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, CFS_ALLOC_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 == NULL)
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                 /* if function called for directory - we should
1438                  * avoid swab not existent lsm objects */
1439                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1440                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1441                         if (S_ISREG(body->mode))
1442                                 lustre_swab_lov_user_md_objects(
1443                                  ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1444                                  ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count);
1445                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1446                         lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1447                         if (S_ISREG(body->mode))
1448                                 lustre_swab_lov_user_md_objects(
1449                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1450                                  ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count);
1451                 }
1452         }
1453
1454 out:
1455         *lmmp = lmm;
1456         *lmm_size = lmmsize;
1457         *request = req;
1458         return rc;
1459 }
1460
1461 static int ll_lov_setea(struct inode *inode, struct file *file,
1462                             unsigned long arg)
1463 {
1464         int                      flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1465         struct lov_user_md      *lump;
1466         int                      lum_size = sizeof(struct lov_user_md) +
1467                                             sizeof(struct lov_user_ost_data);
1468         int                      rc;
1469         ENTRY;
1470
1471         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1472                 RETURN(-EPERM);
1473
1474         OBD_ALLOC_LARGE(lump, lum_size);
1475         if (lump == NULL)
1476                 RETURN(-ENOMEM);
1477
1478         if (copy_from_user(lump, (struct lov_user_md  *)arg, lum_size)) {
1479                 OBD_FREE_LARGE(lump, lum_size);
1480                 RETURN(-EFAULT);
1481         }
1482
1483         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1484
1485         OBD_FREE_LARGE(lump, lum_size);
1486         RETURN(rc);
1487 }
1488
1489 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1490                             unsigned long arg)
1491 {
1492         struct lov_user_md_v3    lumv3;
1493         struct lov_user_md_v1   *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1494         struct lov_user_md_v1   *lumv1p = (struct lov_user_md_v1 *)arg;
1495         struct lov_user_md_v3   *lumv3p = (struct lov_user_md_v3 *)arg;
1496         int                      lum_size, rc;
1497         int                      flags = FMODE_WRITE;
1498         ENTRY;
1499
1500         /* first try with v1 which is smaller than v3 */
1501         lum_size = sizeof(struct lov_user_md_v1);
1502         if (copy_from_user(lumv1, lumv1p, lum_size))
1503                 RETURN(-EFAULT);
1504
1505         if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1506                 lum_size = sizeof(struct lov_user_md_v3);
1507                 if (copy_from_user(&lumv3, lumv3p, lum_size))
1508                         RETURN(-EFAULT);
1509         }
1510
1511         rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
1512         if (rc == 0) {
1513                 struct lov_stripe_md *lsm;
1514                 __u32 gen;
1515
1516                 put_user(0, &lumv1p->lmm_stripe_count);
1517
1518                 ll_layout_refresh(inode, &gen);
1519                 lsm = ccc_inode_lsm_get(inode);
1520                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1521                                    0, lsm, (void *)arg);
1522                 ccc_inode_lsm_put(inode, lsm);
1523         }
1524         RETURN(rc);
1525 }
1526
1527 static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1528 {
1529         struct lov_stripe_md *lsm;
1530         int rc = -ENODATA;
1531         ENTRY;
1532
1533         lsm = ccc_inode_lsm_get(inode);
1534         if (lsm != NULL)
1535                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0,
1536                                    lsm, (void *)arg);
1537         ccc_inode_lsm_put(inode, lsm);
1538         RETURN(rc);
1539 }
1540
1541 int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1542 {
1543         struct ll_inode_info   *lli = ll_i2info(inode);
1544         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1545         struct ccc_grouplock    grouplock;
1546         int                     rc;
1547         ENTRY;
1548
1549         if (ll_file_nolock(file))
1550                 RETURN(-EOPNOTSUPP);
1551
1552         spin_lock(&lli->lli_lock);
1553         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1554                 CWARN("group lock already existed with gid %lu\n",
1555                       fd->fd_grouplock.cg_gid);
1556                 spin_unlock(&lli->lli_lock);
1557                 RETURN(-EINVAL);
1558         }
1559         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1560         spin_unlock(&lli->lli_lock);
1561
1562         rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1563                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1564         if (rc)
1565                 RETURN(rc);
1566
1567         spin_lock(&lli->lli_lock);
1568         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1569                 spin_unlock(&lli->lli_lock);
1570                 CERROR("another thread just won the race\n");
1571                 cl_put_grouplock(&grouplock);
1572                 RETURN(-EINVAL);
1573         }
1574
1575         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1576         fd->fd_grouplock = grouplock;
1577         spin_unlock(&lli->lli_lock);
1578
1579         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1580         RETURN(0);
1581 }
1582
1583 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1584 {
1585         struct ll_inode_info   *lli = ll_i2info(inode);
1586         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1587         struct ccc_grouplock    grouplock;
1588         ENTRY;
1589
1590         spin_lock(&lli->lli_lock);
1591         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1592                 spin_unlock(&lli->lli_lock);
1593                 CWARN("no group lock held\n");
1594                 RETURN(-EINVAL);
1595         }
1596         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1597
1598         if (fd->fd_grouplock.cg_gid != arg) {
1599                 CWARN("group lock %lu doesn't match current id %lu\n",
1600                        arg, fd->fd_grouplock.cg_gid);
1601                 spin_unlock(&lli->lli_lock);
1602                 RETURN(-EINVAL);
1603         }
1604
1605         grouplock = fd->fd_grouplock;
1606         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1607         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1608         spin_unlock(&lli->lli_lock);
1609
1610         cl_put_grouplock(&grouplock);
1611         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1612         RETURN(0);
1613 }
1614
1615 /**
1616  * Close inode open handle
1617  *
1618  * \param dentry [in]     dentry which contains the inode
1619  * \param it     [in,out] intent which contains open info and result
1620  *
1621  * \retval 0     success
1622  * \retval <0    failure
1623  */
1624 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1625 {
1626         struct inode *inode = dentry->d_inode;
1627         struct obd_client_handle *och;
1628         int rc;
1629         ENTRY;
1630
1631         LASSERT(inode);
1632
1633         /* Root ? Do nothing. */
1634         if (dentry->d_inode->i_sb->s_root == dentry)
1635                 RETURN(0);
1636
1637         /* No open handle to close? Move away */
1638         if (!it_disposition(it, DISP_OPEN_OPEN))
1639                 RETURN(0);
1640
1641         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1642
1643         OBD_ALLOC(och, sizeof(*och));
1644         if (!och)
1645                 GOTO(out, rc = -ENOMEM);
1646
1647         ll_och_fill(ll_i2sbi(inode)->ll_md_exp,
1648                     ll_i2info(inode), it, och);
1649
1650         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1651                                        inode, och);
1652  out:
1653         /* this one is in place of ll_file_open */
1654         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1655                 ptlrpc_req_finished(it->d.lustre.it_data);
1656                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1657         }
1658         RETURN(rc);
1659 }
1660
1661 /**
1662  * Get size for inode for which FIEMAP mapping is requested.
1663  * Make the FIEMAP get_info call and returns the result.
1664  */
1665 int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1666               int num_bytes)
1667 {
1668         struct obd_export *exp = ll_i2dtexp(inode);
1669         struct lov_stripe_md *lsm = NULL;
1670         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1671         int vallen = num_bytes;
1672         int rc;
1673         ENTRY;
1674
1675         /* Checks for fiemap flags */
1676         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1677                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1678                 return -EBADR;
1679         }
1680
1681         /* Check for FIEMAP_FLAG_SYNC */
1682         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1683                 rc = filemap_fdatawrite(inode->i_mapping);
1684                 if (rc)
1685                         return rc;
1686         }
1687
1688         lsm = ccc_inode_lsm_get(inode);
1689         if (lsm == NULL)
1690                 return -ENOENT;
1691
1692         /* If the stripe_count > 1 and the application does not understand
1693          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1694          */
1695         if (lsm->lsm_stripe_count > 1 &&
1696             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1697                 GOTO(out, rc = -EOPNOTSUPP);
1698
1699         fm_key.oa.o_oi = lsm->lsm_oi;
1700         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1701
1702         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1703         obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1704         /* If filesize is 0, then there would be no objects for mapping */
1705         if (fm_key.oa.o_size == 0) {
1706                 fiemap->fm_mapped_extents = 0;
1707                 GOTO(out, rc = 0);
1708         }
1709
1710         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1711
1712         rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1713                           fiemap, lsm);
1714         if (rc)
1715                 CERROR("obd_get_info failed: rc = %d\n", rc);
1716
1717 out:
1718         ccc_inode_lsm_put(inode, lsm);
1719         RETURN(rc);
1720 }
1721
1722 int ll_fid2path(struct inode *inode, void *arg)
1723 {
1724         struct obd_export       *exp = ll_i2mdexp(inode);
1725         struct getinfo_fid2path *gfout, *gfin;
1726         int                      outsize, rc;
1727         ENTRY;
1728
1729         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1730             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1731                 RETURN(-EPERM);
1732
1733         /* Need to get the buflen */
1734         OBD_ALLOC_PTR(gfin);
1735         if (gfin == NULL)
1736                 RETURN(-ENOMEM);
1737         if (copy_from_user(gfin, arg, sizeof(*gfin))) {
1738                 OBD_FREE_PTR(gfin);
1739                 RETURN(-EFAULT);
1740         }
1741
1742         outsize = sizeof(*gfout) + gfin->gf_pathlen;
1743         OBD_ALLOC(gfout, outsize);
1744         if (gfout == NULL) {
1745                 OBD_FREE_PTR(gfin);
1746                 RETURN(-ENOMEM);
1747         }
1748         memcpy(gfout, gfin, sizeof(*gfout));
1749         OBD_FREE_PTR(gfin);
1750
1751         /* Call mdc_iocontrol */
1752         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1753         if (rc)
1754                 GOTO(gf_free, rc);
1755
1756         if (copy_to_user(arg, gfout, outsize))
1757                 rc = -EFAULT;
1758
1759 gf_free:
1760         OBD_FREE(gfout, outsize);
1761         RETURN(rc);
1762 }
1763
1764 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1765 {
1766         struct ll_user_fiemap *fiemap_s;
1767         size_t num_bytes, ret_bytes;
1768         unsigned int extent_count;
1769         int rc = 0;
1770
1771         /* Get the extent count so we can calculate the size of
1772          * required fiemap buffer */
1773         if (get_user(extent_count,
1774             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1775                 RETURN(-EFAULT);
1776         num_bytes = sizeof(*fiemap_s) + (extent_count *
1777                                          sizeof(struct ll_fiemap_extent));
1778
1779         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1780         if (fiemap_s == NULL)
1781                 RETURN(-ENOMEM);
1782
1783         /* get the fiemap value */
1784         if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1785                            sizeof(*fiemap_s)))
1786                 GOTO(error, rc = -EFAULT);
1787
1788         /* If fm_extent_count is non-zero, read the first extent since
1789          * it is used to calculate end_offset and device from previous
1790          * fiemap call. */
1791         if (extent_count) {
1792                 if (copy_from_user(&fiemap_s->fm_extents[0],
1793                     (char __user *)arg + sizeof(*fiemap_s),
1794                     sizeof(struct ll_fiemap_extent)))
1795                         GOTO(error, rc = -EFAULT);
1796         }
1797
1798         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1799         if (rc)
1800                 GOTO(error, rc);
1801
1802         ret_bytes = sizeof(struct ll_user_fiemap);
1803
1804         if (extent_count != 0)
1805                 ret_bytes += (fiemap_s->fm_mapped_extents *
1806                                  sizeof(struct ll_fiemap_extent));
1807
1808         if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
1809                 rc = -EFAULT;
1810
1811 error:
1812         OBD_FREE_LARGE(fiemap_s, num_bytes);
1813         RETURN(rc);
1814 }
1815
1816 /*
1817  * Read the data_version for inode.
1818  *
1819  * This value is computed using stripe object version on OST.
1820  * Version is computed using server side locking.
1821  *
1822  * @param extent_lock  Take extent lock. Not needed if a process is already
1823  *                     holding the OST object group locks.
1824  */
1825 int ll_data_version(struct inode *inode, __u64 *data_version,
1826                     int extent_lock)
1827 {
1828         struct lov_stripe_md    *lsm = NULL;
1829         struct ll_sb_info       *sbi = ll_i2sbi(inode);
1830         struct obdo             *obdo = NULL;
1831         int                      rc;
1832         ENTRY;
1833
1834         /* If no stripe, we consider version is 0. */
1835         lsm = ccc_inode_lsm_get(inode);
1836         if (lsm == NULL) {
1837                 *data_version = 0;
1838                 CDEBUG(D_INODE, "No object for inode\n");
1839                 RETURN(0);
1840         }
1841
1842         OBD_ALLOC_PTR(obdo);
1843         if (obdo == NULL) {
1844                 ccc_inode_lsm_put(inode, lsm);
1845                 RETURN(-ENOMEM);
1846         }
1847
1848         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock);
1849         if (!rc) {
1850                 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1851                         rc = -EOPNOTSUPP;
1852                 else
1853                         *data_version = obdo->o_data_version;
1854         }
1855
1856         OBD_FREE_PTR(obdo);
1857         ccc_inode_lsm_put(inode, lsm);
1858
1859         RETURN(rc);
1860 }
1861
1862 struct ll_swap_stack {
1863         struct iattr             ia1, ia2;
1864         __u64                    dv1, dv2;
1865         struct inode            *inode1, *inode2;
1866         bool                     check_dv1, check_dv2;
1867 };
1868
1869 static int ll_swap_layouts(struct file *file1, struct file *file2,
1870                            struct lustre_swap_layouts *lsl)
1871 {
1872         struct mdc_swap_layouts  msl;
1873         struct md_op_data       *op_data;
1874         __u32                    gid;
1875         __u64                    dv;
1876         struct ll_swap_stack    *llss = NULL;
1877         int                      rc;
1878
1879         OBD_ALLOC_PTR(llss);
1880         if (llss == NULL)
1881                 RETURN(-ENOMEM);
1882
1883         llss->inode1 = file1->f_dentry->d_inode;
1884         llss->inode2 = file2->f_dentry->d_inode;
1885
1886         if (!S_ISREG(llss->inode2->i_mode))
1887                 GOTO(free, rc = -EINVAL);
1888
1889         if (ll_permission(llss->inode1, MAY_WRITE, NULL) ||
1890             ll_permission(llss->inode2, MAY_WRITE, NULL))
1891                 GOTO(free, rc = -EPERM);
1892
1893         if (llss->inode2->i_sb != llss->inode1->i_sb)
1894                 GOTO(free, rc = -EXDEV);
1895
1896         /* we use 2 bool because it is easier to swap than 2 bits */
1897         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
1898                 llss->check_dv1 = true;
1899
1900         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
1901                 llss->check_dv2 = true;
1902
1903         /* we cannot use lsl->sl_dvX directly because we may swap them */
1904         llss->dv1 = lsl->sl_dv1;
1905         llss->dv2 = lsl->sl_dv2;
1906
1907         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
1908         if (rc == 0) /* same file, done! */
1909                 GOTO(free, rc = 0);
1910
1911         if (rc < 0) { /* sequentialize it */
1912                 swap(llss->inode1, llss->inode2);
1913                 swap(file1, file2);
1914                 swap(llss->dv1, llss->dv2);
1915                 swap(llss->check_dv1, llss->check_dv2);
1916         }
1917
1918         gid = lsl->sl_gid;
1919         if (gid != 0) { /* application asks to flush dirty cache */
1920                 rc = ll_get_grouplock(llss->inode1, file1, gid);
1921                 if (rc < 0)
1922                         GOTO(free, rc);
1923
1924                 rc = ll_get_grouplock(llss->inode2, file2, gid);
1925                 if (rc < 0) {
1926                         ll_put_grouplock(llss->inode1, file1, gid);
1927                         GOTO(free, rc);
1928                 }
1929         }
1930
1931         /* to be able to restore mtime and atime after swap
1932          * we need to first save them */
1933         if (lsl->sl_flags &
1934             (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
1935                 llss->ia1.ia_mtime = llss->inode1->i_mtime;
1936                 llss->ia1.ia_atime = llss->inode1->i_atime;
1937                 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
1938                 llss->ia2.ia_mtime = llss->inode2->i_mtime;
1939                 llss->ia2.ia_atime = llss->inode2->i_atime;
1940                 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
1941         }
1942
1943         /* ultimate check, before swaping the layouts we check if
1944          * dataversion has changed (if requested) */
1945         if (llss->check_dv1) {
1946                 rc = ll_data_version(llss->inode1, &dv, 0);
1947                 if (rc)
1948                         GOTO(putgl, rc);
1949                 if (dv != llss->dv1)
1950                         GOTO(putgl, rc = -EAGAIN);
1951         }
1952
1953         if (llss->check_dv2) {
1954                 rc = ll_data_version(llss->inode2, &dv, 0);
1955                 if (rc)
1956                         GOTO(putgl, rc);
1957                 if (dv != llss->dv2)
1958                         GOTO(putgl, rc = -EAGAIN);
1959         }
1960
1961         /* struct md_op_data is used to send the swap args to the mdt
1962          * only flags is missing, so we use struct mdc_swap_layouts
1963          * through the md_op_data->op_data */
1964         /* flags from user space have to be converted before they are send to
1965          * server, no flag is sent today, they are only used on the client */
1966         msl.msl_flags = 0;
1967         rc = -ENOMEM;
1968         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
1969                                      0, LUSTRE_OPC_ANY, &msl);
1970         if (IS_ERR(op_data))
1971                 GOTO(free, rc = PTR_ERR(op_data));
1972
1973         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
1974                            sizeof(*op_data), op_data, NULL);
1975         ll_finish_md_op_data(op_data);
1976
1977 putgl:
1978         if (gid != 0) {
1979                 ll_put_grouplock(llss->inode2, file2, gid);
1980                 ll_put_grouplock(llss->inode1, file1, gid);
1981         }
1982
1983         /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */
1984         if (rc != 0)
1985                 GOTO(free, rc);
1986
1987         /* clear useless flags */
1988         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
1989                 llss->ia1.ia_valid &= ~ATTR_MTIME;
1990                 llss->ia2.ia_valid &= ~ATTR_MTIME;
1991         }
1992
1993         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
1994                 llss->ia1.ia_valid &= ~ATTR_ATIME;
1995                 llss->ia2.ia_valid &= ~ATTR_ATIME;
1996         }
1997
1998         /* update time if requested */
1999         rc = 0;
2000         if (llss->ia2.ia_valid != 0) {
2001                 mutex_lock(&llss->inode1->i_mutex);
2002                 rc = ll_setattr(file1->f_dentry, &llss->ia2);
2003                 mutex_unlock(&llss->inode1->i_mutex);
2004         }
2005
2006         if (llss->ia1.ia_valid != 0) {
2007                 int rc1;
2008
2009                 mutex_lock(&llss->inode2->i_mutex);
2010                 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
2011                 mutex_unlock(&llss->inode2->i_mutex);
2012                 if (rc == 0)
2013                         rc = rc1;
2014         }
2015
2016 free:
2017         if (llss != NULL)
2018                 OBD_FREE_PTR(llss);
2019
2020         RETURN(rc);
2021 }
2022
2023 long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2024 {
2025         struct inode            *inode = file->f_dentry->d_inode;
2026         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2027         int                      flags, rc;
2028         ENTRY;
2029
2030         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
2031                inode->i_generation, inode, cmd);
2032         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2033
2034         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2035         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2036                 RETURN(-ENOTTY);
2037
2038         switch(cmd) {
2039         case LL_IOC_GETFLAGS:
2040                 /* Get the current value of the file flags */
2041                 return put_user(fd->fd_flags, (int *)arg);
2042         case LL_IOC_SETFLAGS:
2043         case LL_IOC_CLRFLAGS:
2044                 /* Set or clear specific file flags */
2045                 /* XXX This probably needs checks to ensure the flags are
2046                  *     not abused, and to handle any flag side effects.
2047                  */
2048                 if (get_user(flags, (int *) arg))
2049                         RETURN(-EFAULT);
2050
2051                 if (cmd == LL_IOC_SETFLAGS) {
2052                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2053                             !(file->f_flags & O_DIRECT)) {
2054                                 CERROR("%s: unable to disable locking on "
2055                                        "non-O_DIRECT file\n", current->comm);
2056                                 RETURN(-EINVAL);
2057                         }
2058
2059                         fd->fd_flags |= flags;
2060                 } else {
2061                         fd->fd_flags &= ~flags;
2062                 }
2063                 RETURN(0);
2064         case LL_IOC_LOV_SETSTRIPE:
2065                 RETURN(ll_lov_setstripe(inode, file, arg));
2066         case LL_IOC_LOV_SETEA:
2067                 RETURN(ll_lov_setea(inode, file, arg));
2068         case LL_IOC_LOV_SWAP_LAYOUTS: {
2069                 struct file *file2;
2070                 struct lustre_swap_layouts lsl;
2071
2072                 if (cfs_copy_from_user(&lsl, (char *)arg,
2073                                        sizeof(struct lustre_swap_layouts)))
2074                         RETURN(-EFAULT);
2075
2076                 if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */
2077                         RETURN(-EPERM);
2078
2079                 file2 = fget(lsl.sl_fd);
2080                 if (file2 == NULL)
2081                         RETURN(-EBADF);
2082
2083                 rc = -EPERM;
2084                 if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */
2085                         rc = ll_swap_layouts(file, file2, &lsl);
2086                 fput(file2);
2087                 RETURN(rc);
2088         }
2089         case LL_IOC_LOV_GETSTRIPE:
2090                 RETURN(ll_lov_getstripe(inode, arg));
2091         case LL_IOC_RECREATE_OBJ:
2092                 RETURN(ll_lov_recreate_obj(inode, arg));
2093         case LL_IOC_RECREATE_FID:
2094                 RETURN(ll_lov_recreate_fid(inode, arg));
2095         case FSFILT_IOC_FIEMAP:
2096                 RETURN(ll_ioctl_fiemap(inode, arg));
2097         case FSFILT_IOC_GETFLAGS:
2098         case FSFILT_IOC_SETFLAGS:
2099                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2100         case FSFILT_IOC_GETVERSION_OLD:
2101         case FSFILT_IOC_GETVERSION:
2102                 RETURN(put_user(inode->i_generation, (int *)arg));
2103         case LL_IOC_GROUP_LOCK:
2104                 RETURN(ll_get_grouplock(inode, file, arg));
2105         case LL_IOC_GROUP_UNLOCK:
2106                 RETURN(ll_put_grouplock(inode, file, arg));
2107         case IOC_OBD_STATFS:
2108                 RETURN(ll_obd_statfs(inode, (void *)arg));
2109
2110         /* We need to special case any other ioctls we want to handle,
2111          * to send them to the MDS/OST as appropriate and to properly
2112          * network encode the arg field.
2113         case FSFILT_IOC_SETVERSION_OLD:
2114         case FSFILT_IOC_SETVERSION:
2115         */
2116         case LL_IOC_FLUSHCTX:
2117                 RETURN(ll_flush_ctx(inode));
2118         case LL_IOC_PATH2FID: {
2119                 if (copy_to_user((void *)arg, ll_inode2fid(inode),
2120                                  sizeof(struct lu_fid)))
2121                         RETURN(-EFAULT);
2122
2123                 RETURN(0);
2124         }
2125         case OBD_IOC_FID2PATH:
2126                 RETURN(ll_fid2path(inode, (void *)arg));
2127         case LL_IOC_DATA_VERSION: {
2128                 struct ioc_data_version idv;
2129                 int                     rc;
2130
2131                 if (copy_from_user(&idv, (char *)arg, sizeof(idv)))
2132                         RETURN(-EFAULT);
2133
2134                 rc = ll_data_version(inode, &idv.idv_version,
2135                                 !(idv.idv_flags & LL_DV_NOFLUSH));
2136
2137                 if (rc == 0 && copy_to_user((char *) arg, &idv, sizeof(idv)))
2138                         RETURN(-EFAULT);
2139
2140                 RETURN(rc);
2141         }
2142
2143         case LL_IOC_GET_MDTIDX: {
2144                 int mdtidx;
2145
2146                 mdtidx = ll_get_mdt_idx(inode);
2147                 if (mdtidx < 0)
2148                         RETURN(mdtidx);
2149
2150                 if (put_user((int)mdtidx, (int*)arg))
2151                         RETURN(-EFAULT);
2152
2153                 RETURN(0);
2154         }
2155         case OBD_IOC_GETDTNAME:
2156         case OBD_IOC_GETMDNAME:
2157                 RETURN(ll_get_obd_name(inode, cmd, arg));
2158         case LL_IOC_HSM_STATE_GET: {
2159                 struct md_op_data       *op_data;
2160                 struct hsm_user_state   *hus;
2161                 int                      rc;
2162
2163                 OBD_ALLOC_PTR(hus);
2164                 if (hus == NULL)
2165                         RETURN(-ENOMEM);
2166
2167                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2168                                              LUSTRE_OPC_ANY, hus);
2169                 if (IS_ERR(op_data)) {
2170                         OBD_FREE_PTR(hus);
2171                         RETURN(PTR_ERR(op_data));
2172                 }
2173
2174                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2175                                    op_data, NULL);
2176
2177                 if (copy_to_user((void *)arg, hus, sizeof(*hus)))
2178                         rc = -EFAULT;
2179
2180                 ll_finish_md_op_data(op_data);
2181                 OBD_FREE_PTR(hus);
2182                 RETURN(rc);
2183         }
2184         case LL_IOC_HSM_STATE_SET: {
2185                 struct md_op_data       *op_data;
2186                 struct hsm_state_set    *hss;
2187                 int                      rc;
2188
2189                 OBD_ALLOC_PTR(hss);
2190                 if (hss == NULL)
2191                         RETURN(-ENOMEM);
2192                 if (copy_from_user(hss, (char *)arg, sizeof(*hss))) {
2193                         OBD_FREE_PTR(hss);
2194                         RETURN(-EFAULT);
2195                 }
2196
2197                 /* Non-root users are forbidden to set or clear flags which are
2198                  * NOT defined in HSM_USER_MASK. */
2199                 if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK)
2200                     && !cfs_capable(CFS_CAP_SYS_ADMIN)) {
2201                         OBD_FREE_PTR(hss);
2202                         RETURN(-EPERM);
2203                 }
2204
2205                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2206                                              LUSTRE_OPC_ANY, hss);
2207                 if (IS_ERR(op_data)) {
2208                         OBD_FREE_PTR(hss);
2209                         RETURN(PTR_ERR(op_data));
2210                 }
2211
2212                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2213                                    op_data, NULL);
2214
2215                 ll_finish_md_op_data(op_data);
2216
2217                 OBD_FREE_PTR(hss);
2218                 RETURN(rc);
2219         }
2220         case LL_IOC_HSM_ACTION: {
2221                 struct md_op_data               *op_data;
2222                 struct hsm_current_action       *hca;
2223                 int                              rc;
2224
2225                 OBD_ALLOC_PTR(hca);
2226                 if (hca == NULL)
2227                         RETURN(-ENOMEM);
2228
2229                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2230                                              LUSTRE_OPC_ANY, hca);
2231                 if (IS_ERR(op_data)) {
2232                         OBD_FREE_PTR(hca);
2233                         RETURN(PTR_ERR(op_data));
2234                 }
2235
2236                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2237                                    op_data, NULL);
2238
2239                 if (cfs_copy_to_user((char *)arg, hca, sizeof(*hca)))
2240                         rc = -EFAULT;
2241
2242                 ll_finish_md_op_data(op_data);
2243                 OBD_FREE_PTR(hca);
2244                 RETURN(rc);
2245         }
2246         default: {
2247                 int err;
2248
2249                 if (LLIOC_STOP ==
2250                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2251                         RETURN(err);
2252
2253                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2254                                      (void *)arg));
2255         }
2256         }
2257 }
2258
2259 #ifndef HAVE_FILE_LLSEEK_SIZE
2260 static inline loff_t
2261 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2262 {
2263         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2264                 return -EINVAL;
2265         if (offset > maxsize)
2266                 return -EINVAL;
2267
2268         if (offset != file->f_pos) {
2269                 file->f_pos = offset;
2270                 file->f_version = 0;
2271         }
2272         return offset;
2273 }
2274
2275 static loff_t
2276 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2277                 loff_t maxsize, loff_t eof)
2278 {
2279         struct inode *inode = file->f_dentry->d_inode;
2280
2281         switch (origin) {
2282         case SEEK_END:
2283                 offset += eof;
2284                 break;
2285         case SEEK_CUR:
2286                 /*
2287                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2288                  * position-querying operation.  Avoid rewriting the "same"
2289                  * f_pos value back to the file because a concurrent read(),
2290                  * write() or lseek() might have altered it
2291                  */
2292                 if (offset == 0)
2293                         return file->f_pos;
2294                 /*
2295                  * f_lock protects against read/modify/write race with other
2296                  * SEEK_CURs. Note that parallel writes and reads behave
2297                  * like SEEK_SET.
2298                  */
2299                 mutex_lock(&inode->i_mutex);
2300                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2301                 mutex_unlock(&inode->i_mutex);
2302                 return offset;
2303         case SEEK_DATA:
2304                 /*
2305                  * In the generic case the entire file is data, so as long as
2306                  * offset isn't at the end of the file then the offset is data.
2307                  */
2308                 if (offset >= eof)
2309                         return -ENXIO;
2310                 break;
2311         case SEEK_HOLE:
2312                 /*
2313                  * There is a virtual hole at the end of the file, so as long as
2314                  * offset isn't i_size or larger, return i_size.
2315                  */
2316                 if (offset >= eof)
2317                         return -ENXIO;
2318                 offset = eof;
2319                 break;
2320         }
2321
2322         return llseek_execute(file, offset, maxsize);
2323 }
2324 #endif
2325
2326 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2327 {
2328         struct inode *inode = file->f_dentry->d_inode;
2329         loff_t retval, eof = 0;
2330
2331         ENTRY;
2332         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2333                            (origin == SEEK_CUR) ? file->f_pos : 0);
2334         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%d)\n",
2335                inode->i_ino, inode->i_generation, inode, retval, retval,
2336                origin);
2337         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2338
2339         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2340                 retval = ll_glimpse_size(inode);
2341                 if (retval != 0)
2342                         RETURN(retval);
2343                 eof = i_size_read(inode);
2344         }
2345
2346         retval = ll_generic_file_llseek_size(file, offset, origin,
2347                                           ll_file_maxbytes(inode), eof);
2348         RETURN(retval);
2349 }
2350
2351 int ll_flush(struct file *file, fl_owner_t id)
2352 {
2353         struct inode *inode = file->f_dentry->d_inode;
2354         struct ll_inode_info *lli = ll_i2info(inode);
2355         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2356         int rc, err;
2357
2358         LASSERT(!S_ISDIR(inode->i_mode));
2359
2360         /* catch async errors that were recorded back when async writeback
2361          * failed for pages in this mapping. */
2362         rc = lli->lli_async_rc;
2363         lli->lli_async_rc = 0;
2364         err = lov_read_and_clear_async_rc(lli->lli_clob);
2365         if (rc == 0)
2366                 rc = err;
2367
2368         /* The application has been told write failure already.
2369          * Do not report failure again. */
2370         if (fd->fd_write_failed)
2371                 return 0;
2372         return rc ? -EIO : 0;
2373 }
2374
2375 /**
2376  * Called to make sure a portion of file has been written out.
2377  * if @local_only is not true, it will send OST_SYNC RPCs to ost.
2378  *
2379  * Return how many pages have been written.
2380  */
2381 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2382                        enum cl_fsync_mode mode, int ignore_layout)
2383 {
2384         struct cl_env_nest nest;
2385         struct lu_env *env;
2386         struct cl_io *io;
2387         struct obd_capa *capa = NULL;
2388         struct cl_fsync_io *fio;
2389         int result;
2390         ENTRY;
2391
2392         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2393             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2394                 RETURN(-EINVAL);
2395
2396         env = cl_env_nested_get(&nest);
2397         if (IS_ERR(env))
2398                 RETURN(PTR_ERR(env));
2399
2400         capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2401
2402         io = ccc_env_thread_io(env);
2403         io->ci_obj = cl_i2info(inode)->lli_clob;
2404         io->ci_ignore_layout = ignore_layout;
2405
2406         /* initialize parameters for sync */
2407         fio = &io->u.ci_fsync;
2408         fio->fi_capa = capa;
2409         fio->fi_start = start;
2410         fio->fi_end = end;
2411         fio->fi_fid = ll_inode2fid(inode);
2412         fio->fi_mode = mode;
2413         fio->fi_nr_written = 0;
2414
2415         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2416                 result = cl_io_loop(env, io);
2417         else
2418                 result = io->ci_result;
2419         if (result == 0)
2420                 result = fio->fi_nr_written;
2421         cl_io_fini(env, io);
2422         cl_env_nested_put(&nest, env);
2423
2424         capa_put(capa);
2425
2426         RETURN(result);
2427 }
2428
2429 /*
2430  * When dentry is provided (the 'else' case), *file->f_dentry may be
2431  * null and dentry must be used directly rather than pulled from
2432  * *file->f_dentry as is done otherwise.
2433  */
2434
2435 #ifdef HAVE_FILE_FSYNC_4ARGS
2436 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2437 {
2438         struct dentry *dentry = file->f_dentry;
2439 #elif defined(HAVE_FILE_FSYNC_2ARGS)
2440 int ll_fsync(struct file *file, int datasync)
2441 {
2442         struct dentry *dentry = file->f_dentry;
2443 #else
2444 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
2445 {
2446 #endif
2447         struct inode *inode = dentry->d_inode;
2448         struct ll_inode_info *lli = ll_i2info(inode);
2449         struct ptlrpc_request *req;
2450         struct obd_capa *oc;
2451         int rc, err;
2452         ENTRY;
2453
2454         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
2455                inode->i_generation, inode);
2456         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2457
2458 #ifdef HAVE_FILE_FSYNC_4ARGS
2459         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2460         mutex_lock(&inode->i_mutex);
2461 #else
2462         /* fsync's caller has already called _fdata{sync,write}, we want
2463          * that IO to finish before calling the osc and mdc sync methods */
2464         rc = filemap_fdatawait(inode->i_mapping);
2465 #endif
2466
2467         /* catch async errors that were recorded back when async writeback
2468          * failed for pages in this mapping. */
2469         if (!S_ISDIR(inode->i_mode)) {
2470                 err = lli->lli_async_rc;
2471                 lli->lli_async_rc = 0;
2472                 if (rc == 0)
2473                         rc = err;
2474                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2475                 if (rc == 0)
2476                         rc = err;
2477         }
2478
2479         oc = ll_mdscapa_get(inode);
2480         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2481                       &req);
2482         capa_put(oc);
2483         if (!rc)
2484                 rc = err;
2485         if (!err)
2486                 ptlrpc_req_finished(req);
2487
2488         if (datasync && S_ISREG(inode->i_mode)) {
2489                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2490
2491                 err = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF,
2492                                 CL_FSYNC_ALL, 0);
2493                 if (rc == 0 && err < 0)
2494                         rc = err;
2495                 if (rc < 0)
2496                         fd->fd_write_failed = true;
2497                 else
2498                         fd->fd_write_failed = false;
2499         }
2500
2501 #ifdef HAVE_FILE_FSYNC_4ARGS
2502         mutex_unlock(&inode->i_mutex);
2503 #endif
2504         RETURN(rc);
2505 }
2506
2507 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2508 {
2509         struct inode *inode = file->f_dentry->d_inode;
2510         struct ll_sb_info *sbi = ll_i2sbi(inode);
2511         struct ldlm_enqueue_info einfo = {
2512                 .ei_type        = LDLM_FLOCK,
2513                 .ei_cb_cp       = ldlm_flock_completion_ast,
2514                 .ei_cbdata      = file_lock,
2515         };
2516         struct md_op_data *op_data;
2517         struct lustre_handle lockh = {0};
2518         ldlm_policy_data_t flock = {{0}};
2519         int flags = 0;
2520         int rc;
2521         int rc2 = 0;
2522         ENTRY;
2523
2524         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2525                inode->i_ino, file_lock);
2526
2527         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2528
2529         if (file_lock->fl_flags & FL_FLOCK) {
2530                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2531                 /* flocks are whole-file locks */
2532                 flock.l_flock.end = OFFSET_MAX;
2533                 /* For flocks owner is determined by the local file desctiptor*/
2534                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2535         } else if (file_lock->fl_flags & FL_POSIX) {
2536                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2537                 flock.l_flock.start = file_lock->fl_start;
2538                 flock.l_flock.end = file_lock->fl_end;
2539         } else {
2540                 RETURN(-EINVAL);
2541         }
2542         flock.l_flock.pid = file_lock->fl_pid;
2543
2544         /* Somewhat ugly workaround for svc lockd.
2545          * lockd installs custom fl_lmops->lm_compare_owner that checks
2546          * for the fl_owner to be the same (which it always is on local node
2547          * I guess between lockd processes) and then compares pid.
2548          * As such we assign pid to the owner field to make it all work,
2549          * conflict with normal locks is unlikely since pid space and
2550          * pointer space for current->files are not intersecting */
2551         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2552                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2553
2554         switch (file_lock->fl_type) {
2555         case F_RDLCK:
2556                 einfo.ei_mode = LCK_PR;
2557                 break;
2558         case F_UNLCK:
2559                 /* An unlock request may or may not have any relation to
2560                  * existing locks so we may not be able to pass a lock handle
2561                  * via a normal ldlm_lock_cancel() request. The request may even
2562                  * unlock a byte range in the middle of an existing lock. In
2563                  * order to process an unlock request we need all of the same
2564                  * information that is given with a normal read or write record
2565                  * lock request. To avoid creating another ldlm unlock (cancel)
2566                  * message we'll treat a LCK_NL flock request as an unlock. */
2567                 einfo.ei_mode = LCK_NL;
2568                 break;
2569         case F_WRLCK:
2570                 einfo.ei_mode = LCK_PW;
2571                 break;
2572         default:
2573                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n",
2574                         file_lock->fl_type);
2575                 RETURN (-ENOTSUPP);
2576         }
2577
2578         switch (cmd) {
2579         case F_SETLKW:
2580 #ifdef F_SETLKW64
2581         case F_SETLKW64:
2582 #endif
2583                 flags = 0;
2584                 break;
2585         case F_SETLK:
2586 #ifdef F_SETLK64
2587         case F_SETLK64:
2588 #endif
2589                 flags = LDLM_FL_BLOCK_NOWAIT;
2590                 break;
2591         case F_GETLK:
2592 #ifdef F_GETLK64
2593         case F_GETLK64:
2594 #endif
2595                 flags = LDLM_FL_TEST_LOCK;
2596                 /* Save the old mode so that if the mode in the lock changes we
2597                  * can decrement the appropriate reader or writer refcount. */
2598                 file_lock->fl_type = einfo.ei_mode;
2599                 break;
2600         default:
2601                 CERROR("unknown fcntl lock command: %d\n", cmd);
2602                 RETURN (-EINVAL);
2603         }
2604
2605         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2606                                      LUSTRE_OPC_ANY, NULL);
2607         if (IS_ERR(op_data))
2608                 RETURN(PTR_ERR(op_data));
2609
2610         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2611                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2612                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2613
2614         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2615                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2616
2617         if ((file_lock->fl_flags & FL_FLOCK) &&
2618             (rc == 0 || file_lock->fl_type == F_UNLCK))
2619                 rc2  = flock_lock_file_wait(file, file_lock);
2620         if ((file_lock->fl_flags & FL_POSIX) &&
2621             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2622             !(flags & LDLM_FL_TEST_LOCK))
2623                 rc2  = posix_lock_file_wait(file, file_lock);
2624
2625         if (rc2 && file_lock->fl_type != F_UNLCK) {
2626                 einfo.ei_mode = LCK_NL;
2627                 md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2628                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2629                 rc = rc2;
2630         }
2631
2632         ll_finish_md_op_data(op_data);
2633
2634         RETURN(rc);
2635 }
2636
2637 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2638 {
2639         ENTRY;
2640
2641         RETURN(-ENOSYS);
2642 }
2643
2644 /**
2645  * test if some locks matching bits and l_req_mode are acquired
2646  * - bits can be in different locks
2647  * - if found clear the common lock bits in *bits
2648  * - the bits not found, are kept in *bits
2649  * \param inode [IN]
2650  * \param bits [IN] searched lock bits [IN]
2651  * \param l_req_mode [IN] searched lock mode
2652  * \retval boolean, true iff all bits are found
2653  */
2654 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
2655 {
2656         struct lustre_handle lockh;
2657         ldlm_policy_data_t policy;
2658         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2659                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2660         struct lu_fid *fid;
2661         __u64 flags;
2662         int i;
2663         ENTRY;
2664
2665         if (!inode)
2666                RETURN(0);
2667
2668         fid = &ll_i2info(inode)->lli_fid;
2669         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2670                ldlm_lockname[mode]);
2671
2672         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2673         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
2674                 policy.l_inodebits.bits = *bits & (1 << i);
2675                 if (policy.l_inodebits.bits == 0)
2676                         continue;
2677
2678                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
2679                                   &policy, mode, &lockh)) {
2680                         struct ldlm_lock *lock;
2681
2682                         lock = ldlm_handle2lock(&lockh);
2683                         if (lock) {
2684                                 *bits &=
2685                                       ~(lock->l_policy_data.l_inodebits.bits);
2686                                 LDLM_LOCK_PUT(lock);
2687                         } else {
2688                                 *bits &= ~policy.l_inodebits.bits;
2689                         }
2690                 }
2691         }
2692         RETURN(*bits == 0);
2693 }
2694
2695 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2696                             struct lustre_handle *lockh, __u64 flags)
2697 {
2698         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2699         struct lu_fid *fid;
2700         ldlm_mode_t rc;
2701         ENTRY;
2702
2703         fid = &ll_i2info(inode)->lli_fid;
2704         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2705
2706         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
2707                            fid, LDLM_IBITS, &policy,
2708                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2709         RETURN(rc);
2710 }
2711
2712 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
2713 {
2714         /* Already unlinked. Just update nlink and return success */
2715         if (rc == -ENOENT) {
2716                 clear_nlink(inode);
2717                 /* This path cannot be hit for regular files unless in
2718                  * case of obscure races, so no need to to validate
2719                  * size. */
2720                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
2721                         return 0;
2722         } else if (rc != 0) {
2723                 CERROR("%s: revalidate FID "DFID" error: rc = %d\n",
2724                        ll_get_fsname(inode->i_sb, NULL, 0),
2725                        PFID(ll_inode2fid(inode)), rc);
2726         }
2727
2728         return rc;
2729 }
2730
2731 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2732                              __u64 ibits)
2733 {
2734         struct inode *inode = dentry->d_inode;
2735         struct ptlrpc_request *req = NULL;
2736         struct obd_export *exp;
2737         int rc = 0;
2738         ENTRY;
2739
2740         LASSERT(inode != NULL);
2741
2742         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2743                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2744
2745         exp = ll_i2mdexp(inode);
2746
2747         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
2748          *      But under CMD case, it caused some lock issues, should be fixed
2749          *      with new CMD ibits lock. See bug 12718 */
2750         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
2751                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2752                 struct md_op_data *op_data;
2753
2754                 if (ibits == MDS_INODELOCK_LOOKUP)
2755                         oit.it_op = IT_LOOKUP;
2756
2757                 /* Call getattr by fid, so do not provide name at all. */
2758                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2759                                              dentry->d_inode, NULL, 0, 0,
2760                                              LUSTRE_OPC_ANY, NULL);
2761                 if (IS_ERR(op_data))
2762                         RETURN(PTR_ERR(op_data));
2763
2764                 oit.it_create_mode |= M_CHECK_STALE;
2765                 rc = md_intent_lock(exp, op_data, NULL, 0,
2766                                     /* we are not interested in name
2767                                        based lookup */
2768                                     &oit, 0, &req,
2769                                     ll_md_blocking_ast, 0);
2770                 ll_finish_md_op_data(op_data);
2771                 oit.it_create_mode &= ~M_CHECK_STALE;
2772                 if (rc < 0) {
2773                         rc = ll_inode_revalidate_fini(inode, rc);
2774                         GOTO (out, rc);
2775                 }
2776
2777                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2778                 if (rc != 0) {
2779                         ll_intent_release(&oit);
2780                         GOTO(out, rc);
2781                 }
2782
2783                 /* Unlinked? Unhash dentry, so it is not picked up later by
2784                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2785                    here to preserve get_cwd functionality on 2.6.
2786                    Bug 10503 */
2787                 if (!dentry->d_inode->i_nlink)
2788                         d_lustre_invalidate(dentry, 0);
2789
2790                 ll_lookup_finish_locks(&oit, dentry);
2791         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
2792                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2793                 obd_valid valid = OBD_MD_FLGETATTR;
2794                 struct md_op_data *op_data;
2795                 int ealen = 0;
2796
2797                 if (S_ISREG(inode->i_mode)) {
2798                         rc = ll_get_max_mdsize(sbi, &ealen);
2799                         if (rc)
2800                                 RETURN(rc);
2801                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2802                 }
2803
2804                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2805                                              0, ealen, LUSTRE_OPC_ANY,
2806                                              NULL);
2807                 if (IS_ERR(op_data))
2808                         RETURN(PTR_ERR(op_data));
2809
2810                 op_data->op_valid = valid;
2811                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2812                  * capa for this inode. Because we only keep capas of dirs
2813                  * fresh. */
2814                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2815                 ll_finish_md_op_data(op_data);
2816                 if (rc) {
2817                         rc = ll_inode_revalidate_fini(inode, rc);
2818                         RETURN(rc);
2819                 }
2820
2821                 rc = ll_prep_inode(&inode, req, NULL, NULL);
2822         }
2823 out:
2824         ptlrpc_req_finished(req);
2825         return rc;
2826 }
2827
2828 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2829                            __u64 ibits)
2830 {
2831         struct inode *inode = dentry->d_inode;
2832         int rc;
2833         ENTRY;
2834
2835         rc = __ll_inode_revalidate_it(dentry, it, ibits);
2836         if (rc != 0)
2837                 RETURN(rc);
2838
2839         /* if object isn't regular file, don't validate size */
2840         if (!S_ISREG(inode->i_mode)) {
2841                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2842                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2843                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2844         } else {
2845                 rc = ll_glimpse_size(inode);
2846         }
2847         RETURN(rc);
2848 }
2849
2850 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2851                   struct lookup_intent *it, struct kstat *stat)
2852 {
2853         struct inode *inode = de->d_inode;
2854         struct ll_sb_info *sbi = ll_i2sbi(inode);
2855         struct ll_inode_info *lli = ll_i2info(inode);
2856         int res = 0;
2857
2858         res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE |
2859                                              MDS_INODELOCK_LOOKUP);
2860         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
2861
2862         if (res)
2863                 return res;
2864
2865         stat->dev = inode->i_sb->s_dev;
2866         if (ll_need_32bit_api(sbi))
2867                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
2868         else
2869                 stat->ino = inode->i_ino;
2870         stat->mode = inode->i_mode;
2871         stat->nlink = inode->i_nlink;
2872         stat->uid = inode->i_uid;
2873         stat->gid = inode->i_gid;
2874         stat->rdev = inode->i_rdev;
2875         stat->atime = inode->i_atime;
2876         stat->mtime = inode->i_mtime;
2877         stat->ctime = inode->i_ctime;
2878         stat->blksize = 1 << inode->i_blkbits;
2879
2880         stat->size = i_size_read(inode);
2881         stat->blocks = inode->i_blocks;
2882
2883         return 0;
2884 }
2885 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2886 {
2887         struct lookup_intent it = { .it_op = IT_GETATTR };
2888
2889         return ll_getattr_it(mnt, de, &it, stat);
2890 }
2891
2892 #ifdef HAVE_LINUX_FIEMAP_H
2893 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2894                 __u64 start, __u64 len)
2895 {
2896         int rc;
2897         size_t num_bytes;
2898         struct ll_user_fiemap *fiemap;
2899         unsigned int extent_count = fieinfo->fi_extents_max;
2900
2901         num_bytes = sizeof(*fiemap) + (extent_count *
2902                                        sizeof(struct ll_fiemap_extent));
2903         OBD_ALLOC_LARGE(fiemap, num_bytes);
2904
2905         if (fiemap == NULL)
2906                 RETURN(-ENOMEM);
2907
2908         fiemap->fm_flags = fieinfo->fi_flags;
2909         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2910         fiemap->fm_start = start;
2911         fiemap->fm_length = len;
2912         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2913                sizeof(struct ll_fiemap_extent));
2914
2915         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2916
2917         fieinfo->fi_flags = fiemap->fm_flags;
2918         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2919         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2920                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2921
2922         OBD_FREE_LARGE(fiemap, num_bytes);
2923         return rc;
2924 }
2925 #endif
2926
2927 struct posix_acl * ll_get_acl(struct inode *inode, int type)
2928 {
2929         struct ll_inode_info *lli = ll_i2info(inode);
2930         struct posix_acl *acl = NULL;
2931         ENTRY;
2932
2933         spin_lock(&lli->lli_lock);
2934         /* VFS' acl_permission_check->check_acl will release the refcount */
2935         acl = posix_acl_dup(lli->lli_posix_acl);
2936         spin_unlock(&lli->lli_lock);
2937
2938         RETURN(acl);
2939 }
2940
2941 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
2942 static int
2943 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
2944 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
2945 # else
2946 ll_check_acl(struct inode *inode, int mask)
2947 # endif
2948 {
2949 # ifdef CONFIG_FS_POSIX_ACL
2950         struct posix_acl *acl;
2951         int rc;
2952         ENTRY;
2953
2954 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
2955         if (flags & IPERM_FLAG_RCU)
2956                 return -ECHILD;
2957 #  endif
2958         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
2959
2960         if (!acl)
2961                 RETURN(-EAGAIN);
2962
2963         rc = posix_acl_permission(inode, acl, mask);
2964         posix_acl_release(acl);
2965
2966         RETURN(rc);
2967 # else /* !CONFIG_FS_POSIX_ACL */
2968         return -EAGAIN;
2969 # endif /* CONFIG_FS_POSIX_ACL */
2970 }
2971 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
2972
2973 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
2974 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
2975 #else
2976 # ifdef HAVE_INODE_PERMISION_2ARGS
2977 int ll_inode_permission(struct inode *inode, int mask)
2978 # else
2979 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2980 # endif
2981 #endif
2982 {
2983         int rc = 0;
2984         ENTRY;
2985
2986 #ifdef MAY_NOT_BLOCK
2987         if (mask & MAY_NOT_BLOCK)
2988                 return -ECHILD;
2989 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
2990         if (flags & IPERM_FLAG_RCU)
2991                 return -ECHILD;
2992 #endif
2993
2994        /* as root inode are NOT getting validated in lookup operation,
2995         * need to do it before permission check. */
2996
2997         if (inode == inode->i_sb->s_root->d_inode) {
2998                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2999
3000                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
3001                                               MDS_INODELOCK_LOOKUP);
3002                 if (rc)
3003                         RETURN(rc);
3004         }
3005
3006         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
3007                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
3008
3009         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
3010                 return lustre_check_remote_perm(inode, mask);
3011
3012         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
3013         rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3014
3015         RETURN(rc);
3016 }
3017
3018 #ifdef HAVE_FILE_READV
3019 #define READ_METHOD readv
3020 #define READ_FUNCTION ll_file_readv
3021 #define WRITE_METHOD writev
3022 #define WRITE_FUNCTION ll_file_writev
3023 #else
3024 #define READ_METHOD aio_read
3025 #define READ_FUNCTION ll_file_aio_read
3026 #define WRITE_METHOD aio_write
3027 #define WRITE_FUNCTION ll_file_aio_write
3028 #endif
3029
3030 /* -o localflock - only provides locally consistent flock locks */
3031 struct file_operations ll_file_operations = {
3032         .read           = ll_file_read,
3033         .READ_METHOD    = READ_FUNCTION,
3034         .write          = ll_file_write,
3035         .WRITE_METHOD   = WRITE_FUNCTION,
3036         .unlocked_ioctl = ll_file_ioctl,
3037         .open           = ll_file_open,
3038         .release        = ll_file_release,
3039         .mmap           = ll_file_mmap,
3040         .llseek         = ll_file_seek,
3041 #ifdef HAVE_KERNEL_SENDFILE
3042         .sendfile       = ll_file_sendfile,
3043 #endif
3044 #ifdef HAVE_KERNEL_SPLICE_READ
3045         .splice_read    = ll_file_splice_read,
3046 #endif
3047         .fsync          = ll_fsync,
3048         .flush          = ll_flush
3049 };
3050
3051 struct file_operations ll_file_operations_flock = {
3052         .read           = ll_file_read,
3053         .READ_METHOD    = READ_FUNCTION,
3054         .write          = ll_file_write,
3055         .WRITE_METHOD   = WRITE_FUNCTION,
3056         .unlocked_ioctl = ll_file_ioctl,
3057         .open           = ll_file_open,
3058         .release        = ll_file_release,
3059         .mmap           = ll_file_mmap,
3060         .llseek         = ll_file_seek,
3061 #ifdef HAVE_KERNEL_SENDFILE
3062         .sendfile       = ll_file_sendfile,
3063 #endif
3064 #ifdef HAVE_KERNEL_SPLICE_READ
3065         .splice_read    = ll_file_splice_read,
3066 #endif
3067         .fsync          = ll_fsync,
3068         .flush          = ll_flush,
3069         .flock          = ll_file_flock,
3070         .lock           = ll_file_flock
3071 };
3072
3073 /* These are for -o noflock - to return ENOSYS on flock calls */
3074 struct file_operations ll_file_operations_noflock = {
3075         .read           = ll_file_read,
3076         .READ_METHOD    = READ_FUNCTION,
3077         .write          = ll_file_write,
3078         .WRITE_METHOD   = WRITE_FUNCTION,
3079         .unlocked_ioctl = ll_file_ioctl,
3080         .open           = ll_file_open,
3081         .release        = ll_file_release,
3082         .mmap           = ll_file_mmap,
3083         .llseek         = ll_file_seek,
3084 #ifdef HAVE_KERNEL_SENDFILE
3085         .sendfile       = ll_file_sendfile,
3086 #endif
3087 #ifdef HAVE_KERNEL_SPLICE_READ
3088         .splice_read    = ll_file_splice_read,
3089 #endif
3090         .fsync          = ll_fsync,
3091         .flush          = ll_flush,
3092         .flock          = ll_file_noflock,
3093         .lock           = ll_file_noflock
3094 };
3095
3096 struct inode_operations ll_file_inode_operations = {
3097         .setattr        = ll_setattr,
3098         .getattr        = ll_getattr,
3099         .permission     = ll_inode_permission,
3100         .setxattr       = ll_setxattr,
3101         .getxattr       = ll_getxattr,
3102         .listxattr      = ll_listxattr,
3103         .removexattr    = ll_removexattr,
3104 #ifdef  HAVE_LINUX_FIEMAP_H
3105         .fiemap         = ll_fiemap,
3106 #endif
3107 #ifdef HAVE_IOP_GET_ACL
3108         .get_acl        = ll_get_acl,
3109 #endif
3110 };
3111
3112 /* dynamic ioctl number support routins */
3113 static struct llioc_ctl_data {
3114         struct rw_semaphore     ioc_sem;
3115         cfs_list_t              ioc_head;
3116 } llioc = {
3117         __RWSEM_INITIALIZER(llioc.ioc_sem),
3118         CFS_LIST_HEAD_INIT(llioc.ioc_head)
3119 };
3120
3121
3122 struct llioc_data {
3123         cfs_list_t              iocd_list;
3124         unsigned int            iocd_size;
3125         llioc_callback_t        iocd_cb;
3126         unsigned int            iocd_count;
3127         unsigned int            iocd_cmd[0];
3128 };
3129
3130 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3131 {
3132         unsigned int size;
3133         struct llioc_data *in_data = NULL;
3134         ENTRY;
3135
3136         if (cb == NULL || cmd == NULL ||
3137             count > LLIOC_MAX_CMD || count < 0)
3138                 RETURN(NULL);
3139
3140         size = sizeof(*in_data) + count * sizeof(unsigned int);
3141         OBD_ALLOC(in_data, size);
3142         if (in_data == NULL)
3143                 RETURN(NULL);
3144
3145         memset(in_data, 0, sizeof(*in_data));
3146         in_data->iocd_size = size;
3147         in_data->iocd_cb = cb;
3148         in_data->iocd_count = count;
3149         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3150
3151         down_write(&llioc.ioc_sem);
3152         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3153         up_write(&llioc.ioc_sem);
3154
3155         RETURN(in_data);
3156 }
3157
3158 void ll_iocontrol_unregister(void *magic)
3159 {
3160         struct llioc_data *tmp;
3161
3162         if (magic == NULL)
3163                 return;
3164
3165         down_write(&llioc.ioc_sem);
3166         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3167                 if (tmp == magic) {
3168                         unsigned int size = tmp->iocd_size;
3169
3170                         cfs_list_del(&tmp->iocd_list);
3171                         up_write(&llioc.ioc_sem);
3172
3173                         OBD_FREE(tmp, size);
3174                         return;
3175                 }
3176         }
3177         up_write(&llioc.ioc_sem);
3178
3179         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3180 }
3181
3182 EXPORT_SYMBOL(ll_iocontrol_register);
3183 EXPORT_SYMBOL(ll_iocontrol_unregister);
3184
3185 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
3186                         unsigned int cmd, unsigned long arg, int *rcp)
3187 {
3188         enum llioc_iter ret = LLIOC_CONT;
3189         struct llioc_data *data;
3190         int rc = -EINVAL, i;
3191
3192         down_read(&llioc.ioc_sem);
3193         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3194                 for (i = 0; i < data->iocd_count; i++) {
3195                         if (cmd != data->iocd_cmd[i])
3196                                 continue;
3197
3198                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3199                         break;
3200                 }
3201
3202                 if (ret == LLIOC_STOP)
3203                         break;
3204         }
3205         up_read(&llioc.ioc_sem);
3206
3207         if (rcp)
3208                 *rcp = rc;
3209         return ret;
3210 }
3211
3212 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3213 {
3214         struct ll_inode_info *lli = ll_i2info(inode);
3215         struct cl_env_nest nest;
3216         struct lu_env *env;
3217         int result;
3218         ENTRY;
3219
3220         if (lli->lli_clob == NULL)
3221                 RETURN(0);
3222
3223         env = cl_env_nested_get(&nest);
3224         if (IS_ERR(env))
3225                 RETURN(PTR_ERR(env));
3226
3227         result = cl_conf_set(env, lli->lli_clob, conf);
3228         cl_env_nested_put(&nest, env);
3229
3230         if (conf->coc_opc == OBJECT_CONF_SET) {
3231                 struct ldlm_lock *lock = conf->coc_lock;
3232
3233                 LASSERT(lock != NULL);
3234                 LASSERT(ldlm_has_layout(lock));
3235                 if (result == 0) {
3236                         /* it can only be allowed to match after layout is
3237                          * applied to inode otherwise false layout would be
3238                          * seen. Applying layout shoud happen before dropping
3239                          * the intent lock. */
3240                         ldlm_lock_allow_match(lock);
3241                 }
3242         }
3243         RETURN(result);
3244 }
3245
3246 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3247 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3248
3249 {
3250         struct ll_sb_info *sbi = ll_i2sbi(inode);
3251         struct obd_capa *oc;
3252         struct ptlrpc_request *req;
3253         struct mdt_body *body;
3254         void *lvbdata;
3255         void *lmm;
3256         int lmmsize;
3257         int rc;
3258         ENTRY;
3259
3260         if (lock->l_lvb_data != NULL)
3261                 RETURN(0);
3262
3263         /* if layout lock was granted right away, the layout is returned
3264          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3265          * blocked and then granted via completion ast, we have to fetch
3266          * layout here. Please note that we can't use the LVB buffer in
3267          * completion AST because it doesn't have a large enough buffer */
3268         oc = ll_mdscapa_get(inode);
3269         rc = ll_get_max_mdsize(sbi, &lmmsize);
3270         if (rc == 0)
3271                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
3272                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3273                                 lmmsize, 0, &req);
3274         capa_put(oc);
3275         if (rc < 0)
3276                 RETURN(rc);
3277
3278         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3279         if (body == NULL || body->eadatasize > lmmsize)
3280                 GOTO(out, rc = -EPROTO);
3281
3282         lmmsize = body->eadatasize;
3283         if (lmmsize == 0) /* empty layout */
3284                 GOTO(out, rc = 0);
3285
3286         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3287         if (lmm == NULL)
3288                 GOTO(out, rc = -EFAULT);
3289
3290         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3291         if (lvbdata == NULL)
3292                 GOTO(out, rc = -ENOMEM);
3293
3294         memcpy(lvbdata, lmm, lmmsize);
3295         lock_res_and_lock(lock);
3296         if (lock->l_lvb_data == NULL) {
3297                 lock->l_lvb_data = lvbdata;
3298                 lock->l_lvb_len = lmmsize;
3299                 lvbdata = NULL;
3300         }
3301         unlock_res_and_lock(lock);
3302
3303         if (lvbdata != NULL)
3304                 OBD_FREE_LARGE(lvbdata, lmmsize);
3305         EXIT;
3306
3307 out:
3308         ptlrpc_req_finished(req);
3309         return rc;
3310 }
3311
3312 /**
3313  * Apply the layout to the inode. Layout lock is held and will be released
3314  * in this function.
3315  */
3316 static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
3317                                 struct inode *inode, __u32 *gen, bool reconf)
3318 {
3319         struct ll_inode_info *lli = ll_i2info(inode);
3320         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3321         struct ldlm_lock *lock;
3322         struct lustre_md md = { NULL };
3323         struct cl_object_conf conf;
3324         int rc = 0;
3325         bool lvb_ready;
3326         bool wait_layout = false;
3327         ENTRY;
3328
3329         LASSERT(lustre_handle_is_used(lockh));
3330
3331         lock = ldlm_handle2lock(lockh);
3332         LASSERT(lock != NULL);
3333         LASSERT(ldlm_has_layout(lock));
3334
3335         LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n",
3336                 inode, PFID(&lli->lli_fid), reconf);
3337
3338         /* in case this is a caching lock and reinstate with new inode */
3339         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3340
3341         lock_res_and_lock(lock);
3342         lvb_ready = !!(lock->l_flags & LDLM_FL_LVB_READY);
3343         unlock_res_and_lock(lock);
3344         /* checking lvb_ready is racy but this is okay. The worst case is
3345          * that multi processes may configure the file on the same time. */
3346         if (lvb_ready || !reconf) {
3347                 rc = -ENODATA;
3348                 if (lvb_ready) {
3349                         /* layout_gen must be valid if layout lock is not
3350                          * cancelled and stripe has already set */
3351                         *gen = lli->lli_layout_gen;
3352                         rc = 0;
3353                 }
3354                 GOTO(out, rc);
3355         }
3356
3357         rc = ll_layout_fetch(inode, lock);
3358         if (rc < 0)
3359                 GOTO(out, rc);
3360
3361         /* for layout lock, lmm is returned in lock's lvb.
3362          * lvb_data is immutable if the lock is held so it's safe to access it
3363          * without res lock. See the description in ldlm_lock_decref_internal()
3364          * for the condition to free lvb_data of layout lock */
3365         if (lock->l_lvb_data != NULL) {
3366                 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
3367                                   lock->l_lvb_data, lock->l_lvb_len);
3368                 if (rc >= 0) {
3369                         *gen = LL_LAYOUT_GEN_EMPTY;
3370                         if (md.lsm != NULL)
3371                                 *gen = md.lsm->lsm_layout_gen;
3372                         rc = 0;
3373                 } else {
3374                         CERROR("%s: file "DFID" unpackmd error: %d\n",
3375                                 ll_get_fsname(inode->i_sb, NULL, 0),
3376                                 PFID(&lli->lli_fid), rc);
3377                 }
3378         }
3379         if (rc < 0)
3380                 GOTO(out, rc);
3381
3382         /* set layout to file. Unlikely this will fail as old layout was
3383          * surely eliminated */
3384         memset(&conf, 0, sizeof conf);
3385         conf.coc_opc = OBJECT_CONF_SET;
3386         conf.coc_inode = inode;
3387         conf.coc_lock = lock;
3388         conf.u.coc_md = &md;
3389         rc = ll_layout_conf(inode, &conf);
3390
3391         if (md.lsm != NULL)
3392                 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3393
3394         /* refresh layout failed, need to wait */
3395         wait_layout = rc == -EBUSY;
3396         EXIT;
3397
3398 out:
3399         LDLM_LOCK_PUT(lock);
3400         ldlm_lock_decref(lockh, mode);
3401
3402         /* wait for IO to complete if it's still being used. */
3403         if (wait_layout) {
3404                 CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n",
3405                         ll_get_fsname(inode->i_sb, NULL, 0),
3406                         inode, PFID(&lli->lli_fid));
3407
3408                 memset(&conf, 0, sizeof conf);
3409                 conf.coc_opc = OBJECT_CONF_WAIT;
3410                 conf.coc_inode = inode;
3411                 rc = ll_layout_conf(inode, &conf);
3412                 if (rc == 0)
3413                         rc = -EAGAIN;
3414
3415                 CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n",
3416                         PFID(&lli->lli_fid), rc);
3417         }
3418         RETURN(rc);
3419 }
3420
3421 /**
3422  * This function checks if there exists a LAYOUT lock on the client side,
3423  * or enqueues it if it doesn't have one in cache.
3424  *
3425  * This function will not hold layout lock so it may be revoked any time after
3426  * this function returns. Any operations depend on layout should be redone
3427  * in that case.
3428  *
3429  * This function should be called before lov_io_init() to get an uptodate
3430  * layout version, the caller should save the version number and after IO
3431  * is finished, this function should be called again to verify that layout
3432  * is not changed during IO time.
3433  */
3434 int ll_layout_refresh(struct inode *inode, __u32 *gen)
3435 {
3436         struct ll_inode_info  *lli = ll_i2info(inode);
3437         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3438         struct md_op_data     *op_data;
3439         struct lookup_intent   it;
3440         struct lustre_handle   lockh;
3441         ldlm_mode_t            mode;
3442         struct ldlm_enqueue_info einfo = {
3443                 .ei_type = LDLM_IBITS,
3444                 .ei_mode = LCK_CR,
3445                 .ei_cb_bl = ll_md_blocking_ast,
3446                 .ei_cb_cp = ldlm_completion_ast,
3447         };
3448         int rc;
3449         ENTRY;
3450
3451         *gen = lli->lli_layout_gen;
3452         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK))
3453                 RETURN(0);
3454
3455         /* sanity checks */
3456         LASSERT(fid_is_sane(ll_inode2fid(inode)));
3457         LASSERT(S_ISREG(inode->i_mode));
3458
3459         /* mostly layout lock is caching on the local side, so try to match
3460          * it before grabbing layout lock mutex. */
3461         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3462         if (mode != 0) { /* hit cached lock */
3463                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, false);
3464                 if (rc == 0)
3465                         RETURN(0);
3466
3467                 /* better hold lli_layout_mutex to try again otherwise
3468                  * it will have starvation problem. */
3469         }
3470
3471         /* take layout lock mutex to enqueue layout lock exclusively. */
3472         mutex_lock(&lli->lli_layout_mutex);
3473
3474 again:
3475         /* try again. Maybe somebody else has done this. */
3476         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3477         if (mode != 0) { /* hit cached lock */
3478                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3479                 if (rc == -EAGAIN)
3480                         goto again;
3481
3482                 mutex_unlock(&lli->lli_layout_mutex);
3483                 RETURN(rc);
3484         }
3485
3486         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3487                         0, 0, LUSTRE_OPC_ANY, NULL);
3488         if (IS_ERR(op_data)) {
3489                 mutex_unlock(&lli->lli_layout_mutex);
3490                 RETURN(PTR_ERR(op_data));
3491         }
3492
3493         /* have to enqueue one */
3494         memset(&it, 0, sizeof(it));
3495         it.it_op = IT_LAYOUT;
3496         lockh.cookie = 0ULL;
3497
3498         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n",
3499                         ll_get_fsname(inode->i_sb, NULL, 0), inode,
3500                         PFID(&lli->lli_fid));
3501
3502         rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
3503                         NULL, 0, NULL, 0);
3504         if (it.d.lustre.it_data != NULL)
3505                 ptlrpc_req_finished(it.d.lustre.it_data);
3506         it.d.lustre.it_data = NULL;
3507
3508         ll_finish_md_op_data(op_data);
3509
3510         mode = it.d.lustre.it_lock_mode;
3511         it.d.lustre.it_lock_mode = 0;
3512         ll_intent_drop_lock(&it);
3513
3514         if (rc == 0) {
3515                 /* set lock data in case this is a new lock */
3516                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
3517                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3518                 if (rc == -EAGAIN)
3519                         goto again;
3520         }
3521         mutex_unlock(&lli->lli_layout_mutex);
3522
3523         RETURN(rc);
3524 }