Line data Source code
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/list.h>
20 :
21 : /* This is the range of ioctl() numbers we claim as ours */
22 : #define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
23 : #define AUTOFS_IOC_COUNT 32
24 :
25 : #define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
26 : #define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11)
27 :
28 : #include <linux/kernel.h>
29 : #include <linux/slab.h>
30 : #include <linux/time.h>
31 : #include <linux/string.h>
32 : #include <linux/wait.h>
33 : #include <linux/sched.h>
34 : #include <linux/mount.h>
35 : #include <linux/namei.h>
36 : #include <asm/current.h>
37 : #include <asm/uaccess.h>
38 :
39 : /* #define DEBUG */
40 :
41 : #ifdef DEBUG
42 : #define DPRINTK(fmt, args...) \
43 : do { \
44 : printk(KERN_DEBUG "pid %d: %s: " fmt "\n", \
45 : current->pid, __func__, ##args); \
46 : } while (0)
47 : #else
48 : #define DPRINTK(fmt, args...) do {} while (0)
49 : #endif
50 :
51 : #define AUTOFS_WARN(fmt, args...) \
52 : do { \
53 : printk(KERN_WARNING "pid %d: %s: " fmt "\n", \
54 : current->pid, __func__, ##args); \
55 : } while (0)
56 :
57 : #define AUTOFS_ERROR(fmt, args...) \
58 : do { \
59 : printk(KERN_ERR "pid %d: %s: " fmt "\n", \
60 : current->pid, __func__, ##args); \
61 : } while (0)
62 :
63 : struct rehash_entry {
64 : struct task_struct *task;
65 : struct list_head list;
66 : };
67 3 :
68 : /* Unified info structure. This is pointed to by both the dentry and
69 : inode structures. Each file in the filesystem has an instance of this
70 : structure. It holds a reference to the dentry, so dentries are never
71 : flushed while the file exists. All name lookups are dealt with at the
72 : dentry level, although the filesystem can interfere in the validation
73 : process. Readdir is implemented by traversing the dentry lists. */
74 : struct autofs_info {
75 : struct dentry *dentry;
76 : struct inode *inode;
77 :
78 : int flags;
79 :
80 : struct completion expire_complete;
81 :
82 : struct list_head active;
83 : int active_count;
84 : struct list_head rehash_list;
85 :
86 : struct list_head expiring;
87 :
88 : struct autofs_sb_info *sbi;
89 : unsigned long last_used;
90 : atomic_t count;
91 :
92 : uid_t uid;
93 : gid_t gid;
94 :
95 : mode_t mode;
96 : size_t size;
97 :
98 : void (*free)(struct autofs_info *);
99 : union {
100 : const char *symlink;
101 : } u;
102 : };
103 1 :
104 : #define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */
105 : #define AUTOFS_INF_MOUNTPOINT (1<<1) /* mountpoint status for direct expire */
106 : #define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
107 : #define AUTOFS_INF_REHASH (1<<3) /* dentry in transit to ->lookup() */
108 :
109 : struct autofs_wait_queue {
110 : wait_queue_head_t queue;
111 : struct autofs_wait_queue *next;
112 : autofs_wqt_t wait_queue_token;
113 : /* We use the following to see what we are waiting for */
114 : struct qstr name;
115 : u32 dev;
116 : u64 ino;
117 : uid_t uid;
118 : gid_t gid;
119 : pid_t pid;
120 : pid_t tgid;
121 : /* This is for status reporting upon return */
122 : int status;
123 : unsigned int wait_ctr;
124 : };
125 1 :
126 : #define AUTOFS_SBI_MAGIC 0x6d4a556d
127 :
128 : struct autofs_sb_info {
129 : u32 magic;
130 : int pipefd;
131 : struct file *pipe;
132 : pid_t oz_pgrp;
133 : int catatonic;
134 : int version;
135 : int sub_version;
136 : int min_proto;
137 : int max_proto;
138 : unsigned long exp_timeout;
139 : unsigned int type;
140 : int reghost_enabled;
141 : int needs_reghost;
142 : struct super_block *sb;
143 : struct mutex wq_mutex;
144 : spinlock_t fs_lock;
145 : struct autofs_wait_queue *queues; /* Wait queue pointer */
146 : spinlock_t lookup_lock;
147 : struct list_head active_list;
148 : struct list_head expiring_list;
149 : };
150 :
151 : static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
152 : {
153 96 : return (struct autofs_sb_info *)(sb->s_fs_info);
154 : }
155 :
156 : static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)
157 : {
158 266 : return (struct autofs_info *)(dentry->d_fsdata);
159 : }
160 :
161 : /* autofs4_oz_mode(): do we see the man behind the curtain? (The
162 : processes which do manipulations for us in user space sees the raw
163 : filesystem without "magic".) */
164 :
165 : static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
166 130 : return sbi->catatonic || task_pgrp_nr(current) == sbi->oz_pgrp;
167 10 : }
168 10 :
169 10 : /* Does a dentry have some pending activity? */
170 : static inline int autofs4_ispending(struct dentry *dentry)
171 : {
172 4 : struct autofs_info *inf = autofs4_dentry_ino(dentry);
173 1 :
174 2 : if (inf->flags & AUTOFS_INF_PENDING)
175 1 : return 1;
176 :
177 2 : if (inf->flags & AUTOFS_INF_EXPIRING)
178 1 : return 1;
179 :
180 1 : return 0;
181 : }
182 :
183 : static inline void autofs4_copy_atime(struct file *src, struct file *dst)
184 : {
185 : dst->f_path.dentry->d_inode->i_atime =
186 : src->f_path.dentry->d_inode->i_atime;
187 : return;
188 : }
189 :
190 : struct inode *autofs4_get_inode(struct super_block *, struct autofs_info *);
191 : void autofs4_free_ino(struct autofs_info *);
192 :
193 : /* Expiration */
194 : int is_autofs4_dentry(struct dentry *);
195 : int autofs4_expire_wait(struct dentry *dentry);
196 : int autofs4_expire_run(struct super_block *, struct vfsmount *,
197 : struct autofs_sb_info *,
198 : struct autofs_packet_expire __user *);
199 : int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
200 : struct autofs_sb_info *sbi, int when);
201 : int autofs4_expire_multi(struct super_block *, struct vfsmount *,
202 : struct autofs_sb_info *, int __user *);
203 : struct dentry *autofs4_expire_direct(struct super_block *sb,
204 : struct vfsmount *mnt,
205 : struct autofs_sb_info *sbi, int how);
206 : struct dentry *autofs4_expire_indirect(struct super_block *sb,
207 : struct vfsmount *mnt,
208 : struct autofs_sb_info *sbi, int how);
209 :
210 : /* Device node initialization */
211 :
212 : int autofs_dev_ioctl_init(void);
213 : void autofs_dev_ioctl_exit(void);
214 :
215 : /* Operations structures */
216 :
217 1 : extern const struct inode_operations autofs4_symlink_inode_operations;
218 1 : extern const struct inode_operations autofs4_dir_inode_operations;
219 : extern const struct inode_operations autofs4_root_inode_operations;
220 1 : extern const struct inode_operations autofs4_indirect_root_inode_operations;
221 1 : extern const struct inode_operations autofs4_direct_root_inode_operations;
222 1 : extern const struct file_operations autofs4_dir_operations;
223 1 : extern const struct file_operations autofs4_root_operations;
224 :
225 : /* Initializing function */
226 :
227 : int autofs4_fill_super(struct super_block *, void *, int);
228 : struct autofs_info *autofs4_init_ino(struct autofs_info *, struct autofs_sb_info *sbi, mode_t mode);
229 :
230 : /* Queue management functions */
231 :
232 : int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
233 : int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
234 : void autofs4_catatonic_mode(struct autofs_sb_info *);
235 :
236 : static inline int autofs4_follow_mount(struct path *path)
237 : {
238 0 : int res = 0;
239 0 :
240 0 : while (d_mountpoint(path->dentry)) {
241 0 : int followed = follow_down(path);
242 0 : if (!followed)
243 0 : break;
244 0 : res = 1;
245 0 : }
246 0 : return res;
247 : }
248 :
249 : static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
250 : {
251 32 : return new_encode_dev(sbi->sb->s_dev);
252 : }
253 :
254 : static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
255 : {
256 16 : return sbi->sb->s_root->d_inode->i_ino;
257 : }
258 :
259 : static inline int simple_positive(struct dentry *dentry)
260 : {
261 195 : return dentry->d_inode && !d_unhashed(dentry);
262 15 : }
263 :
264 : static inline int __simple_empty(struct dentry *dentry)
265 : {
266 : struct dentry *child;
267 : int ret = 0;
268 :
269 : list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
270 : if (simple_positive(child))
271 : goto out;
272 : ret = 1;
273 : out:
274 : return ret;
275 : }
276 :
277 : static inline void autofs4_add_expiring(struct dentry *dentry)
278 : {
279 20 : struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
280 20 : struct autofs_info *ino = autofs4_dentry_ino(dentry);
281 15 : if (ino) {
282 15 : spin_lock(&sbi->lookup_lock);
283 25 : if (list_empty(&ino->expiring))
284 10 : list_add(&ino->expiring, &sbi->expiring_list);
285 20 : spin_unlock(&sbi->lookup_lock);
286 : }
287 10 : return;
288 : }
289 :
290 : static inline void autofs4_del_expiring(struct dentry *dentry)
291 : {
292 12 : struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
293 12 : struct autofs_info *ino = autofs4_dentry_ino(dentry);
294 9 : if (ino) {
295 9 : spin_lock(&sbi->lookup_lock);
296 15 : if (!list_empty(&ino->expiring))
297 6 : list_del_init(&ino->expiring);
298 12 : spin_unlock(&sbi->lookup_lock);
299 : }
300 6 : return;
301 : }
302 :
303 : void autofs4_dentry_release(struct dentry *);
304 : extern void autofs4_kill_sb(struct super_block *);
|