1 /* -*- c -*- ------------------------------------------------------------- *
2 *
3 * linux/fs/autofs/autofs_i.h
4 *
5 * Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
6 * Copyright 2005-2006 Ian Kent <raven@themaw.net>
7 *
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.
11 *
12 * ----------------------------------------------------------------------- */
13
14 /* Internal header file for autofs */
15
16 #include <linux/auto_fs4.h>
17 #include <linux/auto_dev-ioctl.h>
18 #include <linux/mutex.h>
19 #include <linux/spinlock.h>
20 #include <linux/list.h>
21
22 /* This is the range of ioctl() numbers we claim as ours */
23 #define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
24 #define AUTOFS_IOC_COUNT 32
25
26 #define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
27 #define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11)
28
29 #include <linux/kernel.h>
30 #include <linux/slab.h>
31 #include <linux/time.h>
32 #include <linux/string.h>
33 #include <linux/wait.h>
34 #include <linux/sched.h>
35 #include <linux/mount.h>
36 #include <linux/namei.h>
37 #include <asm/current.h>
38 #include <asm/uaccess.h>
39
40 /* #define DEBUG */
41
42 #define DPRINTK(fmt, ...) \
43 pr_debug("pid %d: %s: " fmt "\n", \
44 current->pid, __func__, ##__VA_ARGS__)
45
46 #define AUTOFS_WARN(fmt, ...) \
47 printk(KERN_WARNING "pid %d: %s: " fmt "\n", \
48 current->pid, __func__, ##__VA_ARGS__)
49
50 #define AUTOFS_ERROR(fmt, ...) \
51 printk(KERN_ERR "pid %d: %s: " fmt "\n", \
52 current->pid, __func__, ##__VA_ARGS__)
53
54 /* Unified info structure. This is pointed to by both the dentry and
55 inode structures. Each file in the filesystem has an instance of this
56 structure. It holds a reference to the dentry, so dentries are never
57 flushed while the file exists. All name lookups are dealt with at the
58 dentry level, although the filesystem can interfere in the validation
59 process. Readdir is implemented by traversing the dentry lists. */
60 struct autofs_info {
61 struct dentry *dentry;
62 struct inode *inode;
63
64 int flags;
65
66 struct completion expire_complete;
67
68 struct list_head active;
69 int active_count;
70
71 struct list_head expiring;
72
73 struct autofs_sb_info *sbi;
74 unsigned long last_used;
75 atomic_t count;
76
77 kuid_t uid;
78 kgid_t gid;
79 };
80
81 #define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */
82 #define AUTOFS_INF_NO_RCU (1<<1) /* the dentry is being considered
83 * for expiry, so RCU_walk is
84 * not permitted
85 */
86 #define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
87
88 struct autofs_wait_queue {
89 wait_queue_head_t queue;
90 struct autofs_wait_queue *next;
91 autofs_wqt_t wait_queue_token;
92 /* We use the following to see what we are waiting for */
93 struct qstr name;
94 u32 dev;
95 u64 ino;
96 kuid_t uid;
97 kgid_t gid;
98 pid_t pid;
99 pid_t tgid;
100 /* This is for status reporting upon return */
101 int status;
102 unsigned int wait_ctr;
103 };
104
105 #define AUTOFS_SBI_MAGIC 0x6d4a556d
106
107 struct autofs_sb_info {
108 u32 magic;
109 int pipefd;
110 struct file *pipe;
111 struct pid *oz_pgrp;
112 int catatonic;
113 int version;
114 int sub_version;
115 int min_proto;
116 int max_proto;
117 unsigned long exp_timeout;
118 unsigned int type;
119 int reghost_enabled;
120 int needs_reghost;
121 struct super_block *sb;
122 struct mutex wq_mutex;
123 struct mutex pipe_mutex;
124 spinlock_t fs_lock;
125 struct autofs_wait_queue *queues; /* Wait queue pointer */
126 spinlock_t lookup_lock;
127 struct list_head active_list;
128 struct list_head expiring_list;
129 struct rcu_head rcu;
130 };
131
autofs4_sbi(struct super_block * sb)132 static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
133 {
134 return (struct autofs_sb_info *)(sb->s_fs_info);
135 }
136
autofs4_dentry_ino(struct dentry * dentry)137 static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)
138 {
139 return (struct autofs_info *)(dentry->d_fsdata);
140 }
141
142 /* autofs4_oz_mode(): do we see the man behind the curtain? (The
143 processes which do manipulations for us in user space sees the raw
144 filesystem without "magic".) */
145
autofs4_oz_mode(struct autofs_sb_info * sbi)146 static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
147 return sbi->catatonic || task_pgrp(current) == sbi->oz_pgrp;
148 }
149
150 struct inode *autofs4_get_inode(struct super_block *, umode_t);
151 void autofs4_free_ino(struct autofs_info *);
152
153 /* Expiration */
154 int is_autofs4_dentry(struct dentry *);
155 int autofs4_expire_wait(struct dentry *dentry, int rcu_walk);
156 int autofs4_expire_run(struct super_block *, struct vfsmount *,
157 struct autofs_sb_info *,
158 struct autofs_packet_expire __user *);
159 int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
160 struct autofs_sb_info *sbi, int when);
161 int autofs4_expire_multi(struct super_block *, struct vfsmount *,
162 struct autofs_sb_info *, int __user *);
163 struct dentry *autofs4_expire_direct(struct super_block *sb,
164 struct vfsmount *mnt,
165 struct autofs_sb_info *sbi, int how);
166 struct dentry *autofs4_expire_indirect(struct super_block *sb,
167 struct vfsmount *mnt,
168 struct autofs_sb_info *sbi, int how);
169
170 /* Device node initialization */
171
172 int autofs_dev_ioctl_init(void);
173 void autofs_dev_ioctl_exit(void);
174
175 /* Operations structures */
176
177 extern const struct inode_operations autofs4_symlink_inode_operations;
178 extern const struct inode_operations autofs4_dir_inode_operations;
179 extern const struct file_operations autofs4_dir_operations;
180 extern const struct file_operations autofs4_root_operations;
181 extern const struct dentry_operations autofs4_dentry_operations;
182
183 /* VFS automount flags management functions */
__managed_dentry_set_managed(struct dentry * dentry)184 static inline void __managed_dentry_set_managed(struct dentry *dentry)
185 {
186 dentry->d_flags |= (DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
187 }
188
managed_dentry_set_managed(struct dentry * dentry)189 static inline void managed_dentry_set_managed(struct dentry *dentry)
190 {
191 spin_lock(&dentry->d_lock);
192 __managed_dentry_set_managed(dentry);
193 spin_unlock(&dentry->d_lock);
194 }
195
__managed_dentry_clear_managed(struct dentry * dentry)196 static inline void __managed_dentry_clear_managed(struct dentry *dentry)
197 {
198 dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
199 }
200
managed_dentry_clear_managed(struct dentry * dentry)201 static inline void managed_dentry_clear_managed(struct dentry *dentry)
202 {
203 spin_lock(&dentry->d_lock);
204 __managed_dentry_clear_managed(dentry);
205 spin_unlock(&dentry->d_lock);
206 }
207
208 /* Initializing function */
209
210 int autofs4_fill_super(struct super_block *, void *, int);
211 struct autofs_info *autofs4_new_ino(struct autofs_sb_info *);
212 void autofs4_clean_ino(struct autofs_info *);
213
autofs_prepare_pipe(struct file * pipe)214 static inline int autofs_prepare_pipe(struct file *pipe)
215 {
216 if (!(pipe->f_mode & FMODE_CAN_WRITE))
217 return -EINVAL;
218 if (!S_ISFIFO(file_inode(pipe)->i_mode))
219 return -EINVAL;
220 /* We want a packet pipe */
221 pipe->f_flags |= O_DIRECT;
222 return 0;
223 }
224
225 /* Queue management functions */
226
227 int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
228 int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
229 void autofs4_catatonic_mode(struct autofs_sb_info *);
230
autofs4_get_dev(struct autofs_sb_info * sbi)231 static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
232 {
233 return new_encode_dev(sbi->sb->s_dev);
234 }
235
autofs4_get_ino(struct autofs_sb_info * sbi)236 static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
237 {
238 return d_inode(sbi->sb->s_root)->i_ino;
239 }
240
simple_positive(struct dentry * dentry)241 static inline int simple_positive(struct dentry *dentry)
242 {
243 return d_really_is_positive(dentry) && !d_unhashed(dentry);
244 }
245
__autofs4_add_expiring(struct dentry * dentry)246 static inline void __autofs4_add_expiring(struct dentry *dentry)
247 {
248 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
249 struct autofs_info *ino = autofs4_dentry_ino(dentry);
250 if (ino) {
251 if (list_empty(&ino->expiring))
252 list_add(&ino->expiring, &sbi->expiring_list);
253 }
254 return;
255 }
256
autofs4_add_expiring(struct dentry * dentry)257 static inline void autofs4_add_expiring(struct dentry *dentry)
258 {
259 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
260 struct autofs_info *ino = autofs4_dentry_ino(dentry);
261 if (ino) {
262 spin_lock(&sbi->lookup_lock);
263 if (list_empty(&ino->expiring))
264 list_add(&ino->expiring, &sbi->expiring_list);
265 spin_unlock(&sbi->lookup_lock);
266 }
267 return;
268 }
269
autofs4_del_expiring(struct dentry * dentry)270 static inline void autofs4_del_expiring(struct dentry *dentry)
271 {
272 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
273 struct autofs_info *ino = autofs4_dentry_ino(dentry);
274 if (ino) {
275 spin_lock(&sbi->lookup_lock);
276 if (!list_empty(&ino->expiring))
277 list_del_init(&ino->expiring);
278 spin_unlock(&sbi->lookup_lock);
279 }
280 return;
281 }
282
283 extern void autofs4_kill_sb(struct super_block *);
284