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_GETNAME: {
1853                 struct obd_device *obd =
1854                                 class_exp2obd(ll_i2sbi(inode)->ll_dt_exp);
1855                 if (!obd)
1856                         RETURN(-EFAULT);
1857                 if (cfs_copy_to_user((void *)arg, obd->obd_name,
1858                                      strlen(obd->obd_name) + 1))
1859                         RETURN(-EFAULT);
1860                 RETURN(0);
1861         }
1862
1863         default: {
1864                 int err;
1865
1866                 if (LLIOC_STOP ==
1867                     ll_iocontrol_call(inode, file, cmd, arg, &err))
1868                         RETURN(err);
1869
1870                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
1871                                      (void *)arg));
1872         }
1873         }
1874 }
1875
1876 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
1877 {
1878         struct inode *inode = file->f_dentry->d_inode;
1879         loff_t retval;
1880         ENTRY;
1881         retval = offset + ((origin == 2) ? i_size_read(inode) :
1882                            (origin == 1) ? file->f_pos : 0);
1883         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%s)\n",
1884                inode->i_ino, inode->i_generation, inode, retval, retval,
1885                origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
1886         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
1887
1888         if (origin == 2) { /* SEEK_END */
1889                 int rc;
1890
1891                 rc = ll_glimpse_size(inode);
1892                 if (rc != 0)
1893                         RETURN(rc);
1894
1895                 offset += i_size_read(inode);
1896         } else if (origin == 1) { /* SEEK_CUR */
1897                 offset += file->f_pos;
1898         }
1899
1900         retval = -EINVAL;
1901         if (offset >= 0 && offset <= ll_file_maxbytes(inode)) {
1902                 if (offset != file->f_pos) {
1903                         file->f_pos = offset;
1904                 }
1905                 retval = offset;
1906         }
1907
1908         RETURN(retval);
1909 }
1910
1911 #ifdef HAVE_FLUSH_OWNER_ID
1912 int ll_flush(struct file *file, fl_owner_t id)
1913 #else
1914 int ll_flush(struct file *file)
1915 #endif
1916 {
1917         struct inode *inode = file->f_dentry->d_inode;
1918         struct ll_inode_info *lli = ll_i2info(inode);
1919         struct lov_stripe_md *lsm = lli->lli_smd;
1920         int rc, err;
1921
1922         LASSERT(!S_ISDIR(inode->i_mode));
1923
1924         /* the application should know write failure already. */
1925         if (lli->lli_write_rc)
1926                 return 0;
1927
1928         /* catch async errors that were recorded back when async writeback
1929          * failed for pages in this mapping. */
1930         rc = lli->lli_async_rc;
1931         lli->lli_async_rc = 0;
1932         if (lsm) {
1933                 err = lov_test_and_clear_async_rc(lsm);
1934                 if (rc == 0)
1935                         rc = err;
1936         }
1937
1938         return rc ? -EIO : 0;
1939 }
1940
1941 int ll_fsync(struct file *file, struct dentry *dentry, int data)
1942 {
1943         struct inode *inode = dentry->d_inode;
1944         struct ll_inode_info *lli = ll_i2info(inode);
1945         struct lov_stripe_md *lsm = lli->lli_smd;
1946         struct ptlrpc_request *req;
1947         struct obd_capa *oc;
1948         int rc, err;
1949         ENTRY;
1950         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
1951                inode->i_generation, inode);
1952         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
1953
1954         /* fsync's caller has already called _fdata{sync,write}, we want
1955          * that IO to finish before calling the osc and mdc sync methods */
1956         rc = filemap_fdatawait(inode->i_mapping);
1957
1958         /* catch async errors that were recorded back when async writeback
1959          * failed for pages in this mapping. */
1960         if (!S_ISDIR(inode->i_mode)) {
1961                 err = lli->lli_async_rc;
1962                 lli->lli_async_rc = 0;
1963                 if (rc == 0)
1964                         rc = err;
1965                 if (lsm) {
1966                         err = lov_test_and_clear_async_rc(lsm);
1967                         if (rc == 0)
1968                                 rc = err;
1969                 }
1970         }
1971
1972         oc = ll_mdscapa_get(inode);
1973         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
1974                       &req);
1975         capa_put(oc);
1976         if (!rc)
1977                 rc = err;
1978         if (!err)
1979                 ptlrpc_req_finished(req);
1980
1981         if (data && lsm) {
1982                 struct obd_info *oinfo;
1983
1984                 OBD_ALLOC_PTR(oinfo);
1985                 if (!oinfo)
1986                         RETURN(rc ? rc : -ENOMEM);
1987                 OBDO_ALLOC(oinfo->oi_oa);
1988                 if (!oinfo->oi_oa) {
1989                         OBD_FREE_PTR(oinfo);
1990                         RETURN(rc ? rc : -ENOMEM);
1991                 }
1992                 oinfo->oi_oa->o_id = lsm->lsm_object_id;
1993                 oinfo->oi_oa->o_seq = lsm->lsm_object_seq;
1994                 oinfo->oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1995                 obdo_from_inode(oinfo->oi_oa, inode, &ll_i2info(inode)->lli_fid,
1996                                 OBD_MD_FLTYPE | OBD_MD_FLATIME |
1997                                 OBD_MD_FLMTIME | OBD_MD_FLCTIME |
1998                                 OBD_MD_FLGROUP);
1999                 oinfo->oi_md = lsm;
2000                 oinfo->oi_capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2001                 err = obd_sync_rqset(ll_i2sbi(inode)->ll_dt_exp, oinfo, 0,
2002                                      OBD_OBJECT_EOF);
2003                 capa_put(oinfo->oi_capa);
2004                 if (!rc)
2005                         rc = err;
2006                 OBDO_FREE(oinfo->oi_oa);
2007                 OBD_FREE_PTR(oinfo);
2008                 lli->lli_write_rc = rc < 0 ? rc : 0;
2009         }
2010
2011         RETURN(rc);
2012 }
2013
2014 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2015 {
2016         struct inode *inode = file->f_dentry->d_inode;
2017         struct ll_sb_info *sbi = ll_i2sbi(inode);
2018         struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK,
2019                                            .ei_cb_cp =ldlm_flock_completion_ast,
2020                                            .ei_cbdata = file_lock };
2021         struct md_op_data *op_data;
2022         struct lustre_handle lockh = {0};
2023         ldlm_policy_data_t flock = {{0}};
2024         int flags = 0;
2025         int rc;
2026         ENTRY;
2027
2028         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2029                inode->i_ino, file_lock);
2030
2031         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2032
2033         if (file_lock->fl_flags & FL_FLOCK) {
2034                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2035                 /* flocks are whole-file locks */
2036                 flock.l_flock.end = OFFSET_MAX;
2037                 /* For flocks owner is determined by the local file desctiptor*/
2038                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2039         } else if (file_lock->fl_flags & FL_POSIX) {
2040                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2041                 flock.l_flock.start = file_lock->fl_start;
2042                 flock.l_flock.end = file_lock->fl_end;
2043         } else {
2044                 RETURN(-EINVAL);
2045         }
2046         flock.l_flock.pid = file_lock->fl_pid;
2047
2048         /* Somewhat ugly workaround for svc lockd.
2049          * lockd installs custom fl_lmops->fl_compare_owner that checks
2050          * for the fl_owner to be the same (which it always is on local node
2051          * I guess between lockd processes) and then compares pid.
2052          * As such we assign pid to the owner field to make it all work,
2053          * conflict with normal locks is unlikely since pid space and
2054          * pointer space for current->files are not intersecting */
2055         if (file_lock->fl_lmops && file_lock->fl_lmops->fl_compare_owner)
2056                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2057
2058         switch (file_lock->fl_type) {
2059         case F_RDLCK:
2060                 einfo.ei_mode = LCK_PR;
2061                 break;
2062         case F_UNLCK:
2063                 /* An unlock request may or may not have any relation to
2064                  * existing locks so we may not be able to pass a lock handle
2065                  * via a normal ldlm_lock_cancel() request. The request may even
2066                  * unlock a byte range in the middle of an existing lock. In
2067                  * order to process an unlock request we need all of the same
2068                  * information that is given with a normal read or write record
2069                  * lock request. To avoid creating another ldlm unlock (cancel)
2070                  * message we'll treat a LCK_NL flock request as an unlock. */
2071                 einfo.ei_mode = LCK_NL;
2072                 break;
2073         case F_WRLCK:
2074                 einfo.ei_mode = LCK_PW;
2075                 break;
2076         default:
2077                 CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
2078                 RETURN (-EINVAL);
2079         }
2080
2081         switch (cmd) {
2082         case F_SETLKW:
2083 #ifdef F_SETLKW64
2084         case F_SETLKW64:
2085 #endif
2086                 flags = 0;
2087                 break;
2088         case F_SETLK:
2089 #ifdef F_SETLK64
2090         case F_SETLK64:
2091 #endif
2092                 flags = LDLM_FL_BLOCK_NOWAIT;
2093                 break;
2094         case F_GETLK:
2095 #ifdef F_GETLK64
2096         case F_GETLK64:
2097 #endif
2098                 flags = LDLM_FL_TEST_LOCK;
2099                 /* Save the old mode so that if the mode in the lock changes we
2100                  * can decrement the appropriate reader or writer refcount. */
2101                 file_lock->fl_type = einfo.ei_mode;
2102                 break;
2103         default:
2104                 CERROR("unknown fcntl lock command: %d\n", cmd);
2105                 RETURN (-EINVAL);
2106         }
2107
2108         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2109                                      LUSTRE_OPC_ANY, NULL);
2110         if (IS_ERR(op_data))
2111                 RETURN(PTR_ERR(op_data));
2112
2113         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2114                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2115                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2116
2117         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2118                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2119
2120         ll_finish_md_op_data(op_data);
2121
2122         if ((file_lock->fl_flags & FL_FLOCK) &&
2123             (rc == 0 || file_lock->fl_type == F_UNLCK))
2124                 ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
2125 #ifdef HAVE_F_OP_FLOCK
2126         if ((file_lock->fl_flags & FL_POSIX) &&
2127             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2128             !(flags & LDLM_FL_TEST_LOCK))
2129                 posix_lock_file_wait(file, file_lock);
2130 #endif
2131
2132         RETURN(rc);
2133 }
2134
2135 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2136 {
2137         ENTRY;
2138
2139         RETURN(-ENOSYS);
2140 }
2141
2142 /**
2143  * test if some locks matching bits and l_req_mode are acquired
2144  * - bits can be in different locks
2145  * - if found clear the common lock bits in *bits
2146  * - the bits not found, are kept in *bits
2147  * \param inode [IN]
2148  * \param bits [IN] searched lock bits [IN]
2149  * \param l_req_mode [IN] searched lock mode
2150  * \retval boolean, true iff all bits are found
2151  */
2152 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
2153 {
2154         struct lustre_handle lockh;
2155         ldlm_policy_data_t policy;
2156         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2157                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2158         struct lu_fid *fid;
2159         int flags;
2160         int i;
2161         ENTRY;
2162
2163         if (!inode)
2164                RETURN(0);
2165
2166         fid = &ll_i2info(inode)->lli_fid;
2167         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2168                ldlm_lockname[mode]);
2169
2170         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2171         for (i = 0; i < MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
2172                 policy.l_inodebits.bits = *bits & (1 << i);
2173                 if (policy.l_inodebits.bits == 0)
2174                         continue;
2175
2176                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
2177                                   &policy, mode, &lockh)) {
2178                         struct ldlm_lock *lock;
2179
2180                         lock = ldlm_handle2lock(&lockh);
2181                         if (lock) {
2182                                 *bits &=
2183                                       ~(lock->l_policy_data.l_inodebits.bits);
2184                                 LDLM_LOCK_PUT(lock);
2185                         } else {
2186                                 *bits &= ~policy.l_inodebits.bits;
2187                         }
2188                 }
2189         }
2190         RETURN(*bits == 0);
2191 }
2192
2193 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2194                             struct lustre_handle *lockh)
2195 {
2196         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2197         struct lu_fid *fid;
2198         ldlm_mode_t rc;
2199         int flags;
2200         ENTRY;
2201
2202         fid = &ll_i2info(inode)->lli_fid;
2203         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2204
2205         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING;
2206         rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2207                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2208         RETURN(rc);
2209 }
2210
2211 static int ll_inode_revalidate_fini(struct inode *inode, int rc) {
2212         if (rc == -ENOENT) { /* Already unlinked. Just update nlink
2213                               * and return success */
2214                 inode->i_nlink = 0;
2215                 /* This path cannot be hit for regular files unless in
2216                  * case of obscure races, so no need to to validate
2217                  * size. */
2218                 if (!S_ISREG(inode->i_mode) &&
2219                     !S_ISDIR(inode->i_mode))
2220                         return 0;
2221         }
2222
2223         if (rc) {
2224                 CERROR("failure %d inode %lu\n", rc, inode->i_ino);
2225                 return -abs(rc);
2226
2227         }
2228
2229         return 0;
2230 }
2231
2232 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2233                              __u64 ibits)
2234 {
2235         struct inode *inode = dentry->d_inode;
2236         struct ptlrpc_request *req = NULL;
2237         struct obd_export *exp;
2238         int rc = 0;
2239         ENTRY;
2240
2241         if (!inode) {
2242                 CERROR("REPORT THIS LINE TO PETER\n");
2243                 RETURN(0);
2244         }
2245
2246         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2247                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2248
2249         exp = ll_i2mdexp(inode);
2250
2251         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
2252          *      But under CMD case, it caused some lock issues, should be fixed
2253          *      with new CMD ibits lock. See bug 12718 */
2254         if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) {
2255                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2256                 struct md_op_data *op_data;
2257
2258                 if (ibits == MDS_INODELOCK_LOOKUP)
2259                         oit.it_op = IT_LOOKUP;
2260
2261                 /* Call getattr by fid, so do not provide name at all. */
2262                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2263                                              dentry->d_inode, NULL, 0, 0,
2264                                              LUSTRE_OPC_ANY, NULL);
2265                 if (IS_ERR(op_data))
2266                         RETURN(PTR_ERR(op_data));
2267
2268                 oit.it_create_mode |= M_CHECK_STALE;
2269                 rc = md_intent_lock(exp, op_data, NULL, 0,
2270                                     /* we are not interested in name
2271                                        based lookup */
2272                                     &oit, 0, &req,
2273                                     ll_md_blocking_ast, 0);
2274                 ll_finish_md_op_data(op_data);
2275                 oit.it_create_mode &= ~M_CHECK_STALE;
2276                 if (rc < 0) {
2277                         rc = ll_inode_revalidate_fini(inode, rc);
2278                         GOTO (out, rc);
2279                 }
2280
2281                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2282                 if (rc != 0) {
2283                         ll_intent_release(&oit);
2284                         GOTO(out, rc);
2285                 }
2286
2287                 /* Unlinked? Unhash dentry, so it is not picked up later by
2288                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2289                    here to preserve get_cwd functionality on 2.6.
2290                    Bug 10503 */
2291                 if (!dentry->d_inode->i_nlink) {
2292                         cfs_spin_lock(&ll_lookup_lock);
2293                         spin_lock(&dcache_lock);
2294                         ll_drop_dentry(dentry);
2295                         spin_unlock(&dcache_lock);
2296                         cfs_spin_unlock(&ll_lookup_lock);
2297                 }
2298
2299                 ll_lookup_finish_locks(&oit, dentry);
2300         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
2301                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2302                 obd_valid valid = OBD_MD_FLGETATTR;
2303                 struct md_op_data *op_data;
2304                 int ealen = 0;
2305
2306                 if (S_ISREG(inode->i_mode)) {
2307                         rc = ll_get_max_mdsize(sbi, &ealen);
2308                         if (rc)
2309                                 RETURN(rc);
2310                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2311                 }
2312
2313                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2314                                              0, ealen, LUSTRE_OPC_ANY,
2315                                              NULL);
2316                 if (IS_ERR(op_data))
2317                         RETURN(PTR_ERR(op_data));
2318
2319                 op_data->op_valid = valid;
2320                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2321                  * capa for this inode. Because we only keep capas of dirs
2322                  * fresh. */
2323                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2324                 ll_finish_md_op_data(op_data);
2325                 if (rc) {
2326                         rc = ll_inode_revalidate_fini(inode, rc);
2327                         RETURN(rc);
2328                 }
2329
2330                 rc = ll_prep_inode(&inode, req, NULL);
2331         }
2332 out:
2333         ptlrpc_req_finished(req);
2334         return rc;
2335 }
2336
2337 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2338                            __u64 ibits)
2339 {
2340         struct inode *inode = dentry->d_inode;
2341         int rc;
2342         ENTRY;
2343
2344         rc = __ll_inode_revalidate_it(dentry, it, ibits);
2345
2346         /* if object not yet allocated, don't validate size */
2347         if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) {
2348                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2349                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2350                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2351                 RETURN(0);
2352         }
2353
2354         /* ll_glimpse_size will prefer locally cached writes if they extend
2355          * the file */
2356
2357         if (rc == 0)
2358                 rc = ll_glimpse_size(inode);
2359
2360         RETURN(rc);
2361 }
2362
2363 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2364                   struct lookup_intent *it, struct kstat *stat)
2365 {
2366         struct inode *inode = de->d_inode;
2367         struct ll_sb_info *sbi = ll_i2sbi(inode);
2368         struct ll_inode_info *lli = ll_i2info(inode);
2369         int res = 0;
2370
2371         res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE |
2372                                              MDS_INODELOCK_LOOKUP);
2373         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
2374
2375         if (res)
2376                 return res;
2377
2378         stat->dev = inode->i_sb->s_dev;
2379         if (ll_need_32bit_api(sbi))
2380                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
2381         else
2382                 stat->ino = inode->i_ino;
2383         stat->mode = inode->i_mode;
2384         stat->nlink = inode->i_nlink;
2385         stat->uid = inode->i_uid;
2386         stat->gid = inode->i_gid;
2387         stat->rdev = kdev_t_to_nr(inode->i_rdev);
2388         stat->atime = inode->i_atime;
2389         stat->mtime = inode->i_mtime;
2390         stat->ctime = inode->i_ctime;
2391 #ifdef HAVE_INODE_BLKSIZE
2392         stat->blksize = inode->i_blksize;
2393 #else
2394         stat->blksize = 1 << inode->i_blkbits;
2395 #endif
2396
2397         stat->size = i_size_read(inode);
2398         stat->blocks = inode->i_blocks;
2399
2400         return 0;
2401 }
2402 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2403 {
2404         struct lookup_intent it = { .it_op = IT_GETATTR };
2405
2406         return ll_getattr_it(mnt, de, &it, stat);
2407 }
2408
2409 #ifdef HAVE_LINUX_FIEMAP_H
2410 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2411                 __u64 start, __u64 len)
2412 {
2413         int rc;
2414         size_t num_bytes;
2415         struct ll_user_fiemap *fiemap;
2416         unsigned int extent_count = fieinfo->fi_extents_max;
2417
2418         num_bytes = sizeof(*fiemap) + (extent_count *
2419                                        sizeof(struct ll_fiemap_extent));
2420         OBD_ALLOC_LARGE(fiemap, num_bytes);
2421
2422         if (fiemap == NULL)
2423                 RETURN(-ENOMEM);
2424
2425         fiemap->fm_flags = fieinfo->fi_flags;
2426         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2427         fiemap->fm_start = start;
2428         fiemap->fm_length = len;
2429         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2430                sizeof(struct ll_fiemap_extent));
2431
2432         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2433
2434         fieinfo->fi_flags = fiemap->fm_flags;
2435         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2436         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2437                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2438
2439         OBD_FREE_LARGE(fiemap, num_bytes);
2440         return rc;
2441 }
2442 #endif
2443
2444
2445 static int
2446 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
2447 lustre_check_acl(struct inode *inode, int mask, unsigned int flags)
2448 #else
2449 lustre_check_acl(struct inode *inode, int mask)
2450 #endif
2451 {
2452 #ifdef CONFIG_FS_POSIX_ACL
2453         struct ll_inode_info *lli = ll_i2info(inode);
2454         struct posix_acl *acl;
2455         int rc;
2456         ENTRY;
2457
2458 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
2459         if (flags & IPERM_FLAG_RCU)
2460                 return -ECHILD;
2461 #endif
2462         cfs_spin_lock(&lli->lli_lock);
2463         acl = posix_acl_dup(lli->lli_posix_acl);
2464         cfs_spin_unlock(&lli->lli_lock);
2465
2466         if (!acl)
2467                 RETURN(-EAGAIN);
2468
2469         rc = posix_acl_permission(inode, acl, mask);
2470         posix_acl_release(acl);
2471
2472         RETURN(rc);
2473 #else
2474         return -EAGAIN;
2475 #endif
2476 }
2477
2478 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
2479 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
2480 #else
2481 # ifdef HAVE_INODE_PERMISION_2ARGS
2482 int ll_inode_permission(struct inode *inode, int mask)
2483 # else
2484 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2485 # endif
2486 #endif
2487 {
2488         int rc = 0;
2489         ENTRY;
2490
2491        /* as root inode are NOT getting validated in lookup operation,
2492         * need to do it before permission check. */
2493
2494         if (inode == inode->i_sb->s_root->d_inode) {
2495                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2496
2497                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2498                                               MDS_INODELOCK_LOOKUP);
2499                 if (rc)
2500                         RETURN(rc);
2501         }
2502
2503         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
2504                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
2505
2506         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2507                 return lustre_check_remote_perm(inode, mask);
2508
2509         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2510         rc = ll_generic_permission(inode, mask, flags, lustre_check_acl);
2511
2512         RETURN(rc);
2513 }
2514
2515 #ifdef HAVE_FILE_READV
2516 #define READ_METHOD readv
2517 #define READ_FUNCTION ll_file_readv
2518 #define WRITE_METHOD writev
2519 #define WRITE_FUNCTION ll_file_writev
2520 #else
2521 #define READ_METHOD aio_read
2522 #define READ_FUNCTION ll_file_aio_read
2523 #define WRITE_METHOD aio_write
2524 #define WRITE_FUNCTION ll_file_aio_write
2525 #endif
2526
2527 /* -o localflock - only provides locally consistent flock locks */
2528 struct file_operations ll_file_operations = {
2529         .read           = ll_file_read,
2530         .READ_METHOD    = READ_FUNCTION,
2531         .write          = ll_file_write,
2532         .WRITE_METHOD   = WRITE_FUNCTION,
2533 #ifdef HAVE_UNLOCKED_IOCTL
2534         .unlocked_ioctl = ll_file_ioctl,
2535 #else
2536         .ioctl          = ll_file_ioctl,
2537 #endif
2538         .open           = ll_file_open,
2539         .release        = ll_file_release,
2540         .mmap           = ll_file_mmap,
2541         .llseek         = ll_file_seek,
2542 #ifdef HAVE_KERNEL_SENDFILE
2543         .sendfile       = ll_file_sendfile,
2544 #endif
2545 #ifdef HAVE_KERNEL_SPLICE_READ
2546         .splice_read    = ll_file_splice_read,
2547 #endif
2548         .fsync          = ll_fsync,
2549         .flush          = ll_flush
2550 };
2551
2552 struct file_operations ll_file_operations_flock = {
2553         .read           = ll_file_read,
2554         .READ_METHOD    = READ_FUNCTION,
2555         .write          = ll_file_write,
2556         .WRITE_METHOD   = WRITE_FUNCTION,
2557 #ifdef HAVE_UNLOCKED_IOCTL
2558         .unlocked_ioctl = ll_file_ioctl,
2559 #else
2560         .ioctl          = ll_file_ioctl,
2561 #endif
2562         .open           = ll_file_open,
2563         .release        = ll_file_release,
2564         .mmap           = ll_file_mmap,
2565         .llseek         = ll_file_seek,
2566 #ifdef HAVE_KERNEL_SENDFILE
2567         .sendfile       = ll_file_sendfile,
2568 #endif
2569 #ifdef HAVE_KERNEL_SPLICE_READ
2570         .splice_read    = ll_file_splice_read,
2571 #endif
2572         .fsync          = ll_fsync,
2573         .flush          = ll_flush,
2574 #ifdef HAVE_F_OP_FLOCK
2575         .flock          = ll_file_flock,
2576 #endif
2577         .lock           = ll_file_flock
2578 };
2579
2580 /* These are for -o noflock - to return ENOSYS on flock calls */
2581 struct file_operations ll_file_operations_noflock = {
2582         .read           = ll_file_read,
2583         .READ_METHOD    = READ_FUNCTION,
2584         .write          = ll_file_write,
2585         .WRITE_METHOD   = WRITE_FUNCTION,
2586 #ifdef HAVE_UNLOCKED_IOCTL
2587         .unlocked_ioctl = ll_file_ioctl,
2588 #else
2589         .ioctl          = ll_file_ioctl,
2590 #endif
2591         .open           = ll_file_open,
2592         .release        = ll_file_release,
2593         .mmap           = ll_file_mmap,
2594         .llseek         = ll_file_seek,
2595 #ifdef HAVE_KERNEL_SENDFILE
2596         .sendfile       = ll_file_sendfile,
2597 #endif
2598 #ifdef HAVE_KERNEL_SPLICE_READ
2599         .splice_read    = ll_file_splice_read,
2600 #endif
2601         .fsync          = ll_fsync,
2602         .flush          = ll_flush,
2603 #ifdef HAVE_F_OP_FLOCK
2604         .flock          = ll_file_noflock,
2605 #endif
2606         .lock           = ll_file_noflock
2607 };
2608
2609 struct inode_operations ll_file_inode_operations = {
2610         .setattr        = ll_setattr,
2611         .truncate       = ll_truncate,
2612         .getattr        = ll_getattr,
2613         .permission     = ll_inode_permission,
2614         .setxattr       = ll_setxattr,
2615         .getxattr       = ll_getxattr,
2616         .listxattr      = ll_listxattr,
2617         .removexattr    = ll_removexattr,
2618 #ifdef  HAVE_LINUX_FIEMAP_H
2619         .fiemap         = ll_fiemap,
2620 #endif
2621 };
2622
2623 /* dynamic ioctl number support routins */
2624 static struct llioc_ctl_data {
2625         cfs_rw_semaphore_t      ioc_sem;
2626         cfs_list_t              ioc_head;
2627 } llioc = {
2628         __RWSEM_INITIALIZER(llioc.ioc_sem),
2629         CFS_LIST_HEAD_INIT(llioc.ioc_head)
2630 };
2631
2632
2633 struct llioc_data {
2634         cfs_list_t              iocd_list;
2635         unsigned int            iocd_size;
2636         llioc_callback_t        iocd_cb;
2637         unsigned int            iocd_count;
2638         unsigned int            iocd_cmd[0];
2639 };
2640
2641 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
2642 {
2643         unsigned int size;
2644         struct llioc_data *in_data = NULL;
2645         ENTRY;
2646
2647         if (cb == NULL || cmd == NULL ||
2648             count > LLIOC_MAX_CMD || count < 0)
2649                 RETURN(NULL);
2650
2651         size = sizeof(*in_data) + count * sizeof(unsigned int);
2652         OBD_ALLOC(in_data, size);
2653         if (in_data == NULL)
2654                 RETURN(NULL);
2655
2656         memset(in_data, 0, sizeof(*in_data));
2657         in_data->iocd_size = size;
2658         in_data->iocd_cb = cb;
2659         in_data->iocd_count = count;
2660         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
2661
2662         cfs_down_write(&llioc.ioc_sem);
2663         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
2664         cfs_up_write(&llioc.ioc_sem);
2665
2666         RETURN(in_data);
2667 }
2668
2669 void ll_iocontrol_unregister(void *magic)
2670 {
2671         struct llioc_data *tmp;
2672
2673         if (magic == NULL)
2674                 return;
2675
2676         cfs_down_write(&llioc.ioc_sem);
2677         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
2678                 if (tmp == magic) {
2679                         unsigned int size = tmp->iocd_size;
2680
2681                         cfs_list_del(&tmp->iocd_list);
2682                         cfs_up_write(&llioc.ioc_sem);
2683
2684                         OBD_FREE(tmp, size);
2685                         return;
2686                 }
2687         }
2688         cfs_up_write(&llioc.ioc_sem);
2689
2690         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
2691 }
2692
2693 EXPORT_SYMBOL(ll_iocontrol_register);
2694 EXPORT_SYMBOL(ll_iocontrol_unregister);
2695
2696 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
2697                         unsigned int cmd, unsigned long arg, int *rcp)
2698 {
2699         enum llioc_iter ret = LLIOC_CONT;
2700         struct llioc_data *data;
2701         int rc = -EINVAL, i;
2702
2703         cfs_down_read(&llioc.ioc_sem);
2704         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
2705                 for (i = 0; i < data->iocd_count; i++) {
2706                         if (cmd != data->iocd_cmd[i])
2707                                 continue;
2708
2709                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
2710                         break;
2711                 }
2712
2713                 if (ret == LLIOC_STOP)
2714                         break;
2715         }
2716         cfs_up_read(&llioc.ioc_sem);
2717
2718         if (rcp)
2719                 *rcp = rc;
2720         return ret;
2721 }