cache.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  * Cache operations for Coda.
    3  * For Linux 2.1: (C) 1997 Carnegie Mellon University
    4  * For Linux 2.3: (C) 2000 Carnegie Mellon University
    5  *
    6  * Carnegie Mellon encourages users of this code to contribute improvements
    7  * to the Coda project http://www.coda.cs.cmu.edu/ <coda@cs.cmu.edu>.
    8  */
    9 
   10 #include <linux/types.h>
   11 #include <linux/kernel.h>
   12 #include <linux/sched.h>
   13 #include <linux/fs.h>
   14 #include <linux/stat.h>
   15 #include <linux/errno.h>
   16 #include <linux/locks.h>
   17 #include <asm/uaccess.h>
   18 #include <linux/string.h>
   19 #include <linux/list.h>
   20 
   21 #include <linux/coda.h>
   22 #include <linux/coda_linux.h>
   23 #include <linux/coda_psdev.h>
   24 #include <linux/coda_fs_i.h>
   25 #include <linux/coda_cache.h>
   26 
   27 /* replace or extend an acl cache hit */
   28 void coda_cache_enter(struct inode *inode, int mask)
   29 {
   30         struct coda_inode_info *cii = ITOC(inode);
   31 
   32         if ( !coda_cred_ok(&cii->c_cached_cred) ) {
   33                 coda_load_creds(&cii->c_cached_cred);
   34                 cii->c_cached_perm = mask;
   35         } else
   36                 cii->c_cached_perm |= mask;
   37 }
   38 
   39 /* remove cached acl from an inode */
   40 void coda_cache_clear_inode(struct inode *inode)
   41 {
   42         struct coda_inode_info *cii = ITOC(inode);
   43         cii->c_cached_perm = 0;
   44 }
   45 
   46 /* remove all acl caches for a principal (or all principals when cred == NULL)*/
   47 void coda_cache_clear_all(struct super_block *sb, struct coda_cred *cred)
   48 {
   49         struct coda_sb_info *sbi;
   50         struct coda_inode_info *cii;
   51         struct list_head *tmp;
   52 
   53         sbi = coda_sbp(sb);
   54         if (!sbi) BUG();
   55 
   56         list_for_each(tmp, &sbi->sbi_cihead)
   57         {
   58                 cii = list_entry(tmp, struct coda_inode_info, c_cilist);
   59                 if (!cred || coda_cred_eq(cred, &cii->c_cached_cred))
   60                         cii->c_cached_perm = 0;
   61         }
   62 }
   63 
   64 
   65 /* check if the mask has been matched against the acl already */
   66 int coda_cache_check(struct inode *inode, int mask)
   67 {
   68         struct coda_inode_info *cii = ITOC(inode);
   69         int hit;
   70         
   71         hit = ((mask & cii->c_cached_perm) == mask) &&
   72                 coda_cred_ok(&cii->c_cached_cred);
   73 
   74         CDEBUG(D_CACHE, "%s for ino %ld\n", hit ? "HIT" : "MISS", inode->i_ino);
   75         return hit;
   76 }
   77 
   78 
   79 /* Purging dentries and children */
   80 /* The following routines drop dentries which are not
   81    in use and flag dentries which are in use to be 
   82    zapped later.
   83 
   84    The flags are detected by:
   85    - coda_dentry_revalidate (for lookups) if the flag is C_PURGE
   86    - coda_dentry_delete: to remove dentry from the cache when d_count
   87      falls to zero
   88    - an inode method coda_revalidate (for attributes) if the 
   89      flag is C_VATTR
   90 */
   91 
   92 /* this won't do any harm: just flag all children */
   93 static void coda_flag_children(struct dentry *parent, int flag)
   94 {
   95         struct list_head *child;
   96         struct dentry *de;
   97 
   98         spin_lock(&dcache_lock);
   99         list_for_each(child, &parent->d_subdirs)
  100         {
  101                 de = list_entry(child, struct dentry, d_child);
  102                 /* don't know what to do with negative dentries */
  103                 if ( ! de->d_inode ) 
  104                         continue;
  105                 CDEBUG(D_DOWNCALL, "%d for %*s/%*s\n", flag, 
  106                        de->d_name.len, de->d_name.name, 
  107                        de->d_parent->d_name.len, de->d_parent->d_name.name);
  108                 coda_flag_inode(de->d_inode, flag);
  109         }
  110         spin_unlock(&dcache_lock);
  111         return; 
  112 }
  113 
  114 void coda_flag_inode_children(struct inode *inode, int flag)
  115 {
  116         struct dentry *alias_de;
  117 
  118         if ( !inode || !S_ISDIR(inode->i_mode)) 
  119                 return; 
  120 
  121         alias_de = d_find_alias(inode);
  122         if (!alias_de)
  123                 return;
  124         coda_flag_children(alias_de, flag);
  125         shrink_dcache_parent(alias_de);
  126         dput(alias_de);
  127 }
  128

Cache object: 711ee06e2dcdfc6520481d1e621ee5ae

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/fs/coda/cache.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/coda/cache.c