fs/cifs/fscache.h

   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/fscache.h>
  13
  14 #include "cifsglob.h"
  15
  16 /*
  17  * Coherency data attached to CIFS volume within the cache
  18  */
  19 struct cifs_fscache_volume_coherency_data {
  20         __le64  resource_id;            /* unique server resource id */
  21         __le64  vol_create_time;
  22         __le32  vol_serial_number;
  23 } __packed;
  24
  25 /*
  26  * Coherency data attached to CIFS inode within the cache.
  27  */
  28 struct cifs_fscache_inode_coherency_data {
  29         __le64 last_write_time_sec;
  30         __le64 last_change_time_sec;
  31         __le32 last_write_time_nsec;
  32         __le32 last_change_time_nsec;
  33 };
  34
  35 #ifdef CONFIG_CIFS_FSCACHE
  36
  37 /*
  38  * fscache.c
  39  */
  40 extern int cifs_fscache_get_super_cookie(struct cifs_tcon *);
  41 extern void cifs_fscache_release_super_cookie(struct cifs_tcon *);
  42
  43 extern void cifs_fscache_get_inode_cookie(struct inode *inode);
  44 extern void cifs_fscache_release_inode_cookie(struct inode *);
  45 extern void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update);
  46
  47 static inline
  48 void cifs_fscache_fill_coherency(struct inode *inode,
  49                                  struct cifs_fscache_inode_coherency_data *cd)
  50 {
  51         struct cifsInodeInfo *cifsi = CIFS_I(inode);
  52
  53         memset(cd, 0, sizeof(*cd));
  54         cd->last_write_time_sec   = cpu_to_le64(cifsi->vfs_inode.i_mtime.tv_sec);
  55         cd->last_write_time_nsec  = cpu_to_le32(cifsi->vfs_inode.i_mtime.tv_nsec);
  56         cd->last_change_time_sec  = cpu_to_le64(cifsi->vfs_inode.i_ctime.tv_sec);
  57         cd->last_change_time_nsec = cpu_to_le32(cifsi->vfs_inode.i_ctime.tv_nsec);
  58 }
  59
  60
  61 extern int cifs_fscache_release_page(struct page *page, gfp_t gfp);
  62 extern int __cifs_readpage_from_fscache(struct inode *, struct page *);
  63 extern int __cifs_readpages_from_fscache(struct inode *,
  64                                          struct address_space *,
  65                                          struct list_head *,
  66                                          unsigned *);
  67 extern void __cifs_readpage_to_fscache(struct inode *, struct page *);
  68
  69 static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode)
  70 {
  71         return CIFS_I(inode)->fscache;
  72 }
  73
  74 static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)
  75 {
  76         struct cifs_fscache_inode_coherency_data cd;
  77
  78         cifs_fscache_fill_coherency(inode, &cd);
  79         fscache_invalidate(cifs_inode_cookie(inode), &cd,
  80                            i_size_read(inode), flags);
  81 }
  82
  83 static inline int cifs_readpage_from_fscache(struct inode *inode,
  84                                              struct page *page)
  85 {
  86         if (CIFS_I(inode)->fscache)
  87                 return __cifs_readpage_from_fscache(inode, page);
  88
  89         return -ENOBUFS;
  90 }
  91
  92 static inline int cifs_readpages_from_fscache(struct inode *inode,
  93                                               struct address_space *mapping,
  94                                               struct list_head *pages,
  95                                               unsigned *nr_pages)
  96 {
  97         if (CIFS_I(inode)->fscache)
  98                 return __cifs_readpages_from_fscache(inode, mapping, pages,
  99                                                      nr_pages);
 100         return -ENOBUFS;
 101 }
 102
 103 static inline void cifs_readpage_to_fscache(struct inode *inode,
 104                                             struct page *page)
 105 {
 106         if (PageFsCache(page))
 107                 __cifs_readpage_to_fscache(inode, page);
 108 }
 109
 110 #else /* CONFIG_CIFS_FSCACHE */
 111 static inline
 112 void cifs_fscache_fill_coherency(struct inode *inode,
 113                                  struct cifs_fscache_inode_coherency_data *cd)
 114 {
 115 }
 116
 117 static inline int cifs_fscache_get_super_cookie(struct cifs_tcon *tcon) { return 0; }
 118 static inline void cifs_fscache_release_super_cookie(struct cifs_tcon *tcon) {}
 119
 120 static inline void cifs_fscache_get_inode_cookie(struct inode *inode) {}
 121 static inline void cifs_fscache_release_inode_cookie(struct inode *inode) {}
 122 static inline void cifs_fscache_unuse_inode_cookie(struct inode *inode, bool update) {}
 123 static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode) { return NULL; }
 124 static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags) {}
 125
 126 static inline int
 127 cifs_readpage_from_fscache(struct inode *inode, struct page *page)
 128 {
 129         return -ENOBUFS;
 130 }
 131
 132 static inline int cifs_readpages_from_fscache(struct inode *inode,
 133                                               struct address_space *mapping,
 134                                               struct list_head *pages,
 135                                               unsigned *nr_pages)
 136 {
 137         return -ENOBUFS;
 138 }
 139
 140 static inline void cifs_readpage_to_fscache(struct inode *inode,
 141                         struct page *page) {}
 142
 143 #endif /* CONFIG_CIFS_FSCACHE */
 144
 145 #endif /* _CIFS_FSCACHE_H */