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