2 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
3 * Copyright 2005-2006 Ian Kent <raven@themaw.net>
5 * This file is part of the Linux kernel and is made available under
6 * the terms of the GNU General Public License, version 2, or at your
7 * option, any later version, incorporated herein by reference.
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/file.h>
13 #include <linux/seq_file.h>
14 #include <linux/pagemap.h>
15 #include <linux/parser.h>
16 #include <linux/bitops.h>
18 #include <linux/module.h>
20 struct autofs_info
*autofs4_new_ino(struct autofs_sb_info
*sbi
)
22 struct autofs_info
*ino
;
24 ino
= kzalloc(sizeof(*ino
), GFP_KERNEL
);
26 INIT_LIST_HEAD(&ino
->active
);
27 INIT_LIST_HEAD(&ino
->expiring
);
28 ino
->last_used
= jiffies
;
34 void autofs4_clean_ino(struct autofs_info
*ino
)
36 ino
->uid
= GLOBAL_ROOT_UID
;
37 ino
->gid
= GLOBAL_ROOT_GID
;
38 ino
->last_used
= jiffies
;
41 void autofs4_free_ino(struct autofs_info
*ino
)
46 void autofs4_kill_sb(struct super_block
*sb
)
48 struct autofs_sb_info
*sbi
= autofs4_sbi(sb
);
51 * In the event of a failure in get_sb_nodev the superblock
52 * info is not present so nothing else has been setup, so
53 * just call kill_anon_super when we are called from
57 /* Free wait queues, close pipe */
58 autofs4_catatonic_mode(sbi
);
59 put_pid(sbi
->oz_pgrp
);
62 pr_debug("shutting down\n");
63 kill_litter_super(sb
);
68 static int autofs4_show_options(struct seq_file
*m
, struct dentry
*root
)
70 struct autofs_sb_info
*sbi
= autofs4_sbi(root
->d_sb
);
71 struct inode
*root_inode
= d_inode(root
->d_sb
->s_root
);
76 seq_printf(m
, ",fd=%d", sbi
->pipefd
);
77 if (!uid_eq(root_inode
->i_uid
, GLOBAL_ROOT_UID
))
78 seq_printf(m
, ",uid=%u",
79 from_kuid_munged(&init_user_ns
, root_inode
->i_uid
));
80 if (!gid_eq(root_inode
->i_gid
, GLOBAL_ROOT_GID
))
81 seq_printf(m
, ",gid=%u",
82 from_kgid_munged(&init_user_ns
, root_inode
->i_gid
));
83 seq_printf(m
, ",pgrp=%d", pid_vnr(sbi
->oz_pgrp
));
84 seq_printf(m
, ",timeout=%lu", sbi
->exp_timeout
/HZ
);
85 seq_printf(m
, ",minproto=%d", sbi
->min_proto
);
86 seq_printf(m
, ",maxproto=%d", sbi
->max_proto
);
88 if (autofs_type_offset(sbi
->type
))
89 seq_printf(m
, ",offset");
90 else if (autofs_type_direct(sbi
->type
))
91 seq_printf(m
, ",direct");
93 seq_printf(m
, ",indirect");
94 #ifdef CONFIG_CHECKPOINT_RESTORE
96 seq_printf(m
, ",pipe_ino=%ld", file_inode(sbi
->pipe
)->i_ino
);
98 seq_printf(m
, ",pipe_ino=-1");
103 static void autofs4_evict_inode(struct inode
*inode
)
106 kfree(inode
->i_private
);
109 static const struct super_operations autofs4_sops
= {
110 .statfs
= simple_statfs
,
111 .show_options
= autofs4_show_options
,
112 .evict_inode
= autofs4_evict_inode
,
115 enum {Opt_err
, Opt_fd
, Opt_uid
, Opt_gid
, Opt_pgrp
, Opt_minproto
, Opt_maxproto
,
116 Opt_indirect
, Opt_direct
, Opt_offset
};
118 static const match_table_t tokens
= {
122 {Opt_pgrp
, "pgrp=%u"},
123 {Opt_minproto
, "minproto=%u"},
124 {Opt_maxproto
, "maxproto=%u"},
125 {Opt_indirect
, "indirect"},
126 {Opt_direct
, "direct"},
127 {Opt_offset
, "offset"},
131 static int parse_options(char *options
, int *pipefd
, kuid_t
*uid
, kgid_t
*gid
,
132 int *pgrp
, bool *pgrp_set
, unsigned int *type
,
133 int *minproto
, int *maxproto
)
136 substring_t args
[MAX_OPT_ARGS
];
139 *uid
= current_uid();
140 *gid
= current_gid();
142 *minproto
= AUTOFS_MIN_PROTO_VERSION
;
143 *maxproto
= AUTOFS_MAX_PROTO_VERSION
;
150 while ((p
= strsep(&options
, ",")) != NULL
) {
156 token
= match_token(p
, tokens
, args
);
159 if (match_int(args
, pipefd
))
163 if (match_int(args
, &option
))
165 *uid
= make_kuid(current_user_ns(), option
);
166 if (!uid_valid(*uid
))
170 if (match_int(args
, &option
))
172 *gid
= make_kgid(current_user_ns(), option
);
173 if (!gid_valid(*gid
))
177 if (match_int(args
, &option
))
183 if (match_int(args
, &option
))
188 if (match_int(args
, &option
))
193 set_autofs_type_indirect(type
);
196 set_autofs_type_direct(type
);
199 set_autofs_type_offset(type
);
205 return (*pipefd
< 0);
208 int autofs4_fill_super(struct super_block
*s
, void *data
, int silent
)
210 struct inode
*root_inode
;
214 struct autofs_sb_info
*sbi
;
215 struct autofs_info
*ino
;
217 bool pgrp_set
= false;
220 sbi
= kzalloc(sizeof(*sbi
), GFP_KERNEL
);
223 pr_debug("starting up, sbi = %p\n", sbi
);
226 sbi
->magic
= AUTOFS_SBI_MAGIC
;
230 sbi
->exp_timeout
= 0;
234 sbi
->sub_version
= 0;
235 set_autofs_type_indirect(&sbi
->type
);
238 mutex_init(&sbi
->wq_mutex
);
239 mutex_init(&sbi
->pipe_mutex
);
240 spin_lock_init(&sbi
->fs_lock
);
242 spin_lock_init(&sbi
->lookup_lock
);
243 INIT_LIST_HEAD(&sbi
->active_list
);
244 INIT_LIST_HEAD(&sbi
->expiring_list
);
245 s
->s_blocksize
= 1024;
246 s
->s_blocksize_bits
= 10;
247 s
->s_magic
= AUTOFS_SUPER_MAGIC
;
248 s
->s_op
= &autofs4_sops
;
249 s
->s_d_op
= &autofs4_dentry_operations
;
253 * Get the root inode and dentry, but defer checking for errors.
255 ino
= autofs4_new_ino(sbi
);
260 root_inode
= autofs4_get_inode(s
, S_IFDIR
| 0755);
261 root
= d_make_root(root_inode
);
268 root
->d_fsdata
= ino
;
270 /* Can this call block? */
271 if (parse_options(data
, &pipefd
, &root_inode
->i_uid
, &root_inode
->i_gid
,
272 &pgrp
, &pgrp_set
, &sbi
->type
, &sbi
->min_proto
,
274 pr_err("called with bogus options\n");
278 /* Test versions first */
279 if (sbi
->max_proto
< AUTOFS_MIN_PROTO_VERSION
||
280 sbi
->min_proto
> AUTOFS_MAX_PROTO_VERSION
) {
281 pr_err("kernel does not match daemon version "
282 "daemon (%d, %d) kernel (%d, %d)\n",
283 sbi
->min_proto
, sbi
->max_proto
,
284 AUTOFS_MIN_PROTO_VERSION
, AUTOFS_MAX_PROTO_VERSION
);
288 /* Establish highest kernel protocol version */
289 if (sbi
->max_proto
> AUTOFS_MAX_PROTO_VERSION
)
290 sbi
->version
= AUTOFS_MAX_PROTO_VERSION
;
292 sbi
->version
= sbi
->max_proto
;
293 sbi
->sub_version
= AUTOFS_PROTO_SUBVERSION
;
296 sbi
->oz_pgrp
= find_get_pid(pgrp
);
298 pr_err("could not find process group %d\n",
303 sbi
->oz_pgrp
= get_task_pid(current
, PIDTYPE_PGID
);
306 if (autofs_type_trigger(sbi
->type
))
307 __managed_dentry_set_managed(root
);
309 root_inode
->i_fop
= &autofs4_root_operations
;
310 root_inode
->i_op
= &autofs4_dir_inode_operations
;
312 pr_debug("pipe fd = %d, pgrp = %u\n", pipefd
, pid_nr(sbi
->oz_pgrp
));
316 pr_err("could not open pipe file descriptor\n");
319 ret
= autofs_prepare_pipe(pipe
);
323 sbi
->pipefd
= pipefd
;
327 * Success! Install the root dentry now to indicate completion.
333 * Failure ... clean up.
336 pr_err("pipe file descriptor does not contain proper ops\n");
339 put_pid(sbi
->oz_pgrp
);
344 autofs4_free_ino(ino
);
351 struct inode
*autofs4_get_inode(struct super_block
*sb
, umode_t mode
)
353 struct inode
*inode
= new_inode(sb
);
358 inode
->i_mode
= mode
;
360 inode
->i_uid
= d_inode(sb
->s_root
)->i_uid
;
361 inode
->i_gid
= d_inode(sb
->s_root
)->i_gid
;
363 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
364 inode
->i_ino
= get_next_ino();
368 inode
->i_op
= &autofs4_dir_inode_operations
;
369 inode
->i_fop
= &autofs4_dir_operations
;
370 } else if (S_ISLNK(mode
)) {
371 inode
->i_op
= &autofs4_symlink_inode_operations
;