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 /* Internal header file for autofs */
12 #include <linux/auto_fs.h>
13 #include <linux/auto_dev-ioctl.h>
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/time.h>
18 #include <linux/string.h>
19 #include <linux/wait.h>
20 #include <linux/sched.h>
21 #include <linux/mount.h>
22 #include <linux/namei.h>
23 #include <linux/uaccess.h>
24 #include <linux/mutex.h>
25 #include <linux/spinlock.h>
26 #include <linux/list.h>
27 #include <linux/completion.h>
28 #include <linux/file.h>
30 /* This is the range of ioctl() numbers we claim as ours */
31 #define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
32 #define AUTOFS_IOC_COUNT 32
34 #define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
35 #define AUTOFS_DEV_IOCTL_IOC_COUNT \
36 (AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD - AUTOFS_DEV_IOCTL_VERSION_CMD)
41 #define pr_fmt(fmt) KBUILD_MODNAME ":pid:%d:%s: " fmt, current->pid, __func__
44 * Unified info structure. This is pointed to by both the dentry and
45 * inode structures. Each file in the filesystem has an instance of this
46 * structure. It holds a reference to the dentry, so dentries are never
47 * flushed while the file exists. All name lookups are dealt with at the
48 * dentry level, although the filesystem can interfere in the validation
49 * process. Readdir is implemented by traversing the dentry lists.
52 struct dentry
*dentry
;
57 struct completion expire_complete
;
59 struct list_head active
;
62 struct list_head expiring
;
64 struct autofs_sb_info
*sbi
;
65 unsigned long last_used
;
72 #define AUTOFS_INF_EXPIRING (1<<0) /* dentry in the process of expiring */
73 #define AUTOFS_INF_WANT_EXPIRE (1<<1) /* the dentry is being considered
74 * for expiry, so RCU_walk is
75 * not permitted. If it progresses to
76 * actual expiry attempt, the flag is
77 * not cleared when EXPIRING is set -
78 * in that case it gets cleared only
79 * when it comes to clearing EXPIRING.
81 #define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
83 struct autofs_wait_queue
{
84 wait_queue_head_t queue
;
85 struct autofs_wait_queue
*next
;
86 autofs_wqt_t wait_queue_token
;
87 /* We use the following to see what we are waiting for */
95 /* This is for status reporting upon return */
97 unsigned int wait_ctr
;
100 #define AUTOFS_SBI_MAGIC 0x6d4a556d
102 struct autofs_sb_info
{
112 unsigned long exp_timeout
;
114 struct super_block
*sb
;
115 struct mutex wq_mutex
;
116 struct mutex pipe_mutex
;
118 struct autofs_wait_queue
*queues
; /* Wait queue pointer */
119 spinlock_t lookup_lock
;
120 struct list_head active_list
;
121 struct list_head expiring_list
;
125 static inline struct autofs_sb_info
*autofs_sbi(struct super_block
*sb
)
127 return (struct autofs_sb_info
*)(sb
->s_fs_info
);
130 static inline struct autofs_info
*autofs_dentry_ino(struct dentry
*dentry
)
132 return (struct autofs_info
*)(dentry
->d_fsdata
);
135 /* autofs_oz_mode(): do we see the man behind the curtain? (The
136 * processes which do manipulations for us in user space sees the raw
137 * filesystem without "magic".)
139 static inline int autofs_oz_mode(struct autofs_sb_info
*sbi
)
141 return sbi
->catatonic
|| task_pgrp(current
) == sbi
->oz_pgrp
;
144 struct inode
*autofs_get_inode(struct super_block
*, umode_t
);
145 void autofs_free_ino(struct autofs_info
*);
148 int is_autofs_dentry(struct dentry
*);
149 int autofs_expire_wait(const struct path
*path
, int rcu_walk
);
150 int autofs_expire_run(struct super_block
*, struct vfsmount
*,
151 struct autofs_sb_info
*,
152 struct autofs_packet_expire __user
*);
153 int autofs_do_expire_multi(struct super_block
*sb
, struct vfsmount
*mnt
,
154 struct autofs_sb_info
*sbi
, int when
);
155 int autofs_expire_multi(struct super_block
*, struct vfsmount
*,
156 struct autofs_sb_info
*, int __user
*);
157 struct dentry
*autofs_expire_direct(struct super_block
*sb
,
158 struct vfsmount
*mnt
,
159 struct autofs_sb_info
*sbi
, int how
);
160 struct dentry
*autofs_expire_indirect(struct super_block
*sb
,
161 struct vfsmount
*mnt
,
162 struct autofs_sb_info
*sbi
, int how
);
164 /* Device node initialization */
166 int autofs_dev_ioctl_init(void);
167 void autofs_dev_ioctl_exit(void);
169 /* Operations structures */
171 extern const struct inode_operations autofs_symlink_inode_operations
;
172 extern const struct inode_operations autofs_dir_inode_operations
;
173 extern const struct file_operations autofs_dir_operations
;
174 extern const struct file_operations autofs_root_operations
;
175 extern const struct dentry_operations autofs_dentry_operations
;
177 /* VFS automount flags management functions */
178 static inline void __managed_dentry_set_managed(struct dentry
*dentry
)
180 dentry
->d_flags
|= (DCACHE_NEED_AUTOMOUNT
|DCACHE_MANAGE_TRANSIT
);
183 static inline void managed_dentry_set_managed(struct dentry
*dentry
)
185 spin_lock(&dentry
->d_lock
);
186 __managed_dentry_set_managed(dentry
);
187 spin_unlock(&dentry
->d_lock
);
190 static inline void __managed_dentry_clear_managed(struct dentry
*dentry
)
192 dentry
->d_flags
&= ~(DCACHE_NEED_AUTOMOUNT
|DCACHE_MANAGE_TRANSIT
);
195 static inline void managed_dentry_clear_managed(struct dentry
*dentry
)
197 spin_lock(&dentry
->d_lock
);
198 __managed_dentry_clear_managed(dentry
);
199 spin_unlock(&dentry
->d_lock
);
202 /* Initializing function */
204 int autofs_fill_super(struct super_block
*, void *, int);
205 struct autofs_info
*autofs_new_ino(struct autofs_sb_info
*);
206 void autofs_clean_ino(struct autofs_info
*);
208 static inline int autofs_prepare_pipe(struct file
*pipe
)
210 if (!(pipe
->f_mode
& FMODE_CAN_WRITE
))
212 if (!S_ISFIFO(file_inode(pipe
)->i_mode
))
214 /* We want a packet pipe */
215 pipe
->f_flags
|= O_DIRECT
;
219 /* Queue management functions */
221 int autofs_wait(struct autofs_sb_info
*,
222 const struct path
*, enum autofs_notify
);
223 int autofs_wait_release(struct autofs_sb_info
*, autofs_wqt_t
, int);
224 void autofs_catatonic_mode(struct autofs_sb_info
*);
226 static inline u32
autofs_get_dev(struct autofs_sb_info
*sbi
)
228 return new_encode_dev(sbi
->sb
->s_dev
);
231 static inline u64
autofs_get_ino(struct autofs_sb_info
*sbi
)
233 return d_inode(sbi
->sb
->s_root
)->i_ino
;
236 static inline void __autofs_add_expiring(struct dentry
*dentry
)
238 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
239 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
242 if (list_empty(&ino
->expiring
))
243 list_add(&ino
->expiring
, &sbi
->expiring_list
);
247 static inline void autofs_add_expiring(struct dentry
*dentry
)
249 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
250 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
253 spin_lock(&sbi
->lookup_lock
);
254 if (list_empty(&ino
->expiring
))
255 list_add(&ino
->expiring
, &sbi
->expiring_list
);
256 spin_unlock(&sbi
->lookup_lock
);
260 static inline void autofs_del_expiring(struct dentry
*dentry
)
262 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
263 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
266 spin_lock(&sbi
->lookup_lock
);
267 if (!list_empty(&ino
->expiring
))
268 list_del_init(&ino
->expiring
);
269 spin_unlock(&sbi
->lookup_lock
);
273 void autofs_kill_sb(struct super_block
*);