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