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/sched/signal.h>
22 #include <linux/mount.h>
23 #include <linux/namei.h>
24 #include <linux/uaccess.h>
25 #include <linux/mutex.h>
26 #include <linux/spinlock.h>
27 #include <linux/list.h>
28 #include <linux/completion.h>
29 #include <linux/file.h>
30 #include <linux/magic.h>
32 /* This is the range of ioctl() numbers we claim as ours */
33 #define AUTOFS_IOC_FIRST AUTOFS_IOC_READY
34 #define AUTOFS_IOC_COUNT 32
36 #define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
37 #define AUTOFS_DEV_IOCTL_IOC_COUNT \
38 (AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD - AUTOFS_DEV_IOCTL_VERSION_CMD)
43 #define pr_fmt(fmt) KBUILD_MODNAME ":pid:%d:%s: " fmt, current->pid, __func__
46 * Unified info structure. This is pointed to by both the dentry and
47 * inode structures. Each file in the filesystem has an instance of this
48 * structure. It holds a reference to the dentry, so dentries are never
49 * flushed while the file exists. All name lookups are dealt with at the
50 * dentry level, although the filesystem can interfere in the validation
51 * process. Readdir is implemented by traversing the dentry lists.
54 struct dentry
*dentry
;
59 struct completion expire_complete
;
61 struct list_head active
;
64 struct list_head expiring
;
66 struct autofs_sb_info
*sbi
;
67 unsigned long last_used
;
74 #define AUTOFS_INF_EXPIRING (1<<0) /* dentry in the process of expiring */
75 #define AUTOFS_INF_WANT_EXPIRE (1<<1) /* the dentry is being considered
76 * for expiry, so RCU_walk is
77 * not permitted. If it progresses to
78 * actual expiry attempt, the flag is
79 * not cleared when EXPIRING is set -
80 * in that case it gets cleared only
81 * when it comes to clearing EXPIRING.
83 #define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
85 struct autofs_wait_queue
{
86 wait_queue_head_t queue
;
87 struct autofs_wait_queue
*next
;
88 autofs_wqt_t wait_queue_token
;
89 /* We use the following to see what we are waiting for */
97 /* This is for status reporting upon return */
99 unsigned int wait_ctr
;
102 #define AUTOFS_SBI_MAGIC 0x6d4a556d
104 struct autofs_sb_info
{
114 unsigned long exp_timeout
;
116 struct super_block
*sb
;
117 struct mutex wq_mutex
;
118 struct mutex pipe_mutex
;
120 struct autofs_wait_queue
*queues
; /* Wait queue pointer */
121 spinlock_t lookup_lock
;
122 struct list_head active_list
;
123 struct list_head expiring_list
;
127 static inline struct autofs_sb_info
*autofs_sbi(struct super_block
*sb
)
129 return sb
->s_magic
!= AUTOFS_SUPER_MAGIC
?
130 NULL
: (struct autofs_sb_info
*)(sb
->s_fs_info
);
133 static inline struct autofs_info
*autofs_dentry_ino(struct dentry
*dentry
)
135 return (struct autofs_info
*)(dentry
->d_fsdata
);
138 /* autofs_oz_mode(): do we see the man behind the curtain? (The
139 * processes which do manipulations for us in user space sees the raw
140 * filesystem without "magic".)
142 static inline int autofs_oz_mode(struct autofs_sb_info
*sbi
)
144 return sbi
->catatonic
|| task_pgrp(current
) == sbi
->oz_pgrp
;
147 struct inode
*autofs_get_inode(struct super_block
*, umode_t
);
148 void autofs_free_ino(struct autofs_info
*);
151 int is_autofs_dentry(struct dentry
*);
152 int autofs_expire_wait(const struct path
*path
, int rcu_walk
);
153 int autofs_expire_run(struct super_block
*, struct vfsmount
*,
154 struct autofs_sb_info
*,
155 struct autofs_packet_expire __user
*);
156 int autofs_do_expire_multi(struct super_block
*sb
, struct vfsmount
*mnt
,
157 struct autofs_sb_info
*sbi
, unsigned int how
);
158 int autofs_expire_multi(struct super_block
*, struct vfsmount
*,
159 struct autofs_sb_info
*, int __user
*);
161 /* Device node initialization */
163 int autofs_dev_ioctl_init(void);
164 void autofs_dev_ioctl_exit(void);
166 /* Operations structures */
168 extern const struct inode_operations autofs_symlink_inode_operations
;
169 extern const struct inode_operations autofs_dir_inode_operations
;
170 extern const struct file_operations autofs_dir_operations
;
171 extern const struct file_operations autofs_root_operations
;
172 extern const struct dentry_operations autofs_dentry_operations
;
174 /* VFS automount flags management functions */
175 static inline void __managed_dentry_set_managed(struct dentry
*dentry
)
177 dentry
->d_flags
|= (DCACHE_NEED_AUTOMOUNT
|DCACHE_MANAGE_TRANSIT
);
180 static inline void managed_dentry_set_managed(struct dentry
*dentry
)
182 spin_lock(&dentry
->d_lock
);
183 __managed_dentry_set_managed(dentry
);
184 spin_unlock(&dentry
->d_lock
);
187 static inline void __managed_dentry_clear_managed(struct dentry
*dentry
)
189 dentry
->d_flags
&= ~(DCACHE_NEED_AUTOMOUNT
|DCACHE_MANAGE_TRANSIT
);
192 static inline void managed_dentry_clear_managed(struct dentry
*dentry
)
194 spin_lock(&dentry
->d_lock
);
195 __managed_dentry_clear_managed(dentry
);
196 spin_unlock(&dentry
->d_lock
);
199 /* Initializing function */
201 int autofs_fill_super(struct super_block
*, void *, int);
202 struct autofs_info
*autofs_new_ino(struct autofs_sb_info
*);
203 void autofs_clean_ino(struct autofs_info
*);
205 static inline int autofs_prepare_pipe(struct file
*pipe
)
207 if (!(pipe
->f_mode
& FMODE_CAN_WRITE
))
209 if (!S_ISFIFO(file_inode(pipe
)->i_mode
))
211 /* We want a packet pipe */
212 pipe
->f_flags
|= O_DIRECT
;
216 /* Queue management functions */
218 int autofs_wait(struct autofs_sb_info
*,
219 const struct path
*, enum autofs_notify
);
220 int autofs_wait_release(struct autofs_sb_info
*, autofs_wqt_t
, int);
221 void autofs_catatonic_mode(struct autofs_sb_info
*);
223 static inline u32
autofs_get_dev(struct autofs_sb_info
*sbi
)
225 return new_encode_dev(sbi
->sb
->s_dev
);
228 static inline u64
autofs_get_ino(struct autofs_sb_info
*sbi
)
230 return d_inode(sbi
->sb
->s_root
)->i_ino
;
233 static inline void __autofs_add_expiring(struct dentry
*dentry
)
235 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
236 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
239 if (list_empty(&ino
->expiring
))
240 list_add(&ino
->expiring
, &sbi
->expiring_list
);
244 static inline void autofs_add_expiring(struct dentry
*dentry
)
246 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
247 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
250 spin_lock(&sbi
->lookup_lock
);
251 if (list_empty(&ino
->expiring
))
252 list_add(&ino
->expiring
, &sbi
->expiring_list
);
253 spin_unlock(&sbi
->lookup_lock
);
257 static inline void autofs_del_expiring(struct dentry
*dentry
)
259 struct autofs_sb_info
*sbi
= autofs_sbi(dentry
->d_sb
);
260 struct autofs_info
*ino
= autofs_dentry_ino(dentry
);
263 spin_lock(&sbi
->lookup_lock
);
264 if (!list_empty(&ino
->expiring
))
265 list_del_init(&ino
->expiring
);
266 spin_unlock(&sbi
->lookup_lock
);
270 void autofs_kill_sb(struct super_block
*);