lustre/llite/file.c

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