lustre/llite/file.c

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