LCOV - code coverage report
Current view: top level - fs/nfs - proc.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 243 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 33 0.0 %
Branches: 0 66 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/fs/nfs/proc.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
       6                 :            :  *
       7                 :            :  *  OS-independent nfs remote procedure call functions
       8                 :            :  *
       9                 :            :  *  Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
      10                 :            :  *  so at last we can have decent(ish) throughput off a 
      11                 :            :  *  Sun server.
      12                 :            :  *
      13                 :            :  *  Coding optimized and cleaned up by Florian La Roche.
      14                 :            :  *  Note: Error returns are optimized for NFS_OK, which isn't translated via
      15                 :            :  *  nfs_stat_to_errno(), but happens to be already the right return code.
      16                 :            :  *
      17                 :            :  *  Also, the code currently doesn't check the size of the packet, when
      18                 :            :  *  it decodes the packet.
      19                 :            :  *
      20                 :            :  *  Feel free to fix it and mail me the diffs if it worries you.
      21                 :            :  *
      22                 :            :  *  Completely rewritten to support the new RPC call interface;
      23                 :            :  *  rewrote and moved the entire XDR stuff to xdr.c
      24                 :            :  *  --Olaf Kirch June 1996
      25                 :            :  *
      26                 :            :  *  The code below initializes all auto variables explicitly, otherwise
      27                 :            :  *  it will fail to work as a module (gcc generates a memset call for an
      28                 :            :  *  incomplete struct).
      29                 :            :  */
      30                 :            : 
      31                 :            : #include <linux/types.h>
      32                 :            : #include <linux/param.h>
      33                 :            : #include <linux/time.h>
      34                 :            : #include <linux/mm.h>
      35                 :            : #include <linux/errno.h>
      36                 :            : #include <linux/string.h>
      37                 :            : #include <linux/in.h>
      38                 :            : #include <linux/pagemap.h>
      39                 :            : #include <linux/sunrpc/clnt.h>
      40                 :            : #include <linux/nfs.h>
      41                 :            : #include <linux/nfs2.h>
      42                 :            : #include <linux/nfs_fs.h>
      43                 :            : #include <linux/nfs_page.h>
      44                 :            : #include <linux/lockd/bind.h>
      45                 :            : #include <linux/freezer.h>
      46                 :            : #include "internal.h"
      47                 :            : 
      48                 :            : #define NFSDBG_FACILITY         NFSDBG_PROC
      49                 :            : 
      50                 :            : /*
      51                 :            :  * Bare-bones access to getattr: this is for nfs_read_super.
      52                 :            :  */
      53                 :            : static int
      54                 :          0 : nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
      55                 :            :                   struct nfs_fsinfo *info)
      56                 :            : {
      57                 :          0 :         struct nfs_fattr *fattr = info->fattr;
      58                 :            :         struct nfs2_fsstat fsinfo;
      59                 :          0 :         struct rpc_message msg = {
      60                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
      61                 :            :                 .rpc_argp       = fhandle,
      62                 :            :                 .rpc_resp       = fattr,
      63                 :            :         };
      64                 :            :         int status;
      65                 :            : 
      66                 :            :         dprintk("%s: call getattr\n", __func__);
      67                 :          0 :         nfs_fattr_init(fattr);
      68                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
      69                 :            :         /* Retry with default authentication if different */
      70   [ #  #  #  # ]:          0 :         if (status && server->nfs_client->cl_rpcclient != server->client)
      71                 :          0 :                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
      72                 :            :         dprintk("%s: reply getattr: %d\n", __func__, status);
      73         [ #  # ]:          0 :         if (status)
      74                 :            :                 return status;
      75                 :            :         dprintk("%s: call statfs\n", __func__);
      76                 :          0 :         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
      77                 :          0 :         msg.rpc_resp = &fsinfo;
      78                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
      79                 :            :         /* Retry with default authentication if different */
      80   [ #  #  #  # ]:          0 :         if (status && server->nfs_client->cl_rpcclient != server->client)
      81                 :          0 :                 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
      82                 :            :         dprintk("%s: reply statfs: %d\n", __func__, status);
      83         [ #  # ]:          0 :         if (status)
      84                 :            :                 return status;
      85                 :          0 :         info->rtmax  = NFS_MAXDATA;
      86                 :          0 :         info->rtpref = fsinfo.tsize;
      87                 :          0 :         info->rtmult = fsinfo.bsize;
      88                 :          0 :         info->wtmax  = NFS_MAXDATA;
      89                 :          0 :         info->wtpref = fsinfo.tsize;
      90                 :          0 :         info->wtmult = fsinfo.bsize;
      91                 :          0 :         info->dtpref = fsinfo.tsize;
      92                 :          0 :         info->maxfilesize = 0x7FFFFFFF;
      93                 :          0 :         info->lease_time = 0;
      94                 :          0 :         return 0;
      95                 :            : }
      96                 :            : 
      97                 :            : /*
      98                 :            :  * One function for each procedure in the NFS protocol.
      99                 :            :  */
     100                 :            : static int
     101                 :          0 : nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
     102                 :            :                 struct nfs_fattr *fattr, struct nfs4_label *label,
     103                 :            :                 struct inode *inode)
     104                 :            : {
     105                 :          0 :         struct rpc_message msg = {
     106                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_GETATTR],
     107                 :            :                 .rpc_argp       = fhandle,
     108                 :            :                 .rpc_resp       = fattr,
     109                 :            :         };
     110                 :            :         int     status;
     111                 :            : 
     112                 :            :         dprintk("NFS call  getattr\n");
     113                 :          0 :         nfs_fattr_init(fattr);
     114                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     115                 :            :         dprintk("NFS reply getattr: %d\n", status);
     116                 :          0 :         return status;
     117                 :            : }
     118                 :            : 
     119                 :            : static int
     120                 :          0 : nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
     121                 :            :                  struct iattr *sattr)
     122                 :            : {
     123                 :            :         struct inode *inode = d_inode(dentry);
     124                 :          0 :         struct nfs_sattrargs    arg = { 
     125                 :            :                 .fh     = NFS_FH(inode),
     126                 :            :                 .sattr  = sattr
     127                 :            :         };
     128                 :          0 :         struct rpc_message msg = {
     129                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_SETATTR],
     130                 :            :                 .rpc_argp       = &arg,
     131                 :            :                 .rpc_resp       = fattr,
     132                 :            :         };
     133                 :            :         int     status;
     134                 :            : 
     135                 :            :         /* Mask out the non-modebit related stuff from attr->ia_mode */
     136                 :          0 :         sattr->ia_mode &= S_IALLUGO;
     137                 :            : 
     138                 :            :         dprintk("NFS call  setattr\n");
     139         [ #  # ]:          0 :         if (sattr->ia_valid & ATTR_FILE)
     140                 :          0 :                 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
     141                 :          0 :         nfs_fattr_init(fattr);
     142                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     143         [ #  # ]:          0 :         if (status == 0)
     144                 :          0 :                 nfs_setattr_update_inode(inode, sattr, fattr);
     145                 :            :         dprintk("NFS reply setattr: %d\n", status);
     146                 :          0 :         return status;
     147                 :            : }
     148                 :            : 
     149                 :            : static int
     150                 :          0 : nfs_proc_lookup(struct inode *dir, const struct qstr *name,
     151                 :            :                 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
     152                 :            :                 struct nfs4_label *label)
     153                 :            : {
     154                 :          0 :         struct nfs_diropargs    arg = {
     155                 :            :                 .fh             = NFS_FH(dir),
     156                 :          0 :                 .name           = name->name,
     157                 :          0 :                 .len            = name->len
     158                 :            :         };
     159                 :          0 :         struct nfs_diropok      res = {
     160                 :            :                 .fh             = fhandle,
     161                 :            :                 .fattr          = fattr
     162                 :            :         };
     163                 :          0 :         struct rpc_message msg = {
     164                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_LOOKUP],
     165                 :            :                 .rpc_argp       = &arg,
     166                 :            :                 .rpc_resp       = &res,
     167                 :            :         };
     168                 :            :         int                     status;
     169                 :            : 
     170                 :            :         dprintk("NFS call  lookup %s\n", name->name);
     171                 :          0 :         nfs_fattr_init(fattr);
     172                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     173                 :            :         dprintk("NFS reply lookup: %d\n", status);
     174                 :          0 :         return status;
     175                 :            : }
     176                 :            : 
     177                 :          0 : static int nfs_proc_readlink(struct inode *inode, struct page *page,
     178                 :            :                 unsigned int pgbase, unsigned int pglen)
     179                 :            : {
     180                 :          0 :         struct nfs_readlinkargs args = {
     181                 :            :                 .fh             = NFS_FH(inode),
     182                 :            :                 .pgbase         = pgbase,
     183                 :            :                 .pglen          = pglen,
     184                 :            :                 .pages          = &page
     185                 :            :         };
     186                 :          0 :         struct rpc_message msg = {
     187                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_READLINK],
     188                 :            :                 .rpc_argp       = &args,
     189                 :            :         };
     190                 :            :         int                     status;
     191                 :            : 
     192                 :            :         dprintk("NFS call  readlink\n");
     193                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     194                 :            :         dprintk("NFS reply readlink: %d\n", status);
     195                 :          0 :         return status;
     196                 :            : }
     197                 :            : 
     198                 :            : struct nfs_createdata {
     199                 :            :         struct nfs_createargs arg;
     200                 :            :         struct nfs_diropok res;
     201                 :            :         struct nfs_fh fhandle;
     202                 :            :         struct nfs_fattr fattr;
     203                 :            : };
     204                 :            : 
     205                 :          0 : static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
     206                 :            :                 struct dentry *dentry, struct iattr *sattr)
     207                 :            : {
     208                 :            :         struct nfs_createdata *data;
     209                 :            : 
     210                 :            :         data = kmalloc(sizeof(*data), GFP_KERNEL);
     211                 :            : 
     212         [ #  # ]:          0 :         if (data != NULL) {
     213                 :          0 :                 data->arg.fh = NFS_FH(dir);
     214                 :          0 :                 data->arg.name = dentry->d_name.name;
     215                 :          0 :                 data->arg.len = dentry->d_name.len;
     216                 :          0 :                 data->arg.sattr = sattr;
     217                 :          0 :                 nfs_fattr_init(&data->fattr);
     218                 :          0 :                 data->fhandle.size = 0;
     219                 :          0 :                 data->res.fh = &data->fhandle;
     220                 :          0 :                 data->res.fattr = &data->fattr;
     221                 :            :         }
     222                 :          0 :         return data;
     223                 :            : };
     224                 :            : 
     225                 :            : static void nfs_free_createdata(const struct nfs_createdata *data)
     226                 :            : {
     227                 :          0 :         kfree(data);
     228                 :            : }
     229                 :            : 
     230                 :            : static int
     231                 :          0 : nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
     232                 :            :                 int flags)
     233                 :            : {
     234                 :            :         struct nfs_createdata *data;
     235                 :          0 :         struct rpc_message msg = {
     236                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
     237                 :            :         };
     238                 :            :         int status = -ENOMEM;
     239                 :            : 
     240                 :            :         dprintk("NFS call  create %pd\n", dentry);
     241                 :          0 :         data = nfs_alloc_createdata(dir, dentry, sattr);
     242         [ #  # ]:          0 :         if (data == NULL)
     243                 :            :                 goto out;
     244                 :          0 :         msg.rpc_argp = &data->arg;
     245                 :          0 :         msg.rpc_resp = &data->res;
     246                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     247                 :          0 :         nfs_mark_for_revalidate(dir);
     248         [ #  # ]:          0 :         if (status == 0)
     249                 :          0 :                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
     250                 :            :         nfs_free_createdata(data);
     251                 :            : out:
     252                 :            :         dprintk("NFS reply create: %d\n", status);
     253                 :          0 :         return status;
     254                 :            : }
     255                 :            : 
     256                 :            : /*
     257                 :            :  * In NFSv2, mknod is grafted onto the create call.
     258                 :            :  */
     259                 :            : static int
     260                 :          0 : nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
     261                 :            :                dev_t rdev)
     262                 :            : {
     263                 :            :         struct nfs_createdata *data;
     264                 :          0 :         struct rpc_message msg = {
     265                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_CREATE],
     266                 :            :         };
     267                 :            :         umode_t mode;
     268                 :            :         int status = -ENOMEM;
     269                 :            : 
     270                 :            :         dprintk("NFS call  mknod %pd\n", dentry);
     271                 :            : 
     272                 :          0 :         mode = sattr->ia_mode;
     273         [ #  # ]:          0 :         if (S_ISFIFO(mode)) {
     274                 :          0 :                 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
     275                 :          0 :                 sattr->ia_valid &= ~ATTR_SIZE;
     276         [ #  # ]:          0 :         } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
     277                 :          0 :                 sattr->ia_valid |= ATTR_SIZE;
     278                 :          0 :                 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
     279                 :            :         }
     280                 :            : 
     281                 :          0 :         data = nfs_alloc_createdata(dir, dentry, sattr);
     282         [ #  # ]:          0 :         if (data == NULL)
     283                 :            :                 goto out;
     284                 :          0 :         msg.rpc_argp = &data->arg;
     285                 :          0 :         msg.rpc_resp = &data->res;
     286                 :            : 
     287                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     288                 :          0 :         nfs_mark_for_revalidate(dir);
     289                 :            : 
     290   [ #  #  #  # ]:          0 :         if (status == -EINVAL && S_ISFIFO(mode)) {
     291                 :          0 :                 sattr->ia_mode = mode;
     292                 :          0 :                 nfs_fattr_init(data->res.fattr);
     293                 :          0 :                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     294                 :            :         }
     295         [ #  # ]:          0 :         if (status == 0)
     296                 :          0 :                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
     297                 :            :         nfs_free_createdata(data);
     298                 :            : out:
     299                 :            :         dprintk("NFS reply mknod: %d\n", status);
     300                 :          0 :         return status;
     301                 :            : }
     302                 :            :   
     303                 :            : static int
     304                 :          0 : nfs_proc_remove(struct inode *dir, struct dentry *dentry)
     305                 :            : {
     306                 :          0 :         struct nfs_removeargs arg = {
     307                 :            :                 .fh = NFS_FH(dir),
     308                 :            :                 .name = dentry->d_name,
     309                 :            :         };
     310                 :          0 :         struct rpc_message msg = { 
     311                 :            :                 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
     312                 :            :                 .rpc_argp = &arg,
     313                 :            :         };
     314                 :            :         int                     status;
     315                 :            : 
     316                 :            :         dprintk("NFS call  remove %pd2\n",dentry);
     317                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     318                 :          0 :         nfs_mark_for_revalidate(dir);
     319                 :            : 
     320                 :            :         dprintk("NFS reply remove: %d\n", status);
     321                 :          0 :         return status;
     322                 :            : }
     323                 :            : 
     324                 :            : static void
     325                 :          0 : nfs_proc_unlink_setup(struct rpc_message *msg,
     326                 :            :                 struct dentry *dentry,
     327                 :            :                 struct inode *inode)
     328                 :            : {
     329                 :          0 :         msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
     330                 :          0 : }
     331                 :            : 
     332                 :          0 : static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
     333                 :            : {
     334                 :          0 :         rpc_call_start(task);
     335                 :          0 : }
     336                 :            : 
     337                 :          0 : static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
     338                 :            : {
     339                 :          0 :         nfs_mark_for_revalidate(dir);
     340                 :          0 :         return 1;
     341                 :            : }
     342                 :            : 
     343                 :            : static void
     344                 :          0 : nfs_proc_rename_setup(struct rpc_message *msg,
     345                 :            :                 struct dentry *old_dentry,
     346                 :            :                 struct dentry *new_dentry)
     347                 :            : {
     348                 :          0 :         msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
     349                 :          0 : }
     350                 :            : 
     351                 :          0 : static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
     352                 :            : {
     353                 :          0 :         rpc_call_start(task);
     354                 :          0 : }
     355                 :            : 
     356                 :            : static int
     357                 :          0 : nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
     358                 :            :                      struct inode *new_dir)
     359                 :            : {
     360                 :          0 :         nfs_mark_for_revalidate(old_dir);
     361                 :          0 :         nfs_mark_for_revalidate(new_dir);
     362                 :          0 :         return 1;
     363                 :            : }
     364                 :            : 
     365                 :            : static int
     366                 :          0 : nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
     367                 :            : {
     368                 :          0 :         struct nfs_linkargs     arg = {
     369                 :            :                 .fromfh         = NFS_FH(inode),
     370                 :            :                 .tofh           = NFS_FH(dir),
     371                 :          0 :                 .toname         = name->name,
     372                 :          0 :                 .tolen          = name->len
     373                 :            :         };
     374                 :          0 :         struct rpc_message msg = {
     375                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_LINK],
     376                 :            :                 .rpc_argp       = &arg,
     377                 :            :         };
     378                 :            :         int                     status;
     379                 :            : 
     380                 :            :         dprintk("NFS call  link %s\n", name->name);
     381                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     382                 :          0 :         nfs_mark_for_revalidate(inode);
     383                 :          0 :         nfs_mark_for_revalidate(dir);
     384                 :            :         dprintk("NFS reply link: %d\n", status);
     385                 :          0 :         return status;
     386                 :            : }
     387                 :            : 
     388                 :            : static int
     389                 :          0 : nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
     390                 :            :                  unsigned int len, struct iattr *sattr)
     391                 :            : {
     392                 :            :         struct nfs_fh *fh;
     393                 :            :         struct nfs_fattr *fattr;
     394                 :          0 :         struct nfs_symlinkargs  arg = {
     395                 :            :                 .fromfh         = NFS_FH(dir),
     396                 :          0 :                 .fromname       = dentry->d_name.name,
     397                 :          0 :                 .fromlen        = dentry->d_name.len,
     398                 :            :                 .pages          = &page,
     399                 :            :                 .pathlen        = len,
     400                 :            :                 .sattr          = sattr
     401                 :            :         };
     402                 :          0 :         struct rpc_message msg = {
     403                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_SYMLINK],
     404                 :            :                 .rpc_argp       = &arg,
     405                 :            :         };
     406                 :            :         int status = -ENAMETOOLONG;
     407                 :            : 
     408                 :            :         dprintk("NFS call  symlink %pd\n", dentry);
     409                 :            : 
     410         [ #  # ]:          0 :         if (len > NFS2_MAXPATHLEN)
     411                 :            :                 goto out;
     412                 :            : 
     413                 :          0 :         fh = nfs_alloc_fhandle();
     414                 :          0 :         fattr = nfs_alloc_fattr();
     415                 :            :         status = -ENOMEM;
     416         [ #  # ]:          0 :         if (fh == NULL || fattr == NULL)
     417                 :            :                 goto out_free;
     418                 :            : 
     419                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     420                 :          0 :         nfs_mark_for_revalidate(dir);
     421                 :            : 
     422                 :            :         /*
     423                 :            :          * V2 SYMLINK requests don't return any attributes.  Setting the
     424                 :            :          * filehandle size to zero indicates to nfs_instantiate that it
     425                 :            :          * should fill in the data with a LOOKUP call on the wire.
     426                 :            :          */
     427         [ #  # ]:          0 :         if (status == 0)
     428                 :          0 :                 status = nfs_instantiate(dentry, fh, fattr, NULL);
     429                 :            : 
     430                 :            : out_free:
     431                 :            :         nfs_free_fattr(fattr);
     432                 :            :         nfs_free_fhandle(fh);
     433                 :            : out:
     434                 :            :         dprintk("NFS reply symlink: %d\n", status);
     435                 :          0 :         return status;
     436                 :            : }
     437                 :            : 
     438                 :            : static int
     439                 :          0 : nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
     440                 :            : {
     441                 :            :         struct nfs_createdata *data;
     442                 :          0 :         struct rpc_message msg = {
     443                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_MKDIR],
     444                 :            :         };
     445                 :            :         int status = -ENOMEM;
     446                 :            : 
     447                 :            :         dprintk("NFS call  mkdir %pd\n", dentry);
     448                 :          0 :         data = nfs_alloc_createdata(dir, dentry, sattr);
     449         [ #  # ]:          0 :         if (data == NULL)
     450                 :            :                 goto out;
     451                 :          0 :         msg.rpc_argp = &data->arg;
     452                 :          0 :         msg.rpc_resp = &data->res;
     453                 :            : 
     454                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     455                 :          0 :         nfs_mark_for_revalidate(dir);
     456         [ #  # ]:          0 :         if (status == 0)
     457                 :          0 :                 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
     458                 :            :         nfs_free_createdata(data);
     459                 :            : out:
     460                 :            :         dprintk("NFS reply mkdir: %d\n", status);
     461                 :          0 :         return status;
     462                 :            : }
     463                 :            : 
     464                 :            : static int
     465                 :          0 : nfs_proc_rmdir(struct inode *dir, const struct qstr *name)
     466                 :            : {
     467                 :          0 :         struct nfs_diropargs    arg = {
     468                 :            :                 .fh             = NFS_FH(dir),
     469                 :          0 :                 .name           = name->name,
     470                 :          0 :                 .len            = name->len
     471                 :            :         };
     472                 :          0 :         struct rpc_message msg = {
     473                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_RMDIR],
     474                 :            :                 .rpc_argp       = &arg,
     475                 :            :         };
     476                 :            :         int                     status;
     477                 :            : 
     478                 :            :         dprintk("NFS call  rmdir %s\n", name->name);
     479                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     480                 :          0 :         nfs_mark_for_revalidate(dir);
     481                 :            :         dprintk("NFS reply rmdir: %d\n", status);
     482                 :          0 :         return status;
     483                 :            : }
     484                 :            : 
     485                 :            : /*
     486                 :            :  * The READDIR implementation is somewhat hackish - we pass a temporary
     487                 :            :  * buffer to the encode function, which installs it in the receive
     488                 :            :  * the receive iovec. The decode function just parses the reply to make
     489                 :            :  * sure it is syntactically correct; the entries itself are decoded
     490                 :            :  * from nfs_readdir by calling the decode_entry function directly.
     491                 :            :  */
     492                 :            : static int
     493                 :          0 : nfs_proc_readdir(struct dentry *dentry, const struct cred *cred,
     494                 :            :                  u64 cookie, struct page **pages, unsigned int count, bool plus)
     495                 :            : {
     496                 :            :         struct inode            *dir = d_inode(dentry);
     497                 :          0 :         struct nfs_readdirargs  arg = {
     498                 :            :                 .fh             = NFS_FH(dir),
     499                 :            :                 .cookie         = cookie,
     500                 :            :                 .count          = count,
     501                 :            :                 .pages          = pages,
     502                 :            :         };
     503                 :          0 :         struct rpc_message      msg = {
     504                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_READDIR],
     505                 :            :                 .rpc_argp       = &arg,
     506                 :            :                 .rpc_cred       = cred,
     507                 :            :         };
     508                 :            :         int                     status;
     509                 :            : 
     510                 :            :         dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
     511                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     512                 :            : 
     513                 :          0 :         nfs_invalidate_atime(dir);
     514                 :            : 
     515                 :            :         dprintk("NFS reply readdir: %d\n", status);
     516                 :          0 :         return status;
     517                 :            : }
     518                 :            : 
     519                 :            : static int
     520                 :          0 : nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
     521                 :            :                         struct nfs_fsstat *stat)
     522                 :            : {
     523                 :            :         struct nfs2_fsstat fsinfo;
     524                 :          0 :         struct rpc_message msg = {
     525                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
     526                 :            :                 .rpc_argp       = fhandle,
     527                 :            :                 .rpc_resp       = &fsinfo,
     528                 :            :         };
     529                 :            :         int     status;
     530                 :            : 
     531                 :            :         dprintk("NFS call  statfs\n");
     532                 :          0 :         nfs_fattr_init(stat->fattr);
     533                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     534                 :            :         dprintk("NFS reply statfs: %d\n", status);
     535         [ #  # ]:          0 :         if (status)
     536                 :            :                 goto out;
     537                 :          0 :         stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
     538                 :          0 :         stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
     539                 :          0 :         stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
     540                 :          0 :         stat->tfiles = 0;
     541                 :          0 :         stat->ffiles = 0;
     542                 :          0 :         stat->afiles = 0;
     543                 :            : out:
     544                 :          0 :         return status;
     545                 :            : }
     546                 :            : 
     547                 :            : static int
     548                 :          0 : nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
     549                 :            :                         struct nfs_fsinfo *info)
     550                 :            : {
     551                 :            :         struct nfs2_fsstat fsinfo;
     552                 :          0 :         struct rpc_message msg = {
     553                 :            :                 .rpc_proc       = &nfs_procedures[NFSPROC_STATFS],
     554                 :            :                 .rpc_argp       = fhandle,
     555                 :            :                 .rpc_resp       = &fsinfo,
     556                 :            :         };
     557                 :            :         int     status;
     558                 :            : 
     559                 :            :         dprintk("NFS call  fsinfo\n");
     560                 :          0 :         nfs_fattr_init(info->fattr);
     561                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     562                 :            :         dprintk("NFS reply fsinfo: %d\n", status);
     563         [ #  # ]:          0 :         if (status)
     564                 :            :                 goto out;
     565                 :          0 :         info->rtmax  = NFS_MAXDATA;
     566                 :          0 :         info->rtpref = fsinfo.tsize;
     567                 :          0 :         info->rtmult = fsinfo.bsize;
     568                 :          0 :         info->wtmax  = NFS_MAXDATA;
     569                 :          0 :         info->wtpref = fsinfo.tsize;
     570                 :          0 :         info->wtmult = fsinfo.bsize;
     571                 :          0 :         info->dtpref = fsinfo.tsize;
     572                 :          0 :         info->maxfilesize = 0x7FFFFFFF;
     573                 :          0 :         info->lease_time = 0;
     574                 :            : out:
     575                 :          0 :         return status;
     576                 :            : }
     577                 :            : 
     578                 :            : static int
     579                 :          0 : nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
     580                 :            :                   struct nfs_pathconf *info)
     581                 :            : {
     582                 :          0 :         info->max_link = 0;
     583                 :          0 :         info->max_namelen = NFS2_MAXNAMLEN;
     584                 :          0 :         return 0;
     585                 :            : }
     586                 :            : 
     587                 :          0 : static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
     588                 :            : {
     589                 :          0 :         struct inode *inode = hdr->inode;
     590                 :            : 
     591                 :          0 :         nfs_invalidate_atime(inode);
     592         [ #  # ]:          0 :         if (task->tk_status >= 0) {
     593                 :          0 :                 nfs_refresh_inode(inode, hdr->res.fattr);
     594                 :            :                 /* Emulate the eof flag, which isn't normally needed in NFSv2
     595                 :            :                  * as it is guaranteed to always return the file attributes
     596                 :            :                  */
     597   [ #  #  #  #  :          0 :                 if ((hdr->res.count == 0 && hdr->args.count > 0) ||
                   #  # ]
     598                 :          0 :                     hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
     599                 :          0 :                         hdr->res.eof = 1;
     600                 :            :         }
     601                 :          0 :         return 0;
     602                 :            : }
     603                 :            : 
     604                 :          0 : static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
     605                 :            :                                 struct rpc_message *msg)
     606                 :            : {
     607                 :          0 :         msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
     608                 :          0 : }
     609                 :            : 
     610                 :          0 : static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
     611                 :            :                                      struct nfs_pgio_header *hdr)
     612                 :            : {
     613                 :          0 :         rpc_call_start(task);
     614                 :          0 :         return 0;
     615                 :            : }
     616                 :            : 
     617                 :          0 : static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
     618                 :            : {
     619         [ #  # ]:          0 :         if (task->tk_status >= 0) {
     620                 :          0 :                 hdr->res.count = hdr->args.count;
     621                 :          0 :                 nfs_writeback_update_inode(hdr);
     622                 :            :         }
     623                 :          0 :         return 0;
     624                 :            : }
     625                 :            : 
     626                 :          0 : static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
     627                 :            :                                  struct rpc_message *msg,
     628                 :            :                                  struct rpc_clnt **clnt)
     629                 :            : {
     630                 :            :         /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
     631                 :          0 :         hdr->args.stable = NFS_FILE_SYNC;
     632                 :          0 :         msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
     633                 :          0 : }
     634                 :            : 
     635                 :          0 : static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
     636                 :            : {
     637                 :          0 :         BUG();
     638                 :            : }
     639                 :            : 
     640                 :            : static void
     641                 :          0 : nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
     642                 :            :                         struct rpc_clnt **clnt)
     643                 :            : {
     644                 :          0 :         BUG();
     645                 :            : }
     646                 :            : 
     647                 :            : static int
     648                 :          0 : nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
     649                 :            : {
     650                 :            :         struct inode *inode = file_inode(filp);
     651                 :            : 
     652                 :          0 :         return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL);
     653                 :            : }
     654                 :            : 
     655                 :            : /* Helper functions for NFS lock bounds checking */
     656                 :            : #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
     657                 :          0 : static int nfs_lock_check_bounds(const struct file_lock *fl)
     658                 :            : {
     659                 :            :         __s32 start, end;
     660                 :            : 
     661                 :          0 :         start = (__s32)fl->fl_start;
     662         [ #  # ]:          0 :         if ((loff_t)start != fl->fl_start)
     663                 :            :                 goto out_einval;
     664                 :            : 
     665         [ #  # ]:          0 :         if (fl->fl_end != OFFSET_MAX) {
     666                 :          0 :                 end = (__s32)fl->fl_end;
     667         [ #  # ]:          0 :                 if ((loff_t)end != fl->fl_end)
     668                 :            :                         goto out_einval;
     669                 :            :         } else
     670                 :            :                 end = NFS_LOCK32_OFFSET_MAX;
     671                 :            : 
     672         [ #  # ]:          0 :         if (start < 0 || start > end)
     673                 :            :                 goto out_einval;
     674                 :            :         return 0;
     675                 :            : out_einval:
     676                 :          0 :         return -EINVAL;
     677                 :            : }
     678                 :            : 
     679                 :          0 : static int nfs_have_delegation(struct inode *inode, fmode_t flags)
     680                 :            : {
     681                 :          0 :         return 0;
     682                 :            : }
     683                 :            : 
     684                 :            : static const struct inode_operations nfs_dir_inode_operations = {
     685                 :            :         .create         = nfs_create,
     686                 :            :         .lookup         = nfs_lookup,
     687                 :            :         .link           = nfs_link,
     688                 :            :         .unlink         = nfs_unlink,
     689                 :            :         .symlink        = nfs_symlink,
     690                 :            :         .mkdir          = nfs_mkdir,
     691                 :            :         .rmdir          = nfs_rmdir,
     692                 :            :         .mknod          = nfs_mknod,
     693                 :            :         .rename         = nfs_rename,
     694                 :            :         .permission     = nfs_permission,
     695                 :            :         .getattr        = nfs_getattr,
     696                 :            :         .setattr        = nfs_setattr,
     697                 :            : };
     698                 :            : 
     699                 :            : static const struct inode_operations nfs_file_inode_operations = {
     700                 :            :         .permission     = nfs_permission,
     701                 :            :         .getattr        = nfs_getattr,
     702                 :            :         .setattr        = nfs_setattr,
     703                 :            : };
     704                 :            : 
     705                 :            : const struct nfs_rpc_ops nfs_v2_clientops = {
     706                 :            :         .version        = 2,                   /* protocol version */
     707                 :            :         .dentry_ops     = &nfs_dentry_operations,
     708                 :            :         .dir_inode_ops  = &nfs_dir_inode_operations,
     709                 :            :         .file_inode_ops = &nfs_file_inode_operations,
     710                 :            :         .file_ops       = &nfs_file_operations,
     711                 :            :         .getroot        = nfs_proc_get_root,
     712                 :            :         .submount       = nfs_submount,
     713                 :            :         .try_mount      = nfs_try_mount,
     714                 :            :         .getattr        = nfs_proc_getattr,
     715                 :            :         .setattr        = nfs_proc_setattr,
     716                 :            :         .lookup         = nfs_proc_lookup,
     717                 :            :         .access         = NULL,                /* access */
     718                 :            :         .readlink       = nfs_proc_readlink,
     719                 :            :         .create         = nfs_proc_create,
     720                 :            :         .remove         = nfs_proc_remove,
     721                 :            :         .unlink_setup   = nfs_proc_unlink_setup,
     722                 :            :         .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
     723                 :            :         .unlink_done    = nfs_proc_unlink_done,
     724                 :            :         .rename_setup   = nfs_proc_rename_setup,
     725                 :            :         .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
     726                 :            :         .rename_done    = nfs_proc_rename_done,
     727                 :            :         .link           = nfs_proc_link,
     728                 :            :         .symlink        = nfs_proc_symlink,
     729                 :            :         .mkdir          = nfs_proc_mkdir,
     730                 :            :         .rmdir          = nfs_proc_rmdir,
     731                 :            :         .readdir        = nfs_proc_readdir,
     732                 :            :         .mknod          = nfs_proc_mknod,
     733                 :            :         .statfs         = nfs_proc_statfs,
     734                 :            :         .fsinfo         = nfs_proc_fsinfo,
     735                 :            :         .pathconf       = nfs_proc_pathconf,
     736                 :            :         .decode_dirent  = nfs2_decode_dirent,
     737                 :            :         .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
     738                 :            :         .read_setup     = nfs_proc_read_setup,
     739                 :            :         .read_done      = nfs_read_done,
     740                 :            :         .write_setup    = nfs_proc_write_setup,
     741                 :            :         .write_done     = nfs_write_done,
     742                 :            :         .commit_setup   = nfs_proc_commit_setup,
     743                 :            :         .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
     744                 :            :         .lock           = nfs_proc_lock,
     745                 :            :         .lock_check_bounds = nfs_lock_check_bounds,
     746                 :            :         .close_context  = nfs_close_context,
     747                 :            :         .have_delegation = nfs_have_delegation,
     748                 :            :         .alloc_client   = nfs_alloc_client,
     749                 :            :         .init_client    = nfs_init_client,
     750                 :            :         .free_client    = nfs_free_client,
     751                 :            :         .create_server  = nfs_create_server,
     752                 :            :         .clone_server   = nfs_clone_server,
     753                 :            : };

Generated by: LCOV version 1.14