nfsd4: make recall callback an asynchronous rpc

[safe/jmp/linux-2.6] / fs / autofs / inode.c

diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c
index d8315e6..e1734f2 100644 (file)
--- a/fs/autofs/inode.c
+++ b/fs/autofs/inode.c
@@ -37,6 +37,8 @@ void autofs_kill_sb(struct super_block *sb)
        if (!sbi->catatonic)
                autofs_catatonic_mode(sbi); /* Free wait queues, close pipe */
 
+       put_pid(sbi->oz_pgrp);
+
        autofs_hash_nuke(sbi);
        for (n = 0; n < AUTOFS_MAX_SYMLINKS; n++) {
                if (test_bit(n, sbi->symlink_bitmap))
@@ -50,16 +52,14 @@ out_kill_sb:
        kill_anon_super(sb);
 }
 
-static void autofs_read_inode(struct inode *inode);
-
 static const struct super_operations autofs_sops = {
-       .read_inode     = autofs_read_inode,
        .statfs         = simple_statfs,
+       .show_options   = generic_show_options,
 };
 
 enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto};
 
-static match_table_t autofs_tokens = {
+static const match_table_t autofs_tokens = {
        {Opt_fd, "fd=%u"},
        {Opt_uid, "uid=%u"},
        {Opt_gid, "gid=%u"},
@@ -76,9 +76,9 @@ static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
        substring_t args[MAX_OPT_ARGS];
        int option;
 
-       *uid = current->uid;
-       *gid = current->gid;
-       *pgrp = process_group(current);
+       *uid = current_uid();
+       *gid = current_gid();
+       *pgrp = task_pgrp_nr(current);
 
        *minproto = *maxproto = AUTOFS_PROTO_VERSION;
 
@@ -139,6 +139,9 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
        int pipefd;
        struct autofs_sb_info *sbi;
        int minproto, maxproto;
+       pid_t pgid;
+
+       save_mount_options(s, data);
 
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
        if (!sbi)
@@ -150,7 +153,6 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
        sbi->pipe = NULL;
        sbi->catatonic = 1;
        sbi->exp_timeout = 0;
-       sbi->oz_pgrp = process_group(current);
        autofs_initialize_hash(&sbi->dirhash);
        sbi->queues = NULL;
        memset(sbi->symlink_bitmap, 0, sizeof(long)*AUTOFS_SYMLINK_BITMAP_LEN);
@@ -162,7 +164,9 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
        s->s_time_gran = 1;
        sbi->sb = s;
 
-       root_inode = iget(s, AUTOFS_ROOT_INO);
+       root_inode = autofs_iget(s, AUTOFS_ROOT_INO);
+       if (IS_ERR(root_inode))
+               goto fail_free;
        root = d_alloc_root(root_inode);
        pipe = NULL;
 
@@ -171,7 +175,7 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
 
        /* Can this call block?  - WTF cares? s is locked. */
        if (parse_options(data, &pipefd, &root_inode->i_uid,
-                               &root_inode->i_gid, &sbi->oz_pgrp, &minproto,
+                               &root_inode->i_gid, &pgid, &minproto,
                                &maxproto)) {
                printk("autofs: called with bogus options\n");
                goto fail_dput;
@@ -184,13 +188,21 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
                goto fail_dput;
        }
 
-       DPRINTK(("autofs: pipe fd = %d, pgrp = %u\n", pipefd, sbi->oz_pgrp));
+       DPRINTK(("autofs: pipe fd = %d, pgrp = %u\n", pipefd, pgid));
+       sbi->oz_pgrp = find_get_pid(pgid);
+
+       if (!sbi->oz_pgrp) {
+               printk("autofs: could not find process group %d\n", pgid);
+               goto fail_dput;
+       }
+
        pipe = fget(pipefd);
        
        if (!pipe) {
                printk("autofs: could not open pipe file descriptor\n");
-               goto fail_dput;
+               goto fail_put_pid;
        }
+
        if (!pipe->f_op || !pipe->f_op->write)
                goto fail_fput;
        sbi->pipe = pipe;
@@ -205,6 +217,8 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
 fail_fput:
        printk("autofs: pipe file descriptor does not contain proper ops\n");
        fput(pipe);
+fail_put_pid:
+       put_pid(sbi->oz_pgrp);
 fail_dput:
        dput(root);
        goto fail_free;
@@ -218,11 +232,17 @@ fail_unlock:
        return -EINVAL;
 }
 
-static void autofs_read_inode(struct inode *inode)
+struct inode *autofs_iget(struct super_block *sb, unsigned long ino)
 {
-       ino_t ino = inode->i_ino;
        unsigned int n;
-       struct autofs_sb_info *sbi = autofs_sbi(inode->i_sb);
+       struct autofs_sb_info *sbi = autofs_sbi(sb);
+       struct inode *inode;
+
+       inode = iget_locked(sb, ino);
+       if (!inode)
+               return ERR_PTR(-ENOMEM);
+       if (!(inode->i_state & I_NEW))
+               return inode;
 
        /* Initialize to the default case (stub directory) */
 
@@ -231,14 +251,12 @@ static void autofs_read_inode(struct inode *inode)
        inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
        inode->i_nlink = 2;
        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-       inode->i_blocks = 0;
 
        if (ino == AUTOFS_ROOT_INO) {
                inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
                inode->i_op = &autofs_root_inode_operations;
                inode->i_fop = &autofs_root_operations;
-               inode->i_uid = inode->i_gid = 0; /* Changed in read_super */
-               return;
+               goto done;
        } 
        
        inode->i_uid = inode->i_sb->s_root->d_inode->i_uid;
@@ -251,7 +269,7 @@ static void autofs_read_inode(struct inode *inode)
                n = ino - AUTOFS_FIRST_SYMLINK;
                if (n >= AUTOFS_MAX_SYMLINKS || !test_bit(n,sbi->symlink_bitmap)) {
                        printk("autofs: Looking for bad symlink inode %u\n", (unsigned int) ino);
-                       return;
+                       goto done;
                }
                
                inode->i_op = &autofs_symlink_inode_operations;
@@ -263,4 +281,8 @@ static void autofs_read_inode(struct inode *inode)
                inode->i_size = sl->len;
                inode->i_nlink = 1;
        }
+
+done:
+       unlock_new_inode(inode);
+       return inode;
 }