fs/autofs4/autofs_i.h

   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/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
  25 #define AUTOFS_DEV_IOCTL_IOC_FIRST      (AUTOFS_DEV_IOCTL_VERSION)
  26 #define AUTOFS_DEV_IOCTL_IOC_COUNT      (AUTOFS_IOC_COUNT - 11)
  27
  28 #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
  42 #define DPRINTK(fmt, args...)                           \
  43 do {                                                    \
  44         printk(KERN_DEBUG "pid %d: %s: " fmt "\n",      \
  45                 current->pid, __func__, ##args);        \
  46 } while (0)
  47 #else
  48 #define DPRINTK(fmt, args...) do {} while (0)
  49 #endif
  50
  51 #define AUTOFS_WARN(fmt, args...)                       \
  52 do {                                                    \
  53         printk(KERN_WARNING "pid %d: %s: " fmt "\n",    \
  54                 current->pid, __func__, ##args);        \
  55 } while (0)
  56
  57 #define AUTOFS_ERROR(fmt, args...)                      \
  58 do {                                                    \
  59         printk(KERN_ERR "pid %d: %s: " fmt "\n",        \
  60                 current->pid, __func__, ##args);        \
  61 } while (0)
  62
  63 struct rehash_entry {
  64         struct task_struct *task;
  65         struct list_head list;
  66 };
  67
  68 /* Unified info structure.  This is pointed to by both the dentry and
  69    inode structures.  Each file in the filesystem has an instance of this
  70    structure.  It holds a reference to the dentry, so dentries are never
  71    flushed while the file exists.  All name lookups are dealt with at the
  72    dentry level, although the filesystem can interfere in the validation
  73    process.  Readdir is implemented by traversing the dentry lists. */
  74 struct autofs_info {
  75         struct dentry   *dentry;
  76         struct inode    *inode;
  77
  78         int             flags;
  79
  80         struct completion expire_complete;
  81
  82         struct list_head active;
  83         int active_count;
  84         struct list_head rehash_list;
  85
  86         struct list_head expiring;
  87
  88         struct autofs_sb_info *sbi;
  89         unsigned long last_used;
  90         atomic_t count;
  91
  92         uid_t uid;
  93         gid_t gid;
  94
  95         mode_t  mode;
  96         size_t  size;
  97
  98         void (*free)(struct autofs_info *);
  99         union {
 100                 const char *symlink;
 101         } u;
 102 };
 103
 104 #define AUTOFS_INF_EXPIRING     (1<<0) /* dentry is in the process of expiring */
 105 #define AUTOFS_INF_MOUNTPOINT   (1<<1) /* mountpoint status for direct expire */
 106 #define AUTOFS_INF_PENDING      (1<<2) /* dentry pending mount */
 107 #define AUTOFS_INF_REHASH       (1<<3) /* dentry in transit to ->lookup() */
 108
 109 struct autofs_wait_queue {
 110         wait_queue_head_t queue;
 111         struct autofs_wait_queue *next;
 112         autofs_wqt_t wait_queue_token;
 113         /* We use the following to see what we are waiting for */
 114         struct qstr name;
 115         u32 dev;
 116         u64 ino;
 117         uid_t uid;
 118         gid_t gid;
 119         pid_t pid;
 120         pid_t tgid;
 121         /* This is for status reporting upon return */
 122         int status;
 123         unsigned int wait_ctr;
 124 };
 125
 126 #define AUTOFS_SBI_MAGIC 0x6d4a556d
 127
 128 struct autofs_sb_info {
 129         u32 magic;
 130         int pipefd;
 131         struct file *pipe;
 132         pid_t oz_pgrp;
 133         int catatonic;
 134         int version;
 135         int sub_version;
 136         int min_proto;
 137         int max_proto;
 138         unsigned long exp_timeout;
 139         unsigned int type;
 140         int reghost_enabled;
 141         int needs_reghost;
 142         struct super_block *sb;
 143         struct mutex wq_mutex;
 144         spinlock_t fs_lock;
 145         struct autofs_wait_queue *queues; /* Wait queue pointer */
 146         spinlock_t lookup_lock;
 147         struct list_head active_list;
 148         struct list_head expiring_list;
 149 };
 150
 151 static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)
 152 {
 153         return (struct autofs_sb_info *)(sb->s_fs_info);
 154 }
 155
 156 static inline struct autofs_info *autofs4_dentry_ino(struct dentry *dentry)
 157 {
 158         return (struct autofs_info *)(dentry->d_fsdata);
 159 }
 160
 161 /* autofs4_oz_mode(): do we see the man behind the curtain?  (The
 162    processes which do manipulations for us in user space sees the raw
 163    filesystem without "magic".) */
 164
 165 static inline int autofs4_oz_mode(struct autofs_sb_info *sbi) {
 166         return sbi->catatonic || task_pgrp_nr(current) == sbi->oz_pgrp;
 167 }
 168
 169 /* Does a dentry have some pending activity? */
 170 static inline int autofs4_ispending(struct dentry *dentry)
 171 {
 172         struct autofs_info *inf = autofs4_dentry_ino(dentry);
 173
 174         if (inf->flags & AUTOFS_INF_PENDING)
 175                 return 1;
 176
 177         if (inf->flags & AUTOFS_INF_EXPIRING)
 178                 return 1;
 179
 180         return 0;
 181 }
 182
 183 static inline void autofs4_copy_atime(struct file *src, struct file *dst)
 184 {
 185         dst->f_path.dentry->d_inode->i_atime =
 186                 src->f_path.dentry->d_inode->i_atime;
 187         return;
 188 }
 189
 190 struct inode *autofs4_get_inode(struct super_block *, struct autofs_info *);
 191 void autofs4_free_ino(struct autofs_info *);
 192
 193 /* Expiration */
 194 int is_autofs4_dentry(struct dentry *);
 195 int autofs4_expire_wait(struct dentry *dentry);
 196 int autofs4_expire_run(struct super_block *, struct vfsmount *,
 197                         struct autofs_sb_info *,
 198                         struct autofs_packet_expire __user *);
 199 int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
 200                             struct autofs_sb_info *sbi, int when);
 201 int autofs4_expire_multi(struct super_block *, struct vfsmount *,
 202                         struct autofs_sb_info *, int __user *);
 203 struct dentry *autofs4_expire_direct(struct super_block *sb,
 204                                      struct vfsmount *mnt,
 205                                      struct autofs_sb_info *sbi, int how);
 206 struct dentry *autofs4_expire_indirect(struct super_block *sb,
 207                                        struct vfsmount *mnt,
 208                                        struct autofs_sb_info *sbi, int how);
 209
 210 /* Device node initialization */
 211
 212 int autofs_dev_ioctl_init(void);
 213 void autofs_dev_ioctl_exit(void);
 214
 215 /* Operations structures */
 216
 217 extern const struct inode_operations autofs4_symlink_inode_operations;
 218 extern const struct inode_operations autofs4_dir_inode_operations;
 219 extern const struct inode_operations autofs4_root_inode_operations;
 220 extern const struct inode_operations autofs4_indirect_root_inode_operations;
 221 extern const struct inode_operations autofs4_direct_root_inode_operations;
 222 extern const struct file_operations autofs4_dir_operations;
 223 extern const struct file_operations autofs4_root_operations;
 224
 225 /* Initializing function */
 226
 227 int autofs4_fill_super(struct super_block *, void *, int);
 228 struct autofs_info *autofs4_init_ino(struct autofs_info *, struct autofs_sb_info *sbi, mode_t mode);
 229
 230 /* Queue management functions */
 231
 232 int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
 233 int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
 234 void autofs4_catatonic_mode(struct autofs_sb_info *);
 235
 236 static inline int autofs4_follow_mount(struct path *path)
 237 {
 238         int res = 0;
 239
 240         while (d_mountpoint(path->dentry)) {
 241                 int followed = follow_down(path);
 242                 if (!followed)
 243                         break;
 244                 res = 1;
 245         }
 246         return res;
 247 }
 248
 249 static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
 250 {
 251         return new_encode_dev(sbi->sb->s_dev);
 252 }
 253
 254 static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
 255 {
 256         return sbi->sb->s_root->d_inode->i_ino;
 257 }
 258
 259 static inline int simple_positive(struct dentry *dentry)
 260 {
 261         return dentry->d_inode && !d_unhashed(dentry);
 262 }
 263
 264 static inline int __simple_empty(struct dentry *dentry)
 265 {
 266         struct dentry *child;
 267         int ret = 0;
 268
 269         list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
 270                 if (simple_positive(child))
 271                         goto out;
 272         ret = 1;
 273 out:
 274         return ret;
 275 }
 276
 277 static inline void autofs4_add_expiring(struct dentry *dentry)
 278 {
 279         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 280         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 281         if (ino) {
 282                 spin_lock(&sbi->lookup_lock);
 283                 if (list_empty(&ino->expiring))
 284                         list_add(&ino->expiring, &sbi->expiring_list);
 285                 spin_unlock(&sbi->lookup_lock);
 286         }
 287         return;
 288 }
 289
 290 static inline void autofs4_del_expiring(struct dentry *dentry)
 291 {
 292         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 293         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 294         if (ino) {
 295                 spin_lock(&sbi->lookup_lock);
 296                 if (!list_empty(&ino->expiring))
 297                         list_del_init(&ino->expiring);
 298                 spin_unlock(&sbi->lookup_lock);
 299         }
 300         return;
 301 }
 302
 303 void autofs4_dentry_release(struct dentry *);
 304 extern void autofs4_kill_sb(struct super_block *);