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