Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* NFS FS-Cache index structure definition
       3                 :            :  *
       4                 :            :  * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
       5                 :            :  * Written by David Howells (dhowells@redhat.com)
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/init.h>
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/sched.h>
      11                 :            : #include <linux/mm.h>
      12                 :            : #include <linux/nfs_fs.h>
      13                 :            : #include <linux/nfs_fs_sb.h>
      14                 :            : #include <linux/in6.h>
      15                 :            : #include <linux/iversion.h>
      16                 :            : 
      17                 :            : #include "internal.h"
      18                 :            : #include "fscache.h"
      19                 :            : 
      20                 :            : #define NFSDBG_FACILITY         NFSDBG_FSCACHE
      21                 :            : 
      22                 :            : /*
      23                 :            :  * Define the NFS filesystem for FS-Cache.  Upon registration FS-Cache sticks
      24                 :            :  * the cookie for the top-level index object for NFS into here.  The top-level
      25                 :            :  * index can than have other cache objects inserted into it.
      26                 :            :  */
      27                 :            : struct fscache_netfs nfs_fscache_netfs = {
      28                 :            :         .name           = "nfs",
      29                 :            :         .version        = 0,
      30                 :            : };
      31                 :            : 
      32                 :            : /*
      33                 :            :  * Register NFS for caching
      34                 :            :  */
      35                 :          3 : int nfs_fscache_register(void)
      36                 :            : {
      37                 :          3 :         return fscache_register_netfs(&nfs_fscache_netfs);
      38                 :            : }
      39                 :            : 
      40                 :            : /*
      41                 :            :  * Unregister NFS for caching
      42                 :            :  */
      43                 :          0 : void nfs_fscache_unregister(void)
      44                 :            : {
      45                 :            :         fscache_unregister_netfs(&nfs_fscache_netfs);
      46                 :          0 : }
      47                 :            : 
      48                 :            : /*
      49                 :            :  * Define the server object for FS-Cache.  This is used to describe a server
      50                 :            :  * object to fscache_acquire_cookie().  It is keyed by the NFS protocol and
      51                 :            :  * server address parameters.
      52                 :            :  */
      53                 :            : const struct fscache_cookie_def nfs_fscache_server_index_def = {
      54                 :            :         .name           = "NFS.server",
      55                 :            :         .type           = FSCACHE_COOKIE_TYPE_INDEX,
      56                 :            : };
      57                 :            : 
      58                 :            : /*
      59                 :            :  * Define the superblock object for FS-Cache.  This is used to describe a
      60                 :            :  * superblock object to fscache_acquire_cookie().  It is keyed by all the NFS
      61                 :            :  * parameters that might cause a separate superblock.
      62                 :            :  */
      63                 :            : const struct fscache_cookie_def nfs_fscache_super_index_def = {
      64                 :            :         .name           = "NFS.super",
      65                 :            :         .type           = FSCACHE_COOKIE_TYPE_INDEX,
      66                 :            : };
      67                 :            : 
      68                 :            : /*
      69                 :            :  * Consult the netfs about the state of an object
      70                 :            :  * - This function can be absent if the index carries no state data
      71                 :            :  * - The netfs data from the cookie being used as the target is
      72                 :            :  *   presented, as is the auxiliary data
      73                 :            :  */
      74                 :            : static
      75                 :          0 : enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data,
      76                 :            :                                                   const void *data,
      77                 :            :                                                   uint16_t datalen,
      78                 :            :                                                   loff_t object_size)
      79                 :            : {
      80                 :            :         struct nfs_fscache_inode_auxdata auxdata;
      81                 :            :         struct nfs_inode *nfsi = cookie_netfs_data;
      82                 :            : 
      83                 :          0 :         if (datalen != sizeof(auxdata))
      84                 :            :                 return FSCACHE_CHECKAUX_OBSOLETE;
      85                 :            : 
      86                 :          0 :         memset(&auxdata, 0, sizeof(auxdata));
      87                 :          0 :         auxdata.mtime_sec  = nfsi->vfs_inode.i_mtime.tv_sec;
      88                 :          0 :         auxdata.mtime_nsec = nfsi->vfs_inode.i_mtime.tv_nsec;
      89                 :          0 :         auxdata.ctime_sec  = nfsi->vfs_inode.i_ctime.tv_sec;
      90                 :          0 :         auxdata.ctime_nsec = nfsi->vfs_inode.i_ctime.tv_nsec;
      91                 :            : 
      92                 :          0 :         if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
      93                 :          0 :                 auxdata.change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
      94                 :            : 
      95                 :          0 :         if (memcmp(data, &auxdata, datalen) != 0)
      96                 :            :                 return FSCACHE_CHECKAUX_OBSOLETE;
      97                 :            : 
      98                 :          0 :         return FSCACHE_CHECKAUX_OKAY;
      99                 :            : }
     100                 :            : 
     101                 :            : /*
     102                 :            :  * Get an extra reference on a read context.
     103                 :            :  * - This function can be absent if the completion function doesn't require a
     104                 :            :  *   context.
     105                 :            :  * - The read context is passed back to NFS in the event that a data read on the
     106                 :            :  *   cache fails with EIO - in which case the server must be contacted to
     107                 :            :  *   retrieve the data, which requires the read context for security.
     108                 :            :  */
     109                 :          0 : static void nfs_fh_get_context(void *cookie_netfs_data, void *context)
     110                 :            : {
     111                 :          0 :         get_nfs_open_context(context);
     112                 :          0 : }
     113                 :            : 
     114                 :            : /*
     115                 :            :  * Release an extra reference on a read context.
     116                 :            :  * - This function can be absent if the completion function doesn't require a
     117                 :            :  *   context.
     118                 :            :  */
     119                 :          0 : static void nfs_fh_put_context(void *cookie_netfs_data, void *context)
     120                 :            : {
     121                 :          0 :         if (context)
     122                 :          0 :                 put_nfs_open_context(context);
     123                 :          0 : }
     124                 :            : 
     125                 :            : /*
     126                 :            :  * Define the inode object for FS-Cache.  This is used to describe an inode
     127                 :            :  * object to fscache_acquire_cookie().  It is keyed by the NFS file handle for
     128                 :            :  * an inode.
     129                 :            :  *
     130                 :            :  * Coherency is managed by comparing the copies of i_size, i_mtime and i_ctime
     131                 :            :  * held in the cache auxiliary data for the data storage object with those in
     132                 :            :  * the inode struct in memory.
     133                 :            :  */
     134                 :            : const struct fscache_cookie_def nfs_fscache_inode_object_def = {
     135                 :            :         .name           = "NFS.fh",
     136                 :            :         .type           = FSCACHE_COOKIE_TYPE_DATAFILE,
     137                 :            :         .check_aux      = nfs_fscache_inode_check_aux,
     138                 :            :         .get_context    = nfs_fh_get_context,
     139                 :            :         .put_context    = nfs_fh_put_context,
     140                 :            : };