blob: 8f7cdde4173358575b292088c7f085d71ba66232 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#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
Ian Kent8d7b48e2008-10-15 22:02:54 -070025#define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION)
26#define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11)
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#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
Ian Kent8d7b48e2008-10-15 22:02:54 -070042#define DPRINTK(fmt, args...) \
43do { \
44 printk(KERN_DEBUG "pid %d: %s: " fmt "\n", \
45 current->pid, __func__, ##args); \
46} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#else
Ian Kent8d7b48e2008-10-15 22:02:54 -070048#define DPRINTK(fmt, args...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#endif
50
Ian Kent8d7b48e2008-10-15 22:02:54 -070051#define AUTOFS_WARN(fmt, args...) \
52do { \
53 printk(KERN_WARNING "pid %d: %s: " fmt "\n", \
54 current->pid, __func__, ##args); \
55} while (0)
56
57#define AUTOFS_ERROR(fmt, args...) \
58do { \
59 printk(KERN_ERR "pid %d: %s: " fmt "\n", \
60 current->pid, __func__, ##args); \
61} while (0)
62
Linus Torvalds1da177e2005-04-16 15:20:36 -070063/* Unified info structure. This is pointed to by both the dentry and
64 inode structures. Each file in the filesystem has an instance of this
65 structure. It holds a reference to the dentry, so dentries are never
66 flushed while the file exists. All name lookups are dealt with at the
67 dentry level, although the filesystem can interfere in the validation
68 process. Readdir is implemented by traversing the dentry lists. */
69struct autofs_info {
70 struct dentry *dentry;
71 struct inode *inode;
72
73 int flags;
74
Ian Kent6e60a9a2008-07-23 21:30:27 -070075 struct completion expire_complete;
76
Ian Kent25767372008-07-23 21:30:12 -070077 struct list_head active;
Ian Kent5f6f4f22008-07-23 21:30:09 -070078 struct list_head expiring;
Ian Kentf50b6f82007-02-20 13:58:10 -080079
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 struct autofs_sb_info *sbi;
81 unsigned long last_used;
Ian Kent1aff3c82006-03-27 01:14:46 -080082 atomic_t count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Ian Kentc0f54d32008-10-15 22:02:52 -070084 uid_t uid;
85 gid_t gid;
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 mode_t mode;
88 size_t size;
89
90 void (*free)(struct autofs_info *);
91 union {
92 const char *symlink;
93 } u;
94};
95
96#define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */
Ian Kent6e60a9a2008-07-23 21:30:27 -070097#define AUTOFS_INF_MOUNTPOINT (1<<1) /* mountpoint status for direct expire */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99struct autofs_wait_queue {
100 wait_queue_head_t queue;
101 struct autofs_wait_queue *next;
102 autofs_wqt_t wait_queue_token;
103 /* We use the following to see what we are waiting for */
Jeff Moyer70b52a02008-07-23 21:30:16 -0700104 struct qstr name;
Ian Kent5c0a32f2006-03-27 01:14:55 -0800105 u32 dev;
106 u64 ino;
107 uid_t uid;
108 gid_t gid;
109 pid_t pid;
110 pid_t tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 /* This is for status reporting upon return */
112 int status;
Ian Kent296f7bf2008-07-23 21:30:21 -0700113 unsigned int wait_ctr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114};
115
116#define AUTOFS_SBI_MAGIC 0x6d4a556d
117
118struct autofs_sb_info {
119 u32 magic;
Ian Kentd7c4a5f2006-03-27 01:14:49 -0800120 int pipefd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 struct file *pipe;
122 pid_t oz_pgrp;
123 int catatonic;
124 int version;
125 int sub_version;
Ian Kentd7c4a5f2006-03-27 01:14:49 -0800126 int min_proto;
127 int max_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 unsigned long exp_timeout;
Ian Kent34ca9592006-03-27 01:14:54 -0800129 unsigned int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 int reghost_enabled;
131 int needs_reghost;
132 struct super_block *sb;
Ingo Molnar1d5599e2006-03-23 03:00:41 -0800133 struct mutex wq_mutex;
Ian Kent3a9720c2005-05-01 08:59:17 -0700134 spinlock_t fs_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 struct autofs_wait_queue *queues; /* Wait queue pointer */
Ian Kent5f6f4f22008-07-23 21:30:09 -0700136 spinlock_t lookup_lock;
Ian Kent25767372008-07-23 21:30:12 -0700137 struct list_head active_list;
Ian Kent5f6f4f22008-07-23 21:30:09 -0700138 struct list_head expiring_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139};
140
141static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
142{
143 return (struct autofs_sb_info *)(sb->s_fs_info);
144}
145
146static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)
147{
148 return (struct autofs_info *)(dentry->d_fsdata);
149}
150
151/* autofs4_oz_mode(): do we see the man behind the curtain? (The
152 processes which do manipulations for us in user space sees the raw
153 filesystem without "magic".) */
154
155static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
Pavel Emelianova47afb02007-10-18 23:39:46 -0700156 return sbi->catatonic || task_pgrp_nr(current) == sbi->oz_pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
159/* Does a dentry have some pending activity? */
160static inline int autofs4_ispending(struct dentry *dentry)
161{
162 struct autofs_info *inf = autofs4_dentry_ino(dentry);
163
Ian Kent3a9720c2005-05-01 08:59:17 -0700164 if (dentry->d_flags & DCACHE_AUTOFS_PENDING)
165 return 1;
166
Ian Kent97e74492008-07-23 21:30:26 -0700167 if (inf->flags & AUTOFS_INF_EXPIRING)
168 return 1;
Ian Kent3a9720c2005-05-01 08:59:17 -0700169
Ian Kent97e74492008-07-23 21:30:26 -0700170 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
173static inline void autofs4_copy_atime(struct file *src, struct file *dst)
174{
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800175 dst->f_path.dentry->d_inode->i_atime =
176 src->f_path.dentry->d_inode->i_atime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 return;
178}
179
180struct inode *autofs4_get_inode(struct super_block *, struct autofs_info *);
181void autofs4_free_ino(struct autofs_info *);
182
183/* Expiration */
184int is_autofs4_dentry(struct dentry *);
Ian Kent06a35982008-07-23 21:30:28 -0700185int autofs4_expire_wait(struct dentry *dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186int autofs4_expire_run(struct super_block *, struct vfsmount *,
187 struct autofs_sb_info *,
188 struct autofs_packet_expire __user *);
Ian Kent56fcef72009-03-31 15:24:43 -0700189int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
190 struct autofs_sb_info *sbi, int when);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191int autofs4_expire_multi(struct super_block *, struct vfsmount *,
192 struct autofs_sb_info *, int __user *);
Ian Kent8d7b48e2008-10-15 22:02:54 -0700193struct dentry *autofs4_expire_direct(struct super_block *sb,
194 struct vfsmount *mnt,
195 struct autofs_sb_info *sbi, int how);
196struct dentry *autofs4_expire_indirect(struct super_block *sb,
197 struct vfsmount *mnt,
198 struct autofs_sb_info *sbi, int how);
199
200/* Device node initialization */
201
202int autofs_dev_ioctl_init(void);
203void autofs_dev_ioctl_exit(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205/* Operations structures */
206
Arjan van de Ven754661f2007-02-12 00:55:38 -0800207extern const struct inode_operations autofs4_symlink_inode_operations;
208extern const struct inode_operations autofs4_dir_inode_operations;
209extern const struct inode_operations autofs4_root_inode_operations;
210extern const struct inode_operations autofs4_indirect_root_inode_operations;
211extern const struct inode_operations autofs4_direct_root_inode_operations;
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800212extern const struct file_operations autofs4_dir_operations;
213extern const struct file_operations autofs4_root_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215/* Initializing function */
216
217int autofs4_fill_super(struct super_block *, void *, int);
218struct autofs_info *autofs4_init_ino(struct autofs_info *, struct autofs_sb_info *sbi, mode_t mode);
219
220/* Queue management functions */
221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
223int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
224void autofs4_catatonic_mode(struct autofs_sb_info *);
225
Al Viro9393bd02009-04-18 13:58:15 -0400226static inline int autofs4_follow_mount(struct path *path)
Ian Kent9b1e3af2005-06-21 17:16:38 -0700227{
228 int res = 0;
229
Al Viro9393bd02009-04-18 13:58:15 -0400230 while (d_mountpoint(path->dentry)) {
231 int followed = follow_down(path);
Ian Kent9b1e3af2005-06-21 17:16:38 -0700232 if (!followed)
233 break;
234 res = 1;
235 }
236 return res;
237}
238
Ian Kent5c0a32f2006-03-27 01:14:55 -0800239static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
240{
241 return new_encode_dev(sbi->sb->s_dev);
242}
243
244static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
245{
246 return sbi->sb->s_root->d_inode->i_ino;
247}
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249static inline int simple_positive(struct dentry *dentry)
250{
251 return dentry->d_inode && !d_unhashed(dentry);
252}
253
Ian Kent90a59c72006-03-27 01:14:50 -0800254static inline int __simple_empty(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255{
256 struct dentry *child;
257 int ret = 0;
258
Eric Dumazet5160ee62006-01-08 01:03:32 -0800259 list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (simple_positive(child))
261 goto out;
262 ret = 1;
263out:
264 return ret;
265}
Adrian Bunkf5b95ff2006-03-28 01:56:29 -0800266
267void autofs4_dentry_release(struct dentry *);
David Howells6ce31522006-10-11 01:22:15 -0700268extern void autofs4_kill_sb(struct super_block *);