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