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