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