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