lustre/llite/file.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * 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_sa_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_sa_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_seq = lsm->lsm_object_seq;
 706         oinfo.oi_oa->o_mode = S_IFREG;
 707         oinfo.oi_oa->o_ioepoch = ioepoch;
 708         oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
 709                                OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
 710                                OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
 711                                OBD_MD_FLMTIME | OBD_MD_FLCTIME |
 712                                OBD_MD_FLGROUP | OBD_MD_FLEPOCH;
 713         oinfo.oi_capa = capa;
 714         if (sync) {
 715                 oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
 716                 oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
 717         }
 718
 719         set = ptlrpc_prep_set();
 720         if (set == NULL) {
 721                 CERROR("can't allocate ptlrpc set\n");
 722                 rc = -ENOMEM;
 723         } else {
 724                 rc = obd_getattr_async(exp, &oinfo, set);
 725                 if (rc == 0)
 726                         rc = ptlrpc_set_wait(set);
 727                 ptlrpc_set_destroy(set);
 728         }
 729         if (rc == 0)
 730                 oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
 731                                          OBD_MD_FLATIME | OBD_MD_FLMTIME |
 732                                          OBD_MD_FLCTIME | OBD_MD_FLSIZE);
 733         RETURN(rc);
 734 }
 735
 736 /**
 737   * Performs the getattr on the inode and updates its fields.
 738   * If @sync != 0, perform the getattr under the server-side lock.
 739   */
 740 int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
 741                      __u64 ioepoch, int sync)
 742 {
 743         struct ll_inode_info *lli  = ll_i2info(inode);
 744         struct obd_capa      *capa = ll_mdscapa_get(inode);
 745         int rc;
 746         ENTRY;
 747
 748         rc = ll_lsm_getattr(lli->lli_smd, ll_i2dtexp(inode),
 749                             capa, obdo, ioepoch, sync);
 750         capa_put(capa);
 751         if (rc == 0) {
 752                 obdo_refresh_inode(inode, obdo, obdo->o_valid);
 753                 CDEBUG(D_INODE,
 754                        "objid "LPX64" size %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
 774         /* merge timestamps the most resently obtained from mds with
 775            timestamps obtained from osts */
 776         lvb.lvb_atime = lli->lli_lvb.lvb_atime;
 777         lvb.lvb_mtime = lli->lli_lvb.lvb_mtime;
 778         lvb.lvb_ctime = lli->lli_lvb.lvb_ctime;
 779         rc = obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0);
 780         cl_isize_write_nolock(inode, lvb.lvb_size);
 781
 782         CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
 783                PFID(&lli->lli_fid), lvb.lvb_size);
 784         inode->i_blocks = lvb.lvb_blocks;
 785
 786         LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
 787         LTIME_S(inode->i_atime) = lvb.lvb_atime;
 788         LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
 789         ll_inode_size_unlock(inode, 1);
 790
 791         RETURN(rc);
 792 }
 793
 794 int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
 795                      lstat_t *st)
 796 {
 797         struct obdo obdo = { 0 };
 798         int rc;
 799
 800         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0);
 801         if (rc == 0) {
 802                 st->st_size   = obdo.o_size;
 803                 st->st_blocks = obdo.o_blocks;
 804                 st->st_mtime  = obdo.o_mtime;
 805                 st->st_atime  = obdo.o_atime;
 806                 st->st_ctime  = obdo.o_ctime;
 807         }
 808         return rc;
 809 }
 810
 811 void ll_io_init(struct cl_io *io, const struct file *file, int write)
 812 {
 813         struct inode *inode = file->f_dentry->d_inode;
 814
 815         memset(io, 0, sizeof *io);
 816         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
 817         if (write)
 818                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
 819         io->ci_obj     = ll_i2info(inode)->lli_clob;
 820         io->ci_lockreq = CILR_MAYBE;
 821         if (ll_file_nolock(file)) {
 822                 io->ci_lockreq = CILR_NEVER;
 823                 io->ci_no_srvlock = 1;
 824         } else if (file->f_flags & O_APPEND) {
 825                 io->ci_lockreq = CILR_MANDATORY;
 826         }
 827 }
 828
 829 static ssize_t ll_file_io_generic(const struct lu_env *env,
 830                 struct vvp_io_args *args, struct file *file,
 831                 enum cl_io_type iot, loff_t *ppos, size_t count)
 832 {
 833         struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
 834         struct cl_io         *io;
 835         ssize_t               result;
 836         ENTRY;
 837
 838         io = &ccc_env_info(env)->cti_io;
 839         ll_io_init(io, file, iot == CIT_WRITE);
 840
 841         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
 842                 struct vvp_io *vio = vvp_env_io(env);
 843                 struct ccc_io *cio = ccc_env_io(env);
 844                 int write_sem_locked = 0;
 845
 846                 cio->cui_fd  = LUSTRE_FPRIVATE(file);
 847                 vio->cui_io_subtype = args->via_io_subtype;
 848
 849                 switch (vio->cui_io_subtype) {
 850                 case IO_NORMAL:
 851                         cio->cui_iov = args->u.normal.via_iov;
 852                         cio->cui_nrsegs = args->u.normal.via_nrsegs;
 853                         cio->cui_tot_nrsegs = cio->cui_nrsegs;
 854 #ifndef HAVE_FILE_WRITEV
 855                         cio->cui_iocb = args->u.normal.via_iocb;
 856 #endif
 857                         if ((iot == CIT_WRITE) &&
 858                             !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
 859                                 if(cfs_down_interruptible(&lli->lli_write_sem))
 860                                         GOTO(out, result = -ERESTARTSYS);
 861                                 write_sem_locked = 1;
 862                         } else if (iot == CIT_READ) {
 863                                 cfs_down_read(&lli->lli_trunc_sem);
 864                         }
 865                         break;
 866                 case IO_SENDFILE:
 867                         vio->u.sendfile.cui_actor = args->u.sendfile.via_actor;
 868                         vio->u.sendfile.cui_target = args->u.sendfile.via_target;
 869                         break;
 870                 case IO_SPLICE:
 871                         vio->u.splice.cui_pipe = args->u.splice.via_pipe;
 872                         vio->u.splice.cui_flags = args->u.splice.via_flags;
 873                         break;
 874                 default:
 875                         CERROR("Unknow IO type - %u\n", vio->cui_io_subtype);
 876                         LBUG();
 877                 }
 878                 result = cl_io_loop(env, io);
 879                 if (write_sem_locked)
 880                         cfs_up(&lli->lli_write_sem);
 881                 else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ)
 882                         cfs_up_read(&lli->lli_trunc_sem);
 883         } else {
 884                 /* cl_io_rw_init() handled IO */
 885                 result = io->ci_result;
 886         }
 887
 888         if (io->ci_nob > 0) {
 889                 result = io->ci_nob;
 890                 *ppos = io->u.ci_wr.wr.crw_pos;
 891         }
 892         GOTO(out, result);
 893 out:
 894         cl_io_fini(env, io);
 895         if (iot == CIT_WRITE)
 896                 lli->lli_write_rc = result < 0 ? : 0;
 897         return result;
 898 }
 899
 900
 901 /*
 902  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
 903  */
 904 static int ll_file_get_iov_count(const struct iovec *iov,
 905                                  unsigned long *nr_segs, size_t *count)
 906 {
 907         size_t cnt = 0;
 908         unsigned long seg;
 909
 910         for (seg = 0; seg < *nr_segs; seg++) {
 911                 const struct iovec *iv = &iov[seg];
 912
 913                 /*
 914                  * If any segment has a negative length, or the cumulative
 915                  * length ever wraps negative then return -EINVAL.
 916                  */
 917                 cnt += iv->iov_len;
 918                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
 919                         return -EINVAL;
 920                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
 921                         continue;
 922                 if (seg == 0)
 923                         return -EFAULT;
 924                 *nr_segs = seg;
 925                 cnt -= iv->iov_len;   /* This segment is no good */
 926                 break;
 927         }
 928         *count = cnt;
 929         return 0;
 930 }
 931
 932 #ifdef HAVE_FILE_READV
 933 static ssize_t ll_file_readv(struct file *file, const struct iovec *iov,
 934                               unsigned long nr_segs, loff_t *ppos)
 935 {
 936         struct lu_env      *env;
 937         struct vvp_io_args *args;
 938         size_t              count;
 939         ssize_t             result;
 940         int                 refcheck;
 941         ENTRY;
 942
 943         result = ll_file_get_iov_count(iov, &nr_segs, &count);
 944         if (result)
 945                 RETURN(result);
 946
 947         env = cl_env_get(&refcheck);
 948         if (IS_ERR(env))
 949                 RETURN(PTR_ERR(env));
 950
 951         args = vvp_env_args(env, IO_NORMAL);
 952         args->u.normal.via_iov = (struct iovec *)iov;
 953         args->u.normal.via_nrsegs = nr_segs;
 954
 955         result = ll_file_io_generic(env, args, file, CIT_READ, ppos, count);
 956         cl_env_put(env, &refcheck);
 957         RETURN(result);
 958 }
 959
 960 static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
 961                             loff_t *ppos)
 962 {
 963         struct lu_env *env;
 964         struct iovec  *local_iov;
 965         ssize_t        result;
 966         int            refcheck;
 967         ENTRY;
 968
 969         env = cl_env_get(&refcheck);
 970         if (IS_ERR(env))
 971                 RETURN(PTR_ERR(env));
 972
 973         local_iov = &vvp_env_info(env)->vti_local_iov;
 974         local_iov->iov_base = (void __user *)buf;
 975         local_iov->iov_len = count;
 976         result = ll_file_readv(file, local_iov, 1, ppos);
 977         cl_env_put(env, &refcheck);
 978         RETURN(result);
 979 }
 980
 981 #else
 982 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
 983                                 unsigned long nr_segs, loff_t pos)
 984 {
 985         struct lu_env      *env;
 986         struct vvp_io_args *args;
 987         size_t              count;
 988         ssize_t             result;
 989         int                 refcheck;
 990         ENTRY;
 991
 992         result = ll_file_get_iov_count(iov, &nr_segs, &count);
 993         if (result)
 994                 RETURN(result);
 995
 996         env = cl_env_get(&refcheck);
 997         if (IS_ERR(env))
 998                 RETURN(PTR_ERR(env));
 999
1000         args = vvp_env_args(env, IO_NORMAL);
1001         args->u.normal.via_iov = (struct iovec *)iov;
1002         args->u.normal.via_nrsegs = nr_segs;
1003         args->u.normal.via_iocb = iocb;
1004
1005         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1006                                     &iocb->ki_pos, count);
1007         cl_env_put(env, &refcheck);
1008         RETURN(result);
1009 }
1010
1011 static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
1012                             loff_t *ppos)
1013 {
1014         struct lu_env *env;
1015         struct iovec  *local_iov;
1016         struct kiocb  *kiocb;
1017         ssize_t        result;
1018         int            refcheck;
1019         ENTRY;
1020
1021         env = cl_env_get(&refcheck);
1022         if (IS_ERR(env))
1023                 RETURN(PTR_ERR(env));
1024
1025         local_iov = &vvp_env_info(env)->vti_local_iov;
1026         kiocb = &vvp_env_info(env)->vti_kiocb;
1027         local_iov->iov_base = (void __user *)buf;
1028         local_iov->iov_len = count;
1029         init_sync_kiocb(kiocb, file);
1030         kiocb->ki_pos = *ppos;
1031         kiocb->ki_left = count;
1032
1033         result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1034         *ppos = kiocb->ki_pos;
1035
1036         cl_env_put(env, &refcheck);
1037         RETURN(result);
1038 }
1039 #endif
1040
1041 /*
1042  * Write to a file (through the page cache).
1043  */
1044 #ifdef HAVE_FILE_WRITEV
1045 static ssize_t ll_file_writev(struct file *file, const struct iovec *iov,
1046                               unsigned long nr_segs, loff_t *ppos)
1047 {
1048         struct lu_env      *env;
1049         struct vvp_io_args *args;
1050         size_t              count;
1051         ssize_t             result;
1052         int                 refcheck;
1053         ENTRY;
1054
1055         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1056         if (result)
1057                 RETURN(result);
1058
1059         env = cl_env_get(&refcheck);
1060         if (IS_ERR(env))
1061                 RETURN(PTR_ERR(env));
1062
1063         args = vvp_env_args(env, IO_NORMAL);
1064         args->u.normal.via_iov = (struct iovec *)iov;
1065         args->u.normal.via_nrsegs = nr_segs;
1066
1067         result = ll_file_io_generic(env, args, file, CIT_WRITE, ppos, count);
1068         cl_env_put(env, &refcheck);
1069         RETURN(result);
1070 }
1071
1072 static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1073                              loff_t *ppos)
1074 {
1075         struct lu_env    *env;
1076         struct iovec     *local_iov;
1077         ssize_t           result;
1078         int               refcheck;
1079         ENTRY;
1080
1081         env = cl_env_get(&refcheck);
1082         if (IS_ERR(env))
1083                 RETURN(PTR_ERR(env));
1084
1085         local_iov = &vvp_env_info(env)->vti_local_iov;
1086         local_iov->iov_base = (void __user *)buf;
1087         local_iov->iov_len = count;
1088
1089         result = ll_file_writev(file, local_iov, 1, ppos);
1090         cl_env_put(env, &refcheck);
1091         RETURN(result);
1092 }
1093
1094 #else /* AIO stuff */
1095 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1096                                  unsigned long nr_segs, loff_t pos)
1097 {
1098         struct lu_env      *env;
1099         struct vvp_io_args *args;
1100         size_t              count;
1101         ssize_t             result;
1102         int                 refcheck;
1103         ENTRY;
1104
1105         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1106         if (result)
1107                 RETURN(result);
1108
1109         env = cl_env_get(&refcheck);
1110         if (IS_ERR(env))
1111                 RETURN(PTR_ERR(env));
1112
1113         args = vvp_env_args(env, IO_NORMAL);
1114         args->u.normal.via_iov = (struct iovec *)iov;
1115         args->u.normal.via_nrsegs = nr_segs;
1116         args->u.normal.via_iocb = iocb;
1117
1118         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1119                                   &iocb->ki_pos, count);
1120         cl_env_put(env, &refcheck);
1121         RETURN(result);
1122 }
1123
1124 static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1125                              loff_t *ppos)
1126 {
1127         struct lu_env *env;
1128         struct iovec  *local_iov;
1129         struct kiocb  *kiocb;
1130         ssize_t        result;
1131         int            refcheck;
1132         ENTRY;
1133
1134         env = cl_env_get(&refcheck);
1135         if (IS_ERR(env))
1136                 RETURN(PTR_ERR(env));
1137
1138         local_iov = &vvp_env_info(env)->vti_local_iov;
1139         kiocb = &vvp_env_info(env)->vti_kiocb;
1140         local_iov->iov_base = (void __user *)buf;
1141         local_iov->iov_len = count;
1142         init_sync_kiocb(kiocb, file);
1143         kiocb->ki_pos = *ppos;
1144         kiocb->ki_left = count;
1145
1146         result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1147         *ppos = kiocb->ki_pos;
1148
1149         cl_env_put(env, &refcheck);
1150         RETURN(result);
1151 }
1152 #endif
1153
1154
1155 #ifdef HAVE_KERNEL_SENDFILE
1156 /*
1157  * Send file content (through pagecache) somewhere with helper
1158  */
1159 static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count,
1160                                 read_actor_t actor, void *target)
1161 {
1162         struct lu_env      *env;
1163         struct vvp_io_args *args;
1164         ssize_t             result;
1165         int                 refcheck;
1166         ENTRY;
1167
1168         env = cl_env_get(&refcheck);
1169         if (IS_ERR(env))
1170                 RETURN(PTR_ERR(env));
1171
1172         args = vvp_env_args(env, IO_SENDFILE);
1173         args->u.sendfile.via_target = target;
1174         args->u.sendfile.via_actor = actor;
1175
1176         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1177         cl_env_put(env, &refcheck);
1178         RETURN(result);
1179 }
1180 #endif
1181
1182 #ifdef HAVE_KERNEL_SPLICE_READ
1183 /*
1184  * Send file content (through pagecache) somewhere with helper
1185  */
1186 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1187                                    struct pipe_inode_info *pipe, size_t count,
1188                                    unsigned int flags)
1189 {
1190         struct lu_env      *env;
1191         struct vvp_io_args *args;
1192         ssize_t             result;
1193         int                 refcheck;
1194         ENTRY;
1195
1196         env = cl_env_get(&refcheck);
1197         if (IS_ERR(env))
1198                 RETURN(PTR_ERR(env));
1199
1200         args = vvp_env_args(env, IO_SPLICE);
1201         args->u.splice.via_pipe = pipe;
1202         args->u.splice.via_flags = flags;
1203
1204         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1205         cl_env_put(env, &refcheck);
1206         RETURN(result);
1207 }
1208 #endif
1209
1210 static int ll_lov_recreate(struct inode *inode, obd_id id, obd_seq seq,
1211                            obd_count ost_idx)
1212 {
1213         struct obd_export *exp = ll_i2dtexp(inode);
1214         struct obd_trans_info oti = { 0 };
1215         struct obdo *oa = NULL;
1216         int lsm_size;
1217         int rc = 0;
1218         struct lov_stripe_md *lsm, *lsm2;
1219         ENTRY;
1220
1221         OBDO_ALLOC(oa);
1222         if (oa == NULL)
1223                 RETURN(-ENOMEM);
1224
1225         ll_inode_size_lock(inode, 0);
1226         lsm = ll_i2info(inode)->lli_smd;
1227         if (lsm == NULL)
1228                 GOTO(out, rc = -ENOENT);
1229         lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) *
1230                    (lsm->lsm_stripe_count));
1231
1232         OBD_ALLOC_LARGE(lsm2, lsm_size);
1233         if (lsm2 == NULL)
1234                 GOTO(out, rc = -ENOMEM);
1235
1236         oa->o_id = id;
1237         oa->o_seq = seq;
1238         oa->o_nlink = ost_idx;
1239         oa->o_flags |= OBD_FL_RECREATE_OBJS;
1240         oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1241         obdo_from_inode(oa, inode, &ll_i2info(inode)->lli_fid, OBD_MD_FLTYPE |
1242                         OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME);
1243         memcpy(lsm2, lsm, lsm_size);
1244         rc = obd_create(exp, oa, &lsm2, &oti);
1245
1246         OBD_FREE_LARGE(lsm2, lsm_size);
1247         GOTO(out, rc);
1248 out:
1249         ll_inode_size_unlock(inode, 0);
1250         OBDO_FREE(oa);
1251         return rc;
1252 }
1253
1254 static int ll_lov_recreate_obj(struct inode *inode, unsigned long arg)
1255 {
1256         struct ll_recreate_obj ucreat;
1257         ENTRY;
1258
1259         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1260                 RETURN(-EPERM);
1261
1262         if (cfs_copy_from_user(&ucreat, (struct ll_recreate_obj *)arg,
1263                                sizeof(struct ll_recreate_obj)))
1264                 RETURN(-EFAULT);
1265
1266         RETURN(ll_lov_recreate(inode, ucreat.lrc_id, 0,
1267                                ucreat.lrc_ost_idx));
1268 }
1269
1270 static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg)
1271 {
1272         struct lu_fid fid;
1273         obd_id id;
1274         obd_count ost_idx;
1275         ENTRY;
1276
1277         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1278                 RETURN(-EPERM);
1279
1280         if (cfs_copy_from_user(&fid, (struct lu_fid *)arg,
1281                                sizeof(struct lu_fid)))
1282                 RETURN(-EFAULT);
1283
1284         id = fid_oid(&fid) | ((fid_seq(&fid) & 0xffff) << 32);
1285         ost_idx = (fid_seq(&fid) >> 16) & 0xffff;
1286         RETURN(ll_lov_recreate(inode, id, 0, ost_idx));
1287 }
1288
1289 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1290                              int flags, struct lov_user_md *lum, int lum_size)
1291 {
1292         struct lov_stripe_md *lsm;
1293         struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
1294         int rc = 0;
1295         ENTRY;
1296
1297         ll_inode_size_lock(inode, 0);
1298         lsm = ll_i2info(inode)->lli_smd;
1299         if (lsm) {
1300                 ll_inode_size_unlock(inode, 0);
1301                 CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
1302                        inode->i_ino);
1303                 RETURN(-EEXIST);
1304         }
1305
1306         rc = ll_intent_file_open(file, lum, lum_size, &oit);
1307         if (rc)
1308                 GOTO(out, rc);
1309         if (it_disposition(&oit, DISP_LOOKUP_NEG))
1310                 GOTO(out_req_free, rc = -ENOENT);
1311         rc = oit.d.lustre.it_status;
1312         if (rc < 0)
1313                 GOTO(out_req_free, rc);
1314
1315         ll_release_openhandle(file->f_dentry, &oit);
1316
1317  out:
1318         ll_inode_size_unlock(inode, 0);
1319         ll_intent_release(&oit);
1320         RETURN(rc);
1321 out_req_free:
1322         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
1323         goto out;
1324 }
1325
1326 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1327                              struct lov_mds_md **lmmp, int *lmm_size,
1328                              struct ptlrpc_request **request)
1329 {
1330         struct ll_sb_info *sbi = ll_i2sbi(inode);
1331         struct mdt_body  *body;
1332         struct lov_mds_md *lmm = NULL;
1333         struct ptlrpc_request *req = NULL;
1334         struct md_op_data *op_data;
1335         int rc, lmmsize;
1336
1337         rc = ll_get_max_mdsize(sbi, &lmmsize);
1338         if (rc)
1339                 RETURN(rc);
1340
1341         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1342                                      strlen(filename), lmmsize,
1343                                      LUSTRE_OPC_ANY, NULL);
1344         if (op_data == NULL)
1345                 RETURN(-ENOMEM);
1346
1347         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1348         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1349         ll_finish_md_op_data(op_data);
1350         if (rc < 0) {
1351                 CDEBUG(D_INFO, "md_getattr_name failed "
1352                        "on %s: rc %d\n", filename, rc);
1353                 GOTO(out, rc);
1354         }
1355
1356         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1357         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1358
1359         lmmsize = body->eadatasize;
1360
1361         if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1362                         lmmsize == 0) {
1363                 GOTO(out, rc = -ENODATA);
1364         }
1365
1366         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1367         LASSERT(lmm != NULL);
1368
1369         if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1370             (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1371                 GOTO(out, rc = -EPROTO);
1372         }
1373
1374         /*
1375          * This is coming from the MDS, so is probably in
1376          * little endian.  We convert it to host endian before
1377          * passing it to userspace.
1378          */
1379         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1380                 /* if function called for directory - we should
1381                  * avoid swab not existent lsm objects */
1382                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1383                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1384                         if (S_ISREG(body->mode))
1385                                 lustre_swab_lov_user_md_objects(
1386                                  ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1387                                  ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count);
1388                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1389                         lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1390                         if (S_ISREG(body->mode))
1391                                 lustre_swab_lov_user_md_objects(
1392                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1393                                  ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count);
1394                 }
1395         }
1396
1397 out:
1398         *lmmp = lmm;
1399         *lmm_size = lmmsize;
1400         *request = req;
1401         return rc;
1402 }
1403
1404 static int ll_lov_setea(struct inode *inode, struct file *file,
1405                             unsigned long arg)
1406 {
1407         int flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1408         struct lov_user_md  *lump;
1409         int lum_size = sizeof(struct lov_user_md) +
1410                        sizeof(struct lov_user_ost_data);
1411         int rc;
1412         ENTRY;
1413
1414         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1415                 RETURN(-EPERM);
1416
1417         OBD_ALLOC_LARGE(lump, lum_size);
1418         if (lump == NULL) {
1419                 RETURN(-ENOMEM);
1420         }
1421         if (cfs_copy_from_user(lump, (struct lov_user_md  *)arg, lum_size)) {
1422                 OBD_FREE_LARGE(lump, lum_size);
1423                 RETURN(-EFAULT);
1424         }
1425
1426         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1427
1428         OBD_FREE_LARGE(lump, lum_size);
1429         RETURN(rc);
1430 }
1431
1432 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1433                             unsigned long arg)
1434 {
1435         struct lov_user_md_v3 lumv3;
1436         struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1437         struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg;
1438         struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg;
1439         int lum_size;
1440         int rc;
1441         int flags = FMODE_WRITE;
1442         ENTRY;
1443
1444         /* first try with v1 which is smaller than v3 */
1445         lum_size = sizeof(struct lov_user_md_v1);
1446         if (cfs_copy_from_user(lumv1, lumv1p, lum_size))
1447                 RETURN(-EFAULT);
1448
1449         if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1450                 lum_size = sizeof(struct lov_user_md_v3);
1451                 if (cfs_copy_from_user(&lumv3, lumv3p, lum_size))
1452                         RETURN(-EFAULT);
1453         }
1454
1455         rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
1456         if (rc == 0) {
1457                  put_user(0, &lumv1p->lmm_stripe_count);
1458                  rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1459                                     0, ll_i2info(inode)->lli_smd,
1460                                     (void *)arg);
1461         }
1462         RETURN(rc);
1463 }
1464
1465 static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1466 {
1467         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
1468
1469         if (!lsm)
1470                 RETURN(-ENODATA);
1471
1472         return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, lsm,
1473                             (void *)arg);
1474 }
1475
1476 int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1477 {
1478         struct ll_inode_info   *lli = ll_i2info(inode);
1479         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1480         struct ccc_grouplock    grouplock;
1481         int                     rc;
1482         ENTRY;
1483
1484         if (ll_file_nolock(file))
1485                 RETURN(-EOPNOTSUPP);
1486
1487         cfs_spin_lock(&lli->lli_lock);
1488         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1489                 CWARN("group lock already existed with gid %lu\n",
1490                        fd->fd_grouplock.cg_gid);
1491                 cfs_spin_unlock(&lli->lli_lock);
1492                 RETURN(-EINVAL);
1493         }
1494         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1495         cfs_spin_unlock(&lli->lli_lock);
1496
1497         rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1498                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1499         if (rc)
1500                 RETURN(rc);
1501
1502         cfs_spin_lock(&lli->lli_lock);
1503         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1504                 cfs_spin_unlock(&lli->lli_lock);
1505                 CERROR("another thread just won the race\n");
1506                 cl_put_grouplock(&grouplock);
1507                 RETURN(-EINVAL);
1508         }
1509
1510         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1511         fd->fd_grouplock = grouplock;
1512         cfs_spin_unlock(&lli->lli_lock);
1513
1514         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1515         RETURN(0);
1516 }
1517
1518 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1519 {
1520         struct ll_inode_info   *lli = ll_i2info(inode);
1521         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1522         struct ccc_grouplock    grouplock;
1523         ENTRY;
1524
1525         cfs_spin_lock(&lli->lli_lock);
1526         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1527                 cfs_spin_unlock(&lli->lli_lock);
1528                 CWARN("no group lock held\n");
1529                 RETURN(-EINVAL);
1530         }
1531         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1532
1533         if (fd->fd_grouplock.cg_gid != arg) {
1534                 CWARN("group lock %lu doesn't match current id %lu\n",
1535                        arg, fd->fd_grouplock.cg_gid);
1536                 cfs_spin_unlock(&lli->lli_lock);
1537                 RETURN(-EINVAL);
1538         }
1539
1540         grouplock = fd->fd_grouplock;
1541         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1542         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1543         cfs_spin_unlock(&lli->lli_lock);
1544
1545         cl_put_grouplock(&grouplock);
1546         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1547         RETURN(0);
1548 }
1549
1550 /**
1551  * Close inode open handle
1552  *
1553  * \param dentry [in]     dentry which contains the inode
1554  * \param it     [in,out] intent which contains open info and result
1555  *
1556  * \retval 0     success
1557  * \retval <0    failure
1558  */
1559 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1560 {
1561         struct inode *inode = dentry->d_inode;
1562         struct obd_client_handle *och;
1563         int rc;
1564         ENTRY;
1565
1566         LASSERT(inode);
1567
1568         /* Root ? Do nothing. */
1569         if (dentry->d_inode->i_sb->s_root == dentry)
1570                 RETURN(0);
1571
1572         /* No open handle to close? Move away */
1573         if (!it_disposition(it, DISP_OPEN_OPEN))
1574                 RETURN(0);
1575
1576         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1577
1578         OBD_ALLOC(och, sizeof(*och));
1579         if (!och)
1580                 GOTO(out, rc = -ENOMEM);
1581
1582         ll_och_fill(ll_i2sbi(inode)->ll_md_exp,
1583                     ll_i2info(inode), it, och);
1584
1585         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1586                                        inode, och);
1587  out:
1588         /* this one is in place of ll_file_open */
1589         if (it_disposition(it, DISP_ENQ_OPEN_REF))
1590                 ptlrpc_req_finished(it->d.lustre.it_data);
1591         it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1592         RETURN(rc);
1593 }
1594
1595 /**
1596  * Get size for inode for which FIEMAP mapping is requested.
1597  * Make the FIEMAP get_info call and returns the result.
1598  */
1599 int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1600               int num_bytes)
1601 {
1602         struct obd_export *exp = ll_i2dtexp(inode);
1603         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
1604         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1605         int vallen = num_bytes;
1606         int rc;
1607         ENTRY;
1608
1609         /* Checks for fiemap flags */
1610         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1611                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1612                 return -EBADR;
1613         }
1614
1615         /* Check for FIEMAP_FLAG_SYNC */
1616         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1617                 rc = filemap_fdatawrite(inode->i_mapping);
1618                 if (rc)
1619                         return rc;
1620         }
1621
1622         /* If the stripe_count > 1 and the application does not understand
1623          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1624          */
1625         if (lsm->lsm_stripe_count > 1 &&
1626             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1627                 return -EOPNOTSUPP;
1628
1629         fm_key.oa.o_id = lsm->lsm_object_id;
1630         fm_key.oa.o_seq = lsm->lsm_object_seq;
1631         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1632
1633         obdo_from_inode(&fm_key.oa, inode, &ll_i2info(inode)->lli_fid,
1634                         OBD_MD_FLSIZE);
1635         /* If filesize is 0, then there would be no objects for mapping */
1636         if (fm_key.oa.o_size == 0) {
1637                 fiemap->fm_mapped_extents = 0;
1638                 RETURN(0);
1639         }
1640
1641         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1642
1643         rc = obd_get_info(exp, sizeof(fm_key), &fm_key, &vallen, fiemap, lsm);
1644         if (rc)
1645                 CERROR("obd_get_info failed: rc = %d\n", rc);
1646
1647         RETURN(rc);
1648 }
1649
1650 int ll_fid2path(struct obd_export *exp, void *arg)
1651 {
1652         struct getinfo_fid2path *gfout, *gfin;
1653         int outsize, rc;
1654         ENTRY;
1655
1656         /* Need to get the buflen */
1657         OBD_ALLOC_PTR(gfin);
1658         if (gfin == NULL)
1659                 RETURN(-ENOMEM);
1660         if (cfs_copy_from_user(gfin, arg, sizeof(*gfin))) {
1661                 OBD_FREE_PTR(gfin);
1662                 RETURN(-EFAULT);
1663         }
1664
1665         outsize = sizeof(*gfout) + gfin->gf_pathlen;
1666         OBD_ALLOC(gfout, outsize);
1667         if (gfout == NULL) {
1668                 OBD_FREE_PTR(gfin);
1669                 RETURN(-ENOMEM);
1670         }
1671         memcpy(gfout, gfin, sizeof(*gfout));
1672         OBD_FREE_PTR(gfin);
1673
1674         /* Call mdc_iocontrol */
1675         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1676         if (rc)
1677                 GOTO(gf_free, rc);
1678         if (cfs_copy_to_user(arg, gfout, outsize))
1679                 rc = -EFAULT;
1680
1681 gf_free:
1682         OBD_FREE(gfout, outsize);
1683         RETURN(rc);
1684 }
1685
1686 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1687 {
1688         struct ll_user_fiemap *fiemap_s;
1689         size_t num_bytes, ret_bytes;
1690         unsigned int extent_count;
1691         int rc = 0;
1692
1693         /* Get the extent count so we can calculate the size of
1694          * required fiemap buffer */
1695         if (get_user(extent_count,
1696             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1697                 RETURN(-EFAULT);
1698         num_bytes = sizeof(*fiemap_s) + (extent_count *
1699                                          sizeof(struct ll_fiemap_extent));
1700
1701         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1702         if (fiemap_s == NULL)
1703                 RETURN(-ENOMEM);
1704
1705         /* get the fiemap value */
1706         if (copy_from_user(fiemap_s,(struct ll_user_fiemap __user *)arg,
1707                            sizeof(*fiemap_s)))
1708                 GOTO(error, rc = -EFAULT);
1709
1710         /* If fm_extent_count is non-zero, read the first extent since
1711          * it is used to calculate end_offset and device from previous
1712          * fiemap call. */
1713         if (extent_count) {
1714                 if (copy_from_user(&fiemap_s->fm_extents[0],
1715                     (char __user *)arg + sizeof(*fiemap_s),
1716                     sizeof(struct ll_fiemap_extent)))
1717                         GOTO(error, rc = -EFAULT);
1718         }
1719
1720         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1721         if (rc)
1722                 GOTO(error, rc);
1723
1724         ret_bytes = sizeof(struct ll_user_fiemap);
1725
1726         if (extent_count != 0)
1727                 ret_bytes += (fiemap_s->fm_mapped_extents *
1728                                  sizeof(struct ll_fiemap_extent));
1729
1730         if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
1731                 rc = -EFAULT;
1732
1733 error:
1734         OBD_FREE_LARGE(fiemap_s, num_bytes);
1735         RETURN(rc);
1736 }
1737
1738 #ifdef HAVE_UNLOCKED_IOCTL
1739 long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1740 {
1741         struct inode *inode = file->f_dentry->d_inode;
1742 #else
1743 int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
1744                   unsigned long arg)
1745 {
1746 #endif
1747         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1748         int flags;
1749         ENTRY;
1750
1751         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
1752                inode->i_generation, inode, cmd);
1753         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
1754
1755         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
1756         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
1757                 RETURN(-ENOTTY);
1758
1759         switch(cmd) {
1760         case LL_IOC_GETFLAGS:
1761                 /* Get the current value of the file flags */
1762                 return put_user(fd->fd_flags, (int *)arg);
1763         case LL_IOC_SETFLAGS:
1764         case LL_IOC_CLRFLAGS:
1765                 /* Set or clear specific file flags */
1766                 /* XXX This probably needs checks to ensure the flags are
1767                  *     not abused, and to handle any flag side effects.
1768                  */
1769                 if (get_user(flags, (int *) arg))
1770                         RETURN(-EFAULT);
1771
1772                 if (cmd == LL_IOC_SETFLAGS) {
1773                         if ((flags & LL_FILE_IGNORE_LOCK) &&
1774                             !(file->f_flags & O_DIRECT)) {
1775                                 CERROR("%s: unable to disable locking on "
1776                                        "non-O_DIRECT file\n", current->comm);
1777                                 RETURN(-EINVAL);
1778                         }
1779
1780                         fd->fd_flags |= flags;
1781                 } else {
1782                         fd->fd_flags &= ~flags;
1783                 }
1784                 RETURN(0);
1785         case LL_IOC_LOV_SETSTRIPE:
1786                 RETURN(ll_lov_setstripe(inode, file, arg));
1787         case LL_IOC_LOV_SETEA:
1788                 RETURN(ll_lov_setea(inode, file, arg));
1789         case LL_IOC_LOV_GETSTRIPE:
1790                 RETURN(ll_lov_getstripe(inode, arg));
1791         case LL_IOC_RECREATE_OBJ:
1792                 RETURN(ll_lov_recreate_obj(inode, arg));
1793         case LL_IOC_RECREATE_FID:
1794                 RETURN(ll_lov_recreate_fid(inode, arg));
1795         case FSFILT_IOC_FIEMAP:
1796                 RETURN(ll_ioctl_fiemap(inode, arg));
1797         case FSFILT_IOC_GETFLAGS:
1798         case FSFILT_IOC_SETFLAGS:
1799                 RETURN(ll_iocontrol(inode, file, cmd, arg));
1800         case FSFILT_IOC_GETVERSION_OLD:
1801         case FSFILT_IOC_GETVERSION:
1802                 RETURN(put_user(inode->i_generation, (int *)arg));
1803         case LL_IOC_GROUP_LOCK:
1804                 RETURN(ll_get_grouplock(inode, file, arg));
1805         case LL_IOC_GROUP_UNLOCK:
1806                 RETURN(ll_put_grouplock(inode, file, arg));
1807         case IOC_OBD_STATFS:
1808                 RETURN(ll_obd_statfs(inode, (void *)arg));
1809
1810         /* We need to special case any other ioctls we want to handle,
1811          * to send them to the MDS/OST as appropriate and to properly
1812          * network encode the arg field.
1813         case FSFILT_IOC_SETVERSION_OLD:
1814         case FSFILT_IOC_SETVERSION:
1815         */
1816         case LL_IOC_FLUSHCTX:
1817                 RETURN(ll_flush_ctx(inode));
1818         case LL_IOC_PATH2FID: {
1819                 if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode),
1820                                      sizeof(struct lu_fid)))
1821                         RETURN(-EFAULT);
1822
1823                 RETURN(0);
1824         }
1825         case OBD_IOC_FID2PATH:
1826                 RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg));
1827
1828         case LL_IOC_GET_MDTIDX: {
1829                 int mdtidx;
1830
1831                 mdtidx = ll_get_mdt_idx(inode);
1832                 if (mdtidx < 0)
1833                         RETURN(mdtidx);
1834
1835                 if (put_user((int)mdtidx, (int*)arg))
1836                         RETURN(-EFAULT);
1837
1838                 RETURN(0);
1839         }
1840
1841         default: {
1842                 int err;
1843
1844                 if (LLIOC_STOP ==
1845                     ll_iocontrol_call(inode, file, cmd, arg, &err))
1846                         RETURN(err);
1847
1848                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
1849                                      (void *)arg));
1850         }
1851         }
1852 }
1853
1854 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
1855 {
1856         struct inode *inode = file->f_dentry->d_inode;
1857         loff_t retval;
1858         ENTRY;
1859         retval = offset + ((origin == 2) ? i_size_read(inode) :
1860                            (origin == 1) ? file->f_pos : 0);
1861         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
1862                inode->i_ino, inode->i_generation, inode, retval, retval,
1863                origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
1864         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
1865
1866         if (origin == 2) { /* SEEK_END */
1867                 int nonblock = 0, rc;
1868
1869                 if (file->f_flags & O_NONBLOCK)
1870                         nonblock = LDLM_FL_BLOCK_NOWAIT;
1871
1872                 rc = cl_glimpse_size(inode);
1873                 if (rc != 0)
1874                         RETURN(rc);
1875
1876                 offset += i_size_read(inode);
1877         } else if (origin == 1) { /* SEEK_CUR */
1878                 offset += file->f_pos;
1879         }
1880
1881         retval = -EINVAL;
1882         if (offset >= 0 && offset <= ll_file_maxbytes(inode)) {
1883                 if (offset != file->f_pos) {
1884                         file->f_pos = offset;
1885                 }
1886                 retval = offset;
1887         }
1888
1889         RETURN(retval);
1890 }
1891
1892 #ifdef HAVE_FLUSH_OWNER_ID
1893 int ll_flush(struct file *file, fl_owner_t id)
1894 #else
1895 int ll_flush(struct file *file)
1896 #endif
1897 {
1898         struct inode *inode = file->f_dentry->d_inode;
1899         struct ll_inode_info *lli = ll_i2info(inode);
1900         struct lov_stripe_md *lsm = lli->lli_smd;
1901         int rc, err;
1902
1903         /* the application should know write failure already. */
1904         if (lli->lli_write_rc)
1905                 return 0;
1906
1907         /* catch async errors that were recorded back when async writeback
1908          * failed for pages in this mapping. */
1909         rc = lli->lli_async_rc;
1910         lli->lli_async_rc = 0;
1911         if (lsm) {
1912                 err = lov_test_and_clear_async_rc(lsm);
1913                 if (rc == 0)
1914                         rc = err;
1915         }
1916
1917         return rc ? -EIO : 0;
1918 }
1919
1920 int ll_fsync(struct file *file, struct dentry *dentry, int data)
1921 {
1922         struct inode *inode = dentry->d_inode;
1923         struct ll_inode_info *lli = ll_i2info(inode);
1924         struct lov_stripe_md *lsm = lli->lli_smd;
1925         struct ptlrpc_request *req;
1926         struct obd_capa *oc;
1927         int rc, err;
1928         ENTRY;
1929         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
1930                inode->i_generation, inode);
1931         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
1932
1933         /* fsync's caller has already called _fdata{sync,write}, we want
1934          * that IO to finish before calling the osc and mdc sync methods */
1935         rc = filemap_fdatawait(inode->i_mapping);
1936
1937         /* catch async errors that were recorded back when async writeback
1938          * failed for pages in this mapping. */
1939         err = lli->lli_async_rc;
1940         lli->lli_async_rc = 0;
1941         if (rc == 0)
1942                 rc = err;
1943         if (lsm) {
1944                 err = lov_test_and_clear_async_rc(lsm);
1945                 if (rc == 0)
1946                         rc = err;
1947         }
1948
1949         oc = ll_mdscapa_get(inode);
1950         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
1951                       &req);
1952         capa_put(oc);
1953         if (!rc)
1954                 rc = err;
1955         if (!err)
1956                 ptlrpc_req_finished(req);
1957
1958         if (data && lsm) {
1959                 struct obdo *oa;
1960
1961                 OBDO_ALLOC(oa);
1962                 if (!oa)
1963                         RETURN(rc ? rc : -ENOMEM);
1964
1965                 oa->o_id = lsm->lsm_object_id;
1966                 oa->o_seq = lsm->lsm_object_seq;
1967                 oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1968                 obdo_from_inode(oa, inode, &ll_i2info(inode)->lli_fid,
1969                                 OBD_MD_FLTYPE | OBD_MD_FLATIME |
1970                                 OBD_MD_FLMTIME | OBD_MD_FLCTIME |
1971                                 OBD_MD_FLGROUP);
1972
1973                 oc = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
1974                 err = obd_sync(ll_i2sbi(inode)->ll_dt_exp, oa, lsm,
1975                                0, OBD_OBJECT_EOF, oc);
1976                 capa_put(oc);
1977                 if (!rc)
1978                         rc = err;
1979                 OBDO_FREE(oa);
1980                 lli->lli_write_rc = err < 0 ? : 0;
1981         }
1982
1983         RETURN(rc);
1984 }
1985
1986 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
1987 {
1988         struct inode *inode = file->f_dentry->d_inode;
1989         struct ll_sb_info *sbi = ll_i2sbi(inode);
1990         struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK,
1991                                            .ei_cb_cp =ldlm_flock_completion_ast,
1992                                            .ei_cbdata = file_lock };
1993         struct md_op_data *op_data;
1994         struct lustre_handle lockh = {0};
1995         ldlm_policy_data_t flock;
1996         int flags = 0;
1997         int rc;
1998         ENTRY;
1999
2000         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2001                inode->i_ino, file_lock);
2002
2003         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2004
2005         if (file_lock->fl_flags & FL_FLOCK) {
2006                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2007                 /* set missing params for flock() calls */
2008                 file_lock->fl_end = OFFSET_MAX;
2009                 file_lock->fl_pid = current->tgid;
2010         }
2011         flock.l_flock.pid = file_lock->fl_pid;
2012         flock.l_flock.start = file_lock->fl_start;
2013         flock.l_flock.end = file_lock->fl_end;
2014
2015         switch (file_lock->fl_type) {
2016         case F_RDLCK:
2017                 einfo.ei_mode = LCK_PR;
2018                 break;
2019         case F_UNLCK:
2020                 /* An unlock request may or may not have any relation to
2021                  * existing locks so we may not be able to pass a lock handle
2022                  * via a normal ldlm_lock_cancel() request. The request may even
2023                  * unlock a byte range in the middle of an existing lock. In
2024                  * order to process an unlock request we need all of the same
2025                  * information that is given with a normal read or write record
2026                  * lock request. To avoid creating another ldlm unlock (cancel)
2027                  * message we'll treat a LCK_NL flock request as an unlock. */
2028                 einfo.ei_mode = LCK_NL;
2029                 break;
2030         case F_WRLCK:
2031                 einfo.ei_mode = LCK_PW;
2032                 break;
2033         default:
2034                 CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
2035                 RETURN (-EINVAL);
2036         }
2037
2038         switch (cmd) {
2039         case F_SETLKW:
2040 #ifdef F_SETLKW64
2041         case F_SETLKW64:
2042 #endif
2043                 flags = 0;
2044                 break;
2045         case F_SETLK:
2046 #ifdef F_SETLK64
2047         case F_SETLK64:
2048 #endif
2049                 flags = LDLM_FL_BLOCK_NOWAIT;
2050                 break;
2051         case F_GETLK:
2052 #ifdef F_GETLK64
2053         case F_GETLK64:
2054 #endif
2055                 flags = LDLM_FL_TEST_LOCK;
2056                 /* Save the old mode so that if the mode in the lock changes we
2057                  * can decrement the appropriate reader or writer refcount. */
2058                 file_lock->fl_type = einfo.ei_mode;
2059                 break;
2060         default:
2061                 CERROR("unknown fcntl lock command: %d\n", cmd);
2062                 RETURN (-EINVAL);
2063         }
2064
2065         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2066                                      LUSTRE_OPC_ANY, NULL);
2067         if (IS_ERR(op_data))
2068                 RETURN(PTR_ERR(op_data));
2069
2070         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2071                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2072                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2073
2074         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2075                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2076
2077         ll_finish_md_op_data(op_data);
2078
2079         if ((file_lock->fl_flags & FL_FLOCK) &&
2080             (rc == 0 || file_lock->fl_type == F_UNLCK))
2081                 ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
2082 #ifdef HAVE_F_OP_FLOCK
2083         if ((file_lock->fl_flags & FL_POSIX) &&
2084             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2085             !(flags & LDLM_FL_TEST_LOCK))
2086                 posix_lock_file_wait(file, file_lock);
2087 #endif
2088
2089         RETURN(rc);
2090 }
2091
2092 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2093 {
2094         ENTRY;
2095
2096         RETURN(-ENOSYS);
2097 }
2098
2099 int ll_have_md_lock(struct inode *inode, __u64 bits,  ldlm_mode_t l_req_mode)
2100 {
2101         struct lustre_handle lockh;
2102         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2103         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2104                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2105         struct lu_fid *fid;
2106         int flags;
2107         ENTRY;
2108
2109         if (!inode)
2110                RETURN(0);
2111
2112         fid = &ll_i2info(inode)->lli_fid;
2113         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2114                ldlm_lockname[mode]);
2115
2116         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2117         if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2118                           mode, &lockh)) {
2119                 RETURN(1);
2120         }
2121         RETURN(0);
2122 }
2123
2124 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2125                             struct lustre_handle *lockh)
2126 {
2127         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2128         struct lu_fid *fid;
2129         ldlm_mode_t rc;
2130         int flags;
2131         ENTRY;
2132
2133         fid = &ll_i2info(inode)->lli_fid;
2134         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2135
2136         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING;
2137         rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2138                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2139         RETURN(rc);
2140 }
2141
2142 static int ll_inode_revalidate_fini(struct inode *inode, int rc) {
2143         if (rc == -ENOENT) { /* Already unlinked. Just update nlink
2144                               * and return success */
2145                 inode->i_nlink = 0;
2146                 /* This path cannot be hit for regular files unless in
2147                  * case of obscure races, so no need to to validate
2148                  * size. */
2149                 if (!S_ISREG(inode->i_mode) &&
2150                     !S_ISDIR(inode->i_mode))
2151                         return 0;
2152         }
2153
2154         if (rc) {
2155                 CERROR("failure %d inode %lu\n", rc, inode->i_ino);
2156                 return -abs(rc);
2157
2158         }
2159
2160         return 0;
2161 }
2162
2163 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2164                              __u64 ibits)
2165 {
2166         struct inode *inode = dentry->d_inode;
2167         struct ptlrpc_request *req = NULL;
2168         struct ll_sb_info *sbi;
2169         struct obd_export *exp;
2170         int rc = 0;
2171         ENTRY;
2172
2173         if (!inode) {
2174                 CERROR("REPORT THIS LINE TO PETER\n");
2175                 RETURN(0);
2176         }
2177         sbi = ll_i2sbi(inode);
2178
2179         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2180                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2181
2182         exp = ll_i2mdexp(inode);
2183
2184         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
2185          *      But under CMD case, it caused some lock issues, should be fixed
2186          *      with new CMD ibits lock. See bug 12718 */
2187         if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) {
2188                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2189                 struct md_op_data *op_data;
2190
2191                 /* Call getattr by fid, so do not provide name at all. */
2192                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2193                                              dentry->d_inode, NULL, 0, 0,
2194                                              LUSTRE_OPC_ANY, NULL);
2195                 if (IS_ERR(op_data))
2196                         RETURN(PTR_ERR(op_data));
2197
2198                 oit.it_create_mode |= M_CHECK_STALE;
2199                 rc = md_intent_lock(exp, op_data, NULL, 0,
2200                                     /* we are not interested in name
2201                                        based lookup */
2202                                     &oit, 0, &req,
2203                                     ll_md_blocking_ast, 0);
2204                 ll_finish_md_op_data(op_data);
2205                 oit.it_create_mode &= ~M_CHECK_STALE;
2206                 if (rc < 0) {
2207                         rc = ll_inode_revalidate_fini(inode, rc);
2208                         GOTO (out, rc);
2209                 }
2210
2211                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2212                 if (rc != 0) {
2213                         ll_intent_release(&oit);
2214                         GOTO(out, rc);
2215                 }
2216
2217                 /* Unlinked? Unhash dentry, so it is not picked up later by
2218                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2219                    here to preserve get_cwd functionality on 2.6.
2220                    Bug 10503 */
2221                 if (!dentry->d_inode->i_nlink) {
2222                         cfs_spin_lock(&ll_lookup_lock);
2223                         spin_lock(&dcache_lock);
2224                         ll_drop_dentry(dentry);
2225                         spin_unlock(&dcache_lock);
2226                         cfs_spin_unlock(&ll_lookup_lock);
2227                 }
2228
2229                 ll_lookup_finish_locks(&oit, dentry);
2230         } else if (!ll_have_md_lock(dentry->d_inode, ibits, LCK_MINMODE)) {
2231                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2232                 obd_valid valid = OBD_MD_FLGETATTR;
2233                 struct md_op_data *op_data;
2234                 int ealen = 0;
2235
2236                 if (S_ISREG(inode->i_mode)) {
2237                         rc = ll_get_max_mdsize(sbi, &ealen);
2238                         if (rc)
2239                                 RETURN(rc);
2240                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2241                 }
2242
2243                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2244                                              0, ealen, LUSTRE_OPC_ANY,
2245                                              NULL);
2246                 if (op_data == NULL)
2247                         RETURN(-ENOMEM);
2248
2249                 op_data->op_valid = valid;
2250                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2251                  * capa for this inode. Because we only keep capas of dirs
2252                  * fresh. */
2253                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2254                 ll_finish_md_op_data(op_data);
2255                 if (rc) {
2256                         rc = ll_inode_revalidate_fini(inode, rc);
2257                         RETURN(rc);
2258                 }
2259
2260                 rc = ll_prep_inode(&inode, req, NULL);
2261         }
2262 out:
2263         ptlrpc_req_finished(req);
2264         return rc;
2265 }
2266
2267 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it)
2268 {
2269         struct inode *inode = dentry->d_inode;
2270         int rc;
2271         ENTRY;
2272
2273         rc = __ll_inode_revalidate_it(dentry, it, MDS_INODELOCK_UPDATE |
2274                                                   MDS_INODELOCK_LOOKUP);
2275
2276         /* if object not yet allocated, don't validate size */
2277         if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) {
2278                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2279                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2280                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2281                 RETURN(0);
2282         }
2283
2284         /* cl_glimpse_size will prefer locally cached writes if they extend
2285          * the file */
2286
2287         if (rc == 0)
2288                 rc = cl_glimpse_size(inode);
2289
2290         RETURN(rc);
2291 }
2292
2293 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2294                   struct lookup_intent *it, struct kstat *stat)
2295 {
2296         struct inode *inode = de->d_inode;
2297         struct ll_inode_info *lli = ll_i2info(inode);
2298         int res = 0;
2299
2300         res = ll_inode_revalidate_it(de, it);
2301         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETATTR, 1);
2302
2303         if (res)
2304                 return res;
2305
2306         stat->dev = inode->i_sb->s_dev;
2307         if (ll_need_32bit_api(ll_i2sbi(inode)))
2308                 stat->ino = cl_fid_build_ino32(&lli->lli_fid);
2309         else
2310                 stat->ino = inode->i_ino;
2311
2312         stat->mode = inode->i_mode;
2313         stat->nlink = inode->i_nlink;
2314         stat->uid = inode->i_uid;
2315         stat->gid = inode->i_gid;
2316         stat->rdev = kdev_t_to_nr(inode->i_rdev);
2317         stat->atime = inode->i_atime;
2318         stat->mtime = inode->i_mtime;
2319         stat->ctime = inode->i_ctime;
2320 #ifdef HAVE_INODE_BLKSIZE
2321         stat->blksize = inode->i_blksize;
2322 #else
2323         stat->blksize = 1 << inode->i_blkbits;
2324 #endif
2325
2326         stat->size = i_size_read(inode);
2327         stat->blocks = inode->i_blocks;
2328
2329         return 0;
2330 }
2331 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2332 {
2333         struct lookup_intent it = { .it_op = IT_GETATTR };
2334
2335         return ll_getattr_it(mnt, de, &it, stat);
2336 }
2337
2338 #ifdef HAVE_LINUX_FIEMAP_H
2339 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2340                 __u64 start, __u64 len)
2341 {
2342         int rc;
2343         size_t num_bytes;
2344         struct ll_user_fiemap *fiemap;
2345         unsigned int extent_count = fieinfo->fi_extents_max;
2346
2347         num_bytes = sizeof(*fiemap) + (extent_count *
2348                                        sizeof(struct ll_fiemap_extent));
2349         OBD_ALLOC_LARGE(fiemap, num_bytes);
2350
2351         if (fiemap == NULL)
2352                 RETURN(-ENOMEM);
2353
2354         fiemap->fm_flags = fieinfo->fi_flags;
2355         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2356         fiemap->fm_start = start;
2357         fiemap->fm_length = len;
2358         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2359                sizeof(struct ll_fiemap_extent));
2360
2361         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2362
2363         fieinfo->fi_flags = fiemap->fm_flags;
2364         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2365         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2366                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2367
2368         OBD_FREE_LARGE(fiemap, num_bytes);
2369         return rc;
2370 }
2371 #endif
2372
2373
2374 static
2375 int lustre_check_acl(struct inode *inode, int mask)
2376 {
2377 #ifdef CONFIG_FS_POSIX_ACL
2378         struct ll_inode_info *lli = ll_i2info(inode);
2379         struct posix_acl *acl;
2380         int rc;
2381         ENTRY;
2382
2383         cfs_spin_lock(&lli->lli_lock);
2384         acl = posix_acl_dup(lli->lli_posix_acl);
2385         cfs_spin_unlock(&lli->lli_lock);
2386
2387         if (!acl)
2388                 RETURN(-EAGAIN);
2389
2390         rc = posix_acl_permission(inode, acl, mask);
2391         posix_acl_release(acl);
2392
2393         RETURN(rc);
2394 #else
2395         return -EAGAIN;
2396 #endif
2397 }
2398
2399 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
2400 #ifndef HAVE_INODE_PERMISION_2ARGS
2401 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2402 #else
2403 int ll_inode_permission(struct inode *inode, int mask)
2404 #endif
2405 {
2406         int rc = 0;
2407         ENTRY;
2408
2409        /* as root inode are NOT getting validated in lookup operation,
2410         * need to do it before permission check. */
2411
2412         if (inode == inode->i_sb->s_root->d_inode) {
2413                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2414
2415                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2416                                               MDS_INODELOCK_LOOKUP);
2417                 if (rc)
2418                         RETURN(rc);
2419         }
2420
2421         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
2422                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
2423
2424         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2425                 return lustre_check_remote_perm(inode, mask);
2426
2427         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2428         rc = generic_permission(inode, mask, lustre_check_acl);
2429
2430         RETURN(rc);
2431 }
2432 #else
2433 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2434 {
2435         int mode = inode->i_mode;
2436         int rc;
2437
2438         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
2439                inode->i_ino, inode->i_generation, inode, mask);
2440
2441         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2442                 return lustre_check_remote_perm(inode, mask);
2443
2444         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2445
2446         if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
2447             (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
2448                 return -EROFS;
2449         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
2450                 return -EACCES;
2451         if (cfs_curproc_fsuid() == inode->i_uid) {
2452                 mode >>= 6;
2453         } else if (1) {
2454                 if (((mode >> 3) & mask & S_IRWXO) != mask)
2455                         goto check_groups;
2456                 rc = lustre_check_acl(inode, mask);
2457                 if (rc == -EAGAIN)
2458                         goto check_groups;
2459                 if (rc == -EACCES)
2460                         goto check_capabilities;
2461                 return rc;
2462         } else {
2463 check_groups:
2464                 if (cfs_curproc_is_in_groups(inode->i_gid))
2465                         mode >>= 3;
2466         }
2467         if ((mode & mask & S_IRWXO) == mask)
2468                 return 0;
2469
2470 check_capabilities:
2471         if (!(mask & MAY_EXEC) ||
2472             (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
2473                 if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
2474                         return 0;
2475
2476         if (cfs_capable(CFS_CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) ||
2477             (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))))
2478                 return 0;
2479
2480         return -EACCES;
2481 }
2482 #endif
2483
2484 #ifdef HAVE_FILE_READV
2485 #define READ_METHOD readv
2486 #define READ_FUNCTION ll_file_readv
2487 #define WRITE_METHOD writev
2488 #define WRITE_FUNCTION ll_file_writev
2489 #else
2490 #define READ_METHOD aio_read
2491 #define READ_FUNCTION ll_file_aio_read
2492 #define WRITE_METHOD aio_write
2493 #define WRITE_FUNCTION ll_file_aio_write
2494 #endif
2495
2496 /* -o localflock - only provides locally consistent flock locks */
2497 struct file_operations ll_file_operations = {
2498         .read           = ll_file_read,
2499         .READ_METHOD    = READ_FUNCTION,
2500         .write          = ll_file_write,
2501         .WRITE_METHOD   = WRITE_FUNCTION,
2502 #ifdef HAVE_UNLOCKED_IOCTL
2503         .unlocked_ioctl = ll_file_ioctl,
2504 #else
2505         .ioctl          = ll_file_ioctl,
2506 #endif
2507         .open           = ll_file_open,
2508         .release        = ll_file_release,
2509         .mmap           = ll_file_mmap,
2510         .llseek         = ll_file_seek,
2511 #ifdef HAVE_KERNEL_SENDFILE
2512         .sendfile       = ll_file_sendfile,
2513 #endif
2514 #ifdef HAVE_KERNEL_SPLICE_READ
2515         .splice_read    = ll_file_splice_read,
2516 #endif
2517         .fsync          = ll_fsync,
2518         .flush          = ll_flush
2519 };
2520
2521 struct file_operations ll_file_operations_flock = {
2522         .read           = ll_file_read,
2523         .READ_METHOD    = READ_FUNCTION,
2524         .write          = ll_file_write,
2525         .WRITE_METHOD   = WRITE_FUNCTION,
2526 #ifdef HAVE_UNLOCKED_IOCTL
2527         .unlocked_ioctl = ll_file_ioctl,
2528 #else
2529         .ioctl          = ll_file_ioctl,
2530 #endif
2531         .open           = ll_file_open,
2532         .release        = ll_file_release,
2533         .mmap           = ll_file_mmap,
2534         .llseek         = ll_file_seek,
2535 #ifdef HAVE_KERNEL_SENDFILE
2536         .sendfile       = ll_file_sendfile,
2537 #endif
2538 #ifdef HAVE_KERNEL_SPLICE_READ
2539         .splice_read    = ll_file_splice_read,
2540 #endif
2541         .fsync          = ll_fsync,
2542         .flush          = ll_flush,
2543 #ifdef HAVE_F_OP_FLOCK
2544         .flock          = ll_file_flock,
2545 #endif
2546         .lock           = ll_file_flock
2547 };
2548
2549 /* These are for -o noflock - to return ENOSYS on flock calls */
2550 struct file_operations ll_file_operations_noflock = {
2551         .read           = ll_file_read,
2552         .READ_METHOD    = READ_FUNCTION,
2553         .write          = ll_file_write,
2554         .WRITE_METHOD   = WRITE_FUNCTION,
2555 #ifdef HAVE_UNLOCKED_IOCTL
2556         .unlocked_ioctl = ll_file_ioctl,
2557 #else
2558         .ioctl          = ll_file_ioctl,
2559 #endif
2560         .open           = ll_file_open,
2561         .release        = ll_file_release,
2562         .mmap           = ll_file_mmap,
2563         .llseek         = ll_file_seek,
2564 #ifdef HAVE_KERNEL_SENDFILE
2565         .sendfile       = ll_file_sendfile,
2566 #endif
2567 #ifdef HAVE_KERNEL_SPLICE_READ
2568         .splice_read    = ll_file_splice_read,
2569 #endif
2570         .fsync          = ll_fsync,
2571         .flush          = ll_flush,
2572 #ifdef HAVE_F_OP_FLOCK
2573         .flock          = ll_file_noflock,
2574 #endif
2575         .lock           = ll_file_noflock
2576 };
2577
2578 struct inode_operations ll_file_inode_operations = {
2579 #ifdef HAVE_VFS_INTENT_PATCHES
2580         .setattr_raw    = ll_setattr_raw,
2581 #endif
2582         .setattr        = ll_setattr,
2583         .truncate       = ll_truncate,
2584         .getattr        = ll_getattr,
2585         .permission     = ll_inode_permission,
2586         .setxattr       = ll_setxattr,
2587         .getxattr       = ll_getxattr,
2588         .listxattr      = ll_listxattr,
2589         .removexattr    = ll_removexattr,
2590 #ifdef  HAVE_LINUX_FIEMAP_H
2591         .fiemap         = ll_fiemap,
2592 #endif
2593 };
2594
2595 /* dynamic ioctl number support routins */
2596 static struct llioc_ctl_data {
2597         cfs_rw_semaphore_t      ioc_sem;
2598         cfs_list_t              ioc_head;
2599 } llioc = {
2600         __RWSEM_INITIALIZER(llioc.ioc_sem),
2601         CFS_LIST_HEAD_INIT(llioc.ioc_head)
2602 };
2603
2604
2605 struct llioc_data {
2606         cfs_list_t              iocd_list;
2607         unsigned int            iocd_size;
2608         llioc_callback_t        iocd_cb;
2609         unsigned int            iocd_count;
2610         unsigned int            iocd_cmd[0];
2611 };
2612
2613 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
2614 {
2615         unsigned int size;
2616         struct llioc_data *in_data = NULL;
2617         ENTRY;
2618
2619         if (cb == NULL || cmd == NULL ||
2620             count > LLIOC_MAX_CMD || count < 0)
2621                 RETURN(NULL);
2622
2623         size = sizeof(*in_data) + count * sizeof(unsigned int);
2624         OBD_ALLOC(in_data, size);
2625         if (in_data == NULL)
2626                 RETURN(NULL);
2627
2628         memset(in_data, 0, sizeof(*in_data));
2629         in_data->iocd_size = size;
2630         in_data->iocd_cb = cb;
2631         in_data->iocd_count = count;
2632         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
2633
2634         cfs_down_write(&llioc.ioc_sem);
2635         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
2636         cfs_up_write(&llioc.ioc_sem);
2637
2638         RETURN(in_data);
2639 }
2640
2641 void ll_iocontrol_unregister(void *magic)
2642 {
2643         struct llioc_data *tmp;
2644
2645         if (magic == NULL)
2646                 return;
2647
2648         cfs_down_write(&llioc.ioc_sem);
2649         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
2650                 if (tmp == magic) {
2651                         unsigned int size = tmp->iocd_size;
2652
2653                         cfs_list_del(&tmp->iocd_list);
2654                         cfs_up_write(&llioc.ioc_sem);
2655
2656                         OBD_FREE(tmp, size);
2657                         return;
2658                 }
2659         }
2660         cfs_up_write(&llioc.ioc_sem);
2661
2662         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
2663 }
2664
2665 EXPORT_SYMBOL(ll_iocontrol_register);
2666 EXPORT_SYMBOL(ll_iocontrol_unregister);
2667
2668 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
2669                         unsigned int cmd, unsigned long arg, int *rcp)
2670 {
2671         enum llioc_iter ret = LLIOC_CONT;
2672         struct llioc_data *data;
2673         int rc = -EINVAL, i;
2674
2675         cfs_down_read(&llioc.ioc_sem);
2676         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
2677                 for (i = 0; i < data->iocd_count; i++) {
2678                         if (cmd != data->iocd_cmd[i])
2679                                 continue;
2680
2681                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
2682                         break;
2683                 }
2684
2685                 if (ret == LLIOC_STOP)
2686                         break;
2687         }
2688         cfs_up_read(&llioc.ioc_sem);
2689
2690         if (rcp)
2691                 *rcp = rc;
2692         return ret;
2693 }