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

fscache.h (4801B)

      1/* SPDX-License-Identifier: LGPL-2.1 */
      2/*
      3 *   CIFS filesystem cache interface definitions
      4 *
      5 *   Copyright (c) 2010 Novell, Inc.
      6 *   Authors(s): Suresh Jayaraman (sjayaraman@suse.de>
      7 *
      8 */
      9#ifndef _CIFS_FSCACHE_H
     10#define _CIFS_FSCACHE_H
     11
     12#include <linux/swap.h>
     13#include <linux/fscache.h>
     14
     15#include "cifsglob.h"
     16
     17/*
     18 * Coherency data attached to CIFS volume within the cache
     19 */
     20struct cifs_fscache_volume_coherency_data {
     21	__le64	resource_id;		/* unique server resource id */
     22	__le64	vol_create_time;
     23	__le32	vol_serial_number;
     24} __packed;
     25
     26/*
     27 * Coherency data attached to CIFS inode within the cache.
     28 */
     29struct cifs_fscache_inode_coherency_data {
     30	__le64 last_write_time_sec;
     31	__le64 last_change_time_sec;
     32	__le32 last_write_time_nsec;
     33	__le32 last_change_time_nsec;
     34};
     35
     36#ifdef CONFIG_CIFS_FSCACHE
     37
     38/*
     39 * fscache.c
     40 */
     41extern int cifs_fscache_get_super_cookie(struct cifs_tcon *);
     42extern void cifs_fscache_release_super_cookie(struct cifs_tcon *);
     43
     44extern void cifs_fscache_get_inode_cookie(struct inode *inode);
     45extern void cifs_fscache_release_inode_cookie(struct inode *);
     46extern void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update);
     47
     48static inline
     49void cifs_fscache_fill_coherency(struct inode *inode,
     50				 struct cifs_fscache_inode_coherency_data *cd)
     51{
     52	struct cifsInodeInfo *cifsi = CIFS_I(inode);
     53
     54	memset(cd, 0, sizeof(*cd));
     55	cd->last_write_time_sec   = cpu_to_le64(cifsi->netfs.inode.i_mtime.tv_sec);
     56	cd->last_write_time_nsec  = cpu_to_le32(cifsi->netfs.inode.i_mtime.tv_nsec);
     57	cd->last_change_time_sec  = cpu_to_le64(cifsi->netfs.inode.i_ctime.tv_sec);
     58	cd->last_change_time_nsec = cpu_to_le32(cifsi->netfs.inode.i_ctime.tv_nsec);
     59}
     60
     61
     62static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode)
     63{
     64	return netfs_i_cookie(&CIFS_I(inode)->netfs);
     65}
     66
     67static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)
     68{
     69	struct cifs_fscache_inode_coherency_data cd;
     70
     71	cifs_fscache_fill_coherency(inode, &cd);
     72	fscache_invalidate(cifs_inode_cookie(inode), &cd,
     73			   i_size_read(inode), flags);
     74}
     75
     76extern int __cifs_fscache_query_occupancy(struct inode *inode,
     77					  pgoff_t first, unsigned int nr_pages,
     78					  pgoff_t *_data_first,
     79					  unsigned int *_data_nr_pages);
     80
     81static inline int cifs_fscache_query_occupancy(struct inode *inode,
     82					       pgoff_t first, unsigned int nr_pages,
     83					       pgoff_t *_data_first,
     84					       unsigned int *_data_nr_pages)
     85{
     86	if (!cifs_inode_cookie(inode))
     87		return -ENOBUFS;
     88	return __cifs_fscache_query_occupancy(inode, first, nr_pages,
     89					      _data_first, _data_nr_pages);
     90}
     91
     92extern int __cifs_readpage_from_fscache(struct inode *pinode, struct page *ppage);
     93extern void __cifs_readpage_to_fscache(struct inode *pinode, struct page *ppage);
     94
     95
     96static inline int cifs_readpage_from_fscache(struct inode *inode,
     97					     struct page *page)
     98{
     99	if (cifs_inode_cookie(inode))
    100		return __cifs_readpage_from_fscache(inode, page);
    101	return -ENOBUFS;
    102}
    103
    104static inline void cifs_readpage_to_fscache(struct inode *inode,
    105					    struct page *page)
    106{
    107	if (cifs_inode_cookie(inode))
    108		__cifs_readpage_to_fscache(inode, page);
    109}
    110
    111static inline int cifs_fscache_release_page(struct page *page, gfp_t gfp)
    112{
    113	if (PageFsCache(page)) {
    114		if (current_is_kswapd() || !(gfp & __GFP_FS))
    115			return false;
    116		wait_on_page_fscache(page);
    117		fscache_note_page_release(cifs_inode_cookie(page->mapping->host));
    118	}
    119	return true;
    120}
    121
    122#else /* CONFIG_CIFS_FSCACHE */
    123static inline
    124void cifs_fscache_fill_coherency(struct inode *inode,
    125				 struct cifs_fscache_inode_coherency_data *cd)
    126{
    127}
    128
    129static inline int cifs_fscache_get_super_cookie(struct cifs_tcon *tcon) { return 0; }
    130static inline void cifs_fscache_release_super_cookie(struct cifs_tcon *tcon) {}
    131
    132static inline void cifs_fscache_get_inode_cookie(struct inode *inode) {}
    133static inline void cifs_fscache_release_inode_cookie(struct inode *inode) {}
    134static inline void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update) {}
    135static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode) { return NULL; }
    136static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags) {}
    137
    138static inline int cifs_fscache_query_occupancy(struct inode *inode,
    139					       pgoff_t first, unsigned int nr_pages,
    140					       pgoff_t *_data_first,
    141					       unsigned int *_data_nr_pages)
    142{
    143	*_data_first = ULONG_MAX;
    144	*_data_nr_pages = 0;
    145	return -ENOBUFS;
    146}
    147
    148static inline int
    149cifs_readpage_from_fscache(struct inode *inode, struct page *page)
    150{
    151	return -ENOBUFS;
    152}
    153
    154static inline
    155void cifs_readpage_to_fscache(struct inode *inode, struct page *page) {}
    156
    157static inline int nfs_fscache_release_page(struct page *page, gfp_t gfp)
    158{
    159	return true; /* May release page */
    160}
    161
    162#endif /* CONFIG_CIFS_FSCACHE */
    163
    164#endif /* _CIFS_FSCACHE_H */