1 /* -*- c -*- --------------------------------------------------------------- *
3 * linux/fs/autofs/inode.c
5 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
6 * Copyright 2005-2006 Ian Kent <raven@themaw.net>
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
12 * ------------------------------------------------------------------------- */
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/file.h>
17 #include <linux/seq_file.h>
18 #include <linux/pagemap.h>
19 #include <linux/parser.h>
20 #include <linux/bitops.h>
21 #include <linux/smp_lock.h>
23 #include <linux/module.h>
25 static void ino_lnkfree(struct autofs_info *ino)
27 kfree(ino->u.symlink);
28 ino->u.symlink = NULL;
31 struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
32 struct autofs_sb_info *sbi, mode_t mode)
38 ino = kmalloc(sizeof(*ino), GFP_KERNEL);
50 ino->last_used = jiffies;
51 atomic_set(&ino->count, 0);
55 if (reinit && ino->free)
58 memset(&ino->u, 0, sizeof(ino->u));
63 ino->free = ino_lnkfree;
68 void autofs4_free_ino(struct autofs_info *ino)
70 struct autofs_info *p_ino;
73 ino->dentry->d_fsdata = NULL;
74 if (ino->dentry->d_inode) {
75 struct dentry *parent = ino->dentry->d_parent;
76 if (atomic_dec_and_test(&ino->count)) {
77 p_ino = autofs4_dentry_ino(parent);
78 if (p_ino && parent != ino->dentry)
79 atomic_dec(&p_ino->count);
91 * Deal with the infamous "Busy inodes after umount ..." message.
93 * Clean up the dentry tree. This happens with autofs if the user
94 * space program goes away due to a SIGKILL, SIGSEGV etc.
96 static void autofs4_force_release(struct autofs_sb_info *sbi)
98 struct dentry *this_parent = sbi->sb->s_root;
99 struct list_head *next;
101 spin_lock(&dcache_lock);
103 next = this_parent->d_subdirs.next;
105 while (next != &this_parent->d_subdirs) {
106 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
108 /* Negative dentry - don`t care */
109 if (!simple_positive(dentry)) {
114 if (!list_empty(&dentry->d_subdirs)) {
115 this_parent = dentry;
120 spin_unlock(&dcache_lock);
122 DPRINTK("dentry %p %.*s",
123 dentry, (int)dentry->d_name.len, dentry->d_name.name);
126 spin_lock(&dcache_lock);
129 if (this_parent != sbi->sb->s_root) {
130 struct dentry *dentry = this_parent;
132 next = this_parent->d_u.d_child.next;
133 this_parent = this_parent->d_parent;
134 spin_unlock(&dcache_lock);
135 DPRINTK("parent dentry %p %.*s",
136 dentry, (int)dentry->d_name.len, dentry->d_name.name);
138 spin_lock(&dcache_lock);
141 spin_unlock(&dcache_lock);
144 void autofs4_kill_sb(struct super_block *sb)
146 struct autofs_sb_info *sbi = autofs4_sbi(sb);
148 sb->s_fs_info = NULL;
150 if ( !sbi->catatonic )
151 autofs4_catatonic_mode(sbi); /* Free wait queues, close pipe */
153 /* Clean up and release dangling references */
154 autofs4_force_release(sbi);
158 DPRINTK("shutting down");
162 static int autofs4_show_options(struct seq_file *m, struct vfsmount *mnt)
164 struct autofs_sb_info *sbi = autofs4_sbi(mnt->mnt_sb);
169 seq_printf(m, ",fd=%d", sbi->pipefd);
170 seq_printf(m, ",pgrp=%d", sbi->oz_pgrp);
171 seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
172 seq_printf(m, ",minproto=%d", sbi->min_proto);
173 seq_printf(m, ",maxproto=%d", sbi->max_proto);
175 if (sbi->type & AUTOFS_TYPE_OFFSET)
176 seq_printf(m, ",offset");
177 else if (sbi->type & AUTOFS_TYPE_DIRECT)
178 seq_printf(m, ",direct");
180 seq_printf(m, ",indirect");
185 static struct super_operations autofs4_sops = {
186 .statfs = simple_statfs,
187 .show_options = autofs4_show_options,
190 enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto,
191 Opt_indirect, Opt_direct, Opt_offset};
193 static match_table_t tokens = {
197 {Opt_pgrp, "pgrp=%u"},
198 {Opt_minproto, "minproto=%u"},
199 {Opt_maxproto, "maxproto=%u"},
200 {Opt_indirect, "indirect"},
201 {Opt_direct, "direct"},
202 {Opt_offset, "offset"},
206 static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
207 pid_t *pgrp, unsigned int *type,
208 int *minproto, int *maxproto)
211 substring_t args[MAX_OPT_ARGS];
216 *pgrp = process_group(current);
218 *minproto = AUTOFS_MIN_PROTO_VERSION;
219 *maxproto = AUTOFS_MAX_PROTO_VERSION;
226 while ((p = strsep(&options, ",")) != NULL) {
231 token = match_token(p, tokens, args);
234 if (match_int(args, pipefd))
238 if (match_int(args, &option))
243 if (match_int(args, &option))
248 if (match_int(args, &option))
253 if (match_int(args, &option))
258 if (match_int(args, &option))
263 *type = AUTOFS_TYPE_INDIRECT;
266 *type = AUTOFS_TYPE_DIRECT;
269 *type = AUTOFS_TYPE_DIRECT | AUTOFS_TYPE_OFFSET;
275 return (*pipefd < 0);
278 static struct autofs_info *autofs4_mkroot(struct autofs_sb_info *sbi)
280 struct autofs_info *ino;
282 ino = autofs4_init_ino(NULL, sbi, S_IFDIR | 0755);
289 static struct dentry_operations autofs4_sb_dentry_operations = {
290 .d_release = autofs4_dentry_release,
293 int autofs4_fill_super(struct super_block *s, void *data, int silent)
295 struct inode * root_inode;
296 struct dentry * root;
299 struct autofs_sb_info *sbi;
300 struct autofs_info *ino;
302 sbi = (struct autofs_sb_info *) kmalloc(sizeof(*sbi), GFP_KERNEL);
305 DPRINTK("starting up, sbi = %p",sbi);
307 memset(sbi, 0, sizeof(*sbi));
310 sbi->magic = AUTOFS_SBI_MAGIC;
313 sbi->exp_timeout = 0;
314 sbi->oz_pgrp = process_group(current);
317 sbi->sub_version = 0;
321 mutex_init(&sbi->wq_mutex);
322 spin_lock_init(&sbi->fs_lock);
324 s->s_blocksize = 1024;
325 s->s_blocksize_bits = 10;
326 s->s_magic = AUTOFS_SUPER_MAGIC;
327 s->s_op = &autofs4_sops;
331 * Get the root inode and dentry, but defer checking for errors.
333 ino = autofs4_mkroot(sbi);
336 root_inode = autofs4_get_inode(s, ino);
340 root = d_alloc_root(root_inode);
345 root->d_op = &autofs4_sb_dentry_operations;
346 root->d_fsdata = ino;
348 /* Can this call block? */
349 if (parse_options(data, &pipefd,
350 &root_inode->i_uid, &root_inode->i_gid,
351 &sbi->oz_pgrp, &sbi->type,
352 &sbi->min_proto, &sbi->max_proto)) {
353 printk("autofs: called with bogus options\n");
357 root_inode->i_fop = &autofs4_root_operations;
358 root_inode->i_op = sbi->type & AUTOFS_TYPE_DIRECT ?
359 &autofs4_direct_root_inode_operations :
360 &autofs4_indirect_root_inode_operations;
362 /* Couldn't this be tested earlier? */
363 if (sbi->max_proto < AUTOFS_MIN_PROTO_VERSION ||
364 sbi->min_proto > AUTOFS_MAX_PROTO_VERSION) {
365 printk("autofs: kernel does not match daemon version "
366 "daemon (%d, %d) kernel (%d, %d)\n",
367 sbi->min_proto, sbi->max_proto,
368 AUTOFS_MIN_PROTO_VERSION, AUTOFS_MAX_PROTO_VERSION);
372 /* Establish highest kernel protocol version */
373 if (sbi->max_proto > AUTOFS_MAX_PROTO_VERSION)
374 sbi->version = AUTOFS_MAX_PROTO_VERSION;
376 sbi->version = sbi->max_proto;
377 sbi->sub_version = AUTOFS_PROTO_SUBVERSION;
379 DPRINTK("pipe fd = %d, pgrp = %u", pipefd, sbi->oz_pgrp);
383 printk("autofs: could not open pipe file descriptor\n");
386 if ( !pipe->f_op || !pipe->f_op->write )
389 sbi->pipefd = pipefd;
392 * Success! Install the root dentry now to indicate completion.
398 * Failure ... clean up.
401 printk("autofs: pipe file descriptor does not contain proper ops\n");
408 printk("autofs: get root dentry failed\n");
418 struct inode *autofs4_get_inode(struct super_block *sb,
419 struct autofs_info *inf)
421 struct inode *inode = new_inode(sb);
427 inode->i_mode = inf->mode;
429 inode->i_uid = sb->s_root->d_inode->i_uid;
430 inode->i_gid = sb->s_root->d_inode->i_gid;
436 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
438 if (S_ISDIR(inf->mode)) {
440 inode->i_op = &autofs4_dir_inode_operations;
441 inode->i_fop = &autofs4_dir_operations;
442 } else if (S_ISLNK(inf->mode)) {
443 inode->i_size = inf->size;
444 inode->i_op = &autofs4_symlink_inode_operations;