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 (op_data != NULL) {
1971                 rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS,
1972                                    ll_i2mdexp(llss->inode1),
1973                                    sizeof(*op_data), op_data, NULL);
1974                 ll_finish_md_op_data(op_data);
1975         }
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 (op_data == NULL) {
2170                         OBD_FREE_PTR(hus);
2171                         RETURN(-ENOMEM);
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 (op_data == NULL) {
2208                         OBD_FREE_PTR(hss);
2209                         RETURN(-ENOMEM);
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 (op_data == NULL) {
2232                         OBD_FREE_PTR(hca);
2233                         RETURN(-ENOMEM);
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 = { .ei_type = LDLM_FLOCK,
2512                                            .ei_cb_cp =ldlm_flock_completion_ast,
2513                                            .ei_cbdata = file_lock };
2514         struct md_op_data *op_data;
2515         struct lustre_handle lockh = {0};
2516         ldlm_policy_data_t flock = {{0}};
2517         int flags = 0;
2518         int rc;
2519         int rc2 = 0;
2520         ENTRY;
2521
2522         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2523                inode->i_ino, file_lock);
2524
2525         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2526
2527         if (file_lock->fl_flags & FL_FLOCK) {
2528                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2529                 /* flocks are whole-file locks */
2530                 flock.l_flock.end = OFFSET_MAX;
2531                 /* For flocks owner is determined by the local file desctiptor*/
2532                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2533         } else if (file_lock->fl_flags & FL_POSIX) {
2534                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2535                 flock.l_flock.start = file_lock->fl_start;
2536                 flock.l_flock.end = file_lock->fl_end;
2537         } else {
2538                 RETURN(-EINVAL);
2539         }
2540         flock.l_flock.pid = file_lock->fl_pid;
2541
2542         /* Somewhat ugly workaround for svc lockd.
2543          * lockd installs custom fl_lmops->lm_compare_owner that checks
2544          * for the fl_owner to be the same (which it always is on local node
2545          * I guess between lockd processes) and then compares pid.
2546          * As such we assign pid to the owner field to make it all work,
2547          * conflict with normal locks is unlikely since pid space and
2548          * pointer space for current->files are not intersecting */
2549         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2550                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2551
2552         switch (file_lock->fl_type) {
2553         case F_RDLCK:
2554                 einfo.ei_mode = LCK_PR;
2555                 break;
2556         case F_UNLCK:
2557                 /* An unlock request may or may not have any relation to
2558                  * existing locks so we may not be able to pass a lock handle
2559                  * via a normal ldlm_lock_cancel() request. The request may even
2560                  * unlock a byte range in the middle of an existing lock. In
2561                  * order to process an unlock request we need all of the same
2562                  * information that is given with a normal read or write record
2563                  * lock request. To avoid creating another ldlm unlock (cancel)
2564                  * message we'll treat a LCK_NL flock request as an unlock. */
2565                 einfo.ei_mode = LCK_NL;
2566                 break;
2567         case F_WRLCK:
2568                 einfo.ei_mode = LCK_PW;
2569                 break;
2570         default:
2571                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n",
2572                         file_lock->fl_type);
2573                 RETURN (-ENOTSUPP);
2574         }
2575
2576         switch (cmd) {
2577         case F_SETLKW:
2578 #ifdef F_SETLKW64
2579         case F_SETLKW64:
2580 #endif
2581                 flags = 0;
2582                 break;
2583         case F_SETLK:
2584 #ifdef F_SETLK64
2585         case F_SETLK64:
2586 #endif
2587                 flags = LDLM_FL_BLOCK_NOWAIT;
2588                 break;
2589         case F_GETLK:
2590 #ifdef F_GETLK64
2591         case F_GETLK64:
2592 #endif
2593                 flags = LDLM_FL_TEST_LOCK;
2594                 /* Save the old mode so that if the mode in the lock changes we
2595                  * can decrement the appropriate reader or writer refcount. */
2596                 file_lock->fl_type = einfo.ei_mode;
2597                 break;
2598         default:
2599                 CERROR("unknown fcntl lock command: %d\n", cmd);
2600                 RETURN (-EINVAL);
2601         }
2602
2603         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2604                                      LUSTRE_OPC_ANY, NULL);
2605         if (IS_ERR(op_data))
2606                 RETURN(PTR_ERR(op_data));
2607
2608         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2609                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2610                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2611
2612         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2613                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2614
2615         if ((file_lock->fl_flags & FL_FLOCK) &&
2616             (rc == 0 || file_lock->fl_type == F_UNLCK))
2617                 rc2  = flock_lock_file_wait(file, file_lock);
2618         if ((file_lock->fl_flags & FL_POSIX) &&
2619             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2620             !(flags & LDLM_FL_TEST_LOCK))
2621                 rc2  = posix_lock_file_wait(file, file_lock);
2622
2623         if (rc2 && file_lock->fl_type != F_UNLCK) {
2624                 einfo.ei_mode = LCK_NL;
2625                 md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2626                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2627                 rc = rc2;
2628         }
2629
2630         ll_finish_md_op_data(op_data);
2631
2632         RETURN(rc);
2633 }
2634
2635 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2636 {
2637         ENTRY;
2638
2639         RETURN(-ENOSYS);
2640 }
2641
2642 /**
2643  * test if some locks matching bits and l_req_mode are acquired
2644  * - bits can be in different locks
2645  * - if found clear the common lock bits in *bits
2646  * - the bits not found, are kept in *bits
2647  * \param inode [IN]
2648  * \param bits [IN] searched lock bits [IN]
2649  * \param l_req_mode [IN] searched lock mode
2650  * \retval boolean, true iff all bits are found
2651  */
2652 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
2653 {
2654         struct lustre_handle lockh;
2655         ldlm_policy_data_t policy;
2656         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2657                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2658         struct lu_fid *fid;
2659         __u64 flags;
2660         int i;
2661         ENTRY;
2662
2663         if (!inode)
2664                RETURN(0);
2665
2666         fid = &ll_i2info(inode)->lli_fid;
2667         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2668                ldlm_lockname[mode]);
2669
2670         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2671         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
2672                 policy.l_inodebits.bits = *bits & (1 << i);
2673                 if (policy.l_inodebits.bits == 0)
2674                         continue;
2675
2676                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
2677                                   &policy, mode, &lockh)) {
2678                         struct ldlm_lock *lock;
2679
2680                         lock = ldlm_handle2lock(&lockh);
2681                         if (lock) {
2682                                 *bits &=
2683                                       ~(lock->l_policy_data.l_inodebits.bits);
2684                                 LDLM_LOCK_PUT(lock);
2685                         } else {
2686                                 *bits &= ~policy.l_inodebits.bits;
2687                         }
2688                 }
2689         }
2690         RETURN(*bits == 0);
2691 }
2692
2693 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2694                             struct lustre_handle *lockh, __u64 flags)
2695 {
2696         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2697         struct lu_fid *fid;
2698         ldlm_mode_t rc;
2699         ENTRY;
2700
2701         fid = &ll_i2info(inode)->lli_fid;
2702         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2703
2704         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
2705                            fid, LDLM_IBITS, &policy,
2706                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2707         RETURN(rc);
2708 }
2709
2710 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
2711 {
2712         /* Already unlinked. Just update nlink and return success */
2713         if (rc == -ENOENT) {
2714                 clear_nlink(inode);
2715                 /* This path cannot be hit for regular files unless in
2716                  * case of obscure races, so no need to to validate
2717                  * size. */
2718                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
2719                         return 0;
2720         } else if (rc != 0) {
2721                 CERROR("%s: revalidate FID "DFID" error: rc = %d\n",
2722                        ll_get_fsname(inode->i_sb, NULL, 0),
2723                        PFID(ll_inode2fid(inode)), rc);
2724         }
2725
2726         return rc;
2727 }
2728
2729 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2730                              __u64 ibits)
2731 {
2732         struct inode *inode = dentry->d_inode;
2733         struct ptlrpc_request *req = NULL;
2734         struct obd_export *exp;
2735         int rc = 0;
2736         ENTRY;
2737
2738         LASSERT(inode != NULL);
2739
2740         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2741                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2742
2743         exp = ll_i2mdexp(inode);
2744
2745         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
2746          *      But under CMD case, it caused some lock issues, should be fixed
2747          *      with new CMD ibits lock. See bug 12718 */
2748         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
2749                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2750                 struct md_op_data *op_data;
2751
2752                 if (ibits == MDS_INODELOCK_LOOKUP)
2753                         oit.it_op = IT_LOOKUP;
2754
2755                 /* Call getattr by fid, so do not provide name at all. */
2756                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2757                                              dentry->d_inode, NULL, 0, 0,
2758                                              LUSTRE_OPC_ANY, NULL);
2759                 if (IS_ERR(op_data))
2760                         RETURN(PTR_ERR(op_data));
2761
2762                 oit.it_create_mode |= M_CHECK_STALE;
2763                 rc = md_intent_lock(exp, op_data, NULL, 0,
2764                                     /* we are not interested in name
2765                                        based lookup */
2766                                     &oit, 0, &req,
2767                                     ll_md_blocking_ast, 0);
2768                 ll_finish_md_op_data(op_data);
2769                 oit.it_create_mode &= ~M_CHECK_STALE;
2770                 if (rc < 0) {
2771                         rc = ll_inode_revalidate_fini(inode, rc);
2772                         GOTO (out, rc);
2773                 }
2774
2775                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2776                 if (rc != 0) {
2777                         ll_intent_release(&oit);
2778                         GOTO(out, rc);
2779                 }
2780
2781                 /* Unlinked? Unhash dentry, so it is not picked up later by
2782                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2783                    here to preserve get_cwd functionality on 2.6.
2784                    Bug 10503 */
2785                 if (!dentry->d_inode->i_nlink)
2786                         d_lustre_invalidate(dentry, 0);
2787
2788                 ll_lookup_finish_locks(&oit, dentry);
2789         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
2790                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2791                 obd_valid valid = OBD_MD_FLGETATTR;
2792                 struct md_op_data *op_data;
2793                 int ealen = 0;
2794
2795                 if (S_ISREG(inode->i_mode)) {
2796                         rc = ll_get_max_mdsize(sbi, &ealen);
2797                         if (rc)
2798                                 RETURN(rc);
2799                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2800                 }
2801
2802                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2803                                              0, ealen, LUSTRE_OPC_ANY,
2804                                              NULL);
2805                 if (IS_ERR(op_data))
2806                         RETURN(PTR_ERR(op_data));
2807
2808                 op_data->op_valid = valid;
2809                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2810                  * capa for this inode. Because we only keep capas of dirs
2811                  * fresh. */
2812                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2813                 ll_finish_md_op_data(op_data);
2814                 if (rc) {
2815                         rc = ll_inode_revalidate_fini(inode, rc);
2816                         RETURN(rc);
2817                 }
2818
2819                 rc = ll_prep_inode(&inode, req, NULL, NULL);
2820         }
2821 out:
2822         ptlrpc_req_finished(req);
2823         return rc;
2824 }
2825
2826 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2827                            __u64 ibits)
2828 {
2829         struct inode *inode = dentry->d_inode;
2830         int rc;
2831         ENTRY;
2832
2833         rc = __ll_inode_revalidate_it(dentry, it, ibits);
2834         if (rc != 0)
2835                 RETURN(rc);
2836
2837         /* if object isn't regular file, don't validate size */
2838         if (!S_ISREG(inode->i_mode)) {
2839                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2840                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2841                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2842         } else {
2843                 rc = ll_glimpse_size(inode);
2844         }
2845         RETURN(rc);
2846 }
2847
2848 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2849                   struct lookup_intent *it, struct kstat *stat)
2850 {
2851         struct inode *inode = de->d_inode;
2852         struct ll_sb_info *sbi = ll_i2sbi(inode);
2853         struct ll_inode_info *lli = ll_i2info(inode);
2854         int res = 0;
2855
2856         res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE |
2857                                              MDS_INODELOCK_LOOKUP);
2858         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
2859
2860         if (res)
2861                 return res;
2862
2863         stat->dev = inode->i_sb->s_dev;
2864         if (ll_need_32bit_api(sbi))
2865                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
2866         else
2867                 stat->ino = inode->i_ino;
2868         stat->mode = inode->i_mode;
2869         stat->nlink = inode->i_nlink;
2870         stat->uid = inode->i_uid;
2871         stat->gid = inode->i_gid;
2872         stat->rdev = inode->i_rdev;
2873         stat->atime = inode->i_atime;
2874         stat->mtime = inode->i_mtime;
2875         stat->ctime = inode->i_ctime;
2876         stat->blksize = 1 << inode->i_blkbits;
2877
2878         stat->size = i_size_read(inode);
2879         stat->blocks = inode->i_blocks;
2880
2881         return 0;
2882 }
2883 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2884 {
2885         struct lookup_intent it = { .it_op = IT_GETATTR };
2886
2887         return ll_getattr_it(mnt, de, &it, stat);
2888 }
2889
2890 #ifdef HAVE_LINUX_FIEMAP_H
2891 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2892                 __u64 start, __u64 len)
2893 {
2894         int rc;
2895         size_t num_bytes;
2896         struct ll_user_fiemap *fiemap;
2897         unsigned int extent_count = fieinfo->fi_extents_max;
2898
2899         num_bytes = sizeof(*fiemap) + (extent_count *
2900                                        sizeof(struct ll_fiemap_extent));
2901         OBD_ALLOC_LARGE(fiemap, num_bytes);
2902
2903         if (fiemap == NULL)
2904                 RETURN(-ENOMEM);
2905
2906         fiemap->fm_flags = fieinfo->fi_flags;
2907         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2908         fiemap->fm_start = start;
2909         fiemap->fm_length = len;
2910         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2911                sizeof(struct ll_fiemap_extent));
2912
2913         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2914
2915         fieinfo->fi_flags = fiemap->fm_flags;
2916         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2917         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2918                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2919
2920         OBD_FREE_LARGE(fiemap, num_bytes);
2921         return rc;
2922 }
2923 #endif
2924
2925 struct posix_acl * ll_get_acl(struct inode *inode, int type)
2926 {
2927         struct ll_inode_info *lli = ll_i2info(inode);
2928         struct posix_acl *acl = NULL;
2929         ENTRY;
2930
2931         spin_lock(&lli->lli_lock);
2932         /* VFS' acl_permission_check->check_acl will release the refcount */
2933         acl = posix_acl_dup(lli->lli_posix_acl);
2934         spin_unlock(&lli->lli_lock);
2935
2936         RETURN(acl);
2937 }
2938
2939 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
2940 static int
2941 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
2942 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
2943 # else
2944 ll_check_acl(struct inode *inode, int mask)
2945 # endif
2946 {
2947 # ifdef CONFIG_FS_POSIX_ACL
2948         struct posix_acl *acl;
2949         int rc;
2950         ENTRY;
2951
2952 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
2953         if (flags & IPERM_FLAG_RCU)
2954                 return -ECHILD;
2955 #  endif
2956         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
2957
2958         if (!acl)
2959                 RETURN(-EAGAIN);
2960
2961         rc = posix_acl_permission(inode, acl, mask);
2962         posix_acl_release(acl);
2963
2964         RETURN(rc);
2965 # else /* !CONFIG_FS_POSIX_ACL */
2966         return -EAGAIN;
2967 # endif /* CONFIG_FS_POSIX_ACL */
2968 }
2969 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
2970
2971 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
2972 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
2973 #else
2974 # ifdef HAVE_INODE_PERMISION_2ARGS
2975 int ll_inode_permission(struct inode *inode, int mask)
2976 # else
2977 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2978 # endif
2979 #endif
2980 {
2981         int rc = 0;
2982         ENTRY;
2983
2984 #ifdef MAY_NOT_BLOCK
2985         if (mask & MAY_NOT_BLOCK)
2986                 return -ECHILD;
2987 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
2988         if (flags & IPERM_FLAG_RCU)
2989                 return -ECHILD;
2990 #endif
2991
2992        /* as root inode are NOT getting validated in lookup operation,
2993         * need to do it before permission check. */
2994
2995         if (inode == inode->i_sb->s_root->d_inode) {
2996                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2997
2998                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2999                                               MDS_INODELOCK_LOOKUP);
3000                 if (rc)
3001                         RETURN(rc);
3002         }
3003
3004         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
3005                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
3006
3007         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
3008                 return lustre_check_remote_perm(inode, mask);
3009
3010         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
3011         rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3012
3013         RETURN(rc);
3014 }
3015
3016 #ifdef HAVE_FILE_READV
3017 #define READ_METHOD readv
3018 #define READ_FUNCTION ll_file_readv
3019 #define WRITE_METHOD writev
3020 #define WRITE_FUNCTION ll_file_writev
3021 #else
3022 #define READ_METHOD aio_read
3023 #define READ_FUNCTION ll_file_aio_read
3024 #define WRITE_METHOD aio_write
3025 #define WRITE_FUNCTION ll_file_aio_write
3026 #endif
3027
3028 /* -o localflock - only provides locally consistent flock locks */
3029 struct file_operations ll_file_operations = {
3030         .read           = ll_file_read,
3031         .READ_METHOD    = READ_FUNCTION,
3032         .write          = ll_file_write,
3033         .WRITE_METHOD   = WRITE_FUNCTION,
3034         .unlocked_ioctl = ll_file_ioctl,
3035         .open           = ll_file_open,
3036         .release        = ll_file_release,
3037         .mmap           = ll_file_mmap,
3038         .llseek         = ll_file_seek,
3039 #ifdef HAVE_KERNEL_SENDFILE
3040         .sendfile       = ll_file_sendfile,
3041 #endif
3042 #ifdef HAVE_KERNEL_SPLICE_READ
3043         .splice_read    = ll_file_splice_read,
3044 #endif
3045         .fsync          = ll_fsync,
3046         .flush          = ll_flush
3047 };
3048
3049 struct file_operations ll_file_operations_flock = {
3050         .read           = ll_file_read,
3051         .READ_METHOD    = READ_FUNCTION,
3052         .write          = ll_file_write,
3053         .WRITE_METHOD   = WRITE_FUNCTION,
3054         .unlocked_ioctl = ll_file_ioctl,
3055         .open           = ll_file_open,
3056         .release        = ll_file_release,
3057         .mmap           = ll_file_mmap,
3058         .llseek         = ll_file_seek,
3059 #ifdef HAVE_KERNEL_SENDFILE
3060         .sendfile       = ll_file_sendfile,
3061 #endif
3062 #ifdef HAVE_KERNEL_SPLICE_READ
3063         .splice_read    = ll_file_splice_read,
3064 #endif
3065         .fsync          = ll_fsync,
3066         .flush          = ll_flush,
3067         .flock          = ll_file_flock,
3068         .lock           = ll_file_flock
3069 };
3070
3071 /* These are for -o noflock - to return ENOSYS on flock calls */
3072 struct file_operations ll_file_operations_noflock = {
3073         .read           = ll_file_read,
3074         .READ_METHOD    = READ_FUNCTION,
3075         .write          = ll_file_write,
3076         .WRITE_METHOD   = WRITE_FUNCTION,
3077         .unlocked_ioctl = ll_file_ioctl,
3078         .open           = ll_file_open,
3079         .release        = ll_file_release,
3080         .mmap           = ll_file_mmap,
3081         .llseek         = ll_file_seek,
3082 #ifdef HAVE_KERNEL_SENDFILE
3083         .sendfile       = ll_file_sendfile,
3084 #endif
3085 #ifdef HAVE_KERNEL_SPLICE_READ
3086         .splice_read    = ll_file_splice_read,
3087 #endif
3088         .fsync          = ll_fsync,
3089         .flush          = ll_flush,
3090         .flock          = ll_file_noflock,
3091         .lock           = ll_file_noflock
3092 };
3093
3094 struct inode_operations ll_file_inode_operations = {
3095         .setattr        = ll_setattr,
3096         .getattr        = ll_getattr,
3097         .permission     = ll_inode_permission,
3098         .setxattr       = ll_setxattr,
3099         .getxattr       = ll_getxattr,
3100         .listxattr      = ll_listxattr,
3101         .removexattr    = ll_removexattr,
3102 #ifdef  HAVE_LINUX_FIEMAP_H
3103         .fiemap         = ll_fiemap,
3104 #endif
3105 #ifdef HAVE_IOP_GET_ACL
3106         .get_acl        = ll_get_acl,
3107 #endif
3108 };
3109
3110 /* dynamic ioctl number support routins */
3111 static struct llioc_ctl_data {
3112         struct rw_semaphore     ioc_sem;
3113         cfs_list_t              ioc_head;
3114 } llioc = {
3115         __RWSEM_INITIALIZER(llioc.ioc_sem),
3116         CFS_LIST_HEAD_INIT(llioc.ioc_head)
3117 };
3118
3119
3120 struct llioc_data {
3121         cfs_list_t              iocd_list;
3122         unsigned int            iocd_size;
3123         llioc_callback_t        iocd_cb;
3124         unsigned int            iocd_count;
3125         unsigned int            iocd_cmd[0];
3126 };
3127
3128 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3129 {
3130         unsigned int size;
3131         struct llioc_data *in_data = NULL;
3132         ENTRY;
3133
3134         if (cb == NULL || cmd == NULL ||
3135             count > LLIOC_MAX_CMD || count < 0)
3136                 RETURN(NULL);
3137
3138         size = sizeof(*in_data) + count * sizeof(unsigned int);
3139         OBD_ALLOC(in_data, size);
3140         if (in_data == NULL)
3141                 RETURN(NULL);
3142
3143         memset(in_data, 0, sizeof(*in_data));
3144         in_data->iocd_size = size;
3145         in_data->iocd_cb = cb;
3146         in_data->iocd_count = count;
3147         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3148
3149         down_write(&llioc.ioc_sem);
3150         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3151         up_write(&llioc.ioc_sem);
3152
3153         RETURN(in_data);
3154 }
3155
3156 void ll_iocontrol_unregister(void *magic)
3157 {
3158         struct llioc_data *tmp;
3159
3160         if (magic == NULL)
3161                 return;
3162
3163         down_write(&llioc.ioc_sem);
3164         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3165                 if (tmp == magic) {
3166                         unsigned int size = tmp->iocd_size;
3167
3168                         cfs_list_del(&tmp->iocd_list);
3169                         up_write(&llioc.ioc_sem);
3170
3171                         OBD_FREE(tmp, size);
3172                         return;
3173                 }
3174         }
3175         up_write(&llioc.ioc_sem);
3176
3177         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3178 }
3179
3180 EXPORT_SYMBOL(ll_iocontrol_register);
3181 EXPORT_SYMBOL(ll_iocontrol_unregister);
3182
3183 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
3184                         unsigned int cmd, unsigned long arg, int *rcp)
3185 {
3186         enum llioc_iter ret = LLIOC_CONT;
3187         struct llioc_data *data;
3188         int rc = -EINVAL, i;
3189
3190         down_read(&llioc.ioc_sem);
3191         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3192                 for (i = 0; i < data->iocd_count; i++) {
3193                         if (cmd != data->iocd_cmd[i])
3194                                 continue;
3195
3196                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3197                         break;
3198                 }
3199
3200                 if (ret == LLIOC_STOP)
3201                         break;
3202         }
3203         up_read(&llioc.ioc_sem);
3204
3205         if (rcp)
3206                 *rcp = rc;
3207         return ret;
3208 }
3209
3210 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3211 {
3212         struct ll_inode_info *lli = ll_i2info(inode);
3213         struct cl_env_nest nest;
3214         struct lu_env *env;
3215         int result;
3216         ENTRY;
3217
3218         if (lli->lli_clob == NULL)
3219                 RETURN(0);
3220
3221         env = cl_env_nested_get(&nest);
3222         if (IS_ERR(env))
3223                 RETURN(PTR_ERR(env));
3224
3225         result = cl_conf_set(env, lli->lli_clob, conf);
3226         cl_env_nested_put(&nest, env);
3227
3228         if (conf->coc_opc == OBJECT_CONF_SET) {
3229                 struct ldlm_lock *lock = conf->coc_lock;
3230
3231                 LASSERT(lock != NULL);
3232                 LASSERT(ldlm_has_layout(lock));
3233                 if (result == 0) {
3234                         /* it can only be allowed to match after layout is
3235                          * applied to inode otherwise false layout would be
3236                          * seen. Applying layout shoud happen before dropping
3237                          * the intent lock. */
3238                         ldlm_lock_allow_match(lock);
3239                 }
3240         }
3241         RETURN(result);
3242 }
3243
3244 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3245 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3246
3247 {
3248         struct ll_sb_info *sbi = ll_i2sbi(inode);
3249         struct obd_capa *oc;
3250         struct ptlrpc_request *req;
3251         struct mdt_body *body;
3252         void *lvbdata;
3253         void *lmm;
3254         int lmmsize;
3255         int rc;
3256         ENTRY;
3257
3258         if (lock->l_lvb_data != NULL)
3259                 RETURN(0);
3260
3261         /* if layout lock was granted right away, the layout is returned
3262          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3263          * blocked and then granted via completion ast, we have to fetch
3264          * layout here. Please note that we can't use the LVB buffer in
3265          * completion AST because it doesn't have a large enough buffer */
3266         oc = ll_mdscapa_get(inode);
3267         rc = ll_get_max_mdsize(sbi, &lmmsize);
3268         if (rc == 0)
3269                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
3270                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3271                                 lmmsize, 0, &req);
3272         capa_put(oc);
3273         if (rc < 0)
3274                 RETURN(rc);
3275
3276         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3277         if (body == NULL || body->eadatasize > lmmsize)
3278                 GOTO(out, rc = -EPROTO);
3279
3280         lmmsize = body->eadatasize;
3281         if (lmmsize == 0) /* empty layout */
3282                 GOTO(out, rc = 0);
3283
3284         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3285         if (lmm == NULL)
3286                 GOTO(out, rc = -EFAULT);
3287
3288         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3289         if (lvbdata == NULL)
3290                 GOTO(out, rc = -ENOMEM);
3291
3292         memcpy(lvbdata, lmm, lmmsize);
3293         lock_res_and_lock(lock);
3294         if (lock->l_lvb_data == NULL) {
3295                 lock->l_lvb_data = lvbdata;
3296                 lock->l_lvb_len = lmmsize;
3297                 lvbdata = NULL;
3298         }
3299         unlock_res_and_lock(lock);
3300
3301         if (lvbdata != NULL)
3302                 OBD_FREE_LARGE(lvbdata, lmmsize);
3303         EXIT;
3304
3305 out:
3306         ptlrpc_req_finished(req);
3307         return rc;
3308 }
3309
3310 /**
3311  * Apply the layout to the inode. Layout lock is held and will be released
3312  * in this function.
3313  */
3314 static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
3315                                 struct inode *inode, __u32 *gen, bool reconf)
3316 {
3317         struct ll_inode_info *lli = ll_i2info(inode);
3318         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3319         struct ldlm_lock *lock;
3320         struct lustre_md md = { NULL };
3321         struct cl_object_conf conf;
3322         int rc = 0;
3323         bool lvb_ready;
3324         bool wait_layout = false;
3325         ENTRY;
3326
3327         LASSERT(lustre_handle_is_used(lockh));
3328
3329         lock = ldlm_handle2lock(lockh);
3330         LASSERT(lock != NULL);
3331         LASSERT(ldlm_has_layout(lock));
3332
3333         LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n",
3334                 inode, PFID(&lli->lli_fid), reconf);
3335
3336         /* in case this is a caching lock and reinstate with new inode */
3337         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3338
3339         lock_res_and_lock(lock);
3340         lvb_ready = !!(lock->l_flags & LDLM_FL_LVB_READY);
3341         unlock_res_and_lock(lock);
3342         /* checking lvb_ready is racy but this is okay. The worst case is
3343          * that multi processes may configure the file on the same time. */
3344         if (lvb_ready || !reconf) {
3345                 rc = -ENODATA;
3346                 if (lvb_ready) {
3347                         /* layout_gen must be valid if layout lock is not
3348                          * cancelled and stripe has already set */
3349                         *gen = lli->lli_layout_gen;
3350                         rc = 0;
3351                 }
3352                 GOTO(out, rc);
3353         }
3354
3355         rc = ll_layout_fetch(inode, lock);
3356         if (rc < 0)
3357                 GOTO(out, rc);
3358
3359         /* for layout lock, lmm is returned in lock's lvb.
3360          * lvb_data is immutable if the lock is held so it's safe to access it
3361          * without res lock. See the description in ldlm_lock_decref_internal()
3362          * for the condition to free lvb_data of layout lock */
3363         if (lock->l_lvb_data != NULL) {
3364                 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
3365                                   lock->l_lvb_data, lock->l_lvb_len);
3366                 if (rc >= 0) {
3367                         *gen = LL_LAYOUT_GEN_EMPTY;
3368                         if (md.lsm != NULL)
3369                                 *gen = md.lsm->lsm_layout_gen;
3370                         rc = 0;
3371                 } else {
3372                         CERROR("%s: file "DFID" unpackmd error: %d\n",
3373                                 ll_get_fsname(inode->i_sb, NULL, 0),
3374                                 PFID(&lli->lli_fid), rc);
3375                 }
3376         }
3377         if (rc < 0)
3378                 GOTO(out, rc);
3379
3380         /* set layout to file. Unlikely this will fail as old layout was
3381          * surely eliminated */
3382         memset(&conf, 0, sizeof conf);
3383         conf.coc_opc = OBJECT_CONF_SET;
3384         conf.coc_inode = inode;
3385         conf.coc_lock = lock;
3386         conf.u.coc_md = &md;
3387         rc = ll_layout_conf(inode, &conf);
3388
3389         if (md.lsm != NULL)
3390                 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3391
3392         /* refresh layout failed, need to wait */
3393         wait_layout = rc == -EBUSY;
3394         EXIT;
3395
3396 out:
3397         LDLM_LOCK_PUT(lock);
3398         ldlm_lock_decref(lockh, mode);
3399
3400         /* wait for IO to complete if it's still being used. */
3401         if (wait_layout) {
3402                 CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n",
3403                         ll_get_fsname(inode->i_sb, NULL, 0),
3404                         inode, PFID(&lli->lli_fid));
3405
3406                 memset(&conf, 0, sizeof conf);
3407                 conf.coc_opc = OBJECT_CONF_WAIT;
3408                 conf.coc_inode = inode;
3409                 rc = ll_layout_conf(inode, &conf);
3410                 if (rc == 0)
3411                         rc = -EAGAIN;
3412
3413                 CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n",
3414                         PFID(&lli->lli_fid), rc);
3415         }
3416         RETURN(rc);
3417 }
3418
3419 /**
3420  * This function checks if there exists a LAYOUT lock on the client side,
3421  * or enqueues it if it doesn't have one in cache.
3422  *
3423  * This function will not hold layout lock so it may be revoked any time after
3424  * this function returns. Any operations depend on layout should be redone
3425  * in that case.
3426  *
3427  * This function should be called before lov_io_init() to get an uptodate
3428  * layout version, the caller should save the version number and after IO
3429  * is finished, this function should be called again to verify that layout
3430  * is not changed during IO time.
3431  */
3432 int ll_layout_refresh(struct inode *inode, __u32 *gen)
3433 {
3434         struct ll_inode_info  *lli = ll_i2info(inode);
3435         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3436         struct md_op_data     *op_data;
3437         struct lookup_intent   it;
3438         struct lustre_handle   lockh;
3439         ldlm_mode_t            mode;
3440         struct ldlm_enqueue_info einfo = { .ei_type = LDLM_IBITS,
3441                                            .ei_mode = LCK_CR,
3442                                            .ei_cb_bl = ll_md_blocking_ast,
3443                                            .ei_cb_cp = ldlm_completion_ast,
3444                                            .ei_cbdata = NULL };
3445         int rc;
3446         ENTRY;
3447
3448         *gen = lli->lli_layout_gen;
3449         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK))
3450                 RETURN(0);
3451
3452         /* sanity checks */
3453         LASSERT(fid_is_sane(ll_inode2fid(inode)));
3454         LASSERT(S_ISREG(inode->i_mode));
3455
3456         /* mostly layout lock is caching on the local side, so try to match
3457          * it before grabbing layout lock mutex. */
3458         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3459         if (mode != 0) { /* hit cached lock */
3460                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, false);
3461                 if (rc == 0)
3462                         RETURN(0);
3463
3464                 /* better hold lli_layout_mutex to try again otherwise
3465                  * it will have starvation problem. */
3466         }
3467
3468         /* take layout lock mutex to enqueue layout lock exclusively. */
3469         mutex_lock(&lli->lli_layout_mutex);
3470
3471 again:
3472         /* try again. Maybe somebody else has done this. */
3473         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3474         if (mode != 0) { /* hit cached lock */
3475                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3476                 if (rc == -EAGAIN)
3477                         goto again;
3478
3479                 mutex_unlock(&lli->lli_layout_mutex);
3480                 RETURN(rc);
3481         }
3482
3483         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3484                         0, 0, LUSTRE_OPC_ANY, NULL);
3485         if (IS_ERR(op_data)) {
3486                 mutex_unlock(&lli->lli_layout_mutex);
3487                 RETURN(PTR_ERR(op_data));
3488         }
3489
3490         /* have to enqueue one */
3491         memset(&it, 0, sizeof(it));
3492         it.it_op = IT_LAYOUT;
3493         lockh.cookie = 0ULL;
3494
3495         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n",
3496                         ll_get_fsname(inode->i_sb, NULL, 0), inode,
3497                         PFID(&lli->lli_fid));
3498
3499         rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
3500                         NULL, 0, NULL, 0);
3501         if (it.d.lustre.it_data != NULL)
3502                 ptlrpc_req_finished(it.d.lustre.it_data);
3503         it.d.lustre.it_data = NULL;
3504
3505         ll_finish_md_op_data(op_data);
3506
3507         mode = it.d.lustre.it_lock_mode;
3508         it.d.lustre.it_lock_mode = 0;
3509         ll_intent_drop_lock(&it);
3510
3511         if (rc == 0) {
3512                 /* set lock data in case this is a new lock */
3513                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
3514                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3515                 if (rc == -EAGAIN)
3516                         goto again;
3517         }
3518         mutex_unlock(&lli->lli_layout_mutex);
3519
3520         RETURN(rc);
3521 }