1#ifndef __LINUX_DCACHE_H 2#define __LINUX_DCACHE_H 3 4#include <linux/atomic.h> 5#include <linux/list.h> 6#include <linux/rculist.h> 7#include <linux/rculist_bl.h> 8#include <linux/spinlock.h> 9#include <linux/seqlock.h> 10#include <linux/cache.h> 11#include <linux/rcupdate.h> 12#include <linux/lockref.h> 13 14struct path; 15struct vfsmount; 16 17/* 18 * linux/include/linux/dcache.h 19 * 20 * Dirent cache data structures 21 * 22 * (C) Copyright 1997 Thomas Schoebel-Theuer, 23 * with heavy changes by Linus Torvalds 24 */ 25 26#define IS_ROOT(x) ((x) == (x)->d_parent) 27 28/* The hash is always the low bits of hash_len */ 29#ifdef __LITTLE_ENDIAN 30 #define HASH_LEN_DECLARE u32 hash; u32 len; 31 #define bytemask_from_count(cnt) (~(~0ul << (cnt)*8)) 32#else 33 #define HASH_LEN_DECLARE u32 len; u32 hash; 34 #define bytemask_from_count(cnt) (~(~0ul >> (cnt)*8)) 35#endif 36 37/* 38 * "quick string" -- eases parameter passing, but more importantly 39 * saves "metadata" about the string (ie length and the hash). 40 * 41 * hash comes first so it snuggles against d_parent in the 42 * dentry. 43 */ 44struct qstr { 45 union { 46 struct { 47 HASH_LEN_DECLARE; 48 }; 49 u64 hash_len; 50 }; 51 const unsigned char *name; 52}; 53 54#define QSTR_INIT(n,l) { { { .len = l } }, .name = n } 55#define hashlen_hash(hashlen) ((u32) (hashlen)) 56#define hashlen_len(hashlen) ((u32)((hashlen) >> 32)) 57#define hashlen_create(hash,len) (((u64)(len)<<32)|(u32)(hash)) 58 59struct dentry_stat_t { 60 long nr_dentry; 61 long nr_unused; 62 long age_limit; /* age in seconds */ 63 long want_pages; /* pages requested by system */ 64 long dummy[2]; 65}; 66extern struct dentry_stat_t dentry_stat; 67 68/* Name hashing routines. Initial hash value */ 69/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */ 70#define init_name_hash() 0 71 72/* partial hash update function. Assume roughly 4 bits per character */ 73static inline unsigned long 74partial_name_hash(unsigned long c, unsigned long prevhash) 75{ 76 return (prevhash + (c << 4) + (c >> 4)) * 11; 77} 78 79/* 80 * Finally: cut down the number of bits to a int value (and try to avoid 81 * losing bits) 82 */ 83static inline unsigned long end_name_hash(unsigned long hash) 84{ 85 return (unsigned int) hash; 86} 87 88/* Compute the hash for a name string. */ 89extern unsigned int full_name_hash(const unsigned char *, unsigned int); 90 91/* 92 * Try to keep struct dentry aligned on 64 byte cachelines (this will 93 * give reasonable cacheline footprint with larger lines without the 94 * large memory footprint increase). 95 */ 96#ifdef CONFIG_64BIT 97# define DNAME_INLINE_LEN 32 /* 192 bytes */ 98#else 99# ifdef CONFIG_SMP 100# define DNAME_INLINE_LEN 36 /* 128 bytes */ 101# else 102# define DNAME_INLINE_LEN 40 /* 128 bytes */ 103# endif 104#endif 105 106#define d_lock d_lockref.lock 107 108struct dentry { 109 /* RCU lookup touched fields */ 110 unsigned int d_flags; /* protected by d_lock */ 111 seqcount_t d_seq; /* per dentry seqlock */ 112 struct hlist_bl_node d_hash; /* lookup hash list */ 113 struct dentry *d_parent; /* parent directory */ 114 struct qstr d_name; 115 struct inode *d_inode; /* Where the name belongs to - NULL is 116 * negative */ 117 unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */ 118 119 /* Ref lookup also touches following */ 120 struct lockref d_lockref; /* per-dentry lock and refcount */ 121 const struct dentry_operations *d_op; 122 struct super_block *d_sb; /* The root of the dentry tree */ 123 unsigned long d_time; /* used by d_revalidate */ 124 void *d_fsdata; /* fs-specific data */ 125 126 struct list_head d_lru; /* LRU list */ 127 struct list_head d_child; /* child of parent list */ 128 struct list_head d_subdirs; /* our children */ 129 /* 130 * d_alias and d_rcu can share memory 131 */ 132 union { 133 struct hlist_node d_alias; /* inode alias list */ 134 struct rcu_head d_rcu; 135 } d_u; 136}; 137 138/* 139 * dentry->d_lock spinlock nesting subclasses: 140 * 141 * 0: normal 142 * 1: nested 143 */ 144enum dentry_d_lock_class 145{ 146 DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */ 147 DENTRY_D_LOCK_NESTED 148}; 149 150struct dentry_operations { 151 int (*d_revalidate)(struct dentry *, unsigned int); 152 int (*d_weak_revalidate)(struct dentry *, unsigned int); 153 int (*d_hash)(const struct dentry *, struct qstr *); 154 int (*d_compare)(const struct dentry *, const struct dentry *, 155 unsigned int, const char *, const struct qstr *); 156 int (*d_delete)(const struct dentry *); 157 void (*d_release)(struct dentry *); 158 void (*d_prune)(struct dentry *); 159 void (*d_iput)(struct dentry *, struct inode *); 160 char *(*d_dname)(struct dentry *, char *, int); 161 struct vfsmount *(*d_automount)(struct path *); 162 int (*d_manage)(struct dentry *, bool); 163 struct inode *(*d_select_inode)(struct dentry *, unsigned); 164} ____cacheline_aligned; 165 166/* 167 * Locking rules for dentry_operations callbacks are to be found in 168 * Documentation/filesystems/Locking. Keep it updated! 169 * 170 * FUrther descriptions are found in Documentation/filesystems/vfs.txt. 171 * Keep it updated too! 172 */ 173 174/* d_flags entries */ 175#define DCACHE_OP_HASH 0x00000001 176#define DCACHE_OP_COMPARE 0x00000002 177#define DCACHE_OP_REVALIDATE 0x00000004 178#define DCACHE_OP_DELETE 0x00000008 179#define DCACHE_OP_PRUNE 0x00000010 180 181#define DCACHE_DISCONNECTED 0x00000020 182 /* This dentry is possibly not currently connected to the dcache tree, in 183 * which case its parent will either be itself, or will have this flag as 184 * well. nfsd will not use a dentry with this bit set, but will first 185 * endeavour to clear the bit either by discovering that it is connected, 186 * or by performing lookup operations. Any filesystem which supports 187 * nfsd_operations MUST have a lookup function which, if it finds a 188 * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that 189 * dentry into place and return that dentry rather than the passed one, 190 * typically using d_splice_alias. */ 191 192#define DCACHE_REFERENCED 0x00000040 /* Recently used, don't discard. */ 193#define DCACHE_RCUACCESS 0x00000080 /* Entry has ever been RCU-visible */ 194 195#define DCACHE_CANT_MOUNT 0x00000100 196#define DCACHE_GENOCIDE 0x00000200 197#define DCACHE_SHRINK_LIST 0x00000400 198 199#define DCACHE_OP_WEAK_REVALIDATE 0x00000800 200 201#define DCACHE_NFSFS_RENAMED 0x00001000 202 /* this dentry has been "silly renamed" and has to be deleted on the last 203 * dput() */ 204#define DCACHE_COOKIE 0x00002000 /* For use by dcookie subsystem */ 205#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000 206 /* Parent inode is watched by some fsnotify listener */ 207 208#define DCACHE_DENTRY_KILLED 0x00008000 209 210#define DCACHE_MOUNTED 0x00010000 /* is a mountpoint */ 211#define DCACHE_NEED_AUTOMOUNT 0x00020000 /* handle automount on this dir */ 212#define DCACHE_MANAGE_TRANSIT 0x00040000 /* manage transit from this dirent */ 213#define DCACHE_MANAGED_DENTRY \ 214 (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT) 215 216#define DCACHE_LRU_LIST 0x00080000 217 218#define DCACHE_ENTRY_TYPE 0x00700000 219#define DCACHE_MISS_TYPE 0x00000000 /* Negative dentry (maybe fallthru to nowhere) */ 220#define DCACHE_WHITEOUT_TYPE 0x00100000 /* Whiteout dentry (stop pathwalk) */ 221#define DCACHE_DIRECTORY_TYPE 0x00200000 /* Normal directory */ 222#define DCACHE_AUTODIR_TYPE 0x00300000 /* Lookupless directory (presumed automount) */ 223#define DCACHE_REGULAR_TYPE 0x00400000 /* Regular file type (or fallthru to such) */ 224#define DCACHE_SPECIAL_TYPE 0x00500000 /* Other file type (or fallthru to such) */ 225#define DCACHE_SYMLINK_TYPE 0x00600000 /* Symlink (or fallthru to such) */ 226 227#define DCACHE_MAY_FREE 0x00800000 228#define DCACHE_FALLTHRU 0x01000000 /* Fall through to lower layer */ 229#define DCACHE_OP_SELECT_INODE 0x02000000 /* Unioned entry: dcache op selects inode */ 230 231extern seqlock_t rename_lock; 232 233/* 234 * These are the low-level FS interfaces to the dcache.. 235 */ 236extern void d_instantiate(struct dentry *, struct inode *); 237extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *); 238extern int d_instantiate_no_diralias(struct dentry *, struct inode *); 239extern void __d_drop(struct dentry *dentry); 240extern void d_drop(struct dentry *dentry); 241extern void d_delete(struct dentry *); 242extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op); 243 244/* allocate/de-allocate */ 245extern struct dentry * d_alloc(struct dentry *, const struct qstr *); 246extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *); 247extern struct dentry * d_splice_alias(struct inode *, struct dentry *); 248extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *); 249extern struct dentry *d_find_any_alias(struct inode *inode); 250extern struct dentry * d_obtain_alias(struct inode *); 251extern struct dentry * d_obtain_root(struct inode *); 252extern void shrink_dcache_sb(struct super_block *); 253extern void shrink_dcache_parent(struct dentry *); 254extern void shrink_dcache_for_umount(struct super_block *); 255extern void d_invalidate(struct dentry *); 256 257/* only used at mount-time */ 258extern struct dentry * d_make_root(struct inode *); 259 260/* <clickety>-<click> the ramfs-type tree */ 261extern void d_genocide(struct dentry *); 262 263extern void d_tmpfile(struct dentry *, struct inode *); 264 265extern struct dentry *d_find_alias(struct inode *); 266extern void d_prune_aliases(struct inode *); 267 268/* test whether we have any submounts in a subdir tree */ 269extern int have_submounts(struct dentry *); 270 271/* 272 * This adds the entry to the hash queues. 273 */ 274extern void d_rehash(struct dentry *); 275 276/** 277 * d_add - add dentry to hash queues 278 * @entry: dentry to add 279 * @inode: The inode to attach to this dentry 280 * 281 * This adds the entry to the hash queues and initializes @inode. 282 * The entry was actually filled in earlier during d_alloc(). 283 */ 284 285static inline void d_add(struct dentry *entry, struct inode *inode) 286{ 287 d_instantiate(entry, inode); 288 d_rehash(entry); 289} 290 291/** 292 * d_add_unique - add dentry to hash queues without aliasing 293 * @entry: dentry to add 294 * @inode: The inode to attach to this dentry 295 * 296 * This adds the entry to the hash queues and initializes @inode. 297 * The entry was actually filled in earlier during d_alloc(). 298 */ 299static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode) 300{ 301 struct dentry *res; 302 303 res = d_instantiate_unique(entry, inode); 304 d_rehash(res != NULL ? res : entry); 305 return res; 306} 307 308extern void dentry_update_name_case(struct dentry *, struct qstr *); 309 310/* used for rename() and baskets */ 311extern void d_move(struct dentry *, struct dentry *); 312extern void d_exchange(struct dentry *, struct dentry *); 313extern struct dentry *d_ancestor(struct dentry *, struct dentry *); 314 315/* appendix may either be NULL or be used for transname suffixes */ 316extern struct dentry *d_lookup(const struct dentry *, const struct qstr *); 317extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *); 318extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *); 319extern struct dentry *__d_lookup_rcu(const struct dentry *parent, 320 const struct qstr *name, unsigned *seq); 321 322static inline unsigned d_count(const struct dentry *dentry) 323{ 324 return dentry->d_lockref.count; 325} 326 327/* 328 * helper function for dentry_operations.d_dname() members 329 */ 330extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...); 331extern char *simple_dname(struct dentry *, char *, int); 332 333extern char *__d_path(const struct path *, const struct path *, char *, int); 334extern char *d_absolute_path(const struct path *, char *, int); 335extern char *d_path(const struct path *, char *, int); 336extern char *dentry_path_raw(struct dentry *, char *, int); 337extern char *dentry_path(struct dentry *, char *, int); 338 339/* Allocation counts.. */ 340 341/** 342 * dget, dget_dlock - get a reference to a dentry 343 * @dentry: dentry to get a reference to 344 * 345 * Given a dentry or %NULL pointer increment the reference count 346 * if appropriate and return the dentry. A dentry will not be 347 * destroyed when it has references. 348 */ 349static inline struct dentry *dget_dlock(struct dentry *dentry) 350{ 351 if (dentry) 352 dentry->d_lockref.count++; 353 return dentry; 354} 355 356static inline struct dentry *dget(struct dentry *dentry) 357{ 358 if (dentry) 359 lockref_get(&dentry->d_lockref); 360 return dentry; 361} 362 363extern struct dentry *dget_parent(struct dentry *dentry); 364 365/** 366 * d_unhashed - is dentry hashed 367 * @dentry: entry to check 368 * 369 * Returns true if the dentry passed is not currently hashed. 370 */ 371 372static inline int d_unhashed(const struct dentry *dentry) 373{ 374 return hlist_bl_unhashed(&dentry->d_hash); 375} 376 377static inline int d_unlinked(const struct dentry *dentry) 378{ 379 return d_unhashed(dentry) && !IS_ROOT(dentry); 380} 381 382static inline int cant_mount(const struct dentry *dentry) 383{ 384 return (dentry->d_flags & DCACHE_CANT_MOUNT); 385} 386 387static inline void dont_mount(struct dentry *dentry) 388{ 389 spin_lock(&dentry->d_lock); 390 dentry->d_flags |= DCACHE_CANT_MOUNT; 391 spin_unlock(&dentry->d_lock); 392} 393 394extern void dput(struct dentry *); 395 396static inline bool d_managed(const struct dentry *dentry) 397{ 398 return dentry->d_flags & DCACHE_MANAGED_DENTRY; 399} 400 401static inline bool d_mountpoint(const struct dentry *dentry) 402{ 403 return dentry->d_flags & DCACHE_MOUNTED; 404} 405 406/* 407 * Directory cache entry type accessor functions. 408 */ 409static inline unsigned __d_entry_type(const struct dentry *dentry) 410{ 411 return dentry->d_flags & DCACHE_ENTRY_TYPE; 412} 413 414static inline bool d_is_miss(const struct dentry *dentry) 415{ 416 return __d_entry_type(dentry) == DCACHE_MISS_TYPE; 417} 418 419static inline bool d_is_whiteout(const struct dentry *dentry) 420{ 421 return __d_entry_type(dentry) == DCACHE_WHITEOUT_TYPE; 422} 423 424static inline bool d_can_lookup(const struct dentry *dentry) 425{ 426 return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE; 427} 428 429static inline bool d_is_autodir(const struct dentry *dentry) 430{ 431 return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE; 432} 433 434static inline bool d_is_dir(const struct dentry *dentry) 435{ 436 return d_can_lookup(dentry) || d_is_autodir(dentry); 437} 438 439static inline bool d_is_symlink(const struct dentry *dentry) 440{ 441 return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE; 442} 443 444static inline bool d_is_reg(const struct dentry *dentry) 445{ 446 return __d_entry_type(dentry) == DCACHE_REGULAR_TYPE; 447} 448 449static inline bool d_is_special(const struct dentry *dentry) 450{ 451 return __d_entry_type(dentry) == DCACHE_SPECIAL_TYPE; 452} 453 454static inline bool d_is_file(const struct dentry *dentry) 455{ 456 return d_is_reg(dentry) || d_is_special(dentry); 457} 458 459static inline bool d_is_negative(const struct dentry *dentry) 460{ 461 // TODO: check d_is_whiteout(dentry) also. 462 return d_is_miss(dentry); 463} 464 465static inline bool d_is_positive(const struct dentry *dentry) 466{ 467 return !d_is_negative(dentry); 468} 469 470/** 471 * d_really_is_negative - Determine if a dentry is really negative (ignoring fallthroughs) 472 * @dentry: The dentry in question 473 * 474 * Returns true if the dentry represents either an absent name or a name that 475 * doesn't map to an inode (ie. ->d_inode is NULL). The dentry could represent 476 * a true miss, a whiteout that isn't represented by a 0,0 chardev or a 477 * fallthrough marker in an opaque directory. 478 * 479 * Note! (1) This should be used *only* by a filesystem to examine its own 480 * dentries. It should not be used to look at some other filesystem's 481 * dentries. (2) It should also be used in combination with d_inode() to get 482 * the inode. (3) The dentry may have something attached to ->d_lower and the 483 * type field of the flags may be set to something other than miss or whiteout. 484 */ 485static inline bool d_really_is_negative(const struct dentry *dentry) 486{ 487 return dentry->d_inode == NULL; 488} 489 490/** 491 * d_really_is_positive - Determine if a dentry is really positive (ignoring fallthroughs) 492 * @dentry: The dentry in question 493 * 494 * Returns true if the dentry represents a name that maps to an inode 495 * (ie. ->d_inode is not NULL). The dentry might still represent a whiteout if 496 * that is represented on medium as a 0,0 chardev. 497 * 498 * Note! (1) This should be used *only* by a filesystem to examine its own 499 * dentries. It should not be used to look at some other filesystem's 500 * dentries. (2) It should also be used in combination with d_inode() to get 501 * the inode. 502 */ 503static inline bool d_really_is_positive(const struct dentry *dentry) 504{ 505 return dentry->d_inode != NULL; 506} 507 508extern void d_set_fallthru(struct dentry *dentry); 509 510static inline bool d_is_fallthru(const struct dentry *dentry) 511{ 512 return dentry->d_flags & DCACHE_FALLTHRU; 513} 514 515 516extern int sysctl_vfs_cache_pressure; 517 518static inline unsigned long vfs_pressure_ratio(unsigned long val) 519{ 520 return mult_frac(val, sysctl_vfs_cache_pressure, 100); 521} 522 523/** 524 * d_inode - Get the actual inode of this dentry 525 * @dentry: The dentry to query 526 * 527 * This is the helper normal filesystems should use to get at their own inodes 528 * in their own dentries and ignore the layering superimposed upon them. 529 */ 530static inline struct inode *d_inode(const struct dentry *dentry) 531{ 532 return dentry->d_inode; 533} 534 535/** 536 * d_inode_rcu - Get the actual inode of this dentry with ACCESS_ONCE() 537 * @dentry: The dentry to query 538 * 539 * This is the helper normal filesystems should use to get at their own inodes 540 * in their own dentries and ignore the layering superimposed upon them. 541 */ 542static inline struct inode *d_inode_rcu(const struct dentry *dentry) 543{ 544 return ACCESS_ONCE(dentry->d_inode); 545} 546 547/** 548 * d_backing_inode - Get upper or lower inode we should be using 549 * @upper: The upper layer 550 * 551 * This is the helper that should be used to get at the inode that will be used 552 * if this dentry were to be opened as a file. The inode may be on the upper 553 * dentry or it may be on a lower dentry pinned by the upper. 554 * 555 * Normal filesystems should not use this to access their own inodes. 556 */ 557static inline struct inode *d_backing_inode(const struct dentry *upper) 558{ 559 struct inode *inode = upper->d_inode; 560 561 return inode; 562} 563 564/** 565 * d_backing_dentry - Get upper or lower dentry we should be using 566 * @upper: The upper layer 567 * 568 * This is the helper that should be used to get the dentry of the inode that 569 * will be used if this dentry were opened as a file. It may be the upper 570 * dentry or it may be a lower dentry pinned by the upper. 571 * 572 * Normal filesystems should not use this to access their own dentries. 573 */ 574static inline struct dentry *d_backing_dentry(struct dentry *upper) 575{ 576 return upper; 577} 578 579#endif /* __LINUX_DCACHE_H */ 580