blob: 8e98cf954babb8944a32fdc58fd3c38760933a5a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* -*- c -*- ------------------------------------------------------------- *
2 *
3 * linux/fs/autofs/autofs_i.h
4 *
5 * Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
Ian Kent34ca9592006-03-27 01:14:54 -08006 * Copyright 2005-2006 Ian Kent <raven@themaw.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
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>
Ian Kent8d7b48e2008-10-15 22:02:54 -070017#include <linux/auto_dev-ioctl.h>
Ingo Molnar1d5599e2006-03-23 03:00:41 -080018#include <linux/mutex.h>
Nick Pigginb5c84bf2011-01-07 17:49:38 +110019#include <linux/spinlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#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
Ian Kent8d7b48e2008-10-15 22:02:54 -070026#define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
27#define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11)
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#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
Linus Torvaldsc3ad9962011-08-08 11:35:17 -070042#define DPRINTK(fmt, ...) \
43 pr_debug("pid %d: %s: " fmt "\n", \
44 current->pid, __func__, ##__VA_ARGS__)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Linus Torvaldsc3ad9962011-08-08 11:35:17 -070046#define AUTOFS_WARN(fmt, ...) \
Ian Kent8d7b48e2008-10-15 22:02:54 -070047 printk(KERN_WARNING "pid %d: %s: " fmt "\n", \
Linus Torvaldsc3ad9962011-08-08 11:35:17 -070048 current->pid, __func__, ##__VA_ARGS__)
Ian Kent8d7b48e2008-10-15 22:02:54 -070049
Linus Torvaldsc3ad9962011-08-08 11:35:17 -070050#define AUTOFS_ERROR(fmt, ...) \
Ian Kent8d7b48e2008-10-15 22:02:54 -070051 printk(KERN_ERR "pid %d: %s: " fmt "\n", \
Linus Torvaldsc3ad9962011-08-08 11:35:17 -070052 current->pid, __func__, ##__VA_ARGS__)
Ian Kent8d7b48e2008-10-15 22:02:54 -070053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054/* 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. */
60struct autofs_info {
61 struct dentry *dentry;
62 struct inode *inode;
63
64 int flags;
65
Ian Kent6e60a9a2008-07-23 21:30:27 -070066 struct completion expire_complete;
67
Ian Kent25767372008-07-23 21:30:12 -070068 struct list_head active;
Ian Kent4f8427d2009-12-15 16:45:42 -080069 int active_count;
70
Ian Kent5f6f4f22008-07-23 21:30:09 -070071 struct list_head expiring;
Ian Kentf50b6f82007-02-20 13:58:10 -080072
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 struct autofs_sb_info *sbi;
74 unsigned long last_used;
Ian Kent1aff3c82006-03-27 01:14:46 -080075 atomic_t count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Eric W. Biederman45634cd2012-02-07 16:18:52 -080077 kuid_t uid;
78 kgid_t gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079};
80
81#define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */
NeilBrown4d885f92014-10-13 15:52:20 -070082#define AUTOFS_INF_NO_RCU (1<<1) /* the dentry is being considered
83 * for expiry, so RCU_walk is
84 * not permitted
85 */
Ian Kentaa952eb2009-12-15 16:45:45 -080086#define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88struct 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 */
Jeff Moyer70b52a02008-07-23 21:30:16 -070093 struct qstr name;
Ian Kent5c0a32f2006-03-27 01:14:55 -080094 u32 dev;
95 u64 ino;
Eric W. Biederman45634cd2012-02-07 16:18:52 -080096 kuid_t uid;
97 kgid_t gid;
Ian Kent5c0a32f2006-03-27 01:14:55 -080098 pid_t pid;
99 pid_t tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 /* This is for status reporting upon return */
101 int status;
Ian Kent296f7bf2008-07-23 21:30:21 -0700102 unsigned int wait_ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103};
104
105#define AUTOFS_SBI_MAGIC 0x6d4a556d
106
107struct autofs_sb_info {
108 u32 magic;
Ian Kentd7c4a5f2006-03-27 01:14:49 -0800109 int pipefd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 struct file *pipe;
Sukadev Bhattiprolu6eaba352014-01-23 15:54:57 -0800111 struct pid *oz_pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 int catatonic;
113 int version;
114 int sub_version;
Ian Kentd7c4a5f2006-03-27 01:14:49 -0800115 int min_proto;
116 int max_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 unsigned long exp_timeout;
Ian Kent34ca9592006-03-27 01:14:54 -0800118 unsigned int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 int reghost_enabled;
120 int needs_reghost;
121 struct super_block *sb;
Ingo Molnar1d5599e2006-03-23 03:00:41 -0800122 struct mutex wq_mutex;
Al Virod668dc52012-01-10 22:35:38 -0500123 struct mutex pipe_mutex;
Ian Kent3a9720c2005-05-01 08:59:17 -0700124 spinlock_t fs_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 struct autofs_wait_queue *queues; /* Wait queue pointer */
Ian Kent5f6f4f22008-07-23 21:30:09 -0700126 spinlock_t lookup_lock;
Ian Kent25767372008-07-23 21:30:12 -0700127 struct list_head active_list;
Ian Kent5f6f4f22008-07-23 21:30:09 -0700128 struct list_head expiring_list;
Al Virobaa40672013-10-03 12:46:44 -0400129 struct rcu_head rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
132static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
133{
134 return (struct autofs_sb_info *)(sb->s_fs_info);
135}
136
137static 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
146static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
Sukadev Bhattiprolu6eaba352014-01-23 15:54:57 -0800147 return sbi->catatonic || task_pgrp(current) == sbi->oz_pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Al Viro030a8ba2011-07-26 03:29:03 -0400150struct inode *autofs4_get_inode(struct super_block *, umode_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151void autofs4_free_ino(struct autofs_info *);
152
153/* Expiration */
154int is_autofs4_dentry(struct dentry *);
NeilBrown23bfc2a2014-10-13 15:52:14 -0700155int autofs4_expire_wait(struct dentry *dentry, int rcu_walk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156int autofs4_expire_run(struct super_block *, struct vfsmount *,
157 struct autofs_sb_info *,
158 struct autofs_packet_expire __user *);
Ian Kent56fcef72009-03-31 15:24:43 -0700159int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
160 struct autofs_sb_info *sbi, int when);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161int autofs4_expire_multi(struct super_block *, struct vfsmount *,
162 struct autofs_sb_info *, int __user *);
Ian Kent8d7b48e2008-10-15 22:02:54 -0700163struct dentry *autofs4_expire_direct(struct super_block *sb,
164 struct vfsmount *mnt,
165 struct autofs_sb_info *sbi, int how);
166struct 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
172int autofs_dev_ioctl_init(void);
173void autofs_dev_ioctl_exit(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175/* Operations structures */
176
Arjan van de Ven754661f2007-02-12 00:55:38 -0800177extern const struct inode_operations autofs4_symlink_inode_operations;
178extern const struct inode_operations autofs4_dir_inode_operations;
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800179extern const struct file_operations autofs4_dir_operations;
180extern const struct file_operations autofs4_root_operations;
Ian Kent71e469d2011-01-14 18:46:19 +0000181extern const struct dentry_operations autofs4_dentry_operations;
Ian Kent10584212011-01-14 18:45:58 +0000182
183/* VFS automount flags management functions */
Ian Kentb5b80172011-01-14 18:46:03 +0000184static inline void __managed_dentry_set_managed(struct dentry *dentry)
185{
186 dentry->d_flags |= (DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
187}
188
189static 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
196static inline void __managed_dentry_clear_managed(struct dentry *dentry)
197{
198 dentry->d_flags &= ~(DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT);
199}
200
201static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208/* Initializing function */
209
210int autofs4_fill_super(struct super_block *, void *, int);
Al Viro26e6c912011-01-16 18:43:40 -0500211struct autofs_info *autofs4_new_ino(struct autofs_sb_info *);
212void autofs4_clean_ino(struct autofs_info *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Linus Torvalds64f371b2012-04-29 13:30:08 -0700214static inline int autofs_prepare_pipe(struct file *pipe)
215{
Al Viro72c2d532013-09-22 16:27:52 -0400216 if (!pipe->f_op->write)
Linus Torvalds64f371b2012-04-29 13:30:08 -0700217 return -EINVAL;
Al Viro496ad9a2013-01-23 17:07:38 -0500218 if (!S_ISFIFO(file_inode(pipe)->i_mode))
Linus Torvalds64f371b2012-04-29 13:30:08 -0700219 return -EINVAL;
220 /* We want a packet pipe */
221 pipe->f_flags |= O_DIRECT;
222 return 0;
223}
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225/* Queue management functions */
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
228int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
229void autofs4_catatonic_mode(struct autofs_sb_info *);
230
Ian Kent5c0a32f2006-03-27 01:14:55 -0800231static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
232{
233 return new_encode_dev(sbi->sb->s_dev);
234}
235
236static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
237{
238 return sbi->sb->s_root->d_inode->i_ino;
239}
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241static inline int simple_positive(struct dentry *dentry)
242{
243 return dentry->d_inode && !d_unhashed(dentry);
244}
245
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100246static 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
Ian Kentc4cd70b2009-12-15 16:45:43 -0800257static 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
270static 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
David Howells6ce31522006-10-11 01:22:15 -0700283extern void autofs4_kill_sb(struct super_block *);