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