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