lustre/llite/file.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/llite/file.c
  32  *
  33  * Author: Peter Braam <braam@clusterfs.com>
  34  * Author: Phil Schwan <phil@clusterfs.com>
  35  * Author: Andreas Dilger <adilger@clusterfs.com>
  36  */
  37
  38 #define DEBUG_SUBSYSTEM S_LLITE
  39 #include <lustre_dlm.h>
  40 #include <linux/pagemap.h>
  41 #include <linux/file.h>
  42 #include <linux/sched.h>
  43 #include <linux/user_namespace.h>
  44 #include <linux/uidgid.h>
  45 #include <linux/falloc.h>
  46 #include <linux/ktime.h>
  47 #ifdef HAVE_LINUX_FILELOCK_HEADER
  48 #include <linux/filelock.h>
  49 #endif
  50
  51 #include <uapi/linux/lustre/lustre_ioctl.h>
  52 #include <lustre_swab.h>
  53
  54 #include "cl_object.h"
  55 #include "llite_internal.h"
  56 #include "vvp_internal.h"
  57
  58 struct split_param {
  59         struct inode    *sp_inode;
  60         __u16           sp_mirror_id;
  61 };
  62
  63 struct pcc_param {
  64         __u64   pa_data_version;
  65         __u32   pa_archive_id;
  66         __u32   pa_layout_gen;
  67 };
  68
  69 static int
  70 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
  71
  72 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
  73                           bool *lease_broken);
  74
  75 static struct ll_file_data *ll_file_data_get(void)
  76 {
  77         struct ll_file_data *fd;
  78
  79         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
  80         if (fd == NULL)
  81                 return NULL;
  82
  83         fd->fd_write_failed = false;
  84         pcc_file_init(&fd->fd_pcc_file);
  85
  86         return fd;
  87 }
  88
  89 static void ll_file_data_put(struct ll_file_data *fd)
  90 {
  91         if (fd != NULL)
  92                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
  93 }
  94
  95 /**
  96  * Packs all the attributes into @op_data for the CLOSE rpc.
  97  */
  98 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
  99                              struct obd_client_handle *och)
 100 {
 101         ENTRY;
 102
 103         ll_prep_md_op_data(op_data, inode, NULL, NULL,
 104                            0, 0, LUSTRE_OPC_ANY, NULL);
 105
 106         op_data->op_attr.ia_mode = inode->i_mode;
 107         op_data->op_attr.ia_atime = inode->i_atime;
 108         op_data->op_attr.ia_mtime = inode->i_mtime;
 109         op_data->op_attr.ia_ctime = inode->i_ctime;
 110         /* In case of encrypted file without the key, visible size was rounded
 111          * up to next LUSTRE_ENCRYPTION_UNIT_SIZE, and clear text size was
 112          * stored into lli_lazysize in ll_merge_attr(), so set proper file size
 113          * now that we are closing.
 114          */
 115         if (llcrypt_require_key(inode) == -ENOKEY &&
 116             ll_i2info(inode)->lli_attr_valid & OBD_MD_FLLAZYSIZE)
 117                 op_data->op_attr.ia_size = ll_i2info(inode)->lli_lazysize;
 118         else
 119                 op_data->op_attr.ia_size = i_size_read(inode);
 120         op_data->op_attr.ia_valid |= (ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
 121                                       ATTR_MTIME | ATTR_MTIME_SET |
 122                                       ATTR_CTIME);
 123         op_data->op_xvalid |= OP_XVALID_CTIME_SET;
 124         op_data->op_attr_blocks = inode->i_blocks;
 125         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
 126         if (test_bit(LLIF_PROJECT_INHERIT, &ll_i2info(inode)->lli_flags))
 127                 op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
 128         op_data->op_open_handle = och->och_open_handle;
 129
 130         if (och->och_flags & FMODE_WRITE &&
 131             test_and_clear_bit(LLIF_DATA_MODIFIED,
 132                                &ll_i2info(inode)->lli_flags))
 133                 /* For HSM: if inode data has been modified, pack it so that
 134                  * MDT can set data dirty flag in the archive. */
 135                 op_data->op_bias |= MDS_DATA_MODIFIED;
 136
 137         EXIT;
 138 }
 139
 140 /**
 141  * Perform a close, possibly with a bias.
 142  * The meaning of "data" depends on the value of "bias".
 143  *
 144  * If \a bias is MDS_HSM_RELEASE then \a data is a pointer to the data version.
 145  * If \a bias is MDS_CLOSE_LAYOUT_SWAP then \a data is a pointer to the inode to
 146  * swap layouts with.
 147  */
 148 static int ll_close_inode_openhandle(struct inode *inode,
 149                                      struct obd_client_handle *och,
 150                                      enum mds_op_bias bias, void *data)
 151 {
 152         struct obd_export *md_exp = ll_i2mdexp(inode);
 153         const struct ll_inode_info *lli = ll_i2info(inode);
 154         struct md_op_data *op_data;
 155         struct ptlrpc_request *req = NULL;
 156         int rc;
 157         ENTRY;
 158
 159         if (class_exp2obd(md_exp) == NULL) {
 160                 CERROR("%s: invalid MDC connection handle closing "DFID"\n",
 161                        ll_i2sbi(inode)->ll_fsname, PFID(&lli->lli_fid));
 162                 GOTO(out, rc = 0);
 163         }
 164
 165         OBD_ALLOC_PTR(op_data);
 166         /* We leak openhandle and request here on error, but not much to be
 167          * done in OOM case since app won't retry close on error either. */
 168         if (op_data == NULL)
 169                 GOTO(out, rc = -ENOMEM);
 170
 171         ll_prepare_close(inode, op_data, och);
 172         switch (bias) {
 173         case MDS_CLOSE_LAYOUT_MERGE:
 174                 /* merge blocks from the victim inode */
 175                 op_data->op_attr_blocks += ((struct inode *)data)->i_blocks;
 176                 op_data->op_attr.ia_valid |= ATTR_SIZE;
 177                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
 178                 fallthrough;
 179         case MDS_CLOSE_LAYOUT_SPLIT:
 180         case MDS_CLOSE_LAYOUT_SWAP: {
 181                 struct split_param *sp = data;
 182
 183                 LASSERT(data != NULL);
 184                 op_data->op_bias |= bias;
 185                 op_data->op_data_version = 0;
 186                 op_data->op_lease_handle = och->och_lease_handle;
 187                 if (bias == MDS_CLOSE_LAYOUT_SPLIT) {
 188                         op_data->op_fid2 = *ll_inode2fid(sp->sp_inode);
 189                         op_data->op_mirror_id = sp->sp_mirror_id;
 190                 } else {
 191                         op_data->op_fid2 = *ll_inode2fid(data);
 192                 }
 193                 break;
 194         }
 195
 196         case MDS_CLOSE_RESYNC_DONE: {
 197                 struct ll_ioc_lease *ioc = data;
 198
 199                 LASSERT(data != NULL);
 200                 op_data->op_attr_blocks +=
 201                         ioc->lil_count * op_data->op_attr_blocks;
 202                 op_data->op_attr.ia_valid |= ATTR_SIZE;
 203                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
 204                 op_data->op_bias |= MDS_CLOSE_RESYNC_DONE;
 205
 206                 op_data->op_lease_handle = och->och_lease_handle;
 207                 op_data->op_data = &ioc->lil_ids[0];
 208                 op_data->op_data_size =
 209                         ioc->lil_count * sizeof(ioc->lil_ids[0]);
 210                 break;
 211         }
 212
 213         case MDS_PCC_ATTACH: {
 214                 struct pcc_param *param = data;
 215
 216                 LASSERT(data != NULL);
 217                 op_data->op_bias |= MDS_HSM_RELEASE | MDS_PCC_ATTACH;
 218                 op_data->op_archive_id = param->pa_archive_id;
 219                 op_data->op_data_version = param->pa_data_version;
 220                 op_data->op_lease_handle = och->och_lease_handle;
 221                 break;
 222         }
 223
 224         case MDS_HSM_RELEASE:
 225                 LASSERT(data != NULL);
 226                 op_data->op_bias |= MDS_HSM_RELEASE;
 227                 op_data->op_data_version = *(__u64 *)data;
 228                 op_data->op_lease_handle = och->och_lease_handle;
 229                 op_data->op_attr.ia_valid |= ATTR_SIZE;
 230                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
 231                 break;
 232
 233         default:
 234                 LASSERT(data == NULL);
 235                 break;
 236         }
 237
 238         if (!(op_data->op_attr.ia_valid & ATTR_SIZE))
 239                 op_data->op_xvalid |= OP_XVALID_LAZYSIZE;
 240         if (!(op_data->op_xvalid & OP_XVALID_BLOCKS))
 241                 op_data->op_xvalid |= OP_XVALID_LAZYBLOCKS;
 242
 243         rc = md_close(md_exp, op_data, och->och_mod, &req);
 244         if (rc != 0 && rc != -EINTR)
 245                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
 246                        md_exp->exp_obd->obd_name, PFID(&lli->lli_fid), rc);
 247
 248         if (rc == 0 && op_data->op_bias & bias) {
 249                 struct mdt_body *body;
 250
 251                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 252                 if (!(body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED))
 253                         rc = -EBUSY;
 254
 255                 if (bias & MDS_PCC_ATTACH) {
 256                         struct pcc_param *param = data;
 257
 258                         param->pa_layout_gen = body->mbo_layout_gen;
 259                 }
 260         }
 261
 262         ll_finish_md_op_data(op_data);
 263         EXIT;
 264 out:
 265
 266         md_clear_open_replay_data(md_exp, och);
 267         och->och_open_handle.cookie = DEAD_HANDLE_MAGIC;
 268         OBD_FREE_PTR(och);
 269
 270         ptlrpc_req_finished(req);       /* This is close request */
 271         return rc;
 272 }
 273
 274 int ll_md_real_close(struct inode *inode, fmode_t fmode)
 275 {
 276         struct ll_inode_info *lli = ll_i2info(inode);
 277         struct obd_client_handle **och_p;
 278         struct obd_client_handle *och;
 279         __u64 *och_usecount;
 280         int rc = 0;
 281         ENTRY;
 282
 283         if (fmode & FMODE_WRITE) {
 284                 och_p = &lli->lli_mds_write_och;
 285                 och_usecount = &lli->lli_open_fd_write_count;
 286         } else if (fmode & FMODE_EXEC) {
 287                 och_p = &lli->lli_mds_exec_och;
 288                 och_usecount = &lli->lli_open_fd_exec_count;
 289         } else {
 290                 LASSERT(fmode & FMODE_READ);
 291                 och_p = &lli->lli_mds_read_och;
 292                 och_usecount = &lli->lli_open_fd_read_count;
 293         }
 294
 295         mutex_lock(&lli->lli_och_mutex);
 296         if (*och_usecount > 0) {
 297                 /* There are still users of this handle, so skip
 298                  * freeing it. */
 299                 mutex_unlock(&lli->lli_och_mutex);
 300                 RETURN(0);
 301         }
 302
 303         och = *och_p;
 304         *och_p = NULL;
 305         mutex_unlock(&lli->lli_och_mutex);
 306
 307         if (och != NULL) {
 308                 /* There might be a race and this handle may already
 309                  * be closed. */
 310                 rc = ll_close_inode_openhandle(inode, och, 0, NULL);
 311         }
 312
 313         RETURN(rc);
 314 }
 315
 316 static int ll_md_close(struct inode *inode, struct file *file)
 317 {
 318         union ldlm_policy_data policy = {
 319                 .l_inodebits    = { MDS_INODELOCK_OPEN },
 320         };
 321         __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
 322         struct ll_file_data *fd = file->private_data;
 323         struct ll_inode_info *lli = ll_i2info(inode);
 324         struct lustre_handle lockh;
 325         enum ldlm_mode lockmode;
 326         int rc = 0;
 327         ENTRY;
 328
 329         /* clear group lock, if present */
 330         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
 331                 ll_put_grouplock(inode, file, fd->fd_grouplock.lg_gid);
 332
 333         mutex_lock(&lli->lli_och_mutex);
 334         if (fd->fd_lease_och != NULL) {
 335                 bool lease_broken;
 336                 struct obd_client_handle *lease_och;
 337
 338                 lease_och = fd->fd_lease_och;
 339                 fd->fd_lease_och = NULL;
 340                 mutex_unlock(&lli->lli_och_mutex);
 341
 342                 /* Usually the lease is not released when the
 343                  * application crashed, we need to release here. */
 344                 rc = ll_lease_close(lease_och, inode, &lease_broken);
 345
 346                 mutex_lock(&lli->lli_och_mutex);
 347
 348                 CDEBUG_LIMIT(rc ? D_ERROR : D_INODE,
 349                              "Clean up lease "DFID" %d/%d\n",
 350                              PFID(&lli->lli_fid), rc, lease_broken);
 351         }
 352
 353         if (fd->fd_och != NULL) {
 354                 struct obd_client_handle *och;
 355
 356                 och = fd->fd_och;
 357                 fd->fd_och = NULL;
 358                 mutex_unlock(&lli->lli_och_mutex);
 359
 360                 rc = ll_close_inode_openhandle(inode, och, 0, NULL);
 361                 GOTO(out, rc);
 362         }
 363
 364         /* Let's see if we have good enough OPEN lock on the file and if
 365            we can skip talking to MDS */
 366         if (fd->fd_omode & FMODE_WRITE) {
 367                 lockmode = LCK_CW;
 368                 LASSERT(lli->lli_open_fd_write_count);
 369                 lli->lli_open_fd_write_count--;
 370         } else if (fd->fd_omode & FMODE_EXEC) {
 371                 lockmode = LCK_PR;
 372                 LASSERT(lli->lli_open_fd_exec_count);
 373                 lli->lli_open_fd_exec_count--;
 374         } else {
 375                 lockmode = LCK_CR;
 376                 LASSERT(lli->lli_open_fd_read_count);
 377                 lli->lli_open_fd_read_count--;
 378         }
 379         mutex_unlock(&lli->lli_och_mutex);
 380
 381         /* LU-4398: do not cache write open lock if the file has exec bit */
 382         if ((lockmode == LCK_CW && inode->i_mode & S_IXUGO) ||
 383             !md_lock_match(ll_i2mdexp(inode), flags, ll_inode2fid(inode),
 384                            LDLM_IBITS, &policy, lockmode, &lockh))
 385                 rc = ll_md_real_close(inode, fd->fd_omode);
 386
 387 out:
 388         file->private_data = NULL;
 389         ll_file_data_put(fd);
 390
 391         RETURN(rc);
 392 }
 393
 394 /* While this returns an error code, fput() the caller does not, so we need
 395  * to make every effort to clean up all of our state here.  Also, applications
 396  * rarely check close errors and even if an error is returned they will not
 397  * re-try the close call.
 398  */
 399 int ll_file_release(struct inode *inode, struct file *file)
 400 {
 401         struct ll_file_data *fd;
 402         struct ll_sb_info *sbi = ll_i2sbi(inode);
 403         struct ll_inode_info *lli = ll_i2info(inode);
 404         ktime_t kstart = ktime_get();
 405         int rc;
 406
 407         ENTRY;
 408
 409         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
 410                PFID(ll_inode2fid(inode)), inode);
 411
 412         fd = file->private_data;
 413         LASSERT(fd != NULL);
 414
 415         /* The last ref on @file, maybe not the the owner pid of statahead,
 416          * because parent and child process can share the same file handle. */
 417         if (S_ISDIR(inode->i_mode) &&
 418             (lli->lli_opendir_key == fd || fd->fd_sai))
 419                 ll_deauthorize_statahead(inode, fd);
 420
 421         if (is_root_inode(inode)) {
 422                 file->private_data = NULL;
 423                 ll_file_data_put(fd);
 424                 GOTO(out, rc = 0);
 425         }
 426
 427         pcc_file_release(inode, file);
 428
 429         if (!S_ISDIR(inode->i_mode)) {
 430                 if (lli->lli_clob != NULL)
 431                         lov_read_and_clear_async_rc(lli->lli_clob);
 432                 lli->lli_async_rc = 0;
 433         }
 434
 435         lli->lli_close_fd_time = ktime_get();
 436
 437         rc = ll_md_close(inode, file);
 438
 439         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
 440                 libcfs_debug_dumplog();
 441
 442 out:
 443         if (!rc && !is_root_inode(inode))
 444                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE,
 445                                    ktime_us_delta(ktime_get(), kstart));
 446         RETURN(rc);
 447 }
 448
 449 static inline int ll_dom_readpage(void *data, struct page *page)
 450 {
 451         /* since ll_dom_readpage is a page cache helper, it is safe to assume
 452          * mapping and host pointers are set here
 453          */
 454         struct inode *inode;
 455         struct niobuf_local *lnb = data;
 456         void *kaddr;
 457         int rc = 0;
 458
 459         inode = page2inode(page);
 460
 461         kaddr = kmap_atomic(page);
 462         memcpy(kaddr, lnb->lnb_data, lnb->lnb_len);
 463         if (lnb->lnb_len < PAGE_SIZE)
 464                 memset(kaddr + lnb->lnb_len, 0,
 465                        PAGE_SIZE - lnb->lnb_len);
 466         kunmap_atomic(kaddr);
 467
 468         if (inode && IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode)) {
 469                 if (!llcrypt_has_encryption_key(inode)) {
 470                         CDEBUG(D_SEC, "no enc key for "DFID"\n",
 471                                PFID(ll_inode2fid(inode)));
 472                         rc = -ENOKEY;
 473                 } else {
 474                         unsigned int offs = 0;
 475
 476                         while (offs < PAGE_SIZE) {
 477                                 /* decrypt only if page is not empty */
 478                                 if (memcmp(page_address(page) + offs,
 479                                            page_address(ZERO_PAGE(0)),
 480                                            LUSTRE_ENCRYPTION_UNIT_SIZE) == 0)
 481                                         break;
 482
 483                                 rc = llcrypt_decrypt_pagecache_blocks(page,
 484                                                     LUSTRE_ENCRYPTION_UNIT_SIZE,
 485                                                                       offs);
 486                                 if (rc)
 487                                         break;
 488
 489                                 offs += LUSTRE_ENCRYPTION_UNIT_SIZE;
 490                         }
 491                 }
 492         }
 493         if (!rc) {
 494                 flush_dcache_page(page);
 495                 SetPageUptodate(page);
 496         }
 497         unlock_page(page);
 498
 499         return rc;
 500 }
 501
 502 #ifdef HAVE_READ_CACHE_PAGE_WANTS_FILE
 503 static inline int ll_dom_read_folio(struct file *file, struct folio *folio0)
 504 {
 505         return ll_dom_readpage(file->private_data, folio_page(folio0, 0));
 506 }
 507 #else
 508 #define ll_dom_read_folio       ll_dom_readpage
 509 #endif
 510
 511 void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req)
 512 {
 513         struct lu_env *env;
 514         struct cl_io *io;
 515         struct ll_inode_info *lli = ll_i2info(inode);
 516         struct cl_object *obj = lli->lli_clob;
 517         struct address_space *mapping = inode->i_mapping;
 518         struct page *vmpage;
 519         struct niobuf_remote *rnb;
 520         struct mdt_body *body;
 521         char *data;
 522         unsigned long index, start;
 523         struct niobuf_local lnb;
 524         __u16 refcheck;
 525         int rc;
 526
 527         ENTRY;
 528
 529         if (obj == NULL)
 530                 RETURN_EXIT;
 531
 532         if (!req_capsule_field_present(&req->rq_pill, &RMF_NIOBUF_INLINE,
 533                                        RCL_SERVER))
 534                 RETURN_EXIT;
 535
 536         rnb = req_capsule_server_get(&req->rq_pill, &RMF_NIOBUF_INLINE);
 537         if (rnb == NULL || rnb->rnb_len == 0)
 538                 RETURN_EXIT;
 539
 540         /* LU-11595: Server may return whole file and that is OK always or
 541          * it may return just file tail and its offset must be aligned with
 542          * client PAGE_SIZE to be used on that client, if server's PAGE_SIZE is
 543          * smaller then offset may be not aligned and that data is just ignored.
 544          */
 545         if (rnb->rnb_offset & ~PAGE_MASK)
 546                 RETURN_EXIT;
 547
 548         /* Server returns whole file or just file tail if it fills in reply
 549          * buffer, in both cases total size should be equal to the file size.
 550          */
 551         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 552         if (rnb->rnb_offset + rnb->rnb_len != body->mbo_dom_size &&
 553             !(inode && IS_ENCRYPTED(inode))) {
 554                 CERROR("%s: server returns off/len %llu/%u but size %llu\n",
 555                        ll_i2sbi(inode)->ll_fsname, rnb->rnb_offset,
 556                        rnb->rnb_len, body->mbo_dom_size);
 557                 RETURN_EXIT;
 558         }
 559
 560         env = cl_env_get(&refcheck);
 561         if (IS_ERR(env))
 562                 RETURN_EXIT;
 563         io = vvp_env_thread_io(env);
 564         io->ci_obj = obj;
 565         io->ci_ignore_layout = 1;
 566         rc = cl_io_init(env, io, CIT_MISC, obj);
 567         if (rc)
 568                 GOTO(out_io, rc);
 569
 570         CDEBUG(D_INFO, "Get data along with open at %llu len %i, size %llu\n",
 571                rnb->rnb_offset, rnb->rnb_len, body->mbo_dom_size);
 572
 573         data = (char *)rnb + sizeof(*rnb);
 574
 575         lnb.lnb_file_offset = rnb->rnb_offset;
 576         start = lnb.lnb_file_offset >> PAGE_SHIFT;
 577         index = 0;
 578         LASSERT((lnb.lnb_file_offset & ~PAGE_MASK) == 0);
 579         lnb.lnb_page_offset = 0;
 580         do {
 581                 struct cl_page *page;
 582
 583                 lnb.lnb_data = data + (index << PAGE_SHIFT);
 584                 lnb.lnb_len = rnb->rnb_len - (index << PAGE_SHIFT);
 585                 if (lnb.lnb_len > PAGE_SIZE)
 586                         lnb.lnb_len = PAGE_SIZE;
 587
 588                 vmpage = ll_read_cache_page(mapping, index + start,
 589                                             ll_dom_read_folio, &lnb);
 590                 if (IS_ERR(vmpage)) {
 591                         CWARN("%s: cannot fill page %lu for "DFID
 592                               " with data: rc = %li\n",
 593                               ll_i2sbi(inode)->ll_fsname, index + start,
 594                               PFID(lu_object_fid(&obj->co_lu)),
 595                               PTR_ERR(vmpage));
 596                         break;
 597                 }
 598                 lock_page(vmpage);
 599                 if (vmpage->mapping == NULL) {
 600                         unlock_page(vmpage);
 601                         put_page(vmpage);
 602                         /* page was truncated */
 603                         break;
 604                 }
 605                 /* attach VM page to CL page cache */
 606                 page = cl_page_find(env, obj, vmpage->index, vmpage,
 607                                     CPT_CACHEABLE);
 608                 if (IS_ERR(page)) {
 609                         ClearPageUptodate(vmpage);
 610                         unlock_page(vmpage);
 611                         put_page(vmpage);
 612                         break;
 613                 }
 614                 SetPageUptodate(vmpage);
 615                 cl_page_put(env, page);
 616                 unlock_page(vmpage);
 617                 put_page(vmpage);
 618                 index++;
 619         } while (rnb->rnb_len > (index << PAGE_SHIFT));
 620
 621 out_io:
 622         cl_io_fini(env, io);
 623         cl_env_put(env, &refcheck);
 624
 625         EXIT;
 626 }
 627
 628 static int ll_intent_file_open(struct dentry *de, void *lmm, int lmmsize,
 629                                 struct lookup_intent *itp)
 630 {
 631         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
 632         struct dentry *parent = de->d_parent;
 633         char *name = NULL;
 634         int len = 0;
 635         struct md_op_data *op_data;
 636         struct ptlrpc_request *req = NULL;
 637         int rc;
 638         ENTRY;
 639
 640         LASSERT(parent != NULL);
 641         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
 642
 643         /* if server supports open-by-fid, or file name is invalid, don't pack
 644          * name in open request */
 645         if (CFS_FAIL_CHECK(OBD_FAIL_LLITE_OPEN_BY_NAME) ||
 646             !(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID)) {
 647 retry:
 648                 len = de->d_name.len;
 649                 name = kmalloc(len + 1, GFP_NOFS);
 650                 if (!name)
 651                         RETURN(-ENOMEM);
 652
 653                 /* race here */
 654                 spin_lock(&de->d_lock);
 655                 if (len != de->d_name.len) {
 656                         spin_unlock(&de->d_lock);
 657                         kfree(name);
 658                         goto retry;
 659                 }
 660                 memcpy(name, de->d_name.name, len);
 661                 name[len] = '\0';
 662                 spin_unlock(&de->d_lock);
 663
 664                 if (!lu_name_is_valid_2(name, len)) {
 665                         kfree(name);
 666                         RETURN(-ESTALE);
 667                 }
 668         }
 669
 670         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
 671                                      name, len, 0, LUSTRE_OPC_OPEN, NULL);
 672         if (IS_ERR(op_data)) {
 673                 kfree(name);
 674                 RETURN(PTR_ERR(op_data));
 675         }
 676         op_data->op_data = lmm;
 677         op_data->op_data_size = lmmsize;
 678
 679         CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_OPEN_DELAY, cfs_fail_val);
 680
 681         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
 682                             &ll_md_blocking_ast, 0);
 683         kfree(name);
 684         ll_finish_md_op_data(op_data);
 685         if (rc == -ESTALE) {
 686                 /* reason for keep own exit path - don`t flood log
 687                  * with messages with -ESTALE errors.
 688                  */
 689                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
 690                      it_open_error(DISP_OPEN_OPEN, itp))
 691                         GOTO(out, rc);
 692                 ll_release_openhandle(de, itp);
 693                 GOTO(out, rc);
 694         }
 695
 696         if (it_disposition(itp, DISP_LOOKUP_NEG))
 697                 GOTO(out, rc = -ENOENT);
 698
 699         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
 700                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
 701                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
 702                 GOTO(out, rc);
 703         }
 704
 705         rc = ll_prep_inode(&de->d_inode, &req->rq_pill, NULL, itp);
 706
 707         if (!rc && itp->it_lock_mode) {
 708                 __u64 bits = 0;
 709
 710                 /* If we got a lock back and it has a LOOKUP bit set,
 711                  * make sure the dentry is marked as valid so we can find it.
 712                  * We don't need to care about actual hashing since other bits
 713                  * of kernel will deal with that later.
 714                  */
 715                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, &bits);
 716                 if (bits & MDS_INODELOCK_LOOKUP)
 717                         d_lustre_revalidate(de);
 718
 719                 /* if DoM bit returned along with LAYOUT bit then there
 720                  * can be read-on-open data returned.
 721                  */
 722                 if (bits & MDS_INODELOCK_DOM && bits & MDS_INODELOCK_LAYOUT)
 723                         ll_dom_finish_open(de->d_inode, req);
 724         }
 725         /* open may not fetch LOOKUP lock, update dir depth and default LMV
 726          * anyway.
 727          */
 728         if (!rc && S_ISDIR(de->d_inode->i_mode))
 729                 ll_update_dir_depth_dmv(parent->d_inode, de);
 730
 731 out:
 732         ptlrpc_req_finished(req);
 733         ll_intent_drop_lock(itp);
 734
 735         /* We did open by fid, but by the time we got to the server, the object
 736          * disappeared.  This is possible if the object was unlinked, but it's
 737          * also possible if the object was unlinked by a rename.  In the case
 738          * of an object renamed over our existing one, we can't fail this open.
 739          * O_CREAT also goes through this path if we had an existing dentry,
 740          * and it's obviously wrong to return ENOENT for O_CREAT.
 741          *
 742          * Instead let's return -ESTALE, and the VFS will retry the open with
 743          * LOOKUP_REVAL, which we catch in ll_revalidate_dentry and fail to
 744          * revalidate, causing a lookup.  This causes extra lookups in the case
 745          * where we had a dentry in cache but the file is being unlinked and we
 746          * lose the race with unlink, but this should be very rare.
 747          */
 748         if (rc == -ENOENT)
 749                 rc = -ESTALE;
 750
 751         RETURN(rc);
 752 }
 753
 754 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 755                        struct obd_client_handle *och)
 756 {
 757         struct mdt_body *body;
 758
 759         body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
 760         och->och_open_handle = body->mbo_open_handle;
 761         och->och_fid = body->mbo_fid1;
 762         och->och_lease_handle.cookie = it->it_lock_handle;
 763         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
 764         och->och_flags = it->it_flags;
 765
 766         return md_set_open_replay_data(md_exp, och, it);
 767 }
 768
 769 static int ll_local_open(struct file *file, struct lookup_intent *it,
 770                          struct ll_file_data *fd, struct obd_client_handle *och)
 771 {
 772         struct inode *inode = file_inode(file);
 773         ENTRY;
 774
 775         LASSERT(!file->private_data);
 776
 777         LASSERT(fd != NULL);
 778
 779         if (och) {
 780                 int rc;
 781
 782                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
 783                 if (rc != 0)
 784                         RETURN(rc);
 785         }
 786
 787         file->private_data = fd;
 788         ll_readahead_init(inode, &fd->fd_ras);
 789         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
 790
 791         RETURN(0);
 792 }
 793
 794 void ll_track_file_opens(struct inode *inode)
 795 {
 796         struct ll_inode_info *lli = ll_i2info(inode);
 797         struct ll_sb_info *sbi = ll_i2sbi(inode);
 798
 799         /* do not skew results with delays from never-opened inodes */
 800         if (ktime_to_ns(lli->lli_close_fd_time))
 801                 ll_stats_ops_tally(sbi, LPROC_LL_INODE_OPCLTM,
 802                            ktime_us_delta(ktime_get(), lli->lli_close_fd_time));
 803
 804         if (ktime_after(ktime_get(),
 805                         ktime_add_ms(lli->lli_close_fd_time,
 806                                      sbi->ll_oc_max_ms))) {
 807                 lli->lli_open_fd_count = 1;
 808                 lli->lli_close_fd_time = ns_to_ktime(0);
 809         } else {
 810                 lli->lli_open_fd_count++;
 811         }
 812
 813         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_OCOUNT,
 814                            lli->lli_open_fd_count);
 815 }
 816
 817 /* Open a file, and (for the very first open) create objects on the OSTs at
 818  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
 819  * creation or open until ll_lov_setstripe() ioctl is called.
 820  *
 821  * If we already have the stripe MD locally then we don't request it in
 822  * md_open(), by passing a lmm_size = 0.
 823  *
 824  * It is up to the application to ensure no other processes open this file
 825  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
 826  * used.  We might be able to avoid races of that sort by getting lli_open_sem
 827  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
 828  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
 829  */
 830 int ll_file_open(struct inode *inode, struct file *file)
 831 {
 832         struct ll_inode_info *lli = ll_i2info(inode);
 833         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
 834                                           .it_flags = file->f_flags };
 835         struct obd_client_handle **och_p = NULL;
 836         __u64 *och_usecount = NULL;
 837         struct ll_file_data *fd;
 838         ktime_t kstart = ktime_get();
 839         int rc = 0;
 840         ENTRY;
 841
 842         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
 843                PFID(ll_inode2fid(inode)), inode, file->f_flags);
 844
 845         it = file->private_data; /* XXX: compat macro */
 846         file->private_data = NULL; /* prevent ll_local_open assertion */
 847
 848         if (S_ISREG(inode->i_mode)) {
 849                 rc = ll_file_open_encrypt(inode, file);
 850                 if (rc) {
 851                         if (it && it->it_disposition)
 852                                 ll_release_openhandle(file_dentry(file), it);
 853                         GOTO(out_nofiledata, rc);
 854                 }
 855         }
 856
 857         fd = ll_file_data_get();
 858         if (fd == NULL)
 859                 GOTO(out_nofiledata, rc = -ENOMEM);
 860
 861         fd->fd_file = file;
 862         if (S_ISDIR(inode->i_mode))
 863                 ll_authorize_statahead(inode, fd);
 864
 865         ll_track_file_opens(inode);
 866         if (is_root_inode(inode)) {
 867                 file->private_data = fd;
 868                 RETURN(0);
 869         }
 870
 871         if (!it || !it->it_disposition) {
 872                 /* Convert f_flags into access mode. We cannot use file->f_mode,
 873                  * because everything but O_ACCMODE mask was stripped from
 874                  * there */
 875                 if ((oit.it_flags + 1) & O_ACCMODE)
 876                         oit.it_flags++;
 877                 if (file->f_flags & O_TRUNC)
 878                         oit.it_flags |= FMODE_WRITE;
 879
 880                 /* kernel only call f_op->open in dentry_open.  filp_open calls
 881                  * dentry_open after call to open_namei that checks permissions.
 882                  * Only nfsd_open call dentry_open directly without checking
 883                  * permissions and because of that this code below is safe.
 884                  */
 885                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
 886                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
 887
 888                 /* We do not want O_EXCL here, presumably we opened the file
 889                  * already? XXX - NFS implications? */
 890                 oit.it_flags &= ~O_EXCL;
 891
 892                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
 893                  * created if necessary, then "IT_CREAT" should be set to keep
 894                  * consistent with it */
 895                 if (oit.it_flags & O_CREAT)
 896                         oit.it_op |= IT_CREAT;
 897
 898                 it = &oit;
 899         }
 900
 901 restart:
 902         /* Let's see if we have file open on MDS already. */
 903         if (it->it_flags & FMODE_WRITE) {
 904                 och_p = &lli->lli_mds_write_och;
 905                 och_usecount = &lli->lli_open_fd_write_count;
 906         } else if (it->it_flags & FMODE_EXEC) {
 907                 och_p = &lli->lli_mds_exec_och;
 908                 och_usecount = &lli->lli_open_fd_exec_count;
 909         } else {
 910                 och_p = &lli->lli_mds_read_och;
 911                 och_usecount = &lli->lli_open_fd_read_count;
 912         }
 913
 914         mutex_lock(&lli->lli_och_mutex);
 915         if (*och_p) { /* Open handle is present */
 916                 if (it_disposition(it, DISP_OPEN_OPEN)) {
 917                         /* Well, there's extra open request that we do not need,
 918                          * let's close it somehow. This will decref request. */
 919                         rc = it_open_error(DISP_OPEN_OPEN, it);
 920                         if (rc) {
 921                                 mutex_unlock(&lli->lli_och_mutex);
 922                                 GOTO(out_openerr, rc);
 923                         }
 924
 925                         ll_release_openhandle(file_dentry(file), it);
 926                 }
 927                 (*och_usecount)++;
 928
 929                 rc = ll_local_open(file, it, fd, NULL);
 930                 if (rc) {
 931                         (*och_usecount)--;
 932                         mutex_unlock(&lli->lli_och_mutex);
 933                         GOTO(out_openerr, rc);
 934                 }
 935         } else {
 936                 LASSERT(*och_usecount == 0);
 937                 if (!it->it_disposition) {
 938                         struct dentry *dentry = file_dentry(file);
 939                         struct ll_sb_info *sbi = ll_i2sbi(inode);
 940                         int open_threshold = sbi->ll_oc_thrsh_count;
 941
 942                         /* We cannot just request lock handle now, new ELC code
 943                          * means that one of other OPEN locks for this file
 944                          * could be cancelled, and since blocking ast handler
 945                          * would attempt to grab och_mutex as well, that would
 946                          * result in a deadlock
 947                          */
 948                         mutex_unlock(&lli->lli_och_mutex);
 949                         /*
 950                          * Normally called under two situations:
 951                          * 1. fhandle / NFS export.
 952                          * 2. A race/condition on MDS resulting in no open
 953                          *    handle to be returned from LOOKUP|OPEN request,
 954                          *    for example if the target entry was a symlink.
 955                          *
 956                          * For NFSv3 we need to always cache the open lock
 957                          * for pre 5.5 Linux kernels.
 958                          *
 959                          * After reaching number of opens of this inode
 960                          * we always ask for an open lock on it to handle
 961                          * bad userspace actors that open and close files
 962                          * in a loop for absolutely no good reason
 963                          */
 964                         /* fhandle / NFS path. */
 965                         if (lli->lli_open_thrsh_count != UINT_MAX)
 966                                 open_threshold = lli->lli_open_thrsh_count;
 967
 968                         if (filename_is_volatile(dentry->d_name.name,
 969                                                  dentry->d_name.len,
 970                                                  NULL)) {
 971                                 /* There really is nothing here, but this
 972                                  * make this more readable I think.
 973                                  * We do not want openlock for volatile
 974                                  * files under any circumstances
 975                                  */
 976                         } else if (open_threshold > 0) {
 977                                 /* Take MDS_OPEN_LOCK with many opens */
 978                                 if (lli->lli_open_fd_count >= open_threshold)
 979                                         it->it_flags |= MDS_OPEN_LOCK;
 980
 981                                 /* If this is open after we just closed */
 982                                 else if (ktime_before(ktime_get(),
 983                                             ktime_add_ms(lli->lli_close_fd_time,
 984                                                          sbi->ll_oc_thrsh_ms)))
 985                                         it->it_flags |= MDS_OPEN_LOCK;
 986                         }
 987
 988                         /*
 989                          * Always specify MDS_OPEN_BY_FID because we don't want
 990                          * to get file with different fid.
 991                          */
 992                         it->it_flags |= MDS_OPEN_BY_FID;
 993                         rc = ll_intent_file_open(dentry, NULL, 0, it);
 994                         if (rc)
 995                                 GOTO(out_openerr, rc);
 996
 997                         goto restart;
 998                 }
 999                 OBD_ALLOC(*och_p, sizeof(struct obd_client_handle));
1000                 if (!*och_p)
1001                         GOTO(out_och_free, rc = -ENOMEM);
1002
1003                 (*och_usecount)++;
1004
1005                 /* md_intent_lock() didn't get a request ref if there was an
1006                  * open error, so don't do cleanup on the request here
1007                  * (bug 3430) */
1008                 /* XXX (green): Should not we bail out on any error here, not
1009                  * just open error? */
1010                 rc = it_open_error(DISP_OPEN_OPEN, it);
1011                 if (rc != 0)
1012                         GOTO(out_och_free, rc);
1013
1014                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
1015                          "inode %p: disposition %x, status %d\n", inode,
1016                          it_disposition(it, ~0), it->it_status);
1017
1018                 rc = ll_local_open(file, it, fd, *och_p);
1019                 if (rc)
1020                         GOTO(out_och_free, rc);
1021         }
1022
1023         rc = pcc_file_open(inode, file);
1024         if (rc)
1025                 GOTO(out_och_free, rc);
1026
1027         mutex_unlock(&lli->lli_och_mutex);
1028
1029         fd = NULL;
1030
1031         /* Must do this outside lli_och_mutex lock to prevent deadlock where
1032            different kind of OPEN lock for this same inode gets cancelled
1033            by ldlm_cancel_lru */
1034         if (!S_ISREG(inode->i_mode))
1035                 GOTO(out_och_free, rc);
1036         cl_lov_delay_create_clear(&file->f_flags);
1037         GOTO(out_och_free, rc);
1038
1039 out_och_free:
1040         if (rc) {
1041                 if (och_p && *och_p) {
1042                         OBD_FREE(*och_p, sizeof(struct obd_client_handle));
1043                         *och_p = NULL; /* OBD_FREE writes some magic there */
1044                         (*och_usecount)--;
1045                 }
1046                 mutex_unlock(&lli->lli_och_mutex);
1047
1048 out_openerr:
1049                 if (lli->lli_opendir_key == fd)
1050                         ll_deauthorize_statahead(inode, fd);
1051
1052                 if (fd != NULL)
1053                         ll_file_data_put(fd);
1054         } else {
1055                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN,
1056                                    ktime_us_delta(ktime_get(), kstart));
1057         }
1058
1059 out_nofiledata:
1060         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
1061                 ptlrpc_req_finished(it->it_request);
1062                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1063         }
1064
1065         return rc;
1066 }
1067
1068 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
1069                         struct ldlm_lock_desc *desc, void *data, int flag)
1070 {
1071         int rc;
1072         struct lustre_handle lockh;
1073         ENTRY;
1074
1075         switch (flag) {
1076         case LDLM_CB_BLOCKING:
1077                 ldlm_lock2handle(lock, &lockh);
1078                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
1079                 if (rc < 0) {
1080                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
1081                         RETURN(rc);
1082                 }
1083                 break;
1084         case LDLM_CB_CANCELING:
1085                 /* do nothing */
1086                 break;
1087         }
1088         RETURN(0);
1089 }
1090
1091 /**
1092  * When setting a lease on a file, we take ownership of the lli_mds_*_och
1093  * and save it as fd->fd_och so as to force client to reopen the file even
1094  * if it has an open lock in cache already.
1095  */
1096 static int ll_lease_och_acquire(struct inode *inode, struct file *file,
1097                                 struct lustre_handle *old_open_handle)
1098 {
1099         struct ll_inode_info *lli = ll_i2info(inode);
1100         struct ll_file_data *fd = file->private_data;
1101         struct obd_client_handle **och_p;
1102         __u64 *och_usecount;
1103         int rc = 0;
1104         ENTRY;
1105
1106         /* Get the openhandle of the file */
1107         mutex_lock(&lli->lli_och_mutex);
1108         if (fd->fd_lease_och != NULL)
1109                 GOTO(out_unlock, rc = -EBUSY);
1110
1111         if (fd->fd_och == NULL) {
1112                 if (file->f_mode & FMODE_WRITE) {
1113                         LASSERT(lli->lli_mds_write_och != NULL);
1114                         och_p = &lli->lli_mds_write_och;
1115                         och_usecount = &lli->lli_open_fd_write_count;
1116                 } else {
1117                         LASSERT(lli->lli_mds_read_och != NULL);
1118                         och_p = &lli->lli_mds_read_och;
1119                         och_usecount = &lli->lli_open_fd_read_count;
1120                 }
1121
1122                 if (*och_usecount > 1)
1123                         GOTO(out_unlock, rc = -EBUSY);
1124
1125                 fd->fd_och = *och_p;
1126                 *och_usecount = 0;
1127                 *och_p = NULL;
1128         }
1129
1130         *old_open_handle = fd->fd_och->och_open_handle;
1131
1132         EXIT;
1133 out_unlock:
1134         mutex_unlock(&lli->lli_och_mutex);
1135         return rc;
1136 }
1137
1138 /**
1139  * Release ownership on lli_mds_*_och when putting back a file lease.
1140  */
1141 static int ll_lease_och_release(struct inode *inode, struct file *file)
1142 {
1143         struct ll_inode_info *lli = ll_i2info(inode);
1144         struct ll_file_data *fd = file->private_data;
1145         struct obd_client_handle **och_p;
1146         struct obd_client_handle *old_och = NULL;
1147         __u64 *och_usecount;
1148         int rc = 0;
1149         ENTRY;
1150
1151         mutex_lock(&lli->lli_och_mutex);
1152         if (file->f_mode & FMODE_WRITE) {
1153                 och_p = &lli->lli_mds_write_och;
1154                 och_usecount = &lli->lli_open_fd_write_count;
1155         } else {
1156                 och_p = &lli->lli_mds_read_och;
1157                 och_usecount = &lli->lli_open_fd_read_count;
1158         }
1159
1160         /* The file may have been open by another process (broken lease) so
1161          * *och_p is not NULL. In this case we should simply increase usecount
1162          * and close fd_och.
1163          */
1164         if (*och_p != NULL) {
1165                 old_och = fd->fd_och;
1166                 (*och_usecount)++;
1167         } else {
1168                 *och_p = fd->fd_och;
1169                 *och_usecount = 1;
1170         }
1171         fd->fd_och = NULL;
1172         mutex_unlock(&lli->lli_och_mutex);
1173
1174         if (old_och != NULL)
1175                 rc = ll_close_inode_openhandle(inode, old_och, 0, NULL);
1176
1177         RETURN(rc);
1178 }
1179
1180 /**
1181  * Acquire a lease and open the file.
1182  */
1183 static struct obd_client_handle *
1184 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
1185               __u64 open_flags)
1186 {
1187         struct lookup_intent it = { .it_op = IT_OPEN };
1188         struct ll_sb_info *sbi = ll_i2sbi(inode);
1189         struct md_op_data *op_data;
1190         struct ptlrpc_request *req = NULL;
1191         struct lustre_handle old_open_handle = { 0 };
1192         struct obd_client_handle *och = NULL;
1193         int rc;
1194         int rc2;
1195         ENTRY;
1196
1197         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
1198                 RETURN(ERR_PTR(-EINVAL));
1199
1200         if (file != NULL) {
1201                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
1202                         RETURN(ERR_PTR(-EPERM));
1203
1204                 rc = ll_lease_och_acquire(inode, file, &old_open_handle);
1205                 if (rc)
1206                         RETURN(ERR_PTR(rc));
1207         }
1208
1209         OBD_ALLOC_PTR(och);
1210         if (och == NULL)
1211                 RETURN(ERR_PTR(-ENOMEM));
1212
1213         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
1214                                         LUSTRE_OPC_ANY, NULL);
1215         if (IS_ERR(op_data))
1216                 GOTO(out, rc = PTR_ERR(op_data));
1217
1218         /* To tell the MDT this openhandle is from the same owner */
1219         op_data->op_open_handle = old_open_handle;
1220
1221         it.it_flags = fmode | open_flags;
1222         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
1223         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
1224                             &ll_md_blocking_lease_ast,
1225         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
1226          * it can be cancelled which may mislead applications that the lease is
1227          * broken;
1228          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
1229          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
1230          * doesn't deal with openhandle, so normal openhandle will be leaked. */
1231                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
1232         ll_finish_md_op_data(op_data);
1233         ptlrpc_req_finished(req);
1234         if (rc < 0)
1235                 GOTO(out_release_it, rc);
1236
1237         if (it_disposition(&it, DISP_LOOKUP_NEG))
1238                 GOTO(out_release_it, rc = -ENOENT);
1239
1240         rc = it_open_error(DISP_OPEN_OPEN, &it);
1241         if (rc)
1242                 GOTO(out_release_it, rc);
1243
1244         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
1245         rc = ll_och_fill(sbi->ll_md_exp, &it, och);
1246         if (rc)
1247                 GOTO(out_release_it, rc);
1248
1249         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
1250                 GOTO(out_close, rc = -EOPNOTSUPP);
1251
1252         /* already get lease, handle lease lock */
1253         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
1254         if (!it.it_lock_mode ||
1255             !(it.it_lock_bits & MDS_INODELOCK_OPEN)) {
1256                 /* open lock must return for lease */
1257                 CERROR(DFID "lease granted but no open lock, %d/%llu.\n",
1258                         PFID(ll_inode2fid(inode)), it.it_lock_mode,
1259                         it.it_lock_bits);
1260                 GOTO(out_close, rc = -EPROTO);
1261         }
1262
1263         ll_intent_release(&it);
1264         RETURN(och);
1265
1266 out_close:
1267         /* Cancel open lock */
1268         if (it.it_lock_mode != 0) {
1269                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
1270                                             it.it_lock_mode);
1271                 it.it_lock_mode = 0;
1272                 och->och_lease_handle.cookie = 0ULL;
1273         }
1274         rc2 = ll_close_inode_openhandle(inode, och, 0, NULL);
1275         if (rc2 < 0)
1276                 CERROR("%s: error closing file "DFID": %d\n",
1277                        sbi->ll_fsname, PFID(&ll_i2info(inode)->lli_fid), rc2);
1278         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
1279 out_release_it:
1280         ll_intent_release(&it);
1281 out:
1282         if (och != NULL)
1283                 OBD_FREE_PTR(och);
1284         RETURN(ERR_PTR(rc));
1285 }
1286
1287 /**
1288  * Check whether a layout swap can be done between two inodes.
1289  *
1290  * \param[in] inode1  First inode to check
1291  * \param[in] inode2  Second inode to check
1292  *
1293  * \retval 0 on success, layout swap can be performed between both inodes
1294  * \retval negative error code if requirements are not met
1295  */
1296 static int ll_check_swap_layouts_validity(struct inode *inode1,
1297                                           struct inode *inode2)
1298 {
1299         if (!S_ISREG(inode1->i_mode) || !S_ISREG(inode2->i_mode))
1300                 return -EINVAL;
1301
1302         if (inode_permission(&nop_mnt_idmap, inode1, MAY_WRITE) ||
1303             inode_permission(&nop_mnt_idmap, inode2, MAY_WRITE))
1304                 return -EPERM;
1305
1306         if (inode1->i_sb != inode2->i_sb)
1307                 return -EXDEV;
1308
1309         return 0;
1310 }
1311
1312 static int ll_swap_layouts_close(struct obd_client_handle *och,
1313                                  struct inode *inode, struct inode *inode2)
1314 {
1315         const struct lu_fid     *fid1 = ll_inode2fid(inode);
1316         const struct lu_fid     *fid2;
1317         int                      rc;
1318         ENTRY;
1319
1320         CDEBUG(D_INODE, "%s: biased close of file "DFID"\n",
1321                ll_i2sbi(inode)->ll_fsname, PFID(fid1));
1322
1323         rc = ll_check_swap_layouts_validity(inode, inode2);
1324         if (rc < 0)
1325                 GOTO(out_free_och, rc);
1326
1327         /* We now know that inode2 is a lustre inode */
1328         fid2 = ll_inode2fid(inode2);
1329
1330         rc = lu_fid_cmp(fid1, fid2);
1331         if (rc == 0)
1332                 GOTO(out_free_och, rc = -EINVAL);
1333
1334         /* Close the file and {swap,merge} layouts between inode & inode2.
1335          * NB: local lease handle is released in mdc_close_intent_pack()
1336          * because we still need it to pack l_remote_handle to MDT. */
1337         rc = ll_close_inode_openhandle(inode, och, MDS_CLOSE_LAYOUT_SWAP,
1338                                        inode2);
1339
1340         och = NULL; /* freed in ll_close_inode_openhandle() */
1341
1342 out_free_och:
1343         if (och != NULL)
1344                 OBD_FREE_PTR(och);
1345
1346         RETURN(rc);
1347 }
1348
1349 /**
1350  * Release lease and close the file.
1351  * It will check if the lease has ever broken.
1352  */
1353 static int ll_lease_close_intent(struct obd_client_handle *och,
1354                                  struct inode *inode,
1355                                  bool *lease_broken, enum mds_op_bias bias,
1356                                  void *data)
1357 {
1358         struct ldlm_lock *lock;
1359         bool cancelled = true;
1360         int rc;
1361         ENTRY;
1362
1363         lock = ldlm_handle2lock(&och->och_lease_handle);
1364         if (lock != NULL) {
1365                 lock_res_and_lock(lock);
1366                 cancelled = ldlm_is_cancel(lock);
1367                 unlock_res_and_lock(lock);
1368                 LDLM_LOCK_PUT(lock);
1369         }
1370
1371         CDEBUG(D_INODE, "lease for "DFID" broken? %d, bias: %x\n",
1372                PFID(&ll_i2info(inode)->lli_fid), cancelled, bias);
1373
1374         if (lease_broken != NULL)
1375                 *lease_broken = cancelled;
1376
1377         if (!cancelled && !bias)
1378                 ldlm_cli_cancel(&och->och_lease_handle, 0);
1379
1380         if (cancelled) { /* no need to excute intent */
1381                 bias = 0;
1382                 data = NULL;
1383         }
1384
1385         rc = ll_close_inode_openhandle(inode, och, bias, data);
1386         RETURN(rc);
1387 }
1388
1389 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
1390                           bool *lease_broken)
1391 {
1392         return ll_lease_close_intent(och, inode, lease_broken, 0, NULL);
1393 }
1394
1395 /**
1396  * After lease is taken, send the RPC MDS_REINT_RESYNC to the MDT
1397  */
1398 static int ll_lease_file_resync(struct obd_client_handle *och,
1399                                 struct inode *inode, void __user *uarg)
1400 {
1401         struct ll_sb_info *sbi = ll_i2sbi(inode);
1402         struct md_op_data *op_data;
1403         struct ll_ioc_lease_id ioc;
1404         __u64 data_version_unused;
1405         int rc;
1406         ENTRY;
1407
1408         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
1409                                      LUSTRE_OPC_ANY, NULL);
1410         if (IS_ERR(op_data))
1411                 RETURN(PTR_ERR(op_data));
1412
1413         if (copy_from_user(&ioc, uarg, sizeof(ioc)))
1414                 RETURN(-EFAULT);
1415
1416         /* before starting file resync, it's necessary to clean up page cache
1417          * in client memory, otherwise once the layout version is increased,
1418          * writing back cached data will be denied the OSTs. */
1419         rc = ll_data_version(inode, &data_version_unused, LL_DV_WR_FLUSH);
1420         if (rc)
1421                 GOTO(out, rc);
1422
1423         op_data->op_lease_handle = och->och_lease_handle;
1424         op_data->op_mirror_id = ioc.lil_mirror_id;
1425         rc = md_file_resync(sbi->ll_md_exp, op_data);
1426         if (rc)
1427                 GOTO(out, rc);
1428
1429         EXIT;
1430 out:
1431         ll_finish_md_op_data(op_data);
1432         return rc;
1433 }
1434
1435 static int ll_merge_attr_nolock(const struct lu_env *env, struct inode *inode)
1436 {
1437         struct ll_inode_info *lli = ll_i2info(inode);
1438         struct cl_object *obj = lli->lli_clob;
1439         struct cl_attr *attr = vvp_env_thread_attr(env);
1440         s64 atime;
1441         s64 mtime;
1442         s64 ctime;
1443         int rc = 0;
1444
1445         ENTRY;
1446
1447         /* Merge timestamps the most recently obtained from MDS with
1448          * timestamps obtained from OSTs.
1449          *
1450          * Do not overwrite atime of inode because it may be refreshed
1451          * by file_accessed() function. If the read was served by cache
1452          * data, there is no RPC to be sent so that atime may not be
1453          * transferred to OSTs at all. MDT only updates atime at close time
1454          * if it's at least 'mdd.*.atime_diff' older.
1455          * All in all, the atime in Lustre does not strictly comply with
1456          * POSIX. Solving this problem needs to send an RPC to MDT for each
1457          * read, this will hurt performance.
1458          */
1459         if (test_and_clear_bit(LLIF_UPDATE_ATIME, &lli->lli_flags) ||
1460             inode->i_atime.tv_sec < lli->lli_atime)
1461                 inode->i_atime.tv_sec = lli->lli_atime;
1462
1463         inode->i_mtime.tv_sec = lli->lli_mtime;
1464         inode->i_ctime.tv_sec = lli->lli_ctime;
1465
1466         mtime = inode->i_mtime.tv_sec;
1467         atime = inode->i_atime.tv_sec;
1468         ctime = inode->i_ctime.tv_sec;
1469
1470         cl_object_attr_lock(obj);
1471         if (CFS_FAIL_CHECK(OBD_FAIL_MDC_MERGE))
1472                 rc = -EINVAL;
1473         else
1474                 rc = cl_object_attr_get(env, obj, attr);
1475         cl_object_attr_unlock(obj);
1476
1477         if (rc != 0)
1478                 GOTO(out, rc = (rc == -ENODATA ? 0 : rc));
1479
1480         if (atime < attr->cat_atime)
1481                 atime = attr->cat_atime;
1482
1483         if (ctime < attr->cat_ctime)
1484                 ctime = attr->cat_ctime;
1485
1486         if (mtime < attr->cat_mtime)
1487                 mtime = attr->cat_mtime;
1488
1489         CDEBUG(D_VFSTRACE, DFID" updating i_size %llu i_blocks %llu\n",
1490                PFID(&lli->lli_fid), attr->cat_size, attr->cat_blocks);
1491
1492         if (llcrypt_require_key(inode) == -ENOKEY) {
1493                 /* Without the key, round up encrypted file size to next
1494                  * LUSTRE_ENCRYPTION_UNIT_SIZE. Clear text size is put in
1495                  * lli_lazysize for proper file size setting at close time.
1496                  */
1497                 lli->lli_attr_valid |= OBD_MD_FLLAZYSIZE;
1498                 lli->lli_lazysize = attr->cat_size;
1499                 attr->cat_size = round_up(attr->cat_size,
1500                                           LUSTRE_ENCRYPTION_UNIT_SIZE);
1501         }
1502         i_size_write(inode, attr->cat_size);
1503         inode->i_blocks = attr->cat_blocks;
1504
1505         inode->i_mtime.tv_sec = mtime;
1506         inode->i_atime.tv_sec = atime;
1507         inode->i_ctime.tv_sec = ctime;
1508
1509         EXIT;
1510 out:
1511         return rc;
1512 }
1513
1514 int ll_merge_attr(const struct lu_env *env, struct inode *inode)
1515 {
1516         int rc;
1517
1518         ll_inode_size_lock(inode);
1519         rc = ll_merge_attr_nolock(env, inode);
1520         ll_inode_size_unlock(inode);
1521
1522         return rc;
1523 }
1524
1525 /* Use to update size and blocks on inode for LSOM if there is no contention */
1526 int ll_merge_attr_try(const struct lu_env *env, struct inode *inode)
1527 {
1528         int rc = 0;
1529
1530         if (ll_inode_size_trylock(inode)) {
1531                 rc = ll_merge_attr_nolock(env, inode);
1532                 ll_inode_size_unlock(inode);
1533         }
1534
1535         return rc;
1536 }
1537
1538 /**
1539  * Set designated mirror for I/O.
1540  *
1541  * So far only read, write, and truncated can support to issue I/O to
1542  * designated mirror.
1543  */
1544 void ll_io_set_mirror(struct cl_io *io, const struct file *file)
1545 {
1546         struct ll_file_data *fd = file->private_data;
1547
1548         /* clear layout version for generic(non-resync) I/O in case it carries
1549          * stale layout version due to I/O restart */
1550         io->ci_layout_version = 0;
1551
1552         /* FLR: disable non-delay for designated mirror I/O because obviously
1553          * only one mirror is available */
1554         if (fd->fd_designated_mirror > 0) {
1555                 io->ci_ndelay = 0;
1556                 io->ci_designated_mirror = fd->fd_designated_mirror;
1557                 io->ci_layout_version = fd->fd_layout_version;
1558         }
1559
1560         CDEBUG(D_VFSTRACE, "%s: desiginated mirror: %d\n",
1561                file->f_path.dentry->d_name.name, io->ci_designated_mirror);
1562 }
1563
1564 /*
1565  * This is relatime_need_update() from Linux 5.17, which is not exported.
1566  */
1567 static int relatime_need_update(struct vfsmount *mnt, struct inode *inode,
1568                                 struct timespec64 now)
1569 {
1570
1571         if (!(mnt->mnt_flags & MNT_RELATIME))
1572                 return 1;
1573         /*
1574          * Is mtime younger than atime? If yes, update atime:
1575          */
1576         if (timespec64_compare(&inode->i_mtime, &inode->i_atime) >= 0)
1577                 return 1;
1578         /*
1579          * Is ctime younger than atime? If yes, update atime:
1580          */
1581         if (timespec64_compare(&inode->i_ctime, &inode->i_atime) >= 0)
1582                 return 1;
1583
1584         /*
1585          * Is the previous atime value older than a day? If yes,
1586          * update atime:
1587          */
1588         if ((long)(now.tv_sec - inode->i_atime.tv_sec) >= 24*60*60)
1589                 return 1;
1590         /*
1591          * Good, we can skip the atime update:
1592          */
1593         return 0;
1594 }
1595
1596 /*
1597  * Very similar to kernel function: !__atime_needs_update()
1598  */
1599 static bool file_is_noatime(const struct file *file)
1600 {
1601         struct vfsmount *mnt = file->f_path.mnt;
1602         struct inode *inode = file_inode((struct file *)file);
1603         struct timespec64 now;
1604
1605         if (file->f_flags & O_NOATIME)
1606                 return true;
1607
1608         if (inode->i_flags & S_NOATIME)
1609                 return true;
1610
1611         if (IS_NOATIME(inode))
1612                 return true;
1613
1614         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1615                 return true;
1616
1617         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1618                 return true;
1619
1620         if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
1621                 return true;
1622
1623         now = current_time(inode);
1624
1625         if (!relatime_need_update(mnt, inode, now))
1626                 return true;
1627
1628         return false;
1629 }
1630
1631 void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot,
1632                 struct vvp_io_args *args)
1633 {
1634         struct inode *inode = file_inode(file);
1635         struct ll_file_data *fd  = file->private_data;
1636
1637         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
1638         io->ci_lock_no_expand = fd->ll_lock_no_expand;
1639
1640         if (iot == CIT_WRITE) {
1641                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
1642                 io->u.ci_wr.wr_sync   = !!(file->f_flags & O_SYNC ||
1643                                            file->f_flags & O_DIRECT ||
1644                                            IS_SYNC(inode));
1645 #ifdef HAVE_GENERIC_WRITE_SYNC_2ARGS
1646                 io->u.ci_wr.wr_sync  |= !!(args &&
1647                                            (args->u.normal.via_iocb->ki_flags &
1648                                             IOCB_DSYNC));
1649 #endif
1650         }
1651
1652 #ifdef IOCB_NOWAIT
1653         io->ci_iocb_nowait = !!(args &&
1654                                 (args->u.normal.via_iocb->ki_flags &
1655                                  IOCB_NOWAIT));
1656 #endif
1657
1658         io->ci_obj = ll_i2info(inode)->lli_clob;
1659         io->ci_lockreq = CILR_MAYBE;
1660         if (ll_file_nolock(file)) {
1661                 io->ci_lockreq = CILR_NEVER;
1662                 io->ci_no_srvlock = 1;
1663         } else if (file->f_flags & O_APPEND) {
1664                 io->ci_lockreq = CILR_MANDATORY;
1665         }
1666         io->ci_noatime = file_is_noatime(file);
1667         io->ci_async_readahead = false;
1668
1669         /* FLR: only use non-delay I/O for read as there is only one
1670          * avaliable mirror for write. */
1671         io->ci_ndelay = !(iot == CIT_WRITE);
1672         /* unaligned DIO has compat issues with some older servers, but we find
1673          * out if there are such servers while setting up the IO, so it starts
1674          * out allowed
1675          */
1676         io->ci_allow_unaligned_dio = true;
1677
1678         ll_io_set_mirror(io, file);
1679 }
1680
1681 static void ll_heat_add(struct inode *inode, enum cl_io_type iot,
1682                         __u64 count)
1683 {
1684         struct ll_inode_info *lli = ll_i2info(inode);
1685         struct ll_sb_info *sbi = ll_i2sbi(inode);
1686         enum obd_heat_type sample_type;
1687         enum obd_heat_type iobyte_type;
1688         __u64 now = ktime_get_real_seconds();
1689
1690         if (!ll_sbi_has_file_heat(sbi) ||
1691             lli->lli_heat_flags & LU_HEAT_FLAG_OFF)
1692                 return;
1693
1694         if (iot == CIT_READ) {
1695                 sample_type = OBD_HEAT_READSAMPLE;
1696                 iobyte_type = OBD_HEAT_READBYTE;
1697         } else if (iot == CIT_WRITE) {
1698                 sample_type = OBD_HEAT_WRITESAMPLE;
1699                 iobyte_type = OBD_HEAT_WRITEBYTE;
1700         } else {
1701                 return;
1702         }
1703
1704         spin_lock(&lli->lli_heat_lock);
1705         obd_heat_add(&lli->lli_heat_instances[sample_type], now, 1,
1706                      sbi->ll_heat_decay_weight, sbi->ll_heat_period_second);
1707         obd_heat_add(&lli->lli_heat_instances[iobyte_type], now, count,
1708                      sbi->ll_heat_decay_weight, sbi->ll_heat_period_second);
1709         spin_unlock(&lli->lli_heat_lock);
1710 }
1711
1712 static ssize_t
1713 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1714                    struct file *file, enum cl_io_type iot,
1715                    loff_t *ppos, size_t bytes)
1716 {
1717         struct vvp_io *vio = vvp_env_io(env);
1718         struct inode *inode = file_inode(file);
1719         struct ll_inode_info *lli = ll_i2info(inode);
1720         struct ll_sb_info *sbi = ll_i2sbi(inode);
1721         struct ll_file_data *fd  = file->private_data;
1722         struct range_lock range;
1723         bool range_locked = false;
1724         struct cl_io *io;
1725         ssize_t result = 0;
1726         int rc = 0;
1727         int rc2 = 0;
1728         int retries = 1000;
1729         unsigned int retried = 0, dio_lock = 0;
1730         bool is_aio = false;
1731         bool is_parallel_dio = false;
1732         struct cl_dio_aio *ci_dio_aio = NULL;
1733         size_t per_bytes, max_io_bytes;
1734         bool partial_io;
1735
1736         ENTRY;
1737
1738         CDEBUG(D_VFSTRACE, "%s: %s ppos: %llu, bytes: %zu\n",
1739                 file_dentry(file)->d_name.name,
1740                 iot == CIT_READ ? "read" : "write", *ppos, bytes);
1741
1742         max_io_bytes = min_t(size_t, PTLRPC_MAX_BRW_PAGES * OBD_MAX_RIF_DEFAULT,
1743                              sbi->ll_cache->ccc_lru_max >> 2) << PAGE_SHIFT;
1744
1745         io = vvp_env_thread_io(env);
1746         if (file->f_flags & O_DIRECT) {
1747                 if (file->f_flags & O_APPEND)
1748                         dio_lock = 1;
1749                 if (!is_sync_kiocb(args->u.normal.via_iocb))
1750                         is_aio = true;
1751
1752                 /* the kernel does not support AIO on pipes, and parallel DIO
1753                  * uses part of the AIO path, so we must not do parallel dio
1754                  * to pipes
1755                  */
1756                 is_parallel_dio = !iov_iter_is_pipe(args->u.normal.via_iter) &&
1757                                !is_aio;
1758
1759                 if (!ll_sbi_has_parallel_dio(sbi))
1760                         is_parallel_dio = false;
1761
1762                 ci_dio_aio = cl_dio_aio_alloc(args->u.normal.via_iocb,
1763                                           ll_i2info(inode)->lli_clob, is_aio);
1764                 if (!ci_dio_aio)
1765                         GOTO(out, rc = -ENOMEM);
1766         }
1767
1768 restart:
1769         /**
1770          * IO block size need be aware of cached page limit, otherwise
1771          * if we have small max_cached_mb but large block IO issued, io
1772          * could not be finished and blocked whole client.
1773          */
1774         if (file->f_flags & O_DIRECT || bytes < max_io_bytes) {
1775                 per_bytes = bytes;
1776                 partial_io = false;
1777         } else {
1778                 per_bytes = max_io_bytes;
1779                 partial_io = true;
1780         }
1781         io = vvp_env_thread_io(env);
1782         ll_io_init(io, file, iot, args);
1783         io->ci_dio_aio = ci_dio_aio;
1784         io->ci_dio_lock = dio_lock;
1785         io->ci_ndelay_tried = retried;
1786         io->ci_parallel_dio = is_parallel_dio;
1787
1788         if (cl_io_rw_init(env, io, iot, *ppos, per_bytes) == 0) {
1789                 if (file->f_flags & O_APPEND)
1790                         range_lock_init(&range, 0, LUSTRE_EOF);
1791                 else
1792                         range_lock_init(&range, *ppos, *ppos + per_bytes - 1);
1793
1794                 vio->vui_fd  = file->private_data;
1795                 vio->vui_iter = args->u.normal.via_iter;
1796                 vio->vui_iocb = args->u.normal.via_iocb;
1797                 /* Direct IO reads must also take range lock,
1798                  * or multiple reads will try to work on the same pages
1799                  * See LU-6227 for details.
1800                  */
1801                 if (((iot == CIT_WRITE) ||
1802                     (iot == CIT_READ && (file->f_flags & O_DIRECT))) &&
1803                     !(vio->vui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1804                         CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1805                                RL_PARA(&range));
1806                         rc = range_lock(&lli->lli_write_tree, &range);
1807                         if (rc < 0)
1808                                 GOTO(out, rc);
1809
1810                         range_locked = true;
1811                 }
1812
1813                 ll_cl_add(inode, env, io, LCC_RW);
1814                 rc = cl_io_loop(env, io);
1815                 ll_cl_remove(inode, env);
1816         } else {
1817                 /* cl_io_rw_init() handled IO */
1818                 rc = io->ci_result;
1819         }
1820
1821         if (io->ci_dio_aio && !is_aio) {
1822                 struct cl_sync_io *anchor = &io->ci_dio_aio->cda_sync;
1823
1824                 /* for dio, EIOCBQUEUED is an implementation detail,
1825                  * and we don't return it to userspace
1826                  */
1827                 if (rc == -EIOCBQUEUED)
1828                         rc = 0;
1829
1830                 /* N/B: parallel DIO may be disabled during i/o submission;
1831                  * if that occurs, I/O shifts to sync, so it's all resolved
1832                  * before we get here, and this wait call completes
1833                  * immediately.
1834                  */
1835                 rc2 = cl_sync_io_wait_recycle(env, anchor, 0, 0);
1836                 if (rc2 < 0)
1837                         rc = rc2;
1838         }
1839
1840         if (range_locked) {
1841                 CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1842                        RL_PARA(&range));
1843                 range_unlock(&lli->lli_write_tree, &range);
1844                         range_locked = false;
1845         }
1846
1847         if (io->ci_bytes > 0) {
1848                 if (rc2 == 0) {
1849                         result += io->ci_bytes;
1850                         *ppos = io->u.ci_wr.wr.crw_pos; /* for splice */
1851                 } else if (rc2) {
1852                         result = 0;
1853                 }
1854                 bytes -= io->ci_bytes;
1855
1856                 /* prepare IO restart */
1857                 if (bytes > 0)
1858                         args->u.normal.via_iter = vio->vui_iter;
1859
1860                 if (partial_io) {
1861                         /**
1862                          * Reexpand iov count because it was zero
1863                          * after IO finish.
1864                          */
1865                         iov_iter_reexpand(vio->vui_iter, bytes);
1866                         if (per_bytes == io->ci_bytes)
1867                                 io->ci_need_restart = 1;
1868                 }
1869         }
1870 out:
1871         cl_io_fini(env, io);
1872
1873         CDEBUG(D_VFSTRACE,
1874                "%s: %d io complete with rc: %d, result: %zd, restart: %d\n",
1875                file->f_path.dentry->d_name.name,
1876                iot, rc, result, io->ci_need_restart);
1877
1878         if ((!rc || rc == -ENODATA || rc == -ENOLCK || rc == -EIOCBQUEUED) &&
1879             bytes > 0 && io->ci_need_restart && retries-- > 0) {
1880                 CDEBUG(D_VFSTRACE,
1881                        "%s: restart %s from ppos=%lld bytes=%zu retries=%u ret=%zd: rc = %d\n",
1882                        file_dentry(file)->d_name.name,
1883                        iot == CIT_READ ? "read" : "write",
1884                        *ppos, bytes, retries, result, rc);
1885                 /* preserve the tried count for FLR */
1886                 retried = io->ci_ndelay_tried;
1887                 dio_lock = io->ci_dio_lock;
1888                 goto restart;
1889         }
1890
1891         if (io->ci_dio_aio) {
1892                 /* set the number of bytes successfully moved in the aio */
1893                 if (result > 0)
1894                         io->ci_dio_aio->cda_bytes = result;
1895                 /*
1896                  * VFS will call aio_complete() if no -EIOCBQUEUED
1897                  * is returned for AIO, so we can not call aio_complete()
1898                  * in our end_io().  (cda_no_aio_complete is always set for
1899                  * normal DIO.)
1900                  *
1901                  * NB: Setting cda_no_aio_complete like this is safe because
1902                  * the atomic_dec_and_lock in cl_sync_io_note has implicit
1903                  * memory barriers, so this will be seen by whichever thread
1904                  * completes the DIO/AIO, even if it's not this one.
1905                  */
1906                 if (is_aio && rc != -EIOCBQUEUED)
1907                         io->ci_dio_aio->cda_no_aio_complete = 1;
1908                 /* if an aio enqueued successfully (-EIOCBQUEUED), then Lustre
1909                  * will call aio_complete rather than the vfs, so we return 0
1910                  * to tell the VFS we're handling it
1911                  */
1912                 else if (is_aio) /* rc == -EIOCBQUEUED */
1913                         result = 0;
1914                 /**
1915                  * Drop the reference held by the llite layer on this top level
1916                  * IO context.
1917                  *
1918                  * For DIO, this frees it here, since IO is complete, and for
1919                  * AIO, we will call aio_complete() (and then free this top
1920                  * level context) once all the outstanding chunks of this AIO
1921                  * have completed.
1922                  */
1923                 cl_sync_io_note(env, &io->ci_dio_aio->cda_sync,
1924                                 rc == -EIOCBQUEUED ? 0 : rc);
1925                 if (!is_aio) {
1926                         LASSERT(io->ci_dio_aio->cda_creator_free);
1927                         cl_dio_aio_free(env, io->ci_dio_aio);
1928                         io->ci_dio_aio = NULL;
1929                 }
1930         }
1931
1932         if (iot == CIT_READ) {
1933                 if (result > 0)
1934                         ll_stats_ops_tally(ll_i2sbi(inode),
1935                                            LPROC_LL_READ_BYTES, result);
1936         } else if (iot == CIT_WRITE) {
1937                 if (result > 0) {
1938                         ll_stats_ops_tally(ll_i2sbi(inode),
1939                                            LPROC_LL_WRITE_BYTES, result);
1940                         fd->fd_write_failed = false;
1941                 } else if (result == 0 && rc == 0) {
1942                         rc = io->ci_result;
1943                         if (rc < 0)
1944                                 fd->fd_write_failed = true;
1945                         else
1946                                 fd->fd_write_failed = false;
1947                 } else if (rc != -ERESTARTSYS) {
1948                         fd->fd_write_failed = true;
1949                 }
1950         }
1951
1952         CDEBUG(D_VFSTRACE, "iot: %d, result: %zd\n", iot, result);
1953         if (result > 0)
1954                 ll_heat_add(inode, iot, result);
1955
1956         RETURN(result > 0 ? result : rc);
1957 }
1958
1959 /**
1960  * The purpose of fast read is to overcome per I/O overhead and improve IOPS
1961  * especially for small I/O.
1962  *
1963  * To serve a read request, CLIO has to create and initialize a cl_io and
1964  * then request DLM lock. This has turned out to have siginificant overhead
1965  * and affects the performance of small I/O dramatically.
1966  *
1967  * It's not necessary to create a cl_io for each I/O. Under the help of read
1968  * ahead, most of the pages being read are already in memory cache and we can
1969  * read those pages directly because if the pages exist, the corresponding DLM
1970  * lock must exist so that page content must be valid.
1971  *
1972  * In fast read implementation, the llite speculatively finds and reads pages
1973  * in memory cache. There are three scenarios for fast read:
1974  *   - If the page exists and is uptodate, kernel VM will provide the data and
1975  *     CLIO won't be intervened;
1976  *   - If the page was brought into memory by read ahead, it will be exported
1977  *     and read ahead parameters will be updated;
1978  *   - Otherwise the page is not in memory, we can't do fast read. Therefore,
1979  *     it will go back and invoke normal read, i.e., a cl_io will be created
1980  *     and DLM lock will be requested.
1981  *
1982  * POSIX compliance: posix standard states that read is intended to be atomic.
1983  * Lustre read implementation is in line with Linux kernel read implementation
1984  * and neither of them complies with POSIX standard in this matter. Fast read
1985  * doesn't make the situation worse on single node but it may interleave write
1986  * results from multiple nodes due to short read handling in ll_file_aio_read().
1987  *
1988  * \param env - lu_env
1989  * \param iocb - kiocb from kernel
1990  * \param iter - user space buffers where the data will be copied
1991  *
1992  * \retval - number of bytes have been read, or error code if error occurred.
1993  */
1994 static ssize_t
1995 ll_do_fast_read(struct kiocb *iocb, struct iov_iter *iter)
1996 {
1997         struct ll_inode_info *lli = ll_i2info(file_inode(iocb->ki_filp));
1998         ssize_t result;
1999
2000         if (!ll_sbi_has_fast_read(ll_i2sbi(file_inode(iocb->ki_filp))))
2001                 return 0;
2002
2003         /* NB: we can't do direct IO for fast read because it will need a lock
2004          * to make IO engine happy. */
2005         if (iocb->ki_filp->f_flags & O_DIRECT)
2006                 return 0;
2007
2008         if (ll_layout_version_get(lli) == CL_LAYOUT_GEN_NONE)
2009                 return 0;
2010
2011         result = generic_file_read_iter(iocb, iter);
2012
2013         /* If the first page is not in cache, generic_file_aio_read() will be
2014          * returned with -ENODATA.  Fall back to full read path.
2015          * See corresponding code in ll_readpage().
2016          *
2017          * if we raced with page deletion, we might get EIO.  Rather than add
2018          * locking to the fast path for this rare case, fall back to the full
2019          * read path.  (See vvp_io_read_start() for rest of handling.
2020          */
2021         if (result == -ENODATA || result == -EIO)
2022                 result = 0;
2023
2024         if (result > 0) {
2025                 ll_heat_add(file_inode(iocb->ki_filp), CIT_READ, result);
2026                 ll_stats_ops_tally(ll_i2sbi(file_inode(iocb->ki_filp)),
2027                                    LPROC_LL_READ_BYTES, result);
2028         }
2029
2030         return result;
2031 }
2032
2033 /**
2034  * Confine read iter lest read beyond the EOF
2035  *
2036  * \param iocb [in]     kernel iocb
2037  * \param to [in]       reader iov_iter
2038  *
2039  * \retval <0   failure
2040  * \retval 0    success
2041  * \retval >0   @iocb->ki_pos has passed the EOF
2042  */
2043 static int file_read_confine_iter(struct lu_env *env, struct kiocb *iocb,
2044                                   struct iov_iter *to)
2045 {
2046         struct cl_io *io;
2047         struct cl_attr *attr = vvp_env_thread_attr(env);
2048         struct file *file = iocb->ki_filp;
2049         struct inode *inode = file_inode(file);
2050         struct ll_inode_info *lli = ll_i2info(inode);
2051         struct cl_object *obj = lli->lli_clob;
2052         loff_t read_end = iocb->ki_pos + iov_iter_count(to);
2053         loff_t kms;
2054         loff_t size;
2055         int rc = 0;
2056
2057         ENTRY;
2058
2059         if (!obj)
2060                 RETURN(rc);
2061
2062         io = vvp_env_thread_io(env);
2063         io->ci_obj = obj;
2064         rc = cl_io_init(env, io, CIT_MISC, obj);
2065         if (rc < 0)
2066                 GOTO(fini_io, rc);
2067
2068         cl_object_attr_lock(lli->lli_clob);
2069         rc = cl_object_attr_get(env, lli->lli_clob, attr);
2070         cl_object_attr_unlock(lli->lli_clob);
2071
2072 fini_io:
2073         cl_io_fini(env, io);
2074         if (rc < 0)
2075                 RETURN(rc);
2076
2077         kms = attr->cat_kms;
2078         /* if read beyond end-of-file, adjust read count */
2079         if (kms > 0 && (iocb->ki_pos >= kms || read_end > kms)) {
2080                 rc = ll_glimpse_size(inode);
2081                 if (rc != 0)
2082                         return rc;
2083
2084                 size = i_size_read(inode);
2085                 if (iocb->ki_pos >= size || read_end > size) {
2086                         CDEBUG(D_VFSTRACE,
2087                                "%s: read [%llu, %llu] over eof, kms %llu, file_size %llu.\n",
2088                                file_dentry(file)->d_name.name,
2089                                iocb->ki_pos, read_end, kms, size);
2090
2091                         if (iocb->ki_pos >= size)
2092                                 RETURN(1);
2093
2094                         if (read_end > size)
2095                                 iov_iter_truncate(to, size - iocb->ki_pos);
2096                 }
2097         }
2098
2099         RETURN(rc);
2100 }
2101
2102 /*
2103  * Read from a file (through the page cache).
2104  */
2105 static ssize_t ll_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
2106 {
2107         struct lu_env *env;
2108         struct vvp_io_args *args;
2109         struct file *file = iocb->ki_filp;
2110         ssize_t result;
2111         ssize_t rc2;
2112         __u16 refcheck;
2113         ktime_t kstart = ktime_get();
2114         bool cached;
2115         bool stale_data = false;
2116
2117         ENTRY;
2118
2119         CDEBUG(D_VFSTRACE|D_IOTRACE,
2120                "START file %s:"DFID", ppos: %lld, count: %zu\n",
2121                file_dentry(file)->d_name.name,
2122                PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
2123                iov_iter_count(to));
2124
2125         if (!iov_iter_count(to))
2126                 RETURN(0);
2127
2128         env = cl_env_get(&refcheck);
2129         if (IS_ERR(env))
2130                 RETURN(PTR_ERR(env));
2131
2132         result = file_read_confine_iter(env, iocb, to);
2133         if (result < 0)
2134                 GOTO(out, result);
2135         else if (result > 0)
2136                 stale_data = true;
2137
2138         /**
2139          * Currently when PCC read failed, we do not fall back to the
2140          * normal read path, just return the error.
2141          * The resaon is that: for RW-PCC, the file data may be modified
2142          * in the PCC and inconsistent with the data on OSTs (or file
2143          * data has been removed from the Lustre file system), at this
2144          * time, fallback to the normal read path may read the wrong
2145          * data.
2146          * TODO: for RO-PCC (readonly PCC), fall back to normal read
2147          * path: read data from data copy on OSTs.
2148          */
2149         result = pcc_file_read_iter(iocb, to, &cached);
2150         if (cached)
2151                 GOTO(out, result);
2152
2153         ll_ras_enter(file, iocb->ki_pos, iov_iter_count(to));
2154
2155         result = ll_do_fast_read(iocb, to);
2156         if (result < 0 || iov_iter_count(to) == 0)
2157                 GOTO(out, result);
2158
2159         args = ll_env_args(env);
2160         args->u.normal.via_iter = to;
2161         args->u.normal.via_iocb = iocb;
2162
2163         rc2 = ll_file_io_generic(env, args, file, CIT_READ,
2164                                  &iocb->ki_pos, iov_iter_count(to));
2165         if (rc2 > 0)
2166                 result += rc2;
2167         else if (result == 0)
2168                 result = rc2;
2169
2170 out:
2171         cl_env_put(env, &refcheck);
2172
2173         if (stale_data && result > 0) {
2174                 /**
2175                  * we've reached EOF before the read, the data read are cached
2176                  * stale data.
2177                  */
2178                 iov_iter_truncate(to, 0);
2179                 result = 0;
2180         }
2181
2182         if (result > 0) {
2183                 ll_rw_stats_tally(ll_i2sbi(file_inode(file)), current->pid,
2184                                   file->private_data, iocb->ki_pos, result,
2185                                   READ);
2186                 ll_stats_ops_tally(ll_i2sbi(file_inode(file)), LPROC_LL_READ,
2187                                    ktime_us_delta(ktime_get(), kstart));
2188         }
2189
2190         CDEBUG(D_IOTRACE,
2191                "COMPLETED: file %s:"DFID", ppos: %lld, count: %zu\n",
2192                file_dentry(file)->d_name.name,
2193                PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
2194                iov_iter_count(to));
2195
2196         RETURN(result);
2197 }
2198
2199 /**
2200  * Similar trick to ll_do_fast_read, this improves write speed for tiny writes.
2201  * If a page is already in the page cache and dirty (and some other things -
2202  * See ll_tiny_write_begin for the instantiation of these rules), then we can
2203  * write to it without doing a full I/O, because Lustre already knows about it
2204  * and will write it out.  This saves a lot of processing time.
2205  *
2206  * All writes here are within one page, so exclusion is handled by the page
2207  * lock on the vm page.  We do not do tiny writes for writes which touch
2208  * multiple pages because it's very unlikely multiple sequential pages are
2209  * are already dirty.
2210  *
2211  * We limit these to < PAGE_SIZE because PAGE_SIZE writes are relatively common
2212  * and are unlikely to be to already dirty pages.
2213  *
2214  * Attribute updates are important here, we do them in ll_tiny_write_end.
2215  */
2216 static ssize_t ll_do_tiny_write(struct kiocb *iocb, struct iov_iter *iter)
2217 {
2218         ssize_t count = iov_iter_count(iter);
2219         struct  file *file = iocb->ki_filp;
2220         struct  inode *inode = file_inode(file);
2221         bool    lock_inode = !IS_NOSEC(inode);
2222         ssize_t result = 0;
2223
2224         ENTRY;
2225
2226         /* Restrict writes to single page and < PAGE_SIZE.  See comment at top
2227          * of function for why.
2228          */
2229         if (count >= PAGE_SIZE ||
2230             (iocb->ki_pos & (PAGE_SIZE-1)) + count > PAGE_SIZE)
2231                 RETURN(0);
2232
2233         if (unlikely(lock_inode))
2234                 ll_inode_lock(inode);
2235         result = __generic_file_write_iter(iocb, iter);
2236
2237         if (unlikely(lock_inode))
2238                 ll_inode_unlock(inode);
2239
2240         /* If the page is not already dirty, ll_tiny_write_begin returns
2241          * -ENODATA.  We continue on to normal write.
2242          */
2243         if (result == -ENODATA)
2244                 result = 0;
2245
2246         if (result > 0) {
2247                 ll_heat_add(inode, CIT_WRITE, result);
2248                 set_bit(LLIF_DATA_MODIFIED, &ll_i2info(inode)->lli_flags);
2249         }
2250
2251         CDEBUG(D_VFSTRACE, "result: %zu, original count %zu\n", result, count);
2252
2253         RETURN(result);
2254 }
2255
2256 /*
2257  * Write to a file (through the page cache).
2258  */
2259 static ssize_t ll_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2260 {
2261         struct vvp_io_args *args;
2262         struct lu_env *env;
2263         ssize_t rc_tiny = 0, rc_normal;
2264         struct file *file = iocb->ki_filp;
2265         __u16 refcheck;
2266         bool cached;
2267         ktime_t kstart = ktime_get();
2268         int result;
2269
2270         ENTRY;
2271
2272         CDEBUG(D_VFSTRACE|D_IOTRACE,
2273                "START file %s:"DFID", ppos: %lld, count: %zu\n",
2274                file_dentry(file)->d_name.name,
2275                PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
2276                iov_iter_count(from));
2277
2278         if (!iov_iter_count(from))
2279                 GOTO(out, rc_normal = 0);
2280
2281         /**
2282          * When PCC write failed, we usually do not fall back to the normal
2283          * write path, just return the error. But there is a special case when
2284          * returned error code is -ENOSPC due to running out of space on PCC HSM
2285          * bakcend. At this time, it will fall back to normal I/O path and
2286          * retry the I/O. As the file is in HSM released state, it will restore
2287          * the file data to OSTs first and redo the write again. And the
2288          * restore process will revoke the layout lock and detach the file
2289          * from PCC cache automatically.
2290          */
2291         result = pcc_file_write_iter(iocb, from, &cached);
2292         if (cached && result != -ENOSPC && result != -EDQUOT)
2293                 GOTO(out, rc_normal = result);
2294
2295         /* NB: we can't do direct IO for tiny writes because they use the page
2296          * cache, we can't do sync writes because tiny writes can't flush
2297          * pages, and we can't do append writes because we can't guarantee the
2298          * required DLM locks are held to protect file size.
2299          */
2300         if (ll_sbi_has_tiny_write(ll_i2sbi(file_inode(file))) &&
2301             !(file->f_flags & (O_DIRECT | O_SYNC | O_APPEND)))
2302                 rc_tiny = ll_do_tiny_write(iocb, from);
2303
2304         /* In case of error, go on and try normal write - Only stop if tiny
2305          * write completed I/O.
2306          */
2307         if (iov_iter_count(from) == 0)
2308                 GOTO(out, rc_normal = rc_tiny);
2309
2310         env = cl_env_get(&refcheck);
2311         if (IS_ERR(env))
2312                 RETURN(PTR_ERR(env));
2313
2314         args = ll_env_args(env);
2315         args->u.normal.via_iter = from;
2316         args->u.normal.via_iocb = iocb;
2317
2318         rc_normal = ll_file_io_generic(env, args, file, CIT_WRITE,
2319                                        &iocb->ki_pos, iov_iter_count(from));
2320
2321         /* On success, combine bytes written. */
2322         if (rc_tiny >= 0 && rc_normal > 0)
2323                 rc_normal += rc_tiny;
2324         /* On error, only return error from normal write if tiny write did not
2325          * write any bytes.  Otherwise return bytes written by tiny write.
2326          */
2327         else if (rc_tiny > 0)
2328                 rc_normal = rc_tiny;
2329
2330         cl_env_put(env, &refcheck);
2331 out:
2332         if (rc_normal > 0) {
2333                 ll_rw_stats_tally(ll_i2sbi(file_inode(file)), current->pid,
2334                                   file->private_data, iocb->ki_pos,
2335                                   rc_normal, WRITE);
2336                 ll_stats_ops_tally(ll_i2sbi(file_inode(file)), LPROC_LL_WRITE,
2337                                    ktime_us_delta(ktime_get(), kstart));
2338         }
2339
2340         CDEBUG(D_IOTRACE,
2341                "COMPLETED: file %s:"DFID", ppos: %lld, count: %zu\n",
2342                file_dentry(file)->d_name.name,
2343                PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
2344                iov_iter_count(from));
2345
2346         RETURN(rc_normal);
2347 }
2348
2349 #ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
2350 /*
2351  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
2352  */
2353 static int ll_file_get_iov_count(const struct iovec *iov,
2354                                  unsigned long *nr_segs, size_t *count,
2355                                  int access_flags)
2356 {
2357         size_t cnt = 0;
2358         unsigned long seg;
2359
2360         for (seg = 0; seg < *nr_segs; seg++) {
2361                 const struct iovec *iv = &iov[seg];
2362
2363                 /*
2364                  * If any segment has a negative length, or the cumulative
2365                  * length ever wraps negative then return -EINVAL.
2366                  */
2367                 cnt += iv->iov_len;
2368                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
2369                         return -EINVAL;
2370                 if (access_ok(access_flags, iv->iov_base, iv->iov_len))
2371                         continue;
2372                 if (seg == 0)
2373                         return -EFAULT;
2374                 *nr_segs = seg;
2375                 cnt -= iv->iov_len;     /* This segment is no good */
2376                 break;
2377         }
2378         *count = cnt;
2379         return 0;
2380 }
2381
2382 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
2383                                 unsigned long nr_segs, loff_t pos)
2384 {
2385         struct iov_iter to;
2386         size_t iov_count;
2387         ssize_t result;
2388         ENTRY;
2389
2390         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count, VERIFY_READ);
2391         if (result)
2392                 RETURN(result);
2393
2394         if (!iov_count)
2395                 RETURN(0);
2396
2397 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
2398         iov_iter_init(&to, READ, iov, nr_segs, iov_count);
2399 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
2400         iov_iter_init(&to, iov, nr_segs, iov_count, 0);
2401 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
2402
2403         result = ll_file_read_iter(iocb, &to);
2404
2405         RETURN(result);
2406 }
2407
2408 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
2409                             loff_t *ppos)
2410 {
2411         struct iovec   iov = { .iov_base = buf, .iov_len = count };
2412         struct kiocb   kiocb;
2413         ssize_t        result;
2414
2415         ENTRY;
2416
2417         if (!count)
2418                 RETURN(0);
2419
2420         init_sync_kiocb(&kiocb, file);
2421         kiocb.ki_pos = *ppos;
2422 #ifdef HAVE_KIOCB_KI_LEFT
2423         kiocb.ki_left = count;
2424 #elif defined(HAVE_KI_NBYTES)
2425         kiocb.i_nbytes = count;
2426 #endif
2427
2428         result = ll_file_aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
2429         *ppos = kiocb.ki_pos;
2430
2431         RETURN(result);
2432 }
2433
2434 /*
2435  * Write to a file (through the page cache).
2436  * AIO stuff
2437  */
2438 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
2439                                  unsigned long nr_segs, loff_t pos)
2440 {
2441         struct iov_iter from;
2442         size_t iov_count;
2443         ssize_t result;
2444         ENTRY;
2445
2446         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count, VERIFY_WRITE);
2447         if (result)
2448                 RETURN(result);
2449
2450         if (!iov_count)
2451                 RETURN(0);
2452
2453 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
2454         iov_iter_init(&from, WRITE, iov, nr_segs, iov_count);
2455 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
2456         iov_iter_init(&from, iov, nr_segs, iov_count, 0);
2457 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
2458
2459         result = ll_file_write_iter(iocb, &from);
2460
2461         RETURN(result);
2462 }
2463
2464 static ssize_t ll_file_write(struct file *file, const char __user *buf,
2465                              size_t count, loff_t *ppos)
2466 {
2467         struct iovec   iov = { .iov_base = (void __user *)buf,
2468                                .iov_len = count };
2469         struct kiocb   kiocb;
2470         ssize_t        result;
2471
2472         ENTRY;
2473
2474         if (!count)
2475                 RETURN(0);
2476
2477         init_sync_kiocb(&kiocb, file);
2478         kiocb.ki_pos = *ppos;
2479 #ifdef HAVE_KIOCB_KI_LEFT
2480         kiocb.ki_left = count;
2481 #elif defined(HAVE_KI_NBYTES)
2482         kiocb.ki_nbytes = count;
2483 #endif
2484
2485         result = ll_file_aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
2486         *ppos = kiocb.ki_pos;
2487
2488         RETURN(result);
2489 }
2490 #endif /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
2491
2492 int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
2493                              __u64 flags, struct lov_user_md *lum, int lum_size)
2494 {
2495         struct lookup_intent oit = {
2496                 .it_op = IT_OPEN,
2497                 .it_flags = flags | MDS_OPEN_BY_FID,
2498         };
2499         int rc;
2500         ENTRY;
2501
2502         if ((__swab32(lum->lmm_magic) & le32_to_cpu(LOV_MAGIC_MASK)) ==
2503             le32_to_cpu(LOV_MAGIC_MAGIC)) {
2504                 /* this code will only exist for big-endian systems */
2505                 lustre_swab_lov_user_md(lum, 0);
2506         }
2507
2508         ll_inode_size_lock(inode);
2509         rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
2510         if (rc < 0)
2511                 GOTO(out_unlock, rc);
2512
2513         ll_release_openhandle(dentry, &oit);
2514
2515 out_unlock:
2516         ll_inode_size_unlock(inode);
2517         ll_intent_release(&oit);
2518
2519         RETURN(rc);
2520 }
2521
2522 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
2523                              struct lov_mds_md **lmmp, int *lmm_size,
2524                              struct ptlrpc_request **request)
2525 {
2526         struct ll_sb_info *sbi = ll_i2sbi(inode);
2527         struct mdt_body  *body;
2528         struct lov_mds_md *lmm = NULL;
2529         struct ptlrpc_request *req = NULL;
2530         struct md_op_data *op_data;
2531         int rc, lmmsize;
2532
2533         ENTRY;
2534
2535         rc = ll_get_default_mdsize(sbi, &lmmsize);
2536         if (rc)
2537                 RETURN(rc);
2538
2539         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
2540                                      strlen(filename), lmmsize,
2541                                      LUSTRE_OPC_ANY, NULL);
2542         if (IS_ERR(op_data))
2543                 RETURN(PTR_ERR(op_data));
2544
2545         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
2546         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
2547         ll_finish_md_op_data(op_data);
2548         if (rc < 0) {
2549                 CDEBUG(D_INFO, "md_getattr_name failed on %s: rc %d\n",
2550                        filename, rc);
2551                 GOTO(out, rc);
2552         }
2553
2554         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2555         LASSERT(body != NULL); /* checked by mdc_getattr_name */
2556
2557         lmmsize = body->mbo_eadatasize;
2558
2559         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
2560             lmmsize == 0)
2561                 GOTO(out, rc = -ENODATA);
2562
2563         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
2564         LASSERT(lmm != NULL);
2565
2566         if (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1) &&
2567             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3) &&
2568             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_COMP_V1) &&
2569             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_FOREIGN))
2570                 GOTO(out, rc = -EPROTO);
2571
2572         /*
2573          * This is coming from the MDS, so is probably in
2574          * little endian. We convert it to host endian before
2575          * passing it to userspace.
2576          */
2577         if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC) {
2578                 int stripe_count = 0;
2579
2580                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
2581                     lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
2582                         stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
2583                         if (le32_to_cpu(lmm->lmm_pattern) &
2584                             LOV_PATTERN_F_RELEASED)
2585                                 stripe_count = 0;
2586                         lustre_swab_lov_user_md((struct lov_user_md *)lmm, 0);
2587
2588                         /* if function called for directory - we should
2589                          * avoid swab not existent lsm objects
2590                          */
2591                         if (lmm->lmm_magic == LOV_MAGIC_V1 &&
2592                             S_ISREG(body->mbo_mode))
2593                                 lustre_swab_lov_user_md_objects(
2594                                 ((struct lov_user_md_v1 *)lmm)->lmm_objects,
2595                                 stripe_count);
2596                         else if (lmm->lmm_magic == LOV_MAGIC_V3 &&
2597                                  S_ISREG(body->mbo_mode))
2598                                 lustre_swab_lov_user_md_objects(
2599                                 ((struct lov_user_md_v3 *)lmm)->lmm_objects,
2600                                 stripe_count);
2601                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_COMP_V1)) {
2602                         lustre_swab_lov_comp_md_v1(
2603                                 (struct lov_comp_md_v1 *)lmm);
2604                 }
2605         }
2606
2607         if (lmm->lmm_magic == LOV_MAGIC_COMP_V1) {
2608                 struct lov_comp_md_v1 *comp_v1 = NULL;
2609                 struct lov_comp_md_entry_v1 *ent;
2610                 struct lov_user_md_v1 *v1 = NULL;
2611                 __u32 off;
2612                 int i = 0;
2613
2614                 comp_v1 = (struct lov_comp_md_v1 *)lmm;
2615                 /* Dump the striping information */
2616                 for (; i < comp_v1->lcm_entry_count; i++) {
2617                         ent = &comp_v1->lcm_entries[i];
2618                         off = ent->lcme_offset;
2619                         v1 = (struct lov_user_md_v1 *)((char *)lmm + off);
2620                         CDEBUG(D_INFO,
2621                                "comp[%d]: stripe_count=%u, stripe_size=%u\n",
2622                                i, v1->lmm_stripe_count, v1->lmm_stripe_size);
2623
2624                         if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_LOV_COMP_MAGIC) &&
2625                                      (cfs_fail_val == i + 1)))
2626                                 v1->lmm_magic = LOV_MAGIC_BAD;
2627
2628                         if (unlikely(CFS_FAIL_CHECK(OBD_FAIL_LOV_COMP_PATTERN) &&
2629                                      (cfs_fail_val == i + 1)))
2630                                 v1->lmm_pattern = LOV_PATTERN_BAD;
2631                 }
2632
2633                 if (v1 == NULL)
2634                         GOTO(out, rc = -EINVAL);
2635
2636                 lmm->lmm_stripe_count = v1->lmm_stripe_count;
2637                 lmm->lmm_stripe_size = v1->lmm_stripe_size;
2638                 /**
2639                  * Return valid stripe_count and stripe_size instead of 0 for
2640                  * DoM files to avoid divide-by-zero for older userspace that
2641                  * calls this ioctl, e.g. lustre ADIO driver.
2642                  */
2643                 if (lmm->lmm_stripe_count == 0)
2644                         lmm->lmm_stripe_count = 1;
2645                 if (lmm->lmm_stripe_size == 0) {
2646                         /* Since the first component of the file data is placed
2647                          * on the MDT for faster access, the stripe_size of the
2648                          * second one is always that applications which are
2649                          * doing large IOs.
2650                          */
2651                         if (lmm->lmm_pattern & LOV_PATTERN_MDT)
2652                                 i = comp_v1->lcm_entry_count > 1 ? 1 : 0;
2653                         else
2654                                 i = comp_v1->lcm_entry_count > 1 ?
2655                                     comp_v1->lcm_entry_count - 1 : 0;
2656                         ent = &comp_v1->lcm_entries[i];
2657                         off = ent->lcme_offset;
2658                         v1 = (struct lov_user_md_v1 *)((char *)lmm + off);
2659                         lmm->lmm_stripe_size = v1->lmm_stripe_size;
2660                 }
2661         }
2662 out:
2663         *lmmp = lmm;
2664         *lmm_size = lmmsize;
2665         *request = req;
2666         RETURN(rc);
2667 }
2668
2669 static int ll_lov_setea(struct inode *inode, struct file *file,
2670                         void __user *arg)
2671 {
2672         __u64 flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
2673         struct lov_user_md *lump;
2674         int lum_size = sizeof(*lump) + sizeof(struct lov_user_ost_data);
2675         int rc;
2676         ENTRY;
2677
2678         if (!capable(CAP_SYS_ADMIN))
2679                 RETURN(-EPERM);
2680
2681         OBD_ALLOC_LARGE(lump, lum_size);
2682         if (lump == NULL)
2683                 RETURN(-ENOMEM);
2684
2685         if (copy_from_user(lump, arg, lum_size))
2686                 GOTO(out_lump, rc = -EFAULT);
2687
2688         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, lump,
2689                                       lum_size);
2690         cl_lov_delay_create_clear(&file->f_flags);
2691
2692 out_lump:
2693         OBD_FREE_LARGE(lump, lum_size);
2694         RETURN(rc);
2695 }
2696
2697 static int ll_file_getstripe(struct inode *inode, void __user *lum, size_t size)
2698 {
2699         struct lu_env *env;
2700         __u16 refcheck;
2701         int rc;
2702         ENTRY;
2703
2704         /* exit before doing any work if pointer is bad */
2705         if (unlikely(!ll_access_ok(lum, sizeof(struct lov_user_md))))
2706                 RETURN(-EFAULT);
2707
2708         env = cl_env_get(&refcheck);
2709         if (IS_ERR(env))
2710                 RETURN(PTR_ERR(env));
2711
2712         rc = cl_object_getstripe(env, ll_i2info(inode)->lli_clob, lum, size);
2713         cl_env_put(env, &refcheck);
2714         RETURN(rc);
2715 }
2716
2717 static int ll_lov_setstripe(struct inode *inode, struct file *file,
2718                             void __user *arg)
2719 {
2720         struct lov_user_md __user *lum = arg;
2721         struct lov_user_md *klum;
2722         int lum_size, rc;
2723         __u64 flags = FMODE_WRITE;
2724         ENTRY;
2725
2726         rc = ll_copy_user_md(lum, &klum);
2727         if (rc < 0)
2728                 RETURN(rc);
2729
2730         lum_size = rc;
2731         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, klum,
2732                                       lum_size);
2733         if (!rc) {
2734                 __u32 gen;
2735
2736                 rc = put_user(0, &lum->lmm_stripe_count);
2737                 if (rc)
2738                         GOTO(out, rc);
2739
2740                 rc = ll_layout_refresh(inode, &gen);
2741                 if (rc)
2742                         GOTO(out, rc);
2743
2744                 rc = ll_file_getstripe(inode, arg, lum_size);
2745                 if (S_ISREG(inode->i_mode) && IS_ENCRYPTED(inode) &&
2746                     ll_i2info(inode)->lli_clob) {
2747                         struct iattr attr = { 0 };
2748
2749                         rc = cl_setattr_ost(ll_i2info(inode)->lli_clob, &attr,
2750                                             OP_XVALID_FLAGS, LUSTRE_ENCRYPT_FL);
2751                 }
2752         }
2753         cl_lov_delay_create_clear(&file->f_flags);
2754
2755 out:
2756         OBD_FREE_LARGE(klum, lum_size);
2757         RETURN(rc);
2758 }
2759
2760
2761 static int
2762 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
2763 {
2764         struct ll_inode_info *lli = ll_i2info(inode);
2765         struct cl_object *obj = lli->lli_clob;
2766         struct ll_file_data *fd = file->private_data;
2767         struct ll_grouplock grouplock;
2768         int rc;
2769         ENTRY;
2770
2771         if (arg == 0) {
2772                 CWARN("group id for group lock must not be 0\n");
2773                 RETURN(-EINVAL);
2774         }
2775
2776         if (ll_file_nolock(file))
2777                 RETURN(-EOPNOTSUPP);
2778 retry:
2779         if (file->f_flags & O_NONBLOCK) {
2780                 if (!mutex_trylock(&lli->lli_group_mutex))
2781                         RETURN(-EAGAIN);
2782         } else {
2783                 mutex_lock(&lli->lli_group_mutex);
2784         }
2785
2786         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
2787                 CWARN("group lock already existed with gid %lu\n",
2788                       fd->fd_grouplock.lg_gid);
2789                 GOTO(out, rc = -EINVAL);
2790         }
2791         if (arg != lli->lli_group_gid && lli->lli_group_users != 0) {
2792                 if (file->f_flags & O_NONBLOCK)
2793                         GOTO(out, rc = -EAGAIN);
2794                 mutex_unlock(&lli->lli_group_mutex);
2795                 wait_var_event(&lli->lli_group_users, !lli->lli_group_users);
2796                 GOTO(retry, rc = 0);
2797         }
2798         LASSERT(fd->fd_grouplock.lg_lock == NULL);
2799
2800         /**
2801          * XXX: group lock needs to protect all OST objects while PFL
2802          * can add new OST objects during the IO, so we'd instantiate
2803          * all OST objects before getting its group lock.
2804          */
2805         if (obj) {
2806                 struct lu_env *env;
2807                 __u16 refcheck;
2808                 struct cl_layout cl = {
2809                         .cl_is_composite = false,
2810                 };
2811                 struct lu_extent ext = {
2812                         .e_start = 0,
2813                         .e_end = OBD_OBJECT_EOF,
2814                 };
2815
2816                 env = cl_env_get(&refcheck);
2817                 if (IS_ERR(env))
2818                         GOTO(out, rc = PTR_ERR(env));
2819
2820                 rc = cl_object_layout_get(env, obj, &cl);
2821                 if (rc >= 0 && cl.cl_is_composite)
2822                         rc = ll_layout_write_intent(inode, LAYOUT_INTENT_WRITE,
2823                                                     &ext);
2824
2825                 cl_env_put(env, &refcheck);
2826                 if (rc < 0)
2827                         GOTO(out, rc);
2828         }
2829
2830         rc = cl_get_grouplock(ll_i2info(inode)->lli_clob,
2831                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
2832
2833         if (rc)
2834                 GOTO(out, rc);
2835
2836         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
2837         fd->fd_grouplock = grouplock;
2838         if (lli->lli_group_users == 0)
2839                 lli->lli_group_gid = grouplock.lg_gid;
2840         lli->lli_group_users++;
2841
2842         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
2843 out:
2844         mutex_unlock(&lli->lli_group_mutex);
2845
2846         RETURN(rc);
2847 }
2848
2849 static int ll_put_grouplock(struct inode *inode, struct file *file,
2850                             unsigned long arg)
2851 {
2852         struct ll_inode_info   *lli = ll_i2info(inode);
2853         struct ll_file_data    *fd = file->private_data;
2854         struct ll_grouplock     grouplock;
2855         int                     rc;
2856         ENTRY;
2857
2858         mutex_lock(&lli->lli_group_mutex);
2859         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
2860                 CWARN("no group lock held\n");
2861                 GOTO(out, rc = -EINVAL);
2862         }
2863
2864         LASSERT(fd->fd_grouplock.lg_lock != NULL);
2865
2866         if (fd->fd_grouplock.lg_gid != arg) {
2867                 CWARN("group lock %lu doesn't match current id %lu\n",
2868                       arg, fd->fd_grouplock.lg_gid);
2869                 GOTO(out, rc = -EINVAL);
2870         }
2871
2872         grouplock = fd->fd_grouplock;
2873         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
2874         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
2875
2876         cl_put_grouplock(&grouplock);
2877
2878         lli->lli_group_users--;
2879         if (lli->lli_group_users == 0) {
2880                 lli->lli_group_gid = 0;
2881                 wake_up_var(&lli->lli_group_users);
2882         }
2883         CDEBUG(D_INFO, "group lock %lu released\n", arg);
2884         GOTO(out, rc = 0);
2885 out:
2886         mutex_unlock(&lli->lli_group_mutex);
2887
2888         RETURN(rc);
2889 }
2890
2891 /**
2892  * Close inode open handle
2893  *
2894  * \param dentry [in]     dentry which contains the inode
2895  * \param it     [in,out] intent which contains open info and result
2896  *
2897  * \retval 0     success
2898  * \retval <0    failure
2899  */
2900 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
2901 {
2902         struct inode *inode = dentry->d_inode;
2903         struct obd_client_handle *och;
2904         int rc;
2905         ENTRY;
2906
2907         LASSERT(inode);
2908
2909         /* Root ? Do nothing. */
2910         if (is_root_inode(inode))
2911                 RETURN(0);
2912
2913         /* No open handle to close? Move away */
2914         if (!it_disposition(it, DISP_OPEN_OPEN))
2915                 RETURN(0);
2916
2917         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
2918
2919         OBD_ALLOC(och, sizeof(*och));
2920         if (!och)
2921                 GOTO(out, rc = -ENOMEM);
2922
2923         rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
2924         if (rc)
2925                 GOTO(out, rc);
2926
2927         rc = ll_close_inode_openhandle(inode, och, 0, NULL);
2928 out:
2929         /* this one is in place of ll_file_open */
2930         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
2931                 ptlrpc_req_finished(it->it_request);
2932                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
2933         }
2934         RETURN(rc);
2935 }
2936
2937 /**
2938  * Get size for inode for which FIEMAP mapping is requested.
2939  * Make the FIEMAP get_info call and returns the result.
2940  * \param fiemap        kernel buffer to hold extens
2941  * \param num_bytes     kernel buffer size
2942  */
2943 static int ll_do_fiemap(struct inode *inode, struct fiemap *fiemap,
2944                         size_t num_bytes)
2945 {
2946         struct lu_env                   *env;
2947         __u16                           refcheck;
2948         int                             rc = 0;
2949         struct ll_fiemap_info_key       fmkey = { .lfik_name = KEY_FIEMAP, };
2950         ENTRY;
2951
2952         /* Checks for fiemap flags */
2953         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
2954                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
2955                 return -EBADR;
2956         }
2957
2958         /* Check for FIEMAP_FLAG_SYNC */
2959         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
2960                 rc = filemap_write_and_wait(inode->i_mapping);
2961                 if (rc)
2962                         return rc;
2963         }
2964
2965         env = cl_env_get(&refcheck);
2966         if (IS_ERR(env))
2967                 RETURN(PTR_ERR(env));
2968
2969         if (i_size_read(inode) == 0) {
2970                 rc = ll_glimpse_size(inode);
2971                 if (rc)
2972                         GOTO(out, rc);
2973         }
2974
2975         fmkey.lfik_oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP | OBD_MD_FLPROJID;
2976         obdo_from_inode(&fmkey.lfik_oa, inode, OBD_MD_FLSIZE);
2977         obdo_set_parent_fid(&fmkey.lfik_oa, &ll_i2info(inode)->lli_fid);
2978
2979         /* If filesize is 0, then there would be no objects for mapping */
2980         if (fmkey.lfik_oa.o_size == 0) {
2981                 fiemap->fm_mapped_extents = 0;
2982                 GOTO(out, rc = 0);
2983         }
2984
2985         fmkey.lfik_fiemap = *fiemap;
2986
2987         rc = cl_object_fiemap(env, ll_i2info(inode)->lli_clob,
2988                               &fmkey, fiemap, &num_bytes);
2989 out:
2990         cl_env_put(env, &refcheck);
2991         RETURN(rc);
2992 }
2993
2994 static int fid2path_for_enc_file(struct inode *parent, char *gfpath,
2995                                  __u32 gfpathlen)
2996 {
2997         struct dentry *de = NULL, *de_parent = d_find_any_alias(parent);
2998         struct llcrypt_str lltr = LLTR_INIT(NULL, 0);
2999         struct llcrypt_str de_name;
3000         char *p, *ptr = gfpath;
3001         size_t len = 0, len_orig = 0;
3002         int enckey = -1, nameenc = -1;
3003         int rc = 0;
3004
3005         gfpath++;
3006         while ((p = strsep(&gfpath, "/")) != NULL) {
3007                 struct lu_fid fid;
3008
3009                 de = NULL;
3010                 if (!*p) {
3011                         dput(de_parent);
3012                         break;
3013                 }
3014                 len_orig = strlen(p);
3015
3016                 rc = sscanf(p, "["SFID"]", RFID(&fid));
3017                 if (rc == 3)
3018                         p = strchr(p, ']') + 1;
3019                 else
3020                         fid_zero(&fid);
3021                 rc = 0;
3022                 len = strlen(p);
3023
3024                 if (!IS_ENCRYPTED(parent)) {
3025                         if (gfpathlen < len + 1) {
3026                                 dput(de_parent);
3027                                 rc = -EOVERFLOW;
3028                                 break;
3029                         }
3030                         memmove(ptr, p, len);
3031                         p = ptr;
3032                         ptr += len;
3033                         *(ptr++) = '/';
3034                         gfpathlen -= len + 1;
3035                         goto lookup;
3036                 }
3037
3038                 /* From here, we know parent is encrypted */
3039
3040                 if (enckey != 0) {
3041                         rc = llcrypt_prepare_readdir(parent);
3042                         if (rc && rc != -ENOKEY) {
3043                                 dput(de_parent);
3044                                 break;
3045                         }
3046                 }
3047
3048                 if (enckey == -1) {
3049                         if (llcrypt_has_encryption_key(parent))
3050                                 enckey = 1;
3051                         else
3052                                 enckey = 0;
3053                         if (enckey == 1)
3054                                 nameenc =
3055                                         llcrypt_policy_has_filename_enc(parent);
3056                 }
3057
3058                 /* Even if names are not encrypted, we still need to call
3059                  * ll_fname_disk_to_usr in order to decode names as they are
3060                  * coming from the wire.
3061                  */
3062                 rc = llcrypt_fname_alloc_buffer(parent, NAME_MAX + 1, &lltr);
3063                 if (rc < 0) {
3064                         dput(de_parent);
3065                         break;
3066                 }
3067
3068                 de_name.name = p;
3069                 de_name.len = len;
3070                 rc = ll_fname_disk_to_usr(parent, 0, 0, &de_name,
3071                                           &lltr, &fid);
3072                 if (rc) {
3073                         llcrypt_fname_free_buffer(&lltr);
3074                         dput(de_parent);
3075                         break;
3076                 }
3077                 lltr.name[lltr.len] = '\0';
3078
3079                 if (lltr.len <= len_orig && gfpathlen >= lltr.len + 1) {
3080                         memcpy(ptr, lltr.name, lltr.len);
3081                         p = ptr;
3082                         len = lltr.len;
3083                         ptr += lltr.len;
3084                         *(ptr++) = '/';
3085                         gfpathlen -= lltr.len + 1;
3086                 } else {
3087                         rc = -EOVERFLOW;
3088                 }
3089                 llcrypt_fname_free_buffer(&lltr);
3090
3091                 if (rc == -EOVERFLOW) {
3092                         dput(de_parent);
3093                         break;
3094                 }
3095
3096 lookup:
3097                 if (!gfpath) {
3098                         /* We reached the end of the string, which means
3099                          * we are dealing with the last component in the path.
3100                          * So save a useless lookup and exit.
3101                          */
3102                         dput(de_parent);
3103                         break;
3104                 }
3105
3106                 if (enckey == 0 || nameenc == 0)
3107                         continue;
3108
3109                 ll_inode_lock(parent);
3110                 de = lookup_one_len(p, de_parent, len);
3111                 ll_inode_unlock(parent);
3112                 if (IS_ERR_OR_NULL(de) || !de->d_inode) {
3113                         dput(de_parent);
3114                         rc = -ENODATA;
3115                         break;
3116                 }
3117
3118                 parent = de->d_inode;
3119                 dput(de_parent);
3120                 de_parent = de;
3121         }
3122
3123         if (len)
3124                 *(ptr - 1) = '\0';
3125         if (!IS_ERR_OR_NULL(de))
3126                 dput(de);
3127         return rc;
3128 }
3129
3130 int __ll_fid2path(struct inode *inode, struct getinfo_fid2path *gfout,
3131                   size_t outsize, __u32 pathlen_orig)
3132 {
3133         struct obd_export *exp = ll_i2mdexp(inode);
3134         int rc;
3135
3136         /* Append root FID after gfout to let MDT know the root FID so that
3137          * it can lookup the correct path, this is mainly for fileset.
3138          * old server without fileset mount support will ignore this.
3139          */
3140         *gfout->gf_u.gf_root_fid = *ll_inode2fid(inode);
3141
3142         /* Call mdc_iocontrol */
3143         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
3144
3145         if (!rc && gfout->gf_pathlen && gfout->gf_u.gf_path[0] == '/') {
3146                 /* by convention, server side (mdt_path_current()) puts
3147                  * a leading '/' to tell client that we are dealing with
3148                  * an encrypted file
3149                  */
3150                 rc = fid2path_for_enc_file(inode, gfout->gf_u.gf_path,
3151                                            gfout->gf_pathlen);
3152                 if (!rc && strlen(gfout->gf_u.gf_path) > pathlen_orig)
3153                         rc = -EOVERFLOW;
3154         }
3155
3156         return rc;
3157 }
3158
3159 int ll_fid2path(struct inode *inode, void __user *arg)
3160 {
3161         const struct getinfo_fid2path __user *gfin = arg;
3162         __u32 pathlen, pathlen_orig;
3163         struct getinfo_fid2path *gfout;
3164         size_t outsize;
3165         int rc = 0;
3166
3167         ENTRY;
3168
3169         if (!capable(CAP_DAC_READ_SEARCH) &&
3170             !test_bit(LL_SBI_USER_FID2PATH, ll_i2sbi(inode)->ll_flags))
3171                 RETURN(-EPERM);
3172
3173         /* Only need to get the buflen */
3174         if (get_user(pathlen, &gfin->gf_pathlen))
3175                 RETURN(-EFAULT);
3176
3177         if (pathlen > PATH_MAX)
3178                 RETURN(-EINVAL);
3179         pathlen_orig = pathlen;
3180
3181 gf_alloc:
3182         outsize = sizeof(*gfout) + pathlen;
3183         OBD_ALLOC(gfout, outsize);
3184         if (gfout == NULL)
3185                 RETURN(-ENOMEM);
3186
3187         if (copy_from_user(gfout, arg, sizeof(*gfout)))
3188                 GOTO(gf_free, rc = -EFAULT);
3189
3190         gfout->gf_pathlen = pathlen;
3191         rc = __ll_fid2path(inode, gfout, outsize, pathlen_orig);
3192         if (rc)
3193                 GOTO(gf_free, rc);
3194
3195         if (copy_to_user(arg, gfout, sizeof(*gfout) + pathlen_orig))
3196                 rc = -EFAULT;
3197
3198 gf_free:
3199         OBD_FREE(gfout, outsize);
3200         if (rc == -ENAMETOOLONG) {
3201                 pathlen += PATH_MAX;
3202                 GOTO(gf_alloc, rc);
3203         }
3204         RETURN(rc);
3205 }
3206
3207 static int
3208 ll_ioc_data_version(struct inode *inode, struct ioc_data_version *ioc)
3209 {
3210         struct cl_object *obj = ll_i2info(inode)->lli_clob;
3211         struct lu_env *env;
3212         struct cl_io *io;
3213         __u16  refcheck;
3214         int result;
3215
3216         ENTRY;
3217
3218         ioc->idv_version = 0;
3219         ioc->idv_layout_version = UINT_MAX;
3220
3221         /* If no file object initialized, we consider its version is 0. */
3222         if (obj == NULL)
3223                 RETURN(0);
3224
3225         env = cl_env_get(&refcheck);
3226         if (IS_ERR(env))
3227                 RETURN(PTR_ERR(env));
3228
3229         io = vvp_env_thread_io(env);
3230         io->ci_obj = obj;
3231         io->u.ci_data_version.dv_data_version = 0;
3232         io->u.ci_data_version.dv_layout_version = UINT_MAX;
3233         io->u.ci_data_version.dv_flags = ioc->idv_flags;
3234
3235 restart:
3236         if (cl_io_init(env, io, CIT_DATA_VERSION, io->ci_obj) == 0)
3237                 result = cl_io_loop(env, io);
3238         else
3239                 result = io->ci_result;
3240
3241         ioc->idv_version = io->u.ci_data_version.dv_data_version;
3242         ioc->idv_layout_version = io->u.ci_data_version.dv_layout_version;
3243         cl_io_fini(env, io);
3244
3245         if (unlikely(io->ci_need_restart))
3246                 goto restart;
3247
3248         cl_env_put(env, &refcheck);
3249
3250         RETURN(result);
3251 }
3252
3253 /*
3254  * Read the data_version for inode.
3255  *
3256  * This value is computed using stripe object version on OST.
3257  * Version is computed using server side locking.
3258  *
3259  * @param flags if do sync on the OST side;
3260  *              0: no sync
3261  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
3262  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
3263  */
3264 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
3265 {
3266         struct ioc_data_version ioc = { .idv_flags = flags };
3267         int rc;
3268
3269         rc = ll_ioc_data_version(inode, &ioc);
3270         if (!rc)
3271                 *data_version = ioc.idv_version;
3272
3273         return rc;
3274 }
3275
3276 /*
3277  * Trigger a HSM release request for the provided inode.
3278  */
3279 int ll_hsm_release(struct inode *inode)
3280 {
3281         struct lu_env *env;
3282         struct obd_client_handle *och = NULL;
3283         __u64 data_version = 0;
3284         __u16 refcheck;
3285         int rc;
3286
3287         ENTRY;
3288
3289         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
3290                ll_i2sbi(inode)->ll_fsname,
3291                PFID(&ll_i2info(inode)->lli_fid));
3292
3293         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
3294         if (IS_ERR(och))
3295                 GOTO(out, rc = PTR_ERR(och));
3296
3297         /* Grab latest data_version and [am]time values */
3298         rc = ll_data_version(inode, &data_version,
3299                              LL_DV_WR_FLUSH | LL_DV_SZ_UPDATE);
3300         if (rc != 0)
3301                 GOTO(out, rc);
3302
3303         env = cl_env_get(&refcheck);
3304         if (IS_ERR(env))
3305                 GOTO(out, rc = PTR_ERR(env));
3306
3307         rc = ll_merge_attr(env, inode);
3308         cl_env_put(env, &refcheck);
3309
3310         /* If error happen, we have the wrong size for a file.
3311          * Don't release it.
3312          */
3313         if (rc != 0)
3314                 GOTO(out, rc);
3315
3316         /* Release the file.
3317          * NB: lease lock handle is released in mdc_hsm_release_pack() because
3318          * we still need it to pack l_remote_handle to MDT. */
3319         rc = ll_close_inode_openhandle(inode, och, MDS_HSM_RELEASE,
3320                                        &data_version);
3321         och = NULL;
3322
3323         EXIT;
3324 out:
3325         if (och != NULL && !IS_ERR(och)) /* close the file */
3326                 ll_lease_close(och, inode, NULL);
3327
3328         return rc;
3329 }
3330
3331 struct ll_swap_stack {
3332         __u64                    dv1;
3333         __u64                    dv2;
3334         struct inode            *inode1;
3335         struct inode            *inode2;
3336         bool                     check_dv1;
3337         bool                     check_dv2;
3338 };
3339
3340 static int ll_swap_layouts(struct file *file1, struct file *file2,
3341                            struct lustre_swap_layouts *lsl)
3342 {
3343         struct mdc_swap_layouts  msl;
3344         struct md_op_data       *op_data;
3345         __u32                    gid;
3346         __u64                    dv;
3347         struct ll_swap_stack    *llss = NULL;
3348         int                      rc;
3349
3350         OBD_ALLOC_PTR(llss);
3351         if (llss == NULL)
3352                 RETURN(-ENOMEM);
3353
3354         llss->inode1 = file_inode(file1);
3355         llss->inode2 = file_inode(file2);
3356
3357         rc = ll_check_swap_layouts_validity(llss->inode1, llss->inode2);
3358         if (rc < 0)
3359                 GOTO(free, rc);
3360
3361         /* we use 2 bool because it is easier to swap than 2 bits */
3362         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
3363                 llss->check_dv1 = true;
3364
3365         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
3366                 llss->check_dv2 = true;
3367
3368         /* we cannot use lsl->sl_dvX directly because we may swap them */
3369         llss->dv1 = lsl->sl_dv1;
3370         llss->dv2 = lsl->sl_dv2;
3371
3372         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
3373         if (rc == 0) /* same file, done! */
3374                 GOTO(free, rc);
3375
3376         if (rc < 0) { /* sequentialize it */
3377                 swap(llss->inode1, llss->inode2);
3378                 swap(file1, file2);
3379                 swap(llss->dv1, llss->dv2);
3380                 swap(llss->check_dv1, llss->check_dv2);
3381         }
3382
3383         gid = lsl->sl_gid;
3384         if (gid != 0) { /* application asks to flush dirty cache */
3385                 rc = ll_get_grouplock(llss->inode1, file1, gid);
3386                 if (rc < 0)
3387                         GOTO(free, rc);
3388
3389                 rc = ll_get_grouplock(llss->inode2, file2, gid);
3390                 if (rc < 0) {
3391                         ll_put_grouplock(llss->inode1, file1, gid);
3392                         GOTO(free, rc);
3393                 }
3394         }
3395
3396         /* ultimate check, before swaping the layouts we check if
3397          * dataversion has changed (if requested) */
3398         if (llss->check_dv1) {
3399                 rc = ll_data_version(llss->inode1, &dv, 0);
3400                 if (rc)
3401                         GOTO(putgl, rc);
3402                 if (dv != llss->dv1)
3403                         GOTO(putgl, rc = -EAGAIN);
3404         }
3405
3406         if (llss->check_dv2) {
3407                 rc = ll_data_version(llss->inode2, &dv, 0);
3408                 if (rc)
3409                         GOTO(putgl, rc);
3410                 if (dv != llss->dv2)
3411                         GOTO(putgl, rc = -EAGAIN);
3412         }
3413
3414         /* struct md_op_data is used to send the swap args to the mdt
3415          * only flags is missing, so we use struct mdc_swap_layouts
3416          * through the md_op_data->op_data */
3417         /* flags from user space have to be converted before they are send to
3418          * server, no flag is sent today, they are only used on the client */
3419         msl.msl_flags = 0;
3420         rc = -ENOMEM;
3421         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
3422                                      0, LUSTRE_OPC_ANY, &msl);
3423         if (IS_ERR(op_data))
3424                 GOTO(free, rc = PTR_ERR(op_data));
3425
3426         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
3427                            sizeof(*op_data), op_data, NULL);
3428         ll_finish_md_op_data(op_data);
3429
3430         if (rc < 0)
3431                 GOTO(putgl, rc);
3432
3433 putgl:
3434         if (gid != 0) {
3435                 ll_put_grouplock(llss->inode2, file2, gid);
3436                 ll_put_grouplock(llss->inode1, file1, gid);
3437         }
3438
3439 free:
3440         if (llss != NULL)
3441                 OBD_FREE_PTR(llss);
3442
3443         RETURN(rc);
3444 }
3445
3446 int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
3447 {
3448         struct obd_export *exp = ll_i2mdexp(inode);
3449         struct md_op_data *op_data;
3450         int rc;
3451         ENTRY;
3452
3453         /* Detect out-of range masks */
3454         if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK)
3455                 RETURN(-EINVAL);
3456
3457         /* Non-root users are forbidden to set or clear flags which are
3458          * NOT defined in HSM_USER_MASK. */
3459         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
3460             !capable(CAP_SYS_ADMIN))
3461                 RETURN(-EPERM);
3462
3463         if (!exp_connect_archive_id_array(exp)) {
3464                 /* Detect out-of range archive id */
3465                 if ((hss->hss_valid & HSS_ARCHIVE_ID) &&
3466                     (hss->hss_archive_id > LL_HSM_ORIGIN_MAX_ARCHIVE))
3467                         RETURN(-EINVAL);
3468         }
3469
3470         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3471                                      LUSTRE_OPC_ANY, hss);
3472         if (IS_ERR(op_data))
3473                 RETURN(PTR_ERR(op_data));
3474
3475         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, exp, sizeof(*op_data),
3476                            op_data, NULL);
3477
3478         ll_finish_md_op_data(op_data);
3479
3480         RETURN(rc);
3481 }
3482
3483 static int ll_hsm_import(struct inode *inode, struct file *file,
3484                          struct hsm_user_import *hui)
3485 {
3486         struct hsm_state_set    *hss = NULL;
3487         struct iattr            *attr = NULL;
3488         int                      rc;
3489         ENTRY;
3490
3491         if (!S_ISREG(inode->i_mode))
3492                 RETURN(-EINVAL);
3493
3494         /* set HSM flags */
3495         OBD_ALLOC_PTR(hss);
3496         if (hss == NULL)
3497                 GOTO(out, rc = -ENOMEM);
3498
3499         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
3500         hss->hss_archive_id = hui->hui_archive_id;
3501         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
3502         rc = ll_hsm_state_set(inode, hss);
3503         if (rc != 0)
3504                 GOTO(out, rc);
3505
3506         OBD_ALLOC_PTR(attr);
3507         if (attr == NULL)
3508                 GOTO(out, rc = -ENOMEM);
3509
3510         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
3511         attr->ia_mode |= S_IFREG;
3512         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
3513         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
3514         attr->ia_size = hui->hui_size;
3515         attr->ia_mtime.tv_sec = hui->hui_mtime;
3516         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
3517         attr->ia_atime.tv_sec = hui->hui_atime;
3518         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
3519
3520         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
3521                          ATTR_UID | ATTR_GID |
3522                          ATTR_MTIME | ATTR_MTIME_SET |
3523                          ATTR_ATIME | ATTR_ATIME_SET;
3524
3525         inode_lock(inode);
3526         /* inode lock owner set in ll_setattr_raw()*/
3527         rc = ll_setattr_raw(file_dentry(file), attr, 0, true);
3528         if (rc == -ENODATA)
3529                 rc = 0;
3530         inode_unlock(inode);
3531
3532 out:
3533         if (hss != NULL)
3534                 OBD_FREE_PTR(hss);
3535
3536         if (attr != NULL)
3537                 OBD_FREE_PTR(attr);
3538
3539         RETURN(rc);
3540 }
3541
3542 static inline long ll_lease_type_from_fmode(fmode_t fmode)
3543 {
3544         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
3545                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
3546 }
3547
3548 static int ll_file_futimes_3(struct file *file, const struct ll_futimes_3 *lfu)
3549 {
3550         struct inode *inode = file_inode(file);
3551         struct iattr ia = {
3552                 .ia_valid = ATTR_ATIME | ATTR_ATIME_SET |
3553                             ATTR_MTIME | ATTR_MTIME_SET |
3554                             ATTR_CTIME,
3555                 .ia_atime = {
3556                         .tv_sec = lfu->lfu_atime_sec,
3557                         .tv_nsec = lfu->lfu_atime_nsec,
3558                 },
3559                 .ia_mtime = {
3560                         .tv_sec = lfu->lfu_mtime_sec,
3561                         .tv_nsec = lfu->lfu_mtime_nsec,
3562                 },
3563                 .ia_ctime = {
3564                         .tv_sec = lfu->lfu_ctime_sec,
3565                         .tv_nsec = lfu->lfu_ctime_nsec,
3566                 },
3567         };
3568         int rc;
3569         ENTRY;
3570
3571         if (!capable(CAP_SYS_ADMIN))
3572                 RETURN(-EPERM);
3573
3574         if (!S_ISREG(inode->i_mode))
3575                 RETURN(-EINVAL);
3576
3577         inode_lock(inode);
3578         /* inode lock owner set in ll_setattr_raw()*/
3579         rc = ll_setattr_raw(file_dentry(file), &ia, OP_XVALID_CTIME_SET,
3580                             false);
3581         inode_unlock(inode);
3582
3583         RETURN(rc);
3584 }
3585
3586 static enum cl_lock_mode cl_mode_user_to_kernel(enum lock_mode_user mode)
3587 {
3588         switch (mode) {
3589         case MODE_READ_USER:
3590                 return CLM_READ;
3591         case MODE_WRITE_USER:
3592                 return CLM_WRITE;
3593         default:
3594                 return -EINVAL;
3595         }
3596 }
3597
3598 static const char *const user_lockname[] = LOCK_MODE_NAMES;
3599
3600 /* Used to allow the upper layers of the client to request an LDLM lock
3601  * without doing an actual read or write.
3602  *
3603  * Used for ladvise lockahead to manually request specific locks.
3604  *
3605  * \param[in] file      file this ladvise lock request is on
3606  * \param[in] ladvise   ladvise struct describing this lock request
3607  *
3608  * \retval 0            success, no detailed result available (sync requests
3609  *                      and requests sent to the server [not handled locally]
3610  *                      cannot return detailed results)
3611  * \retval LLA_RESULT_{SAME,DIFFERENT} - detailed result of the lock request,
3612  *                                       see definitions for details.
3613  * \retval negative     negative errno on error
3614  */
3615 int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise)
3616 {
3617         struct lu_env *env = NULL;
3618         struct cl_io *io  = NULL;
3619         struct cl_lock *lock = NULL;
3620         struct cl_lock_descr *descr = NULL;
3621         struct dentry *dentry = file->f_path.dentry;
3622         struct inode *inode = dentry->d_inode;
3623         enum cl_lock_mode cl_mode;
3624         off_t start = ladvise->lla_start;
3625         off_t end = ladvise->lla_end;
3626         int result;
3627         __u16 refcheck;
3628
3629         ENTRY;
3630
3631         CDEBUG(D_VFSTRACE,
3632                "Lock request: file=%pd, inode=%p, mode=%s start=%llu, end=%llu\n",
3633                dentry, dentry->d_inode,
3634                user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
3635                (__u64) end);
3636
3637         cl_mode = cl_mode_user_to_kernel(ladvise->lla_lockahead_mode);
3638         if (cl_mode < 0)
3639                 GOTO(out, result = cl_mode);
3640
3641         /* Get IO environment */
3642         result = cl_io_get(inode, &env, &io, &refcheck);
3643         if (result <= 0)
3644                 GOTO(out, result);
3645
3646         result = cl_io_init(env, io, CIT_MISC, io->ci_obj);
3647         if (result > 0) {
3648                 /*
3649                  * nothing to do for this io. This currently happens when
3650                  * stripe sub-object's are not yet created.
3651                  */
3652                 result = io->ci_result;
3653         } else if (result == 0) {
3654                 lock = vvp_env_lock(env);
3655                 descr = &lock->cll_descr;
3656
3657                 descr->cld_obj   = io->ci_obj;
3658                 /* Convert byte offsets to pages */
3659                 descr->cld_start = start >> PAGE_SHIFT;
3660                 descr->cld_end   = end >> PAGE_SHIFT;
3661                 descr->cld_mode  = cl_mode;
3662                 /* CEF_MUST is used because we do not want to convert a
3663                  * lockahead request to a lockless lock */
3664                 descr->cld_enq_flags = CEF_MUST | CEF_LOCK_NO_EXPAND;
3665
3666                 if (ladvise->lla_peradvice_flags & LF_ASYNC)
3667                         descr->cld_enq_flags |= CEF_SPECULATIVE;
3668
3669                 result = cl_lock_request(env, io, lock);
3670
3671                 /* On success, we need to release the lock */
3672                 if (result >= 0)
3673                         cl_lock_release(env, lock);
3674         }
3675         cl_io_fini(env, io);
3676         cl_env_put(env, &refcheck);
3677
3678         /* -ECANCELED indicates a matching lock with a different extent
3679          * was already present, and -EEXIST indicates a matching lock
3680          * on exactly the same extent was already present.
3681          * We convert them to positive values for userspace to make
3682          * recognizing true errors easier.
3683          * Note we can only return these detailed results on async requests,
3684          * as sync requests look the same as i/o requests for locking. */
3685         if (result == -ECANCELED)
3686                 result = LLA_RESULT_DIFFERENT;
3687         else if (result == -EEXIST)
3688                 result = LLA_RESULT_SAME;
3689
3690 out:
3691         RETURN(result);
3692 }
3693 static const char *const ladvise_names[] = LU_LADVISE_NAMES;
3694
3695 static int ll_ladvise_sanity(struct inode *inode,
3696                              struct llapi_lu_ladvise *ladvise)
3697 {
3698         struct ll_sb_info *sbi = ll_i2sbi(inode);
3699         enum lu_ladvise_type advice = ladvise->lla_advice;
3700         /* Note the peradvice flags is a 32 bit field, so per advice flags must
3701          * be in the first 32 bits of enum ladvise_flags */
3702         __u32 flags = ladvise->lla_peradvice_flags;
3703         /* 3 lines at 80 characters per line, should be plenty */
3704         int rc = 0;
3705
3706         if (advice > LU_LADVISE_MAX || advice == LU_LADVISE_INVALID) {
3707                 rc = -EINVAL;
3708                 CDEBUG(D_VFSTRACE,
3709                        "%s: advice with value '%d' not recognized, last supported advice is %s (value '%d'): rc = %d\n",
3710                        sbi->ll_fsname, advice,
3711                        ladvise_names[LU_LADVISE_MAX-1], LU_LADVISE_MAX-1, rc);
3712                 GOTO(out, rc);
3713         }
3714
3715         /* Per-advice checks */
3716         switch (advice) {
3717         case LU_LADVISE_LOCKNOEXPAND:
3718                 if (flags & ~LF_LOCKNOEXPAND_MASK) {
3719                         rc = -EINVAL;
3720                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
3721                                "rc = %d\n", sbi->ll_fsname, flags,
3722                                ladvise_names[advice], rc);
3723                         GOTO(out, rc);
3724                 }
3725                 break;
3726         case LU_LADVISE_LOCKAHEAD:
3727                 /* Currently only READ and WRITE modes can be requested */
3728                 if (ladvise->lla_lockahead_mode >= MODE_MAX_USER ||
3729                     ladvise->lla_lockahead_mode == 0) {
3730                         rc = -EINVAL;
3731                         CDEBUG(D_VFSTRACE, "%s: Invalid mode (%d) for %s: "
3732                                "rc = %d\n", sbi->ll_fsname,
3733                                ladvise->lla_lockahead_mode,
3734                                ladvise_names[advice], rc);
3735                         GOTO(out, rc);
3736                 }
3737                 fallthrough;
3738         case LU_LADVISE_WILLREAD:
3739         case LU_LADVISE_DONTNEED:
3740         default:
3741                 /* Note fall through above - These checks apply to all advices
3742                  * except LOCKNOEXPAND */
3743                 if (flags & ~LF_DEFAULT_MASK) {
3744                         rc = -EINVAL;
3745                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
3746                                "rc = %d\n", sbi->ll_fsname, flags,
3747                                ladvise_names[advice], rc);
3748                         GOTO(out, rc);
3749                 }
3750                 if (ladvise->lla_start >= ladvise->lla_end) {
3751                         rc = -EINVAL;
3752                         CDEBUG(D_VFSTRACE, "%s: Invalid range (%llu to %llu) "
3753                                "for %s: rc = %d\n", sbi->ll_fsname,
3754                                ladvise->lla_start, ladvise->lla_end,
3755                                ladvise_names[advice], rc);
3756                         GOTO(out, rc);
3757                 }
3758                 break;
3759         }
3760
3761 out:
3762         return rc;
3763 }
3764 #undef ERRSIZE
3765
3766 /*
3767  * Give file access advices
3768  *
3769  * The ladvise interface is similar to Linux fadvise() system call, except it
3770  * forwards the advices directly from Lustre client to server. The server side
3771  * codes will apply appropriate read-ahead and caching techniques for the
3772  * corresponding files.
3773  *
3774  * A typical workload for ladvise is e.g. a bunch of different clients are
3775  * doing small random reads of a file, so prefetching pages into OSS cache
3776  * with big linear reads before the random IO is a net benefit. Fetching
3777  * all that data into each client cache with fadvise() may not be, due to
3778  * much more data being sent to the client.
3779  */
3780 static int ll_ladvise(struct inode *inode, struct file *file, __u64 flags,
3781                       struct llapi_lu_ladvise *ladvise)
3782 {
3783         struct lu_env *env;
3784         struct cl_io *io;
3785         struct cl_ladvise_io *lio;
3786         int rc;
3787         __u16 refcheck;
3788         ENTRY;
3789
3790         env = cl_env_get(&refcheck);
3791         if (IS_ERR(env))
3792                 RETURN(PTR_ERR(env));
3793
3794         io = vvp_env_thread_io(env);
3795         io->ci_obj = ll_i2info(inode)->lli_clob;
3796
3797         /* initialize parameters for ladvise */
3798         lio = &io->u.ci_ladvise;
3799         lio->li_start = ladvise->lla_start;
3800         lio->li_end = ladvise->lla_end;
3801         lio->li_fid = ll_inode2fid(inode);
3802         lio->li_advice = ladvise->lla_advice;
3803         lio->li_flags = flags;
3804
3805         if (cl_io_init(env, io, CIT_LADVISE, io->ci_obj) == 0)
3806                 rc = cl_io_loop(env, io);
3807         else
3808                 rc = io->ci_result;
3809
3810         cl_io_fini(env, io);
3811         cl_env_put(env, &refcheck);
3812         RETURN(rc);
3813 }
3814
3815 static int ll_lock_noexpand(struct file *file, int flags)
3816 {
3817         struct ll_file_data *fd = file->private_data;
3818
3819         fd->ll_lock_no_expand = !(flags & LF_UNSET);
3820
3821         return 0;
3822 }
3823
3824 #ifndef HAVE_FILEATTR_GET
3825 int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
3826                         void __user *uarg)
3827 {
3828         struct fsxattr fsxattr;
3829
3830         if (copy_from_user(&fsxattr, uarg, sizeof(fsxattr)))
3831                 RETURN(-EFAULT);
3832
3833         fsxattr.fsx_xflags = ll_inode_flags_to_xflags(inode->i_flags);
3834         if (test_bit(LLIF_PROJECT_INHERIT, &ll_i2info(inode)->lli_flags))
3835                 fsxattr.fsx_xflags |= FS_XFLAG_PROJINHERIT;
3836         fsxattr.fsx_projid = ll_i2info(inode)->lli_projid;
3837         if (copy_to_user(uarg, &fsxattr, sizeof(fsxattr)))
3838                 RETURN(-EFAULT);
3839
3840         RETURN(0);
3841 }
3842 #endif
3843
3844 int ll_ioctl_check_project(struct inode *inode, __u32 xflags,
3845                            __u32 projid)
3846 {
3847         /*
3848          * Project Quota ID state is only allowed to change from within the init
3849          * namespace. Enforce that restriction only if we are trying to change
3850          * the quota ID state. Everything else is allowed in user namespaces.
3851          */
3852         if (current_user_ns() == &init_user_ns) {
3853                 /*
3854                  * Caller is allowed to change the project ID. if it is being
3855                  * changed, make sure that the new value is valid.
3856                  */
3857                 if (ll_i2info(inode)->lli_projid != projid &&
3858                      !projid_valid(make_kprojid(&init_user_ns, projid)))
3859                         return -EINVAL;
3860
3861                 return 0;
3862         }
3863
3864         if (ll_i2info(inode)->lli_projid != projid)
3865                 return -EINVAL;
3866
3867         if (test_bit(LLIF_PROJECT_INHERIT, &ll_i2info(inode)->lli_flags)) {
3868                 if (!(xflags & FS_XFLAG_PROJINHERIT))
3869                         return -EINVAL;
3870         } else {
3871                 if (xflags & FS_XFLAG_PROJINHERIT)
3872                         return -EINVAL;
3873         }
3874
3875         return 0;
3876 }
3877
3878 int ll_set_project(struct inode *inode, __u32 xflags, __u32 projid)
3879 {
3880         struct ptlrpc_request *req = NULL;
3881         struct md_op_data *op_data;
3882         struct cl_object *obj;
3883         unsigned int inode_flags;
3884         int rc = 0;
3885
3886         CDEBUG(D_QUOTA, DFID" xflags=%x projid=%u\n",
3887                PFID(ll_inode2fid(inode)), xflags, projid);
3888         rc = ll_ioctl_check_project(inode, xflags, projid);
3889         if (rc)
3890                 RETURN(rc);
3891
3892         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3893                                      LUSTRE_OPC_ANY, NULL);
3894         if (IS_ERR(op_data))
3895                 RETURN(PTR_ERR(op_data));
3896
3897         inode_flags = ll_xflags_to_inode_flags(xflags);
3898         op_data->op_attr_flags = ll_inode_to_ext_flags(inode_flags);
3899         if (xflags & FS_XFLAG_PROJINHERIT)
3900                 op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
3901
3902         /* pass projid to md_op_data */
3903         op_data->op_projid = projid;
3904
3905         op_data->op_xvalid |= OP_XVALID_PROJID | OP_XVALID_FLAGS;
3906         rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data, NULL, 0, &req);
3907         ptlrpc_req_finished(req);
3908         if (rc)
3909                 GOTO(out_fsxattr, rc);
3910         ll_update_inode_flags(inode, op_data->op_attr_flags);
3911
3912         /* Avoid OST RPC if this is only ioctl setting project inherit flag */
3913         if (xflags == 0 || xflags == FS_XFLAG_PROJINHERIT)
3914                 GOTO(out_fsxattr, rc);
3915
3916         obj = ll_i2info(inode)->lli_clob;
3917         if (obj) {
3918                 struct iattr attr = { 0 };
3919
3920                 rc = cl_setattr_ost(obj, &attr, OP_XVALID_FLAGS, xflags);
3921         }
3922
3923 out_fsxattr:
3924         ll_finish_md_op_data(op_data);
3925         RETURN(rc);
3926 }
3927
3928 #ifndef HAVE_FILEATTR_GET
3929 int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
3930                         void __user *uarg)
3931 {
3932         struct fsxattr fsxattr;
3933
3934         ENTRY;
3935
3936         if (copy_from_user(&fsxattr, uarg, sizeof(fsxattr)))
3937                 RETURN(-EFAULT);
3938
3939         RETURN(ll_set_project(inode, fsxattr.fsx_xflags,
3940                               fsxattr.fsx_projid));
3941 }
3942 #endif
3943
3944 int ll_ioctl_project(struct file *file, unsigned int cmd, void __user *uarg)
3945 {
3946         struct lu_project lu_project;
3947         struct dentry *dentry = file_dentry(file);
3948         struct inode *inode = file_inode(file);
3949         struct dentry *child_dentry = NULL;
3950         int rc = 0, name_len;
3951
3952         if (copy_from_user(&lu_project, uarg, sizeof(lu_project)))
3953                 RETURN(-EFAULT);
3954
3955         /* apply child dentry if name is valid */
3956         name_len = strnlen(lu_project.project_name, NAME_MAX);
3957         if (name_len > 0 && name_len <= NAME_MAX) {
3958                 ll_inode_lock(inode);
3959                 child_dentry = lookup_one_len(lu_project.project_name,
3960                                               dentry, name_len);
3961                 ll_inode_unlock(inode);
3962                 if (IS_ERR(child_dentry)) {
3963                         rc = PTR_ERR(child_dentry);
3964                         goto out;
3965                 }
3966                 inode = child_dentry->d_inode;
3967                 if (!inode) {
3968                         rc = -ENOENT;
3969                         goto out;
3970                 }
3971         } else if (name_len > NAME_MAX) {
3972                 rc = -EINVAL;
3973                 goto out;
3974         }
3975
3976         switch (lu_project.project_type) {
3977         case LU_PROJECT_SET:
3978                 rc = ll_set_project(inode, lu_project.project_xflags,
3979                                     lu_project.project_id);
3980                 break;
3981         case LU_PROJECT_GET:
3982                 lu_project.project_xflags =
3983                                 ll_inode_flags_to_xflags(inode->i_flags);
3984                 if (test_bit(LLIF_PROJECT_INHERIT,
3985                              &ll_i2info(inode)->lli_flags))
3986                         lu_project.project_xflags |= FS_XFLAG_PROJINHERIT;
3987                 lu_project.project_id = ll_i2info(inode)->lli_projid;
3988                 if (copy_to_user(uarg, &lu_project, sizeof(lu_project))) {
3989                         rc = -EFAULT;
3990                         goto out;
3991                 }
3992                 break;
3993         default:
3994                 rc = -EINVAL;
3995                 break;
3996         }
3997 out:
3998         if (!IS_ERR_OR_NULL(child_dentry))
3999                 dput(child_dentry);
4000         RETURN(rc);
4001 }
4002
4003 static long ll_file_unlock_lease(struct file *file, struct ll_ioc_lease *ioc,
4004                                  void __user *uarg)
4005 {
4006         struct inode *inode = file_inode(file);
4007         struct ll_file_data *fd = file->private_data;
4008         struct ll_inode_info *lli = ll_i2info(inode);
4009         struct obd_client_handle *och = NULL;
4010         struct split_param sp;
4011         struct pcc_param param;
4012         bool lease_broken = false;
4013         fmode_t fmode = 0;
4014         enum mds_op_bias bias = 0;
4015         __u32 fdv;
4016         struct file *layout_file = NULL;
4017         void *data = NULL;
4018         size_t data_size = 0;
4019         bool attached = false;
4020         long rc, rc2 = 0;
4021
4022         ENTRY;
4023
4024         mutex_lock(&lli->lli_och_mutex);
4025         if (fd->fd_lease_och != NULL) {
4026                 och = fd->fd_lease_och;
4027                 fd->fd_lease_och = NULL;
4028         }
4029         mutex_unlock(&lli->lli_och_mutex);
4030
4031         if (och == NULL)
4032                 RETURN(-ENOLCK);
4033
4034         fmode = och->och_flags;
4035
4036         switch (ioc->lil_flags) {
4037         case LL_LEASE_RESYNC_DONE:
4038                 if (ioc->lil_count > IOC_IDS_MAX)
4039                         GOTO(out_lease_close, rc = -EINVAL);
4040
4041                 data_size = offsetof(typeof(*ioc), lil_ids[ioc->lil_count]);
4042                 OBD_ALLOC(data, data_size);
4043                 if (!data)
4044                         GOTO(out_lease_close, rc = -ENOMEM);
4045
4046                 if (copy_from_user(data, uarg, data_size))
4047                         GOTO(out_lease_close, rc = -EFAULT);
4048
4049                 bias = MDS_CLOSE_RESYNC_DONE;
4050                 break;
4051         case LL_LEASE_LAYOUT_MERGE:
4052                 if (ioc->lil_count != 1)
4053                         GOTO(out_lease_close, rc = -EINVAL);
4054
4055                 uarg += sizeof(*ioc);
4056                 if (copy_from_user(&fdv, uarg, sizeof(fdv)))
4057                         GOTO(out_lease_close, rc = -EFAULT);
4058
4059                 layout_file = fget(fdv);
4060                 if (!layout_file)
4061                         GOTO(out_lease_close, rc = -EBADF);
4062
4063                 if ((file->f_flags & O_ACCMODE) == O_RDONLY ||
4064                                 (layout_file->f_flags & O_ACCMODE) == O_RDONLY)
4065                         GOTO(out_lease_close, rc = -EPERM);
4066
4067                 data = file_inode(layout_file);
4068                 bias = MDS_CLOSE_LAYOUT_MERGE;
4069                 break;
4070         case LL_LEASE_LAYOUT_SPLIT: {
4071                 __u32 mirror_id;
4072
4073                 if (ioc->lil_count != 2)
4074                         GOTO(out_lease_close, rc = -EINVAL);
4075
4076                 uarg += sizeof(*ioc);
4077                 if (copy_from_user(&fdv, uarg, sizeof(fdv)))
4078                         GOTO(out_lease_close, rc = -EFAULT);
4079
4080                 uarg += sizeof(fdv);
4081                 if (copy_from_user(&mirror_id, uarg, sizeof(mirror_id)))
4082                         GOTO(out_lease_close, rc = -EFAULT);
4083                 if (mirror_id >= MIRROR_ID_NEG)
4084                         GOTO(out_lease_close, rc = -EINVAL);
4085
4086                 layout_file = fget(fdv);
4087                 if (!layout_file)
4088                         GOTO(out_lease_close, rc = -EBADF);
4089
4090                 /* if layout_file == file, it means to destroy the mirror */
4091                 sp.sp_inode = file_inode(layout_file);
4092                 sp.sp_mirror_id = (__u16)mirror_id;
4093                 data = &sp;
4094                 bias = MDS_CLOSE_LAYOUT_SPLIT;
4095                 break;
4096         }
4097         case LL_LEASE_PCC_ATTACH:
4098                 if (ioc->lil_count != 1)
4099                         RETURN(-EINVAL);
4100
4101                 if (IS_ENCRYPTED(inode))
4102                         RETURN(-EOPNOTSUPP);
4103
4104                 uarg += sizeof(*ioc);
4105                 if (copy_from_user(&param.pa_archive_id, uarg, sizeof(__u32)))
4106                         GOTO(out_lease_close, rc2 = -EFAULT);
4107
4108                 rc2 = pcc_readwrite_attach(file, inode, param.pa_archive_id);
4109                 if (rc2)
4110                         GOTO(out_lease_close, rc2);
4111
4112                 attached = true;
4113                 /* Grab latest data version */
4114                 rc2 = ll_data_version(inode, &param.pa_data_version,
4115                                      LL_DV_WR_FLUSH);
4116                 if (rc2)
4117                         GOTO(out_lease_close, rc2);
4118
4119                 data = &param;
4120                 bias = MDS_PCC_ATTACH;
4121                 break;
4122         default:
4123                 /* without close intent */
4124                 break;
4125         }
4126
4127 out_lease_close:
4128         rc = ll_lease_close_intent(och, inode, &lease_broken, bias, data);
4129         if (rc < 0)
4130                 GOTO(out, rc);
4131
4132         rc = ll_lease_och_release(inode, file);
4133         if (rc < 0)
4134                 GOTO(out, rc);
4135
4136         if (lease_broken)
4137                 fmode = 0;
4138         EXIT;
4139
4140 out:
4141         if (ioc->lil_flags == LL_LEASE_RESYNC_DONE && data)
4142                 OBD_FREE(data, data_size);
4143
4144         if (layout_file)
4145                 fput(layout_file);
4146
4147         if (ioc->lil_flags == LL_LEASE_PCC_ATTACH) {
4148                 if (!rc)
4149                         rc = rc2;
4150                 rc = pcc_readwrite_attach_fini(file, inode,
4151                                                param.pa_layout_gen,
4152                                                lease_broken, rc,
4153                                                attached);
4154         }
4155
4156         ll_layout_refresh(inode, &fd->fd_layout_version);
4157
4158         if (!rc)
4159                 rc = ll_lease_type_from_fmode(fmode);
4160         RETURN(rc);
4161 }
4162
4163 static long ll_file_set_lease(struct file *file, struct ll_ioc_lease *ioc,
4164                               void __user *uarg)
4165 {
4166         struct inode *inode = file_inode(file);
4167         struct ll_inode_info *lli = ll_i2info(inode);
4168         struct ll_file_data *fd = file->private_data;
4169         struct obd_client_handle *och = NULL;
4170         __u64 open_flags = 0;
4171         bool lease_broken;
4172         fmode_t fmode;
4173         long rc;
4174         ENTRY;
4175
4176         switch (ioc->lil_mode) {
4177         case LL_LEASE_WRLCK:
4178                 if (!(file->f_mode & FMODE_WRITE))
4179                         RETURN(-EPERM);
4180                 fmode = FMODE_WRITE;
4181                 break;
4182         case LL_LEASE_RDLCK:
4183                 if (!(file->f_mode & FMODE_READ))
4184                         RETURN(-EPERM);
4185                 fmode = FMODE_READ;
4186                 break;
4187         case LL_LEASE_UNLCK:
4188                 RETURN(ll_file_unlock_lease(file, ioc, uarg));
4189         default:
4190                 RETURN(-EINVAL);
4191         }
4192
4193         CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
4194
4195         /* apply for lease */
4196         if (ioc->lil_flags & LL_LEASE_RESYNC)
4197                 open_flags = MDS_OPEN_RESYNC;
4198         och = ll_lease_open(inode, file, fmode, open_flags);
4199         if (IS_ERR(och))
4200                 RETURN(PTR_ERR(och));
4201
4202         if (ioc->lil_flags & LL_LEASE_RESYNC) {
4203                 rc = ll_lease_file_resync(och, inode, uarg);
4204                 if (rc) {
4205                         ll_lease_close(och, inode, NULL);
4206                         RETURN(rc);
4207                 }
4208                 rc = ll_layout_refresh(inode, &fd->fd_layout_version);
4209                 if (rc) {
4210                         ll_lease_close(och, inode, NULL);
4211                         RETURN(rc);
4212                 }
4213         }
4214
4215         rc = 0;
4216         mutex_lock(&lli->lli_och_mutex);
4217         if (fd->fd_lease_och == NULL) {
4218                 fd->fd_lease_och = och;
4219                 och = NULL;
4220         }
4221         mutex_unlock(&lli->lli_och_mutex);
4222         if (och != NULL) {
4223                 /* impossible now that only excl is supported for now */
4224                 ll_lease_close(och, inode, &lease_broken);
4225                 rc = -EBUSY;
4226         }
4227         RETURN(rc);
4228 }
4229
4230 static void ll_heat_get(struct inode *inode, struct lu_heat *heat)
4231 {
4232         struct ll_inode_info *lli = ll_i2info(inode);
4233         struct ll_sb_info *sbi = ll_i2sbi(inode);
4234         __u64 now = ktime_get_real_seconds();
4235         int i;
4236
4237         spin_lock(&lli->lli_heat_lock);
4238         heat->lh_flags = lli->lli_heat_flags;
4239         for (i = 0; i < heat->lh_count; i++)
4240                 heat->lh_heat[i] = obd_heat_get(&lli->lli_heat_instances[i],
4241                                                 now, sbi->ll_heat_decay_weight,
4242                                                 sbi->ll_heat_period_second);
4243         spin_unlock(&lli->lli_heat_lock);
4244 }
4245
4246 static int ll_heat_set(struct inode *inode, enum lu_heat_flag flags)
4247 {
4248         struct ll_inode_info *lli = ll_i2info(inode);
4249         int rc = 0;
4250
4251         spin_lock(&lli->lli_heat_lock);
4252         if (flags & LU_HEAT_FLAG_CLEAR)
4253                 obd_heat_clear(lli->lli_heat_instances, OBD_HEAT_COUNT);
4254
4255         if (flags & LU_HEAT_FLAG_OFF)
4256                 lli->lli_heat_flags |= LU_HEAT_FLAG_OFF;
4257         else
4258                 lli->lli_heat_flags &= ~LU_HEAT_FLAG_OFF;
4259
4260         spin_unlock(&lli->lli_heat_lock);
4261
4262         RETURN(rc);
4263 }
4264
4265 static long
4266 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
4267 {
4268         struct inode *inode = file_inode(file);
4269         struct ll_file_data *fd = file->private_data;
4270         void __user *uarg = (void __user *)arg;
4271         int flags, rc;
4272         ENTRY;
4273
4274         CDEBUG(D_VFSTRACE|D_IOCTL, "VFS Op:inode="DFID"(%pK) cmd=%x arg=%lx\n",
4275                PFID(ll_inode2fid(inode)), inode, cmd, arg);
4276         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
4277
4278         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
4279         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
4280                 RETURN(-ENOTTY);
4281
4282         /* can't do a generic karg == NULL check here, since it is too noisy and
4283          * we need to return -ENOTTY for unsupported ioctls instead of -EINVAL.
4284          */
4285         switch (cmd) {
4286         case LL_IOC_GETFLAGS:
4287                 /* Get the current value of the file flags */
4288                 return put_user(fd->fd_flags, (int __user *)arg);
4289         case LL_IOC_SETFLAGS:
4290         case LL_IOC_CLRFLAGS:
4291                 /* Set or clear specific file flags */
4292                 /* XXX This probably needs checks to ensure the flags are
4293                  *     not abused, and to handle any flag side effects.
4294                  */
4295                 if (get_user(flags, (int __user *)arg))
4296                         RETURN(-EFAULT);
4297
4298                 if (cmd == LL_IOC_SETFLAGS) {
4299                         if ((flags & LL_FILE_IGNORE_LOCK) &&
4300                             !(file->f_flags & O_DIRECT)) {
4301                                 rc = -EINVAL;
4302                                 CERROR("%s: unable to disable locking on non-O_DIRECT file "DFID": rc = %d\n",
4303                                        current->comm, PFID(ll_inode2fid(inode)),
4304                                        rc);
4305                                 RETURN(rc);
4306                         }
4307
4308                         fd->fd_flags |= flags;
4309                 } else {
4310                         fd->fd_flags &= ~flags;
4311                 }
4312                 RETURN(0);
4313         case LL_IOC_LOV_SETSTRIPE:
4314         case LL_IOC_LOV_SETSTRIPE_NEW:
4315                 RETURN(ll_lov_setstripe(inode, file, uarg));
4316         case LL_IOC_LOV_SETEA:
4317                 RETURN(ll_lov_setea(inode, file, uarg));
4318         case LL_IOC_LOV_SWAP_LAYOUTS: {
4319                 struct file *file2;
4320                 struct lustre_swap_layouts lsl;
4321
4322                 if (copy_from_user(&lsl, uarg, sizeof(lsl)))
4323                         RETURN(-EFAULT);
4324
4325                 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
4326                         RETURN(-EPERM);
4327
4328                 file2 = fget(lsl.sl_fd);
4329                 if (file2 == NULL)
4330                         RETURN(-EBADF);
4331
4332                 /* O_WRONLY or O_RDWR */
4333                 if ((file2->f_flags & O_ACCMODE) == O_RDONLY)
4334                         GOTO(out, rc = -EPERM);
4335
4336                 if (lsl.sl_flags & SWAP_LAYOUTS_CLOSE) {
4337                         struct obd_client_handle *och = NULL;
4338                         struct ll_inode_info *lli;
4339                         struct inode *inode2;
4340
4341                         lli = ll_i2info(inode);
4342                         mutex_lock(&lli->lli_och_mutex);
4343                         if (fd->fd_lease_och != NULL) {
4344                                 och = fd->fd_lease_och;
4345                                 fd->fd_lease_och = NULL;
4346                         }
4347                         mutex_unlock(&lli->lli_och_mutex);
4348                         if (och == NULL)
4349                                 GOTO(out, rc = -ENOLCK);
4350                         inode2 = file_inode(file2);
4351                         rc = ll_swap_layouts_close(och, inode, inode2);
4352                 } else {
4353                         rc = ll_swap_layouts(file, file2, &lsl);
4354                 }
4355 out:
4356                 fput(file2);
4357                 RETURN(rc);
4358         }
4359         case LL_IOC_LOV_GETSTRIPE:
4360         case LL_IOC_LOV_GETSTRIPE_NEW:
4361                 RETURN(ll_file_getstripe(inode, uarg, 0));
4362         case LL_IOC_GROUP_LOCK:
4363                 RETURN(ll_get_grouplock(inode, file, arg));
4364         case LL_IOC_GROUP_UNLOCK:
4365                 RETURN(ll_put_grouplock(inode, file, arg));
4366         case LL_IOC_DATA_VERSION: {
4367                 struct ioc_data_version idv;
4368                 int rc;
4369
4370                 if (copy_from_user(&idv, uarg, sizeof(idv)))
4371                         RETURN(-EFAULT);
4372
4373                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
4374                 rc = ll_ioc_data_version(inode, &idv);
4375
4376                 if (rc == 0 && copy_to_user(uarg, &idv, sizeof(idv)))
4377                         RETURN(-EFAULT);
4378
4379                 RETURN(rc);
4380         }
4381         case LL_IOC_HSM_STATE_GET: {
4382                 struct md_op_data *op_data;
4383                 struct hsm_user_state *hus;
4384                 int rc;
4385
4386                 if (!ll_access_ok(uarg, sizeof(*hus)))
4387                         RETURN(-EFAULT);
4388
4389                 OBD_ALLOC_PTR(hus);
4390                 if (hus == NULL)
4391                         RETURN(-ENOMEM);
4392
4393                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
4394                                              LUSTRE_OPC_ANY, hus);
4395                 if (IS_ERR(op_data)) {
4396                         rc = PTR_ERR(op_data);
4397                 } else {
4398                         rc = obd_iocontrol(cmd, ll_i2mdexp(inode),
4399                                            sizeof(*op_data), op_data, NULL);
4400
4401                         if (copy_to_user(uarg, hus, sizeof(*hus)))
4402                                 rc = -EFAULT;
4403
4404                         ll_finish_md_op_data(op_data);
4405                 }
4406                 OBD_FREE_PTR(hus);
4407                 RETURN(rc);
4408         }
4409         case LL_IOC_HSM_STATE_SET: {
4410                 struct hsm_state_set *hss;
4411                 int rc;
4412
4413                 OBD_ALLOC_PTR(hss);
4414                 if (hss == NULL)
4415                         RETURN(-ENOMEM);
4416
4417                 if (copy_from_user(hss, uarg, sizeof(*hss)))
4418                         rc = -EFAULT;
4419                 else
4420                         rc = ll_hsm_state_set(inode, hss);
4421
4422                 OBD_FREE_PTR(hss);
4423                 RETURN(rc);
4424         }
4425         case LL_IOC_HSM_ACTION: {
4426                 struct md_op_data *op_data;
4427                 struct hsm_current_action *hca;
4428                 const char *action;
4429                 int rc;
4430
4431                 if (!ll_access_ok(uarg, sizeof(*hca)))
4432                         RETURN(-EFAULT);
4433
4434                 OBD_ALLOC_PTR(hca);
4435                 if (hca == NULL)
4436                         RETURN(-ENOMEM);
4437
4438                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
4439                                              LUSTRE_OPC_ANY, hca);
4440                 if (IS_ERR(op_data)) {
4441                         OBD_FREE_PTR(hca);
4442                         RETURN(PTR_ERR(op_data));
4443                 }
4444
4445                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
4446                                    op_data, NULL);
4447                 if (rc < 0)
4448                         GOTO(skip_copy, rc);
4449
4450                 /* The hsm_current_action retreived from the server could
4451                  * contain corrupt information. If it is incorrect data collect
4452                  * debug information. We still send the data even if incorrect
4453                  * to user land to handle.
4454                  */
4455                 action = hsm_user_action2name(hca->hca_action);
4456                 if (strcmp(action, "UNKNOWN") == 0 ||
4457                     hca->hca_state > HPS_DONE) {
4458                         CDEBUG(D_HSM,
4459                                "HSM current state %s action %s, offset = %llu, length %llu\n",
4460                                hsm_progress_state2name(hca->hca_state), action,
4461                                hca->hca_location.offset, hca->hca_location.length);
4462                 }
4463
4464                 if (copy_to_user(uarg, hca, sizeof(*hca)))
4465                         rc = -EFAULT;
4466 skip_copy:
4467                 ll_finish_md_op_data(op_data);
4468                 OBD_FREE_PTR(hca);
4469                 RETURN(rc);
4470         }
4471         case LL_IOC_SET_LEASE_OLD: {
4472                 struct ll_ioc_lease ioc = { .lil_mode = arg };
4473
4474                 RETURN(ll_file_set_lease(file, &ioc, 0));
4475         }
4476         case LL_IOC_SET_LEASE: {
4477                 struct ll_ioc_lease ioc;
4478
4479                 if (copy_from_user(&ioc, uarg, sizeof(ioc)))
4480                         RETURN(-EFAULT);
4481
4482                 RETURN(ll_file_set_lease(file, &ioc, uarg));
4483         }
4484         case LL_IOC_GET_LEASE: {
4485                 struct ll_inode_info *lli = ll_i2info(inode);
4486                 struct ldlm_lock *lock = NULL;
4487                 fmode_t fmode = 0;
4488
4489                 mutex_lock(&lli->lli_och_mutex);
4490                 if (fd->fd_lease_och != NULL) {
4491                         struct obd_client_handle *och = fd->fd_lease_och;
4492
4493                         lock = ldlm_handle2lock(&och->och_lease_handle);
4494                         if (lock != NULL) {
4495                                 lock_res_and_lock(lock);
4496                                 if (!ldlm_is_cancel(lock))
4497                                         fmode = och->och_flags;
4498
4499                                 unlock_res_and_lock(lock);
4500                                 LDLM_LOCK_PUT(lock);
4501                         }
4502                 }
4503                 mutex_unlock(&lli->lli_och_mutex);
4504
4505                 RETURN(ll_lease_type_from_fmode(fmode));
4506         }
4507         case LL_IOC_HSM_IMPORT: {
4508                 struct hsm_user_import *hui;
4509
4510                 OBD_ALLOC_PTR(hui);
4511                 if (hui == NULL)
4512                         RETURN(-ENOMEM);
4513
4514                 if (copy_from_user(hui, uarg, sizeof(*hui)))
4515                         rc = -EFAULT;
4516                 else
4517                         rc = ll_hsm_import(inode, file, hui);
4518
4519                 OBD_FREE_PTR(hui);
4520                 RETURN(rc);
4521         }
4522         case LL_IOC_FUTIMES_3: {
4523                 struct ll_futimes_3 lfu;
4524
4525                 if (copy_from_user(&lfu, uarg, sizeof(lfu)))
4526                         RETURN(-EFAULT);
4527
4528                 RETURN(ll_file_futimes_3(file, &lfu));
4529         }
4530         case LL_IOC_LADVISE: {
4531                 struct llapi_ladvise_hdr *k_ladvise_hdr;
4532                 struct llapi_ladvise_hdr __user *u_ladvise_hdr;
4533                 int i;
4534                 int num_advise;
4535                 int alloc_size = sizeof(*k_ladvise_hdr);
4536
4537                 rc = 0;
4538                 u_ladvise_hdr = uarg;
4539                 OBD_ALLOC_PTR(k_ladvise_hdr);
4540                 if (k_ladvise_hdr == NULL)
4541                         RETURN(-ENOMEM);
4542
4543                 if (copy_from_user(k_ladvise_hdr, u_ladvise_hdr, alloc_size))
4544                         GOTO(out_ladvise, rc = -EFAULT);
4545
4546                 if (k_ladvise_hdr->lah_magic != LADVISE_MAGIC ||
4547                     k_ladvise_hdr->lah_count < 1)
4548                         GOTO(out_ladvise, rc = -EINVAL);
4549
4550                 num_advise = k_ladvise_hdr->lah_count;
4551                 if (num_advise >= LAH_COUNT_MAX)
4552                         GOTO(out_ladvise, rc = -EFBIG);
4553
4554                 OBD_FREE_PTR(k_ladvise_hdr);
4555                 alloc_size = offsetof(typeof(*k_ladvise_hdr),
4556                                       lah_advise[num_advise]);
4557                 OBD_ALLOC(k_ladvise_hdr, alloc_size);
4558                 if (k_ladvise_hdr == NULL)
4559                         RETURN(-ENOMEM);
4560
4561                 /*
4562                  * TODO: submit multiple advices to one server in a single RPC
4563                  */
4564                 if (copy_from_user(k_ladvise_hdr, u_ladvise_hdr, alloc_size))
4565                         GOTO(out_ladvise, rc = -EFAULT);
4566
4567                 for (i = 0; i < num_advise; i++) {
4568                         struct llapi_lu_ladvise *k_ladvise =
4569                                         &k_ladvise_hdr->lah_advise[i];
4570                         struct llapi_lu_ladvise __user *u_ladvise =
4571                                         &u_ladvise_hdr->lah_advise[i];
4572
4573                         rc = ll_ladvise_sanity(inode, k_ladvise);
4574                         if (rc)
4575                                 GOTO(out_ladvise, rc);
4576
4577                         switch (k_ladvise->lla_advice) {
4578                         case LU_LADVISE_LOCKNOEXPAND:
4579                                 rc = ll_lock_noexpand(file,
4580                                                k_ladvise->lla_peradvice_flags);
4581                                 GOTO(out_ladvise, rc);
4582                         case LU_LADVISE_LOCKAHEAD:
4583
4584                                 rc = ll_file_lock_ahead(file, k_ladvise);
4585
4586                                 if (rc < 0)
4587                                         GOTO(out_ladvise, rc);
4588
4589                                 if (put_user(rc,
4590                                              &u_ladvise->lla_lockahead_result))
4591                                         GOTO(out_ladvise, rc = -EFAULT);
4592                                 break;
4593                         default:
4594                                 rc = ll_ladvise(inode, file,
4595                                                 k_ladvise_hdr->lah_flags,
4596                                                 k_ladvise);
4597                                 if (rc)
4598                                         GOTO(out_ladvise, rc);
4599                                 break;
4600                         }
4601
4602                 }
4603
4604 out_ladvise:
4605                 OBD_FREE(k_ladvise_hdr, alloc_size);
4606                 RETURN(rc);
4607         }
4608         case LL_IOC_FLR_SET_MIRROR: {
4609                 /* mirror I/O must be direct to avoid polluting page cache
4610                  * by stale data. */
4611                 if (!(file->f_flags & O_DIRECT))
4612                         RETURN(-EINVAL);
4613
4614                 fd->fd_designated_mirror = arg;
4615                 RETURN(0);
4616         }
4617         case LL_IOC_HEAT_GET: {
4618                 struct lu_heat uheat;
4619                 struct lu_heat *heat;
4620                 int size;
4621
4622                 if (copy_from_user(&uheat, uarg, sizeof(uheat)))
4623                         RETURN(-EFAULT);
4624
4625                 if (uheat.lh_count > OBD_HEAT_COUNT)
4626                         uheat.lh_count = OBD_HEAT_COUNT;
4627
4628                 size = offsetof(typeof(uheat), lh_heat[uheat.lh_count]);
4629                 OBD_ALLOC(heat, size);
4630                 if (heat == NULL)
4631                         RETURN(-ENOMEM);
4632
4633                 heat->lh_count = uheat.lh_count;
4634                 ll_heat_get(inode, heat);
4635                 rc = copy_to_user(uarg, heat, size);
4636                 OBD_FREE(heat, size);
4637                 RETURN(rc ? -EFAULT : 0);
4638         }
4639         case LL_IOC_HEAT_SET: {
4640                 __u64 flags;
4641
4642                 if (copy_from_user(&flags, uarg, sizeof(flags)))
4643                         RETURN(-EFAULT);
4644
4645                 rc = ll_heat_set(inode, flags);
4646                 RETURN(rc);
4647         }
4648         case LL_IOC_PCC_DETACH: {
4649                 struct lu_pcc_detach *detach;
4650
4651                 OBD_ALLOC_PTR(detach);
4652                 if (detach == NULL)
4653                         RETURN(-ENOMEM);
4654
4655                 if (copy_from_user(detach, uarg, sizeof(*detach)))
4656                         GOTO(out_detach_free, rc = -EFAULT);
4657
4658                 if (!S_ISREG(inode->i_mode))
4659                         GOTO(out_detach_free, rc = -EINVAL);
4660
4661                 if (!inode_owner_or_capable(&nop_mnt_idmap, inode))
4662                         GOTO(out_detach_free, rc = -EPERM);
4663
4664                 rc = pcc_ioctl_detach(inode, detach->pccd_opt);
4665 out_detach_free:
4666                 OBD_FREE_PTR(detach);
4667                 RETURN(rc);
4668         }
4669         case LL_IOC_PCC_STATE: {
4670                 struct lu_pcc_state __user *ustate = uarg;
4671                 struct lu_pcc_state *state;
4672
4673                 OBD_ALLOC_PTR(state);
4674                 if (state == NULL)
4675                         RETURN(-ENOMEM);
4676
4677                 if (copy_from_user(state, ustate, sizeof(*state)))
4678                         GOTO(out_state, rc = -EFAULT);
4679
4680                 rc = pcc_ioctl_state(file, inode, state);
4681                 if (rc)
4682                         GOTO(out_state, rc);
4683
4684                 if (copy_to_user(ustate, state, sizeof(*state)))
4685                         GOTO(out_state, rc = -EFAULT);
4686
4687 out_state:
4688                 OBD_FREE_PTR(state);
4689                 RETURN(rc);
4690         }
4691         default:
4692                 rc = ll_iocontrol(inode, file, cmd, uarg);
4693                 if (rc != -ENOTTY)
4694                         RETURN(rc);
4695                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL, uarg));
4696         }
4697 }
4698
4699 static loff_t ll_lseek(struct file *file, loff_t offset, int whence)
4700 {
4701         struct inode *inode = file_inode(file);
4702         struct lu_env *env;
4703         struct cl_io *io;
4704         struct cl_lseek_io *lsio;
4705         __u16 refcheck;
4706         int rc;
4707         loff_t retval;
4708
4709         ENTRY;
4710
4711         env = cl_env_get(&refcheck);
4712         if (IS_ERR(env))
4713                 RETURN(PTR_ERR(env));
4714
4715         io = vvp_env_thread_io(env);
4716         io->ci_obj = ll_i2info(inode)->lli_clob;
4717         ll_io_set_mirror(io, file);
4718
4719         lsio = &io->u.ci_lseek;
4720         lsio->ls_start = offset;
4721         lsio->ls_whence = whence;
4722         lsio->ls_result = -ENXIO;
4723
4724         do {
4725                 rc = cl_io_init(env, io, CIT_LSEEK, io->ci_obj);
4726                 if (!rc) {
4727                         struct vvp_io *vio = vvp_env_io(env);
4728
4729                         vio->vui_fd = file->private_data;
4730                         rc = cl_io_loop(env, io);
4731                 } else {
4732                         rc = io->ci_result;
4733                 }
4734                 retval = rc ? : lsio->ls_result;
4735                 cl_io_fini(env, io);
4736         } while (unlikely(io->ci_need_restart));
4737
4738         cl_env_put(env, &refcheck);
4739
4740         /* Without the key, SEEK_HOLE return value has to be
4741          * rounded up to next LUSTRE_ENCRYPTION_UNIT_SIZE.
4742          */
4743         if (llcrypt_require_key(inode) == -ENOKEY && whence == SEEK_HOLE)
4744                 retval = round_up(retval, LUSTRE_ENCRYPTION_UNIT_SIZE);
4745
4746         RETURN(retval);
4747 }
4748
4749 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
4750 {
4751         struct inode *inode = file_inode(file);
4752         loff_t retval = offset, eof = 0;
4753         ktime_t kstart = ktime_get();
4754
4755         ENTRY;
4756
4757         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
4758                PFID(ll_inode2fid(inode)), inode, retval, retval,
4759                origin);
4760
4761         if (origin == SEEK_END) {
4762                 retval = ll_glimpse_size(inode);
4763                 if (retval != 0)
4764                         RETURN(retval);
4765                 eof = i_size_read(inode);
4766         }
4767
4768         if (origin == SEEK_HOLE || origin == SEEK_DATA) {
4769                 if (offset < 0)
4770                         return -ENXIO;
4771
4772                 /* flush local cache first if any */
4773                 cl_sync_file_range(inode, offset, OBD_OBJECT_EOF,
4774                                    CL_FSYNC_LOCAL, 0);
4775
4776                 retval = ll_lseek(file, offset, origin);
4777                 if (retval < 0)
4778                         return retval;
4779                 retval = vfs_setpos(file, retval, ll_file_maxbytes(inode));
4780         } else {
4781                 retval = generic_file_llseek_size(file, offset, origin,
4782                                                   ll_file_maxbytes(inode), eof);
4783         }
4784         if (retval >= 0)
4785                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK,
4786                                    ktime_us_delta(ktime_get(), kstart));
4787         RETURN(retval);
4788 }
4789
4790 static int ll_flush(struct file *file, fl_owner_t id)
4791 {
4792         struct inode *inode = file_inode(file);
4793         struct ll_inode_info *lli = ll_i2info(inode);
4794         struct ll_file_data *fd = file->private_data;
4795         int rc, err;
4796
4797         LASSERT(!S_ISDIR(inode->i_mode));
4798
4799         /* catch async errors that were recorded back when async writeback
4800          * failed for pages in this mapping. */
4801         rc = lli->lli_async_rc;
4802         lli->lli_async_rc = 0;
4803         if (lli->lli_clob != NULL) {
4804                 err = lov_read_and_clear_async_rc(lli->lli_clob);
4805                 if (rc == 0)
4806                         rc = err;
4807         }
4808
4809         /* The application has been told write failure already.
4810          * Do not report failure again. */
4811         if (fd->fd_write_failed)
4812                 return 0;
4813         return rc ? -EIO : 0;
4814 }
4815
4816 /**
4817  * Called to make sure a portion of file has been written out.
4818  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
4819  *
4820  * Return how many pages have been written.
4821  */
4822 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
4823                        enum cl_fsync_mode mode, int ignore_layout)
4824 {
4825         struct lu_env *env;
4826         struct cl_io *io;
4827         struct cl_fsync_io *fio;
4828         int result;
4829         __u16 refcheck;
4830         ENTRY;
4831
4832         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
4833             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL &&
4834             mode != CL_FSYNC_RECLAIM)
4835                 RETURN(-EINVAL);
4836
4837         env = cl_env_get(&refcheck);
4838         if (IS_ERR(env))
4839                 RETURN(PTR_ERR(env));
4840
4841         io = vvp_env_thread_io(env);
4842         io->ci_obj = ll_i2info(inode)->lli_clob;
4843         io->ci_ignore_layout = ignore_layout;
4844
4845         /* initialize parameters for sync */
4846         fio = &io->u.ci_fsync;
4847         fio->fi_start = start;
4848         fio->fi_end = end;
4849         fio->fi_fid = ll_inode2fid(inode);
4850         fio->fi_mode = mode;
4851         fio->fi_nr_written = 0;
4852
4853         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
4854                 result = cl_io_loop(env, io);
4855         else
4856                 result = io->ci_result;
4857         if (result == 0)
4858                 result = fio->fi_nr_written;
4859         cl_io_fini(env, io);
4860         cl_env_put(env, &refcheck);
4861
4862         RETURN(result);
4863 }
4864
4865 /*
4866  * When dentry is provided (the 'else' case), file_dentry() may be
4867  * null and dentry must be used directly rather than pulled from
4868  * file_dentry() as is done otherwise.
4869  */
4870
4871 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
4872 {
4873         struct dentry *dentry = file_dentry(file);
4874         struct inode *inode = dentry->d_inode;
4875         struct ll_inode_info *lli = ll_i2info(inode);
4876         struct ptlrpc_request *req;
4877         ktime_t kstart = ktime_get();
4878         int rc, err;
4879
4880         ENTRY;
4881
4882         CDEBUG(D_VFSTRACE,
4883                "VFS Op:inode="DFID"(%p), start %lld, end %lld, datasync %d\n",
4884                PFID(ll_inode2fid(inode)), inode, start, end, datasync);
4885
4886         /* fsync's caller has already called _fdata{sync,write}, we want
4887          * that IO to finish before calling the osc and mdc sync methods */
4888         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
4889
4890         /* catch async errors that were recorded back when async writeback
4891          * failed for pages in this mapping. */
4892         if (!S_ISDIR(inode->i_mode)) {
4893                 err = lli->lli_async_rc;
4894                 lli->lli_async_rc = 0;
4895                 if (rc == 0)
4896                         rc = err;
4897                 if (lli->lli_clob != NULL) {
4898                         err = lov_read_and_clear_async_rc(lli->lli_clob);
4899                         if (rc == 0)
4900                                 rc = err;
4901                 }
4902         }
4903
4904         if (S_ISREG(inode->i_mode) && !lli->lli_synced_to_mds) {
4905                 /*
4906                  * only the first sync on MDS makes sense,
4907                  * everything else is stored on OSTs
4908                  */
4909                 err = md_fsync(ll_i2sbi(inode)->ll_md_exp,
4910                                ll_inode2fid(inode), &req);
4911                 if (!rc)
4912                         rc = err;
4913                 if (!err) {
4914                         lli->lli_synced_to_mds = true;
4915                         ptlrpc_req_finished(req);
4916                 }
4917         }
4918
4919         if (S_ISREG(inode->i_mode)) {
4920                 struct ll_file_data *fd = file->private_data;
4921                 bool cached;
4922
4923                 /* Sync metadata on MDT first, and then sync the cached data
4924                  * on PCC.
4925                  */
4926                 err = pcc_fsync(file, start, end, datasync, &cached);
4927                 if (!cached)
4928                         err = cl_sync_file_range(inode, start, end,
4929                                                  CL_FSYNC_ALL, 0);
4930                 if (rc == 0 && err < 0)
4931                         rc = err;
4932                 if (rc < 0)
4933                         fd->fd_write_failed = true;
4934                 else
4935                         fd->fd_write_failed = false;
4936         }
4937
4938         if (!rc)
4939                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC,
4940                                    ktime_us_delta(ktime_get(), kstart));
4941         RETURN(rc);
4942 }
4943
4944 static int
4945 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
4946 {
4947         struct inode *inode = file_inode(file);
4948         struct ll_sb_info *sbi = ll_i2sbi(inode);
4949         struct ldlm_enqueue_info einfo = {
4950                 .ei_type        = LDLM_FLOCK,
4951                 .ei_cb_cp       = ldlm_flock_completion_ast,
4952                 .ei_cbdata      = file_lock,
4953         };
4954         struct md_op_data *op_data;
4955         struct lustre_handle lockh = { 0 };
4956         union ldlm_policy_data flock = { { 0 } };
4957         int fl_type = file_lock->fl_type;
4958         ktime_t kstart = ktime_get();
4959         __u64 flags = 0;
4960         int rc;
4961         int rc2 = 0;
4962         ENTRY;
4963
4964         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
4965                PFID(ll_inode2fid(inode)), file_lock);
4966
4967         if (file_lock->fl_flags & FL_FLOCK) {
4968                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
4969                 /* flocks are whole-file locks */
4970                 flock.l_flock.end = OFFSET_MAX;
4971                 /* For flocks owner is determined by the local file desctiptor*/
4972                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
4973         } else if (file_lock->fl_flags & FL_POSIX) {
4974                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
4975                 flock.l_flock.start = file_lock->fl_start;
4976                 flock.l_flock.end = file_lock->fl_end;
4977         } else {
4978                 RETURN(-EINVAL);
4979         }
4980         flock.l_flock.pid = file_lock->fl_pid;
4981
4982 #if defined(HAVE_LM_COMPARE_OWNER) || defined(lm_compare_owner)
4983         /* Somewhat ugly workaround for svc lockd.
4984          * lockd installs custom fl_lmops->lm_compare_owner that checks
4985          * for the fl_owner to be the same (which it always is on local node
4986          * I guess between lockd processes) and then compares pid.
4987          * As such we assign pid to the owner field to make it all work,
4988          * conflict with normal locks is unlikely since pid space and
4989          * pointer space for current->files are not intersecting */
4990         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
4991                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
4992 #endif
4993
4994         switch (fl_type) {
4995         case F_RDLCK:
4996                 einfo.ei_mode = LCK_PR;
4997                 break;
4998         case F_UNLCK:
4999                 /* An unlock request may or may not have any relation to
5000                  * existing locks so we may not be able to pass a lock handle
5001                  * via a normal ldlm_lock_cancel() request. The request may even
5002                  * unlock a byte range in the middle of an existing lock. In
5003                  * order to process an unlock request we need all of the same
5004                  * information that is given with a normal read or write record
5005                  * lock request. To avoid creating another ldlm unlock (cancel)
5006                  * message we'll treat a LCK_NL flock request as an unlock. */
5007                 einfo.ei_mode = LCK_NL;
5008                 break;
5009         case F_WRLCK:
5010                 einfo.ei_mode = LCK_PW;
5011                 break;
5012         default:
5013                 rc = -EINVAL;
5014                 CERROR("%s: fcntl from '%s' unknown lock type=%d: rc = %d\n",
5015                        sbi->ll_fsname, current->comm, fl_type, rc);
5016                 RETURN(rc);
5017         }
5018
5019         switch (cmd) {
5020         case F_SETLKW:
5021 #ifdef F_SETLKW64
5022         case F_SETLKW64:
5023 #endif
5024                 flags = 0;
5025                 break;
5026         case F_SETLK:
5027 #ifdef F_SETLK64
5028         case F_SETLK64:
5029 #endif
5030                 flags = LDLM_FL_BLOCK_NOWAIT;
5031                 break;
5032         case F_GETLK:
5033 #ifdef F_GETLK64
5034         case F_GETLK64:
5035 #endif
5036                 flags = LDLM_FL_TEST_LOCK;
5037                 break;
5038         default:
5039                 rc = -EINVAL;
5040                 CERROR("%s: fcntl from '%s' unknown lock command=%d: rc = %d\n",
5041                        sbi->ll_fsname, current->comm, cmd, rc);
5042                 RETURN(rc);
5043         }
5044
5045         /* Save the old mode so that if the mode in the lock changes we
5046          * can decrement the appropriate reader or writer refcount. */
5047         file_lock->fl_type = einfo.ei_mode;
5048
5049         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
5050                                      LUSTRE_OPC_ANY, NULL);
5051         if (IS_ERR(op_data))
5052                 RETURN(PTR_ERR(op_data));
5053
5054         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags=%#llx, mode=%u, "
5055                "start=%llu, end=%llu\n", PFID(ll_inode2fid(inode)),
5056                flock.l_flock.pid, flags, einfo.ei_mode,
5057                flock.l_flock.start, flock.l_flock.end);
5058
5059         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data, &lockh,
5060                         flags);
5061
5062         /* Restore the file lock type if not TEST lock. */
5063         if (!(flags & LDLM_FL_TEST_LOCK))
5064                 file_lock->fl_type = fl_type;
5065
5066 #ifdef HAVE_LOCKS_LOCK_FILE_WAIT
5067         if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
5068             !(flags & LDLM_FL_TEST_LOCK))
5069                 rc2  = locks_lock_file_wait(file, file_lock);
5070 #else
5071         if ((file_lock->fl_flags & FL_FLOCK) &&
5072             (rc == 0 || file_lock->fl_type == F_UNLCK))
5073                 rc2  = flock_lock_file_wait(file, file_lock);
5074         if ((file_lock->fl_flags & FL_POSIX) &&
5075             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
5076             !(flags & LDLM_FL_TEST_LOCK))
5077                 rc2  = posix_lock_file_wait(file, file_lock);
5078 #endif /* HAVE_LOCKS_LOCK_FILE_WAIT */
5079
5080         if (rc2 && file_lock->fl_type != F_UNLCK) {
5081                 einfo.ei_mode = LCK_NL;
5082                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data,
5083                            &lockh, flags);
5084                 rc = rc2;
5085         }
5086
5087         ll_finish_md_op_data(op_data);
5088
5089         if (!rc)
5090                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK,
5091                                    ktime_us_delta(ktime_get(), kstart));
5092         RETURN(rc);
5093 }
5094
5095 int ll_get_fid_by_name(struct inode *parent, const char *name,
5096                        int namelen, struct lu_fid *fid,
5097                        struct inode **inode)
5098 {
5099         struct md_op_data *op_data = NULL;
5100         struct mdt_body *body;
5101         struct ptlrpc_request *req;
5102         int rc;
5103         ENTRY;
5104
5105         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
5106                                      LUSTRE_OPC_ANY, NULL);
5107         if (IS_ERR(op_data))
5108                 RETURN(PTR_ERR(op_data));
5109
5110         op_data->op_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
5111         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
5112         ll_finish_md_op_data(op_data);
5113         if (rc < 0)
5114                 RETURN(rc);
5115
5116         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
5117         if (body == NULL)
5118                 GOTO(out_req, rc = -EFAULT);
5119         if (fid != NULL)
5120                 *fid = body->mbo_fid1;
5121
5122         if (inode != NULL)
5123                 rc = ll_prep_inode(inode, &req->rq_pill, parent->i_sb, NULL);
5124 out_req:
5125         ptlrpc_req_finished(req);
5126         RETURN(rc);
5127 }
5128
5129 int ll_migrate(struct inode *parent, struct file *file, struct lmv_user_md *lum,
5130                const char *name, __u32 flags)
5131 {
5132         struct dentry *dchild = NULL;
5133         struct inode *child_inode = NULL;
5134         struct md_op_data *op_data;
5135         struct ptlrpc_request *request = NULL;
5136         struct obd_client_handle *och = NULL;
5137         struct qstr qstr;
5138         struct mdt_body *body;
5139         __u64 data_version = 0;
5140         size_t namelen = strlen(name);
5141         int lumlen = lmv_user_md_size(lum->lum_stripe_count, lum->lum_magic);
5142         int rc;
5143         ENTRY;
5144
5145         CDEBUG(D_VFSTRACE, "migrate "DFID"/%s to MDT%04x stripe count %d\n",
5146                PFID(ll_inode2fid(parent)), name,
5147                lum->lum_stripe_offset, lum->lum_stripe_count);
5148
5149         if (lum->lum_magic != cpu_to_le32(LMV_USER_MAGIC) &&
5150             lum->lum_magic != cpu_to_le32(LMV_USER_MAGIC_SPECIFIC))
5151                 lustre_swab_lmv_user_md(lum);
5152
5153         /* Get child FID first */
5154         qstr.hash = ll_full_name_hash(file_dentry(file), name, namelen);
5155         qstr.name = name;
5156         qstr.len = namelen;
5157         dchild = d_lookup(file_dentry(file), &qstr);
5158         if (dchild) {
5159                 if (dchild->d_inode)
5160                         child_inode = igrab(dchild->d_inode);
5161                 dput(dchild);
5162         }
5163
5164         if (!child_inode) {
5165                 rc = ll_get_fid_by_name(parent, name, namelen, NULL,
5166                                         &child_inode);
5167                 if (rc)
5168                         RETURN(rc);
5169         }
5170
5171         if (!child_inode)
5172                 RETURN(-ENOENT);
5173
5174         if (!(exp_connect_flags2(ll_i2sbi(parent)->ll_md_exp) &
5175               OBD_CONNECT2_DIR_MIGRATE)) {
5176                 if (le32_to_cpu(lum->lum_stripe_count) > 1 ||
5177                     ll_dir_striped(child_inode)) {
5178                         CERROR("%s: MDT doesn't support stripe directory "
5179                                "migration!\n", ll_i2sbi(parent)->ll_fsname);
5180                         GOTO(out_iput, rc = -EOPNOTSUPP);
5181                 }
5182         }
5183
5184         /*
5185          * lfs migrate command needs to be blocked on the client
5186          * by checking the migrate FID against the FID of the
5187          * filesystem root.
5188          */
5189         if (is_root_inode(child_inode))
5190                 GOTO(out_iput, rc = -EINVAL);
5191
5192         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
5193                                      child_inode->i_mode, LUSTRE_OPC_ANY, NULL);
5194         if (IS_ERR(op_data))
5195                 GOTO(out_iput, rc = PTR_ERR(op_data));
5196
5197         ll_inode_lock(child_inode);
5198         op_data->op_fid3 = *ll_inode2fid(child_inode);
5199         if (!fid_is_sane(&op_data->op_fid3)) {
5200                 CERROR("%s: migrate %s, but FID "DFID" is insane\n",
5201                        ll_i2sbi(parent)->ll_fsname, name,
5202                        PFID(&op_data->op_fid3));
5203                 GOTO(out_unlock, rc = -EINVAL);
5204         }
5205
5206         op_data->op_cli_flags |= CLI_MIGRATE | CLI_SET_MEA;
5207         op_data->op_data = lum;
5208         op_data->op_data_size = lumlen;
5209
5210         /* migrate dirent only for subdirs if MDS_MIGRATE_NSONLY set */
5211         if (S_ISDIR(child_inode->i_mode) && (flags & MDS_MIGRATE_NSONLY) &&
5212             lmv_dir_layout_changing(op_data->op_lso1))
5213                 op_data->op_bias |= MDS_MIGRATE_NSONLY;
5214
5215 again:
5216         if (S_ISREG(child_inode->i_mode)) {
5217                 och = ll_lease_open(child_inode, NULL, FMODE_WRITE, 0);
5218                 if (IS_ERR(och)) {
5219                         rc = PTR_ERR(och);
5220                         och = NULL;
5221                         GOTO(out_unlock, rc);
5222                 }
5223
5224                 rc = ll_data_version(child_inode, &data_version,
5225                                      LL_DV_WR_FLUSH);
5226                 if (rc != 0)
5227                         GOTO(out_close, rc);
5228
5229                 op_data->op_open_handle = och->och_open_handle;
5230                 op_data->op_data_version = data_version;
5231                 op_data->op_lease_handle = och->och_lease_handle;
5232                 op_data->op_bias |= MDS_CLOSE_MIGRATE;
5233
5234                 spin_lock(&och->och_mod->mod_open_req->rq_lock);
5235                 och->och_mod->mod_open_req->rq_replay = 0;
5236                 spin_unlock(&och->och_mod->mod_open_req->rq_lock);
5237         }
5238
5239         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data,
5240                        op_data->op_name, op_data->op_namelen,
5241                        op_data->op_name, op_data->op_namelen, &request);
5242         if (rc == 0) {
5243                 LASSERT(request != NULL);
5244                 ll_update_times(request, parent);
5245         }
5246
5247         if (rc == 0 || rc == -EAGAIN) {
5248                 body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
5249                 LASSERT(body != NULL);
5250
5251                 /* If the server does release layout lock, then we cleanup
5252                  * the client och here, otherwise release it in out_close: */
5253                 if (och && body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED) {
5254                         obd_mod_put(och->och_mod);
5255                         md_clear_open_replay_data(ll_i2sbi(parent)->ll_md_exp,
5256                                                   och);
5257                         och->och_open_handle.cookie = DEAD_HANDLE_MAGIC;
5258                         OBD_FREE_PTR(och);
5259                         och = NULL;
5260                 }
5261         }
5262
5263         if (request != NULL) {
5264                 ptlrpc_req_finished(request);
5265                 request = NULL;
5266         }
5267
5268         /* Try again if the lease has cancelled. */
5269         if (rc == -EAGAIN && S_ISREG(child_inode->i_mode))
5270                 goto again;
5271
5272 out_close:
5273         if (och)
5274                 ll_lease_close(och, child_inode, NULL);
5275         if (!rc)
5276                 clear_nlink(child_inode);
5277 out_unlock:
5278         ll_inode_unlock(child_inode);
5279         ll_finish_md_op_data(op_data);
5280 out_iput:
5281         iput(child_inode);
5282         RETURN(rc);
5283 }
5284
5285 static int
5286 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
5287 {
5288         struct ll_file_data *fd = file->private_data;
5289         ENTRY;
5290
5291         /*
5292          * In order to avoid flood of warning messages, only print one message
5293          * for one file. And the entire message rate on the client is limited
5294          * by CDEBUG_LIMIT too.
5295          */
5296         if (!(fd->fd_flags & LL_FILE_FLOCK_WARNING)) {
5297                 fd->fd_flags |= LL_FILE_FLOCK_WARNING;
5298                 CDEBUG_LIMIT(D_CONSOLE,
5299                              "flock disabled, mount with '-o [local]flock' to enable\r\n");
5300         }
5301         RETURN(-ENOSYS);
5302 }
5303
5304 /**
5305  * test if some locks matching bits and l_req_mode are acquired
5306  * - bits can be in different locks
5307  * - if found clear the common lock bits in *bits
5308  * - the bits not found, are kept in *bits
5309  * \param inode [IN]
5310  * \param bits [IN] searched lock bits [IN]
5311  * \param l_req_mode [IN] searched lock mode
5312  * \retval boolean, true iff all bits are found
5313  */
5314 int ll_have_md_lock(struct obd_export *exp, struct inode *inode, __u64 *bits,
5315                     enum ldlm_mode l_req_mode)
5316 {
5317         struct lustre_handle lockh;
5318         union ldlm_policy_data policy;
5319         enum ldlm_mode mode = (l_req_mode == LCK_MINMODE) ?
5320                               (LCK_CR | LCK_CW | LCK_PR | LCK_PW) : l_req_mode;
5321         struct lu_fid *fid;
5322         __u64 flags;
5323         int i;
5324         ENTRY;
5325
5326         if (!inode)
5327                RETURN(0);
5328
5329         fid = &ll_i2info(inode)->lli_fid;
5330         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
5331                ldlm_lockname[mode]);
5332
5333         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
5334         for (i = 0; i < MDS_INODELOCK_NUMBITS && *bits != 0; i++) {
5335                 policy.l_inodebits.bits = *bits & BIT(i);
5336                 if (policy.l_inodebits.bits == 0)
5337                         continue;
5338
5339                 if (md_lock_match(exp, flags, fid, LDLM_IBITS, &policy, mode,
5340                                   &lockh)) {
5341                         struct ldlm_lock *lock;
5342
5343                         lock = ldlm_handle2lock(&lockh);
5344                         if (lock) {
5345                                 *bits &=
5346                                         ~(lock->l_policy_data.l_inodebits.bits);
5347                                 LDLM_LOCK_PUT(lock);
5348                         } else {
5349                                 *bits &= ~policy.l_inodebits.bits;
5350                         }
5351                 }
5352         }
5353         RETURN(*bits == 0);
5354 }
5355
5356 enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
5357                                struct lustre_handle *lockh, __u64 flags,
5358                                enum ldlm_mode mode)
5359 {
5360         union ldlm_policy_data policy = { .l_inodebits = { bits } };
5361         struct lu_fid *fid;
5362         enum ldlm_mode rc;
5363         ENTRY;
5364
5365         fid = &ll_i2info(inode)->lli_fid;
5366         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
5367
5368         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
5369                            fid, LDLM_IBITS, &policy, mode, lockh);
5370
5371         RETURN(rc);
5372 }
5373
5374 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
5375 {
5376         /* Already unlinked. Just update nlink and return success */
5377         if (rc == -ENOENT) {
5378                 clear_nlink(inode);
5379                 /* If it is striped directory, and there is bad stripe
5380                  * Let's revalidate the dentry again, instead of returning
5381                  * error */
5382                 if (ll_dir_striped(inode))
5383                         return 0;
5384
5385                 /* This path cannot be hit for regular files unless in
5386                  * case of obscure races, so no need to to validate
5387                  * size. */
5388                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
5389                         return 0;
5390         } else if (rc != 0) {
5391                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
5392                              "%s: revalidate FID "DFID" error: rc = %d\n",
5393                              ll_i2sbi(inode)->ll_fsname,
5394                              PFID(ll_inode2fid(inode)), rc);
5395         }
5396
5397         return rc;
5398 }
5399
5400 static int ll_inode_revalidate(struct dentry *dentry, enum ldlm_intent_flags op)
5401 {
5402         struct inode *parent;
5403         struct inode *inode = dentry->d_inode;
5404         struct obd_export *exp = ll_i2mdexp(inode);
5405         struct lookup_intent oit = {
5406                 .it_op = op,
5407         };
5408         struct ptlrpc_request *req = NULL;
5409         struct md_op_data *op_data;
5410         const char *name = NULL;
5411         size_t namelen = 0;
5412         int rc = 0;
5413         ENTRY;
5414
5415         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
5416                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
5417
5418         if (exp_connect_flags2(exp) & OBD_CONNECT2_GETATTR_PFID) {
5419                 parent = dentry->d_parent->d_inode;
5420                 name = dentry->d_name.name;
5421                 namelen = dentry->d_name.len;
5422         } else {
5423                 parent = inode;
5424         }
5425
5426         op_data = ll_prep_md_op_data(NULL, parent, inode, name, namelen, 0,
5427                                      LUSTRE_OPC_ANY, NULL);
5428         if (IS_ERR(op_data))
5429                 RETURN(PTR_ERR(op_data));
5430
5431         /* Call getattr by fid */
5432         if (exp_connect_flags2(exp) & OBD_CONNECT2_GETATTR_PFID)
5433                 op_data->op_flags = MF_GETATTR_BY_FID;
5434         rc = md_intent_lock(exp, op_data, &oit, &req, &ll_md_blocking_ast, 0);
5435         ll_finish_md_op_data(op_data);
5436         if (rc < 0) {
5437                 rc = ll_inode_revalidate_fini(inode, rc);
5438                 GOTO(out, rc);
5439         }
5440
5441         rc = ll_revalidate_it_finish(req, &oit, dentry);
5442         if (rc != 0) {
5443                 ll_intent_release(&oit);
5444                 GOTO(out, rc);
5445         }
5446
5447         /* Unlinked? Unhash dentry, so it is not picked up later by
5448          * do_lookup() -> ll_revalidate_it(). We cannot use d_drop
5449          * here to preserve get_cwd functionality on 2.6.
5450          * Bug 10503 */
5451         if (!dentry->d_inode->i_nlink)
5452                 d_lustre_invalidate(dentry);
5453
5454         ll_lookup_finish_locks(&oit, dentry);
5455 out:
5456         ptlrpc_req_finished(req);
5457
5458         return rc;
5459 }
5460
5461 static int ll_merge_md_attr(struct inode *inode)
5462 {
5463         struct ll_inode_info *lli = ll_i2info(inode);
5464         struct lmv_stripe_object *lsm_obj;
5465         struct cl_attr attr = { 0 };
5466         int rc;
5467
5468         if (!ll_dir_striped(inode))
5469                 RETURN(0);
5470
5471         down_read(&lli->lli_lsm_sem);
5472         LASSERT(lli->lli_lsm_obj != NULL);
5473
5474         lsm_obj = lmv_stripe_object_get(lli->lli_lsm_obj);
5475         up_read(&lli->lli_lsm_sem);
5476
5477         rc = md_merge_attr(ll_i2mdexp(inode), lsm_obj,
5478                            &attr, ll_md_blocking_ast);
5479         lmv_stripe_object_put(&lsm_obj);
5480         if (rc != 0)
5481                 RETURN(rc);
5482
5483         spin_lock(&inode->i_lock);
5484         set_nlink(inode, attr.cat_nlink);
5485         spin_unlock(&inode->i_lock);
5486
5487         inode->i_blocks = attr.cat_blocks;
5488         i_size_write(inode, attr.cat_size);
5489
5490         ll_i2info(inode)->lli_atime = attr.cat_atime;
5491         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
5492         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
5493
5494         RETURN(0);
5495 }
5496
5497 int ll_getattr_dentry(struct dentry *de, struct kstat *stat, u32 request_mask,
5498                       unsigned int flags, bool foreign)
5499 {
5500         struct inode *inode = de->d_inode;
5501         struct ll_sb_info *sbi = ll_i2sbi(inode);
5502         struct ll_inode_info *lli = ll_i2info(inode);
5503         struct inode *dir = de->d_parent->d_inode;
5504         bool need_glimpse = true;
5505         ktime_t kstart = ktime_get();
5506         int rc;
5507
5508         /* The OST object(s) determine the file size, blocks and mtime. */
5509         if (!(request_mask & STATX_SIZE || request_mask & STATX_BLOCKS ||
5510               request_mask & STATX_MTIME))
5511                 need_glimpse = false;
5512
5513         if (dentry_may_statahead(dir, de))
5514                 ll_start_statahead(dir, de, need_glimpse &&
5515                                    !(flags & AT_STATX_DONT_SYNC));
5516
5517         if (flags & AT_STATX_DONT_SYNC)
5518                 GOTO(fill_attr, rc = 0);
5519
5520         rc = ll_inode_revalidate(de, IT_GETATTR);
5521         if (rc < 0)
5522                 RETURN(rc);
5523
5524         /* foreign file/dir are always of zero length, so don't
5525          * need to validate size.
5526          */
5527         if (S_ISREG(inode->i_mode) && !foreign) {
5528                 bool cached;
5529
5530                 if (!need_glimpse)
5531                         GOTO(fill_attr, rc);
5532
5533                 rc = pcc_inode_getattr(inode, request_mask, flags, &cached);
5534                 if (cached && rc < 0)
5535                         RETURN(rc);
5536
5537                 if (cached)
5538                         GOTO(fill_attr, rc);
5539
5540                 /*
5541                  * If the returned attr is masked with OBD_MD_FLSIZE &
5542                  * OBD_MD_FLBLOCKS & OBD_MD_FLMTIME, it means that the file size
5543                  * or blocks obtained from MDT is strictly correct, and the file
5544                  * is usually not being modified by clients, and the [a|m|c]time
5545                  * got from MDT is also strictly correct.
5546                  * Under this circumstance, it does not need to send glimpse
5547                  * RPCs to OSTs for file attributes such as the size and blocks.
5548                  */
5549                 if (lli->lli_attr_valid & OBD_MD_FLSIZE &&
5550                     lli->lli_attr_valid & OBD_MD_FLBLOCKS &&
5551                     lli->lli_attr_valid & OBD_MD_FLMTIME) {
5552                         inode->i_mtime.tv_sec = lli->lli_mtime;
5553                         if (lli->lli_attr_valid & OBD_MD_FLATIME)
5554                                 inode->i_atime.tv_sec = lli->lli_atime;
5555                         if (lli->lli_attr_valid & OBD_MD_FLCTIME)
5556                                 inode->i_ctime.tv_sec = lli->lli_ctime;
5557                         GOTO(fill_attr, rc);
5558                 }
5559
5560                 /* In case of restore, the MDT has the right size and has
5561                  * already send it back without granting the layout lock,
5562                  * inode is up-to-date so glimpse is useless.
5563                  * Also to glimpse we need the layout, in case of a running
5564                  * restore the MDT holds the layout lock so the glimpse will
5565                  * block up to the end of restore (getattr will block)
5566                  */
5567                 if (!test_bit(LLIF_FILE_RESTORING, &lli->lli_flags)) {
5568                         rc = ll_glimpse_size(inode);
5569                         if (rc < 0)
5570                                 RETURN(rc);
5571                 }
5572         } else {
5573                 /* If object isn't regular a file then don't validate size. */
5574                 /* foreign dir is not striped dir */
5575                 if (!foreign) {
5576                         rc = ll_merge_md_attr(inode);
5577                         if (rc < 0)
5578                                 RETURN(rc);
5579                 }
5580
5581                 if (lli->lli_attr_valid & OBD_MD_FLATIME)
5582                         inode->i_atime.tv_sec = lli->lli_atime;
5583                 if (lli->lli_attr_valid & OBD_MD_FLMTIME)
5584                         inode->i_mtime.tv_sec = lli->lli_mtime;
5585                 if (lli->lli_attr_valid & OBD_MD_FLCTIME)
5586                         inode->i_ctime.tv_sec = lli->lli_ctime;
5587         }
5588
5589 fill_attr:
5590         CFS_FAIL_TIMEOUT(OBD_FAIL_GETATTR_DELAY, 30);
5591
5592         if (ll_need_32bit_api(sbi)) {
5593                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
5594                 stat->dev = ll_compat_encode_dev(inode->i_sb->s_dev);
5595                 stat->rdev = ll_compat_encode_dev(inode->i_rdev);
5596         } else {
5597                 stat->ino = inode->i_ino;
5598                 stat->dev = inode->i_sb->s_dev;
5599                 stat->rdev = inode->i_rdev;
5600         }
5601
5602         /* foreign symlink to be exposed as a real symlink */
5603         if (!foreign)
5604                 stat->mode = inode->i_mode;
5605         else
5606                 stat->mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
5607
5608         stat->uid = inode->i_uid;
5609         stat->gid = inode->i_gid;
5610         stat->atime = inode->i_atime;
5611         stat->mtime = inode->i_mtime;
5612         stat->ctime = inode->i_ctime;
5613         /* stat->blksize is used to tell about preferred IO size */
5614         if (sbi->ll_stat_blksize)
5615                 stat->blksize = sbi->ll_stat_blksize;
5616         else if (S_ISREG(inode->i_mode))
5617                 stat->blksize = min(PTLRPC_MAX_BRW_SIZE,
5618                                     1U << LL_MAX_BLKSIZE_BITS);
5619         else if (S_ISDIR(inode->i_mode))
5620                 stat->blksize = min(MD_MAX_BRW_SIZE,
5621                                     1U << LL_MAX_BLKSIZE_BITS);
5622         else
5623                 stat->blksize = 1 << inode->i_sb->s_blocksize_bits;
5624
5625         stat->nlink = inode->i_nlink;
5626         stat->size = i_size_read(inode);
5627         stat->blocks = inode->i_blocks;
5628
5629 #if defined(HAVE_USER_NAMESPACE_ARG) || defined(HAVE_INODEOPS_ENHANCED_GETATTR)
5630         if (flags & AT_STATX_DONT_SYNC) {
5631                 if (stat->size == 0 &&
5632                     lli->lli_attr_valid & OBD_MD_FLLAZYSIZE)
5633                         stat->size = lli->lli_lazysize;
5634                 if (stat->blocks == 0 &&
5635                     lli->lli_attr_valid & OBD_MD_FLLAZYBLOCKS)
5636                         stat->blocks = lli->lli_lazyblocks;
5637         }
5638
5639         if (lli->lli_attr_valid & OBD_MD_FLBTIME) {
5640                 stat->result_mask |= STATX_BTIME;
5641                 stat->btime.tv_sec = lli->lli_btime;
5642         }
5643
5644         stat->attributes_mask = STATX_ATTR_IMMUTABLE | STATX_ATTR_APPEND;
5645 #ifdef HAVE_LUSTRE_CRYPTO
5646         stat->attributes_mask |= STATX_ATTR_ENCRYPTED;
5647 #endif
5648         stat->attributes |= ll_inode_to_ext_flags(inode->i_flags);
5649         /* if Lustre specific LUSTRE_ENCRYPT_FL flag is set, also set
5650          * ext4 equivalent to please statx
5651          */
5652         if (stat->attributes & LUSTRE_ENCRYPT_FL)
5653                 stat->attributes |= STATX_ATTR_ENCRYPTED;
5654         stat->result_mask &= request_mask;
5655 #endif
5656
5657         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR,
5658                            ktime_us_delta(ktime_get(), kstart));
5659
5660         return 0;
5661 }
5662
5663 #if defined(HAVE_USER_NAMESPACE_ARG) || defined(HAVE_INODEOPS_ENHANCED_GETATTR)
5664 int ll_getattr(struct mnt_idmap *map, const struct path *path,
5665                struct kstat *stat, u32 request_mask, unsigned int flags)
5666 {
5667         return ll_getattr_dentry(path->dentry, stat, request_mask, flags,
5668                                  false);
5669 }
5670 #else
5671 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
5672 {
5673         return ll_getattr_dentry(de, stat, STATX_BASIC_STATS,
5674                                  AT_STATX_SYNC_AS_STAT, false);
5675 }
5676 #endif
5677
5678 static int cl_falloc(struct file *file, struct inode *inode, int mode,
5679                      loff_t offset, loff_t len)
5680 {
5681         loff_t size = i_size_read(inode);
5682         struct lu_env *env;
5683         struct cl_io *io;
5684         __u16 refcheck;
5685         int rc;
5686
5687         ENTRY;
5688
5689         env = cl_env_get(&refcheck);
5690         if (IS_ERR(env))
5691                 RETURN(PTR_ERR(env));
5692
5693         io = vvp_env_thread_io(env);
5694         io->ci_obj = ll_i2info(inode)->lli_clob;
5695         ll_io_set_mirror(io, file);
5696
5697         io->ci_verify_layout = 1;
5698         io->u.ci_setattr.sa_parent_fid = lu_object_fid(&io->ci_obj->co_lu);
5699         io->u.ci_setattr.sa_falloc_mode = mode;
5700         io->u.ci_setattr.sa_falloc_offset = offset;
5701         io->u.ci_setattr.sa_falloc_end = offset + len;
5702         io->u.ci_setattr.sa_subtype = CL_SETATTR_FALLOCATE;
5703
5704         CDEBUG(D_INODE, "UID %u GID %u PRJID %u\n",
5705                from_kuid(&init_user_ns, inode->i_uid),
5706                from_kgid(&init_user_ns, inode->i_gid),
5707                ll_i2info(inode)->lli_projid);
5708
5709         io->u.ci_setattr.sa_falloc_uid = from_kuid(&init_user_ns, inode->i_uid);
5710         io->u.ci_setattr.sa_falloc_gid = from_kgid(&init_user_ns, inode->i_gid);
5711         io->u.ci_setattr.sa_falloc_projid = ll_i2info(inode)->lli_projid;
5712
5713         if (io->u.ci_setattr.sa_falloc_end > size) {
5714                 loff_t newsize = io->u.ci_setattr.sa_falloc_end;
5715
5716                 /* Check new size against VFS/VM file size limit and rlimit */
5717                 rc = inode_newsize_ok(inode, newsize);
5718                 if (rc)
5719                         goto out;
5720                 if (newsize > ll_file_maxbytes(inode)) {
5721                         CDEBUG(D_INODE, "file size too large %llu > %llu\n",
5722                                (unsigned long long)newsize,
5723                                ll_file_maxbytes(inode));
5724                         rc = -EFBIG;
5725                         goto out;
5726                 }
5727         }
5728
5729         do {
5730                 rc = cl_io_init(env, io, CIT_SETATTR, io->ci_obj);
5731                 if (!rc)
5732                         rc = cl_io_loop(env, io);
5733                 else
5734                         rc = io->ci_result;
5735                 cl_io_fini(env, io);
5736         } while (unlikely(io->ci_need_restart));
5737
5738 out:
5739         cl_env_put(env, &refcheck);
5740         RETURN(rc);
5741 }
5742
5743 static long ll_fallocate(struct file *filp, int mode, loff_t offset, loff_t len)
5744 {
5745         struct inode *inode = file_inode(filp);
5746         int rc;
5747
5748         if (offset < 0 || len <= 0)
5749                 RETURN(-EINVAL);
5750         /*
5751          * Encrypted inodes can't handle collapse range or zero range or insert
5752          * range since we would need to re-encrypt blocks with a different IV or
5753          * XTS tweak (which are based on the logical block number).
5754          * Similar to what ext4 does.
5755          */
5756         if (IS_ENCRYPTED(inode) &&
5757             (mode & (FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE |
5758                      FALLOC_FL_ZERO_RANGE)))
5759                 RETURN(-EOPNOTSUPP);
5760
5761         /*
5762          * mode == 0 (which is standard prealloc) and PUNCH is supported
5763          * Rest of mode options are not supported yet.
5764          */
5765         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
5766                 RETURN(-EOPNOTSUPP);
5767
5768         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FALLOCATE, 1);
5769
5770         rc = cl_falloc(filp, inode, mode, offset, len);
5771         /*
5772          * ENOTSUPP (524) is an NFSv3 specific error code erroneously
5773          * used by Lustre in several places. Retuning it here would
5774          * confuse applications that explicity test for EOPNOTSUPP
5775          * (95) and fall back to ftruncate().
5776          */
5777         if (rc == -ENOTSUPP)
5778                 rc = -EOPNOTSUPP;
5779
5780         RETURN(rc);
5781 }
5782
5783 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
5784                      __u64 start, __u64 len)
5785 {
5786         int             rc;
5787         size_t          num_bytes;
5788         struct fiemap   *fiemap;
5789         unsigned int    extent_count = fieinfo->fi_extents_max;
5790
5791         num_bytes = sizeof(*fiemap) + (extent_count *
5792                                        sizeof(struct fiemap_extent));
5793         OBD_ALLOC_LARGE(fiemap, num_bytes);
5794
5795         if (fiemap == NULL)
5796                 RETURN(-ENOMEM);
5797
5798         fiemap->fm_flags = fieinfo->fi_flags;
5799         fiemap->fm_extent_count = fieinfo->fi_extents_max;
5800         fiemap->fm_start = start;
5801         fiemap->fm_length = len;
5802         if (extent_count > 0 &&
5803             copy_from_user(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
5804                            sizeof(struct fiemap_extent)) != 0)
5805                 GOTO(out, rc = -EFAULT);
5806
5807         rc = ll_do_fiemap(inode, fiemap, num_bytes);
5808
5809         if (IS_ENCRYPTED(inode) && extent_count > 0) {
5810                 int i;
5811
5812                 for (i = 0; i < fiemap->fm_mapped_extents; i++)
5813                         fiemap->fm_extents[i].fe_flags |=
5814                                 FIEMAP_EXTENT_DATA_ENCRYPTED |
5815                                 FIEMAP_EXTENT_ENCODED;
5816         }
5817
5818         fieinfo->fi_flags = fiemap->fm_flags;
5819         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
5820         if (extent_count > 0 &&
5821             copy_to_user(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
5822                          fiemap->fm_mapped_extents *
5823                          sizeof(struct fiemap_extent)) != 0)
5824                 GOTO(out, rc = -EFAULT);
5825 out:
5826         OBD_FREE_LARGE(fiemap, num_bytes);
5827         return rc;
5828 }
5829
5830 int ll_inode_permission(struct mnt_idmap *idmap, struct inode *inode, int mask)
5831 {
5832         int rc = 0;
5833         struct ll_sb_info *sbi;
5834         struct root_squash_info *squash;
5835         struct cred *cred = NULL;
5836         const struct cred *old_cred = NULL;
5837         bool squash_id = false;
5838         ktime_t kstart = ktime_get();
5839
5840         ENTRY;
5841
5842         if (mask & MAY_NOT_BLOCK)
5843                 return -ECHILD;
5844
5845         /*
5846          * as root inode are NOT getting validated in lookup operation,
5847          * need to revalidate PERM before permission check.
5848          */
5849         if (is_root_inode(inode)) {
5850                 rc = ll_inode_revalidate(inode->i_sb->s_root, IT_GETATTR);
5851                 if (rc)
5852                         RETURN(rc);
5853         }
5854
5855         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
5856                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
5857
5858         /* squash fsuid/fsgid if needed */
5859         sbi = ll_i2sbi(inode);
5860         squash = &sbi->ll_squash;
5861         if (unlikely(squash->rsi_uid != 0 &&
5862                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
5863                      !test_bit(LL_SBI_NOROOTSQUASH, sbi->ll_flags))) {
5864                         squash_id = true;
5865         }
5866         if (squash_id) {
5867                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
5868                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
5869                        squash->rsi_uid, squash->rsi_gid);
5870
5871                 /* update current process's credentials
5872                  * and FS capability */
5873                 cred = prepare_creds();
5874                 if (cred == NULL)
5875                         RETURN(-ENOMEM);
5876
5877                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
5878                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
5879                 cred->cap_effective = cap_drop_nfsd_set(cred->cap_effective);
5880                 cred->cap_effective = cap_drop_fs_set(cred->cap_effective);
5881
5882                 old_cred = override_creds(cred);
5883         }
5884
5885         rc = generic_permission(idmap, inode, mask);
5886         /* restore current process's credentials and FS capability */
5887         if (squash_id) {
5888                 revert_creds(old_cred);
5889                 put_cred(cred);
5890         }
5891
5892         if (!rc)
5893                 ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM,
5894                                    ktime_us_delta(ktime_get(), kstart));
5895
5896         RETURN(rc);
5897 }
5898
5899 /* -o localflock - only provides locally consistent flock locks */
5900 static const struct file_operations ll_file_operations = {
5901 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
5902 # ifdef HAVE_SYNC_READ_WRITE
5903         .read           = new_sync_read,
5904         .write          = new_sync_write,
5905 # endif
5906         .read_iter      = ll_file_read_iter,
5907         .write_iter     = ll_file_write_iter,
5908 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5909         .read           = ll_file_read,
5910         .aio_read       = ll_file_aio_read,
5911         .write          = ll_file_write,
5912         .aio_write      = ll_file_aio_write,
5913 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5914         .unlocked_ioctl = ll_file_ioctl,
5915         .open           = ll_file_open,
5916         .release        = ll_file_release,
5917         .mmap           = ll_file_mmap,
5918         .llseek         = ll_file_seek,
5919 #ifndef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
5920         .splice_read    = generic_file_splice_read,
5921 #else
5922         .splice_read    = pcc_file_splice_read,
5923 #endif
5924 #ifdef HAVE_ITER_FILE_SPLICE_WRITE
5925         .splice_write   = iter_file_splice_write,
5926 #endif
5927         .fsync          = ll_fsync,
5928         .flush          = ll_flush,
5929         .fallocate      = ll_fallocate,
5930 };
5931
5932 static const struct file_operations ll_file_operations_flock = {
5933 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
5934 # ifdef HAVE_SYNC_READ_WRITE
5935         .read           = new_sync_read,
5936         .write          = new_sync_write,
5937 # endif /* HAVE_SYNC_READ_WRITE */
5938         .read_iter      = ll_file_read_iter,
5939         .write_iter     = ll_file_write_iter,
5940 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5941         .read           = ll_file_read,
5942         .aio_read       = ll_file_aio_read,
5943         .write          = ll_file_write,
5944         .aio_write      = ll_file_aio_write,
5945 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5946         .unlocked_ioctl = ll_file_ioctl,
5947         .open           = ll_file_open,
5948         .release        = ll_file_release,
5949         .mmap           = ll_file_mmap,
5950         .llseek         = ll_file_seek,
5951 #ifndef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
5952         .splice_read    = generic_file_splice_read,
5953 #else
5954         .splice_read    = pcc_file_splice_read,
5955 #endif
5956 #ifdef HAVE_ITER_FILE_SPLICE_WRITE
5957         .splice_write   = iter_file_splice_write,
5958 #endif
5959         .fsync          = ll_fsync,
5960         .flush          = ll_flush,
5961         .flock          = ll_file_flock,
5962         .lock           = ll_file_flock,
5963         .fallocate      = ll_fallocate,
5964 };
5965
5966 /* These are for -o noflock - to return ENOSYS on flock calls */
5967 static const struct file_operations ll_file_operations_noflock = {
5968 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
5969 # ifdef HAVE_SYNC_READ_WRITE
5970         .read           = new_sync_read,
5971         .write          = new_sync_write,
5972 # endif /* HAVE_SYNC_READ_WRITE */
5973         .read_iter      = ll_file_read_iter,
5974         .write_iter     = ll_file_write_iter,
5975 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5976         .read           = ll_file_read,
5977         .aio_read       = ll_file_aio_read,
5978         .write          = ll_file_write,
5979         .aio_write      = ll_file_aio_write,
5980 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
5981         .unlocked_ioctl = ll_file_ioctl,
5982         .open           = ll_file_open,
5983         .release        = ll_file_release,
5984         .mmap           = ll_file_mmap,
5985         .llseek         = ll_file_seek,
5986 #ifndef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
5987         .splice_read    = generic_file_splice_read,
5988 #else
5989         .splice_read    = pcc_file_splice_read,
5990 #endif
5991 #ifdef HAVE_ITER_FILE_SPLICE_WRITE
5992         .splice_write   = iter_file_splice_write,
5993 #endif
5994         .fsync          = ll_fsync,
5995         .flush          = ll_flush,
5996         .flock          = ll_file_noflock,
5997         .lock           = ll_file_noflock,
5998         .fallocate      = ll_fallocate,
5999 };
6000
6001 const struct inode_operations ll_file_inode_operations = {
6002         .setattr        = ll_setattr,
6003         .getattr        = ll_getattr,
6004         .permission     = ll_inode_permission,
6005 #ifdef HAVE_IOP_XATTR
6006         .setxattr       = ll_setxattr,
6007         .getxattr       = ll_getxattr,
6008         .removexattr    = ll_removexattr,
6009 #endif
6010         .listxattr      = ll_listxattr,
6011         .fiemap         = ll_fiemap,
6012         .get_acl        = ll_get_acl,
6013 #ifdef HAVE_IOP_SET_ACL
6014         .set_acl        = ll_set_acl,
6015 #endif
6016 #ifdef HAVE_FILEATTR_GET
6017         .fileattr_get   = ll_fileattr_get,
6018         .fileattr_set   = ll_fileattr_set,
6019 #endif
6020 };
6021
6022 const struct file_operations *ll_select_file_operations(struct ll_sb_info *sbi)
6023 {
6024         const struct file_operations *fops = &ll_file_operations_noflock;
6025
6026         if (test_bit(LL_SBI_FLOCK, sbi->ll_flags))
6027                 fops = &ll_file_operations_flock;
6028         else if (test_bit(LL_SBI_LOCALFLOCK, sbi->ll_flags))
6029                 fops = &ll_file_operations;
6030
6031         return fops;
6032 }
6033
6034 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
6035 {
6036         struct ll_inode_info *lli = ll_i2info(inode);
6037         struct cl_object *obj = lli->lli_clob;
6038         struct lu_env *env;
6039         int rc;
6040         __u16 refcheck;
6041         ENTRY;
6042
6043         if (obj == NULL)
6044                 RETURN(0);
6045
6046         env = cl_env_get(&refcheck);
6047         if (IS_ERR(env))
6048                 RETURN(PTR_ERR(env));
6049
6050         rc = cl_conf_set(env, lli->lli_clob, conf);
6051         if (rc < 0)
6052                 GOTO(out, rc);
6053
6054         if (conf->coc_opc == OBJECT_CONF_SET) {
6055                 struct ldlm_lock *lock = conf->coc_lock;
6056                 struct cl_layout cl = {
6057                         .cl_layout_gen = 0,
6058                 };
6059
6060                 LASSERT(lock != NULL);
6061                 LASSERT(ldlm_has_layout(lock));
6062
6063                 /* it can only be allowed to match after layout is
6064                  * applied to inode otherwise false layout would be
6065                  * seen. Applying layout shoud happen before dropping
6066                  * the intent lock. */
6067                 ldlm_lock_allow_match(lock);
6068
6069                 rc = cl_object_layout_get(env, obj, &cl);
6070                 if (rc < 0)
6071                         GOTO(out, rc);
6072
6073                 CDEBUG(D_VFSTRACE,
6074                        DFID": layout version change: %u -> %u\n",
6075                        PFID(&lli->lli_fid), ll_layout_version_get(lli),
6076                        cl.cl_layout_gen);
6077                 ll_layout_version_set(lli, cl.cl_layout_gen);
6078         }
6079
6080 out:
6081         cl_env_put(env, &refcheck);
6082
6083         RETURN(rc < 0 ? rc : 0);
6084 }
6085
6086 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
6087 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
6088
6089 {
6090         struct ll_sb_info *sbi = ll_i2sbi(inode);
6091         struct ptlrpc_request *req;
6092         void *lvbdata;
6093         void *lmm;
6094         int lmmsize;
6095         int rc;
6096         ENTRY;
6097
6098         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
6099                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
6100                lock->l_lvb_data, lock->l_lvb_len);
6101
6102         if (lock->l_lvb_data != NULL)
6103                 RETURN(0);
6104
6105         /* if layout lock was granted right away, the layout is returned
6106          * within DLM_LVB of dlm reply; otherwise if the lock was ever
6107          * blocked and then granted via completion ast, we have to fetch
6108          * layout here. Please note that we can't use the LVB buffer in
6109          * completion AST because it doesn't have a large enough buffer */
6110         rc = ll_get_default_mdsize(sbi, &lmmsize);
6111         if (rc < 0)
6112                 RETURN(rc);
6113
6114         rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), OBD_MD_FLXATTR,
6115                          XATTR_NAME_LOV, lmmsize, &req);
6116         if (rc < 0) {
6117                 if (rc == -ENODATA)
6118                         GOTO(out, rc = 0); /* empty layout */
6119                 else
6120                         RETURN(rc);
6121         }
6122
6123         lmmsize = rc;
6124         rc = 0;
6125         if (lmmsize == 0) /* empty layout */
6126                 GOTO(out, rc = 0);
6127
6128         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
6129         if (lmm == NULL)
6130                 GOTO(out, rc = -EFAULT);
6131
6132         OBD_ALLOC_LARGE(lvbdata, lmmsize);
6133         if (lvbdata == NULL)
6134                 GOTO(out, rc = -ENOMEM);
6135
6136         memcpy(lvbdata, lmm, lmmsize);
6137         lock_res_and_lock(lock);
6138         if (unlikely(lock->l_lvb_data == NULL)) {
6139                 lock->l_lvb_type = LVB_T_LAYOUT;
6140                 lock->l_lvb_data = lvbdata;
6141                 lock->l_lvb_len = lmmsize;
6142                 lvbdata = NULL;
6143         }
6144         unlock_res_and_lock(lock);
6145
6146         if (lvbdata)
6147                 OBD_FREE_LARGE(lvbdata, lmmsize);
6148
6149         EXIT;
6150
6151 out:
6152         ptlrpc_req_finished(req);
6153         return rc;
6154 }
6155
6156 /**
6157  * Apply the layout to the inode. Layout lock is held and will be released
6158  * in this function.
6159  */
6160 static int ll_layout_lock_set(struct lustre_handle *lockh, enum ldlm_mode mode,
6161                               struct inode *inode, bool try)
6162 {
6163         struct ll_inode_info *lli = ll_i2info(inode);
6164         struct ll_sb_info    *sbi = ll_i2sbi(inode);
6165         struct ldlm_lock *lock;
6166         struct cl_object_conf conf;
6167         int rc = 0;
6168         bool lvb_ready;
6169         bool wait_layout = false;
6170         ENTRY;
6171
6172         LASSERT(lustre_handle_is_used(lockh));
6173
6174         lock = ldlm_handle2lock(lockh);
6175         LASSERT(lock != NULL);
6176
6177         if (!ldlm_has_layout(lock))
6178                 GOTO(out, rc = -EAGAIN);
6179
6180         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured",
6181                    PFID(&lli->lli_fid), inode);
6182
6183         /* in case this is a caching lock and reinstate with new inode */
6184         md_set_lock_data(sbi->ll_md_exp, lockh, inode, NULL);
6185
6186         lock_res_and_lock(lock);
6187         lvb_ready = ldlm_is_lvb_ready(lock);
6188         unlock_res_and_lock(lock);
6189
6190         /* checking lvb_ready is racy but this is okay. The worst case is
6191          * that multi processes may configure the file on the same time. */
6192         if (lvb_ready)
6193                 GOTO(out, rc = 0);
6194
6195         rc = ll_layout_fetch(inode, lock);
6196         if (rc < 0)
6197                 GOTO(out, rc);
6198
6199         /* for layout lock, lmm is stored in lock's lvb.
6200          * lvb_data is immutable if the lock is held so it's safe to access it
6201          * without res lock.
6202          *
6203          * set layout to file. Unlikely this will fail as old layout was
6204          * surely eliminated */
6205         memset(&conf, 0, sizeof conf);
6206         conf.coc_opc = OBJECT_CONF_SET;
6207         conf.coc_inode = inode;
6208         conf.coc_lock = lock;
6209         conf.coc_try = try;
6210         conf.u.coc_layout.lb_buf = lock->l_lvb_data;
6211         conf.u.coc_layout.lb_len = lock->l_lvb_len;
6212         rc = ll_layout_conf(inode, &conf);
6213
6214         /* refresh layout failed, need to wait */
6215         wait_layout = rc == -EBUSY;
6216         EXIT;
6217 out:
6218         LDLM_LOCK_PUT(lock);
6219         ldlm_lock_decref(lockh, mode);
6220
6221         /* wait for IO to complete if it's still being used. */
6222         if (wait_layout) {
6223                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
6224                        sbi->ll_fsname, PFID(&lli->lli_fid), inode);
6225
6226                 memset(&conf, 0, sizeof conf);
6227                 conf.coc_opc = OBJECT_CONF_WAIT;
6228                 conf.coc_inode = inode;
6229                 rc = ll_layout_conf(inode, &conf);
6230                 if (rc == 0)
6231                         rc = -ERESTARTSYS;
6232
6233                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
6234                        sbi->ll_fsname, PFID(&lli->lli_fid), rc);
6235         }
6236
6237         if (rc == -ERESTARTSYS) {
6238                 __u16 refcheck;
6239                 struct lu_env *env;
6240                 struct cl_object * obj = lli->lli_clob;
6241
6242                 env = cl_env_get(&refcheck);
6243                 if (IS_ERR(env))
6244                         RETURN(PTR_ERR(env));
6245
6246                 CDEBUG(D_INODE, "prune without lock "DFID"\n",
6247                                 PFID(lu_object_fid(&obj->co_lu)));
6248
6249                 trunc_sem_down_write(&lli->lli_trunc_sem);
6250                 cl_object_prune(env, obj);
6251                 trunc_sem_up_write(&lli->lli_trunc_sem);
6252                 cl_env_put(env, &refcheck);
6253
6254                 rc = -EAGAIN;
6255         }
6256
6257         RETURN(rc);
6258 }
6259
6260 /**
6261  * Issue layout intent RPC to MDS.
6262  * \param inode [in]    file inode
6263  * \param intent [in]   layout intent
6264  *
6265  * \retval 0    on success
6266  * \retval < 0  error code
6267  */
6268 static int ll_layout_intent(struct inode *inode, struct layout_intent *intent)
6269 {
6270         struct ll_inode_info  *lli = ll_i2info(inode);
6271         struct ll_sb_info     *sbi = ll_i2sbi(inode);
6272         struct md_op_data     *op_data;
6273         struct lookup_intent it;
6274         struct ptlrpc_request *req;
6275         int rc;
6276         ENTRY;
6277
6278         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
6279                                      0, 0, LUSTRE_OPC_ANY, NULL);
6280         if (IS_ERR(op_data))
6281                 RETURN(PTR_ERR(op_data));
6282
6283         op_data->op_data = intent;
6284         op_data->op_data_size = sizeof(*intent);
6285
6286         memset(&it, 0, sizeof(it));
6287         it.it_op = IT_LAYOUT;
6288         if (intent->li_opc == LAYOUT_INTENT_WRITE ||
6289             intent->li_opc == LAYOUT_INTENT_TRUNC)
6290                 it.it_flags = FMODE_WRITE;
6291
6292         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
6293                           sbi->ll_fsname, PFID(&lli->lli_fid), inode);
6294
6295         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
6296                             &ll_md_blocking_ast, 0);
6297         if (it.it_request != NULL)
6298                 ptlrpc_req_finished(it.it_request);
6299         it.it_request = NULL;
6300
6301         ll_finish_md_op_data(op_data);
6302
6303         /* set lock data in case this is a new lock */
6304         if (!rc)
6305                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
6306
6307         ll_intent_drop_lock(&it);
6308
6309         RETURN(rc);
6310 }
6311
6312 /**
6313  * This function checks if there exists a LAYOUT lock on the client side,
6314  * or enqueues it if it doesn't have one in cache.
6315  *
6316  * This function will not hold layout lock so it may be revoked any time after
6317  * this function returns. Any operations depend on layout should be redone
6318  * in that case.
6319  *
6320  * This function should be called before lov_io_init() to get an uptodate
6321  * layout version, the caller should save the version number and after IO
6322  * is finished, this function should be called again to verify that layout
6323  * is not changed during IO time.
6324  */
6325 int ll_layout_refresh(struct inode *inode, __u32 *gen)
6326 {
6327         struct ll_inode_info    *lli = ll_i2info(inode);
6328         struct ll_sb_info       *sbi = ll_i2sbi(inode);
6329         struct lustre_handle lockh;
6330         struct layout_intent intent = {
6331                 .li_opc = LAYOUT_INTENT_ACCESS,
6332         };
6333         enum ldlm_mode mode;
6334         int rc;
6335         bool try = true;
6336         ENTRY;
6337
6338         *gen = ll_layout_version_get(lli);
6339         if (!test_bit(LL_SBI_LAYOUT_LOCK, sbi->ll_flags) ||
6340             *gen != CL_LAYOUT_GEN_NONE)
6341                 RETURN(0);
6342
6343         /* sanity checks */
6344         LASSERT(fid_is_sane(ll_inode2fid(inode)));
6345         LASSERT(S_ISREG(inode->i_mode));
6346
6347         while (1) {
6348                 /* mostly layout lock is caching on the local side, so try to
6349                  * match it before grabbing layout lock mutex. */
6350                 mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
6351                                        LCK_CR | LCK_CW | LCK_PR |
6352                                        LCK_PW | LCK_EX);
6353                 if (mode != 0) { /* hit cached lock */
6354                         rc = ll_layout_lock_set(&lockh, mode, inode, try);
6355                         try = false;
6356                         if (rc == -EAGAIN)
6357                                 continue;
6358                         break;
6359                 }
6360
6361                 /* take layout lock mutex to enqueue layout lock exclusively. */
6362                 mutex_lock(&lli->lli_layout_mutex);
6363                 rc = ll_layout_intent(inode, &intent);
6364                 mutex_unlock(&lli->lli_layout_mutex);
6365                 if (rc != 0)
6366                         break;
6367         }
6368
6369         if (rc == 0)
6370                 *gen = ll_layout_version_get(lli);
6371
6372         RETURN(rc);
6373 }
6374
6375 /**
6376  * Issue layout intent RPC indicating where in a file an IO is about to write.
6377  *
6378  * \param[in] inode     file inode.
6379  * \param[in] ext       write range with start offset of fille in bytes where
6380  *                      an IO is about to write, and exclusive end offset in
6381  *                      bytes.
6382  *
6383  * \retval 0    on success
6384  * \retval < 0  error code
6385  */
6386 int ll_layout_write_intent(struct inode *inode, enum layout_intent_opc opc,
6387                            struct lu_extent *ext)
6388 {
6389         struct layout_intent intent = {
6390                 .li_opc = opc,
6391                 .li_extent.e_start = ext->e_start,
6392                 .li_extent.e_end = ext->e_end,
6393         };
6394         int rc;
6395         ENTRY;
6396
6397         rc = ll_layout_intent(inode, &intent);
6398
6399         RETURN(rc);
6400 }
6401
6402 /**
6403  *  This function send a restore request to the MDT
6404  */
6405 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
6406 {
6407         struct hsm_user_request *hur;
6408         int                      len, rc;
6409         ENTRY;
6410
6411         len = sizeof(struct hsm_user_request) +
6412               sizeof(struct hsm_user_item);
6413         OBD_ALLOC(hur, len);
6414         if (hur == NULL)
6415                 RETURN(-ENOMEM);
6416
6417         hur->hur_request.hr_action = HUA_RESTORE;
6418         hur->hur_request.hr_archive_id = 0;
6419         hur->hur_request.hr_flags = 0;
6420         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
6421                sizeof(hur->hur_user_item[0].hui_fid));
6422         hur->hur_user_item[0].hui_extent.offset = offset;
6423         hur->hur_user_item[0].hui_extent.length = length;
6424         hur->hur_request.hr_itemcount = 1;
6425         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, ll_i2sbi(inode)->ll_md_exp,
6426                            len, hur, NULL);
6427         OBD_FREE(hur, len);
6428         RETURN(rc);
6429 }