LXR linux/include/linux/dcache.h

   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
  11struct nameidata;
  12struct path;
  13struct 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 */
  33struct qstr {
  34        unsigned int hash;
  35        unsigned int len;
  36        const unsigned char *name;
  37};
  38
  39struct 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};
  46extern 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 */
  53static inline unsigned long
  54partial_name_hash(unsigned long c, unsigned long prevhash)
  55{
  56        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 */
  63static inline unsigned long end_name_hash(unsigned long hash)
  64{
  65        return (unsigned int) hash;
  66}
  67
  68/* Compute the hash for a name string. */
  69static inline unsigned int
  70full_name_hash(const unsigned char *name, unsigned int len)
  71{
  72        unsigned long hash = init_name_hash();
  73        while (len--)
  74                hash = partial_name_hash(*name++, hash);
  75        return end_name_hash(hash);
  76}
  77
  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
  89struct 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: nested
 127 */
 128enum dentry_d_lock_class
 129{
 130        DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
 131        DENTRY_D_LOCK_NESTED
 132};
 133
 134struct 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/*
 152locking rules:
 153                big lock        dcache_lock     d_lock   may block
 154d_revalidate:   no              no              no       yes
 155d_hash          no              no              no       yes
 156d_compare:      no              yes             yes      no
 157d_delete:       no              yes             no       no
 158d_release:      no              no              no       yes
 159d_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#define DCACHE_CANT_MOUNT       0x0100
 190
 191extern spinlock_t dcache_lock;
 192extern seqlock_t rename_lock;
 193
 194/**
 195 * d_drop - drop a dentry
 196 * @dentry: dentry to drop
 197 *
 198 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
 199 * be found through a VFS lookup any more. Note that this is different from
 200 * deleting the dentry - d_delete will try to mark the dentry negative if
 201 * possible, giving a successful _negative_ lookup, while d_drop will
 202 * just make the cache lookup fail.
 203 *
 204 * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
 205 * reason (NFS timeouts or autofs deletes).
 206 *
 207 * __d_drop requires dentry->d_lock.
 208 */
 209
 210static inline void __d_drop(struct dentry *dentry)
 211{
 212        if (!(dentry->d_flags & DCACHE_UNHASHED)) {
 213                dentry->d_flags |= DCACHE_UNHASHED;
 214                hlist_del_rcu(&dentry->d_hash);
 215        }
 216}
 217
 218static inline void d_drop(struct dentry *dentry)
 219{
 220        spin_lock(&dcache_lock);
 221        spin_lock(&dentry->d_lock);
 222        __d_drop(dentry);
 223        spin_unlock(&dentry->d_lock);
 224        spin_unlock(&dcache_lock);
 225}
 226
 227static inline int dname_external(struct dentry *dentry)
 228{
 229        return dentry->d_name.name != dentry->d_iname;
 230}
 231
 232/*
 233 * These are the low-level FS interfaces to the dcache..
 234 */
 235extern void d_instantiate(struct dentry *, struct inode *);
 236extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
 237extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
 238extern void d_delete(struct dentry *);
 239
 240/* allocate/de-allocate */
 241extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
 242extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
 243extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
 244extern struct dentry * d_obtain_alias(struct inode *);
 245extern void shrink_dcache_sb(struct super_block *);
 246extern void shrink_dcache_parent(struct dentry *);
 247extern void shrink_dcache_for_umount(struct super_block *);
 248extern int d_invalidate(struct dentry *);
 249
 250/* only used at mount-time */
 251extern struct dentry * d_alloc_root(struct inode *);
 252
 253/* <clickety>-<click> the ramfs-type tree */
 254extern void d_genocide(struct dentry *);
 255
 256extern struct dentry *d_find_alias(struct inode *);
 257extern void d_prune_aliases(struct inode *);
 258
 259/* test whether we have any submounts in a subdir tree */
 260extern int have_submounts(struct dentry *);
 261
 262/*
 263 * This adds the entry to the hash queues.
 264 */
 265extern void d_rehash(struct dentry *);
 266
 267/**
 268 * d_add - add dentry to hash queues
 269 * @entry: dentry to add
 270 * @inode: The inode to attach to this dentry
 271 *
 272 * This adds the entry to the hash queues and initializes @inode.
 273 * The entry was actually filled in earlier during d_alloc().
 274 */
 275 
 276static inline void d_add(struct dentry *entry, struct inode *inode)
 277{
 278        d_instantiate(entry, inode);
 279        d_rehash(entry);
 280}
 281
 282/**
 283 * d_add_unique - add dentry to hash queues without aliasing
 284 * @entry: dentry to add
 285 * @inode: The inode to attach to this dentry
 286 *
 287 * This adds the entry to the hash queues and initializes @inode.
 288 * The entry was actually filled in earlier during d_alloc().
 289 */
 290static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
 291{
 292        struct dentry *res;
 293
 294        res = d_instantiate_unique(entry, inode);
 295        d_rehash(res != NULL ? res : entry);
 296        return res;
 297}
 298
 299/* used for rename() and baskets */
 300extern void d_move(struct dentry *, struct dentry *);
 301extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
 302
 303/* appendix may either be NULL or be used for transname suffixes */
 304extern struct dentry * d_lookup(struct dentry *, struct qstr *);
 305extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
 306extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
 307
 308/* validate "insecure" dentry pointer */
 309extern int d_validate(struct dentry *, struct dentry *);
 310
 311/*
 312 * helper function for dentry_operations.d_dname() members
 313 */
 314extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 315
 316extern char *__d_path(const struct path *path, struct path *root, char *, int);
 317extern char *d_path(const struct path *, char *, int);
 318extern char *dentry_path(struct dentry *, char *, int);
 319
 320/* Allocation counts.. */
 321
 322/**
 323 *      dget, dget_locked       -       get a reference to a dentry
 324 *      @dentry: dentry to get a reference to
 325 *
 326 *      Given a dentry or %NULL pointer increment the reference count
 327 *      if appropriate and return the dentry. A dentry will not be 
 328 *      destroyed when it has references. dget() should never be
 329 *      called for dentries with zero reference counter. For these cases
 330 *      (preferably none, functions in dcache.c are sufficient for normal
 331 *      needs and they take necessary precautions) you should hold dcache_lock
 332 *      and call dget_locked() instead of dget().
 333 */
 334 
 335static inline struct dentry *dget(struct dentry *dentry)
 336{
 337        if (dentry) {
 338                BUG_ON(!atomic_read(&dentry->d_count));
 339                atomic_inc(&dentry->d_count);
 340        }
 341        return dentry;
 342}
 343
 344extern struct dentry * dget_locked(struct dentry *);
 345
 346/**
 347 *      d_unhashed -    is dentry hashed
 348 *      @dentry: entry to check
 349 *
 350 *      Returns true if the dentry passed is not currently hashed.
 351 */
 352 
 353static inline int d_unhashed(struct dentry *dentry)
 354{
 355        return (dentry->d_flags & DCACHE_UNHASHED);
 356}
 357
 358static inline int d_unlinked(struct dentry *dentry)
 359{
 360        return d_unhashed(dentry) && !IS_ROOT(dentry);
 361}
 362
 363static inline int cant_mount(struct dentry *dentry)
 364{
 365        return (dentry->d_flags & DCACHE_CANT_MOUNT);
 366}
 367
 368static inline void dont_mount(struct dentry *dentry)
 369{
 370        spin_lock(&dentry->d_lock);
 371        dentry->d_flags |= DCACHE_CANT_MOUNT;
 372        spin_unlock(&dentry->d_lock);
 373}
 374
 375static inline struct dentry *dget_parent(struct dentry *dentry)
 376{
 377        struct dentry *ret;
 378
 379        spin_lock(&dentry->d_lock);
 380        ret = dget(dentry->d_parent);
 381        spin_unlock(&dentry->d_lock);
 382        return ret;
 383}
 384
 385extern void dput(struct dentry *);
 386
 387static inline int d_mountpoint(struct dentry *dentry)
 388{
 389        return dentry->d_mounted;
 390}
 391
 392extern struct vfsmount *lookup_mnt(struct path *);
 393extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
 394
 395extern int sysctl_vfs_cache_pressure;
 396
 397#endif  /* __LINUX_DCACHE_H */
 398