fs/nfs/nfs4file.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/nfs/file.c
   4  *
   5  *  Copyright (C) 1992  Rick Sladkey
   6  */
   7 #include <linux/fs.h>
   8 #include <linux/file.h>
   9 #include <linux/falloc.h>
  10 #include <linux/mount.h>
  11 #include <linux/nfs_fs.h>
  12 #include <linux/nfs_ssc.h>
  13 #include "delegation.h"
  14 #include "internal.h"
  15 #include "iostat.h"
  16 #include "fscache.h"
  17 #include "pnfs.h"
  18
  19 #include "nfstrace.h"
  20
  21 #ifdef CONFIG_NFS_V4_2
  22 #include "nfs42.h"
  23 #endif
  24
  25 #define NFSDBG_FACILITY         NFSDBG_FILE
  26
  27 static int
  28 nfs4_file_open(struct inode *inode, struct file *filp)
  29 {
  30         struct nfs_open_context *ctx;
  31         struct dentry *dentry = file_dentry(filp);
  32         struct dentry *parent = NULL;
  33         struct inode *dir;
  34         unsigned openflags = filp->f_flags;
  35         fmode_t f_mode;
  36         struct iattr attr;
  37         int err;
  38
  39         /*
  40          * If no cached dentry exists or if it's negative, NFSv4 handled the
  41          * opens in ->lookup() or ->create().
  42          *
  43          * We only get this far for a cached positive dentry.  We skipped
  44          * revalidation, so handle it here by dropping the dentry and returning
  45          * -EOPENSTALE.  The VFS will retry the lookup/create/open.
  46          */
  47
  48         dprintk("NFS: open file(%pd2)\n", dentry);
  49
  50         err = nfs_check_flags(openflags);
  51         if (err)
  52                 return err;
  53
  54         f_mode = filp->f_mode;
  55         if ((openflags & O_ACCMODE) == 3)
  56                 f_mode |= flags_to_mode(openflags);
  57
  58         /* We can't create new files here */
  59         openflags &= ~(O_CREAT|O_EXCL);
  60
  61         parent = dget_parent(dentry);
  62         dir = d_inode(parent);
  63
  64         ctx = alloc_nfs_open_context(file_dentry(filp), f_mode, filp);
  65         err = PTR_ERR(ctx);
  66         if (IS_ERR(ctx))
  67                 goto out;
  68
  69         attr.ia_valid = ATTR_OPEN;
  70         if (openflags & O_TRUNC) {
  71                 attr.ia_valid |= ATTR_SIZE;
  72                 attr.ia_size = 0;
  73                 filemap_write_and_wait(inode->i_mapping);
  74         }
  75
  76         inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr, NULL);
  77         if (IS_ERR(inode)) {
  78                 err = PTR_ERR(inode);
  79                 switch (err) {
  80                 default:
  81                         goto out_put_ctx;
  82                 case -ENOENT:
  83                 case -ESTALE:
  84                 case -EISDIR:
  85                 case -ENOTDIR:
  86                 case -ELOOP:
  87                         goto out_drop;
  88                 }
  89         }
  90         if (inode != d_inode(dentry))
  91                 goto out_drop;
  92
  93         nfs_file_set_open_context(filp, ctx);
  94         nfs_fscache_open_file(inode, filp);
  95         err = 0;
  96
  97 out_put_ctx:
  98         put_nfs_open_context(ctx);
  99 out:
 100         dput(parent);
 101         return err;
 102
 103 out_drop:
 104         d_drop(dentry);
 105         err = -EOPENSTALE;
 106         goto out_put_ctx;
 107 }
 108
 109 /*
 110  * Flush all dirty pages, and check for write errors.
 111  */
 112 static int
 113 nfs4_file_flush(struct file *file, fl_owner_t id)
 114 {
 115         struct inode    *inode = file_inode(file);
 116         errseq_t since;
 117
 118         dprintk("NFS: flush(%pD2)\n", file);
 119
 120         nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
 121         if ((file->f_mode & FMODE_WRITE) == 0)
 122                 return 0;
 123
 124         /*
 125          * If we're holding a write delegation, then check if we're required
 126          * to flush the i/o on close. If not, then just start the i/o now.
 127          */
 128         if (!nfs4_delegation_flush_on_close(inode))
 129                 return filemap_fdatawrite(file->f_mapping);
 130
 131         /* Flush writes to the server and return any errors */
 132         since = filemap_sample_wb_err(file->f_mapping);
 133         nfs_wb_all(inode);
 134         return filemap_check_wb_err(file->f_mapping, since);
 135 }
 136
 137 #ifdef CONFIG_NFS_V4_2
 138 static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,
 139                                       struct file *file_out, loff_t pos_out,
 140                                       size_t count, unsigned int flags)
 141 {
 142         struct nfs42_copy_notify_res *cn_resp = NULL;
 143         struct nl4_server *nss = NULL;
 144         nfs4_stateid *cnrs = NULL;
 145         ssize_t ret;
 146         bool sync = false;
 147
 148         /* Only offload copy if superblock is the same */
 149         if (file_in->f_op != &nfs4_file_operations)
 150                 return -EXDEV;
 151         if (!nfs_server_capable(file_inode(file_out), NFS_CAP_COPY) ||
 152             !nfs_server_capable(file_inode(file_in), NFS_CAP_COPY))
 153                 return -EOPNOTSUPP;
 154         if (file_inode(file_in) == file_inode(file_out))
 155                 return -EOPNOTSUPP;
 156         /* if the copy size if smaller than 2 RPC payloads, make it
 157          * synchronous
 158          */
 159         if (count <= 2 * NFS_SERVER(file_inode(file_in))->rsize)
 160                 sync = true;
 161 retry:
 162         if (!nfs42_files_from_same_server(file_in, file_out)) {
 163                 /* for inter copy, if copy size if smaller than 12 RPC
 164                  * payloads, fallback to traditional copy. There are
 165                  * 14 RPCs during an NFSv4.x mount between source/dest
 166                  * servers.
 167                  */
 168                 if (sync ||
 169                         count <= 14 * NFS_SERVER(file_inode(file_in))->rsize)
 170                         return -EOPNOTSUPP;
 171                 cn_resp = kzalloc(sizeof(struct nfs42_copy_notify_res),
 172                                 GFP_NOFS);
 173                 if (unlikely(cn_resp == NULL))
 174                         return -ENOMEM;
 175
 176                 ret = nfs42_proc_copy_notify(file_in, file_out, cn_resp);
 177                 if (ret) {
 178                         ret = -EOPNOTSUPP;
 179                         goto out;
 180                 }
 181                 nss = &cn_resp->cnr_src;
 182                 cnrs = &cn_resp->cnr_stateid;
 183         }
 184         ret = nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count,
 185                                 nss, cnrs, sync);
 186 out:
 187         if (!nfs42_files_from_same_server(file_in, file_out))
 188                 kfree(cn_resp);
 189         if (ret == -EAGAIN)
 190                 goto retry;
 191         return ret;
 192 }
 193
 194 static ssize_t nfs4_copy_file_range(struct file *file_in, loff_t pos_in,
 195                                     struct file *file_out, loff_t pos_out,
 196                                     size_t count, unsigned int flags)
 197 {
 198         ssize_t ret;
 199
 200         ret = __nfs4_copy_file_range(file_in, pos_in, file_out, pos_out, count,
 201                                      flags);
 202         if (ret == -EOPNOTSUPP || ret == -EXDEV)
 203                 ret = generic_copy_file_range(file_in, pos_in, file_out,
 204                                               pos_out, count, flags);
 205         return ret;
 206 }
 207
 208 static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence)
 209 {
 210         loff_t ret;
 211
 212         switch (whence) {
 213         case SEEK_HOLE:
 214         case SEEK_DATA:
 215                 ret = nfs42_proc_llseek(filep, offset, whence);
 216                 if (ret != -EOPNOTSUPP)
 217                         return ret;
 218                 fallthrough;
 219         default:
 220                 return nfs_file_llseek(filep, offset, whence);
 221         }
 222 }
 223
 224 static long nfs42_fallocate(struct file *filep, int mode, loff_t offset, loff_t len)
 225 {
 226         struct inode *inode = file_inode(filep);
 227         long ret;
 228
 229         if (!S_ISREG(inode->i_mode))
 230                 return -EOPNOTSUPP;
 231
 232         if ((mode != 0) && (mode != (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE)))
 233                 return -EOPNOTSUPP;
 234
 235         ret = inode_newsize_ok(inode, offset + len);
 236         if (ret < 0)
 237                 return ret;
 238
 239         if (mode & FALLOC_FL_PUNCH_HOLE)
 240                 return nfs42_proc_deallocate(filep, offset, len);
 241         return nfs42_proc_allocate(filep, offset, len);
 242 }
 243
 244 static loff_t nfs42_remap_file_range(struct file *src_file, loff_t src_off,
 245                 struct file *dst_file, loff_t dst_off, loff_t count,
 246                 unsigned int remap_flags)
 247 {
 248         struct inode *dst_inode = file_inode(dst_file);
 249         struct nfs_server *server = NFS_SERVER(dst_inode);
 250         struct inode *src_inode = file_inode(src_file);
 251         unsigned int bs = server->clone_blksize;
 252         bool same_inode = false;
 253         int ret;
 254
 255         /* NFS does not support deduplication. */
 256         if (remap_flags & REMAP_FILE_DEDUP)
 257                 return -EOPNOTSUPP;
 258
 259         if (remap_flags & ~REMAP_FILE_ADVISORY)
 260                 return -EINVAL;
 261
 262         if (IS_SWAPFILE(dst_inode) || IS_SWAPFILE(src_inode))
 263                 return -ETXTBSY;
 264
 265         /* check alignment w.r.t. clone_blksize */
 266         ret = -EINVAL;
 267         if (bs) {
 268                 if (!IS_ALIGNED(src_off, bs) || !IS_ALIGNED(dst_off, bs))
 269                         goto out;
 270                 if (!IS_ALIGNED(count, bs) && i_size_read(src_inode) != (src_off + count))
 271                         goto out;
 272         }
 273
 274         if (src_inode == dst_inode)
 275                 same_inode = true;
 276
 277         /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
 278         if (same_inode) {
 279                 inode_lock(src_inode);
 280         } else if (dst_inode < src_inode) {
 281                 inode_lock_nested(dst_inode, I_MUTEX_PARENT);
 282                 inode_lock_nested(src_inode, I_MUTEX_CHILD);
 283         } else {
 284                 inode_lock_nested(src_inode, I_MUTEX_PARENT);
 285                 inode_lock_nested(dst_inode, I_MUTEX_CHILD);
 286         }
 287
 288         /* flush all pending writes on both src and dst so that server
 289          * has the latest data */
 290         ret = nfs_sync_inode(src_inode);
 291         if (ret)
 292                 goto out_unlock;
 293         ret = nfs_sync_inode(dst_inode);
 294         if (ret)
 295                 goto out_unlock;
 296
 297         ret = nfs42_proc_clone(src_file, dst_file, src_off, dst_off, count);
 298
 299         /* truncate inode page cache of the dst range so that future reads can fetch
 300          * new data from server */
 301         if (!ret)
 302                 truncate_inode_pages_range(&dst_inode->i_data, dst_off, dst_off + count - 1);
 303
 304 out_unlock:
 305         if (same_inode) {
 306                 inode_unlock(src_inode);
 307         } else if (dst_inode < src_inode) {
 308                 inode_unlock(src_inode);
 309                 inode_unlock(dst_inode);
 310         } else {
 311                 inode_unlock(dst_inode);
 312                 inode_unlock(src_inode);
 313         }
 314 out:
 315         return ret < 0 ? ret : count;
 316 }
 317
 318 static int read_name_gen = 1;
 319 #define SSC_READ_NAME_BODY "ssc_read_%d"
 320
 321 static struct file *__nfs42_ssc_open(struct vfsmount *ss_mnt,
 322                 struct nfs_fh *src_fh, nfs4_stateid *stateid)
 323 {
 324         struct nfs_fattr *fattr = nfs_alloc_fattr();
 325         struct file *filep, *res;
 326         struct nfs_server *server;
 327         struct inode *r_ino = NULL;
 328         struct nfs_open_context *ctx;
 329         struct nfs4_state_owner *sp;
 330         char *read_name = NULL;
 331         int len, status = 0;
 332
 333         server = NFS_SERVER(ss_mnt->mnt_root->d_inode);
 334
 335         if (!fattr)
 336                 return ERR_PTR(-ENOMEM);
 337
 338         status = nfs4_proc_getattr(server, src_fh, fattr, NULL, NULL);
 339         if (status < 0) {
 340                 res = ERR_PTR(status);
 341                 goto out;
 342         }
 343
 344         if (!S_ISREG(fattr->mode)) {
 345                 res = ERR_PTR(-EBADF);
 346                 goto out;
 347         }
 348
 349         res = ERR_PTR(-ENOMEM);
 350         len = strlen(SSC_READ_NAME_BODY) + 16;
 351         read_name = kzalloc(len, GFP_NOFS);
 352         if (read_name == NULL)
 353                 goto out;
 354         snprintf(read_name, len, SSC_READ_NAME_BODY, read_name_gen++);
 355
 356         r_ino = nfs_fhget(ss_mnt->mnt_root->d_inode->i_sb, src_fh, fattr,
 357                         NULL);
 358         if (IS_ERR(r_ino)) {
 359                 res = ERR_CAST(r_ino);
 360                 goto out_free_name;
 361         }
 362
 363         filep = alloc_file_pseudo(r_ino, ss_mnt, read_name, FMODE_READ,
 364                                      r_ino->i_fop);
 365         if (IS_ERR(filep)) {
 366                 res = ERR_CAST(filep);
 367                 iput(r_ino);
 368                 goto out_free_name;
 369         }
 370         filep->f_mode |= FMODE_READ;
 371
 372         ctx = alloc_nfs_open_context(filep->f_path.dentry, filep->f_mode,
 373                                         filep);
 374         if (IS_ERR(ctx)) {
 375                 res = ERR_CAST(ctx);
 376                 goto out_filep;
 377         }
 378
 379         res = ERR_PTR(-EINVAL);
 380         sp = nfs4_get_state_owner(server, ctx->cred, GFP_KERNEL);
 381         if (sp == NULL)
 382                 goto out_ctx;
 383
 384         ctx->state = nfs4_get_open_state(r_ino, sp);
 385         if (ctx->state == NULL)
 386                 goto out_stateowner;
 387
 388         set_bit(NFS_SRV_SSC_COPY_STATE, &ctx->state->flags);
 389         memcpy(&ctx->state->open_stateid.other, &stateid->other,
 390                NFS4_STATEID_OTHER_SIZE);
 391         update_open_stateid(ctx->state, stateid, NULL, filep->f_mode);
 392         set_bit(NFS_OPEN_STATE, &ctx->state->flags);
 393
 394         nfs_file_set_open_context(filep, ctx);
 395         put_nfs_open_context(ctx);
 396
 397         file_ra_state_init(&filep->f_ra, filep->f_mapping->host->i_mapping);
 398         res = filep;
 399 out_free_name:
 400         kfree(read_name);
 401 out:
 402         nfs_free_fattr(fattr);
 403         return res;
 404 out_stateowner:
 405         nfs4_put_state_owner(sp);
 406 out_ctx:
 407         put_nfs_open_context(ctx);
 408 out_filep:
 409         fput(filep);
 410         goto out_free_name;
 411 }
 412
 413 static void __nfs42_ssc_close(struct file *filep)
 414 {
 415         struct nfs_open_context *ctx = nfs_file_open_context(filep);
 416
 417         ctx->state->flags = 0;
 418 }
 419
 420 static const struct nfs4_ssc_client_ops nfs4_ssc_clnt_ops_tbl = {
 421         .sco_open = __nfs42_ssc_open,
 422         .sco_close = __nfs42_ssc_close,
 423 };
 424
 425 /**
 426  * nfs42_ssc_register_ops - Wrapper to register NFS_V4 ops in nfs_common
 427  *
 428  * Return values:
 429  *   None
 430  */
 431 void nfs42_ssc_register_ops(void)
 432 {
 433         nfs42_ssc_register(&nfs4_ssc_clnt_ops_tbl);
 434 }
 435
 436 /**
 437  * nfs42_ssc_unregister_ops - wrapper to un-register NFS_V4 ops in nfs_common
 438  *
 439  * Return values:
 440  *   None.
 441  */
 442 void nfs42_ssc_unregister_ops(void)
 443 {
 444         nfs42_ssc_unregister(&nfs4_ssc_clnt_ops_tbl);
 445 }
 446 #endif /* CONFIG_NFS_V4_2 */
 447
 448 const struct file_operations nfs4_file_operations = {
 449         .read_iter      = nfs_file_read,
 450         .write_iter     = nfs_file_write,
 451         .mmap           = nfs_file_mmap,
 452         .open           = nfs4_file_open,
 453         .flush          = nfs4_file_flush,
 454         .release        = nfs_file_release,
 455         .fsync          = nfs_file_fsync,
 456         .lock           = nfs_lock,
 457         .flock          = nfs_flock,
 458         .splice_read    = generic_file_splice_read,
 459         .splice_write   = iter_file_splice_write,
 460         .check_flags    = nfs_check_flags,
 461         .setlease       = simple_nosetlease,
 462 #ifdef CONFIG_NFS_V4_2
 463         .copy_file_range = nfs4_copy_file_range,
 464         .llseek         = nfs4_file_llseek,
 465         .fallocate      = nfs42_fallocate,
 466         .remap_file_range = nfs42_remap_file_range,
 467 #else
 468         .llseek         = nfs_file_llseek,
 469 #endif
 470 };