fs/cifs/fscache.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *   CIFS filesystem cache interface
   4  *
   5  *   Copyright (c) 2010 Novell, Inc.
   6  *   Author(s): Suresh Jayaraman <sjayaraman@suse.de>
   7  *
   8  */
   9 #include "fscache.h"
  10 #include "cifsglob.h"
  11 #include "cifs_debug.h"
  12 #include "cifs_fs_sb.h"
  13 #include "cifsproto.h"
  14
  15 /*
  16  * Key layout of CIFS server cache index object
  17  */
  18 struct cifs_server_key {
  19         struct {
  20                 uint16_t        family;         /* address family */
  21                 __be16          port;           /* IP port */
  22         } hdr;
  23         union {
  24                 struct in_addr  ipv4_addr;
  25                 struct in6_addr ipv6_addr;
  26         };
  27 } __packed;
  28
  29 /*
  30  * Get a cookie for a server object keyed by {IPaddress,port,family} tuple
  31  */
  32 void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
  33 {
  34         const struct sockaddr *sa = (struct sockaddr *) &server->dstaddr;
  35         const struct sockaddr_in *addr = (struct sockaddr_in *) sa;
  36         const struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) sa;
  37         struct cifs_server_key key;
  38         uint16_t key_len = sizeof(key.hdr);
  39
  40         memset(&key, 0, sizeof(key));
  41
  42         /*
  43          * Should not be a problem as sin_family/sin6_family overlays
  44          * sa_family field
  45          */
  46         key.hdr.family = sa->sa_family;
  47         switch (sa->sa_family) {
  48         case AF_INET:
  49                 key.hdr.port = addr->sin_port;
  50                 key.ipv4_addr = addr->sin_addr;
  51                 key_len += sizeof(key.ipv4_addr);
  52                 break;
  53
  54         case AF_INET6:
  55                 key.hdr.port = addr6->sin6_port;
  56                 key.ipv6_addr = addr6->sin6_addr;
  57                 key_len += sizeof(key.ipv6_addr);
  58                 break;
  59
  60         default:
  61                 cifs_dbg(VFS, "Unknown network family '%d'\n", sa->sa_family);
  62                 server->fscache = NULL;
  63                 return;
  64         }
  65
  66         server->fscache =
  67                 fscache_acquire_cookie(cifs_fscache_netfs.primary_index,
  68                                        &cifs_fscache_server_index_def,
  69                                        &key, key_len,
  70                                        NULL, 0,
  71                                        server, 0, true);
  72         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
  73                  __func__, server, server->fscache);
  74 }
  75
  76 void cifs_fscache_release_client_cookie(struct TCP_Server_Info *server)
  77 {
  78         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
  79                  __func__, server, server->fscache);
  80         fscache_relinquish_cookie(server->fscache, NULL, false);
  81         server->fscache = NULL;
  82 }
  83
  84 void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon)
  85 {
  86         struct TCP_Server_Info *server = tcon->ses->server;
  87         char *sharename;
  88         struct cifs_fscache_super_auxdata auxdata;
  89
  90         /*
  91          * Check if cookie was already initialized so don't reinitialize it.
  92          * In the future, as we integrate with newer fscache features,
  93          * we may want to instead add a check if cookie has changed
  94          */
  95         if (tcon->fscache == NULL)
  96                 return;
  97
  98         sharename = extract_sharename(tcon->treeName);
  99         if (IS_ERR(sharename)) {
 100                 cifs_dbg(FYI, "%s: couldn't extract sharename\n", __func__);
 101                 tcon->fscache = NULL;
 102                 return;
 103         }
 104
 105         memset(&auxdata, 0, sizeof(auxdata));
 106         auxdata.resource_id = tcon->resource_id;
 107         auxdata.vol_create_time = tcon->vol_create_time;
 108         auxdata.vol_serial_number = tcon->vol_serial_number;
 109
 110         tcon->fscache =
 111                 fscache_acquire_cookie(server->fscache,
 112                                        &cifs_fscache_super_index_def,
 113                                        sharename, strlen(sharename),
 114                                        &auxdata, sizeof(auxdata),
 115                                        tcon, 0, true);
 116         kfree(sharename);
 117         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
 118                  __func__, server->fscache, tcon->fscache);
 119 }
 120
 121 void cifs_fscache_release_super_cookie(struct cifs_tcon *tcon)
 122 {
 123         struct cifs_fscache_super_auxdata auxdata;
 124
 125         memset(&auxdata, 0, sizeof(auxdata));
 126         auxdata.resource_id = tcon->resource_id;
 127         auxdata.vol_create_time = tcon->vol_create_time;
 128         auxdata.vol_serial_number = tcon->vol_serial_number;
 129
 130         cifs_dbg(FYI, "%s: (0x%p)\n", __func__, tcon->fscache);
 131         fscache_relinquish_cookie(tcon->fscache, &auxdata, false);
 132         tcon->fscache = NULL;
 133 }
 134
 135 static void cifs_fscache_acquire_inode_cookie(struct cifsInodeInfo *cifsi,
 136                                               struct cifs_tcon *tcon)
 137 {
 138         struct cifs_fscache_inode_auxdata auxdata;
 139
 140         memset(&auxdata, 0, sizeof(auxdata));
 141         auxdata.eof = cifsi->server_eof;
 142         auxdata.last_write_time_sec = cifsi->vfs_inode.i_mtime.tv_sec;
 143         auxdata.last_change_time_sec = cifsi->vfs_inode.i_ctime.tv_sec;
 144         auxdata.last_write_time_nsec = cifsi->vfs_inode.i_mtime.tv_nsec;
 145         auxdata.last_change_time_nsec = cifsi->vfs_inode.i_ctime.tv_nsec;
 146
 147         cifsi->fscache =
 148                 fscache_acquire_cookie(tcon->fscache,
 149                                        &cifs_fscache_inode_object_def,
 150                                        &cifsi->uniqueid, sizeof(cifsi->uniqueid),
 151                                        &auxdata, sizeof(auxdata),
 152                                        cifsi, cifsi->vfs_inode.i_size, true);
 153 }
 154
 155 static void cifs_fscache_enable_inode_cookie(struct inode *inode)
 156 {
 157         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 158         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 159         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 160
 161         if (cifsi->fscache)
 162                 return;
 163
 164         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE))
 165                 return;
 166
 167         cifs_fscache_acquire_inode_cookie(cifsi, tcon);
 168
 169         cifs_dbg(FYI, "%s: got FH cookie (0x%p/0x%p)\n",
 170                  __func__, tcon->fscache, cifsi->fscache);
 171 }
 172
 173 void cifs_fscache_release_inode_cookie(struct inode *inode)
 174 {
 175         struct cifs_fscache_inode_auxdata auxdata;
 176         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 177
 178         if (cifsi->fscache) {
 179                 memset(&auxdata, 0, sizeof(auxdata));
 180                 auxdata.eof = cifsi->server_eof;
 181                 auxdata.last_write_time_sec = cifsi->vfs_inode.i_mtime.tv_sec;
 182                 auxdata.last_change_time_sec = cifsi->vfs_inode.i_ctime.tv_sec;
 183                 auxdata.last_write_time_nsec = cifsi->vfs_inode.i_mtime.tv_nsec;
 184                 auxdata.last_change_time_nsec = cifsi->vfs_inode.i_ctime.tv_nsec;
 185
 186                 cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache);
 187                 /* fscache_relinquish_cookie does not seem to update auxdata */
 188                 fscache_update_cookie(cifsi->fscache, &auxdata);
 189                 fscache_relinquish_cookie(cifsi->fscache, &auxdata, false);
 190                 cifsi->fscache = NULL;
 191         }
 192 }
 193
 194 void cifs_fscache_update_inode_cookie(struct inode *inode)
 195 {
 196         struct cifs_fscache_inode_auxdata auxdata;
 197         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 198
 199         if (cifsi->fscache) {
 200                 memset(&auxdata, 0, sizeof(auxdata));
 201                 auxdata.eof = cifsi->server_eof;
 202                 auxdata.last_write_time_sec = cifsi->vfs_inode.i_mtime.tv_sec;
 203                 auxdata.last_change_time_sec = cifsi->vfs_inode.i_ctime.tv_sec;
 204                 auxdata.last_write_time_nsec = cifsi->vfs_inode.i_mtime.tv_nsec;
 205                 auxdata.last_change_time_nsec = cifsi->vfs_inode.i_ctime.tv_nsec;
 206
 207                 cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache);
 208                 fscache_update_cookie(cifsi->fscache, &auxdata);
 209         }
 210 }
 211
 212 void cifs_fscache_set_inode_cookie(struct inode *inode, struct file *filp)
 213 {
 214         cifs_fscache_enable_inode_cookie(inode);
 215 }
 216
 217 void cifs_fscache_reset_inode_cookie(struct inode *inode)
 218 {
 219         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 220         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 221         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 222         struct fscache_cookie *old = cifsi->fscache;
 223
 224         if (cifsi->fscache) {
 225                 /* retire the current fscache cache and get a new one */
 226                 fscache_relinquish_cookie(cifsi->fscache, NULL, true);
 227
 228                 cifs_fscache_acquire_inode_cookie(cifsi, tcon);
 229                 cifs_dbg(FYI, "%s: new cookie 0x%p oldcookie 0x%p\n",
 230                          __func__, cifsi->fscache, old);
 231         }
 232 }
 233
 234 int cifs_fscache_release_page(struct page *page, gfp_t gfp)
 235 {
 236         if (PageFsCache(page)) {
 237                 struct inode *inode = page->mapping->host;
 238                 struct cifsInodeInfo *cifsi = CIFS_I(inode);
 239
 240                 cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
 241                          __func__, page, cifsi->fscache);
 242                 if (!fscache_maybe_release_page(cifsi->fscache, page, gfp))
 243                         return 0;
 244         }
 245
 246         return 1;
 247 }
 248
 249 static void cifs_readpage_from_fscache_complete(struct page *page, void *ctx,
 250                                                 int error)
 251 {
 252         cifs_dbg(FYI, "%s: (0x%p/%d)\n", __func__, page, error);
 253         if (!error)
 254                 SetPageUptodate(page);
 255         unlock_page(page);
 256 }
 257
 258 /*
 259  * Retrieve a page from FS-Cache
 260  */
 261 int __cifs_readpage_from_fscache(struct inode *inode, struct page *page)
 262 {
 263         int ret;
 264
 265         cifs_dbg(FYI, "%s: (fsc:%p, p:%p, i:0x%p\n",
 266                  __func__, CIFS_I(inode)->fscache, page, inode);
 267         ret = fscache_read_or_alloc_page(CIFS_I(inode)->fscache, page,
 268                                          cifs_readpage_from_fscache_complete,
 269                                          NULL,
 270                                          GFP_KERNEL);
 271         switch (ret) {
 272
 273         case 0: /* page found in fscache, read submitted */
 274                 cifs_dbg(FYI, "%s: submitted\n", __func__);
 275                 return ret;
 276         case -ENOBUFS:  /* page won't be cached */
 277         case -ENODATA:  /* page not in cache */
 278                 cifs_dbg(FYI, "%s: %d\n", __func__, ret);
 279                 return 1;
 280
 281         default:
 282                 cifs_dbg(VFS, "unknown error ret = %d\n", ret);
 283         }
 284         return ret;
 285 }
 286
 287 /*
 288  * Retrieve a set of pages from FS-Cache
 289  */
 290 int __cifs_readpages_from_fscache(struct inode *inode,
 291                                 struct address_space *mapping,
 292                                 struct list_head *pages,
 293                                 unsigned *nr_pages)
 294 {
 295         int ret;
 296
 297         cifs_dbg(FYI, "%s: (0x%p/%u/0x%p)\n",
 298                  __func__, CIFS_I(inode)->fscache, *nr_pages, inode);
 299         ret = fscache_read_or_alloc_pages(CIFS_I(inode)->fscache, mapping,
 300                                           pages, nr_pages,
 301                                           cifs_readpage_from_fscache_complete,
 302                                           NULL,
 303                                           mapping_gfp_mask(mapping));
 304         switch (ret) {
 305         case 0: /* read submitted to the cache for all pages */
 306                 cifs_dbg(FYI, "%s: submitted\n", __func__);
 307                 return ret;
 308
 309         case -ENOBUFS:  /* some pages are not cached and can't be */
 310         case -ENODATA:  /* some pages are not cached */
 311                 cifs_dbg(FYI, "%s: no page\n", __func__);
 312                 return 1;
 313
 314         default:
 315                 cifs_dbg(FYI, "unknown error ret = %d\n", ret);
 316         }
 317
 318         return ret;
 319 }
 320
 321 void __cifs_readpage_to_fscache(struct inode *inode, struct page *page)
 322 {
 323         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 324         int ret;
 325
 326         WARN_ON(!cifsi->fscache);
 327
 328         cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n",
 329                  __func__, cifsi->fscache, page, inode);
 330         ret = fscache_write_page(cifsi->fscache, page,
 331                                  cifsi->vfs_inode.i_size, GFP_KERNEL);
 332         if (ret != 0)
 333                 fscache_uncache_page(cifsi->fscache, page);
 334 }
 335
 336 void __cifs_fscache_readpages_cancel(struct inode *inode, struct list_head *pages)
 337 {
 338         cifs_dbg(FYI, "%s: (fsc: %p, i: %p)\n",
 339                  __func__, CIFS_I(inode)->fscache, inode);
 340         fscache_readpages_cancel(CIFS_I(inode)->fscache, pages);
 341 }
 342
 343 void __cifs_fscache_invalidate_page(struct page *page, struct inode *inode)
 344 {
 345         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 346         struct fscache_cookie *cookie = cifsi->fscache;
 347
 348         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", __func__, page, cookie);
 349         fscache_wait_on_page_write(cookie, page);
 350         fscache_uncache_page(cookie, page);
 351 }
 352
 353 void __cifs_fscache_wait_on_page_write(struct inode *inode, struct page *page)
 354 {
 355         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 356         struct fscache_cookie *cookie = cifsi->fscache;
 357
 358         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", __func__, page, cookie);
 359         fscache_wait_on_page_write(cookie, page);
 360 }
 361
 362 void __cifs_fscache_uncache_page(struct inode *inode, struct page *page)
 363 {
 364         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 365         struct fscache_cookie *cookie = cifsi->fscache;
 366
 367         cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", __func__, page, cookie);
 368         fscache_uncache_page(cookie, page);
 369 }