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