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