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
 189extern spinlock_t dcache_lock;
 190extern 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
 208static 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
 216static 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
 225static 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 */
 233extern void d_instantiate(struct dentry *, struct inode *);
 234extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
 235extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
 236extern void d_delete(struct dentry *);
 237
 238/* allocate/de-allocate */
 239extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
 240extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
 241extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
 242extern struct dentry * d_obtain_alias(struct inode *);
 243extern void shrink_dcache_sb(struct super_block *);
 244extern void shrink_dcache_parent(struct dentry *);
 245extern void shrink_dcache_for_umount(struct super_block *);
 246extern int d_invalidate(struct dentry *);
 247
 248/* only used at mount-time */
 249extern struct dentry * d_alloc_root(struct inode *);
 250
 251/* <clickety>-<click> the ramfs-type tree */
 252extern void d_genocide(struct dentry *);
 253
 254extern struct dentry *d_find_alias(struct inode *);
 255extern void d_prune_aliases(struct inode *);
 256
 257/* test whether we have any submounts in a subdir tree */
 258extern int have_submounts(struct dentry *);
 259
 260/*
 261 * This adds the entry to the hash queues.
 262 */
 263extern 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 
 274static 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 */
 288static 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 */
 298extern void d_move(struct dentry *, struct dentry *);
 299extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
 300
 301/* appendix may either be NULL or be used for transname suffixes */
 302extern struct dentry * d_lookup(struct dentry *, struct qstr *);
 303extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
 304extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
 305
 306/* validate "insecure" dentry pointer */
 307extern int d_validate(struct dentry *, struct dentry *);
 308
 309/*
 310 * helper function for dentry_operations.d_dname() members
 311 */
 312extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 313
 314extern char *__d_path(const struct path *path, struct path *root, char *, int);
 315extern char *d_path(const struct path *, char *, int);
 316extern 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 
 333static 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
 342extern 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 
 351static inline int d_unhashed(struct dentry *dentry)
 352{
 353        return (dentry->d_flags & DCACHE_UNHASHED);
 354}
 355
 356static inline int d_unlinked(struct dentry *dentry)
 357{
 358        return d_unhashed(dentry) && !IS_ROOT(dentry);
 359}
 360
 361static 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
 371extern void dput(struct dentry *);
 372
 373static inline int d_mountpoint(struct dentry *dentry)
 374{
 375        return dentry->d_mounted;
 376}
 377
 378extern struct vfsmount *lookup_mnt(struct path *);
 379extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
 380
 381extern int sysctl_vfs_cache_pressure;
 382
 383#endif  /* __LINUX_DCACHE_H */
 384