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 static bool file_is_noatime(const struct file *file)
1059 {
1060         const struct vfsmount *mnt = file->f_path.mnt;
1061         const struct inode *inode = file->f_path.dentry->d_inode;
1062
1063         /* Adapted from file_accessed() and touch_atime().*/
1064         if (file->f_flags & O_NOATIME)
1065                 return true;
1066
1067         if (inode->i_flags & S_NOATIME)
1068                 return true;
1069
1070         if (IS_NOATIME(inode))
1071                 return true;
1072
1073         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1074                 return true;
1075
1076         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1077                 return true;
1078
1079         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1080                 return true;
1081
1082         return false;
1083 }
1084
1085 void ll_io_init(struct cl_io *io, const struct file *file, int write)
1086 {
1087         struct inode *inode = file->f_dentry->d_inode;
1088
1089         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
1090         if (write) {
1091                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
1092                 io->u.ci_wr.wr_sync = file->f_flags & O_SYNC ||
1093                                       file->f_flags & O_DIRECT ||
1094                                       IS_SYNC(inode);
1095         }
1096         io->ci_obj     = ll_i2info(inode)->lli_clob;
1097         io->ci_lockreq = CILR_MAYBE;
1098         if (ll_file_nolock(file)) {
1099                 io->ci_lockreq = CILR_NEVER;
1100                 io->ci_no_srvlock = 1;
1101         } else if (file->f_flags & O_APPEND) {
1102                 io->ci_lockreq = CILR_MANDATORY;
1103         }
1104
1105         io->ci_noatime = file_is_noatime(file);
1106 }
1107
1108 static ssize_t
1109 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1110                    struct file *file, enum cl_io_type iot,
1111                    loff_t *ppos, size_t count)
1112 {
1113         struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
1114         struct ll_file_data  *fd  = LUSTRE_FPRIVATE(file);
1115         struct cl_io         *io;
1116         ssize_t               result;
1117         ENTRY;
1118
1119 restart:
1120         io = ccc_env_thread_io(env);
1121         ll_io_init(io, file, iot == CIT_WRITE);
1122
1123         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
1124                 struct vvp_io *vio = vvp_env_io(env);
1125                 struct ccc_io *cio = ccc_env_io(env);
1126                 int write_mutex_locked = 0;
1127
1128                 cio->cui_fd  = LUSTRE_FPRIVATE(file);
1129                 vio->cui_io_subtype = args->via_io_subtype;
1130
1131                 switch (vio->cui_io_subtype) {
1132                 case IO_NORMAL:
1133                         cio->cui_iov = args->u.normal.via_iov;
1134                         cio->cui_nrsegs = args->u.normal.via_nrsegs;
1135                         cio->cui_tot_nrsegs = cio->cui_nrsegs;
1136                         cio->cui_iocb = args->u.normal.via_iocb;
1137                         if ((iot == CIT_WRITE) &&
1138                             !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1139                                 if (mutex_lock_interruptible(&lli->
1140                                                                lli_write_mutex))
1141                                         GOTO(out, result = -ERESTARTSYS);
1142                                 write_mutex_locked = 1;
1143                         } else if (iot == CIT_READ) {
1144                                 down_read(&lli->lli_trunc_sem);
1145                         }
1146                         break;
1147                 case IO_SENDFILE:
1148                         vio->u.sendfile.cui_actor = args->u.sendfile.via_actor;
1149                         vio->u.sendfile.cui_target = args->u.sendfile.via_target;
1150                         break;
1151                 case IO_SPLICE:
1152                         vio->u.splice.cui_pipe = args->u.splice.via_pipe;
1153                         vio->u.splice.cui_flags = args->u.splice.via_flags;
1154                         break;
1155                 default:
1156                         CERROR("Unknow IO type - %u\n", vio->cui_io_subtype);
1157                         LBUG();
1158                 }
1159                 result = cl_io_loop(env, io);
1160                 if (write_mutex_locked)
1161                         mutex_unlock(&lli->lli_write_mutex);
1162                 else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ)
1163                         up_read(&lli->lli_trunc_sem);
1164         } else {
1165                 /* cl_io_rw_init() handled IO */
1166                 result = io->ci_result;
1167         }
1168
1169         if (io->ci_nob > 0) {
1170                 result = io->ci_nob;
1171                 *ppos = io->u.ci_wr.wr.crw_pos;
1172         }
1173         GOTO(out, result);
1174 out:
1175         cl_io_fini(env, io);
1176         /* If any bit been read/written (result != 0), we just return
1177          * short read/write instead of restart io. */
1178         if ((result == 0 || result == -ENODATA) && io->ci_need_restart) {
1179                 CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zd\n",
1180                        iot == CIT_READ ? "read" : "write",
1181                        file->f_dentry->d_name.name, *ppos, count);
1182                 LASSERTF(io->ci_nob == 0, "%zd", io->ci_nob);
1183                 goto restart;
1184         }
1185
1186         if (iot == CIT_READ) {
1187                 if (result >= 0)
1188                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1189                                            LPROC_LL_READ_BYTES, result);
1190         } else if (iot == CIT_WRITE) {
1191                 if (result >= 0) {
1192                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1193                                            LPROC_LL_WRITE_BYTES, result);
1194                         fd->fd_write_failed = false;
1195                 } else if (result != -ERESTARTSYS) {
1196                         fd->fd_write_failed = true;
1197                 }
1198         }
1199
1200         return result;
1201 }
1202
1203
1204 /*
1205  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1206  */
1207 static int ll_file_get_iov_count(const struct iovec *iov,
1208                                  unsigned long *nr_segs, size_t *count)
1209 {
1210         size_t cnt = 0;
1211         unsigned long seg;
1212
1213         for (seg = 0; seg < *nr_segs; seg++) {
1214                 const struct iovec *iv = &iov[seg];
1215
1216                 /*
1217                  * If any segment has a negative length, or the cumulative
1218                  * length ever wraps negative then return -EINVAL.
1219                  */
1220                 cnt += iv->iov_len;
1221                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1222                         return -EINVAL;
1223                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
1224                         continue;
1225                 if (seg == 0)
1226                         return -EFAULT;
1227                 *nr_segs = seg;
1228                 cnt -= iv->iov_len;   /* This segment is no good */
1229                 break;
1230         }
1231         *count = cnt;
1232         return 0;
1233 }
1234
1235 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1236                                 unsigned long nr_segs, loff_t pos)
1237 {
1238         struct lu_env      *env;
1239         struct vvp_io_args *args;
1240         size_t              count;
1241         ssize_t             result;
1242         int                 refcheck;
1243         ENTRY;
1244
1245         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1246         if (result)
1247                 RETURN(result);
1248
1249         env = cl_env_get(&refcheck);
1250         if (IS_ERR(env))
1251                 RETURN(PTR_ERR(env));
1252
1253         args = vvp_env_args(env, IO_NORMAL);
1254         args->u.normal.via_iov = (struct iovec *)iov;
1255         args->u.normal.via_nrsegs = nr_segs;
1256         args->u.normal.via_iocb = iocb;
1257
1258         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1259                                     &iocb->ki_pos, count);
1260         cl_env_put(env, &refcheck);
1261         RETURN(result);
1262 }
1263
1264 static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
1265                             loff_t *ppos)
1266 {
1267         struct lu_env *env;
1268         struct iovec  *local_iov;
1269         struct kiocb  *kiocb;
1270         ssize_t        result;
1271         int            refcheck;
1272         ENTRY;
1273
1274         env = cl_env_get(&refcheck);
1275         if (IS_ERR(env))
1276                 RETURN(PTR_ERR(env));
1277
1278         local_iov = &vvp_env_info(env)->vti_local_iov;
1279         kiocb = &vvp_env_info(env)->vti_kiocb;
1280         local_iov->iov_base = (void __user *)buf;
1281         local_iov->iov_len = count;
1282         init_sync_kiocb(kiocb, file);
1283         kiocb->ki_pos = *ppos;
1284         kiocb->ki_left = count;
1285
1286         result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1287         *ppos = kiocb->ki_pos;
1288
1289         cl_env_put(env, &refcheck);
1290         RETURN(result);
1291 }
1292
1293 /*
1294  * Write to a file (through the page cache).
1295  * AIO stuff
1296  */
1297 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1298                                  unsigned long nr_segs, loff_t pos)
1299 {
1300         struct lu_env      *env;
1301         struct vvp_io_args *args;
1302         size_t              count;
1303         ssize_t             result;
1304         int                 refcheck;
1305         ENTRY;
1306
1307         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1308         if (result)
1309                 RETURN(result);
1310
1311         env = cl_env_get(&refcheck);
1312         if (IS_ERR(env))
1313                 RETURN(PTR_ERR(env));
1314
1315         args = vvp_env_args(env, IO_NORMAL);
1316         args->u.normal.via_iov = (struct iovec *)iov;
1317         args->u.normal.via_nrsegs = nr_segs;
1318         args->u.normal.via_iocb = iocb;
1319
1320         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1321                                   &iocb->ki_pos, count);
1322         cl_env_put(env, &refcheck);
1323         RETURN(result);
1324 }
1325
1326 static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1327                              loff_t *ppos)
1328 {
1329         struct lu_env *env;
1330         struct iovec  *local_iov;
1331         struct kiocb  *kiocb;
1332         ssize_t        result;
1333         int            refcheck;
1334         ENTRY;
1335
1336         env = cl_env_get(&refcheck);
1337         if (IS_ERR(env))
1338                 RETURN(PTR_ERR(env));
1339
1340         local_iov = &vvp_env_info(env)->vti_local_iov;
1341         kiocb = &vvp_env_info(env)->vti_kiocb;
1342         local_iov->iov_base = (void __user *)buf;
1343         local_iov->iov_len = count;
1344         init_sync_kiocb(kiocb, file);
1345         kiocb->ki_pos = *ppos;
1346         kiocb->ki_left = count;
1347
1348         result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1349         *ppos = kiocb->ki_pos;
1350
1351         cl_env_put(env, &refcheck);
1352         RETURN(result);
1353 }
1354
1355 /*
1356  * Send file content (through pagecache) somewhere with helper
1357  */
1358 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1359                                    struct pipe_inode_info *pipe, size_t count,
1360                                    unsigned int flags)
1361 {
1362         struct lu_env      *env;
1363         struct vvp_io_args *args;
1364         ssize_t             result;
1365         int                 refcheck;
1366         ENTRY;
1367
1368         env = cl_env_get(&refcheck);
1369         if (IS_ERR(env))
1370                 RETURN(PTR_ERR(env));
1371
1372         args = vvp_env_args(env, IO_SPLICE);
1373         args->u.splice.via_pipe = pipe;
1374         args->u.splice.via_flags = flags;
1375
1376         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1377         cl_env_put(env, &refcheck);
1378         RETURN(result);
1379 }
1380
1381 static int ll_lov_recreate(struct inode *inode, struct ost_id *oi,
1382                            obd_count ost_idx)
1383 {
1384         struct obd_export *exp = ll_i2dtexp(inode);
1385         struct obd_trans_info oti = { 0 };
1386         struct obdo *oa = NULL;
1387         int lsm_size;
1388         int rc = 0;
1389         struct lov_stripe_md *lsm = NULL, *lsm2;
1390         ENTRY;
1391
1392         OBDO_ALLOC(oa);
1393         if (oa == NULL)
1394                 RETURN(-ENOMEM);
1395
1396         lsm = ccc_inode_lsm_get(inode);
1397         if (!lsm_has_objects(lsm))
1398                 GOTO(out, rc = -ENOENT);
1399
1400         lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) *
1401                    (lsm->lsm_stripe_count));
1402
1403         OBD_ALLOC_LARGE(lsm2, lsm_size);
1404         if (lsm2 == NULL)
1405                 GOTO(out, rc = -ENOMEM);
1406
1407         oa->o_oi = *oi;
1408         oa->o_nlink = ost_idx;
1409         oa->o_flags |= OBD_FL_RECREATE_OBJS;
1410         oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1411         obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
1412                                    OBD_MD_FLMTIME | OBD_MD_FLCTIME);
1413         obdo_set_parent_fid(oa, &ll_i2info(inode)->lli_fid);
1414         memcpy(lsm2, lsm, lsm_size);
1415         ll_inode_size_lock(inode);
1416         rc = obd_create(NULL, exp, oa, &lsm2, &oti);
1417         ll_inode_size_unlock(inode);
1418
1419         OBD_FREE_LARGE(lsm2, lsm_size);
1420         GOTO(out, rc);
1421 out:
1422         ccc_inode_lsm_put(inode, lsm);
1423         OBDO_FREE(oa);
1424         return rc;
1425 }
1426
1427 static int ll_lov_recreate_obj(struct inode *inode, unsigned long arg)
1428 {
1429         struct ll_recreate_obj ucreat;
1430         struct ost_id           oi;
1431         ENTRY;
1432
1433         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1434                 RETURN(-EPERM);
1435
1436         if (copy_from_user(&ucreat, (struct ll_recreate_obj *)arg,
1437                            sizeof(ucreat)))
1438                 RETURN(-EFAULT);
1439
1440         ostid_set_seq_mdt0(&oi);
1441         ostid_set_id(&oi, ucreat.lrc_id);
1442         RETURN(ll_lov_recreate(inode, &oi, ucreat.lrc_ost_idx));
1443 }
1444
1445 static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg)
1446 {
1447         struct lu_fid   fid;
1448         struct ost_id   oi;
1449         obd_count       ost_idx;
1450         ENTRY;
1451
1452         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1453                 RETURN(-EPERM);
1454
1455         if (copy_from_user(&fid, (struct lu_fid *)arg, sizeof(fid)))
1456                 RETURN(-EFAULT);
1457
1458         fid_to_ostid(&fid, &oi);
1459         ost_idx = (fid_seq(&fid) >> 16) & 0xffff;
1460         RETURN(ll_lov_recreate(inode, &oi, ost_idx));
1461 }
1462
1463 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1464                              __u64  flags, struct lov_user_md *lum,
1465                              int lum_size)
1466 {
1467         struct lov_stripe_md *lsm = NULL;
1468         struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
1469         int rc = 0;
1470         ENTRY;
1471
1472         lsm = ccc_inode_lsm_get(inode);
1473         if (lsm != NULL) {
1474                 ccc_inode_lsm_put(inode, lsm);
1475                 CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
1476                        inode->i_ino);
1477                 RETURN(-EEXIST);
1478         }
1479
1480         ll_inode_size_lock(inode);
1481         rc = ll_intent_file_open(file, lum, lum_size, &oit);
1482         if (rc)
1483                 GOTO(out, rc);
1484         rc = oit.d.lustre.it_status;
1485         if (rc < 0)
1486                 GOTO(out_req_free, rc);
1487
1488         ll_release_openhandle(file->f_dentry, &oit);
1489
1490  out:
1491         ll_inode_size_unlock(inode);
1492         ll_intent_release(&oit);
1493         ccc_inode_lsm_put(inode, lsm);
1494         RETURN(rc);
1495 out_req_free:
1496         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
1497         goto out;
1498 }
1499
1500 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1501                              struct lov_mds_md **lmmp, int *lmm_size,
1502                              struct ptlrpc_request **request)
1503 {
1504         struct ll_sb_info *sbi = ll_i2sbi(inode);
1505         struct mdt_body  *body;
1506         struct lov_mds_md *lmm = NULL;
1507         struct ptlrpc_request *req = NULL;
1508         struct md_op_data *op_data;
1509         int rc, lmmsize;
1510
1511         rc = ll_get_max_mdsize(sbi, &lmmsize);
1512         if (rc)
1513                 RETURN(rc);
1514
1515         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1516                                      strlen(filename), lmmsize,
1517                                      LUSTRE_OPC_ANY, NULL);
1518         if (IS_ERR(op_data))
1519                 RETURN(PTR_ERR(op_data));
1520
1521         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1522         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1523         ll_finish_md_op_data(op_data);
1524         if (rc < 0) {
1525                 CDEBUG(D_INFO, "md_getattr_name failed "
1526                        "on %s: rc %d\n", filename, rc);
1527                 GOTO(out, rc);
1528         }
1529
1530         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1531         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1532
1533         lmmsize = body->eadatasize;
1534
1535         if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1536                         lmmsize == 0) {
1537                 GOTO(out, rc = -ENODATA);
1538         }
1539
1540         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1541         LASSERT(lmm != NULL);
1542
1543         if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1544             (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1545                 GOTO(out, rc = -EPROTO);
1546         }
1547
1548         /*
1549          * This is coming from the MDS, so is probably in
1550          * little endian.  We convert it to host endian before
1551          * passing it to userspace.
1552          */
1553         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1554                 int stripe_count;
1555
1556                 stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1557                 if (le32_to_cpu(lmm->lmm_pattern) & LOV_PATTERN_F_RELEASED)
1558                         stripe_count = 0;
1559
1560                 /* if function called for directory - we should
1561                  * avoid swab not existent lsm objects */
1562                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1563                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1564                         if (S_ISREG(body->mode))
1565                                 lustre_swab_lov_user_md_objects(
1566                                  ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1567                                  stripe_count);
1568                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1569                         lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1570                         if (S_ISREG(body->mode))
1571                                 lustre_swab_lov_user_md_objects(
1572                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1573                                  stripe_count);
1574                 }
1575         }
1576
1577 out:
1578         *lmmp = lmm;
1579         *lmm_size = lmmsize;
1580         *request = req;
1581         return rc;
1582 }
1583
1584 static int ll_lov_setea(struct inode *inode, struct file *file,
1585                             unsigned long arg)
1586 {
1587         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1588         struct lov_user_md      *lump;
1589         int                      lum_size = sizeof(struct lov_user_md) +
1590                                             sizeof(struct lov_user_ost_data);
1591         int                      rc;
1592         ENTRY;
1593
1594         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1595                 RETURN(-EPERM);
1596
1597         OBD_ALLOC_LARGE(lump, lum_size);
1598         if (lump == NULL)
1599                 RETURN(-ENOMEM);
1600
1601         if (copy_from_user(lump, (struct lov_user_md  *)arg, lum_size)) {
1602                 OBD_FREE_LARGE(lump, lum_size);
1603                 RETURN(-EFAULT);
1604         }
1605
1606         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1607
1608         OBD_FREE_LARGE(lump, lum_size);
1609         RETURN(rc);
1610 }
1611
1612 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1613                             unsigned long arg)
1614 {
1615         struct lov_user_md_v3    lumv3;
1616         struct lov_user_md_v1   *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1617         struct lov_user_md_v1   *lumv1p = (struct lov_user_md_v1 *)arg;
1618         struct lov_user_md_v3   *lumv3p = (struct lov_user_md_v3 *)arg;
1619         int                      lum_size, rc;
1620         __u64                    flags = FMODE_WRITE;
1621         ENTRY;
1622
1623         /* first try with v1 which is smaller than v3 */
1624         lum_size = sizeof(struct lov_user_md_v1);
1625         if (copy_from_user(lumv1, lumv1p, lum_size))
1626                 RETURN(-EFAULT);
1627
1628         if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1629                 lum_size = sizeof(struct lov_user_md_v3);
1630                 if (copy_from_user(&lumv3, lumv3p, lum_size))
1631                         RETURN(-EFAULT);
1632         }
1633
1634         rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
1635         if (rc == 0) {
1636                 struct lov_stripe_md *lsm;
1637                 __u32 gen;
1638
1639                 put_user(0, &lumv1p->lmm_stripe_count);
1640
1641                 ll_layout_refresh(inode, &gen);
1642                 lsm = ccc_inode_lsm_get(inode);
1643                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1644                                    0, lsm, (void *)arg);
1645                 ccc_inode_lsm_put(inode, lsm);
1646         }
1647         RETURN(rc);
1648 }
1649
1650 static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1651 {
1652         struct lov_stripe_md *lsm;
1653         int rc = -ENODATA;
1654         ENTRY;
1655
1656         lsm = ccc_inode_lsm_get(inode);
1657         if (lsm != NULL)
1658                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0,
1659                                    lsm, (void *)arg);
1660         ccc_inode_lsm_put(inode, lsm);
1661         RETURN(rc);
1662 }
1663
1664 int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1665 {
1666         struct ll_inode_info   *lli = ll_i2info(inode);
1667         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1668         struct ccc_grouplock    grouplock;
1669         int                     rc;
1670         ENTRY;
1671
1672         if (ll_file_nolock(file))
1673                 RETURN(-EOPNOTSUPP);
1674
1675         spin_lock(&lli->lli_lock);
1676         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1677                 CWARN("group lock already existed with gid %lu\n",
1678                       fd->fd_grouplock.cg_gid);
1679                 spin_unlock(&lli->lli_lock);
1680                 RETURN(-EINVAL);
1681         }
1682         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1683         spin_unlock(&lli->lli_lock);
1684
1685         rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1686                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1687         if (rc)
1688                 RETURN(rc);
1689
1690         spin_lock(&lli->lli_lock);
1691         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1692                 spin_unlock(&lli->lli_lock);
1693                 CERROR("another thread just won the race\n");
1694                 cl_put_grouplock(&grouplock);
1695                 RETURN(-EINVAL);
1696         }
1697
1698         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1699         fd->fd_grouplock = grouplock;
1700         spin_unlock(&lli->lli_lock);
1701
1702         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1703         RETURN(0);
1704 }
1705
1706 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1707 {
1708         struct ll_inode_info   *lli = ll_i2info(inode);
1709         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1710         struct ccc_grouplock    grouplock;
1711         ENTRY;
1712
1713         spin_lock(&lli->lli_lock);
1714         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1715                 spin_unlock(&lli->lli_lock);
1716                 CWARN("no group lock held\n");
1717                 RETURN(-EINVAL);
1718         }
1719         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1720
1721         if (fd->fd_grouplock.cg_gid != arg) {
1722                 CWARN("group lock %lu doesn't match current id %lu\n",
1723                        arg, fd->fd_grouplock.cg_gid);
1724                 spin_unlock(&lli->lli_lock);
1725                 RETURN(-EINVAL);
1726         }
1727
1728         grouplock = fd->fd_grouplock;
1729         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1730         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1731         spin_unlock(&lli->lli_lock);
1732
1733         cl_put_grouplock(&grouplock);
1734         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1735         RETURN(0);
1736 }
1737
1738 /**
1739  * Close inode open handle
1740  *
1741  * \param dentry [in]     dentry which contains the inode
1742  * \param it     [in,out] intent which contains open info and result
1743  *
1744  * \retval 0     success
1745  * \retval <0    failure
1746  */
1747 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1748 {
1749         struct inode *inode = dentry->d_inode;
1750         struct obd_client_handle *och;
1751         int rc;
1752         ENTRY;
1753
1754         LASSERT(inode);
1755
1756         /* Root ? Do nothing. */
1757         if (dentry->d_inode->i_sb->s_root == dentry)
1758                 RETURN(0);
1759
1760         /* No open handle to close? Move away */
1761         if (!it_disposition(it, DISP_OPEN_OPEN))
1762                 RETURN(0);
1763
1764         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1765
1766         OBD_ALLOC(och, sizeof(*och));
1767         if (!och)
1768                 GOTO(out, rc = -ENOMEM);
1769
1770         ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
1771
1772         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1773                                        inode, och, NULL);
1774 out:
1775         /* this one is in place of ll_file_open */
1776         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1777                 ptlrpc_req_finished(it->d.lustre.it_data);
1778                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1779         }
1780         RETURN(rc);
1781 }
1782
1783 /**
1784  * Get size for inode for which FIEMAP mapping is requested.
1785  * Make the FIEMAP get_info call and returns the result.
1786  */
1787 int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1788               int num_bytes)
1789 {
1790         struct obd_export *exp = ll_i2dtexp(inode);
1791         struct lov_stripe_md *lsm = NULL;
1792         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1793         int vallen = num_bytes;
1794         int rc;
1795         ENTRY;
1796
1797         /* Checks for fiemap flags */
1798         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1799                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1800                 return -EBADR;
1801         }
1802
1803         /* Check for FIEMAP_FLAG_SYNC */
1804         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1805                 rc = filemap_fdatawrite(inode->i_mapping);
1806                 if (rc)
1807                         return rc;
1808         }
1809
1810         lsm = ccc_inode_lsm_get(inode);
1811         if (lsm == NULL)
1812                 return -ENOENT;
1813
1814         /* If the stripe_count > 1 and the application does not understand
1815          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1816          */
1817         if (lsm->lsm_stripe_count > 1 &&
1818             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1819                 GOTO(out, rc = -EOPNOTSUPP);
1820
1821         fm_key.oa.o_oi = lsm->lsm_oi;
1822         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1823
1824         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1825         obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1826         /* If filesize is 0, then there would be no objects for mapping */
1827         if (fm_key.oa.o_size == 0) {
1828                 fiemap->fm_mapped_extents = 0;
1829                 GOTO(out, rc = 0);
1830         }
1831
1832         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1833
1834         rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1835                           fiemap, lsm);
1836         if (rc)
1837                 CERROR("obd_get_info failed: rc = %d\n", rc);
1838
1839 out:
1840         ccc_inode_lsm_put(inode, lsm);
1841         RETURN(rc);
1842 }
1843
1844 int ll_fid2path(struct inode *inode, void *arg)
1845 {
1846         struct obd_export       *exp = ll_i2mdexp(inode);
1847         struct getinfo_fid2path *gfout, *gfin;
1848         int                      outsize, rc;
1849         ENTRY;
1850
1851         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1852             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1853                 RETURN(-EPERM);
1854
1855         /* Need to get the buflen */
1856         OBD_ALLOC_PTR(gfin);
1857         if (gfin == NULL)
1858                 RETURN(-ENOMEM);
1859         if (copy_from_user(gfin, arg, sizeof(*gfin))) {
1860                 OBD_FREE_PTR(gfin);
1861                 RETURN(-EFAULT);
1862         }
1863
1864         outsize = sizeof(*gfout) + gfin->gf_pathlen;
1865         OBD_ALLOC(gfout, outsize);
1866         if (gfout == NULL) {
1867                 OBD_FREE_PTR(gfin);
1868                 RETURN(-ENOMEM);
1869         }
1870         memcpy(gfout, gfin, sizeof(*gfout));
1871         OBD_FREE_PTR(gfin);
1872
1873         /* Call mdc_iocontrol */
1874         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1875         if (rc)
1876                 GOTO(gf_free, rc);
1877
1878         if (copy_to_user(arg, gfout, outsize))
1879                 rc = -EFAULT;
1880
1881 gf_free:
1882         OBD_FREE(gfout, outsize);
1883         RETURN(rc);
1884 }
1885
1886 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1887 {
1888         struct ll_user_fiemap *fiemap_s;
1889         size_t num_bytes, ret_bytes;
1890         unsigned int extent_count;
1891         int rc = 0;
1892
1893         /* Get the extent count so we can calculate the size of
1894          * required fiemap buffer */
1895         if (get_user(extent_count,
1896             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1897                 RETURN(-EFAULT);
1898         num_bytes = sizeof(*fiemap_s) + (extent_count *
1899                                          sizeof(struct ll_fiemap_extent));
1900
1901         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1902         if (fiemap_s == NULL)
1903                 RETURN(-ENOMEM);
1904
1905         /* get the fiemap value */
1906         if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1907                            sizeof(*fiemap_s)))
1908                 GOTO(error, rc = -EFAULT);
1909
1910         /* If fm_extent_count is non-zero, read the first extent since
1911          * it is used to calculate end_offset and device from previous
1912          * fiemap call. */
1913         if (extent_count) {
1914                 if (copy_from_user(&fiemap_s->fm_extents[0],
1915                     (char __user *)arg + sizeof(*fiemap_s),
1916                     sizeof(struct ll_fiemap_extent)))
1917                         GOTO(error, rc = -EFAULT);
1918         }
1919
1920         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1921         if (rc)
1922                 GOTO(error, rc);
1923
1924         ret_bytes = sizeof(struct ll_user_fiemap);
1925
1926         if (extent_count != 0)
1927                 ret_bytes += (fiemap_s->fm_mapped_extents *
1928                                  sizeof(struct ll_fiemap_extent));
1929
1930         if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
1931                 rc = -EFAULT;
1932
1933 error:
1934         OBD_FREE_LARGE(fiemap_s, num_bytes);
1935         RETURN(rc);
1936 }
1937
1938 /*
1939  * Read the data_version for inode.
1940  *
1941  * This value is computed using stripe object version on OST.
1942  * Version is computed using server side locking.
1943  *
1944  * @param extent_lock  Take extent lock. Not needed if a process is already
1945  *                     holding the OST object group locks.
1946  */
1947 int ll_data_version(struct inode *inode, __u64 *data_version,
1948                     int extent_lock)
1949 {
1950         struct lov_stripe_md    *lsm = NULL;
1951         struct ll_sb_info       *sbi = ll_i2sbi(inode);
1952         struct obdo             *obdo = NULL;
1953         int                      rc;
1954         ENTRY;
1955
1956         /* If no stripe, we consider version is 0. */
1957         lsm = ccc_inode_lsm_get(inode);
1958         if (!lsm_has_objects(lsm)) {
1959                 *data_version = 0;
1960                 CDEBUG(D_INODE, "No object for inode\n");
1961                 GOTO(out, rc = 0);
1962         }
1963
1964         OBD_ALLOC_PTR(obdo);
1965         if (obdo == NULL)
1966                 GOTO(out, rc = -ENOMEM);
1967
1968         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock);
1969         if (rc == 0) {
1970                 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1971                         rc = -EOPNOTSUPP;
1972                 else
1973                         *data_version = obdo->o_data_version;
1974         }
1975
1976         OBD_FREE_PTR(obdo);
1977         EXIT;
1978 out:
1979         ccc_inode_lsm_put(inode, lsm);
1980         RETURN(rc);
1981 }
1982
1983 /*
1984  * Trigger a HSM release request for the provided inode.
1985  */
1986 int ll_hsm_release(struct inode *inode)
1987 {
1988         struct cl_env_nest nest;
1989         struct lu_env *env;
1990         struct obd_client_handle *och = NULL;
1991         __u64 data_version = 0;
1992         int rc;
1993         ENTRY;
1994
1995         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
1996                ll_get_fsname(inode->i_sb, NULL, 0),
1997                PFID(&ll_i2info(inode)->lli_fid));
1998
1999         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
2000         if (IS_ERR(och))
2001                 GOTO(out, rc = PTR_ERR(och));
2002
2003         /* Grab latest data_version and [am]time values */
2004         rc = ll_data_version(inode, &data_version, 1);
2005         if (rc != 0)
2006                 GOTO(out, rc);
2007
2008         env = cl_env_nested_get(&nest);
2009         if (IS_ERR(env))
2010                 GOTO(out, rc = PTR_ERR(env));
2011
2012         ll_merge_lvb(env, inode);
2013         cl_env_nested_put(&nest, env);
2014
2015         /* Release the file.
2016          * NB: lease lock handle is released in mdc_hsm_release_pack() because
2017          * we still need it to pack l_remote_handle to MDT. */
2018         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
2019                                        &data_version);
2020         och = NULL;
2021
2022         EXIT;
2023 out:
2024         if (och != NULL && !IS_ERR(och)) /* close the file */
2025                 ll_lease_close(och, inode, NULL);
2026
2027         return rc;
2028 }
2029
2030 struct ll_swap_stack {
2031         struct iattr             ia1, ia2;
2032         __u64                    dv1, dv2;
2033         struct inode            *inode1, *inode2;
2034         bool                     check_dv1, check_dv2;
2035 };
2036
2037 static int ll_swap_layouts(struct file *file1, struct file *file2,
2038                            struct lustre_swap_layouts *lsl)
2039 {
2040         struct mdc_swap_layouts  msl;
2041         struct md_op_data       *op_data;
2042         __u32                    gid;
2043         __u64                    dv;
2044         struct ll_swap_stack    *llss = NULL;
2045         int                      rc;
2046
2047         OBD_ALLOC_PTR(llss);
2048         if (llss == NULL)
2049                 RETURN(-ENOMEM);
2050
2051         llss->inode1 = file1->f_dentry->d_inode;
2052         llss->inode2 = file2->f_dentry->d_inode;
2053
2054         if (!S_ISREG(llss->inode2->i_mode))
2055                 GOTO(free, rc = -EINVAL);
2056
2057         if (inode_permission(llss->inode1, MAY_WRITE) ||
2058             inode_permission(llss->inode2, MAY_WRITE))
2059                 GOTO(free, rc = -EPERM);
2060
2061         if (llss->inode2->i_sb != llss->inode1->i_sb)
2062                 GOTO(free, rc = -EXDEV);
2063
2064         /* we use 2 bool because it is easier to swap than 2 bits */
2065         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2066                 llss->check_dv1 = true;
2067
2068         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2069                 llss->check_dv2 = true;
2070
2071         /* we cannot use lsl->sl_dvX directly because we may swap them */
2072         llss->dv1 = lsl->sl_dv1;
2073         llss->dv2 = lsl->sl_dv2;
2074
2075         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2076         if (rc == 0) /* same file, done! */
2077                 GOTO(free, rc = 0);
2078
2079         if (rc < 0) { /* sequentialize it */
2080                 swap(llss->inode1, llss->inode2);
2081                 swap(file1, file2);
2082                 swap(llss->dv1, llss->dv2);
2083                 swap(llss->check_dv1, llss->check_dv2);
2084         }
2085
2086         gid = lsl->sl_gid;
2087         if (gid != 0) { /* application asks to flush dirty cache */
2088                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2089                 if (rc < 0)
2090                         GOTO(free, rc);
2091
2092                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2093                 if (rc < 0) {
2094                         ll_put_grouplock(llss->inode1, file1, gid);
2095                         GOTO(free, rc);
2096                 }
2097         }
2098
2099         /* to be able to restore mtime and atime after swap
2100          * we need to first save them */
2101         if (lsl->sl_flags &
2102             (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
2103                 llss->ia1.ia_mtime = llss->inode1->i_mtime;
2104                 llss->ia1.ia_atime = llss->inode1->i_atime;
2105                 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
2106                 llss->ia2.ia_mtime = llss->inode2->i_mtime;
2107                 llss->ia2.ia_atime = llss->inode2->i_atime;
2108                 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
2109         }
2110
2111         /* ultimate check, before swaping the layouts we check if
2112          * dataversion has changed (if requested) */
2113         if (llss->check_dv1) {
2114                 rc = ll_data_version(llss->inode1, &dv, 0);
2115                 if (rc)
2116                         GOTO(putgl, rc);
2117                 if (dv != llss->dv1)
2118                         GOTO(putgl, rc = -EAGAIN);
2119         }
2120
2121         if (llss->check_dv2) {
2122                 rc = ll_data_version(llss->inode2, &dv, 0);
2123                 if (rc)
2124                         GOTO(putgl, rc);
2125                 if (dv != llss->dv2)
2126                         GOTO(putgl, rc = -EAGAIN);
2127         }
2128
2129         /* struct md_op_data is used to send the swap args to the mdt
2130          * only flags is missing, so we use struct mdc_swap_layouts
2131          * through the md_op_data->op_data */
2132         /* flags from user space have to be converted before they are send to
2133          * server, no flag is sent today, they are only used on the client */
2134         msl.msl_flags = 0;
2135         rc = -ENOMEM;
2136         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2137                                      0, LUSTRE_OPC_ANY, &msl);
2138         if (IS_ERR(op_data))
2139                 GOTO(free, rc = PTR_ERR(op_data));
2140
2141         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2142                            sizeof(*op_data), op_data, NULL);
2143         ll_finish_md_op_data(op_data);
2144
2145 putgl:
2146         if (gid != 0) {
2147                 ll_put_grouplock(llss->inode2, file2, gid);
2148                 ll_put_grouplock(llss->inode1, file1, gid);
2149         }
2150
2151         /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */
2152         if (rc != 0)
2153                 GOTO(free, rc);
2154
2155         /* clear useless flags */
2156         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
2157                 llss->ia1.ia_valid &= ~ATTR_MTIME;
2158                 llss->ia2.ia_valid &= ~ATTR_MTIME;
2159         }
2160
2161         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
2162                 llss->ia1.ia_valid &= ~ATTR_ATIME;
2163                 llss->ia2.ia_valid &= ~ATTR_ATIME;
2164         }
2165
2166         /* update time if requested */
2167         rc = 0;
2168         if (llss->ia2.ia_valid != 0) {
2169                 mutex_lock(&llss->inode1->i_mutex);
2170                 rc = ll_setattr(file1->f_dentry, &llss->ia2);
2171                 mutex_unlock(&llss->inode1->i_mutex);
2172         }
2173
2174         if (llss->ia1.ia_valid != 0) {
2175                 int rc1;
2176
2177                 mutex_lock(&llss->inode2->i_mutex);
2178                 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
2179                 mutex_unlock(&llss->inode2->i_mutex);
2180                 if (rc == 0)
2181                         rc = rc1;
2182         }
2183
2184 free:
2185         if (llss != NULL)
2186                 OBD_FREE_PTR(llss);
2187
2188         RETURN(rc);
2189 }
2190
2191 static int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2192 {
2193         struct md_op_data       *op_data;
2194         int                      rc;
2195
2196         /* Non-root users are forbidden to set or clear flags which are
2197          * NOT defined in HSM_USER_MASK. */
2198         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2199             !cfs_capable(CFS_CAP_SYS_ADMIN))
2200                 RETURN(-EPERM);
2201
2202         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2203                                      LUSTRE_OPC_ANY, hss);
2204         if (IS_ERR(op_data))
2205                 RETURN(PTR_ERR(op_data));
2206
2207         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2208                            sizeof(*op_data), op_data, NULL);
2209
2210         ll_finish_md_op_data(op_data);
2211
2212         RETURN(rc);
2213 }
2214
2215 static int ll_hsm_import(struct inode *inode, struct file *file,
2216                          struct hsm_user_import *hui)
2217 {
2218         struct hsm_state_set    *hss = NULL;
2219         struct iattr            *attr = NULL;
2220         int                      rc;
2221         ENTRY;
2222
2223         if (!S_ISREG(inode->i_mode))
2224                 RETURN(-EINVAL);
2225
2226         /* set HSM flags */
2227         OBD_ALLOC_PTR(hss);
2228         if (hss == NULL)
2229                 GOTO(out, rc = -ENOMEM);
2230
2231         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2232         hss->hss_archive_id = hui->hui_archive_id;
2233         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2234         rc = ll_hsm_state_set(inode, hss);
2235         if (rc != 0)
2236                 GOTO(out, rc);
2237
2238         OBD_ALLOC_PTR(attr);
2239         if (attr == NULL)
2240                 GOTO(out, rc = -ENOMEM);
2241
2242         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2243         attr->ia_mode |= S_IFREG;
2244         attr->ia_uid = hui->hui_uid;
2245         attr->ia_gid = hui->hui_gid;
2246         attr->ia_size = hui->hui_size;
2247         attr->ia_mtime.tv_sec = hui->hui_mtime;
2248         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2249         attr->ia_atime.tv_sec = hui->hui_atime;
2250         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2251
2252         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2253                          ATTR_UID | ATTR_GID |
2254                          ATTR_MTIME | ATTR_MTIME_SET |
2255                          ATTR_ATIME | ATTR_ATIME_SET;
2256
2257         rc = ll_setattr_raw(file->f_dentry, attr, true);
2258         if (rc == -ENODATA)
2259                 rc = 0;
2260
2261 out:
2262         if (hss != NULL)
2263                 OBD_FREE_PTR(hss);
2264
2265         if (attr != NULL)
2266                 OBD_FREE_PTR(attr);
2267
2268         RETURN(rc);
2269 }
2270
2271 long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2272 {
2273         struct inode            *inode = file->f_dentry->d_inode;
2274         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2275         int                      flags, rc;
2276         ENTRY;
2277
2278         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
2279                inode->i_generation, inode, cmd);
2280         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2281
2282         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2283         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2284                 RETURN(-ENOTTY);
2285
2286         switch(cmd) {
2287         case LL_IOC_GETFLAGS:
2288                 /* Get the current value of the file flags */
2289                 return put_user(fd->fd_flags, (int *)arg);
2290         case LL_IOC_SETFLAGS:
2291         case LL_IOC_CLRFLAGS:
2292                 /* Set or clear specific file flags */
2293                 /* XXX This probably needs checks to ensure the flags are
2294                  *     not abused, and to handle any flag side effects.
2295                  */
2296                 if (get_user(flags, (int *) arg))
2297                         RETURN(-EFAULT);
2298
2299                 if (cmd == LL_IOC_SETFLAGS) {
2300                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2301                             !(file->f_flags & O_DIRECT)) {
2302                                 CERROR("%s: unable to disable locking on "
2303                                        "non-O_DIRECT file\n", current->comm);
2304                                 RETURN(-EINVAL);
2305                         }
2306
2307                         fd->fd_flags |= flags;
2308                 } else {
2309                         fd->fd_flags &= ~flags;
2310                 }
2311                 RETURN(0);
2312         case LL_IOC_LOV_SETSTRIPE:
2313                 RETURN(ll_lov_setstripe(inode, file, arg));
2314         case LL_IOC_LOV_SETEA:
2315                 RETURN(ll_lov_setea(inode, file, arg));
2316         case LL_IOC_LOV_SWAP_LAYOUTS: {
2317                 struct file *file2;
2318                 struct lustre_swap_layouts lsl;
2319
2320                 if (copy_from_user(&lsl, (char *)arg,
2321                                        sizeof(struct lustre_swap_layouts)))
2322                         RETURN(-EFAULT);
2323
2324                 if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */
2325                         RETURN(-EPERM);
2326
2327                 file2 = fget(lsl.sl_fd);
2328                 if (file2 == NULL)
2329                         RETURN(-EBADF);
2330
2331                 rc = -EPERM;
2332                 if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */
2333                         rc = ll_swap_layouts(file, file2, &lsl);
2334                 fput(file2);
2335                 RETURN(rc);
2336         }
2337         case LL_IOC_LOV_GETSTRIPE:
2338                 RETURN(ll_lov_getstripe(inode, arg));
2339         case LL_IOC_RECREATE_OBJ:
2340                 RETURN(ll_lov_recreate_obj(inode, arg));
2341         case LL_IOC_RECREATE_FID:
2342                 RETURN(ll_lov_recreate_fid(inode, arg));
2343         case FSFILT_IOC_FIEMAP:
2344                 RETURN(ll_ioctl_fiemap(inode, arg));
2345         case FSFILT_IOC_GETFLAGS:
2346         case FSFILT_IOC_SETFLAGS:
2347                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2348         case FSFILT_IOC_GETVERSION_OLD:
2349         case FSFILT_IOC_GETVERSION:
2350                 RETURN(put_user(inode->i_generation, (int *)arg));
2351         case LL_IOC_GROUP_LOCK:
2352                 RETURN(ll_get_grouplock(inode, file, arg));
2353         case LL_IOC_GROUP_UNLOCK:
2354                 RETURN(ll_put_grouplock(inode, file, arg));
2355         case IOC_OBD_STATFS:
2356                 RETURN(ll_obd_statfs(inode, (void *)arg));
2357
2358         /* We need to special case any other ioctls we want to handle,
2359          * to send them to the MDS/OST as appropriate and to properly
2360          * network encode the arg field.
2361         case FSFILT_IOC_SETVERSION_OLD:
2362         case FSFILT_IOC_SETVERSION:
2363         */
2364         case LL_IOC_FLUSHCTX:
2365                 RETURN(ll_flush_ctx(inode));
2366         case LL_IOC_PATH2FID: {
2367                 if (copy_to_user((void *)arg, ll_inode2fid(inode),
2368                                  sizeof(struct lu_fid)))
2369                         RETURN(-EFAULT);
2370
2371                 RETURN(0);
2372         }
2373         case OBD_IOC_FID2PATH:
2374                 RETURN(ll_fid2path(inode, (void *)arg));
2375         case LL_IOC_DATA_VERSION: {
2376                 struct ioc_data_version idv;
2377                 int                     rc;
2378
2379                 if (copy_from_user(&idv, (char *)arg, sizeof(idv)))
2380                         RETURN(-EFAULT);
2381
2382                 rc = ll_data_version(inode, &idv.idv_version,
2383                                 !(idv.idv_flags & LL_DV_NOFLUSH));
2384
2385                 if (rc == 0 && copy_to_user((char *) arg, &idv, sizeof(idv)))
2386                         RETURN(-EFAULT);
2387
2388                 RETURN(rc);
2389         }
2390
2391         case LL_IOC_GET_MDTIDX: {
2392                 int mdtidx;
2393
2394                 mdtidx = ll_get_mdt_idx(inode);
2395                 if (mdtidx < 0)
2396                         RETURN(mdtidx);
2397
2398                 if (put_user((int)mdtidx, (int*)arg))
2399                         RETURN(-EFAULT);
2400
2401                 RETURN(0);
2402         }
2403         case OBD_IOC_GETDTNAME:
2404         case OBD_IOC_GETMDNAME:
2405                 RETURN(ll_get_obd_name(inode, cmd, arg));
2406         case LL_IOC_HSM_STATE_GET: {
2407                 struct md_op_data       *op_data;
2408                 struct hsm_user_state   *hus;
2409                 int                      rc;
2410
2411                 OBD_ALLOC_PTR(hus);
2412                 if (hus == NULL)
2413                         RETURN(-ENOMEM);
2414
2415                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2416                                              LUSTRE_OPC_ANY, hus);
2417                 if (IS_ERR(op_data)) {
2418                         OBD_FREE_PTR(hus);
2419                         RETURN(PTR_ERR(op_data));
2420                 }
2421
2422                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2423                                    op_data, NULL);
2424
2425                 if (copy_to_user((void *)arg, hus, sizeof(*hus)))
2426                         rc = -EFAULT;
2427
2428                 ll_finish_md_op_data(op_data);
2429                 OBD_FREE_PTR(hus);
2430                 RETURN(rc);
2431         }
2432         case LL_IOC_HSM_STATE_SET: {
2433                 struct hsm_state_set    *hss;
2434                 int                      rc;
2435
2436                 OBD_ALLOC_PTR(hss);
2437                 if (hss == NULL)
2438                         RETURN(-ENOMEM);
2439
2440                 if (copy_from_user(hss, (char *)arg, sizeof(*hss))) {
2441                         OBD_FREE_PTR(hss);
2442                         RETURN(-EFAULT);
2443                 }
2444
2445                 rc = ll_hsm_state_set(inode, hss);
2446
2447                 OBD_FREE_PTR(hss);
2448                 RETURN(rc);
2449         }
2450         case LL_IOC_HSM_ACTION: {
2451                 struct md_op_data               *op_data;
2452                 struct hsm_current_action       *hca;
2453                 int                              rc;
2454
2455                 OBD_ALLOC_PTR(hca);
2456                 if (hca == NULL)
2457                         RETURN(-ENOMEM);
2458
2459                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2460                                              LUSTRE_OPC_ANY, hca);
2461                 if (IS_ERR(op_data)) {
2462                         OBD_FREE_PTR(hca);
2463                         RETURN(PTR_ERR(op_data));
2464                 }
2465
2466                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2467                                    op_data, NULL);
2468
2469                 if (copy_to_user((char *)arg, hca, sizeof(*hca)))
2470                         rc = -EFAULT;
2471
2472                 ll_finish_md_op_data(op_data);
2473                 OBD_FREE_PTR(hca);
2474                 RETURN(rc);
2475         }
2476         case LL_IOC_SET_LEASE: {
2477                 struct ll_inode_info *lli = ll_i2info(inode);
2478                 struct obd_client_handle *och = NULL;
2479                 bool lease_broken;
2480                 fmode_t mode = 0;
2481
2482                 switch (arg) {
2483                 case F_WRLCK:
2484                         if (!(file->f_mode & FMODE_WRITE))
2485                                 RETURN(-EPERM);
2486                         mode = FMODE_WRITE;
2487                         break;
2488                 case F_RDLCK:
2489                         if (!(file->f_mode & FMODE_READ))
2490                                 RETURN(-EPERM);
2491                         mode = FMODE_READ;
2492                         break;
2493                 case F_UNLCK:
2494                         mutex_lock(&lli->lli_och_mutex);
2495                         if (fd->fd_lease_och != NULL) {
2496                                 och = fd->fd_lease_och;
2497                                 fd->fd_lease_och = NULL;
2498                         }
2499                         mutex_unlock(&lli->lli_och_mutex);
2500
2501                         if (och != NULL) {
2502                                 mode = och->och_flags &(FMODE_READ|FMODE_WRITE);
2503                                 rc = ll_lease_close(och, inode, &lease_broken);
2504                                 if (rc == 0 && lease_broken)
2505                                         mode = 0;
2506                         } else {
2507                                 rc = -ENOLCK;
2508                         }
2509
2510                         /* return the type of lease or error */
2511                         RETURN(rc < 0 ? rc : (int)mode);
2512                 default:
2513                         RETURN(-EINVAL);
2514                 }
2515
2516                 CDEBUG(D_INODE, "Set lease with mode %d\n", mode);
2517
2518                 /* apply for lease */
2519                 och = ll_lease_open(inode, file, mode, 0);
2520                 if (IS_ERR(och))
2521                         RETURN(PTR_ERR(och));
2522
2523                 rc = 0;
2524                 mutex_lock(&lli->lli_och_mutex);
2525                 if (fd->fd_lease_och == NULL) {
2526                         fd->fd_lease_och = och;
2527                         och = NULL;
2528                 }
2529                 mutex_unlock(&lli->lli_och_mutex);
2530                 if (och != NULL) {
2531                         /* impossible now that only excl is supported for now */
2532                         ll_lease_close(och, inode, &lease_broken);
2533                         rc = -EBUSY;
2534                 }
2535                 RETURN(rc);
2536         }
2537         case LL_IOC_GET_LEASE: {
2538                 struct ll_inode_info *lli = ll_i2info(inode);
2539                 struct ldlm_lock *lock = NULL;
2540
2541                 rc = 0;
2542                 mutex_lock(&lli->lli_och_mutex);
2543                 if (fd->fd_lease_och != NULL) {
2544                         struct obd_client_handle *och = fd->fd_lease_och;
2545
2546                         lock = ldlm_handle2lock(&och->och_lease_handle);
2547                         if (lock != NULL) {
2548                                 lock_res_and_lock(lock);
2549                                 if (!ldlm_is_cancel(lock))
2550                                         rc = och->och_flags &
2551                                                 (FMODE_READ | FMODE_WRITE);
2552                                 unlock_res_and_lock(lock);
2553                                 LDLM_LOCK_PUT(lock);
2554                         }
2555                 }
2556                 mutex_unlock(&lli->lli_och_mutex);
2557                 RETURN(rc);
2558         }
2559         case LL_IOC_HSM_IMPORT: {
2560                 struct hsm_user_import *hui;
2561
2562                 OBD_ALLOC_PTR(hui);
2563                 if (hui == NULL)
2564                         RETURN(-ENOMEM);
2565
2566                 if (copy_from_user(hui, (void *)arg, sizeof(*hui))) {
2567                         OBD_FREE_PTR(hui);
2568                         RETURN(-EFAULT);
2569                 }
2570
2571                 rc = ll_hsm_import(inode, file, hui);
2572
2573                 OBD_FREE_PTR(hui);
2574                 RETURN(rc);
2575         }
2576         default: {
2577                 int err;
2578
2579                 if (LLIOC_STOP ==
2580                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2581                         RETURN(err);
2582
2583                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2584                                      (void *)arg));
2585         }
2586         }
2587 }
2588
2589 #ifndef HAVE_FILE_LLSEEK_SIZE
2590 static inline loff_t
2591 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2592 {
2593         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2594                 return -EINVAL;
2595         if (offset > maxsize)
2596                 return -EINVAL;
2597
2598         if (offset != file->f_pos) {
2599                 file->f_pos = offset;
2600                 file->f_version = 0;
2601         }
2602         return offset;
2603 }
2604
2605 static loff_t
2606 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2607                 loff_t maxsize, loff_t eof)
2608 {
2609         struct inode *inode = file->f_dentry->d_inode;
2610
2611         switch (origin) {
2612         case SEEK_END:
2613                 offset += eof;
2614                 break;
2615         case SEEK_CUR:
2616                 /*
2617                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2618                  * position-querying operation.  Avoid rewriting the "same"
2619                  * f_pos value back to the file because a concurrent read(),
2620                  * write() or lseek() might have altered it
2621                  */
2622                 if (offset == 0)
2623                         return file->f_pos;
2624                 /*
2625                  * f_lock protects against read/modify/write race with other
2626                  * SEEK_CURs. Note that parallel writes and reads behave
2627                  * like SEEK_SET.
2628                  */
2629                 mutex_lock(&inode->i_mutex);
2630                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2631                 mutex_unlock(&inode->i_mutex);
2632                 return offset;
2633         case SEEK_DATA:
2634                 /*
2635                  * In the generic case the entire file is data, so as long as
2636                  * offset isn't at the end of the file then the offset is data.
2637                  */
2638                 if (offset >= eof)
2639                         return -ENXIO;
2640                 break;
2641         case SEEK_HOLE:
2642                 /*
2643                  * There is a virtual hole at the end of the file, so as long as
2644                  * offset isn't i_size or larger, return i_size.
2645                  */
2646                 if (offset >= eof)
2647                         return -ENXIO;
2648                 offset = eof;
2649                 break;
2650         }
2651
2652         return llseek_execute(file, offset, maxsize);
2653 }
2654 #endif
2655
2656 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2657 {
2658         struct inode *inode = file->f_dentry->d_inode;
2659         loff_t retval, eof = 0;
2660
2661         ENTRY;
2662         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2663                            (origin == SEEK_CUR) ? file->f_pos : 0);
2664         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%d)\n",
2665                inode->i_ino, inode->i_generation, inode, retval, retval,
2666                origin);
2667         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2668
2669         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2670                 retval = ll_glimpse_size(inode);
2671                 if (retval != 0)
2672                         RETURN(retval);
2673                 eof = i_size_read(inode);
2674         }
2675
2676         retval = ll_generic_file_llseek_size(file, offset, origin,
2677                                           ll_file_maxbytes(inode), eof);
2678         RETURN(retval);
2679 }
2680
2681 int ll_flush(struct file *file, fl_owner_t id)
2682 {
2683         struct inode *inode = file->f_dentry->d_inode;
2684         struct ll_inode_info *lli = ll_i2info(inode);
2685         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2686         int rc, err;
2687
2688         LASSERT(!S_ISDIR(inode->i_mode));
2689
2690         /* catch async errors that were recorded back when async writeback
2691          * failed for pages in this mapping. */
2692         rc = lli->lli_async_rc;
2693         lli->lli_async_rc = 0;
2694         err = lov_read_and_clear_async_rc(lli->lli_clob);
2695         if (rc == 0)
2696                 rc = err;
2697
2698         /* The application has been told write failure already.
2699          * Do not report failure again. */
2700         if (fd->fd_write_failed)
2701                 return 0;
2702         return rc ? -EIO : 0;
2703 }
2704
2705 /**
2706  * Called to make sure a portion of file has been written out.
2707  * if @local_only is not true, it will send OST_SYNC RPCs to ost.
2708  *
2709  * Return how many pages have been written.
2710  */
2711 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2712                        enum cl_fsync_mode mode, int ignore_layout)
2713 {
2714         struct cl_env_nest nest;
2715         struct lu_env *env;
2716         struct cl_io *io;
2717         struct obd_capa *capa = NULL;
2718         struct cl_fsync_io *fio;
2719         int result;
2720         ENTRY;
2721
2722         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2723             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2724                 RETURN(-EINVAL);
2725
2726         env = cl_env_nested_get(&nest);
2727         if (IS_ERR(env))
2728                 RETURN(PTR_ERR(env));
2729
2730         capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2731
2732         io = ccc_env_thread_io(env);
2733         io->ci_obj = cl_i2info(inode)->lli_clob;
2734         io->ci_ignore_layout = ignore_layout;
2735
2736         /* initialize parameters for sync */
2737         fio = &io->u.ci_fsync;
2738         fio->fi_capa = capa;
2739         fio->fi_start = start;
2740         fio->fi_end = end;
2741         fio->fi_fid = ll_inode2fid(inode);
2742         fio->fi_mode = mode;
2743         fio->fi_nr_written = 0;
2744
2745         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2746                 result = cl_io_loop(env, io);
2747         else
2748                 result = io->ci_result;
2749         if (result == 0)
2750                 result = fio->fi_nr_written;
2751         cl_io_fini(env, io);
2752         cl_env_nested_put(&nest, env);
2753
2754         capa_put(capa);
2755
2756         RETURN(result);
2757 }
2758
2759 /*
2760  * When dentry is provided (the 'else' case), *file->f_dentry may be
2761  * null and dentry must be used directly rather than pulled from
2762  * *file->f_dentry as is done otherwise.
2763  */
2764
2765 #ifdef HAVE_FILE_FSYNC_4ARGS
2766 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2767 {
2768         struct dentry *dentry = file->f_dentry;
2769 #elif defined(HAVE_FILE_FSYNC_2ARGS)
2770 int ll_fsync(struct file *file, int datasync)
2771 {
2772         struct dentry *dentry = file->f_dentry;
2773 #else
2774 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
2775 {
2776 #endif
2777         struct inode *inode = dentry->d_inode;
2778         struct ll_inode_info *lli = ll_i2info(inode);
2779         struct ptlrpc_request *req;
2780         struct obd_capa *oc;
2781         int rc, err;
2782         ENTRY;
2783
2784         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
2785                inode->i_generation, inode);
2786         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2787
2788 #ifdef HAVE_FILE_FSYNC_4ARGS
2789         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2790         mutex_lock(&inode->i_mutex);
2791 #else
2792         /* fsync's caller has already called _fdata{sync,write}, we want
2793          * that IO to finish before calling the osc and mdc sync methods */
2794         rc = filemap_fdatawait(inode->i_mapping);
2795 #endif
2796
2797         /* catch async errors that were recorded back when async writeback
2798          * failed for pages in this mapping. */
2799         if (!S_ISDIR(inode->i_mode)) {
2800                 err = lli->lli_async_rc;
2801                 lli->lli_async_rc = 0;
2802                 if (rc == 0)
2803                         rc = err;
2804                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2805                 if (rc == 0)
2806                         rc = err;
2807         }
2808
2809         oc = ll_mdscapa_get(inode);
2810         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2811                       &req);
2812         capa_put(oc);
2813         if (!rc)
2814                 rc = err;
2815         if (!err)
2816                 ptlrpc_req_finished(req);
2817
2818         if (datasync && S_ISREG(inode->i_mode)) {
2819                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2820
2821                 err = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF,
2822                                 CL_FSYNC_ALL, 0);
2823                 if (rc == 0 && err < 0)
2824                         rc = err;
2825                 if (rc < 0)
2826                         fd->fd_write_failed = true;
2827                 else
2828                         fd->fd_write_failed = false;
2829         }
2830
2831 #ifdef HAVE_FILE_FSYNC_4ARGS
2832         mutex_unlock(&inode->i_mutex);
2833 #endif
2834         RETURN(rc);
2835 }
2836
2837 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2838 {
2839         struct inode *inode = file->f_dentry->d_inode;
2840         struct ll_sb_info *sbi = ll_i2sbi(inode);
2841         struct ldlm_enqueue_info einfo = {
2842                 .ei_type        = LDLM_FLOCK,
2843                 .ei_cb_cp       = ldlm_flock_completion_ast,
2844                 .ei_cbdata      = file_lock,
2845         };
2846         struct md_op_data *op_data;
2847         struct lustre_handle lockh = {0};
2848         ldlm_policy_data_t flock = {{0}};
2849         int flags = 0;
2850         int rc;
2851         int rc2 = 0;
2852         ENTRY;
2853
2854         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2855                inode->i_ino, file_lock);
2856
2857         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2858
2859         if (file_lock->fl_flags & FL_FLOCK) {
2860                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2861                 /* flocks are whole-file locks */
2862                 flock.l_flock.end = OFFSET_MAX;
2863                 /* For flocks owner is determined by the local file desctiptor*/
2864                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2865         } else if (file_lock->fl_flags & FL_POSIX) {
2866                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2867                 flock.l_flock.start = file_lock->fl_start;
2868                 flock.l_flock.end = file_lock->fl_end;
2869         } else {
2870                 RETURN(-EINVAL);
2871         }
2872         flock.l_flock.pid = file_lock->fl_pid;
2873
2874         /* Somewhat ugly workaround for svc lockd.
2875          * lockd installs custom fl_lmops->lm_compare_owner that checks
2876          * for the fl_owner to be the same (which it always is on local node
2877          * I guess between lockd processes) and then compares pid.
2878          * As such we assign pid to the owner field to make it all work,
2879          * conflict with normal locks is unlikely since pid space and
2880          * pointer space for current->files are not intersecting */
2881         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2882                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2883
2884         switch (file_lock->fl_type) {
2885         case F_RDLCK:
2886                 einfo.ei_mode = LCK_PR;
2887                 break;
2888         case F_UNLCK:
2889                 /* An unlock request may or may not have any relation to
2890                  * existing locks so we may not be able to pass a lock handle
2891                  * via a normal ldlm_lock_cancel() request. The request may even
2892                  * unlock a byte range in the middle of an existing lock. In
2893                  * order to process an unlock request we need all of the same
2894                  * information that is given with a normal read or write record
2895                  * lock request. To avoid creating another ldlm unlock (cancel)
2896                  * message we'll treat a LCK_NL flock request as an unlock. */
2897                 einfo.ei_mode = LCK_NL;
2898                 break;
2899         case F_WRLCK:
2900                 einfo.ei_mode = LCK_PW;
2901                 break;
2902         default:
2903                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n",
2904                         file_lock->fl_type);
2905                 RETURN (-ENOTSUPP);
2906         }
2907
2908         switch (cmd) {
2909         case F_SETLKW:
2910 #ifdef F_SETLKW64
2911         case F_SETLKW64:
2912 #endif
2913                 flags = 0;
2914                 break;
2915         case F_SETLK:
2916 #ifdef F_SETLK64
2917         case F_SETLK64:
2918 #endif
2919                 flags = LDLM_FL_BLOCK_NOWAIT;
2920                 break;
2921         case F_GETLK:
2922 #ifdef F_GETLK64
2923         case F_GETLK64:
2924 #endif
2925                 flags = LDLM_FL_TEST_LOCK;
2926                 /* Save the old mode so that if the mode in the lock changes we
2927                  * can decrement the appropriate reader or writer refcount. */
2928                 file_lock->fl_type = einfo.ei_mode;
2929                 break;
2930         default:
2931                 CERROR("unknown fcntl lock command: %d\n", cmd);
2932                 RETURN (-EINVAL);
2933         }
2934
2935         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2936                                      LUSTRE_OPC_ANY, NULL);
2937         if (IS_ERR(op_data))
2938                 RETURN(PTR_ERR(op_data));
2939
2940         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2941                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2942                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2943
2944         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2945                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2946
2947         if ((file_lock->fl_flags & FL_FLOCK) &&
2948             (rc == 0 || file_lock->fl_type == F_UNLCK))
2949                 rc2  = flock_lock_file_wait(file, file_lock);
2950         if ((file_lock->fl_flags & FL_POSIX) &&
2951             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2952             !(flags & LDLM_FL_TEST_LOCK))
2953                 rc2  = posix_lock_file_wait(file, file_lock);
2954
2955         if (rc2 && file_lock->fl_type != F_UNLCK) {
2956                 einfo.ei_mode = LCK_NL;
2957                 md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2958                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2959                 rc = rc2;
2960         }
2961
2962         ll_finish_md_op_data(op_data);
2963
2964         RETURN(rc);
2965 }
2966
2967 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2968 {
2969         ENTRY;
2970
2971         RETURN(-ENOSYS);
2972 }
2973
2974 /**
2975  * test if some locks matching bits and l_req_mode are acquired
2976  * - bits can be in different locks
2977  * - if found clear the common lock bits in *bits
2978  * - the bits not found, are kept in *bits
2979  * \param inode [IN]
2980  * \param bits [IN] searched lock bits [IN]
2981  * \param l_req_mode [IN] searched lock mode
2982  * \retval boolean, true iff all bits are found
2983  */
2984 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
2985 {
2986         struct lustre_handle lockh;
2987         ldlm_policy_data_t policy;
2988         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2989                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2990         struct lu_fid *fid;
2991         __u64 flags;
2992         int i;
2993         ENTRY;
2994
2995         if (!inode)
2996                RETURN(0);
2997
2998         fid = &ll_i2info(inode)->lli_fid;
2999         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3000                ldlm_lockname[mode]);
3001
3002         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3003         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3004                 policy.l_inodebits.bits = *bits & (1 << i);
3005                 if (policy.l_inodebits.bits == 0)
3006                         continue;
3007
3008                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3009                                   &policy, mode, &lockh)) {
3010                         struct ldlm_lock *lock;
3011
3012                         lock = ldlm_handle2lock(&lockh);
3013                         if (lock) {
3014                                 *bits &=
3015                                       ~(lock->l_policy_data.l_inodebits.bits);
3016                                 LDLM_LOCK_PUT(lock);
3017                         } else {
3018                                 *bits &= ~policy.l_inodebits.bits;
3019                         }
3020                 }
3021         }
3022         RETURN(*bits == 0);
3023 }
3024
3025 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
3026                             struct lustre_handle *lockh, __u64 flags,
3027                             ldlm_mode_t mode)
3028 {
3029         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
3030         struct lu_fid *fid;
3031         ldlm_mode_t rc;
3032         ENTRY;
3033
3034         fid = &ll_i2info(inode)->lli_fid;
3035         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3036
3037         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3038                            fid, LDLM_IBITS, &policy, mode, lockh);
3039
3040         RETURN(rc);
3041 }
3042
3043 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3044 {
3045         /* Already unlinked. Just update nlink and return success */
3046         if (rc == -ENOENT) {
3047                 clear_nlink(inode);
3048                 /* This path cannot be hit for regular files unless in
3049                  * case of obscure races, so no need to to validate
3050                  * size. */
3051                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3052                         return 0;
3053         } else if (rc != 0) {
3054                 CERROR("%s: revalidate FID "DFID" error: rc = %d\n",
3055                        ll_get_fsname(inode->i_sb, NULL, 0),
3056                        PFID(ll_inode2fid(inode)), rc);
3057         }
3058
3059         return rc;
3060 }
3061
3062 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
3063                              __u64 ibits)
3064 {
3065         struct inode *inode = dentry->d_inode;
3066         struct ptlrpc_request *req = NULL;
3067         struct obd_export *exp;
3068         int rc = 0;
3069         ENTRY;
3070
3071         LASSERT(inode != NULL);
3072
3073         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
3074                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
3075
3076         exp = ll_i2mdexp(inode);
3077
3078         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3079          *      But under CMD case, it caused some lock issues, should be fixed
3080          *      with new CMD ibits lock. See bug 12718 */
3081         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3082                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3083                 struct md_op_data *op_data;
3084
3085                 if (ibits == MDS_INODELOCK_LOOKUP)
3086                         oit.it_op = IT_LOOKUP;
3087
3088                 /* Call getattr by fid, so do not provide name at all. */
3089                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
3090                                              dentry->d_inode, NULL, 0, 0,
3091                                              LUSTRE_OPC_ANY, NULL);
3092                 if (IS_ERR(op_data))
3093                         RETURN(PTR_ERR(op_data));
3094
3095                 oit.it_create_mode |= M_CHECK_STALE;
3096                 rc = md_intent_lock(exp, op_data, NULL, 0,
3097                                     /* we are not interested in name
3098                                        based lookup */
3099                                     &oit, 0, &req,
3100                                     ll_md_blocking_ast, 0);
3101                 ll_finish_md_op_data(op_data);
3102                 oit.it_create_mode &= ~M_CHECK_STALE;
3103                 if (rc < 0) {
3104                         rc = ll_inode_revalidate_fini(inode, rc);
3105                         GOTO (out, rc);
3106                 }
3107
3108                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3109                 if (rc != 0) {
3110                         ll_intent_release(&oit);
3111                         GOTO(out, rc);
3112                 }
3113
3114                 /* Unlinked? Unhash dentry, so it is not picked up later by
3115                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3116                    here to preserve get_cwd functionality on 2.6.
3117                    Bug 10503 */
3118                 if (!dentry->d_inode->i_nlink)
3119                         d_lustre_invalidate(dentry, 0);
3120
3121                 ll_lookup_finish_locks(&oit, dentry);
3122         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3123                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3124                 obd_valid valid = OBD_MD_FLGETATTR;
3125                 struct md_op_data *op_data;
3126                 int ealen = 0;
3127
3128                 if (S_ISREG(inode->i_mode)) {
3129                         rc = ll_get_max_mdsize(sbi, &ealen);
3130                         if (rc)
3131                                 RETURN(rc);
3132                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3133                 }
3134
3135                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3136                                              0, ealen, LUSTRE_OPC_ANY,
3137                                              NULL);
3138                 if (IS_ERR(op_data))
3139                         RETURN(PTR_ERR(op_data));
3140
3141                 op_data->op_valid = valid;
3142                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
3143                  * capa for this inode. Because we only keep capas of dirs
3144                  * fresh. */
3145                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3146                 ll_finish_md_op_data(op_data);
3147                 if (rc) {
3148                         rc = ll_inode_revalidate_fini(inode, rc);
3149                         RETURN(rc);
3150                 }
3151
3152                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3153         }
3154 out:
3155         ptlrpc_req_finished(req);
3156         return rc;
3157 }
3158
3159 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
3160                            __u64 ibits)
3161 {
3162         struct inode    *inode = dentry->d_inode;
3163         int              rc;
3164         ENTRY;
3165
3166         rc = __ll_inode_revalidate_it(dentry, it, ibits);
3167         if (rc != 0)
3168                 RETURN(rc);
3169
3170         /* if object isn't regular file, don't validate size */
3171         if (!S_ISREG(inode->i_mode)) {
3172                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
3173                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
3174                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
3175         } else {
3176                 /* In case of restore, the MDT has the right size and has
3177                  * already send it back without granting the layout lock,
3178                  * inode is up-to-date so glimpse is useless.
3179                  * Also to glimpse we need the layout, in case of a running
3180                  * restore the MDT holds the layout lock so the glimpse will
3181                  * block up to the end of restore (getattr will block)
3182                  */
3183                 if (!(ll_i2info(inode)->lli_flags & LLIF_FILE_RESTORING))
3184                         rc = ll_glimpse_size(inode);
3185         }
3186         RETURN(rc);
3187 }
3188
3189 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
3190                   struct lookup_intent *it, struct kstat *stat)
3191 {
3192         struct inode *inode = de->d_inode;
3193         struct ll_sb_info *sbi = ll_i2sbi(inode);
3194         struct ll_inode_info *lli = ll_i2info(inode);
3195         int res = 0;
3196
3197         res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE |
3198                                              MDS_INODELOCK_LOOKUP);
3199         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
3200
3201         if (res)
3202                 return res;
3203
3204         stat->dev = inode->i_sb->s_dev;
3205         if (ll_need_32bit_api(sbi))
3206                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
3207         else
3208                 stat->ino = inode->i_ino;
3209         stat->mode = inode->i_mode;
3210         stat->nlink = inode->i_nlink;
3211         stat->uid = inode->i_uid;
3212         stat->gid = inode->i_gid;
3213         stat->rdev = inode->i_rdev;
3214         stat->atime = inode->i_atime;
3215         stat->mtime = inode->i_mtime;
3216         stat->ctime = inode->i_ctime;
3217         stat->blksize = 1 << inode->i_blkbits;
3218
3219         stat->size = i_size_read(inode);
3220         stat->blocks = inode->i_blocks;
3221
3222         return 0;
3223 }
3224 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
3225 {
3226         struct lookup_intent it = { .it_op = IT_GETATTR };
3227
3228         return ll_getattr_it(mnt, de, &it, stat);
3229 }
3230
3231 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3232                 __u64 start, __u64 len)
3233 {
3234         int rc;
3235         size_t num_bytes;
3236         struct ll_user_fiemap *fiemap;
3237         unsigned int extent_count = fieinfo->fi_extents_max;
3238
3239         num_bytes = sizeof(*fiemap) + (extent_count *
3240                                        sizeof(struct ll_fiemap_extent));
3241         OBD_ALLOC_LARGE(fiemap, num_bytes);
3242
3243         if (fiemap == NULL)
3244                 RETURN(-ENOMEM);
3245
3246         fiemap->fm_flags = fieinfo->fi_flags;
3247         fiemap->fm_extent_count = fieinfo->fi_extents_max;
3248         fiemap->fm_start = start;
3249         fiemap->fm_length = len;
3250         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
3251                sizeof(struct ll_fiemap_extent));
3252
3253         rc = ll_do_fiemap(inode, fiemap, num_bytes);
3254
3255         fieinfo->fi_flags = fiemap->fm_flags;
3256         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
3257         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
3258                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
3259
3260         OBD_FREE_LARGE(fiemap, num_bytes);
3261         return rc;
3262 }
3263
3264 struct posix_acl * ll_get_acl(struct inode *inode, int type)
3265 {
3266         struct ll_inode_info *lli = ll_i2info(inode);
3267         struct posix_acl *acl = NULL;
3268         ENTRY;
3269
3270         spin_lock(&lli->lli_lock);
3271         /* VFS' acl_permission_check->check_acl will release the refcount */
3272         acl = posix_acl_dup(lli->lli_posix_acl);
3273         spin_unlock(&lli->lli_lock);
3274
3275         RETURN(acl);
3276 }
3277
3278 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
3279 static int
3280 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
3281 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
3282 # else
3283 ll_check_acl(struct inode *inode, int mask)
3284 # endif
3285 {
3286 # ifdef CONFIG_FS_POSIX_ACL
3287         struct posix_acl *acl;
3288         int rc;
3289         ENTRY;
3290
3291 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
3292         if (flags & IPERM_FLAG_RCU)
3293                 return -ECHILD;
3294 #  endif
3295         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
3296
3297         if (!acl)
3298                 RETURN(-EAGAIN);
3299
3300         rc = posix_acl_permission(inode, acl, mask);
3301         posix_acl_release(acl);
3302
3303         RETURN(rc);
3304 # else /* !CONFIG_FS_POSIX_ACL */
3305         return -EAGAIN;
3306 # endif /* CONFIG_FS_POSIX_ACL */
3307 }
3308 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
3309
3310 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
3311 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
3312 #else
3313 # ifdef HAVE_INODE_PERMISION_2ARGS
3314 int ll_inode_permission(struct inode *inode, int mask)
3315 # else
3316 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
3317 # endif
3318 #endif
3319 {
3320         int rc = 0;
3321         ENTRY;
3322
3323 #ifdef MAY_NOT_BLOCK
3324         if (mask & MAY_NOT_BLOCK)
3325                 return -ECHILD;
3326 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
3327         if (flags & IPERM_FLAG_RCU)
3328                 return -ECHILD;
3329 #endif
3330
3331        /* as root inode are NOT getting validated in lookup operation,
3332         * need to do it before permission check. */
3333
3334         if (inode == inode->i_sb->s_root->d_inode) {
3335                 struct lookup_intent it = { .it_op = IT_LOOKUP };
3336
3337                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
3338                                               MDS_INODELOCK_LOOKUP);
3339                 if (rc)
3340                         RETURN(rc);
3341         }
3342
3343         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
3344                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
3345
3346         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
3347                 return lustre_check_remote_perm(inode, mask);
3348
3349         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
3350         rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3351
3352         RETURN(rc);
3353 }
3354
3355 /* -o localflock - only provides locally consistent flock locks */
3356 struct file_operations ll_file_operations = {
3357         .read           = ll_file_read,
3358         .aio_read    = ll_file_aio_read,
3359         .write          = ll_file_write,
3360         .aio_write   = ll_file_aio_write,
3361         .unlocked_ioctl = ll_file_ioctl,
3362         .open           = ll_file_open,
3363         .release        = ll_file_release,
3364         .mmap           = ll_file_mmap,
3365         .llseek         = ll_file_seek,
3366         .splice_read    = ll_file_splice_read,
3367         .fsync          = ll_fsync,
3368         .flush          = ll_flush
3369 };
3370
3371 struct file_operations ll_file_operations_flock = {
3372         .read           = ll_file_read,
3373         .aio_read    = ll_file_aio_read,
3374         .write          = ll_file_write,
3375         .aio_write   = ll_file_aio_write,
3376         .unlocked_ioctl = ll_file_ioctl,
3377         .open           = ll_file_open,
3378         .release        = ll_file_release,
3379         .mmap           = ll_file_mmap,
3380         .llseek         = ll_file_seek,
3381         .splice_read    = ll_file_splice_read,
3382         .fsync          = ll_fsync,
3383         .flush          = ll_flush,
3384         .flock          = ll_file_flock,
3385         .lock           = ll_file_flock
3386 };
3387
3388 /* These are for -o noflock - to return ENOSYS on flock calls */
3389 struct file_operations ll_file_operations_noflock = {
3390         .read           = ll_file_read,
3391         .aio_read    = ll_file_aio_read,
3392         .write          = ll_file_write,
3393         .aio_write   = ll_file_aio_write,
3394         .unlocked_ioctl = ll_file_ioctl,
3395         .open           = ll_file_open,
3396         .release        = ll_file_release,
3397         .mmap           = ll_file_mmap,
3398         .llseek         = ll_file_seek,
3399         .splice_read    = ll_file_splice_read,
3400         .fsync          = ll_fsync,
3401         .flush          = ll_flush,
3402         .flock          = ll_file_noflock,
3403         .lock           = ll_file_noflock
3404 };
3405
3406 struct inode_operations ll_file_inode_operations = {
3407         .setattr        = ll_setattr,
3408         .getattr        = ll_getattr,
3409         .permission     = ll_inode_permission,
3410         .setxattr       = ll_setxattr,
3411         .getxattr       = ll_getxattr,
3412         .listxattr      = ll_listxattr,
3413         .removexattr    = ll_removexattr,
3414         .fiemap         = ll_fiemap,
3415 #ifdef HAVE_IOP_GET_ACL
3416         .get_acl        = ll_get_acl,
3417 #endif
3418 };
3419
3420 /* dynamic ioctl number support routins */
3421 static struct llioc_ctl_data {
3422         struct rw_semaphore     ioc_sem;
3423         cfs_list_t              ioc_head;
3424 } llioc = {
3425         __RWSEM_INITIALIZER(llioc.ioc_sem),
3426         CFS_LIST_HEAD_INIT(llioc.ioc_head)
3427 };
3428
3429
3430 struct llioc_data {
3431         cfs_list_t              iocd_list;
3432         unsigned int            iocd_size;
3433         llioc_callback_t        iocd_cb;
3434         unsigned int            iocd_count;
3435         unsigned int            iocd_cmd[0];
3436 };
3437
3438 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3439 {
3440         unsigned int size;
3441         struct llioc_data *in_data = NULL;
3442         ENTRY;
3443
3444         if (cb == NULL || cmd == NULL ||
3445             count > LLIOC_MAX_CMD || count < 0)
3446                 RETURN(NULL);
3447
3448         size = sizeof(*in_data) + count * sizeof(unsigned int);
3449         OBD_ALLOC(in_data, size);
3450         if (in_data == NULL)
3451                 RETURN(NULL);
3452
3453         memset(in_data, 0, sizeof(*in_data));
3454         in_data->iocd_size = size;
3455         in_data->iocd_cb = cb;
3456         in_data->iocd_count = count;
3457         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3458
3459         down_write(&llioc.ioc_sem);
3460         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3461         up_write(&llioc.ioc_sem);
3462
3463         RETURN(in_data);
3464 }
3465
3466 void ll_iocontrol_unregister(void *magic)
3467 {
3468         struct llioc_data *tmp;
3469
3470         if (magic == NULL)
3471                 return;
3472
3473         down_write(&llioc.ioc_sem);
3474         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3475                 if (tmp == magic) {
3476                         unsigned int size = tmp->iocd_size;
3477
3478                         cfs_list_del(&tmp->iocd_list);
3479                         up_write(&llioc.ioc_sem);
3480
3481                         OBD_FREE(tmp, size);
3482                         return;
3483                 }
3484         }
3485         up_write(&llioc.ioc_sem);
3486
3487         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3488 }
3489
3490 EXPORT_SYMBOL(ll_iocontrol_register);
3491 EXPORT_SYMBOL(ll_iocontrol_unregister);
3492
3493 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
3494                         unsigned int cmd, unsigned long arg, int *rcp)
3495 {
3496         enum llioc_iter ret = LLIOC_CONT;
3497         struct llioc_data *data;
3498         int rc = -EINVAL, i;
3499
3500         down_read(&llioc.ioc_sem);
3501         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3502                 for (i = 0; i < data->iocd_count; i++) {
3503                         if (cmd != data->iocd_cmd[i])
3504                                 continue;
3505
3506                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3507                         break;
3508                 }
3509
3510                 if (ret == LLIOC_STOP)
3511                         break;
3512         }
3513         up_read(&llioc.ioc_sem);
3514
3515         if (rcp)
3516                 *rcp = rc;
3517         return ret;
3518 }
3519
3520 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3521 {
3522         struct ll_inode_info *lli = ll_i2info(inode);
3523         struct cl_env_nest nest;
3524         struct lu_env *env;
3525         int result;
3526         ENTRY;
3527
3528         if (lli->lli_clob == NULL)
3529                 RETURN(0);
3530
3531         env = cl_env_nested_get(&nest);
3532         if (IS_ERR(env))
3533                 RETURN(PTR_ERR(env));
3534
3535         result = cl_conf_set(env, lli->lli_clob, conf);
3536         cl_env_nested_put(&nest, env);
3537
3538         if (conf->coc_opc == OBJECT_CONF_SET) {
3539                 struct ldlm_lock *lock = conf->coc_lock;
3540
3541                 LASSERT(lock != NULL);
3542                 LASSERT(ldlm_has_layout(lock));
3543                 if (result == 0) {
3544                         /* it can only be allowed to match after layout is
3545                          * applied to inode otherwise false layout would be
3546                          * seen. Applying layout shoud happen before dropping
3547                          * the intent lock. */
3548                         ldlm_lock_allow_match(lock);
3549                 }
3550         }
3551         RETURN(result);
3552 }
3553
3554 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3555 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3556
3557 {
3558         struct ll_sb_info *sbi = ll_i2sbi(inode);
3559         struct obd_capa *oc;
3560         struct ptlrpc_request *req;
3561         struct mdt_body *body;
3562         void *lvbdata;
3563         void *lmm;
3564         int lmmsize;
3565         int rc;
3566         ENTRY;
3567
3568         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
3569                PFID(ll_inode2fid(inode)), !!(lock->l_flags & LDLM_FL_LVB_READY),
3570                lock->l_lvb_data, lock->l_lvb_len);
3571
3572         if ((lock->l_lvb_data != NULL) && (lock->l_flags & LDLM_FL_LVB_READY))
3573                 RETURN(0);
3574
3575         /* if layout lock was granted right away, the layout is returned
3576          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3577          * blocked and then granted via completion ast, we have to fetch
3578          * layout here. Please note that we can't use the LVB buffer in
3579          * completion AST because it doesn't have a large enough buffer */
3580         oc = ll_mdscapa_get(inode);
3581         rc = ll_get_max_mdsize(sbi, &lmmsize);
3582         if (rc == 0)
3583                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
3584                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3585                                 lmmsize, 0, &req);
3586         capa_put(oc);
3587         if (rc < 0)
3588                 RETURN(rc);
3589
3590         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3591         if (body == NULL || body->eadatasize > lmmsize)
3592                 GOTO(out, rc = -EPROTO);
3593
3594         lmmsize = body->eadatasize;
3595         if (lmmsize == 0) /* empty layout */
3596                 GOTO(out, rc = 0);
3597
3598         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3599         if (lmm == NULL)
3600                 GOTO(out, rc = -EFAULT);
3601
3602         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3603         if (lvbdata == NULL)
3604                 GOTO(out, rc = -ENOMEM);
3605
3606         memcpy(lvbdata, lmm, lmmsize);
3607         lock_res_and_lock(lock);
3608         if (lock->l_lvb_data != NULL)
3609                 OBD_FREE_LARGE(lock->l_lvb_data, lock->l_lvb_len);
3610
3611         lock->l_lvb_data = lvbdata;
3612         lock->l_lvb_len = lmmsize;
3613         unlock_res_and_lock(lock);
3614
3615         EXIT;
3616
3617 out:
3618         ptlrpc_req_finished(req);
3619         return rc;
3620 }
3621
3622 /**
3623  * Apply the layout to the inode. Layout lock is held and will be released
3624  * in this function.
3625  */
3626 static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
3627                                 struct inode *inode, __u32 *gen, bool reconf)
3628 {
3629         struct ll_inode_info *lli = ll_i2info(inode);
3630         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3631         struct ldlm_lock *lock;
3632         struct lustre_md md = { NULL };
3633         struct cl_object_conf conf;
3634         int rc = 0;
3635         bool lvb_ready;
3636         bool wait_layout = false;
3637         ENTRY;
3638
3639         LASSERT(lustre_handle_is_used(lockh));
3640
3641         lock = ldlm_handle2lock(lockh);
3642         LASSERT(lock != NULL);
3643         LASSERT(ldlm_has_layout(lock));
3644
3645         LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n",
3646                    inode, PFID(&lli->lli_fid), reconf);
3647
3648         /* in case this is a caching lock and reinstate with new inode */
3649         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3650
3651         lock_res_and_lock(lock);
3652         lvb_ready = !!(lock->l_flags & LDLM_FL_LVB_READY);
3653         unlock_res_and_lock(lock);
3654         /* checking lvb_ready is racy but this is okay. The worst case is
3655          * that multi processes may configure the file on the same time. */
3656
3657         if (lvb_ready || !reconf) {
3658                 rc = -ENODATA;
3659                 if (lvb_ready) {
3660                         /* layout_gen must be valid if layout lock is not
3661                          * cancelled and stripe has already set */
3662                         *gen = lli->lli_layout_gen;
3663                         rc = 0;
3664                 }
3665                 GOTO(out, rc);
3666         }
3667
3668         rc = ll_layout_fetch(inode, lock);
3669         if (rc < 0)
3670                 GOTO(out, rc);
3671
3672         /* for layout lock, lmm is returned in lock's lvb.
3673          * lvb_data is immutable if the lock is held so it's safe to access it
3674          * without res lock. See the description in ldlm_lock_decref_internal()
3675          * for the condition to free lvb_data of layout lock */
3676         if (lock->l_lvb_data != NULL) {
3677                 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
3678                                   lock->l_lvb_data, lock->l_lvb_len);
3679                 if (rc >= 0) {
3680                         *gen = LL_LAYOUT_GEN_EMPTY;
3681                         if (md.lsm != NULL)
3682                                 *gen = md.lsm->lsm_layout_gen;
3683                         rc = 0;
3684                 } else {
3685                         CERROR("%s: file "DFID" unpackmd error: %d\n",
3686                                 ll_get_fsname(inode->i_sb, NULL, 0),
3687                                 PFID(&lli->lli_fid), rc);
3688                 }
3689         }
3690         if (rc < 0)
3691                 GOTO(out, rc);
3692
3693         /* set layout to file. Unlikely this will fail as old layout was
3694          * surely eliminated */
3695         memset(&conf, 0, sizeof conf);
3696         conf.coc_opc = OBJECT_CONF_SET;
3697         conf.coc_inode = inode;
3698         conf.coc_lock = lock;
3699         conf.u.coc_md = &md;
3700         rc = ll_layout_conf(inode, &conf);
3701
3702         if (md.lsm != NULL)
3703                 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3704
3705         /* refresh layout failed, need to wait */
3706         wait_layout = rc == -EBUSY;
3707         EXIT;
3708
3709 out:
3710         LDLM_LOCK_PUT(lock);
3711         ldlm_lock_decref(lockh, mode);
3712
3713         /* wait for IO to complete if it's still being used. */
3714         if (wait_layout) {
3715                 CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n",
3716                         ll_get_fsname(inode->i_sb, NULL, 0),
3717                         inode, PFID(&lli->lli_fid));
3718
3719                 memset(&conf, 0, sizeof conf);
3720                 conf.coc_opc = OBJECT_CONF_WAIT;
3721                 conf.coc_inode = inode;
3722                 rc = ll_layout_conf(inode, &conf);
3723                 if (rc == 0)
3724                         rc = -EAGAIN;
3725
3726                 CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n",
3727                         PFID(&lli->lli_fid), rc);
3728         }
3729         RETURN(rc);
3730 }
3731
3732 /**
3733  * This function checks if there exists a LAYOUT lock on the client side,
3734  * or enqueues it if it doesn't have one in cache.
3735  *
3736  * This function will not hold layout lock so it may be revoked any time after
3737  * this function returns. Any operations depend on layout should be redone
3738  * in that case.
3739  *
3740  * This function should be called before lov_io_init() to get an uptodate
3741  * layout version, the caller should save the version number and after IO
3742  * is finished, this function should be called again to verify that layout
3743  * is not changed during IO time.
3744  */
3745 int ll_layout_refresh(struct inode *inode, __u32 *gen)
3746 {
3747         struct ll_inode_info  *lli = ll_i2info(inode);
3748         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3749         struct md_op_data     *op_data;
3750         struct lookup_intent   it;
3751         struct lustre_handle   lockh;
3752         ldlm_mode_t            mode;
3753         struct ldlm_enqueue_info einfo = {
3754                 .ei_type = LDLM_IBITS,
3755                 .ei_mode = LCK_CR,
3756                 .ei_cb_bl = ll_md_blocking_ast,
3757                 .ei_cb_cp = ldlm_completion_ast,
3758         };
3759         int rc;
3760         ENTRY;
3761
3762         *gen = lli->lli_layout_gen;
3763         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK))
3764                 RETURN(0);
3765
3766         /* sanity checks */
3767         LASSERT(fid_is_sane(ll_inode2fid(inode)));
3768         LASSERT(S_ISREG(inode->i_mode));
3769
3770         /* mostly layout lock is caching on the local side, so try to match
3771          * it before grabbing layout lock mutex. */
3772         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
3773                                LCK_CR | LCK_CW | LCK_PR | LCK_PW);
3774         if (mode != 0) { /* hit cached lock */
3775                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, false);
3776                 if (rc == 0)
3777                         RETURN(0);
3778
3779                 /* better hold lli_layout_mutex to try again otherwise
3780                  * it will have starvation problem. */
3781         }
3782
3783         /* take layout lock mutex to enqueue layout lock exclusively. */
3784         mutex_lock(&lli->lli_layout_mutex);
3785
3786 again:
3787         /* try again. Maybe somebody else has done this. */
3788         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
3789                                LCK_CR | LCK_CW | LCK_PR | LCK_PW);
3790         if (mode != 0) { /* hit cached lock */
3791                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3792                 if (rc == -EAGAIN)
3793                         goto again;
3794
3795                 mutex_unlock(&lli->lli_layout_mutex);
3796                 RETURN(rc);
3797         }
3798
3799         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3800                         0, 0, LUSTRE_OPC_ANY, NULL);
3801         if (IS_ERR(op_data)) {
3802                 mutex_unlock(&lli->lli_layout_mutex);
3803                 RETURN(PTR_ERR(op_data));
3804         }
3805
3806         /* have to enqueue one */
3807         memset(&it, 0, sizeof(it));
3808         it.it_op = IT_LAYOUT;
3809         lockh.cookie = 0ULL;
3810
3811         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n",
3812                         ll_get_fsname(inode->i_sb, NULL, 0), inode,
3813                         PFID(&lli->lli_fid));
3814
3815         rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
3816                         NULL, 0, NULL, 0);
3817         if (it.d.lustre.it_data != NULL)
3818                 ptlrpc_req_finished(it.d.lustre.it_data);
3819         it.d.lustre.it_data = NULL;
3820
3821         ll_finish_md_op_data(op_data);
3822
3823         mode = it.d.lustre.it_lock_mode;
3824         it.d.lustre.it_lock_mode = 0;
3825         ll_intent_drop_lock(&it);
3826
3827         if (rc == 0) {
3828                 /* set lock data in case this is a new lock */
3829                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
3830                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3831                 if (rc == -EAGAIN)
3832                         goto again;
3833         }
3834         mutex_unlock(&lli->lli_layout_mutex);
3835
3836         RETURN(rc);
3837 }
3838
3839 /**
3840  *  This function send a restore request to the MDT
3841  */
3842 int ll_layout_restore(struct inode *inode)
3843 {
3844         struct hsm_user_request *hur;
3845         int                      len, rc;
3846         ENTRY;
3847
3848         len = sizeof(struct hsm_user_request) +
3849               sizeof(struct hsm_user_item);
3850         OBD_ALLOC(hur, len);
3851         if (hur == NULL)
3852                 RETURN(-ENOMEM);
3853
3854         hur->hur_request.hr_action = HUA_RESTORE;
3855         hur->hur_request.hr_archive_id = 0;
3856         hur->hur_request.hr_flags = 0;
3857         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
3858                sizeof(hur->hur_user_item[0].hui_fid));
3859         hur->hur_user_item[0].hui_extent.length = -1;
3860         hur->hur_request.hr_itemcount = 1;
3861         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, cl_i2sbi(inode)->ll_md_exp,
3862                            len, hur, NULL);
3863         OBD_FREE(hur, len);
3864         RETURN(rc);
3865 }
3866