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