LXR linux/fs/autofs4/autofs

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