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/spinlock.h> 20#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 26#define AUTOFS_DEV_IOCTL_IOC_FIRST (AUTOFS_DEV_IOCTL_VERSION) 27#define AUTOFS_DEV_IOCTL_IOC_COUNT (AUTOFS_IOC_COUNT - 11) 28 29#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 42#define DPRINTK(fmt, ...) \ 43 pr_debug("pid %d: %s: " fmt "\n", \ 44 current->pid, __func__, ##__VA_ARGS__) 45 46#define AUTOFS_WARN(fmt, ...) \ 47 printk(KERN_WARNING "pid %d: %s: " fmt "\n", \ 48 current->pid, __func__, ##__VA_ARGS__) 49 50#define AUTOFS_ERROR(fmt, ...) \ 51 printk(KERN_ERR "pid %d: %s: " fmt "\n", \ 52 current->pid, __func__, ##__VA_ARGS__) 53 54/* 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 66 struct completion expire_complete; 67 68 struct list_head active; 69 int active_count; 70 71 struct list_head expiring; 72 73 struct autofs_sb_info *sbi; 74 unsigned long last_used; 75 atomic_t count; 76 77 kuid_t uid; 78 kgid_t gid; 79}; 80 81#define AUTOFS_INF_EXPIRING (1<<0) /* dentry is in the process of expiring */ 82#define AUTOFS_INF_NO_RCU (1<<1) /* the dentry is being considered 83 * for expiry, so RCU_walk is 84 * not permitted 85 */ 86#define AUTOFS_INF_PENDING (1<<2) /* dentry pending mount */ 87 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 */ 93 struct qstr name; 94 u32 dev; 95 u64 ino; 96 kuid_t uid; 97 kgid_t gid; 98 pid_t pid; 99 pid_t tgid; 100 /* This is for status reporting upon return */ 101 int status; 102 unsigned int wait_ctr; 103}; 104 105#define AUTOFS_SBI_MAGIC 0x6d4a556d 106 107struct autofs_sb_info { 108 u32 magic; 109 int pipefd; 110 struct file *pipe; 111 struct pid *oz_pgrp; 112 int catatonic; 113 int version; 114 int sub_version; 115 int min_proto; 116 int max_proto; 117 unsigned long exp_timeout; 118 unsigned int type; 119 int reghost_enabled; 120 int needs_reghost; 121 struct super_block *sb; 122 struct mutex wq_mutex; 123 struct mutex pipe_mutex; 124 spinlock_t fs_lock; 125 struct autofs_wait_queue *queues; /* Wait queue pointer */ 126 spinlock_t lookup_lock; 127 struct list_head active_list; 128 struct list_head expiring_list; 129 struct rcu_head rcu; 130}; 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) { 147 return sbi->catatonic || task_pgrp(current) == sbi->oz_pgrp; 148} 149 150struct inode *autofs4_get_inode(struct super_block *, umode_t); 151void autofs4_free_ino(struct autofs_info *); 152 153/* Expiration */ 154int is_autofs4_dentry(struct dentry *); 155int autofs4_expire_wait(struct dentry *dentry, int rcu_walk); 156int autofs4_expire_run(struct super_block *, struct vfsmount *, 157 struct autofs_sb_info *, 158 struct autofs_packet_expire __user *); 159int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, 160 struct autofs_sb_info *sbi, int when); 161int autofs4_expire_multi(struct super_block *, struct vfsmount *, 162 struct autofs_sb_info *, int __user *); 163struct 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); 174 175/* Operations structures */ 176 177extern const struct inode_operations autofs4_symlink_inode_operations; 178extern const struct inode_operations autofs4_dir_inode_operations; 179extern const struct file_operations autofs4_dir_operations; 180extern const struct file_operations autofs4_root_operations; 181extern const struct dentry_operations autofs4_dentry_operations; 182 183/* VFS automount flags management functions */ 184static 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 208/* Initializing function */ 209 210int autofs4_fill_super(struct super_block *, void *, int); 211struct autofs_info *autofs4_new_ino(struct autofs_sb_info *); 212void autofs4_clean_ino(struct autofs_info *); 213 214static inline int autofs_prepare_pipe(struct file *pipe) 215{ 216 if (!(pipe->f_mode & FMODE_CAN_WRITE)) 217 return -EINVAL; 218 if (!S_ISFIFO(file_inode(pipe)->i_mode)) 219 return -EINVAL; 220 /* We want a packet pipe */ 221 pipe->f_flags |= O_DIRECT; 222 return 0; 223} 224 225/* Queue management functions */ 226 227int 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 231static 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 d_inode(sbi->sb->s_root)->i_ino; 239} 240 241static inline int simple_positive(struct dentry *dentry) 242{ 243 return d_really_is_positive(dentry) && !d_unhashed(dentry); 244} 245 246static 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 257static 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 283extern void autofs4_kill_sb(struct super_block *); 284