home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / dcache.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  10.0 KB  |  349 lines
  1. #ifndef __LINUX_DCACHE_H
  2. #define __LINUX_DCACHE_H
  3.  
  4. #ifdef __KERNEL__
  5.  
  6. #include <asm/atomic.h>
  7. #include <linux/list.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/cache.h>
  10. #include <linux/rcupdate.h>
  11.  
  12. struct nameidata;
  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.     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.     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.     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. struct dcookie_struct;
  79.  
  80. #define DNAME_INLINE_LEN_MIN 36
  81.  
  82. struct dentry {
  83.     atomic_t d_count;
  84.     unsigned int d_flags;        /* protected by d_lock */
  85.     spinlock_t d_lock;        /* per dentry lock */
  86.     struct inode *d_inode;        /* Where the name belongs to - NULL is
  87.                      * negative */
  88.     /*
  89.      * The next three fields are touched by __d_lookup.  Place them here
  90.      * so they all fit in a cache line.
  91.      */
  92.     struct hlist_node d_hash;    /* lookup hash list */
  93.     struct dentry *d_parent;    /* parent directory */
  94.     struct qstr d_name;
  95.  
  96.     struct list_head d_lru;        /* LRU list */
  97.     /*
  98.      * d_child and d_rcu can share memory
  99.      */
  100.     union {
  101.         struct list_head d_child;    /* child of parent list */
  102.          struct rcu_head d_rcu;
  103.     } d_u;
  104.     struct list_head d_subdirs;    /* our children */
  105.     struct list_head d_alias;    /* inode alias list */
  106.     unsigned long d_time;        /* used by d_revalidate */
  107.     struct dentry_operations *d_op;
  108.     struct super_block *d_sb;    /* The root of the dentry tree */
  109.     void *d_fsdata;            /* fs-specific data */
  110. #ifdef CONFIG_PROFILING
  111.     struct dcookie_struct *d_cookie; /* cookie, if any */
  112. #endif
  113.     int d_mounted;
  114.     unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
  115. };
  116.  
  117. struct dentry_operations {
  118.     int (*d_revalidate)(struct dentry *, struct nameidata *);
  119.     int (*d_hash) (struct dentry *, struct qstr *);
  120.     int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
  121.     int (*d_delete)(struct dentry *);
  122.     void (*d_release)(struct dentry *);
  123.     void (*d_iput)(struct dentry *, struct inode *);
  124. };
  125.  
  126. /* the dentry parameter passed to d_hash and d_compare is the parent
  127.  * directory of the entries to be compared. It is used in case these
  128.  * functions need any directory specific information for determining
  129.  * equivalency classes.  Using the dentry itself might not work, as it
  130.  * might be a negative dentry which has no information associated with
  131.  * it */
  132.  
  133. /*
  134. locking rules:
  135.         big lock    dcache_lock    d_lock   may block
  136. d_revalidate:    no        no        no       yes
  137. d_hash        no        no        no       yes
  138. d_compare:    no        yes        yes      no
  139. d_delete:    no        yes        no       no
  140. d_release:    no        no        no       yes
  141. d_iput:        no        no        no       yes
  142.  */
  143.  
  144. /* d_flags entries */
  145. #define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
  146. #define DCACHE_NFSFS_RENAMED  0x0002    /* this dentry has been "silly
  147.                      * renamed" and has to be
  148.                      * deleted on the last dput()
  149.                      */
  150. #define    DCACHE_DISCONNECTED 0x0004
  151.      /* This dentry is possibly not currently connected to the dcache tree,
  152.       * in which case its parent will either be itself, or will have this
  153.       * flag as well.  nfsd will not use a dentry with this bit set, but will
  154.       * first endeavour to clear the bit either by discovering that it is
  155.       * connected, or by performing lookup operations.   Any filesystem which
  156.       * supports nfsd_operations MUST have a lookup function which, if it finds
  157.       * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
  158.       * that dentry into place and return that dentry rather than the passed one,
  159.       * typically using d_splice_alias.
  160.       */
  161.  
  162. #define DCACHE_REFERENCED    0x0008  /* Recently used, don't discard. */
  163. #define DCACHE_UNHASHED        0x0010    
  164.  
  165. #define DCACHE_INOTIFY_PARENT_WATCHED    0x0020 /* Parent inode is watched */
  166.  
  167. extern spinlock_t dcache_lock;
  168.  
  169. /**
  170.  * d_drop - drop a dentry
  171.  * @dentry: dentry to drop
  172.  *
  173.  * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
  174.  * be found through a VFS lookup any more. Note that this is different from
  175.  * deleting the dentry - d_delete will try to mark the dentry negative if
  176.  * possible, giving a successful _negative_ lookup, while d_drop will
  177.  * just make the cache lookup fail.
  178.  *
  179.  * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
  180.  * reason (NFS timeouts or autofs deletes).
  181.  *
  182.  * __d_drop requires dentry->d_lock.
  183.  */
  184.  
  185. static inline void __d_drop(struct dentry *dentry)
  186. {
  187.     if (!(dentry->d_flags & DCACHE_UNHASHED)) {
  188.         dentry->d_flags |= DCACHE_UNHASHED;
  189.         hlist_del_rcu(&dentry->d_hash);
  190.     }
  191. }
  192.  
  193. static inline void d_drop(struct dentry *dentry)
  194. {
  195.     spin_lock(&dcache_lock);
  196.     spin_lock(&dentry->d_lock);
  197.      __d_drop(dentry);
  198.     spin_unlock(&dentry->d_lock);
  199.     spin_unlock(&dcache_lock);
  200. }
  201.  
  202. static inline int dname_external(struct dentry *dentry)
  203. {
  204.     return dentry->d_name.name != dentry->d_iname;
  205. }
  206.  
  207. /*
  208.  * These are the low-level FS interfaces to the dcache..
  209.  */
  210. extern void d_instantiate(struct dentry *, struct inode *);
  211. extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
  212. extern void d_delete(struct dentry *);
  213.  
  214. /* allocate/de-allocate */
  215. extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
  216. extern struct dentry * d_alloc_anon(struct inode *);
  217. extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
  218. extern void shrink_dcache_sb(struct super_block *);
  219. extern void shrink_dcache_parent(struct dentry *);
  220. extern void shrink_dcache_anon(struct hlist_head *);
  221. extern int d_invalidate(struct dentry *);
  222.  
  223. /* only used at mount-time */
  224. extern struct dentry * d_alloc_root(struct inode *);
  225.  
  226. /* <clickety>-<click> the ramfs-type tree */
  227. extern void d_genocide(struct dentry *);
  228.  
  229. extern struct dentry *d_find_alias(struct inode *);
  230. extern void d_prune_aliases(struct inode *);
  231.  
  232. /* test whether we have any submounts in a subdir tree */
  233. extern int have_submounts(struct dentry *);
  234.  
  235. /*
  236.  * This adds the entry to the hash queues.
  237.  */
  238. extern void d_rehash(struct dentry *);
  239.  
  240. /**
  241.  * d_add - add dentry to hash queues
  242.  * @entry: dentry to add
  243.  * @inode: The inode to attach to this dentry
  244.  *
  245.  * This adds the entry to the hash queues and initializes @inode.
  246.  * The entry was actually filled in earlier during d_alloc().
  247.  */
  248.  
  249. static inline void d_add(struct dentry *entry, struct inode *inode)
  250. {
  251.     d_instantiate(entry, inode);
  252.     d_rehash(entry);
  253. }
  254.  
  255. /**
  256.  * d_add_unique - add dentry to hash queues without aliasing
  257.  * @entry: dentry to add
  258.  * @inode: The inode to attach to this dentry
  259.  *
  260.  * This adds the entry to the hash queues and initializes @inode.
  261.  * The entry was actually filled in earlier during d_alloc().
  262.  */
  263. static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
  264. {
  265.     struct dentry *res;
  266.  
  267.     res = d_instantiate_unique(entry, inode);
  268.     d_rehash(res != NULL ? res : entry);
  269.     return res;
  270. }
  271.  
  272. /* used for rename() and baskets */
  273. extern void d_move(struct dentry *, struct dentry *);
  274.  
  275. /* appendix may either be NULL or be used for transname suffixes */
  276. extern struct dentry * d_lookup(struct dentry *, struct qstr *);
  277. extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
  278. extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
  279.  
  280. /* validate "insecure" dentry pointer */
  281. extern int d_validate(struct dentry *, struct dentry *);
  282.  
  283. extern char * d_path(struct dentry *, struct vfsmount *, char *, int);
  284.   
  285. /* Allocation counts.. */
  286.  
  287. /**
  288.  *    dget, dget_locked    -    get a reference to a dentry
  289.  *    @dentry: dentry to get a reference to
  290.  *
  291.  *    Given a dentry or %NULL pointer increment the reference count
  292.  *    if appropriate and return the dentry. A dentry will not be 
  293.  *    destroyed when it has references. dget() should never be
  294.  *    called for dentries with zero reference counter. For these cases
  295.  *    (preferably none, functions in dcache.c are sufficient for normal
  296.  *    needs and they take necessary precautions) you should hold dcache_lock
  297.  *    and call dget_locked() instead of dget().
  298.  */
  299.  
  300. static inline struct dentry *dget(struct dentry *dentry)
  301. {
  302.     if (dentry) {
  303.         BUG_ON(!atomic_read(&dentry->d_count));
  304.         atomic_inc(&dentry->d_count);
  305.     }
  306.     return dentry;
  307. }
  308.  
  309. extern struct dentry * dget_locked(struct dentry *);
  310.  
  311. /**
  312.  *    d_unhashed -    is dentry hashed
  313.  *    @dentry: entry to check
  314.  *
  315.  *    Returns true if the dentry passed is not currently hashed.
  316.  */
  317.  
  318. static inline int d_unhashed(struct dentry *dentry)
  319. {
  320.     return (dentry->d_flags & DCACHE_UNHASHED);
  321. }
  322.  
  323. static inline struct dentry *dget_parent(struct dentry *dentry)
  324. {
  325.     struct dentry *ret;
  326.  
  327.     spin_lock(&dentry->d_lock);
  328.     ret = dget(dentry->d_parent);
  329.     spin_unlock(&dentry->d_lock);
  330.     return ret;
  331. }
  332.  
  333. extern void dput(struct dentry *);
  334.  
  335. static inline int d_mountpoint(struct dentry *dentry)
  336. {
  337.     return dentry->d_mounted;
  338. }
  339.  
  340. extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
  341. extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
  342. extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
  343.  
  344. extern int sysctl_vfs_cache_pressure;
  345.  
  346. #endif /* __KERNEL__ */
  347.  
  348. #endif    /* __LINUX_DCACHE_H */
  349.