fs/nfs/nfs42proc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
   4  */
   5 #include <linux/fs.h>
   6 #include <linux/sunrpc/addr.h>
   7 #include <linux/sunrpc/sched.h>
   8 #include <linux/nfs.h>
   9 #include <linux/nfs3.h>
  10 #include <linux/nfs4.h>
  11 #include <linux/nfs_xdr.h>
  12 #include <linux/nfs_fs.h>
  13 #include "nfs4_fs.h"
  14 #include "nfs42.h"
  15 #include "iostat.h"
  16 #include "pnfs.h"
  17 #include "nfs4session.h"
  18 #include "internal.h"
  19 #include "delegation.h"
  20 #include "nfs4trace.h"
  21
  22 #define NFSDBG_FACILITY NFSDBG_PROC
  23 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
  24
  25 static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
  26 {
  27         struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
  28         unsigned short port = 2049;
  29
  30         rcu_read_lock();
  31         naddr->netid_len = scnprintf(naddr->netid,
  32                                         sizeof(naddr->netid), "%s",
  33                                         rpc_peeraddr2str(clp->cl_rpcclient,
  34                                         RPC_DISPLAY_NETID));
  35         naddr->addr_len = scnprintf(naddr->addr,
  36                                         sizeof(naddr->addr),
  37                                         "%s.%u.%u",
  38                                         rpc_peeraddr2str(clp->cl_rpcclient,
  39                                         RPC_DISPLAY_ADDR),
  40                                         port >> 8, port & 255);
  41         rcu_read_unlock();
  42 }
  43
  44 static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
  45                 struct nfs_lock_context *lock, loff_t offset, loff_t len)
  46 {
  47         struct inode *inode = file_inode(filep);
  48         struct nfs_server *server = NFS_SERVER(inode);
  49         u32 bitmask[3];
  50         struct nfs42_falloc_args args = {
  51                 .falloc_fh      = NFS_FH(inode),
  52                 .falloc_offset  = offset,
  53                 .falloc_length  = len,
  54                 .falloc_bitmask = bitmask,
  55         };
  56         struct nfs42_falloc_res res = {
  57                 .falloc_server  = server,
  58         };
  59         int status;
  60
  61         msg->rpc_argp = &args;
  62         msg->rpc_resp = &res;
  63
  64         status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
  65                         lock, FMODE_WRITE);
  66         if (status) {
  67                 if (status == -EAGAIN)
  68                         status = -NFS4ERR_BAD_STATEID;
  69                 return status;
  70         }
  71
  72         memcpy(bitmask, server->cache_consistency_bitmask, sizeof(bitmask));
  73         if (server->attr_bitmask[1] & FATTR4_WORD1_SPACE_USED)
  74                 bitmask[1] |= FATTR4_WORD1_SPACE_USED;
  75
  76         res.falloc_fattr = nfs_alloc_fattr();
  77         if (!res.falloc_fattr)
  78                 return -ENOMEM;
  79
  80         status = nfs4_call_sync(server->client, server, msg,
  81                                 &args.seq_args, &res.seq_res, 0);
  82         if (status == 0)
  83                 status = nfs_post_op_update_inode_force_wcc(inode,
  84                                                             res.falloc_fattr);
  85
  86         kfree(res.falloc_fattr);
  87         return status;
  88 }
  89
  90 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
  91                                 loff_t offset, loff_t len)
  92 {
  93         struct inode *inode = file_inode(filep);
  94         struct nfs_server *server = NFS_SERVER(inode);
  95         struct nfs4_exception exception = { };
  96         struct nfs_lock_context *lock;
  97         int err;
  98
  99         lock = nfs_get_lock_context(nfs_file_open_context(filep));
 100         if (IS_ERR(lock))
 101                 return PTR_ERR(lock);
 102
 103         exception.inode = inode;
 104         exception.state = lock->open_context->state;
 105
 106         err = nfs_sync_inode(inode);
 107         if (err)
 108                 goto out;
 109
 110         do {
 111                 err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
 112                 if (err == -ENOTSUPP) {
 113                         err = -EOPNOTSUPP;
 114                         break;
 115                 }
 116                 err = nfs4_handle_exception(server, err, &exception);
 117         } while (exception.retry);
 118 out:
 119         nfs_put_lock_context(lock);
 120         return err;
 121 }
 122
 123 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
 124 {
 125         struct rpc_message msg = {
 126                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
 127         };
 128         struct inode *inode = file_inode(filep);
 129         int err;
 130
 131         if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
 132                 return -EOPNOTSUPP;
 133
 134         inode_lock(inode);
 135
 136         err = nfs42_proc_fallocate(&msg, filep, offset, len);
 137         if (err == -EOPNOTSUPP)
 138                 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
 139
 140         inode_unlock(inode);
 141         return err;
 142 }
 143
 144 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
 145 {
 146         struct rpc_message msg = {
 147                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
 148         };
 149         struct inode *inode = file_inode(filep);
 150         int err;
 151
 152         if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
 153                 return -EOPNOTSUPP;
 154
 155         inode_lock(inode);
 156
 157         err = nfs42_proc_fallocate(&msg, filep, offset, len);
 158         if (err == 0)
 159                 truncate_pagecache_range(inode, offset, (offset + len) -1);
 160         if (err == -EOPNOTSUPP)
 161                 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
 162
 163         inode_unlock(inode);
 164         return err;
 165 }
 166
 167 static int handle_async_copy(struct nfs42_copy_res *res,
 168                              struct nfs_server *dst_server,
 169                              struct nfs_server *src_server,
 170                              struct file *src,
 171                              struct file *dst,
 172                              nfs4_stateid *src_stateid,
 173                              bool *restart)
 174 {
 175         struct nfs4_copy_state *copy, *tmp_copy;
 176         int status = NFS4_OK;
 177         bool found_pending = false;
 178         struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
 179         struct nfs_open_context *src_ctx = nfs_file_open_context(src);
 180
 181         copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
 182         if (!copy)
 183                 return -ENOMEM;
 184
 185         spin_lock(&dst_server->nfs_client->cl_lock);
 186         list_for_each_entry(tmp_copy,
 187                                 &dst_server->nfs_client->pending_cb_stateids,
 188                                 copies) {
 189                 if (memcmp(&res->write_res.stateid, &tmp_copy->stateid,
 190                                 NFS4_STATEID_SIZE))
 191                         continue;
 192                 found_pending = true;
 193                 list_del(&tmp_copy->copies);
 194                 break;
 195         }
 196         if (found_pending) {
 197                 spin_unlock(&dst_server->nfs_client->cl_lock);
 198                 kfree(copy);
 199                 copy = tmp_copy;
 200                 goto out;
 201         }
 202
 203         memcpy(&copy->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
 204         init_completion(&copy->completion);
 205         copy->parent_dst_state = dst_ctx->state;
 206         copy->parent_src_state = src_ctx->state;
 207
 208         list_add_tail(&copy->copies, &dst_server->ss_copies);
 209         spin_unlock(&dst_server->nfs_client->cl_lock);
 210
 211         if (dst_server != src_server) {
 212                 spin_lock(&src_server->nfs_client->cl_lock);
 213                 list_add_tail(&copy->src_copies, &src_server->ss_copies);
 214                 spin_unlock(&src_server->nfs_client->cl_lock);
 215         }
 216
 217         status = wait_for_completion_interruptible(&copy->completion);
 218         spin_lock(&dst_server->nfs_client->cl_lock);
 219         list_del_init(&copy->copies);
 220         spin_unlock(&dst_server->nfs_client->cl_lock);
 221         if (dst_server != src_server) {
 222                 spin_lock(&src_server->nfs_client->cl_lock);
 223                 list_del_init(&copy->src_copies);
 224                 spin_unlock(&src_server->nfs_client->cl_lock);
 225         }
 226         if (status == -ERESTARTSYS) {
 227                 goto out_cancel;
 228         } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
 229                 status = -EAGAIN;
 230                 *restart = true;
 231                 goto out_cancel;
 232         }
 233 out:
 234         res->write_res.count = copy->count;
 235         memcpy(&res->write_res.verifier, &copy->verf, sizeof(copy->verf));
 236         status = -copy->error;
 237
 238 out_free:
 239         kfree(copy);
 240         return status;
 241 out_cancel:
 242         nfs42_do_offload_cancel_async(dst, &copy->stateid);
 243         if (!nfs42_files_from_same_server(src, dst))
 244                 nfs42_do_offload_cancel_async(src, src_stateid);
 245         goto out_free;
 246 }
 247
 248 static int process_copy_commit(struct file *dst, loff_t pos_dst,
 249                                struct nfs42_copy_res *res)
 250 {
 251         struct nfs_commitres cres;
 252         int status = -ENOMEM;
 253
 254         cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
 255         if (!cres.verf)
 256                 goto out;
 257
 258         status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
 259         if (status)
 260                 goto out_free;
 261         if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
 262                                     &cres.verf->verifier)) {
 263                 dprintk("commit verf differs from copy verf\n");
 264                 status = -EAGAIN;
 265         }
 266 out_free:
 267         kfree(cres.verf);
 268 out:
 269         return status;
 270 }
 271
 272 static ssize_t _nfs42_proc_copy(struct file *src,
 273                                 struct nfs_lock_context *src_lock,
 274                                 struct file *dst,
 275                                 struct nfs_lock_context *dst_lock,
 276                                 struct nfs42_copy_args *args,
 277                                 struct nfs42_copy_res *res,
 278                                 struct nl4_server *nss,
 279                                 nfs4_stateid *cnr_stateid,
 280                                 bool *restart)
 281 {
 282         struct rpc_message msg = {
 283                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
 284                 .rpc_argp = args,
 285                 .rpc_resp = res,
 286         };
 287         struct inode *dst_inode = file_inode(dst);
 288         struct inode *src_inode = file_inode(src);
 289         struct nfs_server *dst_server = NFS_SERVER(dst_inode);
 290         struct nfs_server *src_server = NFS_SERVER(src_inode);
 291         loff_t pos_src = args->src_pos;
 292         loff_t pos_dst = args->dst_pos;
 293         size_t count = args->count;
 294         ssize_t status;
 295
 296         if (nss) {
 297                 args->cp_src = nss;
 298                 nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
 299         } else {
 300                 status = nfs4_set_rw_stateid(&args->src_stateid,
 301                                 src_lock->open_context, src_lock, FMODE_READ);
 302                 if (status) {
 303                         if (status == -EAGAIN)
 304                                 status = -NFS4ERR_BAD_STATEID;
 305                         return status;
 306                 }
 307         }
 308         status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
 309                         pos_src, pos_src + (loff_t)count - 1);
 310         if (status)
 311                 return status;
 312
 313         status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
 314                                      dst_lock, FMODE_WRITE);
 315         if (status) {
 316                 if (status == -EAGAIN)
 317                         status = -NFS4ERR_BAD_STATEID;
 318                 return status;
 319         }
 320
 321         status = nfs_sync_inode(dst_inode);
 322         if (status)
 323                 return status;
 324
 325         res->commit_res.verf = NULL;
 326         if (args->sync) {
 327                 res->commit_res.verf =
 328                         kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
 329                 if (!res->commit_res.verf)
 330                         return -ENOMEM;
 331         }
 332         set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
 333                 &src_lock->open_context->state->flags);
 334         set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
 335                 &dst_lock->open_context->state->flags);
 336
 337         status = nfs4_call_sync(dst_server->client, dst_server, &msg,
 338                                 &args->seq_args, &res->seq_res, 0);
 339         if (status == -ENOTSUPP)
 340                 dst_server->caps &= ~NFS_CAP_COPY;
 341         if (status)
 342                 goto out;
 343
 344         if (args->sync &&
 345                 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
 346                                     &res->commit_res.verf->verifier)) {
 347                 status = -EAGAIN;
 348                 goto out;
 349         }
 350
 351         if (!res->synchronous) {
 352                 status = handle_async_copy(res, dst_server, src_server, src,
 353                                 dst, &args->src_stateid, restart);
 354                 if (status)
 355                         goto out;
 356         }
 357
 358         if ((!res->synchronous || !args->sync) &&
 359                         res->write_res.verifier.committed != NFS_FILE_SYNC) {
 360                 status = process_copy_commit(dst, pos_dst, res);
 361                 if (status)
 362                         goto out;
 363         }
 364
 365         WARN_ON_ONCE(invalidate_inode_pages2_range(dst_inode->i_mapping,
 366                                         pos_dst >> PAGE_SHIFT,
 367                                         (pos_dst + res->write_res.count - 1) >> PAGE_SHIFT));
 368         spin_lock(&dst_inode->i_lock);
 369         NFS_I(dst_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
 370                         NFS_INO_REVAL_FORCED | NFS_INO_INVALID_SIZE |
 371                         NFS_INO_INVALID_ATTR | NFS_INO_INVALID_DATA);
 372         spin_unlock(&dst_inode->i_lock);
 373         spin_lock(&src_inode->i_lock);
 374         NFS_I(src_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
 375                         NFS_INO_REVAL_FORCED | NFS_INO_INVALID_ATIME);
 376         spin_unlock(&src_inode->i_lock);
 377         status = res->write_res.count;
 378 out:
 379         if (args->sync)
 380                 kfree(res->commit_res.verf);
 381         return status;
 382 }
 383
 384 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
 385                         struct file *dst, loff_t pos_dst, size_t count,
 386                         struct nl4_server *nss,
 387                         nfs4_stateid *cnr_stateid, bool sync)
 388 {
 389         struct nfs_server *server = NFS_SERVER(file_inode(dst));
 390         struct nfs_lock_context *src_lock;
 391         struct nfs_lock_context *dst_lock;
 392         struct nfs42_copy_args args = {
 393                 .src_fh         = NFS_FH(file_inode(src)),
 394                 .src_pos        = pos_src,
 395                 .dst_fh         = NFS_FH(file_inode(dst)),
 396                 .dst_pos        = pos_dst,
 397                 .count          = count,
 398                 .sync           = sync,
 399         };
 400         struct nfs42_copy_res res;
 401         struct nfs4_exception src_exception = {
 402                 .inode          = file_inode(src),
 403                 .stateid        = &args.src_stateid,
 404         };
 405         struct nfs4_exception dst_exception = {
 406                 .inode          = file_inode(dst),
 407                 .stateid        = &args.dst_stateid,
 408         };
 409         ssize_t err, err2;
 410         bool restart = false;
 411
 412         src_lock = nfs_get_lock_context(nfs_file_open_context(src));
 413         if (IS_ERR(src_lock))
 414                 return PTR_ERR(src_lock);
 415
 416         src_exception.state = src_lock->open_context->state;
 417
 418         dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
 419         if (IS_ERR(dst_lock)) {
 420                 err = PTR_ERR(dst_lock);
 421                 goto out_put_src_lock;
 422         }
 423
 424         dst_exception.state = dst_lock->open_context->state;
 425
 426         do {
 427                 inode_lock(file_inode(dst));
 428                 err = _nfs42_proc_copy(src, src_lock,
 429                                 dst, dst_lock,
 430                                 &args, &res,
 431                                 nss, cnr_stateid, &restart);
 432                 inode_unlock(file_inode(dst));
 433
 434                 if (err >= 0)
 435                         break;
 436                 if (err == -ENOTSUPP &&
 437                                 nfs42_files_from_same_server(src, dst)) {
 438                         err = -EOPNOTSUPP;
 439                         break;
 440                 } else if (err == -EAGAIN) {
 441                         if (!restart) {
 442                                 dst_exception.retry = 1;
 443                                 continue;
 444                         }
 445                         break;
 446                 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
 447                         args.sync = true;
 448                         dst_exception.retry = 1;
 449                         continue;
 450                 } else if ((err == -ESTALE ||
 451                                 err == -NFS4ERR_OFFLOAD_DENIED ||
 452                                 err == -ENOTSUPP) &&
 453                                 !nfs42_files_from_same_server(src, dst)) {
 454                         nfs42_do_offload_cancel_async(src, &args.src_stateid);
 455                         err = -EOPNOTSUPP;
 456                         break;
 457                 }
 458
 459                 err2 = nfs4_handle_exception(server, err, &src_exception);
 460                 err  = nfs4_handle_exception(server, err, &dst_exception);
 461                 if (!err)
 462                         err = err2;
 463         } while (src_exception.retry || dst_exception.retry);
 464
 465         nfs_put_lock_context(dst_lock);
 466 out_put_src_lock:
 467         nfs_put_lock_context(src_lock);
 468         return err;
 469 }
 470
 471 struct nfs42_offloadcancel_data {
 472         struct nfs_server *seq_server;
 473         struct nfs42_offload_status_args args;
 474         struct nfs42_offload_status_res res;
 475 };
 476
 477 static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
 478 {
 479         struct nfs42_offloadcancel_data *data = calldata;
 480
 481         nfs4_setup_sequence(data->seq_server->nfs_client,
 482                                 &data->args.osa_seq_args,
 483                                 &data->res.osr_seq_res, task);
 484 }
 485
 486 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
 487 {
 488         struct nfs42_offloadcancel_data *data = calldata;
 489
 490         nfs41_sequence_done(task, &data->res.osr_seq_res);
 491         if (task->tk_status &&
 492                 nfs4_async_handle_error(task, data->seq_server, NULL,
 493                         NULL) == -EAGAIN)
 494                 rpc_restart_call_prepare(task);
 495 }
 496
 497 static void nfs42_free_offloadcancel_data(void *data)
 498 {
 499         kfree(data);
 500 }
 501
 502 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
 503         .rpc_call_prepare = nfs42_offload_cancel_prepare,
 504         .rpc_call_done = nfs42_offload_cancel_done,
 505         .rpc_release = nfs42_free_offloadcancel_data,
 506 };
 507
 508 static int nfs42_do_offload_cancel_async(struct file *dst,
 509                                          nfs4_stateid *stateid)
 510 {
 511         struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
 512         struct nfs42_offloadcancel_data *data = NULL;
 513         struct nfs_open_context *ctx = nfs_file_open_context(dst);
 514         struct rpc_task *task;
 515         struct rpc_message msg = {
 516                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
 517                 .rpc_cred = ctx->cred,
 518         };
 519         struct rpc_task_setup task_setup_data = {
 520                 .rpc_client = dst_server->client,
 521                 .rpc_message = &msg,
 522                 .callback_ops = &nfs42_offload_cancel_ops,
 523                 .workqueue = nfsiod_workqueue,
 524                 .flags = RPC_TASK_ASYNC,
 525         };
 526         int status;
 527
 528         if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
 529                 return -EOPNOTSUPP;
 530
 531         data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_NOFS);
 532         if (data == NULL)
 533                 return -ENOMEM;
 534
 535         data->seq_server = dst_server;
 536         data->args.osa_src_fh = NFS_FH(file_inode(dst));
 537         memcpy(&data->args.osa_stateid, stateid,
 538                 sizeof(data->args.osa_stateid));
 539         msg.rpc_argp = &data->args;
 540         msg.rpc_resp = &data->res;
 541         task_setup_data.callback_data = data;
 542         nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
 543                            1, 0);
 544         task = rpc_run_task(&task_setup_data);
 545         if (IS_ERR(task))
 546                 return PTR_ERR(task);
 547         status = rpc_wait_for_completion_task(task);
 548         if (status == -ENOTSUPP)
 549                 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
 550         rpc_put_task(task);
 551         return status;
 552 }
 553
 554 static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
 555                                    struct nfs42_copy_notify_args *args,
 556                                    struct nfs42_copy_notify_res *res)
 557 {
 558         struct nfs_server *src_server = NFS_SERVER(file_inode(src));
 559         struct rpc_message msg = {
 560                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
 561                 .rpc_argp = args,
 562                 .rpc_resp = res,
 563         };
 564         int status;
 565         struct nfs_open_context *ctx;
 566         struct nfs_lock_context *l_ctx;
 567
 568         ctx = get_nfs_open_context(nfs_file_open_context(src));
 569         l_ctx = nfs_get_lock_context(ctx);
 570         if (IS_ERR(l_ctx)) {
 571                 status = PTR_ERR(l_ctx);
 572                 goto out;
 573         }
 574
 575         status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
 576                                      FMODE_READ);
 577         nfs_put_lock_context(l_ctx);
 578         if (status) {
 579                 if (status == -EAGAIN)
 580                         status = -NFS4ERR_BAD_STATEID;
 581                 goto out;
 582         }
 583
 584         status = nfs4_call_sync(src_server->client, src_server, &msg,
 585                                 &args->cna_seq_args, &res->cnr_seq_res, 0);
 586         if (status == -ENOTSUPP)
 587                 src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
 588
 589 out:
 590         put_nfs_open_context(nfs_file_open_context(src));
 591         return status;
 592 }
 593
 594 int nfs42_proc_copy_notify(struct file *src, struct file *dst,
 595                                 struct nfs42_copy_notify_res *res)
 596 {
 597         struct nfs_server *src_server = NFS_SERVER(file_inode(src));
 598         struct nfs42_copy_notify_args *args;
 599         struct nfs4_exception exception = {
 600                 .inode = file_inode(src),
 601         };
 602         int status;
 603
 604         if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
 605                 return -EOPNOTSUPP;
 606
 607         args = kzalloc(sizeof(struct nfs42_copy_notify_args), GFP_NOFS);
 608         if (args == NULL)
 609                 return -ENOMEM;
 610
 611         args->cna_src_fh  = NFS_FH(file_inode(src)),
 612         args->cna_dst.nl4_type = NL4_NETADDR;
 613         nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
 614         exception.stateid = &args->cna_src_stateid;
 615
 616         do {
 617                 status = _nfs42_proc_copy_notify(src, dst, args, res);
 618                 if (status == -ENOTSUPP) {
 619                         status = -EOPNOTSUPP;
 620                         goto out;
 621                 }
 622                 status = nfs4_handle_exception(src_server, status, &exception);
 623         } while (exception.retry);
 624
 625 out:
 626         kfree(args);
 627         return status;
 628 }
 629
 630 static loff_t _nfs42_proc_llseek(struct file *filep,
 631                 struct nfs_lock_context *lock, loff_t offset, int whence)
 632 {
 633         struct inode *inode = file_inode(filep);
 634         struct nfs42_seek_args args = {
 635                 .sa_fh          = NFS_FH(inode),
 636                 .sa_offset      = offset,
 637                 .sa_what        = (whence == SEEK_HOLE) ?
 638                                         NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
 639         };
 640         struct nfs42_seek_res res;
 641         struct rpc_message msg = {
 642                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
 643                 .rpc_argp = &args,
 644                 .rpc_resp = &res,
 645         };
 646         struct nfs_server *server = NFS_SERVER(inode);
 647         int status;
 648
 649         if (!nfs_server_capable(inode, NFS_CAP_SEEK))
 650                 return -ENOTSUPP;
 651
 652         status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
 653                         lock, FMODE_READ);
 654         if (status) {
 655                 if (status == -EAGAIN)
 656                         status = -NFS4ERR_BAD_STATEID;
 657                 return status;
 658         }
 659
 660         status = nfs_filemap_write_and_wait_range(inode->i_mapping,
 661                         offset, LLONG_MAX);
 662         if (status)
 663                 return status;
 664
 665         status = nfs4_call_sync(server->client, server, &msg,
 666                                 &args.seq_args, &res.seq_res, 0);
 667         if (status == -ENOTSUPP)
 668                 server->caps &= ~NFS_CAP_SEEK;
 669         if (status)
 670                 return status;
 671
 672         if (whence == SEEK_DATA && res.sr_eof)
 673                 return -NFS4ERR_NXIO;
 674         else
 675                 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
 676 }
 677
 678 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
 679 {
 680         struct nfs_server *server = NFS_SERVER(file_inode(filep));
 681         struct nfs4_exception exception = { };
 682         struct nfs_lock_context *lock;
 683         loff_t err;
 684
 685         lock = nfs_get_lock_context(nfs_file_open_context(filep));
 686         if (IS_ERR(lock))
 687                 return PTR_ERR(lock);
 688
 689         exception.inode = file_inode(filep);
 690         exception.state = lock->open_context->state;
 691
 692         do {
 693                 err = _nfs42_proc_llseek(filep, lock, offset, whence);
 694                 if (err >= 0)
 695                         break;
 696                 if (err == -ENOTSUPP) {
 697                         err = -EOPNOTSUPP;
 698                         break;
 699                 }
 700                 err = nfs4_handle_exception(server, err, &exception);
 701         } while (exception.retry);
 702
 703         nfs_put_lock_context(lock);
 704         return err;
 705 }
 706
 707
 708 static void
 709 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
 710 {
 711         struct nfs42_layoutstat_data *data = calldata;
 712         struct inode *inode = data->inode;
 713         struct nfs_server *server = NFS_SERVER(inode);
 714         struct pnfs_layout_hdr *lo;
 715
 716         spin_lock(&inode->i_lock);
 717         lo = NFS_I(inode)->layout;
 718         if (!pnfs_layout_is_valid(lo)) {
 719                 spin_unlock(&inode->i_lock);
 720                 rpc_exit(task, 0);
 721                 return;
 722         }
 723         nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
 724         spin_unlock(&inode->i_lock);
 725         nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
 726                             &data->res.seq_res, task);
 727 }
 728
 729 static void
 730 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
 731 {
 732         struct nfs42_layoutstat_data *data = calldata;
 733         struct inode *inode = data->inode;
 734         struct pnfs_layout_hdr *lo;
 735
 736         if (!nfs4_sequence_done(task, &data->res.seq_res))
 737                 return;
 738
 739         switch (task->tk_status) {
 740         case 0:
 741                 return;
 742         case -NFS4ERR_BADHANDLE:
 743         case -ESTALE:
 744                 pnfs_destroy_layout(NFS_I(inode));
 745                 break;
 746         case -NFS4ERR_EXPIRED:
 747         case -NFS4ERR_ADMIN_REVOKED:
 748         case -NFS4ERR_DELEG_REVOKED:
 749         case -NFS4ERR_STALE_STATEID:
 750         case -NFS4ERR_BAD_STATEID:
 751                 spin_lock(&inode->i_lock);
 752                 lo = NFS_I(inode)->layout;
 753                 if (pnfs_layout_is_valid(lo) &&
 754                     nfs4_stateid_match(&data->args.stateid,
 755                                              &lo->plh_stateid)) {
 756                         LIST_HEAD(head);
 757
 758                         /*
 759                          * Mark the bad layout state as invalid, then retry
 760                          * with the current stateid.
 761                          */
 762                         pnfs_mark_layout_stateid_invalid(lo, &head);
 763                         spin_unlock(&inode->i_lock);
 764                         pnfs_free_lseg_list(&head);
 765                         nfs_commit_inode(inode, 0);
 766                 } else
 767                         spin_unlock(&inode->i_lock);
 768                 break;
 769         case -NFS4ERR_OLD_STATEID:
 770                 spin_lock(&inode->i_lock);
 771                 lo = NFS_I(inode)->layout;
 772                 if (pnfs_layout_is_valid(lo) &&
 773                     nfs4_stateid_match_other(&data->args.stateid,
 774                                         &lo->plh_stateid)) {
 775                         /* Do we need to delay before resending? */
 776                         if (!nfs4_stateid_is_newer(&lo->plh_stateid,
 777                                                 &data->args.stateid))
 778                                 rpc_delay(task, HZ);
 779                         rpc_restart_call_prepare(task);
 780                 }
 781                 spin_unlock(&inode->i_lock);
 782                 break;
 783         case -ENOTSUPP:
 784         case -EOPNOTSUPP:
 785                 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
 786         }
 787
 788         trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
 789 }
 790
 791 static void
 792 nfs42_layoutstat_release(void *calldata)
 793 {
 794         struct nfs42_layoutstat_data *data = calldata;
 795         struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
 796         int i;
 797
 798         for (i = 0; i < data->args.num_dev; i++) {
 799                 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
 800                         devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
 801         }
 802
 803         pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
 804         smp_mb__before_atomic();
 805         clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
 806         smp_mb__after_atomic();
 807         nfs_iput_and_deactive(data->inode);
 808         kfree(data->args.devinfo);
 809         kfree(data);
 810 }
 811
 812 static const struct rpc_call_ops nfs42_layoutstat_ops = {
 813         .rpc_call_prepare = nfs42_layoutstat_prepare,
 814         .rpc_call_done = nfs42_layoutstat_done,
 815         .rpc_release = nfs42_layoutstat_release,
 816 };
 817
 818 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
 819                                    struct nfs42_layoutstat_data *data)
 820 {
 821         struct rpc_message msg = {
 822                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
 823                 .rpc_argp = &data->args,
 824                 .rpc_resp = &data->res,
 825         };
 826         struct rpc_task_setup task_setup = {
 827                 .rpc_client = server->client,
 828                 .rpc_message = &msg,
 829                 .callback_ops = &nfs42_layoutstat_ops,
 830                 .callback_data = data,
 831                 .flags = RPC_TASK_ASYNC,
 832         };
 833         struct rpc_task *task;
 834
 835         data->inode = nfs_igrab_and_active(data->args.inode);
 836         if (!data->inode) {
 837                 nfs42_layoutstat_release(data);
 838                 return -EAGAIN;
 839         }
 840         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
 841         task = rpc_run_task(&task_setup);
 842         if (IS_ERR(task))
 843                 return PTR_ERR(task);
 844         rpc_put_task(task);
 845         return 0;
 846 }
 847
 848 static struct nfs42_layouterror_data *
 849 nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
 850 {
 851         struct nfs42_layouterror_data *data;
 852         struct inode *inode = lseg->pls_layout->plh_inode;
 853
 854         data = kzalloc(sizeof(*data), gfp_flags);
 855         if (data) {
 856                 data->args.inode = data->inode = nfs_igrab_and_active(inode);
 857                 if (data->inode) {
 858                         data->lseg = pnfs_get_lseg(lseg);
 859                         if (data->lseg)
 860                                 return data;
 861                         nfs_iput_and_deactive(data->inode);
 862                 }
 863                 kfree(data);
 864         }
 865         return NULL;
 866 }
 867
 868 static void
 869 nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
 870 {
 871         pnfs_put_lseg(data->lseg);
 872         nfs_iput_and_deactive(data->inode);
 873         kfree(data);
 874 }
 875
 876 static void
 877 nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
 878 {
 879         struct nfs42_layouterror_data *data = calldata;
 880         struct inode *inode = data->inode;
 881         struct nfs_server *server = NFS_SERVER(inode);
 882         struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
 883         unsigned i;
 884
 885         spin_lock(&inode->i_lock);
 886         if (!pnfs_layout_is_valid(lo)) {
 887                 spin_unlock(&inode->i_lock);
 888                 rpc_exit(task, 0);
 889                 return;
 890         }
 891         for (i = 0; i < data->args.num_errors; i++)
 892                 nfs4_stateid_copy(&data->args.errors[i].stateid,
 893                                 &lo->plh_stateid);
 894         spin_unlock(&inode->i_lock);
 895         nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
 896                             &data->res.seq_res, task);
 897 }
 898
 899 static void
 900 nfs42_layouterror_done(struct rpc_task *task, void *calldata)
 901 {
 902         struct nfs42_layouterror_data *data = calldata;
 903         struct inode *inode = data->inode;
 904         struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
 905
 906         if (!nfs4_sequence_done(task, &data->res.seq_res))
 907                 return;
 908
 909         switch (task->tk_status) {
 910         case 0:
 911                 return;
 912         case -NFS4ERR_BADHANDLE:
 913         case -ESTALE:
 914                 pnfs_destroy_layout(NFS_I(inode));
 915                 break;
 916         case -NFS4ERR_EXPIRED:
 917         case -NFS4ERR_ADMIN_REVOKED:
 918         case -NFS4ERR_DELEG_REVOKED:
 919         case -NFS4ERR_STALE_STATEID:
 920         case -NFS4ERR_BAD_STATEID:
 921                 spin_lock(&inode->i_lock);
 922                 if (pnfs_layout_is_valid(lo) &&
 923                     nfs4_stateid_match(&data->args.errors[0].stateid,
 924                                              &lo->plh_stateid)) {
 925                         LIST_HEAD(head);
 926
 927                         /*
 928                          * Mark the bad layout state as invalid, then retry
 929                          * with the current stateid.
 930                          */
 931                         pnfs_mark_layout_stateid_invalid(lo, &head);
 932                         spin_unlock(&inode->i_lock);
 933                         pnfs_free_lseg_list(&head);
 934                         nfs_commit_inode(inode, 0);
 935                 } else
 936                         spin_unlock(&inode->i_lock);
 937                 break;
 938         case -NFS4ERR_OLD_STATEID:
 939                 spin_lock(&inode->i_lock);
 940                 if (pnfs_layout_is_valid(lo) &&
 941                     nfs4_stateid_match_other(&data->args.errors[0].stateid,
 942                                         &lo->plh_stateid)) {
 943                         /* Do we need to delay before resending? */
 944                         if (!nfs4_stateid_is_newer(&lo->plh_stateid,
 945                                                 &data->args.errors[0].stateid))
 946                                 rpc_delay(task, HZ);
 947                         rpc_restart_call_prepare(task);
 948                 }
 949                 spin_unlock(&inode->i_lock);
 950                 break;
 951         case -ENOTSUPP:
 952         case -EOPNOTSUPP:
 953                 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
 954         }
 955
 956         trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
 957                                task->tk_status);
 958 }
 959
 960 static void
 961 nfs42_layouterror_release(void *calldata)
 962 {
 963         struct nfs42_layouterror_data *data = calldata;
 964
 965         nfs42_free_layouterror_data(data);
 966 }
 967
 968 static const struct rpc_call_ops nfs42_layouterror_ops = {
 969         .rpc_call_prepare = nfs42_layouterror_prepare,
 970         .rpc_call_done = nfs42_layouterror_done,
 971         .rpc_release = nfs42_layouterror_release,
 972 };
 973
 974 int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
 975                 const struct nfs42_layout_error *errors, size_t n)
 976 {
 977         struct inode *inode = lseg->pls_layout->plh_inode;
 978         struct nfs42_layouterror_data *data;
 979         struct rpc_task *task;
 980         struct rpc_message msg = {
 981                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
 982         };
 983         struct rpc_task_setup task_setup = {
 984                 .rpc_message = &msg,
 985                 .callback_ops = &nfs42_layouterror_ops,
 986                 .flags = RPC_TASK_ASYNC,
 987         };
 988         unsigned int i;
 989
 990         if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
 991                 return -EOPNOTSUPP;
 992         if (n > NFS42_LAYOUTERROR_MAX)
 993                 return -EINVAL;
 994         data = nfs42_alloc_layouterror_data(lseg, GFP_NOFS);
 995         if (!data)
 996                 return -ENOMEM;
 997         for (i = 0; i < n; i++) {
 998                 data->args.errors[i] = errors[i];
 999                 data->args.num_errors++;
1000                 data->res.num_errors++;
1001         }
1002         msg.rpc_argp = &data->args;
1003         msg.rpc_resp = &data->res;
1004         task_setup.callback_data = data;
1005         task_setup.rpc_client = NFS_SERVER(inode)->client;
1006         nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
1007         task = rpc_run_task(&task_setup);
1008         if (IS_ERR(task))
1009                 return PTR_ERR(task);
1010         rpc_put_task(task);
1011         return 0;
1012 }
1013 EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
1014
1015 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
1016                 struct file *dst_f, struct nfs_lock_context *src_lock,
1017                 struct nfs_lock_context *dst_lock, loff_t src_offset,
1018                 loff_t dst_offset, loff_t count)
1019 {
1020         struct inode *src_inode = file_inode(src_f);
1021         struct inode *dst_inode = file_inode(dst_f);
1022         struct nfs_server *server = NFS_SERVER(dst_inode);
1023         struct nfs42_clone_args args = {
1024                 .src_fh = NFS_FH(src_inode),
1025                 .dst_fh = NFS_FH(dst_inode),
1026                 .src_offset = src_offset,
1027                 .dst_offset = dst_offset,
1028                 .count = count,
1029                 .dst_bitmask = server->cache_consistency_bitmask,
1030         };
1031         struct nfs42_clone_res res = {
1032                 .server = server,
1033         };
1034         int status;
1035
1036         msg->rpc_argp = &args;
1037         msg->rpc_resp = &res;
1038
1039         status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
1040                         src_lock, FMODE_READ);
1041         if (status) {
1042                 if (status == -EAGAIN)
1043                         status = -NFS4ERR_BAD_STATEID;
1044                 return status;
1045         }
1046         status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
1047                         dst_lock, FMODE_WRITE);
1048         if (status) {
1049                 if (status == -EAGAIN)
1050                         status = -NFS4ERR_BAD_STATEID;
1051                 return status;
1052         }
1053
1054         res.dst_fattr = nfs_alloc_fattr();
1055         if (!res.dst_fattr)
1056                 return -ENOMEM;
1057
1058         status = nfs4_call_sync(server->client, server, msg,
1059                                 &args.seq_args, &res.seq_res, 0);
1060         if (status == 0)
1061                 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
1062
1063         kfree(res.dst_fattr);
1064         return status;
1065 }
1066
1067 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
1068                      loff_t src_offset, loff_t dst_offset, loff_t count)
1069 {
1070         struct rpc_message msg = {
1071                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
1072         };
1073         struct inode *inode = file_inode(src_f);
1074         struct nfs_server *server = NFS_SERVER(file_inode(src_f));
1075         struct nfs_lock_context *src_lock;
1076         struct nfs_lock_context *dst_lock;
1077         struct nfs4_exception src_exception = { };
1078         struct nfs4_exception dst_exception = { };
1079         int err, err2;
1080
1081         if (!nfs_server_capable(inode, NFS_CAP_CLONE))
1082                 return -EOPNOTSUPP;
1083
1084         src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
1085         if (IS_ERR(src_lock))
1086                 return PTR_ERR(src_lock);
1087
1088         src_exception.inode = file_inode(src_f);
1089         src_exception.state = src_lock->open_context->state;
1090
1091         dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
1092         if (IS_ERR(dst_lock)) {
1093                 err = PTR_ERR(dst_lock);
1094                 goto out_put_src_lock;
1095         }
1096
1097         dst_exception.inode = file_inode(dst_f);
1098         dst_exception.state = dst_lock->open_context->state;
1099
1100         do {
1101                 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
1102                                         src_offset, dst_offset, count);
1103                 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
1104                         NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
1105                         err = -EOPNOTSUPP;
1106                         break;
1107                 }
1108
1109                 err2 = nfs4_handle_exception(server, err, &src_exception);
1110                 err = nfs4_handle_exception(server, err, &dst_exception);
1111                 if (!err)
1112                         err = err2;
1113         } while (src_exception.retry || dst_exception.retry);
1114
1115         nfs_put_lock_context(dst_lock);
1116 out_put_src_lock:
1117         nfs_put_lock_context(src_lock);
1118         return err;
1119 }
1120
1121 #define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
1122
1123 static int _nfs42_proc_removexattr(struct inode *inode, const char *name)
1124 {
1125         struct nfs_server *server = NFS_SERVER(inode);
1126         struct nfs42_removexattrargs args = {
1127                 .fh = NFS_FH(inode),
1128                 .xattr_name = name,
1129         };
1130         struct nfs42_removexattrres res;
1131         struct rpc_message msg = {
1132                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
1133                 .rpc_argp = &args,
1134                 .rpc_resp = &res,
1135         };
1136         int ret;
1137         unsigned long timestamp = jiffies;
1138
1139         ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
1140             &res.seq_res, 1);
1141         if (!ret)
1142                 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1143
1144         return ret;
1145 }
1146
1147 static int _nfs42_proc_setxattr(struct inode *inode, const char *name,
1148                                 const void *buf, size_t buflen, int flags)
1149 {
1150         struct nfs_server *server = NFS_SERVER(inode);
1151         struct page *pages[NFS4XATTR_MAXPAGES];
1152         struct nfs42_setxattrargs arg = {
1153                 .fh             = NFS_FH(inode),
1154                 .xattr_pages    = pages,
1155                 .xattr_len      = buflen,
1156                 .xattr_name     = name,
1157                 .xattr_flags    = flags,
1158         };
1159         struct nfs42_setxattrres res;
1160         struct rpc_message msg = {
1161                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
1162                 .rpc_argp       = &arg,
1163                 .rpc_resp       = &res,
1164         };
1165         int ret, np;
1166         unsigned long timestamp = jiffies;
1167
1168         if (buflen > server->sxasize)
1169                 return -ERANGE;
1170
1171         if (buflen > 0) {
1172                 np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
1173                 if (np < 0)
1174                         return np;
1175         } else
1176                 np = 0;
1177
1178         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1179             &res.seq_res, 1);
1180
1181         for (; np > 0; np--)
1182                 put_page(pages[np - 1]);
1183
1184         if (!ret)
1185                 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1186
1187         return ret;
1188 }
1189
1190 static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
1191                                 void *buf, size_t buflen)
1192 {
1193         struct nfs_server *server = NFS_SERVER(inode);
1194         struct page *pages[NFS4XATTR_MAXPAGES] = {};
1195         struct nfs42_getxattrargs arg = {
1196                 .fh             = NFS_FH(inode),
1197                 .xattr_pages    = pages,
1198                 .xattr_len      = buflen,
1199                 .xattr_name     = name,
1200         };
1201         struct nfs42_getxattrres res;
1202         struct rpc_message msg = {
1203                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
1204                 .rpc_argp       = &arg,
1205                 .rpc_resp       = &res,
1206         };
1207         int ret, np;
1208
1209         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1210             &res.seq_res, 0);
1211         if (ret < 0)
1212                 return ret;
1213
1214         /*
1215          * Normally, the caching is done one layer up, but for successful
1216          * RPCS, always cache the result here, even if the caller was
1217          * just querying the length, or if the reply was too big for
1218          * the caller. This avoids a second RPC in the case of the
1219          * common query-alloc-retrieve cycle for xattrs.
1220          *
1221          * Note that xattr_len is always capped to XATTR_SIZE_MAX.
1222          */
1223
1224         nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
1225
1226         if (buflen) {
1227                 if (res.xattr_len > buflen)
1228                         return -ERANGE;
1229                 _copy_from_pages(buf, pages, 0, res.xattr_len);
1230         }
1231
1232         np = DIV_ROUND_UP(res.xattr_len, PAGE_SIZE);
1233         while (--np >= 0)
1234                 __free_page(pages[np]);
1235
1236         return res.xattr_len;
1237 }
1238
1239 static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf,
1240                                  size_t buflen, u64 *cookiep, bool *eofp)
1241 {
1242         struct nfs_server *server = NFS_SERVER(inode);
1243         struct page **pages;
1244         struct nfs42_listxattrsargs arg = {
1245                 .fh             = NFS_FH(inode),
1246                 .cookie         = *cookiep,
1247         };
1248         struct nfs42_listxattrsres res = {
1249                 .eof = false,
1250                 .xattr_buf = buf,
1251                 .xattr_len = buflen,
1252         };
1253         struct rpc_message msg = {
1254                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
1255                 .rpc_argp       = &arg,
1256                 .rpc_resp       = &res,
1257         };
1258         u32 xdrlen;
1259         int ret, np, i;
1260
1261
1262         ret = -ENOMEM;
1263         res.scratch = alloc_page(GFP_KERNEL);
1264         if (!res.scratch)
1265                 goto out;
1266
1267         xdrlen = nfs42_listxattr_xdrsize(buflen);
1268         if (xdrlen > server->lxasize)
1269                 xdrlen = server->lxasize;
1270         np = xdrlen / PAGE_SIZE + 1;
1271
1272         pages = kcalloc(np, sizeof(struct page *), GFP_KERNEL);
1273         if (!pages)
1274                 goto out_free_scratch;
1275         for (i = 0; i < np; i++) {
1276                 pages[i] = alloc_page(GFP_KERNEL);
1277                 if (!pages[i])
1278                         goto out_free_pages;
1279         }
1280
1281         arg.xattr_pages = pages;
1282         arg.count = xdrlen;
1283
1284         ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1285             &res.seq_res, 0);
1286
1287         if (ret >= 0) {
1288                 ret = res.copied;
1289                 *cookiep = res.cookie;
1290                 *eofp = res.eof;
1291         }
1292
1293 out_free_pages:
1294         while (--np >= 0) {
1295                 if (pages[np])
1296                         __free_page(pages[np]);
1297         }
1298         kfree(pages);
1299 out_free_scratch:
1300         __free_page(res.scratch);
1301 out:
1302         return ret;
1303
1304 }
1305
1306 ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
1307                               void *buf, size_t buflen)
1308 {
1309         struct nfs4_exception exception = { };
1310         ssize_t err;
1311
1312         do {
1313                 err = _nfs42_proc_getxattr(inode, name, buf, buflen);
1314                 if (err >= 0)
1315                         break;
1316                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1317                                 &exception);
1318         } while (exception.retry);
1319
1320         return err;
1321 }
1322
1323 int nfs42_proc_setxattr(struct inode *inode, const char *name,
1324                               const void *buf, size_t buflen, int flags)
1325 {
1326         struct nfs4_exception exception = { };
1327         int err;
1328
1329         do {
1330                 err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
1331                 if (!err)
1332                         break;
1333                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1334                                 &exception);
1335         } while (exception.retry);
1336
1337         return err;
1338 }
1339
1340 ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
1341                               size_t buflen, u64 *cookiep, bool *eofp)
1342 {
1343         struct nfs4_exception exception = { };
1344         ssize_t err;
1345
1346         do {
1347                 err = _nfs42_proc_listxattrs(inode, buf, buflen,
1348                     cookiep, eofp);
1349                 if (err >= 0)
1350                         break;
1351                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1352                                 &exception);
1353         } while (exception.retry);
1354
1355         return err;
1356 }
1357
1358 int nfs42_proc_removexattr(struct inode *inode, const char *name)
1359 {
1360         struct nfs4_exception exception = { };
1361         int err;
1362
1363         do {
1364                 err = _nfs42_proc_removexattr(inode, name);
1365                 if (!err)
1366                         break;
1367                 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1368                                 &exception);
1369         } while (exception.retry);
1370
1371         return err;
1372 }