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