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