Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
0004  */
0005 #include <linux/fs.h>
0006 #include <linux/sunrpc/addr.h>
0007 #include <linux/sunrpc/sched.h>
0008 #include <linux/nfs.h>
0009 #include <linux/nfs3.h>
0010 #include <linux/nfs4.h>
0011 #include <linux/nfs_xdr.h>
0012 #include <linux/nfs_fs.h>
0013 #include "nfs4_fs.h"
0014 #include "nfs42.h"
0015 #include "iostat.h"
0016 #include "pnfs.h"
0017 #include "nfs4session.h"
0018 #include "internal.h"
0019 #include "delegation.h"
0020 #include "nfs4trace.h"
0021 
0022 #define NFSDBG_FACILITY NFSDBG_PROC
0023 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
0024 
0025 static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
0026 {
0027     struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
0028     unsigned short port = 2049;
0029 
0030     rcu_read_lock();
0031     naddr->netid_len = scnprintf(naddr->netid,
0032                     sizeof(naddr->netid), "%s",
0033                     rpc_peeraddr2str(clp->cl_rpcclient,
0034                     RPC_DISPLAY_NETID));
0035     naddr->addr_len = scnprintf(naddr->addr,
0036                     sizeof(naddr->addr),
0037                     "%s.%u.%u",
0038                     rpc_peeraddr2str(clp->cl_rpcclient,
0039                     RPC_DISPLAY_ADDR),
0040                     port >> 8, port & 255);
0041     rcu_read_unlock();
0042 }
0043 
0044 static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
0045         struct nfs_lock_context *lock, loff_t offset, loff_t len)
0046 {
0047     struct inode *inode = file_inode(filep);
0048     struct nfs_server *server = NFS_SERVER(inode);
0049     u32 bitmask[NFS_BITMASK_SZ];
0050     struct nfs42_falloc_args args = {
0051         .falloc_fh  = NFS_FH(inode),
0052         .falloc_offset  = offset,
0053         .falloc_length  = len,
0054         .falloc_bitmask = bitmask,
0055     };
0056     struct nfs42_falloc_res res = {
0057         .falloc_server  = server,
0058     };
0059     int status;
0060 
0061     msg->rpc_argp = &args;
0062     msg->rpc_resp = &res;
0063 
0064     status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
0065             lock, FMODE_WRITE);
0066     if (status) {
0067         if (status == -EAGAIN)
0068             status = -NFS4ERR_BAD_STATEID;
0069         return status;
0070     }
0071 
0072     nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask, inode,
0073              NFS_INO_INVALID_BLOCKS);
0074 
0075     res.falloc_fattr = nfs_alloc_fattr();
0076     if (!res.falloc_fattr)
0077         return -ENOMEM;
0078 
0079     status = nfs4_call_sync(server->client, server, msg,
0080                 &args.seq_args, &res.seq_res, 0);
0081     if (status == 0) {
0082         if (nfs_should_remove_suid(inode)) {
0083             spin_lock(&inode->i_lock);
0084             nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
0085             spin_unlock(&inode->i_lock);
0086         }
0087         status = nfs_post_op_update_inode_force_wcc(inode,
0088                                 res.falloc_fattr);
0089     }
0090     if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE])
0091         trace_nfs4_fallocate(inode, &args, status);
0092     else
0093         trace_nfs4_deallocate(inode, &args, status);
0094     kfree(res.falloc_fattr);
0095     return status;
0096 }
0097 
0098 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
0099                 loff_t offset, loff_t len)
0100 {
0101     struct inode *inode = file_inode(filep);
0102     struct nfs_server *server = NFS_SERVER(inode);
0103     struct nfs4_exception exception = { };
0104     struct nfs_lock_context *lock;
0105     int err;
0106 
0107     lock = nfs_get_lock_context(nfs_file_open_context(filep));
0108     if (IS_ERR(lock))
0109         return PTR_ERR(lock);
0110 
0111     exception.inode = inode;
0112     exception.state = lock->open_context->state;
0113 
0114     err = nfs_sync_inode(inode);
0115     if (err)
0116         goto out;
0117 
0118     do {
0119         err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
0120         if (err == -ENOTSUPP) {
0121             err = -EOPNOTSUPP;
0122             break;
0123         }
0124         err = nfs4_handle_exception(server, err, &exception);
0125     } while (exception.retry);
0126 out:
0127     nfs_put_lock_context(lock);
0128     return err;
0129 }
0130 
0131 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
0132 {
0133     struct rpc_message msg = {
0134         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
0135     };
0136     struct inode *inode = file_inode(filep);
0137     int err;
0138 
0139     if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
0140         return -EOPNOTSUPP;
0141 
0142     inode_lock(inode);
0143 
0144     err = nfs42_proc_fallocate(&msg, filep, offset, len);
0145     if (err == -EOPNOTSUPP)
0146         NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
0147 
0148     inode_unlock(inode);
0149     return err;
0150 }
0151 
0152 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
0153 {
0154     struct rpc_message msg = {
0155         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
0156     };
0157     struct inode *inode = file_inode(filep);
0158     int err;
0159 
0160     if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
0161         return -EOPNOTSUPP;
0162 
0163     inode_lock(inode);
0164 
0165     err = nfs42_proc_fallocate(&msg, filep, offset, len);
0166     if (err == 0)
0167         truncate_pagecache_range(inode, offset, (offset + len) -1);
0168     if (err == -EOPNOTSUPP)
0169         NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
0170 
0171     inode_unlock(inode);
0172     return err;
0173 }
0174 
0175 static int handle_async_copy(struct nfs42_copy_res *res,
0176                  struct nfs_server *dst_server,
0177                  struct nfs_server *src_server,
0178                  struct file *src,
0179                  struct file *dst,
0180                  nfs4_stateid *src_stateid,
0181                  bool *restart)
0182 {
0183     struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter;
0184     int status = NFS4_OK;
0185     struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
0186     struct nfs_open_context *src_ctx = nfs_file_open_context(src);
0187 
0188     copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_KERNEL);
0189     if (!copy)
0190         return -ENOMEM;
0191 
0192     spin_lock(&dst_server->nfs_client->cl_lock);
0193     list_for_each_entry(iter,
0194                 &dst_server->nfs_client->pending_cb_stateids,
0195                 copies) {
0196         if (memcmp(&res->write_res.stateid, &iter->stateid,
0197                 NFS4_STATEID_SIZE))
0198             continue;
0199         tmp_copy = iter;
0200         list_del(&iter->copies);
0201         break;
0202     }
0203     if (tmp_copy) {
0204         spin_unlock(&dst_server->nfs_client->cl_lock);
0205         kfree(copy);
0206         copy = tmp_copy;
0207         goto out;
0208     }
0209 
0210     memcpy(&copy->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
0211     init_completion(&copy->completion);
0212     copy->parent_dst_state = dst_ctx->state;
0213     copy->parent_src_state = src_ctx->state;
0214 
0215     list_add_tail(&copy->copies, &dst_server->ss_copies);
0216     spin_unlock(&dst_server->nfs_client->cl_lock);
0217 
0218     if (dst_server != src_server) {
0219         spin_lock(&src_server->nfs_client->cl_lock);
0220         list_add_tail(&copy->src_copies, &src_server->ss_copies);
0221         spin_unlock(&src_server->nfs_client->cl_lock);
0222     }
0223 
0224     status = wait_for_completion_interruptible(&copy->completion);
0225     spin_lock(&dst_server->nfs_client->cl_lock);
0226     list_del_init(&copy->copies);
0227     spin_unlock(&dst_server->nfs_client->cl_lock);
0228     if (dst_server != src_server) {
0229         spin_lock(&src_server->nfs_client->cl_lock);
0230         list_del_init(&copy->src_copies);
0231         spin_unlock(&src_server->nfs_client->cl_lock);
0232     }
0233     if (status == -ERESTARTSYS) {
0234         goto out_cancel;
0235     } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
0236         status = -EAGAIN;
0237         *restart = true;
0238         goto out_cancel;
0239     }
0240 out:
0241     res->write_res.count = copy->count;
0242     memcpy(&res->write_res.verifier, &copy->verf, sizeof(copy->verf));
0243     status = -copy->error;
0244 
0245 out_free:
0246     kfree(copy);
0247     return status;
0248 out_cancel:
0249     nfs42_do_offload_cancel_async(dst, &copy->stateid);
0250     if (!nfs42_files_from_same_server(src, dst))
0251         nfs42_do_offload_cancel_async(src, src_stateid);
0252     goto out_free;
0253 }
0254 
0255 static int process_copy_commit(struct file *dst, loff_t pos_dst,
0256                    struct nfs42_copy_res *res)
0257 {
0258     struct nfs_commitres cres;
0259     int status = -ENOMEM;
0260 
0261     cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_KERNEL);
0262     if (!cres.verf)
0263         goto out;
0264 
0265     status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
0266     if (status)
0267         goto out_free;
0268     if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
0269                     &cres.verf->verifier)) {
0270         dprintk("commit verf differs from copy verf\n");
0271         status = -EAGAIN;
0272     }
0273 out_free:
0274     kfree(cres.verf);
0275 out:
0276     return status;
0277 }
0278 
0279 /**
0280  * nfs42_copy_dest_done - perform inode cache updates after clone/copy offload
0281  * @inode: pointer to destination inode
0282  * @pos: destination offset
0283  * @len: copy length
0284  *
0285  * Punch a hole in the inode page cache, so that the NFS client will
0286  * know to retrieve new data.
0287  * Update the file size if necessary, and then mark the inode as having
0288  * invalid cached values for change attribute, ctime, mtime and space used.
0289  */
0290 static void nfs42_copy_dest_done(struct inode *inode, loff_t pos, loff_t len)
0291 {
0292     loff_t newsize = pos + len;
0293     loff_t end = newsize - 1;
0294 
0295     WARN_ON_ONCE(invalidate_inode_pages2_range(inode->i_mapping,
0296                 pos >> PAGE_SHIFT, end >> PAGE_SHIFT));
0297 
0298     spin_lock(&inode->i_lock);
0299     if (newsize > i_size_read(inode))
0300         i_size_write(inode, newsize);
0301     nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
0302                          NFS_INO_INVALID_CTIME |
0303                          NFS_INO_INVALID_MTIME |
0304                          NFS_INO_INVALID_BLOCKS);
0305     spin_unlock(&inode->i_lock);
0306 }
0307 
0308 static ssize_t _nfs42_proc_copy(struct file *src,
0309                 struct nfs_lock_context *src_lock,
0310                 struct file *dst,
0311                 struct nfs_lock_context *dst_lock,
0312                 struct nfs42_copy_args *args,
0313                 struct nfs42_copy_res *res,
0314                 struct nl4_server *nss,
0315                 nfs4_stateid *cnr_stateid,
0316                 bool *restart)
0317 {
0318     struct rpc_message msg = {
0319         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
0320         .rpc_argp = args,
0321         .rpc_resp = res,
0322     };
0323     struct inode *dst_inode = file_inode(dst);
0324     struct inode *src_inode = file_inode(src);
0325     struct nfs_server *dst_server = NFS_SERVER(dst_inode);
0326     struct nfs_server *src_server = NFS_SERVER(src_inode);
0327     loff_t pos_src = args->src_pos;
0328     loff_t pos_dst = args->dst_pos;
0329     size_t count = args->count;
0330     ssize_t status;
0331 
0332     if (nss) {
0333         args->cp_src = nss;
0334         nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
0335     } else {
0336         status = nfs4_set_rw_stateid(&args->src_stateid,
0337                 src_lock->open_context, src_lock, FMODE_READ);
0338         if (status) {
0339             if (status == -EAGAIN)
0340                 status = -NFS4ERR_BAD_STATEID;
0341             return status;
0342         }
0343     }
0344     status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
0345             pos_src, pos_src + (loff_t)count - 1);
0346     if (status)
0347         return status;
0348 
0349     status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
0350                      dst_lock, FMODE_WRITE);
0351     if (status) {
0352         if (status == -EAGAIN)
0353             status = -NFS4ERR_BAD_STATEID;
0354         return status;
0355     }
0356 
0357     status = nfs_sync_inode(dst_inode);
0358     if (status)
0359         return status;
0360 
0361     res->commit_res.verf = NULL;
0362     if (args->sync) {
0363         res->commit_res.verf =
0364             kzalloc(sizeof(struct nfs_writeverf), GFP_KERNEL);
0365         if (!res->commit_res.verf)
0366             return -ENOMEM;
0367     }
0368     set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
0369         &src_lock->open_context->state->flags);
0370     set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
0371         &dst_lock->open_context->state->flags);
0372 
0373     status = nfs4_call_sync(dst_server->client, dst_server, &msg,
0374                 &args->seq_args, &res->seq_res, 0);
0375     trace_nfs4_copy(src_inode, dst_inode, args, res, nss, status);
0376     if (status == -ENOTSUPP)
0377         dst_server->caps &= ~NFS_CAP_COPY;
0378     if (status)
0379         goto out;
0380 
0381     if (args->sync &&
0382         nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
0383                     &res->commit_res.verf->verifier)) {
0384         status = -EAGAIN;
0385         goto out;
0386     }
0387 
0388     if (!res->synchronous) {
0389         status = handle_async_copy(res, dst_server, src_server, src,
0390                 dst, &args->src_stateid, restart);
0391         if (status)
0392             goto out;
0393     }
0394 
0395     if ((!res->synchronous || !args->sync) &&
0396             res->write_res.verifier.committed != NFS_FILE_SYNC) {
0397         status = process_copy_commit(dst, pos_dst, res);
0398         if (status)
0399             goto out;
0400     }
0401 
0402     nfs42_copy_dest_done(dst_inode, pos_dst, res->write_res.count);
0403     nfs_invalidate_atime(src_inode);
0404     status = res->write_res.count;
0405 out:
0406     if (args->sync)
0407         kfree(res->commit_res.verf);
0408     return status;
0409 }
0410 
0411 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
0412             struct file *dst, loff_t pos_dst, size_t count,
0413             struct nl4_server *nss,
0414             nfs4_stateid *cnr_stateid, bool sync)
0415 {
0416     struct nfs_server *server = NFS_SERVER(file_inode(dst));
0417     struct nfs_lock_context *src_lock;
0418     struct nfs_lock_context *dst_lock;
0419     struct nfs42_copy_args args = {
0420         .src_fh     = NFS_FH(file_inode(src)),
0421         .src_pos    = pos_src,
0422         .dst_fh     = NFS_FH(file_inode(dst)),
0423         .dst_pos    = pos_dst,
0424         .count      = count,
0425         .sync       = sync,
0426     };
0427     struct nfs42_copy_res res;
0428     struct nfs4_exception src_exception = {
0429         .inode      = file_inode(src),
0430         .stateid    = &args.src_stateid,
0431     };
0432     struct nfs4_exception dst_exception = {
0433         .inode      = file_inode(dst),
0434         .stateid    = &args.dst_stateid,
0435     };
0436     ssize_t err, err2;
0437     bool restart = false;
0438 
0439     src_lock = nfs_get_lock_context(nfs_file_open_context(src));
0440     if (IS_ERR(src_lock))
0441         return PTR_ERR(src_lock);
0442 
0443     src_exception.state = src_lock->open_context->state;
0444 
0445     dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
0446     if (IS_ERR(dst_lock)) {
0447         err = PTR_ERR(dst_lock);
0448         goto out_put_src_lock;
0449     }
0450 
0451     dst_exception.state = dst_lock->open_context->state;
0452 
0453     do {
0454         inode_lock(file_inode(dst));
0455         err = _nfs42_proc_copy(src, src_lock,
0456                 dst, dst_lock,
0457                 &args, &res,
0458                 nss, cnr_stateid, &restart);
0459         inode_unlock(file_inode(dst));
0460 
0461         if (err >= 0)
0462             break;
0463         if (err == -ENOTSUPP &&
0464                 nfs42_files_from_same_server(src, dst)) {
0465             err = -EOPNOTSUPP;
0466             break;
0467         } else if (err == -EAGAIN) {
0468             if (!restart) {
0469                 dst_exception.retry = 1;
0470                 continue;
0471             }
0472             break;
0473         } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
0474             args.sync = true;
0475             dst_exception.retry = 1;
0476             continue;
0477         } else if ((err == -ESTALE ||
0478                 err == -NFS4ERR_OFFLOAD_DENIED ||
0479                 err == -ENOTSUPP) &&
0480                 !nfs42_files_from_same_server(src, dst)) {
0481             nfs42_do_offload_cancel_async(src, &args.src_stateid);
0482             err = -EOPNOTSUPP;
0483             break;
0484         }
0485 
0486         err2 = nfs4_handle_exception(server, err, &src_exception);
0487         err  = nfs4_handle_exception(server, err, &dst_exception);
0488         if (!err)
0489             err = err2;
0490     } while (src_exception.retry || dst_exception.retry);
0491 
0492     nfs_put_lock_context(dst_lock);
0493 out_put_src_lock:
0494     nfs_put_lock_context(src_lock);
0495     return err;
0496 }
0497 
0498 struct nfs42_offloadcancel_data {
0499     struct nfs_server *seq_server;
0500     struct nfs42_offload_status_args args;
0501     struct nfs42_offload_status_res res;
0502 };
0503 
0504 static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
0505 {
0506     struct nfs42_offloadcancel_data *data = calldata;
0507 
0508     nfs4_setup_sequence(data->seq_server->nfs_client,
0509                 &data->args.osa_seq_args,
0510                 &data->res.osr_seq_res, task);
0511 }
0512 
0513 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
0514 {
0515     struct nfs42_offloadcancel_data *data = calldata;
0516 
0517     trace_nfs4_offload_cancel(&data->args, task->tk_status);
0518     nfs41_sequence_done(task, &data->res.osr_seq_res);
0519     if (task->tk_status &&
0520         nfs4_async_handle_error(task, data->seq_server, NULL,
0521             NULL) == -EAGAIN)
0522         rpc_restart_call_prepare(task);
0523 }
0524 
0525 static void nfs42_free_offloadcancel_data(void *data)
0526 {
0527     kfree(data);
0528 }
0529 
0530 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
0531     .rpc_call_prepare = nfs42_offload_cancel_prepare,
0532     .rpc_call_done = nfs42_offload_cancel_done,
0533     .rpc_release = nfs42_free_offloadcancel_data,
0534 };
0535 
0536 static int nfs42_do_offload_cancel_async(struct file *dst,
0537                      nfs4_stateid *stateid)
0538 {
0539     struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
0540     struct nfs42_offloadcancel_data *data = NULL;
0541     struct nfs_open_context *ctx = nfs_file_open_context(dst);
0542     struct rpc_task *task;
0543     struct rpc_message msg = {
0544         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
0545         .rpc_cred = ctx->cred,
0546     };
0547     struct rpc_task_setup task_setup_data = {
0548         .rpc_client = dst_server->client,
0549         .rpc_message = &msg,
0550         .callback_ops = &nfs42_offload_cancel_ops,
0551         .workqueue = nfsiod_workqueue,
0552         .flags = RPC_TASK_ASYNC,
0553     };
0554     int status;
0555 
0556     if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
0557         return -EOPNOTSUPP;
0558 
0559     data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_KERNEL);
0560     if (data == NULL)
0561         return -ENOMEM;
0562 
0563     data->seq_server = dst_server;
0564     data->args.osa_src_fh = NFS_FH(file_inode(dst));
0565     memcpy(&data->args.osa_stateid, stateid,
0566         sizeof(data->args.osa_stateid));
0567     msg.rpc_argp = &data->args;
0568     msg.rpc_resp = &data->res;
0569     task_setup_data.callback_data = data;
0570     nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
0571                1, 0);
0572     task = rpc_run_task(&task_setup_data);
0573     if (IS_ERR(task))
0574         return PTR_ERR(task);
0575     status = rpc_wait_for_completion_task(task);
0576     if (status == -ENOTSUPP)
0577         dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
0578     rpc_put_task(task);
0579     return status;
0580 }
0581 
0582 static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
0583                    struct nfs42_copy_notify_args *args,
0584                    struct nfs42_copy_notify_res *res)
0585 {
0586     struct nfs_server *src_server = NFS_SERVER(file_inode(src));
0587     struct rpc_message msg = {
0588         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
0589         .rpc_argp = args,
0590         .rpc_resp = res,
0591     };
0592     int status;
0593     struct nfs_open_context *ctx;
0594     struct nfs_lock_context *l_ctx;
0595 
0596     ctx = get_nfs_open_context(nfs_file_open_context(src));
0597     l_ctx = nfs_get_lock_context(ctx);
0598     if (IS_ERR(l_ctx)) {
0599         status = PTR_ERR(l_ctx);
0600         goto out;
0601     }
0602 
0603     status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
0604                      FMODE_READ);
0605     nfs_put_lock_context(l_ctx);
0606     if (status) {
0607         if (status == -EAGAIN)
0608             status = -NFS4ERR_BAD_STATEID;
0609         goto out;
0610     }
0611 
0612     status = nfs4_call_sync(src_server->client, src_server, &msg,
0613                 &args->cna_seq_args, &res->cnr_seq_res, 0);
0614     trace_nfs4_copy_notify(file_inode(src), args, res, status);
0615     if (status == -ENOTSUPP)
0616         src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
0617 
0618 out:
0619     put_nfs_open_context(nfs_file_open_context(src));
0620     return status;
0621 }
0622 
0623 int nfs42_proc_copy_notify(struct file *src, struct file *dst,
0624                 struct nfs42_copy_notify_res *res)
0625 {
0626     struct nfs_server *src_server = NFS_SERVER(file_inode(src));
0627     struct nfs42_copy_notify_args *args;
0628     struct nfs4_exception exception = {
0629         .inode = file_inode(src),
0630     };
0631     int status;
0632 
0633     if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
0634         return -EOPNOTSUPP;
0635 
0636     args = kzalloc(sizeof(struct nfs42_copy_notify_args), GFP_KERNEL);
0637     if (args == NULL)
0638         return -ENOMEM;
0639 
0640     args->cna_src_fh  = NFS_FH(file_inode(src)),
0641     args->cna_dst.nl4_type = NL4_NETADDR;
0642     nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
0643     exception.stateid = &args->cna_src_stateid;
0644 
0645     do {
0646         status = _nfs42_proc_copy_notify(src, dst, args, res);
0647         if (status == -ENOTSUPP) {
0648             status = -EOPNOTSUPP;
0649             goto out;
0650         }
0651         status = nfs4_handle_exception(src_server, status, &exception);
0652     } while (exception.retry);
0653 
0654 out:
0655     kfree(args);
0656     return status;
0657 }
0658 
0659 static loff_t _nfs42_proc_llseek(struct file *filep,
0660         struct nfs_lock_context *lock, loff_t offset, int whence)
0661 {
0662     struct inode *inode = file_inode(filep);
0663     struct nfs42_seek_args args = {
0664         .sa_fh      = NFS_FH(inode),
0665         .sa_offset  = offset,
0666         .sa_what    = (whence == SEEK_HOLE) ?
0667                     NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
0668     };
0669     struct nfs42_seek_res res;
0670     struct rpc_message msg = {
0671         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
0672         .rpc_argp = &args,
0673         .rpc_resp = &res,
0674     };
0675     struct nfs_server *server = NFS_SERVER(inode);
0676     int status;
0677 
0678     if (!nfs_server_capable(inode, NFS_CAP_SEEK))
0679         return -ENOTSUPP;
0680 
0681     status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
0682             lock, FMODE_READ);
0683     if (status) {
0684         if (status == -EAGAIN)
0685             status = -NFS4ERR_BAD_STATEID;
0686         return status;
0687     }
0688 
0689     status = nfs_filemap_write_and_wait_range(inode->i_mapping,
0690             offset, LLONG_MAX);
0691     if (status)
0692         return status;
0693 
0694     status = nfs4_call_sync(server->client, server, &msg,
0695                 &args.seq_args, &res.seq_res, 0);
0696     trace_nfs4_llseek(inode, &args, &res, status);
0697     if (status == -ENOTSUPP)
0698         server->caps &= ~NFS_CAP_SEEK;
0699     if (status)
0700         return status;
0701 
0702     if (whence == SEEK_DATA && res.sr_eof)
0703         return -NFS4ERR_NXIO;
0704     else
0705         return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
0706 }
0707 
0708 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
0709 {
0710     struct nfs_server *server = NFS_SERVER(file_inode(filep));
0711     struct nfs4_exception exception = { };
0712     struct nfs_lock_context *lock;
0713     loff_t err;
0714 
0715     lock = nfs_get_lock_context(nfs_file_open_context(filep));
0716     if (IS_ERR(lock))
0717         return PTR_ERR(lock);
0718 
0719     exception.inode = file_inode(filep);
0720     exception.state = lock->open_context->state;
0721 
0722     do {
0723         err = _nfs42_proc_llseek(filep, lock, offset, whence);
0724         if (err >= 0)
0725             break;
0726         if (err == -ENOTSUPP) {
0727             err = -EOPNOTSUPP;
0728             break;
0729         }
0730         err = nfs4_handle_exception(server, err, &exception);
0731     } while (exception.retry);
0732 
0733     nfs_put_lock_context(lock);
0734     return err;
0735 }
0736 
0737 
0738 static void
0739 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
0740 {
0741     struct nfs42_layoutstat_data *data = calldata;
0742     struct inode *inode = data->inode;
0743     struct nfs_server *server = NFS_SERVER(inode);
0744     struct pnfs_layout_hdr *lo;
0745 
0746     spin_lock(&inode->i_lock);
0747     lo = NFS_I(inode)->layout;
0748     if (!pnfs_layout_is_valid(lo)) {
0749         spin_unlock(&inode->i_lock);
0750         rpc_exit(task, 0);
0751         return;
0752     }
0753     nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
0754     spin_unlock(&inode->i_lock);
0755     nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
0756                 &data->res.seq_res, task);
0757 }
0758 
0759 static void
0760 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
0761 {
0762     struct nfs42_layoutstat_data *data = calldata;
0763     struct inode *inode = data->inode;
0764     struct pnfs_layout_hdr *lo;
0765 
0766     if (!nfs4_sequence_done(task, &data->res.seq_res))
0767         return;
0768 
0769     switch (task->tk_status) {
0770     case 0:
0771         return;
0772     case -NFS4ERR_BADHANDLE:
0773     case -ESTALE:
0774         pnfs_destroy_layout(NFS_I(inode));
0775         break;
0776     case -NFS4ERR_EXPIRED:
0777     case -NFS4ERR_ADMIN_REVOKED:
0778     case -NFS4ERR_DELEG_REVOKED:
0779     case -NFS4ERR_STALE_STATEID:
0780     case -NFS4ERR_BAD_STATEID:
0781         spin_lock(&inode->i_lock);
0782         lo = NFS_I(inode)->layout;
0783         if (pnfs_layout_is_valid(lo) &&
0784             nfs4_stateid_match(&data->args.stateid,
0785                          &lo->plh_stateid)) {
0786             LIST_HEAD(head);
0787 
0788             /*
0789              * Mark the bad layout state as invalid, then retry
0790              * with the current stateid.
0791              */
0792             pnfs_mark_layout_stateid_invalid(lo, &head);
0793             spin_unlock(&inode->i_lock);
0794             pnfs_free_lseg_list(&head);
0795             nfs_commit_inode(inode, 0);
0796         } else
0797             spin_unlock(&inode->i_lock);
0798         break;
0799     case -NFS4ERR_OLD_STATEID:
0800         spin_lock(&inode->i_lock);
0801         lo = NFS_I(inode)->layout;
0802         if (pnfs_layout_is_valid(lo) &&
0803             nfs4_stateid_match_other(&data->args.stateid,
0804                     &lo->plh_stateid)) {
0805             /* Do we need to delay before resending? */
0806             if (!nfs4_stateid_is_newer(&lo->plh_stateid,
0807                         &data->args.stateid))
0808                 rpc_delay(task, HZ);
0809             rpc_restart_call_prepare(task);
0810         }
0811         spin_unlock(&inode->i_lock);
0812         break;
0813     case -ENOTSUPP:
0814     case -EOPNOTSUPP:
0815         NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
0816     }
0817 
0818     trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
0819 }
0820 
0821 static void
0822 nfs42_layoutstat_release(void *calldata)
0823 {
0824     struct nfs42_layoutstat_data *data = calldata;
0825     struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
0826     int i;
0827 
0828     for (i = 0; i < data->args.num_dev; i++) {
0829         if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
0830             devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
0831     }
0832 
0833     pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
0834     smp_mb__before_atomic();
0835     clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
0836     smp_mb__after_atomic();
0837     nfs_iput_and_deactive(data->inode);
0838     kfree(data->args.devinfo);
0839     kfree(data);
0840 }
0841 
0842 static const struct rpc_call_ops nfs42_layoutstat_ops = {
0843     .rpc_call_prepare = nfs42_layoutstat_prepare,
0844     .rpc_call_done = nfs42_layoutstat_done,
0845     .rpc_release = nfs42_layoutstat_release,
0846 };
0847 
0848 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
0849                    struct nfs42_layoutstat_data *data)
0850 {
0851     struct rpc_message msg = {
0852         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
0853         .rpc_argp = &data->args,
0854         .rpc_resp = &data->res,
0855     };
0856     struct rpc_task_setup task_setup = {
0857         .rpc_client = server->client,
0858         .rpc_message = &msg,
0859         .callback_ops = &nfs42_layoutstat_ops,
0860         .callback_data = data,
0861         .flags = RPC_TASK_ASYNC,
0862     };
0863     struct rpc_task *task;
0864 
0865     data->inode = nfs_igrab_and_active(data->args.inode);
0866     if (!data->inode) {
0867         nfs42_layoutstat_release(data);
0868         return -EAGAIN;
0869     }
0870     nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
0871     task = rpc_run_task(&task_setup);
0872     if (IS_ERR(task))
0873         return PTR_ERR(task);
0874     rpc_put_task(task);
0875     return 0;
0876 }
0877 
0878 static struct nfs42_layouterror_data *
0879 nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
0880 {
0881     struct nfs42_layouterror_data *data;
0882     struct inode *inode = lseg->pls_layout->plh_inode;
0883 
0884     data = kzalloc(sizeof(*data), gfp_flags);
0885     if (data) {
0886         data->args.inode = data->inode = nfs_igrab_and_active(inode);
0887         if (data->inode) {
0888             data->lseg = pnfs_get_lseg(lseg);
0889             if (data->lseg)
0890                 return data;
0891             nfs_iput_and_deactive(data->inode);
0892         }
0893         kfree(data);
0894     }
0895     return NULL;
0896 }
0897 
0898 static void
0899 nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
0900 {
0901     pnfs_put_lseg(data->lseg);
0902     nfs_iput_and_deactive(data->inode);
0903     kfree(data);
0904 }
0905 
0906 static void
0907 nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
0908 {
0909     struct nfs42_layouterror_data *data = calldata;
0910     struct inode *inode = data->inode;
0911     struct nfs_server *server = NFS_SERVER(inode);
0912     struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
0913     unsigned i;
0914 
0915     spin_lock(&inode->i_lock);
0916     if (!pnfs_layout_is_valid(lo)) {
0917         spin_unlock(&inode->i_lock);
0918         rpc_exit(task, 0);
0919         return;
0920     }
0921     for (i = 0; i < data->args.num_errors; i++)
0922         nfs4_stateid_copy(&data->args.errors[i].stateid,
0923                 &lo->plh_stateid);
0924     spin_unlock(&inode->i_lock);
0925     nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
0926                 &data->res.seq_res, task);
0927 }
0928 
0929 static void
0930 nfs42_layouterror_done(struct rpc_task *task, void *calldata)
0931 {
0932     struct nfs42_layouterror_data *data = calldata;
0933     struct inode *inode = data->inode;
0934     struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
0935 
0936     if (!nfs4_sequence_done(task, &data->res.seq_res))
0937         return;
0938 
0939     switch (task->tk_status) {
0940     case 0:
0941         return;
0942     case -NFS4ERR_BADHANDLE:
0943     case -ESTALE:
0944         pnfs_destroy_layout(NFS_I(inode));
0945         break;
0946     case -NFS4ERR_EXPIRED:
0947     case -NFS4ERR_ADMIN_REVOKED:
0948     case -NFS4ERR_DELEG_REVOKED:
0949     case -NFS4ERR_STALE_STATEID:
0950     case -NFS4ERR_BAD_STATEID:
0951         spin_lock(&inode->i_lock);
0952         if (pnfs_layout_is_valid(lo) &&
0953             nfs4_stateid_match(&data->args.errors[0].stateid,
0954                          &lo->plh_stateid)) {
0955             LIST_HEAD(head);
0956 
0957             /*
0958              * Mark the bad layout state as invalid, then retry
0959              * with the current stateid.
0960              */
0961             pnfs_mark_layout_stateid_invalid(lo, &head);
0962             spin_unlock(&inode->i_lock);
0963             pnfs_free_lseg_list(&head);
0964             nfs_commit_inode(inode, 0);
0965         } else
0966             spin_unlock(&inode->i_lock);
0967         break;
0968     case -NFS4ERR_OLD_STATEID:
0969         spin_lock(&inode->i_lock);
0970         if (pnfs_layout_is_valid(lo) &&
0971             nfs4_stateid_match_other(&data->args.errors[0].stateid,
0972                     &lo->plh_stateid)) {
0973             /* Do we need to delay before resending? */
0974             if (!nfs4_stateid_is_newer(&lo->plh_stateid,
0975                         &data->args.errors[0].stateid))
0976                 rpc_delay(task, HZ);
0977             rpc_restart_call_prepare(task);
0978         }
0979         spin_unlock(&inode->i_lock);
0980         break;
0981     case -ENOTSUPP:
0982     case -EOPNOTSUPP:
0983         NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
0984     }
0985 
0986     trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
0987                    task->tk_status);
0988 }
0989 
0990 static void
0991 nfs42_layouterror_release(void *calldata)
0992 {
0993     struct nfs42_layouterror_data *data = calldata;
0994 
0995     nfs42_free_layouterror_data(data);
0996 }
0997 
0998 static const struct rpc_call_ops nfs42_layouterror_ops = {
0999     .rpc_call_prepare = nfs42_layouterror_prepare,
1000     .rpc_call_done = nfs42_layouterror_done,
1001     .rpc_release = nfs42_layouterror_release,
1002 };
1003 
1004 int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
1005         const struct nfs42_layout_error *errors, size_t n)
1006 {
1007     struct inode *inode = lseg->pls_layout->plh_inode;
1008     struct nfs42_layouterror_data *data;
1009     struct rpc_task *task;
1010     struct rpc_message msg = {
1011         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
1012     };
1013     struct rpc_task_setup task_setup = {
1014         .rpc_message = &msg,
1015         .callback_ops = &nfs42_layouterror_ops,
1016         .flags = RPC_TASK_ASYNC,
1017     };
1018     unsigned int i;
1019 
1020     if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
1021         return -EOPNOTSUPP;
1022     if (n > NFS42_LAYOUTERROR_MAX)
1023         return -EINVAL;
1024     data = nfs42_alloc_layouterror_data(lseg, nfs_io_gfp_mask());
1025     if (!data)
1026         return -ENOMEM;
1027     for (i = 0; i < n; i++) {
1028         data->args.errors[i] = errors[i];
1029         data->args.num_errors++;
1030         data->res.num_errors++;
1031     }
1032     msg.rpc_argp = &data->args;
1033     msg.rpc_resp = &data->res;
1034     task_setup.callback_data = data;
1035     task_setup.rpc_client = NFS_SERVER(inode)->client;
1036     nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
1037     task = rpc_run_task(&task_setup);
1038     if (IS_ERR(task))
1039         return PTR_ERR(task);
1040     rpc_put_task(task);
1041     return 0;
1042 }
1043 EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
1044 
1045 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
1046         struct file *dst_f, struct nfs_lock_context *src_lock,
1047         struct nfs_lock_context *dst_lock, loff_t src_offset,
1048         loff_t dst_offset, loff_t count)
1049 {
1050     struct inode *src_inode = file_inode(src_f);
1051     struct inode *dst_inode = file_inode(dst_f);
1052     struct nfs_server *server = NFS_SERVER(dst_inode);
1053     __u32 dst_bitmask[NFS_BITMASK_SZ];
1054     struct nfs42_clone_args args = {
1055         .src_fh = NFS_FH(src_inode),
1056         .dst_fh = NFS_FH(dst_inode),
1057         .src_offset = src_offset,
1058         .dst_offset = dst_offset,
1059         .count = count,
1060         .dst_bitmask = dst_bitmask,
1061     };
1062     struct nfs42_clone_res res = {
1063         .server = server,
1064     };
1065     int status;
1066 
1067     msg->rpc_argp = &args;
1068     msg->rpc_resp = &res;
1069 
1070     status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
1071             src_lock, FMODE_READ);
1072     if (status) {
1073         if (status == -EAGAIN)
1074             status = -NFS4ERR_BAD_STATEID;
1075         return status;
1076     }
1077     status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
1078             dst_lock, FMODE_WRITE);
1079     if (status) {
1080         if (status == -EAGAIN)
1081             status = -NFS4ERR_BAD_STATEID;
1082         return status;
1083     }
1084 
1085     res.dst_fattr = nfs_alloc_fattr();
1086     if (!res.dst_fattr)
1087         return -ENOMEM;
1088 
1089     nfs4_bitmask_set(dst_bitmask, server->cache_consistency_bitmask,
1090              dst_inode, NFS_INO_INVALID_BLOCKS);
1091 
1092     status = nfs4_call_sync(server->client, server, msg,
1093                 &args.seq_args, &res.seq_res, 0);
1094     trace_nfs4_clone(src_inode, dst_inode, &args, status);
1095     if (status == 0) {
1096         nfs42_copy_dest_done(dst_inode, dst_offset, count);
1097         status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
1098     }
1099 
1100     kfree(res.dst_fattr);
1101     return status;
1102 }
1103 
1104 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
1105              loff_t src_offset, loff_t dst_offset, loff_t count)
1106 {
1107     struct rpc_message msg = {
1108         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
1109     };
1110     struct inode *inode = file_inode(src_f);
1111     struct nfs_server *server = NFS_SERVER(file_inode(src_f));
1112     struct nfs_lock_context *src_lock;
1113     struct nfs_lock_context *dst_lock;
1114     struct nfs4_exception src_exception = { };
1115     struct nfs4_exception dst_exception = { };
1116     int err, err2;
1117 
1118     if (!nfs_server_capable(inode, NFS_CAP_CLONE))
1119         return -EOPNOTSUPP;
1120 
1121     src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
1122     if (IS_ERR(src_lock))
1123         return PTR_ERR(src_lock);
1124 
1125     src_exception.inode = file_inode(src_f);
1126     src_exception.state = src_lock->open_context->state;
1127 
1128     dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
1129     if (IS_ERR(dst_lock)) {
1130         err = PTR_ERR(dst_lock);
1131         goto out_put_src_lock;
1132     }
1133 
1134     dst_exception.inode = file_inode(dst_f);
1135     dst_exception.state = dst_lock->open_context->state;
1136 
1137     do {
1138         err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
1139                     src_offset, dst_offset, count);
1140         if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
1141             NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
1142             err = -EOPNOTSUPP;
1143             break;
1144         }
1145 
1146         err2 = nfs4_handle_exception(server, err, &src_exception);
1147         err = nfs4_handle_exception(server, err, &dst_exception);
1148         if (!err)
1149             err = err2;
1150     } while (src_exception.retry || dst_exception.retry);
1151 
1152     nfs_put_lock_context(dst_lock);
1153 out_put_src_lock:
1154     nfs_put_lock_context(src_lock);
1155     return err;
1156 }
1157 
1158 #define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
1159 
1160 static int _nfs42_proc_removexattr(struct inode *inode, const char *name)
1161 {
1162     struct nfs_server *server = NFS_SERVER(inode);
1163     struct nfs42_removexattrargs args = {
1164         .fh = NFS_FH(inode),
1165         .xattr_name = name,
1166     };
1167     struct nfs42_removexattrres res;
1168     struct rpc_message msg = {
1169         .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
1170         .rpc_argp = &args,
1171         .rpc_resp = &res,
1172     };
1173     int ret;
1174     unsigned long timestamp = jiffies;
1175 
1176     ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
1177         &res.seq_res, 1);
1178     if (!ret)
1179         nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1180 
1181     return ret;
1182 }
1183 
1184 static int _nfs42_proc_setxattr(struct inode *inode, const char *name,
1185                 const void *buf, size_t buflen, int flags)
1186 {
1187     struct nfs_server *server = NFS_SERVER(inode);
1188     struct page *pages[NFS4XATTR_MAXPAGES];
1189     struct nfs42_setxattrargs arg = {
1190         .fh     = NFS_FH(inode),
1191         .xattr_pages    = pages,
1192         .xattr_len  = buflen,
1193         .xattr_name = name,
1194         .xattr_flags    = flags,
1195     };
1196     struct nfs42_setxattrres res;
1197     struct rpc_message msg = {
1198         .rpc_proc   = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
1199         .rpc_argp   = &arg,
1200         .rpc_resp   = &res,
1201     };
1202     int ret, np;
1203     unsigned long timestamp = jiffies;
1204 
1205     if (buflen > server->sxasize)
1206         return -ERANGE;
1207 
1208     if (buflen > 0) {
1209         np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
1210         if (np < 0)
1211             return np;
1212     } else
1213         np = 0;
1214 
1215     ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1216         &res.seq_res, 1);
1217 
1218     for (; np > 0; np--)
1219         put_page(pages[np - 1]);
1220 
1221     if (!ret)
1222         nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1223 
1224     return ret;
1225 }
1226 
1227 static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
1228                 void *buf, size_t buflen, struct page **pages,
1229                 size_t plen)
1230 {
1231     struct nfs_server *server = NFS_SERVER(inode);
1232     struct nfs42_getxattrargs arg = {
1233         .fh     = NFS_FH(inode),
1234         .xattr_name = name,
1235     };
1236     struct nfs42_getxattrres res;
1237     struct rpc_message msg = {
1238         .rpc_proc   = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
1239         .rpc_argp   = &arg,
1240         .rpc_resp   = &res,
1241     };
1242     ssize_t ret;
1243 
1244     arg.xattr_len = plen;
1245     arg.xattr_pages = pages;
1246 
1247     ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1248         &res.seq_res, 0);
1249     if (ret < 0)
1250         return ret;
1251 
1252     /*
1253      * Normally, the caching is done one layer up, but for successful
1254      * RPCS, always cache the result here, even if the caller was
1255      * just querying the length, or if the reply was too big for
1256      * the caller. This avoids a second RPC in the case of the
1257      * common query-alloc-retrieve cycle for xattrs.
1258      *
1259      * Note that xattr_len is always capped to XATTR_SIZE_MAX.
1260      */
1261 
1262     nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
1263 
1264     if (buflen) {
1265         if (res.xattr_len > buflen)
1266             return -ERANGE;
1267         _copy_from_pages(buf, pages, 0, res.xattr_len);
1268     }
1269 
1270     return res.xattr_len;
1271 }
1272 
1273 static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf,
1274                  size_t buflen, u64 *cookiep, bool *eofp)
1275 {
1276     struct nfs_server *server = NFS_SERVER(inode);
1277     struct page **pages;
1278     struct nfs42_listxattrsargs arg = {
1279         .fh     = NFS_FH(inode),
1280         .cookie     = *cookiep,
1281     };
1282     struct nfs42_listxattrsres res = {
1283         .eof = false,
1284         .xattr_buf = buf,
1285         .xattr_len = buflen,
1286     };
1287     struct rpc_message msg = {
1288         .rpc_proc   = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
1289         .rpc_argp   = &arg,
1290         .rpc_resp   = &res,
1291     };
1292     u32 xdrlen;
1293     int ret, np, i;
1294 
1295 
1296     ret = -ENOMEM;
1297     res.scratch = alloc_page(GFP_KERNEL);
1298     if (!res.scratch)
1299         goto out;
1300 
1301     xdrlen = nfs42_listxattr_xdrsize(buflen);
1302     if (xdrlen > server->lxasize)
1303         xdrlen = server->lxasize;
1304     np = xdrlen / PAGE_SIZE + 1;
1305 
1306     pages = kcalloc(np, sizeof(struct page *), GFP_KERNEL);
1307     if (!pages)
1308         goto out_free_scratch;
1309     for (i = 0; i < np; i++) {
1310         pages[i] = alloc_page(GFP_KERNEL);
1311         if (!pages[i])
1312             goto out_free_pages;
1313     }
1314 
1315     arg.xattr_pages = pages;
1316     arg.count = xdrlen;
1317 
1318     ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1319         &res.seq_res, 0);
1320 
1321     if (ret >= 0) {
1322         ret = res.copied;
1323         *cookiep = res.cookie;
1324         *eofp = res.eof;
1325     }
1326 
1327 out_free_pages:
1328     while (--np >= 0) {
1329         if (pages[np])
1330             __free_page(pages[np]);
1331     }
1332     kfree(pages);
1333 out_free_scratch:
1334     __free_page(res.scratch);
1335 out:
1336     return ret;
1337 
1338 }
1339 
1340 ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
1341                   void *buf, size_t buflen)
1342 {
1343     struct nfs4_exception exception = { };
1344     ssize_t err, np, i;
1345     struct page **pages;
1346 
1347     np = nfs_page_array_len(0, buflen ?: XATTR_SIZE_MAX);
1348     pages = kmalloc_array(np, sizeof(*pages), GFP_KERNEL);
1349     if (!pages)
1350         return -ENOMEM;
1351 
1352     for (i = 0; i < np; i++) {
1353         pages[i] = alloc_page(GFP_KERNEL);
1354         if (!pages[i]) {
1355             np = i + 1;
1356             err = -ENOMEM;
1357             goto out;
1358         }
1359     }
1360 
1361     /*
1362      * The GETXATTR op has no length field in the call, and the
1363      * xattr data is at the end of the reply.
1364      *
1365      * There is no downside in using the page-aligned length. It will
1366      * allow receiving and caching xattrs that are too large for the
1367      * caller but still fit in the page-rounded value.
1368      */
1369     do {
1370         err = _nfs42_proc_getxattr(inode, name, buf, buflen,
1371             pages, np * PAGE_SIZE);
1372         if (err >= 0)
1373             break;
1374         err = nfs4_handle_exception(NFS_SERVER(inode), err,
1375                 &exception);
1376     } while (exception.retry);
1377 
1378 out:
1379     while (--np >= 0)
1380         __free_page(pages[np]);
1381     kfree(pages);
1382 
1383     return err;
1384 }
1385 
1386 int nfs42_proc_setxattr(struct inode *inode, const char *name,
1387                   const void *buf, size_t buflen, int flags)
1388 {
1389     struct nfs4_exception exception = { };
1390     int err;
1391 
1392     do {
1393         err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
1394         if (!err)
1395             break;
1396         err = nfs4_handle_exception(NFS_SERVER(inode), err,
1397                 &exception);
1398     } while (exception.retry);
1399 
1400     return err;
1401 }
1402 
1403 ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
1404                   size_t buflen, u64 *cookiep, bool *eofp)
1405 {
1406     struct nfs4_exception exception = { };
1407     ssize_t err;
1408 
1409     do {
1410         err = _nfs42_proc_listxattrs(inode, buf, buflen,
1411             cookiep, eofp);
1412         if (err >= 0)
1413             break;
1414         err = nfs4_handle_exception(NFS_SERVER(inode), err,
1415                 &exception);
1416     } while (exception.retry);
1417 
1418     return err;
1419 }
1420 
1421 int nfs42_proc_removexattr(struct inode *inode, const char *name)
1422 {
1423     struct nfs4_exception exception = { };
1424     int err;
1425 
1426     do {
1427         err = _nfs42_proc_removexattr(inode, name);
1428         if (!err)
1429             break;
1430         err = nfs4_handle_exception(NFS_SERVER(inode), err,
1431                 &exception);
1432     } while (exception.retry);
1433 
1434     return err;
1435 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!