LCOV - code coverage report
Current view: top level - lkbce/include/linux - dcache.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 10 10 100.0 %
Date: 2017-01-25 Functions: 3 3 100.0 %

          Line data    Source code
       1             : #ifndef __LINUX_DCACHE_H
       2             : #define __LINUX_DCACHE_H
       3             : 
       4             : #include <asm/atomic.h>
       5             : #include <linux/list.h>
       6             : #include <linux/rculist.h>
       7             : #include <linux/spinlock.h>
       8             : #include <linux/cache.h>
       9             : #include <linux/rcupdate.h>
      10             : 
      11             : struct nameidata;
      12             : struct path;
      13             : struct vfsmount;
      14             : 
      15             : /*
      16             :  * linux/include/linux/dcache.h
      17             :  *
      18             :  * Dirent cache data structures
      19             :  *
      20             :  * (C) Copyright 1997 Thomas Schoebel-Theuer,
      21             :  * with heavy changes by Linus Torvalds
      22             :  */
      23             : 
      24             : #define IS_ROOT(x) ((x) == (x)->d_parent)
      25             : 
      26             : /*
      27             :  * "quick string" -- eases parameter passing, but more importantly
      28             :  * saves "metadata" about the string (ie length and the hash).
      29             :  *
      30             :  * hash comes first so it snuggles against d_parent in the
      31             :  * dentry.
      32             :  */
      33             : struct qstr {
      34             :         unsigned int hash;
      35             :         unsigned int len;
      36             :         const unsigned char *name;
      37             : };
      38             : 
      39             : struct dentry_stat_t {
      40             :         int nr_dentry;
      41             :         int nr_unused;
      42             :         int age_limit;          /* age in seconds */
      43             :         int want_pages;         /* pages requested by system */
      44             :         int dummy[2];
      45             : };
      46             : extern struct dentry_stat_t dentry_stat;
      47             : 
      48             : /* Name hashing routines. Initial hash value */
      49             : /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
      50             : #define init_name_hash()                0
      51             : 
      52             : /* partial hash update function. Assume roughly 4 bits per character */
      53             : static inline unsigned long
      54             : partial_name_hash(unsigned long c, unsigned long prevhash)
      55             : {
      56           6 :         return (prevhash + (c << 4) + (c >> 4)) * 11;
      57             : }
      58             : 
      59             : /*
      60             :  * Finally: cut down the number of bits to a int value (and try to avoid
      61             :  * losing bits)
      62             :  */
      63             : static inline unsigned long end_name_hash(unsigned long hash)
      64             : {
      65           6 :         return (unsigned int) hash;
      66             : }
      67             : 
      68             : /* Compute the hash for a name string. */
      69             : static inline unsigned int
      70             : full_name_hash(const unsigned char *name, unsigned int len)
      71             : {
      72           8 :         unsigned long hash = init_name_hash();
      73          24 :         while (len--)
      74          24 :                 hash = partial_name_hash(*name++, hash);
      75          20 :         return end_name_hash(hash);
      76           4 : }
      77           4 : 
      78             : /*
      79             :  * Try to keep struct dentry aligned on 64 byte cachelines (this will
      80             :  * give reasonable cacheline footprint with larger lines without the
      81             :  * large memory footprint increase).
      82             :  */
      83             : #ifdef CONFIG_64BIT
      84             : #define DNAME_INLINE_LEN_MIN 32 /* 192 bytes */
      85             : #else
      86             : #define DNAME_INLINE_LEN_MIN 40 /* 128 bytes */
      87             : #endif
      88             : 
      89             : struct dentry {
      90             :         atomic_t d_count;
      91             :         unsigned int d_flags;           /* protected by d_lock */
      92             :         spinlock_t d_lock;              /* per dentry lock */
      93             :         int d_mounted;
      94             :         struct inode *d_inode;          /* Where the name belongs to - NULL is
      95             :                                          * negative */
      96             :         /*
      97             :          * The next three fields are touched by __d_lookup.  Place them here
      98             :          * so they all fit in a cache line.
      99             :          */
     100             :         struct hlist_node d_hash;       /* lookup hash list */
     101             :         struct dentry *d_parent;        /* parent directory */
     102             :         struct qstr d_name;
     103             : 
     104             :         struct list_head d_lru;         /* LRU list */
     105             :         /*
     106             :          * d_child and d_rcu can share memory
     107             :          */
     108             :         union {
     109             :                 struct list_head d_child;       /* child of parent list */
     110             :                 struct rcu_head d_rcu;
     111             :         } d_u;
     112             :         struct list_head d_subdirs;     /* our children */
     113             :         struct list_head d_alias;       /* inode alias list */
     114             :         unsigned long d_time;           /* used by d_revalidate */
     115             :         const struct dentry_operations *d_op;
     116             :         struct super_block *d_sb;       /* The root of the dentry tree */
     117             :         void *d_fsdata;                 /* fs-specific data */
     118             : 
     119             :         unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
     120             : };
     121             : 
     122             : /*
     123             :  * dentry->d_lock spinlock nesting subclasses:
     124             :  *
     125             :  * 0: normal
     126           1 :  * 1: nested
     127             :  */
     128             : enum dentry_d_lock_class
     129             : {
     130             :         DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
     131             :         DENTRY_D_LOCK_NESTED
     132             : };
     133             : 
     134             : struct dentry_operations {
     135             :         int (*d_revalidate)(struct dentry *, struct nameidata *);
     136             :         int (*d_hash) (struct dentry *, struct qstr *);
     137             :         int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
     138             :         int (*d_delete)(struct dentry *);
     139             :         void (*d_release)(struct dentry *);
     140             :         void (*d_iput)(struct dentry *, struct inode *);
     141             :         char *(*d_dname)(struct dentry *, char *, int);
     142             : };
     143             : 
     144             : /* the dentry parameter passed to d_hash and d_compare is the parent
     145             :  * directory of the entries to be compared. It is used in case these
     146             :  * functions need any directory specific information for determining
     147             :  * equivalency classes.  Using the dentry itself might not work, as it
     148             :  * might be a negative dentry which has no information associated with
     149             :  * it */
     150             : 
     151             : /*
     152             : locking rules:
     153             :                 big lock        dcache_lock     d_lock   may block
     154             : d_revalidate:   no              no              no       yes
     155             : d_hash          no              no              no       yes
     156             : d_compare:      no              yes             yes      no
     157             : d_delete:       no              yes             no       no
     158             : d_release:      no              no              no       yes
     159             : d_iput:         no              no              no       yes
     160             :  */
     161             : 
     162             : /* d_flags entries */
     163             : #define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
     164             : #define DCACHE_NFSFS_RENAMED  0x0002    /* this dentry has been "silly
     165             :                                          * renamed" and has to be
     166             :                                          * deleted on the last dput()
     167             :                                          */
     168             : #define DCACHE_DISCONNECTED 0x0004
     169             :      /* This dentry is possibly not currently connected to the dcache tree,
     170             :       * in which case its parent will either be itself, or will have this
     171             :       * flag as well.  nfsd will not use a dentry with this bit set, but will
     172             :       * first endeavour to clear the bit either by discovering that it is
     173             :       * connected, or by performing lookup operations.   Any filesystem which
     174             :       * supports nfsd_operations MUST have a lookup function which, if it finds
     175             :       * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
     176             :       * that dentry into place and return that dentry rather than the passed one,
     177             :       * typically using d_splice_alias.
     178             :       */
     179             : 
     180             : #define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
     181             : #define DCACHE_UNHASHED         0x0010  
     182             : 
     183             : #define DCACHE_INOTIFY_PARENT_WATCHED   0x0020 /* Parent inode is watched by inotify */
     184             : 
     185             : #define DCACHE_COOKIE           0x0040  /* For use by dcookie subsystem */
     186             : 
     187             : #define DCACHE_FSNOTIFY_PARENT_WATCHED  0x0080 /* Parent inode is watched by some fsnotify listener */
     188             : 
     189             : extern spinlock_t dcache_lock;
     190             : extern seqlock_t rename_lock;
     191             : 
     192             : /**
     193             :  * d_drop - drop a dentry
     194             :  * @dentry: dentry to drop
     195             :  *
     196             :  * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
     197             :  * be found through a VFS lookup any more. Note that this is different from
     198             :  * deleting the dentry - d_delete will try to mark the dentry negative if
     199             :  * possible, giving a successful _negative_ lookup, while d_drop will
     200             :  * just make the cache lookup fail.
     201             :  *
     202             :  * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
     203             :  * reason (NFS timeouts or autofs deletes).
     204             :  *
     205             :  * __d_drop requires dentry->d_lock.
     206             :  */
     207             : 
     208             : static inline void __d_drop(struct dentry *dentry)
     209             : {
     210             :         if (!(dentry->d_flags & DCACHE_UNHASHED)) {
     211             :                 dentry->d_flags |= DCACHE_UNHASHED;
     212             :                 hlist_del_rcu(&dentry->d_hash);
     213             :         }
     214             : }
     215             : 
     216             : static inline void d_drop(struct dentry *dentry)
     217             : {
     218             :         spin_lock(&dcache_lock);
     219             :         spin_lock(&dentry->d_lock);
     220             :         __d_drop(dentry);
     221             :         spin_unlock(&dentry->d_lock);
     222             :         spin_unlock(&dcache_lock);
     223             : }
     224             : 
     225             : static inline int dname_external(struct dentry *dentry)
     226             : {
     227             :         return dentry->d_name.name != dentry->d_iname;
     228             : }
     229             : 
     230             : /*
     231             :  * These are the low-level FS interfaces to the dcache..
     232             :  */
     233             : extern void d_instantiate(struct dentry *, struct inode *);
     234             : extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
     235             : extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
     236             : extern void d_delete(struct dentry *);
     237             : 
     238             : /* allocate/de-allocate */
     239             : extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
     240             : extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
     241             : extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
     242             : extern struct dentry * d_obtain_alias(struct inode *);
     243             : extern void shrink_dcache_sb(struct super_block *);
     244             : extern void shrink_dcache_parent(struct dentry *);
     245             : extern void shrink_dcache_for_umount(struct super_block *);
     246             : extern int d_invalidate(struct dentry *);
     247             : 
     248             : /* only used at mount-time */
     249             : extern struct dentry * d_alloc_root(struct inode *);
     250             : 
     251             : /* <clickety>-<click> the ramfs-type tree */
     252             : extern void d_genocide(struct dentry *);
     253             : 
     254             : extern struct dentry *d_find_alias(struct inode *);
     255             : extern void d_prune_aliases(struct inode *);
     256             : 
     257             : /* test whether we have any submounts in a subdir tree */
     258             : extern int have_submounts(struct dentry *);
     259             : 
     260             : /*
     261             :  * This adds the entry to the hash queues.
     262             :  */
     263             : extern void d_rehash(struct dentry *);
     264             : 
     265             : /**
     266             :  * d_add - add dentry to hash queues
     267             :  * @entry: dentry to add
     268             :  * @inode: The inode to attach to this dentry
     269             :  *
     270             :  * This adds the entry to the hash queues and initializes @inode.
     271             :  * The entry was actually filled in earlier during d_alloc().
     272             :  */
     273             :  
     274             : static inline void d_add(struct dentry *entry, struct inode *inode)
     275             : {
     276             :         d_instantiate(entry, inode);
     277             :         d_rehash(entry);
     278             : }
     279             : 
     280             : /**
     281             :  * d_add_unique - add dentry to hash queues without aliasing
     282             :  * @entry: dentry to add
     283             :  * @inode: The inode to attach to this dentry
     284             :  *
     285             :  * This adds the entry to the hash queues and initializes @inode.
     286             :  * The entry was actually filled in earlier during d_alloc().
     287             :  */
     288             : static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
     289             : {
     290             :         struct dentry *res;
     291             : 
     292             :         res = d_instantiate_unique(entry, inode);
     293             :         d_rehash(res != NULL ? res : entry);
     294             :         return res;
     295             : }
     296             : 
     297             : /* used for rename() and baskets */
     298             : extern void d_move(struct dentry *, struct dentry *);
     299             : extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
     300             : 
     301             : /* appendix may either be NULL or be used for transname suffixes */
     302             : extern struct dentry * d_lookup(struct dentry *, struct qstr *);
     303             : extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
     304             : extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
     305             : 
     306             : /* validate "insecure" dentry pointer */
     307             : extern int d_validate(struct dentry *, struct dentry *);
     308             : 
     309             : /*
     310             :  * helper function for dentry_operations.d_dname() members
     311             :  */
     312             : extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
     313             : 
     314             : extern char *__d_path(const struct path *path, struct path *root, char *, int);
     315             : extern char *d_path(const struct path *, char *, int);
     316             : extern char *dentry_path(struct dentry *, char *, int);
     317             : 
     318             : /* Allocation counts.. */
     319             : 
     320             : /**
     321             :  *      dget, dget_locked       -       get a reference to a dentry
     322             :  *      @dentry: dentry to get a reference to
     323             :  *
     324             :  *      Given a dentry or %NULL pointer increment the reference count
     325             :  *      if appropriate and return the dentry. A dentry will not be 
     326             :  *      destroyed when it has references. dget() should never be
     327             :  *      called for dentries with zero reference counter. For these cases
     328             :  *      (preferably none, functions in dcache.c are sufficient for normal
     329             :  *      needs and they take necessary precautions) you should hold dcache_lock
     330             :  *      and call dget_locked() instead of dget().
     331             :  */
     332             :  
     333             : static inline struct dentry *dget(struct dentry *dentry)
     334             : {
     335             :         if (dentry) {
     336             :                 BUG_ON(!atomic_read(&dentry->d_count));
     337             :                 atomic_inc(&dentry->d_count);
     338             :         }
     339             :         return dentry;
     340             : }
     341             : 
     342             : extern struct dentry * dget_locked(struct dentry *);
     343             : 
     344             : /**
     345             :  *      d_unhashed -    is dentry hashed
     346             :  *      @dentry: entry to check
     347             :  *
     348             :  *      Returns true if the dentry passed is not currently hashed.
     349             :  */
     350             :  
     351             : static inline int d_unhashed(struct dentry *dentry)
     352             : {
     353             :         return (dentry->d_flags & DCACHE_UNHASHED);
     354             : }
     355             : 
     356             : static inline int d_unlinked(struct dentry *dentry)
     357             : {
     358             :         return d_unhashed(dentry) && !IS_ROOT(dentry);
     359             : }
     360             : 
     361             : static inline struct dentry *dget_parent(struct dentry *dentry)
     362             : {
     363             :         struct dentry *ret;
     364             : 
     365             :         spin_lock(&dentry->d_lock);
     366             :         ret = dget(dentry->d_parent);
     367             :         spin_unlock(&dentry->d_lock);
     368             :         return ret;
     369             : }
     370             : 
     371             : extern void dput(struct dentry *);
     372             : 
     373             : static inline int d_mountpoint(struct dentry *dentry)
     374             : {
     375             :         return dentry->d_mounted;
     376             : }
     377             : 
     378             : extern struct vfsmount *lookup_mnt(struct path *);
     379             : extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
     380             : 
     381             : extern int sysctl_vfs_cache_pressure;
     382           1 : 
     383             : #endif  /* __LINUX_DCACHE_H */

Generated by: LCOV version 1.10