Merge branch 'master' of /usr/src/ntfs-2.6/
[linux-2.6] / fs / autofs4 / inode.c
1 /* -*- c -*- --------------------------------------------------------------- *
2  *
3  * linux/fs/autofs/inode.c
4  *
5  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
6  *
7  * This file is part of the Linux kernel and is made available under
8  * the terms of the GNU General Public License, version 2, or at your
9  * option, any later version, incorporated herein by reference.
10  *
11  * ------------------------------------------------------------------------- */
12
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/file.h>
16 #include <linux/pagemap.h>
17 #include <linux/parser.h>
18 #include <linux/bitops.h>
19 #include <linux/smp_lock.h>
20 #include "autofs_i.h"
21 #include <linux/module.h>
22
23 static void ino_lnkfree(struct autofs_info *ino)
24 {
25         kfree(ino->u.symlink);
26         ino->u.symlink = NULL;
27 }
28
29 struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
30                                      struct autofs_sb_info *sbi, mode_t mode)
31 {
32         int reinit = 1;
33
34         if (ino == NULL) {
35                 reinit = 0;
36                 ino = kmalloc(sizeof(*ino), GFP_KERNEL);
37         }
38
39         if (ino == NULL)
40                 return NULL;
41
42         ino->flags = 0;
43         ino->mode = mode;
44         ino->inode = NULL;
45         ino->dentry = NULL;
46         ino->size = 0;
47
48         ino->last_used = jiffies;
49
50         ino->sbi = sbi;
51
52         if (reinit && ino->free)
53                 (ino->free)(ino);
54
55         memset(&ino->u, 0, sizeof(ino->u));
56
57         ino->free = NULL;
58
59         if (S_ISLNK(mode))
60                 ino->free = ino_lnkfree;
61
62         return ino;
63 }
64
65 void autofs4_free_ino(struct autofs_info *ino)
66 {
67         if (ino->dentry) {
68                 ino->dentry->d_fsdata = NULL;
69                 if (ino->dentry->d_inode)
70                         dput(ino->dentry);
71                 ino->dentry = NULL;
72         }
73         if (ino->free)
74                 (ino->free)(ino);
75         kfree(ino);
76 }
77
78 /*
79  * Deal with the infamous "Busy inodes after umount ..." message.
80  *
81  * Clean up the dentry tree. This happens with autofs if the user
82  * space program goes away due to a SIGKILL, SIGSEGV etc.
83  */
84 static void autofs4_force_release(struct autofs_sb_info *sbi)
85 {
86         struct dentry *this_parent = sbi->root;
87         struct list_head *next;
88
89         spin_lock(&dcache_lock);
90 repeat:
91         next = this_parent->d_subdirs.next;
92 resume:
93         while (next != &this_parent->d_subdirs) {
94                 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
95
96                 /* Negative dentry - don`t care */
97                 if (!simple_positive(dentry)) {
98                         next = next->next;
99                         continue;
100                 }
101
102                 if (!list_empty(&dentry->d_subdirs)) {
103                         this_parent = dentry;
104                         goto repeat;
105                 }
106
107                 next = next->next;
108                 spin_unlock(&dcache_lock);
109
110                 DPRINTK("dentry %p %.*s",
111                         dentry, (int)dentry->d_name.len, dentry->d_name.name);
112
113                 dput(dentry);
114                 spin_lock(&dcache_lock);
115         }
116
117         if (this_parent != sbi->root) {
118                 struct dentry *dentry = this_parent;
119
120                 next = this_parent->d_u.d_child.next;
121                 this_parent = this_parent->d_parent;
122                 spin_unlock(&dcache_lock);
123                 DPRINTK("parent dentry %p %.*s",
124                         dentry, (int)dentry->d_name.len, dentry->d_name.name);
125                 dput(dentry);
126                 spin_lock(&dcache_lock);
127                 goto resume;
128         }
129         spin_unlock(&dcache_lock);
130
131         dput(sbi->root);
132         sbi->root = NULL;
133         shrink_dcache_sb(sbi->sb);
134
135         return;
136 }
137
138 static void autofs4_put_super(struct super_block *sb)
139 {
140         struct autofs_sb_info *sbi = autofs4_sbi(sb);
141
142         sb->s_fs_info = NULL;
143
144         if ( !sbi->catatonic )
145                 autofs4_catatonic_mode(sbi); /* Free wait queues, close pipe */
146
147         /* Clean up and release dangling references */
148         if (sbi)
149                 autofs4_force_release(sbi);
150
151         kfree(sbi);
152
153         DPRINTK("shutting down");
154 }
155
156 static struct super_operations autofs4_sops = {
157         .put_super      = autofs4_put_super,
158         .statfs         = simple_statfs,
159 };
160
161 enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto};
162
163 static match_table_t tokens = {
164         {Opt_fd, "fd=%u"},
165         {Opt_uid, "uid=%u"},
166         {Opt_gid, "gid=%u"},
167         {Opt_pgrp, "pgrp=%u"},
168         {Opt_minproto, "minproto=%u"},
169         {Opt_maxproto, "maxproto=%u"},
170         {Opt_err, NULL}
171 };
172
173 static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
174                          pid_t *pgrp, int *minproto, int *maxproto)
175 {
176         char *p;
177         substring_t args[MAX_OPT_ARGS];
178         int option;
179
180         *uid = current->uid;
181         *gid = current->gid;
182         *pgrp = process_group(current);
183
184         *minproto = AUTOFS_MIN_PROTO_VERSION;
185         *maxproto = AUTOFS_MAX_PROTO_VERSION;
186
187         *pipefd = -1;
188
189         if (!options)
190                 return 1;
191
192         while ((p = strsep(&options, ",")) != NULL) {
193                 int token;
194                 if (!*p)
195                         continue;
196
197                 token = match_token(p, tokens, args);
198                 switch (token) {
199                 case Opt_fd:
200                         if (match_int(args, pipefd))
201                                 return 1;
202                         break;
203                 case Opt_uid:
204                         if (match_int(args, &option))
205                                 return 1;
206                         *uid = option;
207                         break;
208                 case Opt_gid:
209                         if (match_int(args, &option))
210                                 return 1;
211                         *gid = option;
212                         break;
213                 case Opt_pgrp:
214                         if (match_int(args, &option))
215                                 return 1;
216                         *pgrp = option;
217                         break;
218                 case Opt_minproto:
219                         if (match_int(args, &option))
220                                 return 1;
221                         *minproto = option;
222                         break;
223                 case Opt_maxproto:
224                         if (match_int(args, &option))
225                                 return 1;
226                         *maxproto = option;
227                         break;
228                 default:
229                         return 1;
230                 }
231         }
232         return (*pipefd < 0);
233 }
234
235 static struct autofs_info *autofs4_mkroot(struct autofs_sb_info *sbi)
236 {
237         struct autofs_info *ino;
238
239         ino = autofs4_init_ino(NULL, sbi, S_IFDIR | 0755);
240         if (!ino)
241                 return NULL;
242
243         return ino;
244 }
245
246 int autofs4_fill_super(struct super_block *s, void *data, int silent)
247 {
248         struct inode * root_inode;
249         struct dentry * root;
250         struct file * pipe;
251         int pipefd;
252         struct autofs_sb_info *sbi;
253         struct autofs_info *ino;
254         int minproto, maxproto;
255
256         sbi = (struct autofs_sb_info *) kmalloc(sizeof(*sbi), GFP_KERNEL);
257         if ( !sbi )
258                 goto fail_unlock;
259         DPRINTK("starting up, sbi = %p",sbi);
260
261         memset(sbi, 0, sizeof(*sbi));
262
263         s->s_fs_info = sbi;
264         sbi->magic = AUTOFS_SBI_MAGIC;
265         sbi->root = NULL;
266         sbi->catatonic = 0;
267         sbi->exp_timeout = 0;
268         sbi->oz_pgrp = process_group(current);
269         sbi->sb = s;
270         sbi->version = 0;
271         sbi->sub_version = 0;
272         init_MUTEX(&sbi->wq_sem);
273         spin_lock_init(&sbi->fs_lock);
274         sbi->queues = NULL;
275         s->s_blocksize = 1024;
276         s->s_blocksize_bits = 10;
277         s->s_magic = AUTOFS_SUPER_MAGIC;
278         s->s_op = &autofs4_sops;
279         s->s_time_gran = 1;
280
281         /*
282          * Get the root inode and dentry, but defer checking for errors.
283          */
284         ino = autofs4_mkroot(sbi);
285         if (!ino)
286                 goto fail_free;
287         root_inode = autofs4_get_inode(s, ino);
288         kfree(ino);
289         if (!root_inode)
290                 goto fail_free;
291
292         root_inode->i_op = &autofs4_root_inode_operations;
293         root_inode->i_fop = &autofs4_root_operations;
294         root = d_alloc_root(root_inode);
295         pipe = NULL;
296
297         if (!root)
298                 goto fail_iput;
299
300         /* Can this call block? */
301         if (parse_options(data, &pipefd,
302                           &root_inode->i_uid, &root_inode->i_gid,
303                           &sbi->oz_pgrp,
304                           &minproto, &maxproto)) {
305                 printk("autofs: called with bogus options\n");
306                 goto fail_dput;
307         }
308
309         /* Couldn't this be tested earlier? */
310         if (maxproto < AUTOFS_MIN_PROTO_VERSION ||
311             minproto > AUTOFS_MAX_PROTO_VERSION) {
312                 printk("autofs: kernel does not match daemon version "
313                        "daemon (%d, %d) kernel (%d, %d)\n",
314                         minproto, maxproto,
315                         AUTOFS_MIN_PROTO_VERSION, AUTOFS_MAX_PROTO_VERSION);
316                 goto fail_dput;
317         }
318
319         sbi->version = maxproto > AUTOFS_MAX_PROTO_VERSION ? AUTOFS_MAX_PROTO_VERSION : maxproto;
320         sbi->sub_version = AUTOFS_PROTO_SUBVERSION;
321
322         DPRINTK("pipe fd = %d, pgrp = %u", pipefd, sbi->oz_pgrp);
323         pipe = fget(pipefd);
324         
325         if ( !pipe ) {
326                 printk("autofs: could not open pipe file descriptor\n");
327                 goto fail_dput;
328         }
329         if ( !pipe->f_op || !pipe->f_op->write )
330                 goto fail_fput;
331         sbi->pipe = pipe;
332
333         /*
334          * Take a reference to the root dentry so we get a chance to
335          * clean up the dentry tree on umount.
336          * See autofs4_force_release.
337          */
338         sbi->root = dget(root);
339
340         /*
341          * Success! Install the root dentry now to indicate completion.
342          */
343         s->s_root = root;
344         return 0;
345         
346         /*
347          * Failure ... clean up.
348          */
349 fail_fput:
350         printk("autofs: pipe file descriptor does not contain proper ops\n");
351         fput(pipe);
352         /* fall through */
353 fail_dput:
354         dput(root);
355         goto fail_free;
356 fail_iput:
357         printk("autofs: get root dentry failed\n");
358         iput(root_inode);
359 fail_free:
360         kfree(sbi);
361 fail_unlock:
362         return -EINVAL;
363 }
364
365 struct inode *autofs4_get_inode(struct super_block *sb,
366                                 struct autofs_info *inf)
367 {
368         struct inode *inode = new_inode(sb);
369
370         if (inode == NULL)
371                 return NULL;
372
373         inf->inode = inode;
374         inode->i_mode = inf->mode;
375         if (sb->s_root) {
376                 inode->i_uid = sb->s_root->d_inode->i_uid;
377                 inode->i_gid = sb->s_root->d_inode->i_gid;
378         } else {
379                 inode->i_uid = 0;
380                 inode->i_gid = 0;
381         }
382         inode->i_blksize = PAGE_CACHE_SIZE;
383         inode->i_blocks = 0;
384         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
385
386         if (S_ISDIR(inf->mode)) {
387                 inode->i_nlink = 2;
388                 inode->i_op = &autofs4_dir_inode_operations;
389                 inode->i_fop = &autofs4_dir_operations;
390         } else if (S_ISLNK(inf->mode)) {
391                 inode->i_size = inf->size;
392                 inode->i_op = &autofs4_symlink_inode_operations;
393         }
394
395         return inode;
396 }