LXR linux/fs/coda/cache.c

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