LCOV - code coverage report
Current view: top level - lkbce/fs/autofs4 - autofs_i.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 42 51 82.4 %
Date: 2017-01-25 Functions: 9 10 90.0 %

          Line data    Source code
       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           3 : 
      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           1 : 
     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           1 : 
     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          96 :         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         266 :         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         130 :         return sbi->catatonic || task_pgrp_nr(current) == sbi->oz_pgrp;
     167          10 : }
     168          10 : 
     169          10 : /* Does a dentry have some pending activity? */
     170             : static inline int autofs4_ispending(struct dentry *dentry)
     171             : {
     172           4 :         struct autofs_info *inf = autofs4_dentry_ino(dentry);
     173           1 : 
     174           2 :         if (inf->flags & AUTOFS_INF_PENDING)
     175           1 :                 return 1;
     176             : 
     177           2 :         if (inf->flags & AUTOFS_INF_EXPIRING)
     178           1 :                 return 1;
     179             : 
     180           1 :         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           1 : extern const struct inode_operations autofs4_symlink_inode_operations;
     218           1 : extern const struct inode_operations autofs4_dir_inode_operations;
     219             : extern const struct inode_operations autofs4_root_inode_operations;
     220           1 : extern const struct inode_operations autofs4_indirect_root_inode_operations;
     221           1 : extern const struct inode_operations autofs4_direct_root_inode_operations;
     222           1 : extern const struct file_operations autofs4_dir_operations;
     223           1 : 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           0 :         int res = 0;
     239           0 : 
     240           0 :         while (d_mountpoint(path->dentry)) {
     241           0 :                 int followed = follow_down(path);
     242           0 :                 if (!followed)
     243           0 :                         break;
     244           0 :                 res = 1;
     245           0 :         }
     246           0 :         return res;
     247             : }
     248             : 
     249             : static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
     250             : {
     251          32 :         return new_encode_dev(sbi->sb->s_dev);
     252             : }
     253             : 
     254             : static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
     255             : {
     256          16 :         return sbi->sb->s_root->d_inode->i_ino;
     257             : }
     258             : 
     259             : static inline int simple_positive(struct dentry *dentry)
     260             : {
     261         195 :         return dentry->d_inode && !d_unhashed(dentry);
     262          15 : }
     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          20 :         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
     280          20 :         struct autofs_info *ino = autofs4_dentry_ino(dentry);
     281          15 :         if (ino) {
     282          15 :                 spin_lock(&sbi->lookup_lock);
     283          25 :                 if (list_empty(&ino->expiring))
     284          10 :                         list_add(&ino->expiring, &sbi->expiring_list);
     285          20 :                 spin_unlock(&sbi->lookup_lock);
     286             :         }
     287          10 :         return;
     288             : }
     289             : 
     290             : static inline void autofs4_del_expiring(struct dentry *dentry)
     291             : {
     292          12 :         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
     293          12 :         struct autofs_info *ino = autofs4_dentry_ino(dentry);
     294           9 :         if (ino) {
     295           9 :                 spin_lock(&sbi->lookup_lock);
     296          15 :                 if (!list_empty(&ino->expiring))
     297           6 :                         list_del_init(&ino->expiring);
     298          12 :                 spin_unlock(&sbi->lookup_lock);
     299             :         }
     300           6 :         return;
     301             : }
     302             : 
     303             : void autofs4_dentry_release(struct dentry *);
     304             : extern void autofs4_kill_sb(struct super_block *);

Generated by: LCOV version 1.10