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

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/fs/nfs/nfs3proc.c
       4                 :            :  *
       5                 :            :  *  Client-side NFSv3 procedures stubs.
       6                 :            :  *
       7                 :            :  *  Copyright (C) 1997, Olaf Kirch
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/mm.h>
      11                 :            : #include <linux/errno.h>
      12                 :            : #include <linux/string.h>
      13                 :            : #include <linux/sunrpc/clnt.h>
      14                 :            : #include <linux/slab.h>
      15                 :            : #include <linux/nfs.h>
      16                 :            : #include <linux/nfs3.h>
      17                 :            : #include <linux/nfs_fs.h>
      18                 :            : #include <linux/nfs_page.h>
      19                 :            : #include <linux/lockd/bind.h>
      20                 :            : #include <linux/nfs_mount.h>
      21                 :            : #include <linux/freezer.h>
      22                 :            : #include <linux/xattr.h>
      23                 :            : 
      24                 :            : #include "iostat.h"
      25                 :            : #include "internal.h"
      26                 :            : #include "nfs3_fs.h"
      27                 :            : 
      28                 :            : #define NFSDBG_FACILITY         NFSDBG_PROC
      29                 :            : 
      30                 :            : /* A wrapper to handle the EJUKEBOX error messages */
      31                 :            : static int
      32                 :          0 : nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
      33                 :            : {
      34                 :            :         int res;
      35                 :            :         do {
      36                 :          0 :                 res = rpc_call_sync(clnt, msg, flags);
      37         [ #  # ]:          0 :                 if (res != -EJUKEBOX)
      38                 :            :                         break;
      39                 :          0 :                 freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
      40                 :            :                 res = -ERESTARTSYS;
      41         [ #  # ]:          0 :         } while (!fatal_signal_pending(current));
      42                 :          0 :         return res;
      43                 :            : }
      44                 :            : 
      45                 :            : #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
      46                 :            : 
      47                 :            : static int
      48                 :          0 : nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
      49                 :            : {
      50         [ #  # ]:          0 :         if (task->tk_status != -EJUKEBOX)
      51                 :            :                 return 0;
      52         [ #  # ]:          0 :         if (task->tk_status == -EJUKEBOX)
      53                 :          0 :                 nfs_inc_stats(inode, NFSIOS_DELAY);
      54                 :          0 :         task->tk_status = 0;
      55                 :          0 :         rpc_restart_call(task);
      56                 :          0 :         rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
      57                 :          0 :         return 1;
      58                 :            : }
      59                 :            : 
      60                 :            : static int
      61                 :          0 : do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
      62                 :            :                  struct nfs_fsinfo *info)
      63                 :            : {
      64                 :          0 :         struct rpc_message msg = {
      65                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
      66                 :            :                 .rpc_argp       = fhandle,
      67                 :            :                 .rpc_resp       = info,
      68                 :            :         };
      69                 :            :         int     status;
      70                 :            : 
      71                 :            :         dprintk("%s: call  fsinfo\n", __func__);
      72                 :          0 :         nfs_fattr_init(info->fattr);
      73                 :          0 :         status = rpc_call_sync(client, &msg, 0);
      74                 :            :         dprintk("%s: reply fsinfo: %d\n", __func__, status);
      75   [ #  #  #  # ]:          0 :         if (status == 0 && !(info->fattr->valid & NFS_ATTR_FATTR)) {
      76                 :          0 :                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
      77                 :          0 :                 msg.rpc_resp = info->fattr;
      78                 :          0 :                 status = rpc_call_sync(client, &msg, 0);
      79                 :            :                 dprintk("%s: reply getattr: %d\n", __func__, status);
      80                 :            :         }
      81                 :          0 :         return status;
      82                 :            : }
      83                 :            : 
      84                 :            : /*
      85                 :            :  * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
      86                 :            :  */
      87                 :            : static int
      88                 :          0 : nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
      89                 :            :                    struct nfs_fsinfo *info)
      90                 :            : {
      91                 :            :         int     status;
      92                 :            : 
      93                 :          0 :         status = do_proc_get_root(server->client, fhandle, info);
      94   [ #  #  #  # ]:          0 :         if (status && server->nfs_client->cl_rpcclient != server->client)
      95                 :          0 :                 status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
      96                 :          0 :         return status;
      97                 :            : }
      98                 :            : 
      99                 :            : /*
     100                 :            :  * One function for each procedure in the NFS protocol.
     101                 :            :  */
     102                 :            : static int
     103                 :          0 : nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
     104                 :            :                 struct nfs_fattr *fattr, struct nfs4_label *label,
     105                 :            :                 struct inode *inode)
     106                 :            : {
     107                 :          0 :         struct rpc_message msg = {
     108                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_GETATTR],
     109                 :            :                 .rpc_argp       = fhandle,
     110                 :            :                 .rpc_resp       = fattr,
     111                 :            :         };
     112                 :            :         int     status;
     113                 :            : 
     114                 :            :         dprintk("NFS call  getattr\n");
     115                 :          0 :         nfs_fattr_init(fattr);
     116                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     117                 :            :         dprintk("NFS reply getattr: %d\n", status);
     118                 :          0 :         return status;
     119                 :            : }
     120                 :            : 
     121                 :            : static int
     122                 :          0 : nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
     123                 :            :                         struct iattr *sattr)
     124                 :            : {
     125                 :            :         struct inode *inode = d_inode(dentry);
     126                 :          0 :         struct nfs3_sattrargs   arg = {
     127                 :            :                 .fh             = NFS_FH(inode),
     128                 :            :                 .sattr          = sattr,
     129                 :            :         };
     130                 :          0 :         struct rpc_message msg = {
     131                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SETATTR],
     132                 :            :                 .rpc_argp       = &arg,
     133                 :            :                 .rpc_resp       = fattr,
     134                 :            :         };
     135                 :            :         int     status;
     136                 :            : 
     137                 :            :         dprintk("NFS call  setattr\n");
     138         [ #  # ]:          0 :         if (sattr->ia_valid & ATTR_FILE)
     139                 :          0 :                 msg.rpc_cred = nfs_file_cred(sattr->ia_file);
     140                 :          0 :         nfs_fattr_init(fattr);
     141                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     142         [ #  # ]:          0 :         if (status == 0) {
     143         [ #  # ]:          0 :                 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
     144                 :          0 :                         nfs_zap_acl_cache(inode);
     145                 :          0 :                 nfs_setattr_update_inode(inode, sattr, fattr);
     146                 :            :         }
     147                 :            :         dprintk("NFS reply setattr: %d\n", status);
     148                 :          0 :         return status;
     149                 :            : }
     150                 :            : 
     151                 :            : static int
     152                 :          0 : nfs3_proc_lookup(struct inode *dir, const struct qstr *name,
     153                 :            :                  struct nfs_fh *fhandle, struct nfs_fattr *fattr,
     154                 :            :                  struct nfs4_label *label)
     155                 :            : {
     156                 :          0 :         struct nfs3_diropargs   arg = {
     157                 :            :                 .fh             = NFS_FH(dir),
     158                 :          0 :                 .name           = name->name,
     159                 :          0 :                 .len            = name->len
     160                 :            :         };
     161                 :          0 :         struct nfs3_diropres    res = {
     162                 :            :                 .fh             = fhandle,
     163                 :            :                 .fattr          = fattr
     164                 :            :         };
     165                 :          0 :         struct rpc_message msg = {
     166                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LOOKUP],
     167                 :            :                 .rpc_argp       = &arg,
     168                 :            :                 .rpc_resp       = &res,
     169                 :            :         };
     170                 :            :         int                     status;
     171                 :            : 
     172                 :            :         dprintk("NFS call  lookup %s\n", name->name);
     173                 :          0 :         res.dir_attr = nfs_alloc_fattr();
     174         [ #  # ]:          0 :         if (res.dir_attr == NULL)
     175                 :            :                 return -ENOMEM;
     176                 :            : 
     177                 :          0 :         nfs_fattr_init(fattr);
     178                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     179                 :          0 :         nfs_refresh_inode(dir, res.dir_attr);
     180   [ #  #  #  # ]:          0 :         if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
     181                 :          0 :                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
     182                 :          0 :                 msg.rpc_argp = fhandle;
     183                 :          0 :                 msg.rpc_resp = fattr;
     184                 :          0 :                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     185                 :            :         }
     186                 :          0 :         nfs_free_fattr(res.dir_attr);
     187                 :            :         dprintk("NFS reply lookup: %d\n", status);
     188                 :          0 :         return status;
     189                 :            : }
     190                 :            : 
     191                 :          0 : static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
     192                 :            : {
     193                 :          0 :         struct nfs3_accessargs  arg = {
     194                 :            :                 .fh             = NFS_FH(inode),
     195                 :          0 :                 .access         = entry->mask,
     196                 :            :         };
     197                 :            :         struct nfs3_accessres   res;
     198                 :          0 :         struct rpc_message msg = {
     199                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_ACCESS],
     200                 :            :                 .rpc_argp       = &arg,
     201                 :            :                 .rpc_resp       = &res,
     202                 :          0 :                 .rpc_cred       = entry->cred,
     203                 :            :         };
     204                 :            :         int status = -ENOMEM;
     205                 :            : 
     206                 :            :         dprintk("NFS call  access\n");
     207                 :          0 :         res.fattr = nfs_alloc_fattr();
     208         [ #  # ]:          0 :         if (res.fattr == NULL)
     209                 :            :                 goto out;
     210                 :            : 
     211                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     212                 :          0 :         nfs_refresh_inode(inode, res.fattr);
     213         [ #  # ]:          0 :         if (status == 0)
     214                 :          0 :                 nfs_access_set_mask(entry, res.access);
     215                 :          0 :         nfs_free_fattr(res.fattr);
     216                 :            : out:
     217                 :            :         dprintk("NFS reply access: %d\n", status);
     218                 :          0 :         return status;
     219                 :            : }
     220                 :            : 
     221                 :          0 : static int nfs3_proc_readlink(struct inode *inode, struct page *page,
     222                 :            :                 unsigned int pgbase, unsigned int pglen)
     223                 :            : {
     224                 :            :         struct nfs_fattr        *fattr;
     225                 :          0 :         struct nfs3_readlinkargs args = {
     226                 :            :                 .fh             = NFS_FH(inode),
     227                 :            :                 .pgbase         = pgbase,
     228                 :            :                 .pglen          = pglen,
     229                 :            :                 .pages          = &page
     230                 :            :         };
     231                 :          0 :         struct rpc_message msg = {
     232                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READLINK],
     233                 :            :                 .rpc_argp       = &args,
     234                 :            :         };
     235                 :            :         int status = -ENOMEM;
     236                 :            : 
     237                 :            :         dprintk("NFS call  readlink\n");
     238                 :          0 :         fattr = nfs_alloc_fattr();
     239         [ #  # ]:          0 :         if (fattr == NULL)
     240                 :            :                 goto out;
     241                 :          0 :         msg.rpc_resp = fattr;
     242                 :            : 
     243                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     244                 :          0 :         nfs_refresh_inode(inode, fattr);
     245                 :            :         nfs_free_fattr(fattr);
     246                 :            : out:
     247                 :            :         dprintk("NFS reply readlink: %d\n", status);
     248                 :          0 :         return status;
     249                 :            : }
     250                 :            : 
     251                 :            : struct nfs3_createdata {
     252                 :            :         struct rpc_message msg;
     253                 :            :         union {
     254                 :            :                 struct nfs3_createargs create;
     255                 :            :                 struct nfs3_mkdirargs mkdir;
     256                 :            :                 struct nfs3_symlinkargs symlink;
     257                 :            :                 struct nfs3_mknodargs mknod;
     258                 :            :         } arg;
     259                 :            :         struct nfs3_diropres res;
     260                 :            :         struct nfs_fh fh;
     261                 :            :         struct nfs_fattr fattr;
     262                 :            :         struct nfs_fattr dir_attr;
     263                 :            : };
     264                 :            : 
     265                 :          0 : static struct nfs3_createdata *nfs3_alloc_createdata(void)
     266                 :            : {
     267                 :            :         struct nfs3_createdata *data;
     268                 :            : 
     269                 :          0 :         data = kzalloc(sizeof(*data), GFP_KERNEL);
     270         [ #  # ]:          0 :         if (data != NULL) {
     271                 :          0 :                 data->msg.rpc_argp = &data->arg;
     272                 :          0 :                 data->msg.rpc_resp = &data->res;
     273                 :          0 :                 data->res.fh = &data->fh;
     274                 :          0 :                 data->res.fattr = &data->fattr;
     275                 :          0 :                 data->res.dir_attr = &data->dir_attr;
     276                 :          0 :                 nfs_fattr_init(data->res.fattr);
     277                 :          0 :                 nfs_fattr_init(data->res.dir_attr);
     278                 :            :         }
     279                 :          0 :         return data;
     280                 :            : }
     281                 :            : 
     282                 :            : static struct dentry *
     283                 :          0 : nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
     284                 :            : {
     285                 :            :         int status;
     286                 :            : 
     287                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
     288                 :          0 :         nfs_post_op_update_inode(dir, data->res.dir_attr);
     289         [ #  # ]:          0 :         if (status != 0)
     290                 :          0 :                 return ERR_PTR(status);
     291                 :            : 
     292                 :          0 :         return nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr, NULL);
     293                 :            : }
     294                 :            : 
     295                 :            : static void nfs3_free_createdata(struct nfs3_createdata *data)
     296                 :            : {
     297                 :          0 :         kfree(data);
     298                 :            : }
     299                 :            : 
     300                 :            : /*
     301                 :            :  * Create a regular file.
     302                 :            :  */
     303                 :            : static int
     304                 :          0 : nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
     305                 :            :                  int flags)
     306                 :            : {
     307                 :            :         struct posix_acl *default_acl, *acl;
     308                 :            :         struct nfs3_createdata *data;
     309                 :            :         struct dentry *d_alias;
     310                 :            :         int status = -ENOMEM;
     311                 :            : 
     312                 :            :         dprintk("NFS call  create %pd\n", dentry);
     313                 :            : 
     314                 :          0 :         data = nfs3_alloc_createdata();
     315         [ #  # ]:          0 :         if (data == NULL)
     316                 :            :                 goto out;
     317                 :            : 
     318                 :          0 :         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
     319                 :          0 :         data->arg.create.fh = NFS_FH(dir);
     320                 :          0 :         data->arg.create.name = dentry->d_name.name;
     321                 :          0 :         data->arg.create.len = dentry->d_name.len;
     322                 :          0 :         data->arg.create.sattr = sattr;
     323                 :            : 
     324                 :          0 :         data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
     325         [ #  # ]:          0 :         if (flags & O_EXCL) {
     326                 :          0 :                 data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
     327                 :          0 :                 data->arg.create.verifier[0] = cpu_to_be32(jiffies);
     328                 :          0 :                 data->arg.create.verifier[1] = cpu_to_be32(current->pid);
     329                 :            :         }
     330                 :            : 
     331                 :          0 :         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
     332         [ #  # ]:          0 :         if (status)
     333                 :            :                 goto out;
     334                 :            : 
     335                 :            :         for (;;) {
     336                 :          0 :                 d_alias = nfs3_do_create(dir, dentry, data);
     337                 :            :                 status = PTR_ERR_OR_ZERO(d_alias);
     338                 :            : 
     339         [ #  # ]:          0 :                 if (status != -ENOTSUPP)
     340                 :            :                         break;
     341                 :            :                 /* If the server doesn't support the exclusive creation
     342                 :            :                  * semantics, try again with simple 'guarded' mode. */
     343   [ #  #  #  # ]:          0 :                 switch (data->arg.create.createmode) {
     344                 :            :                         case NFS3_CREATE_EXCLUSIVE:
     345                 :          0 :                                 data->arg.create.createmode = NFS3_CREATE_GUARDED;
     346                 :          0 :                                 break;
     347                 :            : 
     348                 :            :                         case NFS3_CREATE_GUARDED:
     349                 :          0 :                                 data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
     350                 :          0 :                                 break;
     351                 :            : 
     352                 :            :                         case NFS3_CREATE_UNCHECKED:
     353                 :            :                                 goto out;
     354                 :            :                 }
     355                 :          0 :                 nfs_fattr_init(data->res.dir_attr);
     356                 :          0 :                 nfs_fattr_init(data->res.fattr);
     357                 :          0 :         }
     358                 :            : 
     359         [ #  # ]:          0 :         if (status != 0)
     360                 :            :                 goto out_release_acls;
     361                 :            : 
     362         [ #  # ]:          0 :         if (d_alias)
     363                 :          0 :                 dentry = d_alias;
     364                 :            : 
     365                 :            :         /* When we created the file with exclusive semantics, make
     366                 :            :          * sure we set the attributes afterwards. */
     367         [ #  # ]:          0 :         if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
     368                 :            :                 dprintk("NFS call  setattr (post-create)\n");
     369                 :            : 
     370         [ #  # ]:          0 :                 if (!(sattr->ia_valid & ATTR_ATIME_SET))
     371                 :          0 :                         sattr->ia_valid |= ATTR_ATIME;
     372         [ #  # ]:          0 :                 if (!(sattr->ia_valid & ATTR_MTIME_SET))
     373                 :          0 :                         sattr->ia_valid |= ATTR_MTIME;
     374                 :            : 
     375                 :            :                 /* Note: we could use a guarded setattr here, but I'm
     376                 :            :                  * not sure this buys us anything (and I'd have
     377                 :            :                  * to revamp the NFSv3 XDR code) */
     378                 :          0 :                 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
     379                 :          0 :                 nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);
     380                 :            :                 dprintk("NFS reply setattr (post-create): %d\n", status);
     381         [ #  # ]:          0 :                 if (status != 0)
     382                 :            :                         goto out_dput;
     383                 :            :         }
     384                 :            : 
     385                 :          0 :         status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
     386                 :            : 
     387                 :            : out_dput:
     388                 :          0 :         dput(d_alias);
     389                 :            : out_release_acls:
     390                 :          0 :         posix_acl_release(acl);
     391                 :          0 :         posix_acl_release(default_acl);
     392                 :            : out:
     393                 :            :         nfs3_free_createdata(data);
     394                 :            :         dprintk("NFS reply create: %d\n", status);
     395                 :          0 :         return status;
     396                 :            : }
     397                 :            : 
     398                 :            : static int
     399                 :          0 : nfs3_proc_remove(struct inode *dir, struct dentry *dentry)
     400                 :            : {
     401                 :          0 :         struct nfs_removeargs arg = {
     402                 :            :                 .fh = NFS_FH(dir),
     403                 :            :                 .name = dentry->d_name,
     404                 :            :         };
     405                 :            :         struct nfs_removeres res;
     406                 :          0 :         struct rpc_message msg = {
     407                 :            :                 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
     408                 :            :                 .rpc_argp = &arg,
     409                 :            :                 .rpc_resp = &res,
     410                 :            :         };
     411                 :            :         int status = -ENOMEM;
     412                 :            : 
     413                 :            :         dprintk("NFS call  remove %pd2\n", dentry);
     414                 :          0 :         res.dir_attr = nfs_alloc_fattr();
     415         [ #  # ]:          0 :         if (res.dir_attr == NULL)
     416                 :            :                 goto out;
     417                 :            : 
     418                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     419                 :          0 :         nfs_post_op_update_inode(dir, res.dir_attr);
     420                 :          0 :         nfs_free_fattr(res.dir_attr);
     421                 :            : out:
     422                 :            :         dprintk("NFS reply remove: %d\n", status);
     423                 :          0 :         return status;
     424                 :            : }
     425                 :            : 
     426                 :            : static void
     427                 :          0 : nfs3_proc_unlink_setup(struct rpc_message *msg,
     428                 :            :                 struct dentry *dentry,
     429                 :            :                 struct inode *inode)
     430                 :            : {
     431                 :          0 :         msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
     432                 :          0 : }
     433                 :            : 
     434                 :          0 : static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
     435                 :            : {
     436                 :          0 :         rpc_call_start(task);
     437                 :          0 : }
     438                 :            : 
     439                 :            : static int
     440                 :          0 : nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
     441                 :            : {
     442                 :            :         struct nfs_removeres *res;
     443         [ #  # ]:          0 :         if (nfs3_async_handle_jukebox(task, dir))
     444                 :            :                 return 0;
     445                 :          0 :         res = task->tk_msg.rpc_resp;
     446                 :          0 :         nfs_post_op_update_inode(dir, res->dir_attr);
     447                 :          0 :         return 1;
     448                 :            : }
     449                 :            : 
     450                 :            : static void
     451                 :          0 : nfs3_proc_rename_setup(struct rpc_message *msg,
     452                 :            :                 struct dentry *old_dentry,
     453                 :            :                 struct dentry *new_dentry)
     454                 :            : {
     455                 :          0 :         msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
     456                 :          0 : }
     457                 :            : 
     458                 :          0 : static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
     459                 :            : {
     460                 :          0 :         rpc_call_start(task);
     461                 :          0 : }
     462                 :            : 
     463                 :            : static int
     464                 :          0 : nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
     465                 :            :                       struct inode *new_dir)
     466                 :            : {
     467                 :            :         struct nfs_renameres *res;
     468                 :            : 
     469         [ #  # ]:          0 :         if (nfs3_async_handle_jukebox(task, old_dir))
     470                 :            :                 return 0;
     471                 :          0 :         res = task->tk_msg.rpc_resp;
     472                 :            : 
     473                 :          0 :         nfs_post_op_update_inode(old_dir, res->old_fattr);
     474                 :          0 :         nfs_post_op_update_inode(new_dir, res->new_fattr);
     475                 :          0 :         return 1;
     476                 :            : }
     477                 :            : 
     478                 :            : static int
     479                 :          0 : nfs3_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
     480                 :            : {
     481                 :          0 :         struct nfs3_linkargs    arg = {
     482                 :            :                 .fromfh         = NFS_FH(inode),
     483                 :            :                 .tofh           = NFS_FH(dir),
     484                 :          0 :                 .toname         = name->name,
     485                 :          0 :                 .tolen          = name->len
     486                 :            :         };
     487                 :            :         struct nfs3_linkres     res;
     488                 :          0 :         struct rpc_message msg = {
     489                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LINK],
     490                 :            :                 .rpc_argp       = &arg,
     491                 :            :                 .rpc_resp       = &res,
     492                 :            :         };
     493                 :            :         int status = -ENOMEM;
     494                 :            : 
     495                 :            :         dprintk("NFS call  link %s\n", name->name);
     496                 :          0 :         res.fattr = nfs_alloc_fattr();
     497                 :          0 :         res.dir_attr = nfs_alloc_fattr();
     498   [ #  #  #  # ]:          0 :         if (res.fattr == NULL || res.dir_attr == NULL)
     499                 :            :                 goto out;
     500                 :            : 
     501                 :          0 :         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
     502                 :          0 :         nfs_post_op_update_inode(dir, res.dir_attr);
     503                 :          0 :         nfs_post_op_update_inode(inode, res.fattr);
     504                 :            : out:
     505                 :          0 :         nfs_free_fattr(res.dir_attr);
     506                 :          0 :         nfs_free_fattr(res.fattr);
     507                 :            :         dprintk("NFS reply link: %d\n", status);
     508                 :          0 :         return status;
     509                 :            : }
     510                 :            : 
     511                 :            : static int
     512                 :          0 : nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
     513                 :            :                   unsigned int len, struct iattr *sattr)
     514                 :            : {
     515                 :            :         struct nfs3_createdata *data;
     516                 :            :         struct dentry *d_alias;
     517                 :            :         int status = -ENOMEM;
     518                 :            : 
     519         [ #  # ]:          0 :         if (len > NFS3_MAXPATHLEN)
     520                 :            :                 return -ENAMETOOLONG;
     521                 :            : 
     522                 :            :         dprintk("NFS call  symlink %pd\n", dentry);
     523                 :            : 
     524                 :          0 :         data = nfs3_alloc_createdata();
     525         [ #  # ]:          0 :         if (data == NULL)
     526                 :            :                 goto out;
     527                 :          0 :         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
     528                 :          0 :         data->arg.symlink.fromfh = NFS_FH(dir);
     529                 :          0 :         data->arg.symlink.fromname = dentry->d_name.name;
     530                 :          0 :         data->arg.symlink.fromlen = dentry->d_name.len;
     531                 :          0 :         data->arg.symlink.pages = &page;
     532                 :          0 :         data->arg.symlink.pathlen = len;
     533                 :          0 :         data->arg.symlink.sattr = sattr;
     534                 :            : 
     535                 :          0 :         d_alias = nfs3_do_create(dir, dentry, data);
     536                 :            :         status = PTR_ERR_OR_ZERO(d_alias);
     537                 :            : 
     538         [ #  # ]:          0 :         if (status == 0)
     539                 :          0 :                 dput(d_alias);
     540                 :            : 
     541                 :            :         nfs3_free_createdata(data);
     542                 :            : out:
     543                 :            :         dprintk("NFS reply symlink: %d\n", status);
     544                 :          0 :         return status;
     545                 :            : }
     546                 :            : 
     547                 :            : static int
     548                 :          0 : nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
     549                 :            : {
     550                 :            :         struct posix_acl *default_acl, *acl;
     551                 :            :         struct nfs3_createdata *data;
     552                 :            :         struct dentry *d_alias;
     553                 :            :         int status = -ENOMEM;
     554                 :            : 
     555                 :            :         dprintk("NFS call  mkdir %pd\n", dentry);
     556                 :            : 
     557                 :          0 :         data = nfs3_alloc_createdata();
     558         [ #  # ]:          0 :         if (data == NULL)
     559                 :            :                 goto out;
     560                 :            : 
     561                 :          0 :         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
     562         [ #  # ]:          0 :         if (status)
     563                 :            :                 goto out;
     564                 :            : 
     565                 :          0 :         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
     566                 :          0 :         data->arg.mkdir.fh = NFS_FH(dir);
     567                 :          0 :         data->arg.mkdir.name = dentry->d_name.name;
     568                 :          0 :         data->arg.mkdir.len = dentry->d_name.len;
     569                 :          0 :         data->arg.mkdir.sattr = sattr;
     570                 :            : 
     571                 :          0 :         d_alias = nfs3_do_create(dir, dentry, data);
     572                 :            :         status = PTR_ERR_OR_ZERO(d_alias);
     573                 :            : 
     574         [ #  # ]:          0 :         if (status != 0)
     575                 :            :                 goto out_release_acls;
     576                 :            : 
     577         [ #  # ]:          0 :         if (d_alias)
     578                 :            :                 dentry = d_alias;
     579                 :            : 
     580                 :          0 :         status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
     581                 :            : 
     582                 :          0 :         dput(d_alias);
     583                 :            : out_release_acls:
     584                 :          0 :         posix_acl_release(acl);
     585                 :          0 :         posix_acl_release(default_acl);
     586                 :            : out:
     587                 :            :         nfs3_free_createdata(data);
     588                 :            :         dprintk("NFS reply mkdir: %d\n", status);
     589                 :          0 :         return status;
     590                 :            : }
     591                 :            : 
     592                 :            : static int
     593                 :          0 : nfs3_proc_rmdir(struct inode *dir, const struct qstr *name)
     594                 :            : {
     595                 :            :         struct nfs_fattr        *dir_attr;
     596                 :          0 :         struct nfs3_diropargs   arg = {
     597                 :            :                 .fh             = NFS_FH(dir),
     598                 :          0 :                 .name           = name->name,
     599                 :          0 :                 .len            = name->len
     600                 :            :         };
     601                 :          0 :         struct rpc_message msg = {
     602                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RMDIR],
     603                 :            :                 .rpc_argp       = &arg,
     604                 :            :         };
     605                 :            :         int status = -ENOMEM;
     606                 :            : 
     607                 :            :         dprintk("NFS call  rmdir %s\n", name->name);
     608                 :          0 :         dir_attr = nfs_alloc_fattr();
     609         [ #  # ]:          0 :         if (dir_attr == NULL)
     610                 :            :                 goto out;
     611                 :            : 
     612                 :          0 :         msg.rpc_resp = dir_attr;
     613                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     614                 :          0 :         nfs_post_op_update_inode(dir, dir_attr);
     615                 :            :         nfs_free_fattr(dir_attr);
     616                 :            : out:
     617                 :            :         dprintk("NFS reply rmdir: %d\n", status);
     618                 :          0 :         return status;
     619                 :            : }
     620                 :            : 
     621                 :            : /*
     622                 :            :  * The READDIR implementation is somewhat hackish - we pass the user buffer
     623                 :            :  * to the encode function, which installs it in the receive iovec.
     624                 :            :  * The decode function itself doesn't perform any decoding, it just makes
     625                 :            :  * sure the reply is syntactically correct.
     626                 :            :  *
     627                 :            :  * Also note that this implementation handles both plain readdir and
     628                 :            :  * readdirplus.
     629                 :            :  */
     630                 :            : static int
     631                 :          0 : nfs3_proc_readdir(struct dentry *dentry, const struct cred *cred,
     632                 :            :                   u64 cookie, struct page **pages, unsigned int count, bool plus)
     633                 :            : {
     634                 :            :         struct inode            *dir = d_inode(dentry);
     635                 :          0 :         __be32                  *verf = NFS_I(dir)->cookieverf;
     636                 :          0 :         struct nfs3_readdirargs arg = {
     637                 :            :                 .fh             = NFS_FH(dir),
     638                 :            :                 .cookie         = cookie,
     639                 :          0 :                 .verf           = {verf[0], verf[1]},
     640                 :            :                 .plus           = plus,
     641                 :            :                 .count          = count,
     642                 :            :                 .pages          = pages
     643                 :            :         };
     644                 :          0 :         struct nfs3_readdirres  res = {
     645                 :            :                 .verf           = verf,
     646                 :            :                 .plus           = plus
     647                 :            :         };
     648                 :          0 :         struct rpc_message      msg = {
     649                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READDIR],
     650                 :            :                 .rpc_argp       = &arg,
     651                 :            :                 .rpc_resp       = &res,
     652                 :            :                 .rpc_cred       = cred,
     653                 :            :         };
     654                 :            :         int status = -ENOMEM;
     655                 :            : 
     656         [ #  # ]:          0 :         if (plus)
     657                 :          0 :                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
     658                 :            : 
     659                 :            :         dprintk("NFS call  readdir%s %d\n",
     660                 :            :                         plus? "plus" : "", (unsigned int) cookie);
     661                 :            : 
     662                 :          0 :         res.dir_attr = nfs_alloc_fattr();
     663         [ #  # ]:          0 :         if (res.dir_attr == NULL)
     664                 :            :                 goto out;
     665                 :            : 
     666                 :          0 :         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
     667                 :            : 
     668                 :          0 :         nfs_invalidate_atime(dir);
     669                 :          0 :         nfs_refresh_inode(dir, res.dir_attr);
     670                 :            : 
     671                 :          0 :         nfs_free_fattr(res.dir_attr);
     672                 :            : out:
     673                 :            :         dprintk("NFS reply readdir%s: %d\n",
     674                 :            :                         plus? "plus" : "", status);
     675                 :          0 :         return status;
     676                 :            : }
     677                 :            : 
     678                 :            : static int
     679                 :          0 : nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
     680                 :            :                 dev_t rdev)
     681                 :            : {
     682                 :            :         struct posix_acl *default_acl, *acl;
     683                 :            :         struct nfs3_createdata *data;
     684                 :            :         struct dentry *d_alias;
     685                 :            :         int status = -ENOMEM;
     686                 :            : 
     687                 :            :         dprintk("NFS call  mknod %pd %u:%u\n", dentry,
     688                 :            :                         MAJOR(rdev), MINOR(rdev));
     689                 :            : 
     690                 :          0 :         data = nfs3_alloc_createdata();
     691         [ #  # ]:          0 :         if (data == NULL)
     692                 :            :                 goto out;
     693                 :            : 
     694                 :          0 :         status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
     695         [ #  # ]:          0 :         if (status)
     696                 :            :                 goto out;
     697                 :            : 
     698                 :          0 :         data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
     699                 :          0 :         data->arg.mknod.fh = NFS_FH(dir);
     700                 :          0 :         data->arg.mknod.name = dentry->d_name.name;
     701                 :          0 :         data->arg.mknod.len = dentry->d_name.len;
     702                 :          0 :         data->arg.mknod.sattr = sattr;
     703                 :          0 :         data->arg.mknod.rdev = rdev;
     704                 :            : 
     705   [ #  #  #  #  :          0 :         switch (sattr->ia_mode & S_IFMT) {
                      # ]
     706                 :            :         case S_IFBLK:
     707                 :          0 :                 data->arg.mknod.type = NF3BLK;
     708                 :          0 :                 break;
     709                 :            :         case S_IFCHR:
     710                 :          0 :                 data->arg.mknod.type = NF3CHR;
     711                 :          0 :                 break;
     712                 :            :         case S_IFIFO:
     713                 :          0 :                 data->arg.mknod.type = NF3FIFO;
     714                 :          0 :                 break;
     715                 :            :         case S_IFSOCK:
     716                 :          0 :                 data->arg.mknod.type = NF3SOCK;
     717                 :          0 :                 break;
     718                 :            :         default:
     719                 :            :                 status = -EINVAL;
     720                 :            :                 goto out;
     721                 :            :         }
     722                 :            : 
     723                 :          0 :         d_alias = nfs3_do_create(dir, dentry, data);
     724                 :            :         status = PTR_ERR_OR_ZERO(d_alias);
     725         [ #  # ]:          0 :         if (status != 0)
     726                 :            :                 goto out_release_acls;
     727                 :            : 
     728         [ #  # ]:          0 :         if (d_alias)
     729                 :            :                 dentry = d_alias;
     730                 :            : 
     731                 :          0 :         status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
     732                 :            : 
     733                 :          0 :         dput(d_alias);
     734                 :            : out_release_acls:
     735                 :          0 :         posix_acl_release(acl);
     736                 :          0 :         posix_acl_release(default_acl);
     737                 :            : out:
     738                 :            :         nfs3_free_createdata(data);
     739                 :            :         dprintk("NFS reply mknod: %d\n", status);
     740                 :          0 :         return status;
     741                 :            : }
     742                 :            : 
     743                 :            : static int
     744                 :          0 : nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
     745                 :            :                  struct nfs_fsstat *stat)
     746                 :            : {
     747                 :          0 :         struct rpc_message msg = {
     748                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSSTAT],
     749                 :            :                 .rpc_argp       = fhandle,
     750                 :            :                 .rpc_resp       = stat,
     751                 :            :         };
     752                 :            :         int     status;
     753                 :            : 
     754                 :            :         dprintk("NFS call  fsstat\n");
     755                 :          0 :         nfs_fattr_init(stat->fattr);
     756                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     757                 :            :         dprintk("NFS reply fsstat: %d\n", status);
     758                 :          0 :         return status;
     759                 :            : }
     760                 :            : 
     761                 :            : static int
     762                 :          0 : do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
     763                 :            :                  struct nfs_fsinfo *info)
     764                 :            : {
     765                 :          0 :         struct rpc_message msg = {
     766                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
     767                 :            :                 .rpc_argp       = fhandle,
     768                 :            :                 .rpc_resp       = info,
     769                 :            :         };
     770                 :            :         int     status;
     771                 :            : 
     772                 :            :         dprintk("NFS call  fsinfo\n");
     773                 :          0 :         nfs_fattr_init(info->fattr);
     774                 :          0 :         status = rpc_call_sync(client, &msg, 0);
     775                 :            :         dprintk("NFS reply fsinfo: %d\n", status);
     776                 :          0 :         return status;
     777                 :            : }
     778                 :            : 
     779                 :            : /*
     780                 :            :  * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
     781                 :            :  * nfs_create_server
     782                 :            :  */
     783                 :            : static int
     784                 :          0 : nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
     785                 :            :                    struct nfs_fsinfo *info)
     786                 :            : {
     787                 :            :         int     status;
     788                 :            : 
     789                 :          0 :         status = do_proc_fsinfo(server->client, fhandle, info);
     790   [ #  #  #  # ]:          0 :         if (status && server->nfs_client->cl_rpcclient != server->client)
     791                 :          0 :                 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
     792                 :          0 :         return status;
     793                 :            : }
     794                 :            : 
     795                 :            : static int
     796                 :          0 : nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
     797                 :            :                    struct nfs_pathconf *info)
     798                 :            : {
     799                 :          0 :         struct rpc_message msg = {
     800                 :            :                 .rpc_proc       = &nfs3_procedures[NFS3PROC_PATHCONF],
     801                 :            :                 .rpc_argp       = fhandle,
     802                 :            :                 .rpc_resp       = info,
     803                 :            :         };
     804                 :            :         int     status;
     805                 :            : 
     806                 :            :         dprintk("NFS call  pathconf\n");
     807                 :          0 :         nfs_fattr_init(info->fattr);
     808                 :          0 :         status = rpc_call_sync(server->client, &msg, 0);
     809                 :            :         dprintk("NFS reply pathconf: %d\n", status);
     810                 :          0 :         return status;
     811                 :            : }
     812                 :            : 
     813                 :          0 : static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
     814                 :            : {
     815                 :          0 :         struct inode *inode = hdr->inode;
     816                 :            :         struct nfs_server *server = NFS_SERVER(inode);
     817                 :            : 
     818         [ #  # ]:          0 :         if (hdr->pgio_done_cb != NULL)
     819                 :          0 :                 return hdr->pgio_done_cb(task, hdr);
     820                 :            : 
     821         [ #  # ]:          0 :         if (nfs3_async_handle_jukebox(task, inode))
     822                 :            :                 return -EAGAIN;
     823                 :            : 
     824   [ #  #  #  # ]:          0 :         if (task->tk_status >= 0 && !server->read_hdrsize)
     825                 :          0 :                 cmpxchg(&server->read_hdrsize, 0, hdr->res.replen);
     826                 :            : 
     827                 :          0 :         nfs_invalidate_atime(inode);
     828                 :          0 :         nfs_refresh_inode(inode, &hdr->fattr);
     829                 :          0 :         return 0;
     830                 :            : }
     831                 :            : 
     832                 :          0 : static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr,
     833                 :            :                                  struct rpc_message *msg)
     834                 :            : {
     835                 :          0 :         msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
     836                 :          0 :         hdr->args.replen = NFS_SERVER(hdr->inode)->read_hdrsize;
     837                 :          0 : }
     838                 :            : 
     839                 :          0 : static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task,
     840                 :            :                                       struct nfs_pgio_header *hdr)
     841                 :            : {
     842                 :          0 :         rpc_call_start(task);
     843                 :          0 :         return 0;
     844                 :            : }
     845                 :            : 
     846                 :          0 : static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
     847                 :            : {
     848                 :          0 :         struct inode *inode = hdr->inode;
     849                 :            : 
     850         [ #  # ]:          0 :         if (hdr->pgio_done_cb != NULL)
     851                 :          0 :                 return hdr->pgio_done_cb(task, hdr);
     852                 :            : 
     853         [ #  # ]:          0 :         if (nfs3_async_handle_jukebox(task, inode))
     854                 :            :                 return -EAGAIN;
     855         [ #  # ]:          0 :         if (task->tk_status >= 0)
     856                 :          0 :                 nfs_writeback_update_inode(hdr);
     857                 :            :         return 0;
     858                 :            : }
     859                 :            : 
     860                 :          0 : static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr,
     861                 :            :                                   struct rpc_message *msg,
     862                 :            :                                   struct rpc_clnt **clnt)
     863                 :            : {
     864                 :          0 :         msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
     865                 :          0 : }
     866                 :            : 
     867                 :          0 : static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
     868                 :            : {
     869                 :          0 :         rpc_call_start(task);
     870                 :          0 : }
     871                 :            : 
     872                 :          0 : static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
     873                 :            : {
     874         [ #  # ]:          0 :         if (data->commit_done_cb != NULL)
     875                 :          0 :                 return data->commit_done_cb(task, data);
     876                 :            : 
     877         [ #  # ]:          0 :         if (nfs3_async_handle_jukebox(task, data->inode))
     878                 :            :                 return -EAGAIN;
     879                 :          0 :         nfs_refresh_inode(data->inode, data->res.fattr);
     880                 :          0 :         return 0;
     881                 :            : }
     882                 :            : 
     883                 :          0 : static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
     884                 :            :                                    struct rpc_clnt **clnt)
     885                 :            : {
     886                 :          0 :         msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
     887                 :          0 : }
     888                 :            : 
     889                 :          0 : static void nfs3_nlm_alloc_call(void *data)
     890                 :            : {
     891                 :            :         struct nfs_lock_context *l_ctx = data;
     892   [ #  #  #  # ]:          0 :         if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) {
     893                 :          0 :                 get_nfs_open_context(l_ctx->open_context);
     894                 :          0 :                 nfs_get_lock_context(l_ctx->open_context);
     895                 :            :         }
     896                 :          0 : }
     897                 :            : 
     898                 :          0 : static bool nfs3_nlm_unlock_prepare(struct rpc_task *task, void *data)
     899                 :            : {
     900                 :            :         struct nfs_lock_context *l_ctx = data;
     901   [ #  #  #  # ]:          0 :         if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags))
     902                 :          0 :                 return nfs_async_iocounter_wait(task, l_ctx);
     903                 :            :         return false;
     904                 :            : 
     905                 :            : }
     906                 :            : 
     907                 :          0 : static void nfs3_nlm_release_call(void *data)
     908                 :            : {
     909                 :            :         struct nfs_lock_context *l_ctx = data;
     910                 :            :         struct nfs_open_context *ctx;
     911   [ #  #  #  # ]:          0 :         if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) {
     912                 :            :                 ctx = l_ctx->open_context;
     913                 :          0 :                 nfs_put_lock_context(l_ctx);
     914                 :          0 :                 put_nfs_open_context(ctx);
     915                 :            :         }
     916                 :          0 : }
     917                 :            : 
     918                 :            : static const struct nlmclnt_operations nlmclnt_fl_close_lock_ops = {
     919                 :            :         .nlmclnt_alloc_call = nfs3_nlm_alloc_call,
     920                 :            :         .nlmclnt_unlock_prepare = nfs3_nlm_unlock_prepare,
     921                 :            :         .nlmclnt_release_call = nfs3_nlm_release_call,
     922                 :            : };
     923                 :            : 
     924                 :            : static int
     925                 :          0 : nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
     926                 :            : {
     927                 :            :         struct inode *inode = file_inode(filp);
     928                 :            :         struct nfs_lock_context *l_ctx = NULL;
     929                 :            :         struct nfs_open_context *ctx = nfs_file_open_context(filp);
     930                 :            :         int status;
     931                 :            : 
     932         [ #  # ]:          0 :         if (fl->fl_flags & FL_CLOSE) {
     933                 :          0 :                 l_ctx = nfs_get_lock_context(ctx);
     934         [ #  # ]:          0 :                 if (IS_ERR(l_ctx))
     935                 :            :                         l_ctx = NULL;
     936                 :            :                 else
     937                 :          0 :                         set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags);
     938                 :            :         }
     939                 :            : 
     940                 :          0 :         status = nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, l_ctx);
     941                 :            : 
     942         [ #  # ]:          0 :         if (l_ctx)
     943                 :          0 :                 nfs_put_lock_context(l_ctx);
     944                 :            : 
     945                 :          0 :         return status;
     946                 :            : }
     947                 :            : 
     948                 :          0 : static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
     949                 :            : {
     950                 :          0 :         return 0;
     951                 :            : }
     952                 :            : 
     953                 :            : static const struct inode_operations nfs3_dir_inode_operations = {
     954                 :            :         .create         = nfs_create,
     955                 :            :         .lookup         = nfs_lookup,
     956                 :            :         .link           = nfs_link,
     957                 :            :         .unlink         = nfs_unlink,
     958                 :            :         .symlink        = nfs_symlink,
     959                 :            :         .mkdir          = nfs_mkdir,
     960                 :            :         .rmdir          = nfs_rmdir,
     961                 :            :         .mknod          = nfs_mknod,
     962                 :            :         .rename         = nfs_rename,
     963                 :            :         .permission     = nfs_permission,
     964                 :            :         .getattr        = nfs_getattr,
     965                 :            :         .setattr        = nfs_setattr,
     966                 :            : #ifdef CONFIG_NFS_V3_ACL
     967                 :            :         .listxattr      = nfs3_listxattr,
     968                 :            :         .get_acl        = nfs3_get_acl,
     969                 :            :         .set_acl        = nfs3_set_acl,
     970                 :            : #endif
     971                 :            : };
     972                 :            : 
     973                 :            : static const struct inode_operations nfs3_file_inode_operations = {
     974                 :            :         .permission     = nfs_permission,
     975                 :            :         .getattr        = nfs_getattr,
     976                 :            :         .setattr        = nfs_setattr,
     977                 :            : #ifdef CONFIG_NFS_V3_ACL
     978                 :            :         .listxattr      = nfs3_listxattr,
     979                 :            :         .get_acl        = nfs3_get_acl,
     980                 :            :         .set_acl        = nfs3_set_acl,
     981                 :            : #endif
     982                 :            : };
     983                 :            : 
     984                 :            : const struct nfs_rpc_ops nfs_v3_clientops = {
     985                 :            :         .version        = 3,                    /* protocol version */
     986                 :            :         .dentry_ops     = &nfs_dentry_operations,
     987                 :            :         .dir_inode_ops  = &nfs3_dir_inode_operations,
     988                 :            :         .file_inode_ops = &nfs3_file_inode_operations,
     989                 :            :         .file_ops       = &nfs_file_operations,
     990                 :            :         .nlmclnt_ops    = &nlmclnt_fl_close_lock_ops,
     991                 :            :         .getroot        = nfs3_proc_get_root,
     992                 :            :         .submount       = nfs_submount,
     993                 :            :         .try_mount      = nfs_try_mount,
     994                 :            :         .getattr        = nfs3_proc_getattr,
     995                 :            :         .setattr        = nfs3_proc_setattr,
     996                 :            :         .lookup         = nfs3_proc_lookup,
     997                 :            :         .access         = nfs3_proc_access,
     998                 :            :         .readlink       = nfs3_proc_readlink,
     999                 :            :         .create         = nfs3_proc_create,
    1000                 :            :         .remove         = nfs3_proc_remove,
    1001                 :            :         .unlink_setup   = nfs3_proc_unlink_setup,
    1002                 :            :         .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
    1003                 :            :         .unlink_done    = nfs3_proc_unlink_done,
    1004                 :            :         .rename_setup   = nfs3_proc_rename_setup,
    1005                 :            :         .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
    1006                 :            :         .rename_done    = nfs3_proc_rename_done,
    1007                 :            :         .link           = nfs3_proc_link,
    1008                 :            :         .symlink        = nfs3_proc_symlink,
    1009                 :            :         .mkdir          = nfs3_proc_mkdir,
    1010                 :            :         .rmdir          = nfs3_proc_rmdir,
    1011                 :            :         .readdir        = nfs3_proc_readdir,
    1012                 :            :         .mknod          = nfs3_proc_mknod,
    1013                 :            :         .statfs         = nfs3_proc_statfs,
    1014                 :            :         .fsinfo         = nfs3_proc_fsinfo,
    1015                 :            :         .pathconf       = nfs3_proc_pathconf,
    1016                 :            :         .decode_dirent  = nfs3_decode_dirent,
    1017                 :            :         .pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare,
    1018                 :            :         .read_setup     = nfs3_proc_read_setup,
    1019                 :            :         .read_done      = nfs3_read_done,
    1020                 :            :         .write_setup    = nfs3_proc_write_setup,
    1021                 :            :         .write_done     = nfs3_write_done,
    1022                 :            :         .commit_setup   = nfs3_proc_commit_setup,
    1023                 :            :         .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
    1024                 :            :         .commit_done    = nfs3_commit_done,
    1025                 :            :         .lock           = nfs3_proc_lock,
    1026                 :            :         .clear_acl_cache = forget_all_cached_acls,
    1027                 :            :         .close_context  = nfs_close_context,
    1028                 :            :         .have_delegation = nfs3_have_delegation,
    1029                 :            :         .alloc_client   = nfs_alloc_client,
    1030                 :            :         .init_client    = nfs_init_client,
    1031                 :            :         .free_client    = nfs_free_client,
    1032                 :            :         .create_server  = nfs3_create_server,
    1033                 :            :         .clone_server   = nfs3_clone_server,
    1034                 :            : };

Generated by: LCOV version 1.14