1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
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
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
55
56
57
58
59
60struct 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)
82#define AUTOFS_INF_PENDING (1<<2)
83
84struct autofs_wait_queue {
85 wait_queue_head_t queue;
86 struct autofs_wait_queue *next;
87 autofs_wqt_t wait_queue_token;
88
89 struct qstr name;
90 u32 dev;
91 u64 ino;
92 kuid_t uid;
93 kgid_t gid;
94 pid_t pid;
95 pid_t tgid;
96
97 int status;
98 unsigned int wait_ctr;
99};
100
101#define AUTOFS_SBI_MAGIC 0x6d4a556d
102
103struct autofs_sb_info {
104 u32 magic;
105 int pipefd;
106 struct file *pipe;
107 struct pid *oz_pgrp;
108 int catatonic;
109 int version;
110 int sub_version;
111 int min_proto;
112 int max_proto;
113 unsigned long exp_timeout;
114 unsigned int type;
115 int reghost_enabled;
116 int needs_reghost;
117 struct super_block *sb;
118 struct mutex wq_mutex;
119 struct mutex pipe_mutex;
120 spinlock_t fs_lock;
121 struct autofs_wait_queue *queues;
122 spinlock_t lookup_lock;
123 struct list_head active_list;
124 struct list_head expiring_list;
125 struct rcu_head rcu;
126};
127
128static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
129{
130 return (struct autofs_sb_info *)(sb->s_fs_info);
131}
132
133static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)
134{
135 return (struct autofs_info *)(dentry->d_fsdata);
136}
137
138
139
140
141
142static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
143 return sbi->catatonic || task_pgrp(current) == sbi->oz_pgrp;
144}
145
146
147static inline int autofs4_ispending(struct dentry *dentry)
148{
149 struct autofs_info *inf = autofs4_dentry_ino(dentry);
150
151 if (inf->flags & AUTOFS_INF_PENDING)
152 return 1;
153
154 if (inf->flags & AUTOFS_INF_EXPIRING)
155 return 1;
156
157 return 0;
158}
159
160struct inode *autofs4_get_inode(struct super_block *, umode_t);
161void autofs4_free_ino(struct autofs_info *);
162
163
164int is_autofs4_dentry(struct dentry *);
165int autofs4_expire_wait(struct dentry *dentry);
166int autofs4_expire_run(struct super_block *, struct vfsmount *,
167 struct autofs_sb_info *,
168 struct autofs_packet_expire __user *);
169int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
170 struct autofs_sb_info *sbi, int when);
171int autofs4_expire_multi(struct super_block *, struct vfsmount *,
172 struct autofs_sb_info *, int __user *);
173struct dentry *autofs4_expire_direct(struct super_block *sb,
174 struct vfsmount *mnt,
175 struct autofs_sb_info *sbi, int how);
176struct dentry *autofs4_expire_indirect(struct super_block *sb,
177 struct vfsmount *mnt,
178 struct autofs_sb_info *sbi, int how);
179
180
181
182int autofs_dev_ioctl_init(void);
183void autofs_dev_ioctl_exit(void);
184
185
186
187extern const struct inode_operations autofs4_symlink_inode_operations;
188extern const struct inode_operations autofs4_dir_inode_operations;
189extern const struct file_operations autofs4_dir_operations;
190extern const struct file_operations autofs4_root_operations;
191extern const struct dentry_operations autofs4_dentry_operations;
192
193
194
195static inline void __managed_dentry_set_automount(struct dentry *dentry)
196{
197 dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
198}
199
200static inline void managed_dentry_set_automount(struct dentry *dentry)
201{
202 spin_lock(&dentry->d_lock);
203 __managed_dentry_set_automount(dentry);
204 spin_unlock(&dentry->d_lock);
205}
206
207static inline void __managed_dentry_clear_automount(struct dentry *dentry)
208{
209 dentry->d_flags &= ~DCACHE_NEED_AUTOMOUNT;
210}
211
212static inline void managed_dentry_clear_automount(struct dentry *dentry)
213{
214 spin_lock(&dentry->d_lock);
215 __managed_dentry_clear_automount(dentry);
216 spin_unlock(&dentry->d_lock);
217}
218
219static inline void __managed_dentry_set_transit(struct dentry *dentry)
220{
221 dentry->d_flags |= DCACHE_MANAGE_TRANSIT;
222}
223
224static inline void managed_dentry_set_transit(struct dentry *dentry)
225{
226 spin_lock(&dentry->d_lock);
227 __managed_dentry_set_transit(dentry);
228 spin_unlock(&dentry->d_lock);
229}
230
231static inline void __managed_dentry_clear_transit(struct dentry *dentry)
232{
233 dentry->d_flags &= ~DCACHE_MANAGE_TRANSIT;
234}
235
236static inline void managed_dentry_clear_transit(struct dentry *dentry)
237{
238 spin_lock(&dentry->d_lock);
239 __managed_dentry_clear_transit(dentry);
240 spin_unlock(&dentry->d_lock);
241}
242
243static inline void __managed_dentry_set_managed(struct dentry *dentry)
244{
245 dentry->d_flags |= (DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
246}
247
248static inline void managed_dentry_set_managed(struct dentry *dentry)
249{
250 spin_lock(&dentry->d_lock);
251 __managed_dentry_set_managed(dentry);
252 spin_unlock(&dentry->d_lock);
253}
254
255static inline void __managed_dentry_clear_managed(struct dentry *dentry)
256{
257 dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
258}
259
260static inline void managed_dentry_clear_managed(struct dentry *dentry)
261{
262 spin_lock(&dentry->d_lock);
263 __managed_dentry_clear_managed(dentry);
264 spin_unlock(&dentry->d_lock);
265}
266
267
268
269int autofs4_fill_super(struct super_block *, void *, int);
270struct autofs_info *autofs4_new_ino(struct autofs_sb_info *);
271void autofs4_clean_ino(struct autofs_info *);
272
273static inline int autofs_prepare_pipe(struct file *pipe)
274{
275 if (!pipe->f_op->write)
276 return -EINVAL;
277 if (!S_ISFIFO(file_inode(pipe)->i_mode))
278 return -EINVAL;
279
280 pipe->f_flags |= O_DIRECT;
281 return 0;
282}
283
284
285
286int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
287int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
288void autofs4_catatonic_mode(struct autofs_sb_info *);
289
290static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
291{
292 return new_encode_dev(sbi->sb->s_dev);
293}
294
295static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
296{
297 return sbi->sb->s_root->d_inode->i_ino;
298}
299
300static inline int simple_positive(struct dentry *dentry)
301{
302 return dentry->d_inode && !d_unhashed(dentry);
303}
304
305static inline void __autofs4_add_expiring(struct dentry *dentry)
306{
307 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
308 struct autofs_info *ino = autofs4_dentry_ino(dentry);
309 if (ino) {
310 if (list_empty(&ino->expiring))
311 list_add(&ino->expiring, &sbi->expiring_list);
312 }
313 return;
314}
315
316static inline void autofs4_add_expiring(struct dentry *dentry)
317{
318 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
319 struct autofs_info *ino = autofs4_dentry_ino(dentry);
320 if (ino) {
321 spin_lock(&sbi->lookup_lock);
322 if (list_empty(&ino->expiring))
323 list_add(&ino->expiring, &sbi->expiring_list);
324 spin_unlock(&sbi->lookup_lock);
325 }
326 return;
327}
328
329static inline void autofs4_del_expiring(struct dentry *dentry)
330{
331 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
332 struct autofs_info *ino = autofs4_dentry_ino(dentry);
333 if (ino) {
334 spin_lock(&sbi->lookup_lock);
335 if (!list_empty(&ino->expiring))
336 list_del_init(&ino->expiring);
337 spin_unlock(&sbi->lookup_lock);
338 }
339 return;
340}
341
342extern void autofs4_kill_sb(struct super_block *);
343