cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

cache.c (3060B)

      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