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, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/llite/file.c
  33  *
  34  * Author: Peter Braam <braam@clusterfs.com>
  35  * Author: Phil Schwan <phil@clusterfs.com>
  36  * Author: Andreas Dilger <adilger@clusterfs.com>
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_LLITE
  40 #include <lustre_dlm.h>
  41 #include <linux/pagemap.h>
  42 #include <linux/file.h>
  43 #include <linux/sched.h>
  44 #include <linux/user_namespace.h>
  45 #ifdef HAVE_UIDGID_HEADER
  46 # include <linux/uidgid.h>
  47 #endif
  48 #include <lustre/ll_fiemap.h>
  49
  50 #include <uapi/linux/lustre_ioctl.h>
  51 #include <lustre_swab.h>
  52
  53 #include "cl_object.h"
  54 #include "llite_internal.h"
  55 #include "vvp_internal.h"
  56
  57 static int
  58 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
  59
  60 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
  61                           bool *lease_broken);
  62
  63 static enum llioc_iter
  64 ll_iocontrol_call(struct inode *inode, struct file *file,
  65                   unsigned int cmd, unsigned long arg, int *rcp);
  66
  67 static struct ll_file_data *ll_file_data_get(void)
  68 {
  69         struct ll_file_data *fd;
  70
  71         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
  72         if (fd == NULL)
  73                 return NULL;
  74
  75         fd->fd_write_failed = false;
  76
  77         return fd;
  78 }
  79
  80 static void ll_file_data_put(struct ll_file_data *fd)
  81 {
  82         if (fd != NULL)
  83                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
  84 }
  85
  86 /**
  87  * Packs all the attributes into @op_data for the CLOSE rpc.
  88  */
  89 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
  90                              struct obd_client_handle *och)
  91 {
  92         ENTRY;
  93
  94         ll_prep_md_op_data(op_data, inode, NULL, NULL,
  95                            0, 0, LUSTRE_OPC_ANY, NULL);
  96
  97         op_data->op_attr.ia_mode = inode->i_mode;
  98         op_data->op_attr.ia_atime = inode->i_atime;
  99         op_data->op_attr.ia_mtime = inode->i_mtime;
 100         op_data->op_attr.ia_ctime = inode->i_ctime;
 101         op_data->op_attr.ia_size = i_size_read(inode);
 102         op_data->op_attr.ia_valid |= ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
 103                                      ATTR_MTIME | ATTR_MTIME_SET |
 104                                      ATTR_CTIME | ATTR_CTIME_SET;
 105         op_data->op_attr_blocks = inode->i_blocks;
 106         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
 107         op_data->op_handle = och->och_fh;
 108
 109         if (och->och_flags & FMODE_WRITE &&
 110             ll_file_test_and_clear_flag(ll_i2info(inode), LLIF_DATA_MODIFIED))
 111                 /* For HSM: if inode data has been modified, pack it so that
 112                  * MDT can set data dirty flag in the archive. */
 113                 op_data->op_bias |= MDS_DATA_MODIFIED;
 114
 115         EXIT;
 116 }
 117
 118 /**
 119  * Perform a close, possibly with a bias.
 120  * The meaning of "data" depends on the value of "bias".
 121  *
 122  * If \a bias is MDS_HSM_RELEASE then \a data is a pointer to the data version.
 123  * If \a bias is MDS_CLOSE_LAYOUT_SWAP then \a data is a pointer to the inode to
 124  * swap layouts with.
 125  */
 126 static int ll_close_inode_openhandle(struct inode *inode,
 127                                      struct obd_client_handle *och,
 128                                      enum mds_op_bias bias, void *data)
 129 {
 130         struct obd_export *md_exp = ll_i2mdexp(inode);
 131         const struct ll_inode_info *lli = ll_i2info(inode);
 132         struct md_op_data *op_data;
 133         struct ptlrpc_request *req = NULL;
 134         int rc;
 135         ENTRY;
 136
 137         if (class_exp2obd(md_exp) == NULL) {
 138                 CERROR("%s: invalid MDC connection handle closing "DFID"\n",
 139                        ll_get_fsname(inode->i_sb, NULL, 0),
 140                        PFID(&lli->lli_fid));
 141                 GOTO(out, rc = 0);
 142         }
 143
 144         OBD_ALLOC_PTR(op_data);
 145         /* We leak openhandle and request here on error, but not much to be
 146          * done in OOM case since app won't retry close on error either. */
 147         if (op_data == NULL)
 148                 GOTO(out, rc = -ENOMEM);
 149
 150         ll_prepare_close(inode, op_data, och);
 151         switch (bias) {
 152         case MDS_CLOSE_LAYOUT_SWAP:
 153                 LASSERT(data != NULL);
 154                 op_data->op_bias |= MDS_CLOSE_LAYOUT_SWAP;
 155                 op_data->op_data_version = 0;
 156                 op_data->op_lease_handle = och->och_lease_handle;
 157                 op_data->op_fid2 = *ll_inode2fid(data);
 158                 break;
 159
 160         case MDS_HSM_RELEASE:
 161                 LASSERT(data != NULL);
 162                 op_data->op_bias |= MDS_HSM_RELEASE;
 163                 op_data->op_data_version = *(__u64 *)data;
 164                 op_data->op_lease_handle = och->och_lease_handle;
 165                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 166                 break;
 167
 168         default:
 169                 LASSERT(data == NULL);
 170                 break;
 171         }
 172
 173         rc = md_close(md_exp, op_data, och->och_mod, &req);
 174         if (rc != 0 && rc != -EINTR)
 175                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
 176                        md_exp->exp_obd->obd_name, PFID(&lli->lli_fid), rc);
 177
 178         if (rc == 0 &&
 179             op_data->op_bias & (MDS_HSM_RELEASE | MDS_CLOSE_LAYOUT_SWAP)) {
 180                 struct mdt_body *body;
 181
 182                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 183                 if (!(body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED))
 184                         rc = -EBUSY;
 185         }
 186
 187         ll_finish_md_op_data(op_data);
 188         EXIT;
 189 out:
 190
 191         md_clear_open_replay_data(md_exp, och);
 192         och->och_fh.cookie = DEAD_HANDLE_MAGIC;
 193         OBD_FREE_PTR(och);
 194
 195         ptlrpc_req_finished(req);       /* This is close request */
 196         return rc;
 197 }
 198
 199 int ll_md_real_close(struct inode *inode, fmode_t fmode)
 200 {
 201         struct ll_inode_info *lli = ll_i2info(inode);
 202         struct obd_client_handle **och_p;
 203         struct obd_client_handle *och;
 204         __u64 *och_usecount;
 205         int rc = 0;
 206         ENTRY;
 207
 208         if (fmode & FMODE_WRITE) {
 209                 och_p = &lli->lli_mds_write_och;
 210                 och_usecount = &lli->lli_open_fd_write_count;
 211         } else if (fmode & FMODE_EXEC) {
 212                 och_p = &lli->lli_mds_exec_och;
 213                 och_usecount = &lli->lli_open_fd_exec_count;
 214         } else {
 215                 LASSERT(fmode & FMODE_READ);
 216                 och_p = &lli->lli_mds_read_och;
 217                 och_usecount = &lli->lli_open_fd_read_count;
 218         }
 219
 220         mutex_lock(&lli->lli_och_mutex);
 221         if (*och_usecount > 0) {
 222                 /* There are still users of this handle, so skip
 223                  * freeing it. */
 224                 mutex_unlock(&lli->lli_och_mutex);
 225                 RETURN(0);
 226         }
 227
 228         och = *och_p;
 229         *och_p = NULL;
 230         mutex_unlock(&lli->lli_och_mutex);
 231
 232         if (och != NULL) {
 233                 /* There might be a race and this handle may already
 234                  * be closed. */
 235                 rc = ll_close_inode_openhandle(inode, och, 0, NULL);
 236         }
 237
 238         RETURN(rc);
 239 }
 240
 241 static int ll_md_close(struct inode *inode, struct file *file)
 242 {
 243         union ldlm_policy_data policy = {
 244                 .l_inodebits    = { MDS_INODELOCK_OPEN },
 245         };
 246         __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
 247         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 248         struct ll_inode_info *lli = ll_i2info(inode);
 249         struct lustre_handle lockh;
 250         enum ldlm_mode lockmode;
 251         int rc = 0;
 252         ENTRY;
 253
 254         /* clear group lock, if present */
 255         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
 256                 ll_put_grouplock(inode, file, fd->fd_grouplock.lg_gid);
 257
 258         if (fd->fd_lease_och != NULL) {
 259                 bool lease_broken;
 260
 261                 /* Usually the lease is not released when the
 262                  * application crashed, we need to release here. */
 263                 rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken);
 264                 CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n",
 265                         PFID(&lli->lli_fid), rc, lease_broken);
 266
 267                 fd->fd_lease_och = NULL;
 268         }
 269
 270         if (fd->fd_och != NULL) {
 271                 rc = ll_close_inode_openhandle(inode, fd->fd_och, 0, NULL);
 272                 fd->fd_och = NULL;
 273                 GOTO(out, rc);
 274         }
 275
 276         /* Let's see if we have good enough OPEN lock on the file and if
 277            we can skip talking to MDS */
 278         mutex_lock(&lli->lli_och_mutex);
 279         if (fd->fd_omode & FMODE_WRITE) {
 280                 lockmode = LCK_CW;
 281                 LASSERT(lli->lli_open_fd_write_count);
 282                 lli->lli_open_fd_write_count--;
 283         } else if (fd->fd_omode & FMODE_EXEC) {
 284                 lockmode = LCK_PR;
 285                 LASSERT(lli->lli_open_fd_exec_count);
 286                 lli->lli_open_fd_exec_count--;
 287         } else {
 288                 lockmode = LCK_CR;
 289                 LASSERT(lli->lli_open_fd_read_count);
 290                 lli->lli_open_fd_read_count--;
 291         }
 292         mutex_unlock(&lli->lli_och_mutex);
 293
 294         if (!md_lock_match(ll_i2mdexp(inode), flags, ll_inode2fid(inode),
 295                            LDLM_IBITS, &policy, lockmode, &lockh))
 296                 rc = ll_md_real_close(inode, fd->fd_omode);
 297
 298 out:
 299         LUSTRE_FPRIVATE(file) = NULL;
 300         ll_file_data_put(fd);
 301
 302         RETURN(rc);
 303 }
 304
 305 /* While this returns an error code, fput() the caller does not, so we need
 306  * to make every effort to clean up all of our state here.  Also, applications
 307  * rarely check close errors and even if an error is returned they will not
 308  * re-try the close call.
 309  */
 310 int ll_file_release(struct inode *inode, struct file *file)
 311 {
 312         struct ll_file_data *fd;
 313         struct ll_sb_info *sbi = ll_i2sbi(inode);
 314         struct ll_inode_info *lli = ll_i2info(inode);
 315         int rc;
 316         ENTRY;
 317
 318         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
 319                PFID(ll_inode2fid(inode)), inode);
 320
 321         if (inode->i_sb->s_root != file_dentry(file))
 322                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
 323         fd = LUSTRE_FPRIVATE(file);
 324         LASSERT(fd != NULL);
 325
 326         /* The last ref on @file, maybe not the the owner pid of statahead,
 327          * because parent and child process can share the same file handle. */
 328         if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd)
 329                 ll_deauthorize_statahead(inode, fd);
 330
 331         if (inode->i_sb->s_root == file_dentry(file)) {
 332                 LUSTRE_FPRIVATE(file) = NULL;
 333                 ll_file_data_put(fd);
 334                 RETURN(0);
 335         }
 336
 337         if (!S_ISDIR(inode->i_mode)) {
 338                 if (lli->lli_clob != NULL)
 339                         lov_read_and_clear_async_rc(lli->lli_clob);
 340                 lli->lli_async_rc = 0;
 341         }
 342
 343         rc = ll_md_close(inode, file);
 344
 345         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
 346                 libcfs_debug_dumplog();
 347
 348         RETURN(rc);
 349 }
 350
 351 static int ll_intent_file_open(struct dentry *de, void *lmm, int lmmsize,
 352                                 struct lookup_intent *itp)
 353 {
 354         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
 355         struct dentry *parent = de->d_parent;
 356         const char *name = NULL;
 357         int len = 0;
 358         struct md_op_data *op_data;
 359         struct ptlrpc_request *req = NULL;
 360         int rc;
 361         ENTRY;
 362
 363         LASSERT(parent != NULL);
 364         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
 365
 366         /* if server supports open-by-fid, or file name is invalid, don't pack
 367          * name in open request */
 368         if (!(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID) &&
 369             lu_name_is_valid_2(de->d_name.name, de->d_name.len)) {
 370                 name = de->d_name.name;
 371                 len = de->d_name.len;
 372         }
 373
 374         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
 375                                      name, len, 0, LUSTRE_OPC_ANY, NULL);
 376         if (IS_ERR(op_data))
 377                 RETURN(PTR_ERR(op_data));
 378         op_data->op_data = lmm;
 379         op_data->op_data_size = lmmsize;
 380
 381         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
 382                             &ll_md_blocking_ast, 0);
 383         ll_finish_md_op_data(op_data);
 384         if (rc == -ESTALE) {
 385                 /* reason for keep own exit path - don`t flood log
 386                  * with messages with -ESTALE errors.
 387                  */
 388                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
 389                      it_open_error(DISP_OPEN_OPEN, itp))
 390                         GOTO(out, rc);
 391                 ll_release_openhandle(de, itp);
 392                 GOTO(out, rc);
 393         }
 394
 395         if (it_disposition(itp, DISP_LOOKUP_NEG))
 396                 GOTO(out, rc = -ENOENT);
 397
 398         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
 399                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
 400                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
 401                 GOTO(out, rc);
 402         }
 403
 404         rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
 405         if (!rc && itp->it_lock_mode)
 406                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, NULL);
 407
 408 out:
 409         ptlrpc_req_finished(req);
 410         ll_intent_drop_lock(itp);
 411
 412         /* We did open by fid, but by the time we got to the server,
 413          * the object disappeared. If this is a create, we cannot really
 414          * tell the userspace that the file it was trying to create
 415          * does not exist. Instead let's return -ESTALE, and the VFS will
 416          * retry the create with LOOKUP_REVAL that we are going to catch
 417          * in ll_revalidate_dentry() and use lookup then.
 418          */
 419         if (rc == -ENOENT && itp->it_op & IT_CREAT)
 420                 rc = -ESTALE;
 421
 422         RETURN(rc);
 423 }
 424
 425 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 426                        struct obd_client_handle *och)
 427 {
 428         struct mdt_body *body;
 429
 430         body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
 431         och->och_fh = body->mbo_handle;
 432         och->och_fid = body->mbo_fid1;
 433         och->och_lease_handle.cookie = it->it_lock_handle;
 434         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
 435         och->och_flags = it->it_flags;
 436
 437         return md_set_open_replay_data(md_exp, och, it);
 438 }
 439
 440 static int ll_local_open(struct file *file, struct lookup_intent *it,
 441                          struct ll_file_data *fd, struct obd_client_handle *och)
 442 {
 443         struct inode *inode = file_inode(file);
 444         ENTRY;
 445
 446         LASSERT(!LUSTRE_FPRIVATE(file));
 447
 448         LASSERT(fd != NULL);
 449
 450         if (och) {
 451                 int rc;
 452
 453                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
 454                 if (rc != 0)
 455                         RETURN(rc);
 456         }
 457
 458         LUSTRE_FPRIVATE(file) = fd;
 459         ll_readahead_init(inode, &fd->fd_ras);
 460         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
 461
 462         /* ll_cl_context initialize */
 463         rwlock_init(&fd->fd_lock);
 464         INIT_LIST_HEAD(&fd->fd_lccs);
 465
 466         RETURN(0);
 467 }
 468
 469 /* Open a file, and (for the very first open) create objects on the OSTs at
 470  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
 471  * creation or open until ll_lov_setstripe() ioctl is called.
 472  *
 473  * If we already have the stripe MD locally then we don't request it in
 474  * md_open(), by passing a lmm_size = 0.
 475  *
 476  * It is up to the application to ensure no other processes open this file
 477  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
 478  * used.  We might be able to avoid races of that sort by getting lli_open_sem
 479  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
 480  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
 481  */
 482 int ll_file_open(struct inode *inode, struct file *file)
 483 {
 484         struct ll_inode_info *lli = ll_i2info(inode);
 485         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
 486                                           .it_flags = file->f_flags };
 487         struct obd_client_handle **och_p = NULL;
 488         __u64 *och_usecount = NULL;
 489         struct ll_file_data *fd;
 490         int rc = 0;
 491         ENTRY;
 492
 493         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
 494                PFID(ll_inode2fid(inode)), inode, file->f_flags);
 495
 496         it = file->private_data; /* XXX: compat macro */
 497         file->private_data = NULL; /* prevent ll_local_open assertion */
 498
 499         fd = ll_file_data_get();
 500         if (fd == NULL)
 501                 GOTO(out_openerr, rc = -ENOMEM);
 502
 503         fd->fd_file = file;
 504         if (S_ISDIR(inode->i_mode))
 505                 ll_authorize_statahead(inode, fd);
 506
 507         if (inode->i_sb->s_root == file_dentry(file)) {
 508                 LUSTRE_FPRIVATE(file) = fd;
 509                 RETURN(0);
 510         }
 511
 512         if (!it || !it->it_disposition) {
 513                 /* Convert f_flags into access mode. We cannot use file->f_mode,
 514                  * because everything but O_ACCMODE mask was stripped from
 515                  * there */
 516                 if ((oit.it_flags + 1) & O_ACCMODE)
 517                         oit.it_flags++;
 518                 if (file->f_flags & O_TRUNC)
 519                         oit.it_flags |= FMODE_WRITE;
 520
 521                 /* kernel only call f_op->open in dentry_open.  filp_open calls
 522                  * dentry_open after call to open_namei that checks permissions.
 523                  * Only nfsd_open call dentry_open directly without checking
 524                  * permissions and because of that this code below is safe. */
 525                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
 526                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
 527
 528                 /* We do not want O_EXCL here, presumably we opened the file
 529                  * already? XXX - NFS implications? */
 530                 oit.it_flags &= ~O_EXCL;
 531
 532                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
 533                  * created if necessary, then "IT_CREAT" should be set to keep
 534                  * consistent with it */
 535                 if (oit.it_flags & O_CREAT)
 536                         oit.it_op |= IT_CREAT;
 537
 538                 it = &oit;
 539         }
 540
 541 restart:
 542         /* Let's see if we have file open on MDS already. */
 543         if (it->it_flags & FMODE_WRITE) {
 544                 och_p = &lli->lli_mds_write_och;
 545                 och_usecount = &lli->lli_open_fd_write_count;
 546         } else if (it->it_flags & FMODE_EXEC) {
 547                 och_p = &lli->lli_mds_exec_och;
 548                 och_usecount = &lli->lli_open_fd_exec_count;
 549          } else {
 550                 och_p = &lli->lli_mds_read_och;
 551                 och_usecount = &lli->lli_open_fd_read_count;
 552         }
 553
 554         mutex_lock(&lli->lli_och_mutex);
 555         if (*och_p) { /* Open handle is present */
 556                 if (it_disposition(it, DISP_OPEN_OPEN)) {
 557                         /* Well, there's extra open request that we do not need,
 558                            let's close it somehow. This will decref request. */
 559                         rc = it_open_error(DISP_OPEN_OPEN, it);
 560                         if (rc) {
 561                                 mutex_unlock(&lli->lli_och_mutex);
 562                                 GOTO(out_openerr, rc);
 563                         }
 564
 565                         ll_release_openhandle(file_dentry(file), it);
 566                 }
 567                 (*och_usecount)++;
 568
 569                 rc = ll_local_open(file, it, fd, NULL);
 570                 if (rc) {
 571                         (*och_usecount)--;
 572                         mutex_unlock(&lli->lli_och_mutex);
 573                         GOTO(out_openerr, rc);
 574                 }
 575         } else {
 576                 LASSERT(*och_usecount == 0);
 577                 if (!it->it_disposition) {
 578                         struct ll_dentry_data *ldd = ll_d2d(file->f_path.dentry);
 579                         /* We cannot just request lock handle now, new ELC code
 580                            means that one of other OPEN locks for this file
 581                            could be cancelled, and since blocking ast handler
 582                            would attempt to grab och_mutex as well, that would
 583                            result in a deadlock */
 584                         mutex_unlock(&lli->lli_och_mutex);
 585                         /*
 586                          * Normally called under two situations:
 587                          * 1. NFS export.
 588                          * 2. A race/condition on MDS resulting in no open
 589                          *    handle to be returned from LOOKUP|OPEN request,
 590                          *    for example if the target entry was a symlink.
 591                          *
 592                          *  Only fetch MDS_OPEN_LOCK if this is in NFS path,
 593                          *  marked by a bit set in ll_iget_for_nfs. Clear the
 594                          *  bit so that it's not confusing later callers.
 595                          *
 596                          *  NB; when ldd is NULL, it must have come via normal
 597                          *  lookup path only, since ll_iget_for_nfs always calls
 598                          *  ll_d_init().
 599                          */
 600                         if (ldd && ldd->lld_nfs_dentry) {
 601                                 ldd->lld_nfs_dentry = 0;
 602                                 it->it_flags |= MDS_OPEN_LOCK;
 603                         }
 604
 605                          /*
 606                          * Always specify MDS_OPEN_BY_FID because we don't want
 607                          * to get file with different fid.
 608                          */
 609                         it->it_flags |= MDS_OPEN_BY_FID;
 610                         rc = ll_intent_file_open(file_dentry(file), NULL, 0,
 611                                                  it);
 612                         if (rc)
 613                                 GOTO(out_openerr, rc);
 614
 615                         goto restart;
 616                 }
 617                 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
 618                 if (!*och_p)
 619                         GOTO(out_och_free, rc = -ENOMEM);
 620
 621                 (*och_usecount)++;
 622
 623                 /* md_intent_lock() didn't get a request ref if there was an
 624                  * open error, so don't do cleanup on the request here
 625                  * (bug 3430) */
 626                 /* XXX (green): Should not we bail out on any error here, not
 627                  * just open error? */
 628                 rc = it_open_error(DISP_OPEN_OPEN, it);
 629                 if (rc != 0)
 630                         GOTO(out_och_free, rc);
 631
 632                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
 633                          "inode %p: disposition %x, status %d\n", inode,
 634                          it_disposition(it, ~0), it->it_status);
 635
 636                 rc = ll_local_open(file, it, fd, *och_p);
 637                 if (rc)
 638                         GOTO(out_och_free, rc);
 639         }
 640         mutex_unlock(&lli->lli_och_mutex);
 641         fd = NULL;
 642
 643         /* Must do this outside lli_och_mutex lock to prevent deadlock where
 644            different kind of OPEN lock for this same inode gets cancelled
 645            by ldlm_cancel_lru */
 646         if (!S_ISREG(inode->i_mode))
 647                 GOTO(out_och_free, rc);
 648
 649         cl_lov_delay_create_clear(&file->f_flags);
 650         GOTO(out_och_free, rc);
 651
 652 out_och_free:
 653         if (rc) {
 654                 if (och_p && *och_p) {
 655                         OBD_FREE(*och_p, sizeof (struct obd_client_handle));
 656                         *och_p = NULL; /* OBD_FREE writes some magic there */
 657                         (*och_usecount)--;
 658                 }
 659                 mutex_unlock(&lli->lli_och_mutex);
 660
 661 out_openerr:
 662                 if (lli->lli_opendir_key == fd)
 663                         ll_deauthorize_statahead(inode, fd);
 664                 if (fd != NULL)
 665                         ll_file_data_put(fd);
 666         } else {
 667                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
 668         }
 669
 670         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
 671                 ptlrpc_req_finished(it->it_request);
 672                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
 673         }
 674
 675         return rc;
 676 }
 677
 678 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
 679                         struct ldlm_lock_desc *desc, void *data, int flag)
 680 {
 681         int rc;
 682         struct lustre_handle lockh;
 683         ENTRY;
 684
 685         switch (flag) {
 686         case LDLM_CB_BLOCKING:
 687                 ldlm_lock2handle(lock, &lockh);
 688                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
 689                 if (rc < 0) {
 690                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 691                         RETURN(rc);
 692                 }
 693                 break;
 694         case LDLM_CB_CANCELING:
 695                 /* do nothing */
 696                 break;
 697         }
 698         RETURN(0);
 699 }
 700
 701 /**
 702  * When setting a lease on a file, we take ownership of the lli_mds_*_och
 703  * and save it as fd->fd_och so as to force client to reopen the file even
 704  * if it has an open lock in cache already.
 705  */
 706 static int ll_lease_och_acquire(struct inode *inode, struct file *file,
 707                                 struct lustre_handle *old_handle)
 708 {
 709         struct ll_inode_info *lli = ll_i2info(inode);
 710         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 711         struct obd_client_handle **och_p;
 712         __u64 *och_usecount;
 713         int rc = 0;
 714         ENTRY;
 715
 716         /* Get the openhandle of the file */
 717         mutex_lock(&lli->lli_och_mutex);
 718         if (fd->fd_lease_och != NULL)
 719                 GOTO(out_unlock, rc = -EBUSY);
 720
 721         if (fd->fd_och == NULL) {
 722                 if (file->f_mode & FMODE_WRITE) {
 723                         LASSERT(lli->lli_mds_write_och != NULL);
 724                         och_p = &lli->lli_mds_write_och;
 725                         och_usecount = &lli->lli_open_fd_write_count;
 726                 } else {
 727                         LASSERT(lli->lli_mds_read_och != NULL);
 728                         och_p = &lli->lli_mds_read_och;
 729                         och_usecount = &lli->lli_open_fd_read_count;
 730                 }
 731
 732                 if (*och_usecount > 1)
 733                         GOTO(out_unlock, rc = -EBUSY);
 734
 735                 fd->fd_och = *och_p;
 736                 *och_usecount = 0;
 737                 *och_p = NULL;
 738         }
 739
 740         *old_handle = fd->fd_och->och_fh;
 741
 742         EXIT;
 743 out_unlock:
 744         mutex_unlock(&lli->lli_och_mutex);
 745         return rc;
 746 }
 747
 748 /**
 749  * Release ownership on lli_mds_*_och when putting back a file lease.
 750  */
 751 static int ll_lease_och_release(struct inode *inode, struct file *file)
 752 {
 753         struct ll_inode_info *lli = ll_i2info(inode);
 754         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 755         struct obd_client_handle **och_p;
 756         struct obd_client_handle *old_och = NULL;
 757         __u64 *och_usecount;
 758         int rc = 0;
 759         ENTRY;
 760
 761         mutex_lock(&lli->lli_och_mutex);
 762         if (file->f_mode & FMODE_WRITE) {
 763                 och_p = &lli->lli_mds_write_och;
 764                 och_usecount = &lli->lli_open_fd_write_count;
 765         } else {
 766                 och_p = &lli->lli_mds_read_och;
 767                 och_usecount = &lli->lli_open_fd_read_count;
 768         }
 769
 770         /* The file may have been open by another process (broken lease) so
 771          * *och_p is not NULL. In this case we should simply increase usecount
 772          * and close fd_och.
 773          */
 774         if (*och_p != NULL) {
 775                 old_och = fd->fd_och;
 776                 (*och_usecount)++;
 777         } else {
 778                 *och_p = fd->fd_och;
 779                 *och_usecount = 1;
 780         }
 781         fd->fd_och = NULL;
 782         mutex_unlock(&lli->lli_och_mutex);
 783
 784         if (old_och != NULL)
 785                 rc = ll_close_inode_openhandle(inode, old_och, 0, NULL);
 786
 787         RETURN(rc);
 788 }
 789
 790 /**
 791  * Acquire a lease and open the file.
 792  */
 793 static struct obd_client_handle *
 794 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
 795               __u64 open_flags)
 796 {
 797         struct lookup_intent it = { .it_op = IT_OPEN };
 798         struct ll_sb_info *sbi = ll_i2sbi(inode);
 799         struct md_op_data *op_data;
 800         struct ptlrpc_request *req = NULL;
 801         struct lustre_handle old_handle = { 0 };
 802         struct obd_client_handle *och = NULL;
 803         int rc;
 804         int rc2;
 805         ENTRY;
 806
 807         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
 808                 RETURN(ERR_PTR(-EINVAL));
 809
 810         if (file != NULL) {
 811                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
 812                         RETURN(ERR_PTR(-EPERM));
 813
 814                 rc = ll_lease_och_acquire(inode, file, &old_handle);
 815                 if (rc)
 816                         RETURN(ERR_PTR(rc));
 817         }
 818
 819         OBD_ALLOC_PTR(och);
 820         if (och == NULL)
 821                 RETURN(ERR_PTR(-ENOMEM));
 822
 823         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
 824                                         LUSTRE_OPC_ANY, NULL);
 825         if (IS_ERR(op_data))
 826                 GOTO(out, rc = PTR_ERR(op_data));
 827
 828         /* To tell the MDT this openhandle is from the same owner */
 829         op_data->op_handle = old_handle;
 830
 831         it.it_flags = fmode | open_flags;
 832         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
 833         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
 834                             &ll_md_blocking_lease_ast,
 835         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
 836          * it can be cancelled which may mislead applications that the lease is
 837          * broken;
 838          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
 839          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
 840          * doesn't deal with openhandle, so normal openhandle will be leaked. */
 841                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
 842         ll_finish_md_op_data(op_data);
 843         ptlrpc_req_finished(req);
 844         if (rc < 0)
 845                 GOTO(out_release_it, rc);
 846
 847         if (it_disposition(&it, DISP_LOOKUP_NEG))
 848                 GOTO(out_release_it, rc = -ENOENT);
 849
 850         rc = it_open_error(DISP_OPEN_OPEN, &it);
 851         if (rc)
 852                 GOTO(out_release_it, rc);
 853
 854         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
 855         ll_och_fill(sbi->ll_md_exp, &it, och);
 856
 857         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
 858                 GOTO(out_close, rc = -EOPNOTSUPP);
 859
 860         /* already get lease, handle lease lock */
 861         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
 862         if (it.it_lock_mode == 0 ||
 863             it.it_lock_bits != MDS_INODELOCK_OPEN) {
 864                 /* open lock must return for lease */
 865                 CERROR(DFID "lease granted but no open lock, %d/%llu.\n",
 866                         PFID(ll_inode2fid(inode)), it.it_lock_mode,
 867                         it.it_lock_bits);
 868                 GOTO(out_close, rc = -EPROTO);
 869         }
 870
 871         ll_intent_release(&it);
 872         RETURN(och);
 873
 874 out_close:
 875         /* Cancel open lock */
 876         if (it.it_lock_mode != 0) {
 877                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
 878                                             it.it_lock_mode);
 879                 it.it_lock_mode = 0;
 880                 och->och_lease_handle.cookie = 0ULL;
 881         }
 882         rc2 = ll_close_inode_openhandle(inode, och, 0, NULL);
 883         if (rc2 < 0)
 884                 CERROR("%s: error closing file "DFID": %d\n",
 885                        ll_get_fsname(inode->i_sb, NULL, 0),
 886                        PFID(&ll_i2info(inode)->lli_fid), rc2);
 887         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
 888 out_release_it:
 889         ll_intent_release(&it);
 890 out:
 891         if (och != NULL)
 892                 OBD_FREE_PTR(och);
 893         RETURN(ERR_PTR(rc));
 894 }
 895
 896 /**
 897  * Check whether a layout swap can be done between two inodes.
 898  *
 899  * \param[in] inode1  First inode to check
 900  * \param[in] inode2  Second inode to check
 901  *
 902  * \retval 0 on success, layout swap can be performed between both inodes
 903  * \retval negative error code if requirements are not met
 904  */
 905 static int ll_check_swap_layouts_validity(struct inode *inode1,
 906                                           struct inode *inode2)
 907 {
 908         if (!S_ISREG(inode1->i_mode) || !S_ISREG(inode2->i_mode))
 909                 return -EINVAL;
 910
 911         if (inode_permission(inode1, MAY_WRITE) ||
 912             inode_permission(inode2, MAY_WRITE))
 913                 return -EPERM;
 914
 915         if (inode1->i_sb != inode2->i_sb)
 916                 return -EXDEV;
 917
 918         return 0;
 919 }
 920
 921 static int ll_swap_layouts_close(struct obd_client_handle *och,
 922                                  struct inode *inode, struct inode *inode2)
 923 {
 924         const struct lu_fid     *fid1 = ll_inode2fid(inode);
 925         const struct lu_fid     *fid2;
 926         int                      rc;
 927         ENTRY;
 928
 929         CDEBUG(D_INODE, "%s: biased close of file "DFID"\n",
 930                ll_get_fsname(inode->i_sb, NULL, 0), PFID(fid1));
 931
 932         rc = ll_check_swap_layouts_validity(inode, inode2);
 933         if (rc < 0)
 934                 GOTO(out_free_och, rc);
 935
 936         /* We now know that inode2 is a lustre inode */
 937         fid2 = ll_inode2fid(inode2);
 938
 939         rc = lu_fid_cmp(fid1, fid2);
 940         if (rc == 0)
 941                 GOTO(out_free_och, rc = -EINVAL);
 942
 943         /* Close the file and swap layouts between inode & inode2.
 944          * NB: lease lock handle is released in mdc_close_layout_swap_pack()
 945          * because we still need it to pack l_remote_handle to MDT. */
 946         rc = ll_close_inode_openhandle(inode, och, MDS_CLOSE_LAYOUT_SWAP,
 947                                        inode2);
 948
 949         och = NULL; /* freed in ll_close_inode_openhandle() */
 950
 951 out_free_och:
 952         if (och != NULL)
 953                 OBD_FREE_PTR(och);
 954
 955         RETURN(rc);
 956 }
 957
 958 /**
 959  * Release lease and close the file.
 960  * It will check if the lease has ever broken.
 961  */
 962 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
 963                           bool *lease_broken)
 964 {
 965         struct ldlm_lock *lock;
 966         bool cancelled = true;
 967         int rc;
 968         ENTRY;
 969
 970         lock = ldlm_handle2lock(&och->och_lease_handle);
 971         if (lock != NULL) {
 972                 lock_res_and_lock(lock);
 973                 cancelled = ldlm_is_cancel(lock);
 974                 unlock_res_and_lock(lock);
 975                 LDLM_LOCK_PUT(lock);
 976         }
 977
 978         CDEBUG(D_INODE, "lease for "DFID" broken? %d\n",
 979                PFID(&ll_i2info(inode)->lli_fid), cancelled);
 980
 981         if (!cancelled)
 982                 ldlm_cli_cancel(&och->och_lease_handle, 0);
 983
 984         if (lease_broken != NULL)
 985                 *lease_broken = cancelled;
 986
 987         rc = ll_close_inode_openhandle(inode, och, 0, NULL);
 988         RETURN(rc);
 989 }
 990
 991 int ll_merge_attr(const struct lu_env *env, struct inode *inode)
 992 {
 993         struct ll_inode_info *lli = ll_i2info(inode);
 994         struct cl_object *obj = lli->lli_clob;
 995         struct cl_attr *attr = vvp_env_thread_attr(env);
 996         s64 atime;
 997         s64 mtime;
 998         s64 ctime;
 999         int rc = 0;
1000
1001         ENTRY;
1002
1003         ll_inode_size_lock(inode);
1004
1005         /* Merge timestamps the most recently obtained from MDS with
1006          * timestamps obtained from OSTs.
1007          *
1008          * Do not overwrite atime of inode because it may be refreshed
1009          * by file_accessed() function. If the read was served by cache
1010          * data, there is no RPC to be sent so that atime may not be
1011          * transferred to OSTs at all. MDT only updates atime at close time
1012          * if it's at least 'mdd.*.atime_diff' older.
1013          * All in all, the atime in Lustre does not strictly comply with
1014          * POSIX. Solving this problem needs to send an RPC to MDT for each
1015          * read, this will hurt performance. */
1016         if (LTIME_S(inode->i_atime) < lli->lli_atime || lli->lli_update_atime) {
1017                 LTIME_S(inode->i_atime) = lli->lli_atime;
1018                 lli->lli_update_atime = 0;
1019         }
1020         LTIME_S(inode->i_mtime) = lli->lli_mtime;
1021         LTIME_S(inode->i_ctime) = lli->lli_ctime;
1022
1023         atime = LTIME_S(inode->i_atime);
1024         mtime = LTIME_S(inode->i_mtime);
1025         ctime = LTIME_S(inode->i_ctime);
1026
1027         cl_object_attr_lock(obj);
1028         rc = cl_object_attr_get(env, obj, attr);
1029         cl_object_attr_unlock(obj);
1030
1031         if (rc != 0)
1032                 GOTO(out_size_unlock, rc);
1033
1034         if (atime < attr->cat_atime)
1035                 atime = attr->cat_atime;
1036
1037         if (ctime < attr->cat_ctime)
1038                 ctime = attr->cat_ctime;
1039
1040         if (mtime < attr->cat_mtime)
1041                 mtime = attr->cat_mtime;
1042
1043         CDEBUG(D_VFSTRACE, DFID" updating i_size %llu\n",
1044                PFID(&lli->lli_fid), attr->cat_size);
1045
1046         i_size_write(inode, attr->cat_size);
1047         inode->i_blocks = attr->cat_blocks;
1048
1049         LTIME_S(inode->i_atime) = atime;
1050         LTIME_S(inode->i_mtime) = mtime;
1051         LTIME_S(inode->i_ctime) = ctime;
1052
1053 out_size_unlock:
1054         ll_inode_size_unlock(inode);
1055
1056         RETURN(rc);
1057 }
1058
1059 static bool file_is_noatime(const struct file *file)
1060 {
1061         const struct vfsmount *mnt = file->f_path.mnt;
1062         const struct inode *inode = file_inode((struct file *)file);
1063
1064         /* Adapted from file_accessed() and touch_atime().*/
1065         if (file->f_flags & O_NOATIME)
1066                 return true;
1067
1068         if (inode->i_flags & S_NOATIME)
1069                 return true;
1070
1071         if (IS_NOATIME(inode))
1072                 return true;
1073
1074         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1075                 return true;
1076
1077         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1078                 return true;
1079
1080         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1081                 return true;
1082
1083         return false;
1084 }
1085
1086 static int ll_file_io_ptask(struct cfs_ptask *ptask);
1087
1088 static void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot)
1089 {
1090         struct inode *inode = file_inode(file);
1091
1092         memset(&io->u.ci_rw.rw_iter, 0, sizeof(io->u.ci_rw.rw_iter));
1093         init_sync_kiocb(&io->u.ci_rw.rw_iocb, file);
1094         io->u.ci_rw.rw_file = file;
1095         io->u.ci_rw.rw_ptask = ll_file_io_ptask;
1096         io->u.ci_rw.rw_nonblock = !!(file->f_flags & O_NONBLOCK);
1097         if (iot == CIT_WRITE) {
1098                 io->u.ci_rw.rw_append = !!(file->f_flags & O_APPEND);
1099                 io->u.ci_rw.rw_sync   = !!(file->f_flags & O_SYNC ||
1100                                            file->f_flags & O_DIRECT ||
1101                                            IS_SYNC(inode));
1102         }
1103         io->ci_obj = ll_i2info(inode)->lli_clob;
1104         io->ci_lockreq = CILR_MAYBE;
1105         if (ll_file_nolock(file)) {
1106                 io->ci_lockreq = CILR_NEVER;
1107                 io->ci_no_srvlock = 1;
1108         } else if (file->f_flags & O_APPEND) {
1109                 io->ci_lockreq = CILR_MANDATORY;
1110         }
1111         io->ci_noatime = file_is_noatime(file);
1112         if (ll_i2sbi(inode)->ll_flags & LL_SBI_PIO)
1113                 io->ci_pio = !io->u.ci_rw.rw_append;
1114         else
1115                 io->ci_pio = 0;
1116 }
1117
1118 static int ll_file_io_ptask(struct cfs_ptask *ptask)
1119 {
1120         struct cl_io_pt *pt = ptask->pt_cbdata;
1121         struct file *file = pt->cip_file;
1122         struct lu_env *env;
1123         struct cl_io *io;
1124         loff_t pos = pt->cip_pos;
1125         int rc;
1126         __u16 refcheck;
1127         ENTRY;
1128
1129         env = cl_env_get(&refcheck);
1130         if (IS_ERR(env))
1131                 RETURN(PTR_ERR(env));
1132
1133         CDEBUG(D_VFSTRACE, "%s: %s range: [%llu, %llu)\n",
1134                 file_dentry(file)->d_name.name,
1135                 pt->cip_iot == CIT_READ ? "read" : "write",
1136                 pos, pos + pt->cip_count);
1137
1138 restart:
1139         io = vvp_env_thread_io(env);
1140         ll_io_init(io, file, pt->cip_iot);
1141         io->u.ci_rw.rw_iter = pt->cip_iter;
1142         io->u.ci_rw.rw_iocb = pt->cip_iocb;
1143         io->ci_pio = 0; /* It's already in parallel task */
1144
1145         rc = cl_io_rw_init(env, io, pt->cip_iot, pos,
1146                            pt->cip_count - pt->cip_result);
1147         if (!rc) {
1148                 struct vvp_io *vio = vvp_env_io(env);
1149
1150                 vio->vui_io_subtype = IO_NORMAL;
1151                 vio->vui_fd = LUSTRE_FPRIVATE(file);
1152
1153                 ll_cl_add(file, env, io, LCC_RW);
1154                 rc = cl_io_loop(env, io);
1155                 ll_cl_remove(file, env);
1156         } else {
1157                 /* cl_io_rw_init() handled IO */
1158                 rc = io->ci_result;
1159         }
1160
1161         if (OBD_FAIL_CHECK_RESET(OBD_FAIL_LLITE_PTASK_IO_FAIL, 0)) {
1162                 if (io->ci_nob > 0)
1163                         io->ci_nob /= 2;
1164                 rc = -EIO;
1165         }
1166
1167         if (io->ci_nob > 0) {
1168                 pt->cip_result += io->ci_nob;
1169                 iov_iter_advance(&pt->cip_iter, io->ci_nob);
1170                 pos += io->ci_nob;
1171                 pt->cip_iocb.ki_pos = pos;
1172 #ifdef HAVE_KIOCB_KI_LEFT
1173                 pt->cip_iocb.ki_left = pt->cip_count - pt->cip_result;
1174 #elif defined(HAVE_KI_NBYTES)
1175                 pt->cip_iocb.ki_nbytes = pt->cip_count - pt->cip_result;
1176 #endif
1177         }
1178
1179         cl_io_fini(env, io);
1180
1181         if ((rc == 0 || rc == -ENODATA) &&
1182             pt->cip_result < pt->cip_count &&
1183             io->ci_need_restart) {
1184                 CDEBUG(D_VFSTRACE,
1185                         "%s: restart %s range: [%llu, %llu) ret: %zd, rc: %d\n",
1186                         file_dentry(file)->d_name.name,
1187                         pt->cip_iot == CIT_READ ? "read" : "write",
1188                         pos, pos + pt->cip_count - pt->cip_result,
1189                         pt->cip_result, rc);
1190                 goto restart;
1191         }
1192
1193         CDEBUG(D_VFSTRACE, "%s: %s ret: %zd, rc: %d\n",
1194                 file_dentry(file)->d_name.name,
1195                 pt->cip_iot == CIT_READ ? "read" : "write",
1196                 pt->cip_result, rc);
1197
1198         cl_env_put(env, &refcheck);
1199         RETURN(pt->cip_result > 0 ? 0 : rc);
1200 }
1201
1202 static ssize_t
1203 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1204                    struct file *file, enum cl_io_type iot,
1205                    loff_t *ppos, size_t count)
1206 {
1207         struct range_lock       range;
1208         struct vvp_io           *vio = vvp_env_io(env);
1209         struct inode            *inode = file_inode(file);
1210         struct ll_inode_info    *lli = ll_i2info(inode);
1211         struct ll_file_data     *fd  = LUSTRE_FPRIVATE(file);
1212         struct cl_io            *io;
1213         loff_t                  pos = *ppos;
1214         ssize_t                 result = 0;
1215         int                     rc = 0;
1216
1217         ENTRY;
1218
1219         CDEBUG(D_VFSTRACE, "%s: %s range: [%llu, %llu)\n",
1220                 file_dentry(file)->d_name.name,
1221                 iot == CIT_READ ? "read" : "write", pos, pos + count);
1222
1223 restart:
1224         io = vvp_env_thread_io(env);
1225         ll_io_init(io, file, iot);
1226         if (args->via_io_subtype == IO_NORMAL) {
1227                 io->u.ci_rw.rw_iter = *args->u.normal.via_iter;
1228                 io->u.ci_rw.rw_iocb = *args->u.normal.via_iocb;
1229         } else {
1230                 io->ci_pio = 0;
1231         }
1232
1233         if (cl_io_rw_init(env, io, iot, pos, count) == 0) {
1234                 bool range_locked = false;
1235
1236                 if (file->f_flags & O_APPEND)
1237                         range_lock_init(&range, 0, LUSTRE_EOF);
1238                 else
1239                         range_lock_init(&range, pos, pos + count - 1);
1240
1241                 vio->vui_fd  = LUSTRE_FPRIVATE(file);
1242                 vio->vui_io_subtype = args->via_io_subtype;
1243
1244                 switch (vio->vui_io_subtype) {
1245                 case IO_NORMAL:
1246                         /* Direct IO reads must also take range lock,
1247                          * or multiple reads will try to work on the same pages
1248                          * See LU-6227 for details. */
1249                         if (((iot == CIT_WRITE) ||
1250                             (iot == CIT_READ && (file->f_flags & O_DIRECT))) &&
1251                             !(vio->vui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1252                                 CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1253                                        RL_PARA(&range));
1254                                 rc = range_lock(&lli->lli_write_tree, &range);
1255                                 if (rc < 0)
1256                                         GOTO(out, rc);
1257
1258                                 range_locked = true;
1259                         }
1260                         break;
1261                 case IO_SPLICE:
1262                         vio->u.splice.vui_pipe = args->u.splice.via_pipe;
1263                         vio->u.splice.vui_flags = args->u.splice.via_flags;
1264                         break;
1265                 default:
1266                         CERROR("unknown IO subtype %u\n", vio->vui_io_subtype);
1267                         LBUG();
1268                 }
1269
1270                 ll_cl_add(file, env, io, LCC_RW);
1271                 if (io->ci_pio && iot == CIT_WRITE && !IS_NOSEC(inode) &&
1272                     !lli->lli_inode_locked) {
1273                         inode_lock(inode);
1274                         lli->lli_inode_locked = 1;
1275                 }
1276                 rc = cl_io_loop(env, io);
1277                 if (lli->lli_inode_locked) {
1278                         lli->lli_inode_locked = 0;
1279                         inode_unlock(inode);
1280                 }
1281                 ll_cl_remove(file, env);
1282
1283                 if (range_locked) {
1284                         CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1285                                RL_PARA(&range));
1286                         range_unlock(&lli->lli_write_tree, &range);
1287                 }
1288         } else {
1289                 /* cl_io_rw_init() handled IO */
1290                 rc = io->ci_result;
1291         }
1292
1293         if (io->ci_nob > 0) {
1294                 result += io->ci_nob;
1295                 count  -= io->ci_nob;
1296
1297                 if (args->via_io_subtype == IO_NORMAL) {
1298                         iov_iter_advance(args->u.normal.via_iter, io->ci_nob);
1299                         pos += io->ci_nob;
1300                         args->u.normal.via_iocb->ki_pos = pos;
1301 #ifdef HAVE_KIOCB_KI_LEFT
1302                         args->u.normal.via_iocb->ki_left = count;
1303 #elif defined(HAVE_KI_NBYTES)
1304                         args->u.normal.via_iocb->ki_nbytes = count;
1305 #endif
1306                 } else {
1307                         /* for splice */
1308                         pos = io->u.ci_rw.rw_range.cir_pos;
1309                 }
1310         }
1311 out:
1312         cl_io_fini(env, io);
1313
1314         if ((rc == 0 || rc == -ENODATA) && count > 0 && io->ci_need_restart) {
1315                 CDEBUG(D_VFSTRACE,
1316                         "%s: restart %s range: [%llu, %llu) ret: %zd, rc: %d\n",
1317                         file_dentry(file)->d_name.name,
1318                         iot == CIT_READ ? "read" : "write",
1319                         pos, pos + count, result, rc);
1320                 goto restart;
1321         }
1322
1323         if (iot == CIT_READ) {
1324                 if (result > 0)
1325                         ll_stats_ops_tally(ll_i2sbi(inode),
1326                                            LPROC_LL_READ_BYTES, result);
1327         } else if (iot == CIT_WRITE) {
1328                 if (result > 0) {
1329                         ll_stats_ops_tally(ll_i2sbi(inode),
1330                                            LPROC_LL_WRITE_BYTES, result);
1331                         fd->fd_write_failed = false;
1332                 } else if (result == 0 && rc == 0) {
1333                         rc = io->ci_result;
1334                         if (rc < 0)
1335                                 fd->fd_write_failed = true;
1336                         else
1337                                 fd->fd_write_failed = false;
1338                 } else if (rc != -ERESTARTSYS) {
1339                         fd->fd_write_failed = true;
1340                 }
1341         }
1342
1343         CDEBUG(D_VFSTRACE, "%s: %s *ppos: %llu, pos: %llu, ret: %zd, rc: %d\n",
1344                 file_dentry(file)->d_name.name,
1345                 iot == CIT_READ ? "read" : "write", *ppos, pos, result, rc);
1346
1347         *ppos = pos;
1348
1349         RETURN(result > 0 ? result : rc);
1350 }
1351
1352 /**
1353  * The purpose of fast read is to overcome per I/O overhead and improve IOPS
1354  * especially for small I/O.
1355  *
1356  * To serve a read request, CLIO has to create and initialize a cl_io and
1357  * then request DLM lock. This has turned out to have siginificant overhead
1358  * and affects the performance of small I/O dramatically.
1359  *
1360  * It's not necessary to create a cl_io for each I/O. Under the help of read
1361  * ahead, most of the pages being read are already in memory cache and we can
1362  * read those pages directly because if the pages exist, the corresponding DLM
1363  * lock must exist so that page content must be valid.
1364  *
1365  * In fast read implementation, the llite speculatively finds and reads pages
1366  * in memory cache. There are three scenarios for fast read:
1367  *   - If the page exists and is uptodate, kernel VM will provide the data and
1368  *     CLIO won't be intervened;
1369  *   - If the page was brought into memory by read ahead, it will be exported
1370  *     and read ahead parameters will be updated;
1371  *   - Otherwise the page is not in memory, we can't do fast read. Therefore,
1372  *     it will go back and invoke normal read, i.e., a cl_io will be created
1373  *     and DLM lock will be requested.
1374  *
1375  * POSIX compliance: posix standard states that read is intended to be atomic.
1376  * Lustre read implementation is in line with Linux kernel read implementation
1377  * and neither of them complies with POSIX standard in this matter. Fast read
1378  * doesn't make the situation worse on single node but it may interleave write
1379  * results from multiple nodes due to short read handling in ll_file_aio_read().
1380  *
1381  * \param env - lu_env
1382  * \param iocb - kiocb from kernel
1383  * \param iter - user space buffers where the data will be copied
1384  *
1385  * \retval - number of bytes have been read, or error code if error occurred.
1386  */
1387 static ssize_t
1388 ll_do_fast_read(const struct lu_env *env, struct kiocb *iocb,
1389                 struct iov_iter *iter)
1390 {
1391         ssize_t result;
1392
1393         if (!ll_sbi_has_fast_read(ll_i2sbi(file_inode(iocb->ki_filp))))
1394                 return 0;
1395
1396         /* NB: we can't do direct IO for fast read because it will need a lock
1397          * to make IO engine happy. */
1398         if (iocb->ki_filp->f_flags & O_DIRECT)
1399                 return 0;
1400
1401         ll_cl_add(iocb->ki_filp, env, NULL, LCC_RW);
1402         result = generic_file_read_iter(iocb, iter);
1403         ll_cl_remove(iocb->ki_filp, env);
1404
1405         /* If the first page is not in cache, generic_file_aio_read() will be
1406          * returned with -ENODATA.
1407          * See corresponding code in ll_readpage(). */
1408         if (result == -ENODATA)
1409                 result = 0;
1410
1411         if (result > 0)
1412                 ll_stats_ops_tally(ll_i2sbi(file_inode(iocb->ki_filp)),
1413                                 LPROC_LL_READ_BYTES, result);
1414
1415         return result;
1416 }
1417
1418 /*
1419  * Read from a file (through the page cache).
1420  */
1421 static ssize_t ll_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
1422 {
1423         struct lu_env *env;
1424         struct vvp_io_args *args;
1425         ssize_t result;
1426         ssize_t rc2;
1427         __u16 refcheck;
1428
1429         env = cl_env_get(&refcheck);
1430         if (IS_ERR(env))
1431                 return PTR_ERR(env);
1432
1433         result = ll_do_fast_read(env, iocb, to);
1434         if (result < 0 || iov_iter_count(to) == 0)
1435                 GOTO(out, result);
1436
1437         args = ll_env_args(env, IO_NORMAL);
1438         args->u.normal.via_iter = to;
1439         args->u.normal.via_iocb = iocb;
1440
1441         rc2 = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1442                                  &iocb->ki_pos, iov_iter_count(to));
1443         if (rc2 > 0)
1444                 result += rc2;
1445         else if (result == 0)
1446                 result = rc2;
1447
1448 out:
1449         cl_env_put(env, &refcheck);
1450         return result;
1451 }
1452
1453 /*
1454  * Write to a file (through the page cache).
1455  */
1456 static ssize_t ll_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1457 {
1458         struct vvp_io_args *args;
1459         struct lu_env *env;
1460         ssize_t result;
1461         __u16 refcheck;
1462
1463         env = cl_env_get(&refcheck);
1464         if (IS_ERR(env))
1465                 return PTR_ERR(env);
1466
1467         args = ll_env_args(env, IO_NORMAL);
1468         args->u.normal.via_iter = from;
1469         args->u.normal.via_iocb = iocb;
1470
1471         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1472                                     &iocb->ki_pos, iov_iter_count(from));
1473         cl_env_put(env, &refcheck);
1474         return result;
1475 }
1476
1477 #ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
1478 /*
1479  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1480  */
1481 static int ll_file_get_iov_count(const struct iovec *iov,
1482                                  unsigned long *nr_segs, size_t *count)
1483 {
1484         size_t cnt = 0;
1485         unsigned long seg;
1486
1487         for (seg = 0; seg < *nr_segs; seg++) {
1488                 const struct iovec *iv = &iov[seg];
1489
1490                 /*
1491                  * If any segment has a negative length, or the cumulative
1492                  * length ever wraps negative then return -EINVAL.
1493                  */
1494                 cnt += iv->iov_len;
1495                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1496                         return -EINVAL;
1497                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
1498                         continue;
1499                 if (seg == 0)
1500                         return -EFAULT;
1501                 *nr_segs = seg;
1502                 cnt -= iv->iov_len;     /* This segment is no good */
1503                 break;
1504         }
1505         *count = cnt;
1506         return 0;
1507 }
1508
1509 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1510                                 unsigned long nr_segs, loff_t pos)
1511 {
1512         struct iov_iter to;
1513         size_t iov_count;
1514         ssize_t result;
1515         ENTRY;
1516
1517         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count);
1518         if (result)
1519                 RETURN(result);
1520
1521 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
1522         iov_iter_init(&to, READ, iov, nr_segs, iov_count);
1523 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
1524         iov_iter_init(&to, iov, nr_segs, iov_count, 0);
1525 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
1526
1527         result = ll_file_read_iter(iocb, &to);
1528
1529         RETURN(result);
1530 }
1531
1532 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
1533                             loff_t *ppos)
1534 {
1535         struct lu_env *env;
1536         struct iovec   iov = { .iov_base = buf, .iov_len = count };
1537         struct kiocb  *kiocb;
1538         ssize_t        result;
1539         __u16          refcheck;
1540         ENTRY;
1541
1542         env = cl_env_get(&refcheck);
1543         if (IS_ERR(env))
1544                 RETURN(PTR_ERR(env));
1545
1546         kiocb = &ll_env_info(env)->lti_kiocb;
1547         init_sync_kiocb(kiocb, file);
1548         kiocb->ki_pos = *ppos;
1549 #ifdef HAVE_KIOCB_KI_LEFT
1550         kiocb->ki_left = count;
1551 #elif defined(HAVE_KI_NBYTES)
1552         kiocb->ki_nbytes = count;
1553 #endif
1554
1555         result = ll_file_aio_read(kiocb, &iov, 1, kiocb->ki_pos);
1556         *ppos = kiocb->ki_pos;
1557
1558         cl_env_put(env, &refcheck);
1559         RETURN(result);
1560 }
1561
1562 /*
1563  * Write to a file (through the page cache).
1564  * AIO stuff
1565  */
1566 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1567                                  unsigned long nr_segs, loff_t pos)
1568 {
1569         struct iov_iter from;
1570         size_t iov_count;
1571         ssize_t result;
1572         ENTRY;
1573
1574         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count);
1575         if (result)
1576                 RETURN(result);
1577
1578 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
1579         iov_iter_init(&from, WRITE, iov, nr_segs, iov_count);
1580 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
1581         iov_iter_init(&from, iov, nr_segs, iov_count, 0);
1582 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
1583
1584         result = ll_file_write_iter(iocb, &from);
1585
1586         RETURN(result);
1587 }
1588
1589 static ssize_t ll_file_write(struct file *file, const char __user *buf,
1590                              size_t count, loff_t *ppos)
1591 {
1592         struct lu_env *env;
1593         struct iovec   iov = { .iov_base = (void __user *)buf,
1594                                .iov_len = count };
1595         struct kiocb  *kiocb;
1596         ssize_t        result;
1597         __u16          refcheck;
1598         ENTRY;
1599
1600         env = cl_env_get(&refcheck);
1601         if (IS_ERR(env))
1602                 RETURN(PTR_ERR(env));
1603
1604         kiocb = &ll_env_info(env)->lti_kiocb;
1605         init_sync_kiocb(kiocb, file);
1606         kiocb->ki_pos = *ppos;
1607 #ifdef HAVE_KIOCB_KI_LEFT
1608         kiocb->ki_left = count;
1609 #elif defined(HAVE_KI_NBYTES)
1610         kiocb->ki_nbytes = count;
1611 #endif
1612
1613         result = ll_file_aio_write(kiocb, &iov, 1, kiocb->ki_pos);
1614         *ppos = kiocb->ki_pos;
1615
1616         cl_env_put(env, &refcheck);
1617         RETURN(result);
1618 }
1619 #endif /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
1620
1621 /*
1622  * Send file content (through pagecache) somewhere with helper
1623  */
1624 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1625                                    struct pipe_inode_info *pipe, size_t count,
1626                                    unsigned int flags)
1627 {
1628         struct lu_env      *env;
1629         struct vvp_io_args *args;
1630         ssize_t             result;
1631         __u16               refcheck;
1632         ENTRY;
1633
1634         env = cl_env_get(&refcheck);
1635         if (IS_ERR(env))
1636                 RETURN(PTR_ERR(env));
1637
1638         args = ll_env_args(env, IO_SPLICE);
1639         args->u.splice.via_pipe = pipe;
1640         args->u.splice.via_flags = flags;
1641
1642         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1643         cl_env_put(env, &refcheck);
1644         RETURN(result);
1645 }
1646
1647 int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
1648                              __u64 flags, struct lov_user_md *lum, int lum_size)
1649 {
1650         struct lookup_intent oit = {
1651                 .it_op = IT_OPEN,
1652                 .it_flags = flags | MDS_OPEN_BY_FID,
1653         };
1654         int rc;
1655         ENTRY;
1656
1657         ll_inode_size_lock(inode);
1658         rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
1659         if (rc < 0)
1660                 GOTO(out_unlock, rc);
1661
1662         ll_release_openhandle(dentry, &oit);
1663
1664 out_unlock:
1665         ll_inode_size_unlock(inode);
1666         ll_intent_release(&oit);
1667
1668         RETURN(rc);
1669 }
1670
1671 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1672                              struct lov_mds_md **lmmp, int *lmm_size,
1673                              struct ptlrpc_request **request)
1674 {
1675         struct ll_sb_info *sbi = ll_i2sbi(inode);
1676         struct mdt_body  *body;
1677         struct lov_mds_md *lmm = NULL;
1678         struct ptlrpc_request *req = NULL;
1679         struct md_op_data *op_data;
1680         int rc, lmmsize;
1681
1682         rc = ll_get_default_mdsize(sbi, &lmmsize);
1683         if (rc)
1684                 RETURN(rc);
1685
1686         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1687                                      strlen(filename), lmmsize,
1688                                      LUSTRE_OPC_ANY, NULL);
1689         if (IS_ERR(op_data))
1690                 RETURN(PTR_ERR(op_data));
1691
1692         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1693         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1694         ll_finish_md_op_data(op_data);
1695         if (rc < 0) {
1696                 CDEBUG(D_INFO, "md_getattr_name failed "
1697                        "on %s: rc %d\n", filename, rc);
1698                 GOTO(out, rc);
1699         }
1700
1701         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1702         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1703
1704         lmmsize = body->mbo_eadatasize;
1705
1706         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1707                         lmmsize == 0) {
1708                 GOTO(out, rc = -ENODATA);
1709         }
1710
1711         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1712         LASSERT(lmm != NULL);
1713
1714         if (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1) &&
1715             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3) &&
1716             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_COMP_V1))
1717                 GOTO(out, rc = -EPROTO);
1718
1719         /*
1720          * This is coming from the MDS, so is probably in
1721          * little endian.  We convert it to host endian before
1722          * passing it to userspace.
1723          */
1724         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1725                 int stripe_count;
1726
1727                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
1728                     lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1729                         stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1730                         if (le32_to_cpu(lmm->lmm_pattern) &
1731                             LOV_PATTERN_F_RELEASED)
1732                                 stripe_count = 0;
1733                 }
1734
1735                 /* if function called for directory - we should
1736                  * avoid swab not existent lsm objects */
1737                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1738                         lustre_swab_lov_user_md_v1(
1739                                         (struct lov_user_md_v1 *)lmm);
1740                         if (S_ISREG(body->mbo_mode))
1741                                 lustre_swab_lov_user_md_objects(
1742                                     ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1743                                     stripe_count);
1744                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1745                         lustre_swab_lov_user_md_v3(
1746                                         (struct lov_user_md_v3 *)lmm);
1747                         if (S_ISREG(body->mbo_mode))
1748                                 lustre_swab_lov_user_md_objects(
1749                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1750                                  stripe_count);
1751                 } else if (lmm->lmm_magic ==
1752                            cpu_to_le32(LOV_MAGIC_COMP_V1)) {
1753                         lustre_swab_lov_comp_md_v1(
1754                                         (struct lov_comp_md_v1 *)lmm);
1755                 }
1756         }
1757
1758 out:
1759         *lmmp = lmm;
1760         *lmm_size = lmmsize;
1761         *request = req;
1762         return rc;
1763 }
1764
1765 static int ll_lov_setea(struct inode *inode, struct file *file,
1766                             unsigned long arg)
1767 {
1768         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1769         struct lov_user_md      *lump;
1770         int                      lum_size = sizeof(struct lov_user_md) +
1771                                             sizeof(struct lov_user_ost_data);
1772         int                      rc;
1773         ENTRY;
1774
1775         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1776                 RETURN(-EPERM);
1777
1778         OBD_ALLOC_LARGE(lump, lum_size);
1779         if (lump == NULL)
1780                 RETURN(-ENOMEM);
1781
1782         if (copy_from_user(lump, (struct lov_user_md __user *)arg, lum_size))
1783                 GOTO(out_lump, rc = -EFAULT);
1784
1785         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, lump,
1786                                       lum_size);
1787         cl_lov_delay_create_clear(&file->f_flags);
1788
1789 out_lump:
1790         OBD_FREE_LARGE(lump, lum_size);
1791         RETURN(rc);
1792 }
1793
1794 static int ll_file_getstripe(struct inode *inode,
1795                              struct lov_user_md __user *lum)
1796 {
1797         struct lu_env   *env;
1798         __u16           refcheck;
1799         int             rc;
1800         ENTRY;
1801
1802         env = cl_env_get(&refcheck);
1803         if (IS_ERR(env))
1804                 RETURN(PTR_ERR(env));
1805
1806         rc = cl_object_getstripe(env, ll_i2info(inode)->lli_clob, lum);
1807         cl_env_put(env, &refcheck);
1808         RETURN(rc);
1809 }
1810
1811 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1812                             unsigned long arg)
1813 {
1814         struct lov_user_md __user *lum = (struct lov_user_md __user *)arg;
1815         struct lov_user_md        *klum;
1816         int                        lum_size, rc;
1817         __u64                      flags = FMODE_WRITE;
1818         ENTRY;
1819
1820         rc = ll_copy_user_md(lum, &klum);
1821         if (rc < 0)
1822                 RETURN(rc);
1823
1824         lum_size = rc;
1825         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, klum,
1826                                       lum_size);
1827         cl_lov_delay_create_clear(&file->f_flags);
1828         OBD_FREE(klum, lum_size);
1829         RETURN(rc);
1830 }
1831
1832 static int
1833 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1834 {
1835         struct ll_inode_info *lli = ll_i2info(inode);
1836         struct cl_object *obj = lli->lli_clob;
1837         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1838         struct ll_grouplock grouplock;
1839         int rc;
1840         ENTRY;
1841
1842         if (arg == 0) {
1843                 CWARN("group id for group lock must not be 0\n");
1844                 RETURN(-EINVAL);
1845         }
1846
1847         if (ll_file_nolock(file))
1848                 RETURN(-EOPNOTSUPP);
1849
1850         spin_lock(&lli->lli_lock);
1851         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1852                 CWARN("group lock already existed with gid %lu\n",
1853                       fd->fd_grouplock.lg_gid);
1854                 spin_unlock(&lli->lli_lock);
1855                 RETURN(-EINVAL);
1856         }
1857         LASSERT(fd->fd_grouplock.lg_lock == NULL);
1858         spin_unlock(&lli->lli_lock);
1859
1860         /**
1861          * XXX: group lock needs to protect all OST objects while PFL
1862          * can add new OST objects during the IO, so we'd instantiate
1863          * all OST objects before getting its group lock.
1864          */
1865         if (obj) {
1866                 struct lu_env *env;
1867                 __u16 refcheck;
1868                 struct cl_layout cl = {
1869                         .cl_is_composite = false,
1870                 };
1871
1872                 env = cl_env_get(&refcheck);
1873                 if (IS_ERR(env))
1874                         RETURN(PTR_ERR(env));
1875
1876                 rc = cl_object_layout_get(env, obj, &cl);
1877                 if (!rc && cl.cl_is_composite)
1878                         rc = ll_layout_write_intent(inode, 0, OBD_OBJECT_EOF);
1879
1880                 cl_env_put(env, &refcheck);
1881                 if (rc)
1882                         RETURN(rc);
1883         }
1884
1885         rc = cl_get_grouplock(ll_i2info(inode)->lli_clob,
1886                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1887         if (rc)
1888                 RETURN(rc);
1889
1890         spin_lock(&lli->lli_lock);
1891         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1892                 spin_unlock(&lli->lli_lock);
1893                 CERROR("another thread just won the race\n");
1894                 cl_put_grouplock(&grouplock);
1895                 RETURN(-EINVAL);
1896         }
1897
1898         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1899         fd->fd_grouplock = grouplock;
1900         spin_unlock(&lli->lli_lock);
1901
1902         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1903         RETURN(0);
1904 }
1905
1906 static int ll_put_grouplock(struct inode *inode, struct file *file,
1907                             unsigned long arg)
1908 {
1909         struct ll_inode_info   *lli = ll_i2info(inode);
1910         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1911         struct ll_grouplock     grouplock;
1912         ENTRY;
1913
1914         spin_lock(&lli->lli_lock);
1915         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1916                 spin_unlock(&lli->lli_lock);
1917                 CWARN("no group lock held\n");
1918                 RETURN(-EINVAL);
1919         }
1920
1921         LASSERT(fd->fd_grouplock.lg_lock != NULL);
1922
1923         if (fd->fd_grouplock.lg_gid != arg) {
1924                 CWARN("group lock %lu doesn't match current id %lu\n",
1925                       arg, fd->fd_grouplock.lg_gid);
1926                 spin_unlock(&lli->lli_lock);
1927                 RETURN(-EINVAL);
1928         }
1929
1930         grouplock = fd->fd_grouplock;
1931         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1932         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1933         spin_unlock(&lli->lli_lock);
1934
1935         cl_put_grouplock(&grouplock);
1936         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1937         RETURN(0);
1938 }
1939
1940 /**
1941  * Close inode open handle
1942  *
1943  * \param dentry [in]     dentry which contains the inode
1944  * \param it     [in,out] intent which contains open info and result
1945  *
1946  * \retval 0     success
1947  * \retval <0    failure
1948  */
1949 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1950 {
1951         struct inode *inode = dentry->d_inode;
1952         struct obd_client_handle *och;
1953         int rc;
1954         ENTRY;
1955
1956         LASSERT(inode);
1957
1958         /* Root ? Do nothing. */
1959         if (dentry->d_inode->i_sb->s_root == dentry)
1960                 RETURN(0);
1961
1962         /* No open handle to close? Move away */
1963         if (!it_disposition(it, DISP_OPEN_OPEN))
1964                 RETURN(0);
1965
1966         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1967
1968         OBD_ALLOC(och, sizeof(*och));
1969         if (!och)
1970                 GOTO(out, rc = -ENOMEM);
1971
1972         ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
1973
1974         rc = ll_close_inode_openhandle(inode, och, 0, NULL);
1975 out:
1976         /* this one is in place of ll_file_open */
1977         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1978                 ptlrpc_req_finished(it->it_request);
1979                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1980         }
1981         RETURN(rc);
1982 }
1983
1984 /**
1985  * Get size for inode for which FIEMAP mapping is requested.
1986  * Make the FIEMAP get_info call and returns the result.
1987  * \param fiemap        kernel buffer to hold extens
1988  * \param num_bytes     kernel buffer size
1989  */
1990 static int ll_do_fiemap(struct inode *inode, struct fiemap *fiemap,
1991                         size_t num_bytes)
1992 {
1993         struct lu_env                   *env;
1994         __u16                           refcheck;
1995         int                             rc = 0;
1996         struct ll_fiemap_info_key       fmkey = { .lfik_name = KEY_FIEMAP, };
1997         ENTRY;
1998
1999         /* Checks for fiemap flags */
2000         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
2001                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
2002                 return -EBADR;
2003         }
2004
2005         /* Check for FIEMAP_FLAG_SYNC */
2006         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
2007                 rc = filemap_fdatawrite(inode->i_mapping);
2008                 if (rc)
2009                         return rc;
2010         }
2011
2012         env = cl_env_get(&refcheck);
2013         if (IS_ERR(env))
2014                 RETURN(PTR_ERR(env));
2015
2016         if (i_size_read(inode) == 0) {
2017                 rc = ll_glimpse_size(inode);
2018                 if (rc)
2019                         GOTO(out, rc);
2020         }
2021
2022         fmkey.lfik_oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
2023         obdo_from_inode(&fmkey.lfik_oa, inode, OBD_MD_FLSIZE);
2024         obdo_set_parent_fid(&fmkey.lfik_oa, &ll_i2info(inode)->lli_fid);
2025
2026         /* If filesize is 0, then there would be no objects for mapping */
2027         if (fmkey.lfik_oa.o_size == 0) {
2028                 fiemap->fm_mapped_extents = 0;
2029                 GOTO(out, rc = 0);
2030         }
2031
2032         fmkey.lfik_fiemap = *fiemap;
2033
2034         rc = cl_object_fiemap(env, ll_i2info(inode)->lli_clob,
2035                               &fmkey, fiemap, &num_bytes);
2036 out:
2037         cl_env_put(env, &refcheck);
2038         RETURN(rc);
2039 }
2040
2041 int ll_fid2path(struct inode *inode, void __user *arg)
2042 {
2043         struct obd_export       *exp = ll_i2mdexp(inode);
2044         const struct getinfo_fid2path __user *gfin = arg;
2045         __u32                    pathlen;
2046         struct getinfo_fid2path *gfout;
2047         size_t                   outsize;
2048         int                      rc;
2049
2050         ENTRY;
2051
2052         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
2053             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
2054                 RETURN(-EPERM);
2055
2056         /* Only need to get the buflen */
2057         if (get_user(pathlen, &gfin->gf_pathlen))
2058                 RETURN(-EFAULT);
2059
2060         if (pathlen > PATH_MAX)
2061                 RETURN(-EINVAL);
2062
2063         outsize = sizeof(*gfout) + pathlen;
2064         OBD_ALLOC(gfout, outsize);
2065         if (gfout == NULL)
2066                 RETURN(-ENOMEM);
2067
2068         if (copy_from_user(gfout, arg, sizeof(*gfout)))
2069                 GOTO(gf_free, rc = -EFAULT);
2070         /* append root FID after gfout to let MDT know the root FID so that it
2071          * can lookup the correct path, this is mainly for fileset.
2072          * old server without fileset mount support will ignore this. */
2073         *gfout->gf_u.gf_root_fid = *ll_inode2fid(inode);
2074
2075         /* Call mdc_iocontrol */
2076         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
2077         if (rc != 0)
2078                 GOTO(gf_free, rc);
2079
2080         if (copy_to_user(arg, gfout, outsize))
2081                 rc = -EFAULT;
2082
2083 gf_free:
2084         OBD_FREE(gfout, outsize);
2085         RETURN(rc);
2086 }
2087
2088 /*
2089  * Read the data_version for inode.
2090  *
2091  * This value is computed using stripe object version on OST.
2092  * Version is computed using server side locking.
2093  *
2094  * @param flags if do sync on the OST side;
2095  *              0: no sync
2096  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
2097  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
2098  */
2099 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
2100 {
2101         struct cl_object *obj = ll_i2info(inode)->lli_clob;
2102         struct lu_env *env;
2103         struct cl_io *io;
2104         __u16  refcheck;
2105         int result;
2106
2107         ENTRY;
2108
2109         /* If no file object initialized, we consider its version is 0. */
2110         if (obj == NULL) {
2111                 *data_version = 0;
2112                 RETURN(0);
2113         }
2114
2115         env = cl_env_get(&refcheck);
2116         if (IS_ERR(env))
2117                 RETURN(PTR_ERR(env));
2118
2119         io = vvp_env_thread_io(env);
2120         io->ci_obj = obj;
2121         io->u.ci_data_version.dv_data_version = 0;
2122         io->u.ci_data_version.dv_flags = flags;
2123
2124 restart:
2125         if (cl_io_init(env, io, CIT_DATA_VERSION, io->ci_obj) == 0)
2126                 result = cl_io_loop(env, io);
2127         else
2128                 result = io->ci_result;
2129
2130         *data_version = io->u.ci_data_version.dv_data_version;
2131
2132         cl_io_fini(env, io);
2133
2134         if (unlikely(io->ci_need_restart))
2135                 goto restart;
2136
2137         cl_env_put(env, &refcheck);
2138
2139         RETURN(result);
2140 }
2141
2142 /*
2143  * Trigger a HSM release request for the provided inode.
2144  */
2145 int ll_hsm_release(struct inode *inode)
2146 {
2147         struct lu_env *env;
2148         struct obd_client_handle *och = NULL;
2149         __u64 data_version = 0;
2150         int rc;
2151         __u16 refcheck;
2152         ENTRY;
2153
2154         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
2155                ll_get_fsname(inode->i_sb, NULL, 0),
2156                PFID(&ll_i2info(inode)->lli_fid));
2157
2158         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
2159         if (IS_ERR(och))
2160                 GOTO(out, rc = PTR_ERR(och));
2161
2162         /* Grab latest data_version and [am]time values */
2163         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
2164         if (rc != 0)
2165                 GOTO(out, rc);
2166
2167         env = cl_env_get(&refcheck);
2168         if (IS_ERR(env))
2169                 GOTO(out, rc = PTR_ERR(env));
2170
2171         ll_merge_attr(env, inode);
2172         cl_env_put(env, &refcheck);
2173
2174         /* Release the file.
2175          * NB: lease lock handle is released in mdc_hsm_release_pack() because
2176          * we still need it to pack l_remote_handle to MDT. */
2177         rc = ll_close_inode_openhandle(inode, och, MDS_HSM_RELEASE,
2178                                        &data_version);
2179         och = NULL;
2180
2181         EXIT;
2182 out:
2183         if (och != NULL && !IS_ERR(och)) /* close the file */
2184                 ll_lease_close(och, inode, NULL);
2185
2186         return rc;
2187 }
2188
2189 struct ll_swap_stack {
2190         __u64                    dv1;
2191         __u64                    dv2;
2192         struct inode            *inode1;
2193         struct inode            *inode2;
2194         bool                     check_dv1;
2195         bool                     check_dv2;
2196 };
2197
2198 static int ll_swap_layouts(struct file *file1, struct file *file2,
2199                            struct lustre_swap_layouts *lsl)
2200 {
2201         struct mdc_swap_layouts  msl;
2202         struct md_op_data       *op_data;
2203         __u32                    gid;
2204         __u64                    dv;
2205         struct ll_swap_stack    *llss = NULL;
2206         int                      rc;
2207
2208         OBD_ALLOC_PTR(llss);
2209         if (llss == NULL)
2210                 RETURN(-ENOMEM);
2211
2212         llss->inode1 = file_inode(file1);
2213         llss->inode2 = file_inode(file2);
2214
2215         rc = ll_check_swap_layouts_validity(llss->inode1, llss->inode2);
2216         if (rc < 0)
2217                 GOTO(free, rc);
2218
2219         /* we use 2 bool because it is easier to swap than 2 bits */
2220         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2221                 llss->check_dv1 = true;
2222
2223         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2224                 llss->check_dv2 = true;
2225
2226         /* we cannot use lsl->sl_dvX directly because we may swap them */
2227         llss->dv1 = lsl->sl_dv1;
2228         llss->dv2 = lsl->sl_dv2;
2229
2230         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2231         if (rc == 0) /* same file, done! */
2232                 GOTO(free, rc);
2233
2234         if (rc < 0) { /* sequentialize it */
2235                 swap(llss->inode1, llss->inode2);
2236                 swap(file1, file2);
2237                 swap(llss->dv1, llss->dv2);
2238                 swap(llss->check_dv1, llss->check_dv2);
2239         }
2240
2241         gid = lsl->sl_gid;
2242         if (gid != 0) { /* application asks to flush dirty cache */
2243                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2244                 if (rc < 0)
2245                         GOTO(free, rc);
2246
2247                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2248                 if (rc < 0) {
2249                         ll_put_grouplock(llss->inode1, file1, gid);
2250                         GOTO(free, rc);
2251                 }
2252         }
2253
2254         /* ultimate check, before swaping the layouts we check if
2255          * dataversion has changed (if requested) */
2256         if (llss->check_dv1) {
2257                 rc = ll_data_version(llss->inode1, &dv, 0);
2258                 if (rc)
2259                         GOTO(putgl, rc);
2260                 if (dv != llss->dv1)
2261                         GOTO(putgl, rc = -EAGAIN);
2262         }
2263
2264         if (llss->check_dv2) {
2265                 rc = ll_data_version(llss->inode2, &dv, 0);
2266                 if (rc)
2267                         GOTO(putgl, rc);
2268                 if (dv != llss->dv2)
2269                         GOTO(putgl, rc = -EAGAIN);
2270         }
2271
2272         /* struct md_op_data is used to send the swap args to the mdt
2273          * only flags is missing, so we use struct mdc_swap_layouts
2274          * through the md_op_data->op_data */
2275         /* flags from user space have to be converted before they are send to
2276          * server, no flag is sent today, they are only used on the client */
2277         msl.msl_flags = 0;
2278         rc = -ENOMEM;
2279         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2280                                      0, LUSTRE_OPC_ANY, &msl);
2281         if (IS_ERR(op_data))
2282                 GOTO(free, rc = PTR_ERR(op_data));
2283
2284         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2285                            sizeof(*op_data), op_data, NULL);
2286         ll_finish_md_op_data(op_data);
2287
2288         if (rc < 0)
2289                 GOTO(putgl, rc);
2290
2291 putgl:
2292         if (gid != 0) {
2293                 ll_put_grouplock(llss->inode2, file2, gid);
2294                 ll_put_grouplock(llss->inode1, file1, gid);
2295         }
2296
2297 free:
2298         if (llss != NULL)
2299                 OBD_FREE_PTR(llss);
2300
2301         RETURN(rc);
2302 }
2303
2304 int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2305 {
2306         struct md_op_data       *op_data;
2307         int                      rc;
2308         ENTRY;
2309
2310         /* Detect out-of range masks */
2311         if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK)
2312                 RETURN(-EINVAL);
2313
2314         /* Non-root users are forbidden to set or clear flags which are
2315          * NOT defined in HSM_USER_MASK. */
2316         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2317             !cfs_capable(CFS_CAP_SYS_ADMIN))
2318                 RETURN(-EPERM);
2319
2320         /* Detect out-of range archive id */
2321         if ((hss->hss_valid & HSS_ARCHIVE_ID) &&
2322             (hss->hss_archive_id > LL_HSM_MAX_ARCHIVE))
2323                 RETURN(-EINVAL);
2324
2325         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2326                                      LUSTRE_OPC_ANY, hss);
2327         if (IS_ERR(op_data))
2328                 RETURN(PTR_ERR(op_data));
2329
2330         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2331                            sizeof(*op_data), op_data, NULL);
2332
2333         ll_finish_md_op_data(op_data);
2334
2335         RETURN(rc);
2336 }
2337
2338 static int ll_hsm_import(struct inode *inode, struct file *file,
2339                          struct hsm_user_import *hui)
2340 {
2341         struct hsm_state_set    *hss = NULL;
2342         struct iattr            *attr = NULL;
2343         int                      rc;
2344         ENTRY;
2345
2346         if (!S_ISREG(inode->i_mode))
2347                 RETURN(-EINVAL);
2348
2349         /* set HSM flags */
2350         OBD_ALLOC_PTR(hss);
2351         if (hss == NULL)
2352                 GOTO(out, rc = -ENOMEM);
2353
2354         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2355         hss->hss_archive_id = hui->hui_archive_id;
2356         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2357         rc = ll_hsm_state_set(inode, hss);
2358         if (rc != 0)
2359                 GOTO(out, rc);
2360
2361         OBD_ALLOC_PTR(attr);
2362         if (attr == NULL)
2363                 GOTO(out, rc = -ENOMEM);
2364
2365         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2366         attr->ia_mode |= S_IFREG;
2367         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2368         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2369         attr->ia_size = hui->hui_size;
2370         attr->ia_mtime.tv_sec = hui->hui_mtime;
2371         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2372         attr->ia_atime.tv_sec = hui->hui_atime;
2373         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2374
2375         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2376                          ATTR_UID | ATTR_GID |
2377                          ATTR_MTIME | ATTR_MTIME_SET |
2378                          ATTR_ATIME | ATTR_ATIME_SET;
2379
2380         inode_lock(inode);
2381
2382         rc = ll_setattr_raw(file_dentry(file), attr, true);
2383         if (rc == -ENODATA)
2384                 rc = 0;
2385
2386         inode_unlock(inode);
2387
2388 out:
2389         if (hss != NULL)
2390                 OBD_FREE_PTR(hss);
2391
2392         if (attr != NULL)
2393                 OBD_FREE_PTR(attr);
2394
2395         RETURN(rc);
2396 }
2397
2398 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2399 {
2400         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2401                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2402 }
2403
2404 static int ll_file_futimes_3(struct file *file, const struct ll_futimes_3 *lfu)
2405 {
2406         struct inode *inode = file_inode(file);
2407         struct iattr ia = {
2408                 .ia_valid = ATTR_ATIME | ATTR_ATIME_SET |
2409                             ATTR_MTIME | ATTR_MTIME_SET |
2410                             ATTR_CTIME | ATTR_CTIME_SET,
2411                 .ia_atime = {
2412                         .tv_sec = lfu->lfu_atime_sec,
2413                         .tv_nsec = lfu->lfu_atime_nsec,
2414                 },
2415                 .ia_mtime = {
2416                         .tv_sec = lfu->lfu_mtime_sec,
2417                         .tv_nsec = lfu->lfu_mtime_nsec,
2418                 },
2419                 .ia_ctime = {
2420                         .tv_sec = lfu->lfu_ctime_sec,
2421                         .tv_nsec = lfu->lfu_ctime_nsec,
2422                 },
2423         };
2424         int rc;
2425         ENTRY;
2426
2427         if (!capable(CAP_SYS_ADMIN))
2428                 RETURN(-EPERM);
2429
2430         if (!S_ISREG(inode->i_mode))
2431                 RETURN(-EINVAL);
2432
2433         inode_lock(inode);
2434         rc = ll_setattr_raw(file_dentry(file), &ia, false);
2435         inode_unlock(inode);
2436
2437         RETURN(rc);
2438 }
2439
2440 /*
2441  * Give file access advices
2442  *
2443  * The ladvise interface is similar to Linux fadvise() system call, except it
2444  * forwards the advices directly from Lustre client to server. The server side
2445  * codes will apply appropriate read-ahead and caching techniques for the
2446  * corresponding files.
2447  *
2448  * A typical workload for ladvise is e.g. a bunch of different clients are
2449  * doing small random reads of a file, so prefetching pages into OSS cache
2450  * with big linear reads before the random IO is a net benefit. Fetching
2451  * all that data into each client cache with fadvise() may not be, due to
2452  * much more data being sent to the client.
2453  */
2454 static int ll_ladvise(struct inode *inode, struct file *file, __u64 flags,
2455                       struct llapi_lu_ladvise *ladvise)
2456 {
2457         struct lu_env *env;
2458         struct cl_io *io;
2459         struct cl_ladvise_io *lio;
2460         int rc;
2461         __u16 refcheck;
2462         ENTRY;
2463
2464         env = cl_env_get(&refcheck);
2465         if (IS_ERR(env))
2466                 RETURN(PTR_ERR(env));
2467
2468         io = vvp_env_thread_io(env);
2469         io->ci_obj = ll_i2info(inode)->lli_clob;
2470
2471         /* initialize parameters for ladvise */
2472         lio = &io->u.ci_ladvise;
2473         lio->li_start = ladvise->lla_start;
2474         lio->li_end = ladvise->lla_end;
2475         lio->li_fid = ll_inode2fid(inode);
2476         lio->li_advice = ladvise->lla_advice;
2477         lio->li_flags = flags;
2478
2479         if (cl_io_init(env, io, CIT_LADVISE, io->ci_obj) == 0)
2480                 rc = cl_io_loop(env, io);
2481         else
2482                 rc = io->ci_result;
2483
2484         cl_io_fini(env, io);
2485         cl_env_put(env, &refcheck);
2486         RETURN(rc);
2487 }
2488
2489 int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
2490                         unsigned long arg)
2491 {
2492         struct fsxattr fsxattr;
2493
2494         if (copy_from_user(&fsxattr,
2495                            (const struct fsxattr __user *)arg,
2496                            sizeof(fsxattr)))
2497                 RETURN(-EFAULT);
2498
2499         fsxattr.fsx_projid = ll_i2info(inode)->lli_projid;
2500         if (copy_to_user((struct fsxattr __user *)arg,
2501                          &fsxattr, sizeof(fsxattr)))
2502                 RETURN(-EFAULT);
2503
2504         RETURN(0);
2505 }
2506
2507 int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
2508                         unsigned long arg)
2509 {
2510
2511         struct md_op_data *op_data;
2512         struct ptlrpc_request *req = NULL;
2513         int rc = 0;
2514         struct fsxattr fsxattr;
2515
2516         /* only root could change project ID */
2517         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
2518                 RETURN(-EPERM);
2519
2520         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2521                                      LUSTRE_OPC_ANY, NULL);
2522         if (IS_ERR(op_data))
2523                 RETURN(PTR_ERR(op_data));
2524
2525         if (copy_from_user(&fsxattr,
2526                            (const struct fsxattr __user *)arg,
2527                            sizeof(fsxattr)))
2528                 GOTO(out_fsxattr1, rc = -EFAULT);
2529
2530         op_data->op_projid = fsxattr.fsx_projid;
2531         op_data->op_attr.ia_valid |= MDS_ATTR_PROJID;
2532         rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data, NULL,
2533                         0, &req);
2534         ptlrpc_req_finished(req);
2535
2536 out_fsxattr1:
2537         ll_finish_md_op_data(op_data);
2538         RETURN(rc);
2539
2540
2541 }
2542
2543 static long
2544 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2545 {
2546         struct inode            *inode = file_inode(file);
2547         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2548         int                      flags, rc;
2549         ENTRY;
2550
2551         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
2552                PFID(ll_inode2fid(inode)), inode, cmd);
2553         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2554
2555         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2556         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2557                 RETURN(-ENOTTY);
2558
2559         switch(cmd) {
2560         case LL_IOC_GETFLAGS:
2561                 /* Get the current value of the file flags */
2562                 return put_user(fd->fd_flags, (int __user *)arg);
2563         case LL_IOC_SETFLAGS:
2564         case LL_IOC_CLRFLAGS:
2565                 /* Set or clear specific file flags */
2566                 /* XXX This probably needs checks to ensure the flags are
2567                  *     not abused, and to handle any flag side effects.
2568                  */
2569                 if (get_user(flags, (int __user *) arg))
2570                         RETURN(-EFAULT);
2571
2572                 if (cmd == LL_IOC_SETFLAGS) {
2573                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2574                             !(file->f_flags & O_DIRECT)) {
2575                                 CERROR("%s: unable to disable locking on "
2576                                        "non-O_DIRECT file\n", current->comm);
2577                                 RETURN(-EINVAL);
2578                         }
2579
2580                         fd->fd_flags |= flags;
2581                 } else {
2582                         fd->fd_flags &= ~flags;
2583                 }
2584                 RETURN(0);
2585         case LL_IOC_LOV_SETSTRIPE:
2586                 RETURN(ll_lov_setstripe(inode, file, arg));
2587         case LL_IOC_LOV_SETEA:
2588                 RETURN(ll_lov_setea(inode, file, arg));
2589         case LL_IOC_LOV_SWAP_LAYOUTS: {
2590                 struct file *file2;
2591                 struct lustre_swap_layouts lsl;
2592
2593                 if (copy_from_user(&lsl, (char __user *)arg,
2594                                        sizeof(struct lustre_swap_layouts)))
2595                         RETURN(-EFAULT);
2596
2597                 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
2598                         RETURN(-EPERM);
2599
2600                 file2 = fget(lsl.sl_fd);
2601                 if (file2 == NULL)
2602                         RETURN(-EBADF);
2603
2604                 /* O_WRONLY or O_RDWR */
2605                 if ((file2->f_flags & O_ACCMODE) == O_RDONLY)
2606                         GOTO(out, rc = -EPERM);
2607
2608                 if (lsl.sl_flags & SWAP_LAYOUTS_CLOSE) {
2609                         struct inode                    *inode2;
2610                         struct ll_inode_info            *lli;
2611                         struct obd_client_handle        *och = NULL;
2612
2613                         if (lsl.sl_flags != SWAP_LAYOUTS_CLOSE)
2614                                 GOTO(out, rc = -EINVAL);
2615
2616                         lli = ll_i2info(inode);
2617                         mutex_lock(&lli->lli_och_mutex);
2618                         if (fd->fd_lease_och != NULL) {
2619                                 och = fd->fd_lease_och;
2620                                 fd->fd_lease_och = NULL;
2621                         }
2622                         mutex_unlock(&lli->lli_och_mutex);
2623                         if (och == NULL)
2624                                 GOTO(out, rc = -ENOLCK);
2625                         inode2 = file_inode(file2);
2626                         rc = ll_swap_layouts_close(och, inode, inode2);
2627                 } else {
2628                         rc = ll_swap_layouts(file, file2, &lsl);
2629                 }
2630 out:
2631                 fput(file2);
2632                 RETURN(rc);
2633         }
2634         case LL_IOC_LOV_GETSTRIPE:
2635                 RETURN(ll_file_getstripe(inode,
2636                                          (struct lov_user_md __user *)arg));
2637         case FSFILT_IOC_GETFLAGS:
2638         case FSFILT_IOC_SETFLAGS:
2639                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2640         case FSFILT_IOC_GETVERSION_OLD:
2641         case FSFILT_IOC_GETVERSION:
2642                 RETURN(put_user(inode->i_generation, (int __user *)arg));
2643         case LL_IOC_GROUP_LOCK:
2644                 RETURN(ll_get_grouplock(inode, file, arg));
2645         case LL_IOC_GROUP_UNLOCK:
2646                 RETURN(ll_put_grouplock(inode, file, arg));
2647         case IOC_OBD_STATFS:
2648                 RETURN(ll_obd_statfs(inode, (void __user *)arg));
2649
2650         /* We need to special case any other ioctls we want to handle,
2651          * to send them to the MDS/OST as appropriate and to properly
2652          * network encode the arg field.
2653         case FSFILT_IOC_SETVERSION_OLD:
2654         case FSFILT_IOC_SETVERSION:
2655         */
2656         case LL_IOC_FLUSHCTX:
2657                 RETURN(ll_flush_ctx(inode));
2658         case LL_IOC_PATH2FID: {
2659                 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
2660                                  sizeof(struct lu_fid)))
2661                         RETURN(-EFAULT);
2662
2663                 RETURN(0);
2664         }
2665         case LL_IOC_GETPARENT:
2666                 RETURN(ll_getparent(file, (struct getparent __user *)arg));
2667
2668         case OBD_IOC_FID2PATH:
2669                 RETURN(ll_fid2path(inode, (void __user *)arg));
2670         case LL_IOC_DATA_VERSION: {
2671                 struct ioc_data_version idv;
2672                 int rc;
2673
2674                 if (copy_from_user(&idv, (char __user *)arg, sizeof(idv)))
2675                         RETURN(-EFAULT);
2676
2677                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
2678                 rc = ll_data_version(inode, &idv.idv_version, idv.idv_flags);
2679
2680                 if (rc == 0 &&
2681                     copy_to_user((char __user *)arg, &idv, sizeof(idv)))
2682                         RETURN(-EFAULT);
2683
2684                 RETURN(rc);
2685         }
2686
2687         case LL_IOC_GET_MDTIDX: {
2688                 int mdtidx;
2689
2690                 mdtidx = ll_get_mdt_idx(inode);
2691                 if (mdtidx < 0)
2692                         RETURN(mdtidx);
2693
2694                 if (put_user((int)mdtidx, (int __user *)arg))
2695                         RETURN(-EFAULT);
2696
2697                 RETURN(0);
2698         }
2699         case OBD_IOC_GETDTNAME:
2700         case OBD_IOC_GETMDNAME:
2701                 RETURN(ll_get_obd_name(inode, cmd, arg));
2702         case LL_IOC_HSM_STATE_GET: {
2703                 struct md_op_data       *op_data;
2704                 struct hsm_user_state   *hus;
2705                 int                      rc;
2706
2707                 OBD_ALLOC_PTR(hus);
2708                 if (hus == NULL)
2709                         RETURN(-ENOMEM);
2710
2711                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2712                                              LUSTRE_OPC_ANY, hus);
2713                 if (IS_ERR(op_data)) {
2714                         OBD_FREE_PTR(hus);
2715                         RETURN(PTR_ERR(op_data));
2716                 }
2717
2718                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2719                                    op_data, NULL);
2720
2721                 if (copy_to_user((void __user *)arg, hus, sizeof(*hus)))
2722                         rc = -EFAULT;
2723
2724                 ll_finish_md_op_data(op_data);
2725                 OBD_FREE_PTR(hus);
2726                 RETURN(rc);
2727         }
2728         case LL_IOC_HSM_STATE_SET: {
2729                 struct hsm_state_set    *hss;
2730                 int                      rc;
2731
2732                 OBD_ALLOC_PTR(hss);
2733                 if (hss == NULL)
2734                         RETURN(-ENOMEM);
2735
2736                 if (copy_from_user(hss, (char __user *)arg, sizeof(*hss))) {
2737                         OBD_FREE_PTR(hss);
2738                         RETURN(-EFAULT);
2739                 }
2740
2741                 rc = ll_hsm_state_set(inode, hss);
2742
2743                 OBD_FREE_PTR(hss);
2744                 RETURN(rc);
2745         }
2746         case LL_IOC_HSM_ACTION: {
2747                 struct md_op_data               *op_data;
2748                 struct hsm_current_action       *hca;
2749                 int                              rc;
2750
2751                 OBD_ALLOC_PTR(hca);
2752                 if (hca == NULL)
2753                         RETURN(-ENOMEM);
2754
2755                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2756                                              LUSTRE_OPC_ANY, hca);
2757                 if (IS_ERR(op_data)) {
2758                         OBD_FREE_PTR(hca);
2759                         RETURN(PTR_ERR(op_data));
2760                 }
2761
2762                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2763                                    op_data, NULL);
2764
2765                 if (copy_to_user((char __user *)arg, hca, sizeof(*hca)))
2766                         rc = -EFAULT;
2767
2768                 ll_finish_md_op_data(op_data);
2769                 OBD_FREE_PTR(hca);
2770                 RETURN(rc);
2771         }
2772         case LL_IOC_SET_LEASE: {
2773                 struct ll_inode_info *lli = ll_i2info(inode);
2774                 struct obd_client_handle *och = NULL;
2775                 bool lease_broken;
2776                 fmode_t fmode;
2777
2778                 switch (arg) {
2779                 case LL_LEASE_WRLCK:
2780                         if (!(file->f_mode & FMODE_WRITE))
2781                                 RETURN(-EPERM);
2782                         fmode = FMODE_WRITE;
2783                         break;
2784                 case LL_LEASE_RDLCK:
2785                         if (!(file->f_mode & FMODE_READ))
2786                                 RETURN(-EPERM);
2787                         fmode = FMODE_READ;
2788                         break;
2789                 case LL_LEASE_UNLCK:
2790                         mutex_lock(&lli->lli_och_mutex);
2791                         if (fd->fd_lease_och != NULL) {
2792                                 och = fd->fd_lease_och;
2793                                 fd->fd_lease_och = NULL;
2794                         }
2795                         mutex_unlock(&lli->lli_och_mutex);
2796
2797                         if (och == NULL)
2798                                 RETURN(-ENOLCK);
2799
2800                         fmode = och->och_flags;
2801                         rc = ll_lease_close(och, inode, &lease_broken);
2802                         if (rc < 0)
2803                                 RETURN(rc);
2804
2805                         rc = ll_lease_och_release(inode, file);
2806                         if (rc < 0)
2807                                 RETURN(rc);
2808
2809                         if (lease_broken)
2810                                 fmode = 0;
2811
2812                         RETURN(ll_lease_type_from_fmode(fmode));
2813                 default:
2814                         RETURN(-EINVAL);
2815                 }
2816
2817                 CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
2818
2819                 /* apply for lease */
2820                 och = ll_lease_open(inode, file, fmode, 0);
2821                 if (IS_ERR(och))
2822                         RETURN(PTR_ERR(och));
2823
2824                 rc = 0;
2825                 mutex_lock(&lli->lli_och_mutex);
2826                 if (fd->fd_lease_och == NULL) {
2827                         fd->fd_lease_och = och;
2828                         och = NULL;
2829                 }
2830                 mutex_unlock(&lli->lli_och_mutex);
2831                 if (och != NULL) {
2832                         /* impossible now that only excl is supported for now */
2833                         ll_lease_close(och, inode, &lease_broken);
2834                         rc = -EBUSY;
2835                 }
2836                 RETURN(rc);
2837         }
2838         case LL_IOC_GET_LEASE: {
2839                 struct ll_inode_info *lli = ll_i2info(inode);
2840                 struct ldlm_lock *lock = NULL;
2841                 fmode_t fmode = 0;
2842
2843                 mutex_lock(&lli->lli_och_mutex);
2844                 if (fd->fd_lease_och != NULL) {
2845                         struct obd_client_handle *och = fd->fd_lease_och;
2846
2847                         lock = ldlm_handle2lock(&och->och_lease_handle);
2848                         if (lock != NULL) {
2849                                 lock_res_and_lock(lock);
2850                                 if (!ldlm_is_cancel(lock))
2851                                         fmode = och->och_flags;
2852
2853                                 unlock_res_and_lock(lock);
2854                                 LDLM_LOCK_PUT(lock);
2855                         }
2856                 }
2857                 mutex_unlock(&lli->lli_och_mutex);
2858
2859                 RETURN(ll_lease_type_from_fmode(fmode));
2860         }
2861         case LL_IOC_HSM_IMPORT: {
2862                 struct hsm_user_import *hui;
2863
2864                 OBD_ALLOC_PTR(hui);
2865                 if (hui == NULL)
2866                         RETURN(-ENOMEM);
2867
2868                 if (copy_from_user(hui, (void __user *)arg, sizeof(*hui))) {
2869                         OBD_FREE_PTR(hui);
2870                         RETURN(-EFAULT);
2871                 }
2872
2873                 rc = ll_hsm_import(inode, file, hui);
2874
2875                 OBD_FREE_PTR(hui);
2876                 RETURN(rc);
2877         }
2878         case LL_IOC_FUTIMES_3: {
2879                 struct ll_futimes_3 lfu;
2880
2881                 if (copy_from_user(&lfu,
2882                                    (const struct ll_futimes_3 __user *)arg,
2883                                    sizeof(lfu)))
2884                         RETURN(-EFAULT);
2885
2886                 RETURN(ll_file_futimes_3(file, &lfu));
2887         }
2888         case LL_IOC_LADVISE: {
2889                 struct llapi_ladvise_hdr *ladvise_hdr;
2890                 int i;
2891                 int num_advise;
2892                 int alloc_size = sizeof(*ladvise_hdr);
2893
2894                 rc = 0;
2895                 OBD_ALLOC_PTR(ladvise_hdr);
2896                 if (ladvise_hdr == NULL)
2897                         RETURN(-ENOMEM);
2898
2899                 if (copy_from_user(ladvise_hdr,
2900                                    (const struct llapi_ladvise_hdr __user *)arg,
2901                                    alloc_size))
2902                         GOTO(out_ladvise, rc = -EFAULT);
2903
2904                 if (ladvise_hdr->lah_magic != LADVISE_MAGIC ||
2905                     ladvise_hdr->lah_count < 1)
2906                         GOTO(out_ladvise, rc = -EINVAL);
2907
2908                 num_advise = ladvise_hdr->lah_count;
2909                 if (num_advise >= LAH_COUNT_MAX)
2910                         GOTO(out_ladvise, rc = -EFBIG);
2911
2912                 OBD_FREE_PTR(ladvise_hdr);
2913                 alloc_size = offsetof(typeof(*ladvise_hdr),
2914                                       lah_advise[num_advise]);
2915                 OBD_ALLOC(ladvise_hdr, alloc_size);
2916                 if (ladvise_hdr == NULL)
2917                         RETURN(-ENOMEM);
2918
2919                 /*
2920                  * TODO: submit multiple advices to one server in a single RPC
2921                  */
2922                 if (copy_from_user(ladvise_hdr,
2923                                    (const struct llapi_ladvise_hdr __user *)arg,
2924                                    alloc_size))
2925                         GOTO(out_ladvise, rc = -EFAULT);
2926
2927                 for (i = 0; i < num_advise; i++) {
2928                         rc = ll_ladvise(inode, file, ladvise_hdr->lah_flags,
2929                                         &ladvise_hdr->lah_advise[i]);
2930                         if (rc)
2931                                 break;
2932                 }
2933
2934 out_ladvise:
2935                 OBD_FREE(ladvise_hdr, alloc_size);
2936                 RETURN(rc);
2937         }
2938         case LL_IOC_FSGETXATTR:
2939                 RETURN(ll_ioctl_fsgetxattr(inode, cmd, arg));
2940         case LL_IOC_FSSETXATTR:
2941                 RETURN(ll_ioctl_fssetxattr(inode, cmd, arg));
2942         default: {
2943                 int err;
2944
2945                 if (LLIOC_STOP ==
2946                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2947                         RETURN(err);
2948
2949                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2950                                      (void __user *)arg));
2951         }
2952         }
2953 }
2954
2955 #ifndef HAVE_FILE_LLSEEK_SIZE
2956 static inline loff_t
2957 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2958 {
2959         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2960                 return -EINVAL;
2961         if (offset > maxsize)
2962                 return -EINVAL;
2963
2964         if (offset != file->f_pos) {
2965                 file->f_pos = offset;
2966                 file->f_version = 0;
2967         }
2968         return offset;
2969 }
2970
2971 static loff_t
2972 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2973                 loff_t maxsize, loff_t eof)
2974 {
2975         struct inode *inode = file_inode(file);
2976
2977         switch (origin) {
2978         case SEEK_END:
2979                 offset += eof;
2980                 break;
2981         case SEEK_CUR:
2982                 /*
2983                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2984                  * position-querying operation.  Avoid rewriting the "same"
2985                  * f_pos value back to the file because a concurrent read(),
2986                  * write() or lseek() might have altered it
2987                  */
2988                 if (offset == 0)
2989                         return file->f_pos;
2990                 /*
2991                  * f_lock protects against read/modify/write race with other
2992                  * SEEK_CURs. Note that parallel writes and reads behave
2993                  * like SEEK_SET.
2994                  */
2995                 inode_lock(inode);
2996                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2997                 inode_unlock(inode);
2998                 return offset;
2999         case SEEK_DATA:
3000                 /*
3001                  * In the generic case the entire file is data, so as long as
3002                  * offset isn't at the end of the file then the offset is data.
3003                  */
3004                 if (offset >= eof)
3005                         return -ENXIO;
3006                 break;
3007         case SEEK_HOLE:
3008                 /*
3009                  * There is a virtual hole at the end of the file, so as long as
3010                  * offset isn't i_size or larger, return i_size.
3011                  */
3012                 if (offset >= eof)
3013                         return -ENXIO;
3014                 offset = eof;
3015                 break;
3016         }
3017
3018         return llseek_execute(file, offset, maxsize);
3019 }
3020 #endif
3021
3022 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
3023 {
3024         struct inode *inode = file_inode(file);
3025         loff_t retval, eof = 0;
3026
3027         ENTRY;
3028         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
3029                            (origin == SEEK_CUR) ? file->f_pos : 0);
3030         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
3031                PFID(ll_inode2fid(inode)), inode, retval, retval,
3032                origin);
3033         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
3034
3035         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
3036                 retval = ll_glimpse_size(inode);
3037                 if (retval != 0)
3038                         RETURN(retval);
3039                 eof = i_size_read(inode);
3040         }
3041
3042         retval = ll_generic_file_llseek_size(file, offset, origin,
3043                                           ll_file_maxbytes(inode), eof);
3044         RETURN(retval);
3045 }
3046
3047 static int ll_flush(struct file *file, fl_owner_t id)
3048 {
3049         struct inode *inode = file_inode(file);
3050         struct ll_inode_info *lli = ll_i2info(inode);
3051         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
3052         int rc, err;
3053
3054         LASSERT(!S_ISDIR(inode->i_mode));
3055
3056         /* catch async errors that were recorded back when async writeback
3057          * failed for pages in this mapping. */
3058         rc = lli->lli_async_rc;
3059         lli->lli_async_rc = 0;
3060         if (lli->lli_clob != NULL) {
3061                 err = lov_read_and_clear_async_rc(lli->lli_clob);
3062                 if (rc == 0)
3063                         rc = err;
3064         }
3065
3066         /* The application has been told write failure already.
3067          * Do not report failure again. */
3068         if (fd->fd_write_failed)
3069                 return 0;
3070         return rc ? -EIO : 0;
3071 }
3072
3073 /**
3074  * Called to make sure a portion of file has been written out.
3075  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
3076  *
3077  * Return how many pages have been written.
3078  */
3079 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
3080                        enum cl_fsync_mode mode, int ignore_layout)
3081 {
3082         struct lu_env *env;
3083         struct cl_io *io;
3084         struct cl_fsync_io *fio;
3085         int result;
3086         __u16 refcheck;
3087         ENTRY;
3088
3089         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
3090             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
3091                 RETURN(-EINVAL);
3092
3093         env = cl_env_get(&refcheck);
3094         if (IS_ERR(env))
3095                 RETURN(PTR_ERR(env));
3096
3097         io = vvp_env_thread_io(env);
3098         io->ci_obj = ll_i2info(inode)->lli_clob;
3099         io->ci_ignore_layout = ignore_layout;
3100
3101         /* initialize parameters for sync */
3102         fio = &io->u.ci_fsync;
3103         fio->fi_start = start;
3104         fio->fi_end = end;
3105         fio->fi_fid = ll_inode2fid(inode);
3106         fio->fi_mode = mode;
3107         fio->fi_nr_written = 0;
3108
3109         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
3110                 result = cl_io_loop(env, io);
3111         else
3112                 result = io->ci_result;
3113         if (result == 0)
3114                 result = fio->fi_nr_written;
3115         cl_io_fini(env, io);
3116         cl_env_put(env, &refcheck);
3117
3118         RETURN(result);
3119 }
3120
3121 /*
3122  * When dentry is provided (the 'else' case), file_dentry() may be
3123  * null and dentry must be used directly rather than pulled from
3124  * file_dentry() as is done otherwise.
3125  */
3126
3127 #ifdef HAVE_FILE_FSYNC_4ARGS
3128 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
3129 {
3130         struct dentry *dentry = file_dentry(file);
3131         bool lock_inode;
3132 #elif defined(HAVE_FILE_FSYNC_2ARGS)
3133 int ll_fsync(struct file *file, int datasync)
3134 {
3135         struct dentry *dentry = file_dentry(file);
3136         loff_t start = 0;
3137         loff_t end = LLONG_MAX;
3138 #else
3139 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
3140 {
3141         loff_t start = 0;
3142         loff_t end = LLONG_MAX;
3143 #endif
3144         struct inode *inode = dentry->d_inode;
3145         struct ll_inode_info *lli = ll_i2info(inode);
3146         struct ptlrpc_request *req;
3147         int rc, err;
3148         ENTRY;
3149
3150         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
3151                PFID(ll_inode2fid(inode)), inode);
3152         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
3153
3154 #ifdef HAVE_FILE_FSYNC_4ARGS
3155         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
3156         lock_inode = !lli->lli_inode_locked;
3157         if (lock_inode)
3158                 inode_lock(inode);
3159 #else
3160         /* fsync's caller has already called _fdata{sync,write}, we want
3161          * that IO to finish before calling the osc and mdc sync methods */
3162         rc = filemap_fdatawait(inode->i_mapping);
3163 #endif
3164
3165         /* catch async errors that were recorded back when async writeback
3166          * failed for pages in this mapping. */
3167         if (!S_ISDIR(inode->i_mode)) {
3168                 err = lli->lli_async_rc;
3169                 lli->lli_async_rc = 0;
3170                 if (rc == 0)
3171                         rc = err;
3172                 if (lli->lli_clob != NULL) {
3173                         err = lov_read_and_clear_async_rc(lli->lli_clob);
3174                         if (rc == 0)
3175                                 rc = err;
3176                 }
3177         }
3178
3179         err = md_fsync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), &req);
3180         if (!rc)
3181                 rc = err;
3182         if (!err)
3183                 ptlrpc_req_finished(req);
3184
3185         if (S_ISREG(inode->i_mode)) {
3186                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
3187
3188                 err = cl_sync_file_range(inode, start, end, CL_FSYNC_ALL, 0);
3189                 if (rc == 0 && err < 0)
3190                         rc = err;
3191                 if (rc < 0)
3192                         fd->fd_write_failed = true;
3193                 else
3194                         fd->fd_write_failed = false;
3195         }
3196
3197 #ifdef HAVE_FILE_FSYNC_4ARGS
3198         if (lock_inode)
3199                 inode_unlock(inode);
3200 #endif
3201         RETURN(rc);
3202 }
3203
3204 static int
3205 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
3206 {
3207         struct inode *inode = file_inode(file);
3208         struct ll_sb_info *sbi = ll_i2sbi(inode);
3209         struct ldlm_enqueue_info einfo = {
3210                 .ei_type        = LDLM_FLOCK,
3211                 .ei_cb_cp       = ldlm_flock_completion_ast,
3212                 .ei_cbdata      = file_lock,
3213         };
3214         struct md_op_data *op_data;
3215         struct lustre_handle lockh = { 0 };
3216         union ldlm_policy_data flock = { { 0 } };
3217         int fl_type = file_lock->fl_type;
3218         __u64 flags = 0;
3219         int rc;
3220         int rc2 = 0;
3221         ENTRY;
3222
3223         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
3224                PFID(ll_inode2fid(inode)), file_lock);
3225
3226         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
3227
3228         if (file_lock->fl_flags & FL_FLOCK) {
3229                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
3230                 /* flocks are whole-file locks */
3231                 flock.l_flock.end = OFFSET_MAX;
3232                 /* For flocks owner is determined by the local file desctiptor*/
3233                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
3234         } else if (file_lock->fl_flags & FL_POSIX) {
3235                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
3236                 flock.l_flock.start = file_lock->fl_start;
3237                 flock.l_flock.end = file_lock->fl_end;
3238         } else {
3239                 RETURN(-EINVAL);
3240         }
3241         flock.l_flock.pid = file_lock->fl_pid;
3242
3243         /* Somewhat ugly workaround for svc lockd.
3244          * lockd installs custom fl_lmops->lm_compare_owner that checks
3245          * for the fl_owner to be the same (which it always is on local node
3246          * I guess between lockd processes) and then compares pid.
3247          * As such we assign pid to the owner field to make it all work,
3248          * conflict with normal locks is unlikely since pid space and
3249          * pointer space for current->files are not intersecting */
3250         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
3251                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
3252
3253         switch (fl_type) {
3254         case F_RDLCK:
3255                 einfo.ei_mode = LCK_PR;
3256                 break;
3257         case F_UNLCK:
3258                 /* An unlock request may or may not have any relation to
3259                  * existing locks so we may not be able to pass a lock handle
3260                  * via a normal ldlm_lock_cancel() request. The request may even
3261                  * unlock a byte range in the middle of an existing lock. In
3262                  * order to process an unlock request we need all of the same
3263                  * information that is given with a normal read or write record
3264                  * lock request. To avoid creating another ldlm unlock (cancel)
3265                  * message we'll treat a LCK_NL flock request as an unlock. */
3266                 einfo.ei_mode = LCK_NL;
3267                 break;
3268         case F_WRLCK:
3269                 einfo.ei_mode = LCK_PW;
3270                 break;
3271         default:
3272                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n", fl_type);
3273                 RETURN (-ENOTSUPP);
3274         }
3275
3276         switch (cmd) {
3277         case F_SETLKW:
3278 #ifdef F_SETLKW64
3279         case F_SETLKW64:
3280 #endif
3281                 flags = 0;
3282                 break;
3283         case F_SETLK:
3284 #ifdef F_SETLK64
3285         case F_SETLK64:
3286 #endif
3287                 flags = LDLM_FL_BLOCK_NOWAIT;
3288                 break;
3289         case F_GETLK:
3290 #ifdef F_GETLK64
3291         case F_GETLK64:
3292 #endif
3293                 flags = LDLM_FL_TEST_LOCK;
3294                 break;
3295         default:
3296                 CERROR("unknown fcntl lock command: %d\n", cmd);
3297                 RETURN (-EINVAL);
3298         }
3299
3300         /* Save the old mode so that if the mode in the lock changes we
3301          * can decrement the appropriate reader or writer refcount. */
3302         file_lock->fl_type = einfo.ei_mode;
3303
3304         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3305                                      LUSTRE_OPC_ANY, NULL);
3306         if (IS_ERR(op_data))
3307                 RETURN(PTR_ERR(op_data));
3308
3309         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags=%#llx, mode=%u, "
3310                "start=%llu, end=%llu\n", PFID(ll_inode2fid(inode)),
3311                flock.l_flock.pid, flags, einfo.ei_mode,
3312                flock.l_flock.start, flock.l_flock.end);
3313
3314         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data, &lockh,
3315                         flags);
3316
3317         /* Restore the file lock type if not TEST lock. */
3318         if (!(flags & LDLM_FL_TEST_LOCK))
3319                 file_lock->fl_type = fl_type;
3320
3321 #ifdef HAVE_LOCKS_LOCK_FILE_WAIT
3322         if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
3323             !(flags & LDLM_FL_TEST_LOCK))
3324                 rc2  = locks_lock_file_wait(file, file_lock);
3325 #else
3326         if ((file_lock->fl_flags & FL_FLOCK) &&
3327             (rc == 0 || file_lock->fl_type == F_UNLCK))
3328                 rc2  = flock_lock_file_wait(file, file_lock);
3329         if ((file_lock->fl_flags & FL_POSIX) &&
3330             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
3331             !(flags & LDLM_FL_TEST_LOCK))
3332                 rc2  = posix_lock_file_wait(file, file_lock);
3333 #endif /* HAVE_LOCKS_LOCK_FILE_WAIT */
3334
3335         if (rc2 && file_lock->fl_type != F_UNLCK) {
3336                 einfo.ei_mode = LCK_NL;
3337                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data,
3338                            &lockh, flags);
3339                 rc = rc2;
3340         }
3341
3342         ll_finish_md_op_data(op_data);
3343
3344         RETURN(rc);
3345 }
3346
3347 int ll_get_fid_by_name(struct inode *parent, const char *name,
3348                        int namelen, struct lu_fid *fid,
3349                        struct inode **inode)
3350 {
3351         struct md_op_data       *op_data = NULL;
3352         struct mdt_body         *body;
3353         struct ptlrpc_request   *req;
3354         int                     rc;
3355         ENTRY;
3356
3357         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
3358                                      LUSTRE_OPC_ANY, NULL);
3359         if (IS_ERR(op_data))
3360                 RETURN(PTR_ERR(op_data));
3361
3362         op_data->op_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
3363         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
3364         ll_finish_md_op_data(op_data);
3365         if (rc < 0)
3366                 RETURN(rc);
3367
3368         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3369         if (body == NULL)
3370                 GOTO(out_req, rc = -EFAULT);
3371         if (fid != NULL)
3372                 *fid = body->mbo_fid1;
3373
3374         if (inode != NULL)
3375                 rc = ll_prep_inode(inode, req, parent->i_sb, NULL);
3376 out_req:
3377         ptlrpc_req_finished(req);
3378         RETURN(rc);
3379 }
3380
3381 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
3382                const char *name, int namelen)
3383 {
3384         struct dentry         *dchild = NULL;
3385         struct inode          *child_inode = NULL;
3386         struct md_op_data     *op_data;
3387         struct ptlrpc_request *request = NULL;
3388         struct obd_client_handle *och = NULL;
3389         struct qstr           qstr;
3390         struct mdt_body         *body;
3391         int                    rc;
3392         __u64                   data_version = 0;
3393         ENTRY;
3394
3395         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
3396                name, PFID(ll_inode2fid(parent)), mdtidx);
3397
3398         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
3399                                      0, LUSTRE_OPC_ANY, NULL);
3400         if (IS_ERR(op_data))
3401                 RETURN(PTR_ERR(op_data));
3402
3403         /* Get child FID first */
3404         qstr.hash = ll_full_name_hash(file_dentry(file), name, namelen);
3405         qstr.name = name;
3406         qstr.len = namelen;
3407         dchild = d_lookup(file_dentry(file), &qstr);
3408         if (dchild != NULL) {
3409                 if (dchild->d_inode != NULL)
3410                         child_inode = igrab(dchild->d_inode);
3411                 dput(dchild);
3412         }
3413
3414         if (child_inode == NULL) {
3415                 rc = ll_get_fid_by_name(parent, name, namelen,
3416                                         &op_data->op_fid3, &child_inode);
3417                 if (rc != 0)
3418                         GOTO(out_free, rc);
3419         }
3420
3421         if (child_inode == NULL)
3422                 GOTO(out_free, rc = -EINVAL);
3423
3424         /*
3425          * lfs migrate command needs to be blocked on the client
3426          * by checking the migrate FID against the FID of the
3427          * filesystem root.
3428          */
3429         if (child_inode == parent->i_sb->s_root->d_inode)
3430                 GOTO(out_iput, rc = -EINVAL);
3431
3432         inode_lock(child_inode);
3433         op_data->op_fid3 = *ll_inode2fid(child_inode);
3434         if (!fid_is_sane(&op_data->op_fid3)) {
3435                 CERROR("%s: migrate %s, but FID "DFID" is insane\n",
3436                        ll_get_fsname(parent->i_sb, NULL, 0), name,
3437                        PFID(&op_data->op_fid3));
3438                 GOTO(out_unlock, rc = -EINVAL);
3439         }
3440
3441         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
3442         if (rc < 0)
3443                 GOTO(out_unlock, rc);
3444
3445         if (rc == mdtidx) {
3446                 CDEBUG(D_INFO, "%s: "DFID" is already on MDT%04x\n", name,
3447                        PFID(&op_data->op_fid3), mdtidx);
3448                 GOTO(out_unlock, rc = 0);
3449         }
3450 again:
3451         if (S_ISREG(child_inode->i_mode)) {
3452                 och = ll_lease_open(child_inode, NULL, FMODE_WRITE, 0);
3453                 if (IS_ERR(och)) {
3454                         rc = PTR_ERR(och);
3455                         och = NULL;
3456                         GOTO(out_unlock, rc);
3457                 }
3458
3459                 rc = ll_data_version(child_inode, &data_version,
3460                                      LL_DV_WR_FLUSH);
3461                 if (rc != 0)
3462                         GOTO(out_close, rc);
3463
3464                 op_data->op_handle = och->och_fh;
3465                 op_data->op_data = och->och_mod;
3466                 op_data->op_data_version = data_version;
3467                 op_data->op_lease_handle = och->och_lease_handle;
3468                 op_data->op_bias |= MDS_RENAME_MIGRATE;
3469         }
3470
3471         op_data->op_mds = mdtidx;
3472         op_data->op_cli_flags = CLI_MIGRATE;
3473         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3474                        namelen, name, namelen, &request);
3475         if (rc == 0) {
3476                 LASSERT(request != NULL);
3477                 ll_update_times(request, parent);
3478
3479                 body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
3480                 LASSERT(body != NULL);
3481
3482                 /* If the server does release layout lock, then we cleanup
3483                  * the client och here, otherwise release it in out_close: */
3484                 if (och != NULL &&
3485                     body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED) {
3486                         obd_mod_put(och->och_mod);
3487                         md_clear_open_replay_data(ll_i2sbi(parent)->ll_md_exp,
3488                                                   och);
3489                         och->och_fh.cookie = DEAD_HANDLE_MAGIC;
3490                         OBD_FREE_PTR(och);
3491                         och = NULL;
3492                 }
3493         }
3494
3495         if (request != NULL) {
3496                 ptlrpc_req_finished(request);
3497                 request = NULL;
3498         }
3499
3500         /* Try again if the file layout has changed. */
3501         if (rc == -EAGAIN && S_ISREG(child_inode->i_mode))
3502                 goto again;
3503
3504 out_close:
3505         if (och != NULL) /* close the file */
3506                 ll_lease_close(och, child_inode, NULL);
3507         if (rc == 0)
3508                 clear_nlink(child_inode);
3509 out_unlock:
3510         inode_unlock(child_inode);
3511 out_iput:
3512         iput(child_inode);
3513 out_free:
3514         ll_finish_md_op_data(op_data);
3515         RETURN(rc);
3516 }
3517
3518 static int
3519 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3520 {
3521         ENTRY;
3522
3523         RETURN(-ENOSYS);
3524 }
3525
3526 /**
3527  * test if some locks matching bits and l_req_mode are acquired
3528  * - bits can be in different locks
3529  * - if found clear the common lock bits in *bits
3530  * - the bits not found, are kept in *bits
3531  * \param inode [IN]
3532  * \param bits [IN] searched lock bits [IN]
3533  * \param l_req_mode [IN] searched lock mode
3534  * \retval boolean, true iff all bits are found
3535  */
3536 int ll_have_md_lock(struct inode *inode, __u64 *bits, enum ldlm_mode l_req_mode)
3537 {
3538         struct lustre_handle lockh;
3539         union ldlm_policy_data policy;
3540         enum ldlm_mode mode = (l_req_mode == LCK_MINMODE) ?
3541                               (LCK_CR | LCK_CW | LCK_PR | LCK_PW) : l_req_mode;
3542         struct lu_fid *fid;
3543         __u64 flags;
3544         int i;
3545         ENTRY;
3546
3547         if (!inode)
3548                RETURN(0);
3549
3550         fid = &ll_i2info(inode)->lli_fid;
3551         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3552                ldlm_lockname[mode]);
3553
3554         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3555         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3556                 policy.l_inodebits.bits = *bits & (1 << i);
3557                 if (policy.l_inodebits.bits == 0)
3558                         continue;
3559
3560                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3561                                   &policy, mode, &lockh)) {
3562                         struct ldlm_lock *lock;
3563
3564                         lock = ldlm_handle2lock(&lockh);
3565                         if (lock) {
3566                                 *bits &=
3567                                       ~(lock->l_policy_data.l_inodebits.bits);
3568                                 LDLM_LOCK_PUT(lock);
3569                         } else {
3570                                 *bits &= ~policy.l_inodebits.bits;
3571                         }
3572                 }
3573         }
3574         RETURN(*bits == 0);
3575 }
3576
3577 enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
3578                                struct lustre_handle *lockh, __u64 flags,
3579                                enum ldlm_mode mode)
3580 {
3581         union ldlm_policy_data policy = { .l_inodebits = { bits } };
3582         struct lu_fid *fid;
3583         enum ldlm_mode rc;
3584         ENTRY;
3585
3586         fid = &ll_i2info(inode)->lli_fid;
3587         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3588
3589         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3590                            fid, LDLM_IBITS, &policy, mode, lockh);
3591
3592         RETURN(rc);
3593 }
3594
3595 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3596 {
3597         /* Already unlinked. Just update nlink and return success */
3598         if (rc == -ENOENT) {
3599                 clear_nlink(inode);
3600                 /* If it is striped directory, and there is bad stripe
3601                  * Let's revalidate the dentry again, instead of returning
3602                  * error */
3603                 if (S_ISDIR(inode->i_mode) &&
3604                     ll_i2info(inode)->lli_lsm_md != NULL)
3605                         return 0;
3606
3607                 /* This path cannot be hit for regular files unless in
3608                  * case of obscure races, so no need to to validate
3609                  * size. */
3610                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3611                         return 0;
3612         } else if (rc != 0) {
3613                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
3614                              "%s: revalidate FID "DFID" error: rc = %d\n",
3615                              ll_get_fsname(inode->i_sb, NULL, 0),
3616                              PFID(ll_inode2fid(inode)), rc);
3617         }
3618
3619         return rc;
3620 }
3621
3622 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3623 {
3624         struct inode *inode = dentry->d_inode;
3625         struct ptlrpc_request *req = NULL;
3626         struct obd_export *exp;
3627         int rc = 0;
3628         ENTRY;
3629
3630         LASSERT(inode != NULL);
3631
3632         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
3633                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
3634
3635         exp = ll_i2mdexp(inode);
3636
3637         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3638          *      But under CMD case, it caused some lock issues, should be fixed
3639          *      with new CMD ibits lock. See bug 12718 */
3640         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3641                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3642                 struct md_op_data *op_data;
3643
3644                 if (ibits == MDS_INODELOCK_LOOKUP)
3645                         oit.it_op = IT_LOOKUP;
3646
3647                 /* Call getattr by fid, so do not provide name at all. */
3648                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
3649                                              dentry->d_inode, NULL, 0, 0,
3650                                              LUSTRE_OPC_ANY, NULL);
3651                 if (IS_ERR(op_data))
3652                         RETURN(PTR_ERR(op_data));
3653
3654                 rc = md_intent_lock(exp, op_data, &oit, &req,
3655                                     &ll_md_blocking_ast, 0);
3656                 ll_finish_md_op_data(op_data);
3657                 if (rc < 0) {
3658                         rc = ll_inode_revalidate_fini(inode, rc);
3659                         GOTO (out, rc);
3660                 }
3661
3662                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3663                 if (rc != 0) {
3664                         ll_intent_release(&oit);
3665                         GOTO(out, rc);
3666                 }
3667
3668                 /* Unlinked? Unhash dentry, so it is not picked up later by
3669                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3670                    here to preserve get_cwd functionality on 2.6.
3671                    Bug 10503 */
3672                 if (!dentry->d_inode->i_nlink) {
3673                         ll_lock_dcache(inode);
3674                         d_lustre_invalidate(dentry, 0);
3675                         ll_unlock_dcache(inode);
3676                 }
3677
3678                 ll_lookup_finish_locks(&oit, dentry);
3679         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3680                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3681                 u64 valid = OBD_MD_FLGETATTR;
3682                 struct md_op_data *op_data;
3683                 int ealen = 0;
3684
3685                 if (S_ISREG(inode->i_mode)) {
3686                         rc = ll_get_default_mdsize(sbi, &ealen);
3687                         if (rc)
3688                                 RETURN(rc);
3689                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3690                 }
3691
3692                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3693                                              0, ealen, LUSTRE_OPC_ANY,
3694                                              NULL);
3695                 if (IS_ERR(op_data))
3696                         RETURN(PTR_ERR(op_data));
3697
3698                 op_data->op_valid = valid;
3699                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3700                 ll_finish_md_op_data(op_data);
3701                 if (rc) {
3702                         rc = ll_inode_revalidate_fini(inode, rc);
3703                         RETURN(rc);
3704                 }
3705
3706                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3707         }
3708 out:
3709         ptlrpc_req_finished(req);
3710         return rc;
3711 }
3712
3713 static int ll_merge_md_attr(struct inode *inode)
3714 {
3715         struct cl_attr attr = { 0 };
3716         int rc;
3717
3718         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
3719         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
3720                            &attr, ll_md_blocking_ast);
3721         if (rc != 0)
3722                 RETURN(rc);
3723
3724         set_nlink(inode, attr.cat_nlink);
3725         inode->i_blocks = attr.cat_blocks;
3726         i_size_write(inode, attr.cat_size);
3727
3728         ll_i2info(inode)->lli_atime = attr.cat_atime;
3729         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
3730         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
3731
3732         RETURN(0);
3733 }
3734
3735 static int
3736 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3737 {
3738         struct inode    *inode = dentry->d_inode;
3739         int              rc;
3740         ENTRY;
3741
3742         rc = __ll_inode_revalidate(dentry, ibits);
3743         if (rc != 0)
3744                 RETURN(rc);
3745
3746         /* if object isn't regular file, don't validate size */
3747         if (!S_ISREG(inode->i_mode)) {
3748                 if (S_ISDIR(inode->i_mode) &&
3749                     ll_i2info(inode)->lli_lsm_md != NULL) {
3750                         rc = ll_merge_md_attr(inode);
3751                         if (rc != 0)
3752                                 RETURN(rc);
3753                 }
3754
3755                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_atime;
3756                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_mtime;
3757                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_ctime;
3758         } else {
3759                 /* In case of restore, the MDT has the right size and has
3760                  * already send it back without granting the layout lock,
3761                  * inode is up-to-date so glimpse is useless.
3762                  * Also to glimpse we need the layout, in case of a running
3763                  * restore the MDT holds the layout lock so the glimpse will
3764                  * block up to the end of restore (getattr will block)
3765                  */
3766                 if (!ll_file_test_flag(ll_i2info(inode), LLIF_FILE_RESTORING))
3767                         rc = ll_glimpse_size(inode);
3768         }
3769         RETURN(rc);
3770 }
3771
3772 static inline dev_t ll_compat_encode_dev(dev_t dev)
3773 {
3774         /* The compat_sys_*stat*() syscalls will fail unless the
3775          * device majors and minors are both less than 256. Note that
3776          * the value returned here will be passed through
3777          * old_encode_dev() in cp_compat_stat(). And so we are not
3778          * trying to return a valid compat (u16) device number, just
3779          * one that will pass the old_valid_dev() check. */
3780
3781         return MKDEV(MAJOR(dev) & 0xff, MINOR(dev) & 0xff);
3782 }
3783
3784 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
3785 {
3786         struct inode *inode = de->d_inode;
3787         struct ll_sb_info *sbi = ll_i2sbi(inode);
3788         struct ll_inode_info *lli = ll_i2info(inode);
3789         int res = 0;
3790
3791         res = ll_inode_revalidate(de, MDS_INODELOCK_UPDATE |
3792                                       MDS_INODELOCK_LOOKUP);
3793         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
3794
3795         if (res)
3796                 return res;
3797
3798         OBD_FAIL_TIMEOUT(OBD_FAIL_GETATTR_DELAY, 30);
3799
3800         if (ll_need_32bit_api(sbi)) {
3801                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
3802                 stat->dev = ll_compat_encode_dev(inode->i_sb->s_dev);
3803                 stat->rdev = ll_compat_encode_dev(inode->i_rdev);
3804         } else {
3805                 stat->ino = inode->i_ino;
3806                 stat->dev = inode->i_sb->s_dev;
3807                 stat->rdev = inode->i_rdev;
3808         }
3809
3810         stat->mode = inode->i_mode;
3811         stat->uid = inode->i_uid;
3812         stat->gid = inode->i_gid;
3813         stat->atime = inode->i_atime;
3814         stat->mtime = inode->i_mtime;
3815         stat->ctime = inode->i_ctime;
3816         stat->blksize = sbi->ll_stat_blksize ?: 1 << inode->i_blkbits;
3817
3818         stat->nlink = inode->i_nlink;
3819         stat->size = i_size_read(inode);
3820         stat->blocks = inode->i_blocks;
3821
3822         return 0;
3823 }
3824
3825 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3826                      __u64 start, __u64 len)
3827 {
3828         int             rc;
3829         size_t          num_bytes;
3830         struct fiemap   *fiemap;
3831         unsigned int    extent_count = fieinfo->fi_extents_max;
3832
3833         num_bytes = sizeof(*fiemap) + (extent_count *
3834                                        sizeof(struct fiemap_extent));
3835         OBD_ALLOC_LARGE(fiemap, num_bytes);
3836
3837         if (fiemap == NULL)
3838                 RETURN(-ENOMEM);
3839
3840         fiemap->fm_flags = fieinfo->fi_flags;
3841         fiemap->fm_extent_count = fieinfo->fi_extents_max;
3842         fiemap->fm_start = start;
3843         fiemap->fm_length = len;
3844         if (extent_count > 0 &&
3845             copy_from_user(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
3846                            sizeof(struct fiemap_extent)) != 0)
3847                 GOTO(out, rc = -EFAULT);
3848
3849         rc = ll_do_fiemap(inode, fiemap, num_bytes);
3850
3851         fieinfo->fi_flags = fiemap->fm_flags;
3852         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
3853         if (extent_count > 0 &&
3854             copy_to_user(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
3855                          fiemap->fm_mapped_extents *
3856                          sizeof(struct fiemap_extent)) != 0)
3857                 GOTO(out, rc = -EFAULT);
3858 out:
3859         OBD_FREE_LARGE(fiemap, num_bytes);
3860         return rc;
3861 }
3862
3863 struct posix_acl *ll_get_acl(struct inode *inode, int type)
3864 {
3865         struct ll_inode_info *lli = ll_i2info(inode);
3866         struct posix_acl *acl = NULL;
3867         ENTRY;
3868
3869         spin_lock(&lli->lli_lock);
3870         /* VFS' acl_permission_check->check_acl will release the refcount */
3871         acl = posix_acl_dup(lli->lli_posix_acl);
3872         spin_unlock(&lli->lli_lock);
3873
3874         RETURN(acl);
3875 }
3876
3877 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
3878 static int
3879 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
3880 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
3881 # else
3882 ll_check_acl(struct inode *inode, int mask)
3883 # endif
3884 {
3885 # ifdef CONFIG_FS_POSIX_ACL
3886         struct posix_acl *acl;
3887         int rc;
3888         ENTRY;
3889
3890 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
3891         if (flags & IPERM_FLAG_RCU)
3892                 return -ECHILD;
3893 #  endif
3894         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
3895
3896         if (!acl)
3897                 RETURN(-EAGAIN);
3898
3899         rc = posix_acl_permission(inode, acl, mask);
3900         posix_acl_release(acl);
3901
3902         RETURN(rc);
3903 # else /* !CONFIG_FS_POSIX_ACL */
3904         return -EAGAIN;
3905 # endif /* CONFIG_FS_POSIX_ACL */
3906 }
3907 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
3908
3909 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
3910 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
3911 #else
3912 # ifdef HAVE_INODE_PERMISION_2ARGS
3913 int ll_inode_permission(struct inode *inode, int mask)
3914 # else
3915 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
3916 # endif
3917 #endif
3918 {
3919         int rc = 0;
3920         struct ll_sb_info *sbi;
3921         struct root_squash_info *squash;
3922         struct cred *cred = NULL;
3923         const struct cred *old_cred = NULL;
3924         cfs_cap_t cap;
3925         bool squash_id = false;
3926         ENTRY;
3927
3928 #ifdef MAY_NOT_BLOCK
3929         if (mask & MAY_NOT_BLOCK)
3930                 return -ECHILD;
3931 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
3932         if (flags & IPERM_FLAG_RCU)
3933                 return -ECHILD;
3934 #endif
3935
3936        /* as root inode are NOT getting validated in lookup operation,
3937         * need to do it before permission check. */
3938
3939         if (inode == inode->i_sb->s_root->d_inode) {
3940                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
3941                                            MDS_INODELOCK_LOOKUP);
3942                 if (rc)
3943                         RETURN(rc);
3944         }
3945
3946         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
3947                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
3948
3949         /* squash fsuid/fsgid if needed */
3950         sbi = ll_i2sbi(inode);
3951         squash = &sbi->ll_squash;
3952         if (unlikely(squash->rsi_uid != 0 &&
3953                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
3954                      !(sbi->ll_flags & LL_SBI_NOROOTSQUASH))) {
3955                         squash_id = true;
3956         }
3957         if (squash_id) {
3958                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
3959                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
3960                        squash->rsi_uid, squash->rsi_gid);
3961
3962                 /* update current process's credentials
3963                  * and FS capability */
3964                 cred = prepare_creds();
3965                 if (cred == NULL)
3966                         RETURN(-ENOMEM);
3967
3968                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
3969                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
3970                 for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
3971                         if ((1 << cap) & CFS_CAP_FS_MASK)
3972                                 cap_lower(cred->cap_effective, cap);
3973                 }
3974                 old_cred = override_creds(cred);
3975         }
3976
3977         ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM, 1);
3978         rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3979         /* restore current process's credentials and FS capability */
3980         if (squash_id) {
3981                 revert_creds(old_cred);
3982                 put_cred(cred);
3983         }
3984
3985         RETURN(rc);
3986 }
3987
3988 /* -o localflock - only provides locally consistent flock locks */
3989 struct file_operations ll_file_operations = {
3990 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
3991 # ifdef HAVE_SYNC_READ_WRITE
3992         .read           = new_sync_read,
3993         .write          = new_sync_write,
3994 # endif
3995         .read_iter      = ll_file_read_iter,
3996         .write_iter     = ll_file_write_iter,
3997 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3998         .read           = ll_file_read,
3999         .aio_read       = ll_file_aio_read,
4000         .write          = ll_file_write,
4001         .aio_write      = ll_file_aio_write,
4002 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4003         .unlocked_ioctl = ll_file_ioctl,
4004         .open           = ll_file_open,
4005         .release        = ll_file_release,
4006         .mmap           = ll_file_mmap,
4007         .llseek         = ll_file_seek,
4008         .splice_read    = ll_file_splice_read,
4009         .fsync          = ll_fsync,
4010         .flush          = ll_flush
4011 };
4012
4013 struct file_operations ll_file_operations_flock = {
4014 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
4015 # ifdef HAVE_SYNC_READ_WRITE
4016         .read           = new_sync_read,
4017         .write          = new_sync_write,
4018 # endif /* HAVE_SYNC_READ_WRITE */
4019         .read_iter      = ll_file_read_iter,
4020         .write_iter     = ll_file_write_iter,
4021 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4022         .read           = ll_file_read,
4023         .aio_read       = ll_file_aio_read,
4024         .write          = ll_file_write,
4025         .aio_write      = ll_file_aio_write,
4026 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4027         .unlocked_ioctl = ll_file_ioctl,
4028         .open           = ll_file_open,
4029         .release        = ll_file_release,
4030         .mmap           = ll_file_mmap,
4031         .llseek         = ll_file_seek,
4032         .splice_read    = ll_file_splice_read,
4033         .fsync          = ll_fsync,
4034         .flush          = ll_flush,
4035         .flock          = ll_file_flock,
4036         .lock           = ll_file_flock
4037 };
4038
4039 /* These are for -o noflock - to return ENOSYS on flock calls */
4040 struct file_operations ll_file_operations_noflock = {
4041 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
4042 # ifdef HAVE_SYNC_READ_WRITE
4043         .read           = new_sync_read,
4044         .write          = new_sync_write,
4045 # endif /* HAVE_SYNC_READ_WRITE */
4046         .read_iter      = ll_file_read_iter,
4047         .write_iter     = ll_file_write_iter,
4048 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4049         .read           = ll_file_read,
4050         .aio_read       = ll_file_aio_read,
4051         .write          = ll_file_write,
4052         .aio_write      = ll_file_aio_write,
4053 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4054         .unlocked_ioctl = ll_file_ioctl,
4055         .open           = ll_file_open,
4056         .release        = ll_file_release,
4057         .mmap           = ll_file_mmap,
4058         .llseek         = ll_file_seek,
4059         .splice_read    = ll_file_splice_read,
4060         .fsync          = ll_fsync,
4061         .flush          = ll_flush,
4062         .flock          = ll_file_noflock,
4063         .lock           = ll_file_noflock
4064 };
4065
4066 struct inode_operations ll_file_inode_operations = {
4067         .setattr        = ll_setattr,
4068         .getattr        = ll_getattr,
4069         .permission     = ll_inode_permission,
4070         .setxattr       = ll_setxattr,
4071         .getxattr       = ll_getxattr,
4072         .listxattr      = ll_listxattr,
4073         .removexattr    = ll_removexattr,
4074         .fiemap         = ll_fiemap,
4075 #ifdef HAVE_IOP_GET_ACL
4076         .get_acl        = ll_get_acl,
4077 #endif
4078 };
4079
4080 /* dynamic ioctl number support routins */
4081 static struct llioc_ctl_data {
4082         struct rw_semaphore     ioc_sem;
4083         struct list_head        ioc_head;
4084 } llioc = {
4085         __RWSEM_INITIALIZER(llioc.ioc_sem),
4086         LIST_HEAD_INIT(llioc.ioc_head)
4087 };
4088
4089
4090 struct llioc_data {
4091         struct list_head        iocd_list;
4092         unsigned int            iocd_size;
4093         llioc_callback_t        iocd_cb;
4094         unsigned int            iocd_count;
4095         unsigned int            iocd_cmd[0];
4096 };
4097
4098 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
4099 {
4100         unsigned int size;
4101         struct llioc_data *in_data = NULL;
4102         ENTRY;
4103
4104         if (cb == NULL || cmd == NULL ||
4105             count > LLIOC_MAX_CMD || count < 0)
4106                 RETURN(NULL);
4107
4108         size = sizeof(*in_data) + count * sizeof(unsigned int);
4109         OBD_ALLOC(in_data, size);
4110         if (in_data == NULL)
4111                 RETURN(NULL);
4112
4113         memset(in_data, 0, sizeof(*in_data));
4114         in_data->iocd_size = size;
4115         in_data->iocd_cb = cb;
4116         in_data->iocd_count = count;
4117         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
4118
4119         down_write(&llioc.ioc_sem);
4120         list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
4121         up_write(&llioc.ioc_sem);
4122
4123         RETURN(in_data);
4124 }
4125
4126 void ll_iocontrol_unregister(void *magic)
4127 {
4128         struct llioc_data *tmp;
4129
4130         if (magic == NULL)
4131                 return;
4132
4133         down_write(&llioc.ioc_sem);
4134         list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
4135                 if (tmp == magic) {
4136                         unsigned int size = tmp->iocd_size;
4137
4138                         list_del(&tmp->iocd_list);
4139                         up_write(&llioc.ioc_sem);
4140
4141                         OBD_FREE(tmp, size);
4142                         return;
4143                 }
4144         }
4145         up_write(&llioc.ioc_sem);
4146
4147         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
4148 }
4149
4150 EXPORT_SYMBOL(ll_iocontrol_register);
4151 EXPORT_SYMBOL(ll_iocontrol_unregister);
4152
4153 static enum llioc_iter
4154 ll_iocontrol_call(struct inode *inode, struct file *file,
4155                   unsigned int cmd, unsigned long arg, int *rcp)
4156 {
4157         enum llioc_iter ret = LLIOC_CONT;
4158         struct llioc_data *data;
4159         int rc = -EINVAL, i;
4160
4161         down_read(&llioc.ioc_sem);
4162         list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
4163                 for (i = 0; i < data->iocd_count; i++) {
4164                         if (cmd != data->iocd_cmd[i])
4165                                 continue;
4166
4167                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
4168                         break;
4169                 }
4170
4171                 if (ret == LLIOC_STOP)
4172                         break;
4173         }
4174         up_read(&llioc.ioc_sem);
4175
4176         if (rcp)
4177                 *rcp = rc;
4178         return ret;
4179 }
4180
4181 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
4182 {
4183         struct ll_inode_info *lli = ll_i2info(inode);
4184         struct cl_object *obj = lli->lli_clob;
4185         struct lu_env *env;
4186         int rc;
4187         __u16 refcheck;
4188         ENTRY;
4189
4190         if (obj == NULL)
4191                 RETURN(0);
4192
4193         env = cl_env_get(&refcheck);
4194         if (IS_ERR(env))
4195                 RETURN(PTR_ERR(env));
4196
4197         rc = cl_conf_set(env, lli->lli_clob, conf);
4198         if (rc < 0)
4199                 GOTO(out, rc);
4200
4201         if (conf->coc_opc == OBJECT_CONF_SET) {
4202                 struct ldlm_lock *lock = conf->coc_lock;
4203                 struct cl_layout cl = {
4204                         .cl_layout_gen = 0,
4205                 };
4206
4207                 LASSERT(lock != NULL);
4208                 LASSERT(ldlm_has_layout(lock));
4209
4210                 /* it can only be allowed to match after layout is
4211                  * applied to inode otherwise false layout would be
4212                  * seen. Applying layout shoud happen before dropping
4213                  * the intent lock. */
4214                 ldlm_lock_allow_match(lock);
4215
4216                 rc = cl_object_layout_get(env, obj, &cl);
4217                 if (rc < 0)
4218                         GOTO(out, rc);
4219
4220                 CDEBUG(D_VFSTRACE,
4221                        DFID": layout version change: %u -> %u\n",
4222                        PFID(&lli->lli_fid), ll_layout_version_get(lli),
4223                        cl.cl_layout_gen);
4224                 ll_layout_version_set(lli, cl.cl_layout_gen);
4225         }
4226
4227 out:
4228         cl_env_put(env, &refcheck);
4229
4230         RETURN(rc);
4231 }
4232
4233 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
4234 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
4235
4236 {
4237         struct ll_sb_info *sbi = ll_i2sbi(inode);
4238         struct ptlrpc_request *req;
4239         struct mdt_body *body;
4240         void *lvbdata;
4241         void *lmm;
4242         int lmmsize;
4243         int rc;
4244         ENTRY;
4245
4246         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
4247                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
4248                lock->l_lvb_data, lock->l_lvb_len);
4249
4250         if (lock->l_lvb_data != NULL)
4251                 RETURN(0);
4252
4253         /* if layout lock was granted right away, the layout is returned
4254          * within DLM_LVB of dlm reply; otherwise if the lock was ever
4255          * blocked and then granted via completion ast, we have to fetch
4256          * layout here. Please note that we can't use the LVB buffer in
4257          * completion AST because it doesn't have a large enough buffer */
4258         rc = ll_get_default_mdsize(sbi, &lmmsize);
4259         if (rc == 0)
4260                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode),
4261                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
4262                                 lmmsize, 0, &req);
4263         if (rc < 0)
4264                 RETURN(rc);
4265
4266         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
4267         if (body == NULL)
4268                 GOTO(out, rc = -EPROTO);
4269
4270         lmmsize = body->mbo_eadatasize;
4271         if (lmmsize == 0) /* empty layout */
4272                 GOTO(out, rc = 0);
4273
4274         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
4275         if (lmm == NULL)
4276                 GOTO(out, rc = -EFAULT);
4277
4278         OBD_ALLOC_LARGE(lvbdata, lmmsize);
4279         if (lvbdata == NULL)
4280                 GOTO(out, rc = -ENOMEM);
4281
4282         memcpy(lvbdata, lmm, lmmsize);
4283         lock_res_and_lock(lock);
4284         if (unlikely(lock->l_lvb_data == NULL)) {
4285                 lock->l_lvb_type = LVB_T_LAYOUT;
4286                 lock->l_lvb_data = lvbdata;
4287                 lock->l_lvb_len = lmmsize;
4288                 lvbdata = NULL;
4289         }
4290         unlock_res_and_lock(lock);
4291
4292         if (lvbdata)
4293                 OBD_FREE_LARGE(lvbdata, lmmsize);
4294
4295         EXIT;
4296
4297 out:
4298         ptlrpc_req_finished(req);
4299         return rc;
4300 }
4301
4302 /**
4303  * Apply the layout to the inode. Layout lock is held and will be released
4304  * in this function.
4305  */
4306 static int ll_layout_lock_set(struct lustre_handle *lockh, enum ldlm_mode mode,
4307                               struct inode *inode)
4308 {
4309         struct ll_inode_info *lli = ll_i2info(inode);
4310         struct ll_sb_info    *sbi = ll_i2sbi(inode);
4311         struct ldlm_lock *lock;
4312         struct cl_object_conf conf;
4313         int rc = 0;
4314         bool lvb_ready;
4315         bool wait_layout = false;
4316         ENTRY;
4317
4318         LASSERT(lustre_handle_is_used(lockh));
4319
4320         lock = ldlm_handle2lock(lockh);
4321         LASSERT(lock != NULL);
4322         LASSERT(ldlm_has_layout(lock));
4323
4324         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured",
4325                    PFID(&lli->lli_fid), inode);
4326
4327         /* in case this is a caching lock and reinstate with new inode */
4328         md_set_lock_data(sbi->ll_md_exp, lockh, inode, NULL);
4329
4330         lock_res_and_lock(lock);
4331         lvb_ready = ldlm_is_lvb_ready(lock);
4332         unlock_res_and_lock(lock);
4333
4334         /* checking lvb_ready is racy but this is okay. The worst case is
4335          * that multi processes may configure the file on the same time. */
4336         if (lvb_ready)
4337                 GOTO(out, rc = 0);
4338
4339         rc = ll_layout_fetch(inode, lock);
4340         if (rc < 0)
4341                 GOTO(out, rc);
4342
4343         /* for layout lock, lmm is stored in lock's lvb.
4344          * lvb_data is immutable if the lock is held so it's safe to access it
4345          * without res lock.
4346          *
4347          * set layout to file. Unlikely this will fail as old layout was
4348          * surely eliminated */
4349         memset(&conf, 0, sizeof conf);
4350         conf.coc_opc = OBJECT_CONF_SET;
4351         conf.coc_inode = inode;
4352         conf.coc_lock = lock;
4353         conf.u.coc_layout.lb_buf = lock->l_lvb_data;
4354         conf.u.coc_layout.lb_len = lock->l_lvb_len;
4355         rc = ll_layout_conf(inode, &conf);
4356
4357         /* refresh layout failed, need to wait */
4358         wait_layout = rc == -EBUSY;
4359         EXIT;
4360 out:
4361         LDLM_LOCK_PUT(lock);
4362         ldlm_lock_decref(lockh, mode);
4363
4364         /* wait for IO to complete if it's still being used. */
4365         if (wait_layout) {
4366                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
4367                        ll_get_fsname(inode->i_sb, NULL, 0),
4368                        PFID(&lli->lli_fid), inode);
4369
4370                 memset(&conf, 0, sizeof conf);
4371                 conf.coc_opc = OBJECT_CONF_WAIT;
4372                 conf.coc_inode = inode;
4373                 rc = ll_layout_conf(inode, &conf);
4374                 if (rc == 0)
4375                         rc = -EAGAIN;
4376
4377                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
4378                        ll_get_fsname(inode->i_sb, NULL, 0),
4379                        PFID(&lli->lli_fid), rc);
4380         }
4381         RETURN(rc);
4382 }
4383
4384 /**
4385  * Issue layout intent RPC to MDS.
4386  * \param inode [in]    file inode
4387  * \param intent [in]   layout intent
4388  *
4389  * \retval 0    on success
4390  * \retval < 0  error code
4391  */
4392 static int ll_layout_intent(struct inode *inode, struct layout_intent *intent)
4393 {
4394         struct ll_inode_info  *lli = ll_i2info(inode);
4395         struct ll_sb_info     *sbi = ll_i2sbi(inode);
4396         struct md_op_data     *op_data;
4397         struct lookup_intent it;
4398         struct ptlrpc_request *req;
4399         int rc;
4400         ENTRY;
4401
4402         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
4403                                      0, 0, LUSTRE_OPC_ANY, NULL);
4404         if (IS_ERR(op_data))
4405                 RETURN(PTR_ERR(op_data));
4406
4407         op_data->op_data = intent;
4408         op_data->op_data_size = sizeof(*intent);
4409
4410         memset(&it, 0, sizeof(it));
4411         it.it_op = IT_LAYOUT;
4412         if (intent->li_opc == LAYOUT_INTENT_WRITE ||
4413             intent->li_opc == LAYOUT_INTENT_TRUNC)
4414                 it.it_flags = FMODE_WRITE;
4415
4416         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
4417                           ll_get_fsname(inode->i_sb, NULL, 0),
4418                           PFID(&lli->lli_fid), inode);
4419
4420         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
4421                             &ll_md_blocking_ast, 0);
4422         if (it.it_request != NULL)
4423                 ptlrpc_req_finished(it.it_request);
4424         it.it_request = NULL;
4425
4426         ll_finish_md_op_data(op_data);
4427
4428         /* set lock data in case this is a new lock */
4429         if (!rc)
4430                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
4431
4432         ll_intent_drop_lock(&it);
4433
4434         RETURN(rc);
4435 }
4436
4437 /**
4438  * This function checks if there exists a LAYOUT lock on the client side,
4439  * or enqueues it if it doesn't have one in cache.
4440  *
4441  * This function will not hold layout lock so it may be revoked any time after
4442  * this function returns. Any operations depend on layout should be redone
4443  * in that case.
4444  *
4445  * This function should be called before lov_io_init() to get an uptodate
4446  * layout version, the caller should save the version number and after IO
4447  * is finished, this function should be called again to verify that layout
4448  * is not changed during IO time.
4449  */
4450 int ll_layout_refresh(struct inode *inode, __u32 *gen)
4451 {
4452         struct ll_inode_info    *lli = ll_i2info(inode);
4453         struct ll_sb_info       *sbi = ll_i2sbi(inode);
4454         struct lustre_handle lockh;
4455         struct layout_intent intent = {
4456                 .li_opc = LAYOUT_INTENT_ACCESS,
4457         };
4458         enum ldlm_mode mode;
4459         int rc;
4460         ENTRY;
4461
4462         *gen = ll_layout_version_get(lli);
4463         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK) || *gen != CL_LAYOUT_GEN_NONE)
4464                 RETURN(0);
4465
4466         /* sanity checks */
4467         LASSERT(fid_is_sane(ll_inode2fid(inode)));
4468         LASSERT(S_ISREG(inode->i_mode));
4469
4470         /* take layout lock mutex to enqueue layout lock exclusively. */
4471         mutex_lock(&lli->lli_layout_mutex);
4472
4473         while (1) {
4474                 /* mostly layout lock is caching on the local side, so try to
4475                  * match it before grabbing layout lock mutex. */
4476                 mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
4477                                        LCK_CR | LCK_CW | LCK_PR | LCK_PW);
4478                 if (mode != 0) { /* hit cached lock */
4479                         rc = ll_layout_lock_set(&lockh, mode, inode);
4480                         if (rc == -EAGAIN)
4481                                 continue;
4482                         break;
4483                 }
4484
4485                 rc = ll_layout_intent(inode, &intent);
4486                 if (rc != 0)
4487                         break;
4488         }
4489
4490         if (rc == 0)
4491                 *gen = ll_layout_version_get(lli);
4492         mutex_unlock(&lli->lli_layout_mutex);
4493
4494         RETURN(rc);
4495 }
4496
4497 /**
4498  * Issue layout intent RPC indicating where in a file an IO is about to write.
4499  *
4500  * \param[in] inode     file inode.
4501  * \param[in] start     start offset of fille in bytes where an IO is about to
4502  *                      write.
4503  * \param[in] end       exclusive end offset in bytes of the write range.
4504  *
4505  * \retval 0    on success
4506  * \retval < 0  error code
4507  */
4508 int ll_layout_write_intent(struct inode *inode, __u64 start, __u64 end)
4509 {
4510         struct layout_intent intent = {
4511                 .li_opc = LAYOUT_INTENT_WRITE,
4512                 .li_start = start,
4513                 .li_end = end,
4514         };
4515         int rc;
4516         ENTRY;
4517
4518         rc = ll_layout_intent(inode, &intent);
4519
4520         RETURN(rc);
4521 }
4522
4523 /**
4524  *  This function send a restore request to the MDT
4525  */
4526 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
4527 {
4528         struct hsm_user_request *hur;
4529         int                      len, rc;
4530         ENTRY;
4531
4532         len = sizeof(struct hsm_user_request) +
4533               sizeof(struct hsm_user_item);
4534         OBD_ALLOC(hur, len);
4535         if (hur == NULL)
4536                 RETURN(-ENOMEM);
4537
4538         hur->hur_request.hr_action = HUA_RESTORE;
4539         hur->hur_request.hr_archive_id = 0;
4540         hur->hur_request.hr_flags = 0;
4541         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
4542                sizeof(hur->hur_user_item[0].hui_fid));
4543         hur->hur_user_item[0].hui_extent.offset = offset;
4544         hur->hur_user_item[0].hui_extent.length = length;
4545         hur->hur_request.hr_itemcount = 1;
4546         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, ll_i2sbi(inode)->ll_md_exp,
4547                            len, hur, NULL);
4548         OBD_FREE(hur, len);
4549         RETURN(rc);
4550 }