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