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(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(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(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(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(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_VMALLOC(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_VFREE(fiemap_s, num_bytes);
1735         RETURN(rc);
1736 }
1737
1738 int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
1739                   unsigned long arg)
1740 {
1741         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1742         int flags;
1743         ENTRY;
1744
1745         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
1746                inode->i_generation, inode, cmd);
1747         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
1748
1749         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
1750         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
1751                 RETURN(-ENOTTY);
1752
1753         switch(cmd) {
1754         case LL_IOC_GETFLAGS:
1755                 /* Get the current value of the file flags */
1756                 return put_user(fd->fd_flags, (int *)arg);
1757         case LL_IOC_SETFLAGS:
1758         case LL_IOC_CLRFLAGS:
1759                 /* Set or clear specific file flags */
1760                 /* XXX This probably needs checks to ensure the flags are
1761                  *     not abused, and to handle any flag side effects.
1762                  */
1763                 if (get_user(flags, (int *) arg))
1764                         RETURN(-EFAULT);
1765
1766                 if (cmd == LL_IOC_SETFLAGS) {
1767                         if ((flags & LL_FILE_IGNORE_LOCK) &&
1768                             !(file->f_flags & O_DIRECT)) {
1769                                 CERROR("%s: unable to disable locking on "
1770                                        "non-O_DIRECT file\n", current->comm);
1771                                 RETURN(-EINVAL);
1772                         }
1773
1774                         fd->fd_flags |= flags;
1775                 } else {
1776                         fd->fd_flags &= ~flags;
1777                 }
1778                 RETURN(0);
1779         case LL_IOC_LOV_SETSTRIPE:
1780                 RETURN(ll_lov_setstripe(inode, file, arg));
1781         case LL_IOC_LOV_SETEA:
1782                 RETURN(ll_lov_setea(inode, file, arg));
1783         case LL_IOC_LOV_GETSTRIPE:
1784                 RETURN(ll_lov_getstripe(inode, arg));
1785         case LL_IOC_RECREATE_OBJ:
1786                 RETURN(ll_lov_recreate_obj(inode, arg));
1787         case LL_IOC_RECREATE_FID:
1788                 RETURN(ll_lov_recreate_fid(inode, arg));
1789         case FSFILT_IOC_FIEMAP:
1790                 RETURN(ll_ioctl_fiemap(inode, arg));
1791         case FSFILT_IOC_GETFLAGS:
1792         case FSFILT_IOC_SETFLAGS:
1793                 RETURN(ll_iocontrol(inode, file, cmd, arg));
1794         case FSFILT_IOC_GETVERSION_OLD:
1795         case FSFILT_IOC_GETVERSION:
1796                 RETURN(put_user(inode->i_generation, (int *)arg));
1797         case LL_IOC_GROUP_LOCK:
1798                 RETURN(ll_get_grouplock(inode, file, arg));
1799         case LL_IOC_GROUP_UNLOCK:
1800                 RETURN(ll_put_grouplock(inode, file, arg));
1801         case IOC_OBD_STATFS:
1802                 RETURN(ll_obd_statfs(inode, (void *)arg));
1803
1804         /* We need to special case any other ioctls we want to handle,
1805          * to send them to the MDS/OST as appropriate and to properly
1806          * network encode the arg field.
1807         case FSFILT_IOC_SETVERSION_OLD:
1808         case FSFILT_IOC_SETVERSION:
1809         */
1810         case LL_IOC_FLUSHCTX:
1811                 RETURN(ll_flush_ctx(inode));
1812         case LL_IOC_PATH2FID: {
1813                 if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode),
1814                                      sizeof(struct lu_fid)))
1815                         RETURN(-EFAULT);
1816
1817                 RETURN(0);
1818         }
1819         case OBD_IOC_FID2PATH:
1820                 RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg));
1821
1822         case LL_IOC_GET_MDTIDX: {
1823                 int mdtidx;
1824
1825                 mdtidx = ll_get_mdt_idx(inode);
1826                 if (mdtidx < 0)
1827                         RETURN(mdtidx);
1828
1829                 if (put_user((int)mdtidx, (int*)arg))
1830                         RETURN(-EFAULT);
1831
1832                 RETURN(0);
1833         }
1834
1835         default: {
1836                 int err;
1837
1838                 if (LLIOC_STOP ==
1839                     ll_iocontrol_call(inode, file, cmd, arg, &err))
1840                         RETURN(err);
1841
1842                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
1843                                      (void *)arg));
1844         }
1845         }
1846 }
1847
1848 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
1849 {
1850         struct inode *inode = file->f_dentry->d_inode;
1851         loff_t retval;
1852         ENTRY;
1853         retval = offset + ((origin == 2) ? i_size_read(inode) :
1854                            (origin == 1) ? file->f_pos : 0);
1855         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
1856                inode->i_ino, inode->i_generation, inode, retval, retval,
1857                origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
1858         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
1859
1860         if (origin == 2) { /* SEEK_END */
1861                 int nonblock = 0, rc;
1862
1863                 if (file->f_flags & O_NONBLOCK)
1864                         nonblock = LDLM_FL_BLOCK_NOWAIT;
1865
1866                 rc = cl_glimpse_size(inode);
1867                 if (rc != 0)
1868                         RETURN(rc);
1869
1870                 offset += i_size_read(inode);
1871         } else if (origin == 1) { /* SEEK_CUR */
1872                 offset += file->f_pos;
1873         }
1874
1875         retval = -EINVAL;
1876         if (offset >= 0 && offset <= ll_file_maxbytes(inode)) {
1877                 if (offset != file->f_pos) {
1878                         file->f_pos = offset;
1879                 }
1880                 retval = offset;
1881         }
1882
1883         RETURN(retval);
1884 }
1885
1886 #ifdef HAVE_FLUSH_OWNER_ID
1887 int ll_flush(struct file *file, fl_owner_t id)
1888 #else
1889 int ll_flush(struct file *file)
1890 #endif
1891 {
1892         struct inode *inode = file->f_dentry->d_inode;
1893         struct ll_inode_info *lli = ll_i2info(inode);
1894         struct lov_stripe_md *lsm = lli->lli_smd;
1895         int rc, err;
1896
1897         /* the application should know write failure already. */
1898         if (lli->lli_write_rc)
1899                 return 0;
1900
1901         /* catch async errors that were recorded back when async writeback
1902          * failed for pages in this mapping. */
1903         rc = lli->lli_async_rc;
1904         lli->lli_async_rc = 0;
1905         if (lsm) {
1906                 err = lov_test_and_clear_async_rc(lsm);
1907                 if (rc == 0)
1908                         rc = err;
1909         }
1910
1911         return rc ? -EIO : 0;
1912 }
1913
1914 int ll_fsync(struct file *file, struct dentry *dentry, int data)
1915 {
1916         struct inode *inode = dentry->d_inode;
1917         struct ll_inode_info *lli = ll_i2info(inode);
1918         struct lov_stripe_md *lsm = lli->lli_smd;
1919         struct ptlrpc_request *req;
1920         struct obd_capa *oc;
1921         int rc, err;
1922         ENTRY;
1923         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
1924                inode->i_generation, inode);
1925         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
1926
1927         /* fsync's caller has already called _fdata{sync,write}, we want
1928          * that IO to finish before calling the osc and mdc sync methods */
1929         rc = filemap_fdatawait(inode->i_mapping);
1930
1931         /* catch async errors that were recorded back when async writeback
1932          * failed for pages in this mapping. */
1933         err = lli->lli_async_rc;
1934         lli->lli_async_rc = 0;
1935         if (rc == 0)
1936                 rc = err;
1937         if (lsm) {
1938                 err = lov_test_and_clear_async_rc(lsm);
1939                 if (rc == 0)
1940                         rc = err;
1941         }
1942
1943         oc = ll_mdscapa_get(inode);
1944         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
1945                       &req);
1946         capa_put(oc);
1947         if (!rc)
1948                 rc = err;
1949         if (!err)
1950                 ptlrpc_req_finished(req);
1951
1952         if (data && lsm) {
1953                 struct obdo *oa;
1954
1955                 OBDO_ALLOC(oa);
1956                 if (!oa)
1957                         RETURN(rc ? rc : -ENOMEM);
1958
1959                 oa->o_id = lsm->lsm_object_id;
1960                 oa->o_seq = lsm->lsm_object_seq;
1961                 oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1962                 obdo_from_inode(oa, inode, &ll_i2info(inode)->lli_fid,
1963                                 OBD_MD_FLTYPE | OBD_MD_FLATIME |
1964                                 OBD_MD_FLMTIME | OBD_MD_FLCTIME |
1965                                 OBD_MD_FLGROUP);
1966
1967                 oc = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
1968                 err = obd_sync(ll_i2sbi(inode)->ll_dt_exp, oa, lsm,
1969                                0, OBD_OBJECT_EOF, oc);
1970                 capa_put(oc);
1971                 if (!rc)
1972                         rc = err;
1973                 OBDO_FREE(oa);
1974                 lli->lli_write_rc = err < 0 ? : 0;
1975         }
1976
1977         RETURN(rc);
1978 }
1979
1980 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
1981 {
1982         struct inode *inode = file->f_dentry->d_inode;
1983         struct ll_sb_info *sbi = ll_i2sbi(inode);
1984         struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK,
1985                                            .ei_cb_cp =ldlm_flock_completion_ast,
1986                                            .ei_cbdata = file_lock };
1987         struct md_op_data *op_data;
1988         struct lustre_handle lockh = {0};
1989         ldlm_policy_data_t flock;
1990         int flags = 0;
1991         int rc;
1992         ENTRY;
1993
1994         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
1995                inode->i_ino, file_lock);
1996
1997         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
1998
1999         if (file_lock->fl_flags & FL_FLOCK) {
2000                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2001                 /* set missing params for flock() calls */
2002                 file_lock->fl_end = OFFSET_MAX;
2003                 file_lock->fl_pid = current->tgid;
2004         }
2005         flock.l_flock.pid = file_lock->fl_pid;
2006         flock.l_flock.start = file_lock->fl_start;
2007         flock.l_flock.end = file_lock->fl_end;
2008
2009         switch (file_lock->fl_type) {
2010         case F_RDLCK:
2011                 einfo.ei_mode = LCK_PR;
2012                 break;
2013         case F_UNLCK:
2014                 /* An unlock request may or may not have any relation to
2015                  * existing locks so we may not be able to pass a lock handle
2016                  * via a normal ldlm_lock_cancel() request. The request may even
2017                  * unlock a byte range in the middle of an existing lock. In
2018                  * order to process an unlock request we need all of the same
2019                  * information that is given with a normal read or write record
2020                  * lock request. To avoid creating another ldlm unlock (cancel)
2021                  * message we'll treat a LCK_NL flock request as an unlock. */
2022                 einfo.ei_mode = LCK_NL;
2023                 break;
2024         case F_WRLCK:
2025                 einfo.ei_mode = LCK_PW;
2026                 break;
2027         default:
2028                 CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
2029                 RETURN (-EINVAL);
2030         }
2031
2032         switch (cmd) {
2033         case F_SETLKW:
2034 #ifdef F_SETLKW64
2035         case F_SETLKW64:
2036 #endif
2037                 flags = 0;
2038                 break;
2039         case F_SETLK:
2040 #ifdef F_SETLK64
2041         case F_SETLK64:
2042 #endif
2043                 flags = LDLM_FL_BLOCK_NOWAIT;
2044                 break;
2045         case F_GETLK:
2046 #ifdef F_GETLK64
2047         case F_GETLK64:
2048 #endif
2049                 flags = LDLM_FL_TEST_LOCK;
2050                 /* Save the old mode so that if the mode in the lock changes we
2051                  * can decrement the appropriate reader or writer refcount. */
2052                 file_lock->fl_type = einfo.ei_mode;
2053                 break;
2054         default:
2055                 CERROR("unknown fcntl lock command: %d\n", cmd);
2056                 RETURN (-EINVAL);
2057         }
2058
2059         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2060                                      LUSTRE_OPC_ANY, NULL);
2061         if (IS_ERR(op_data))
2062                 RETURN(PTR_ERR(op_data));
2063
2064         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2065                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2066                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2067
2068         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2069                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
2070
2071         ll_finish_md_op_data(op_data);
2072
2073         if ((file_lock->fl_flags & FL_FLOCK) &&
2074             (rc == 0 || file_lock->fl_type == F_UNLCK))
2075                 ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
2076 #ifdef HAVE_F_OP_FLOCK
2077         if ((file_lock->fl_flags & FL_POSIX) &&
2078             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2079             !(flags & LDLM_FL_TEST_LOCK))
2080                 posix_lock_file_wait(file, file_lock);
2081 #endif
2082
2083         RETURN(rc);
2084 }
2085
2086 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2087 {
2088         ENTRY;
2089
2090         RETURN(-ENOSYS);
2091 }
2092
2093 int ll_have_md_lock(struct inode *inode, __u64 bits,  ldlm_mode_t l_req_mode)
2094 {
2095         struct lustre_handle lockh;
2096         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2097         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2098                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2099         struct lu_fid *fid;
2100         int flags;
2101         ENTRY;
2102
2103         if (!inode)
2104                RETURN(0);
2105
2106         fid = &ll_i2info(inode)->lli_fid;
2107         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2108                ldlm_lockname[mode]);
2109
2110         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2111         if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2112                           mode, &lockh)) {
2113                 RETURN(1);
2114         }
2115         RETURN(0);
2116 }
2117
2118 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2119                             struct lustre_handle *lockh)
2120 {
2121         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2122         struct lu_fid *fid;
2123         ldlm_mode_t rc;
2124         int flags;
2125         ENTRY;
2126
2127         fid = &ll_i2info(inode)->lli_fid;
2128         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2129
2130         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING;
2131         rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2132                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2133         RETURN(rc);
2134 }
2135
2136 static int ll_inode_revalidate_fini(struct inode *inode, int rc) {
2137         if (rc == -ENOENT) { /* Already unlinked. Just update nlink
2138                               * and return success */
2139                 inode->i_nlink = 0;
2140                 /* This path cannot be hit for regular files unless in
2141                  * case of obscure races, so no need to to validate
2142                  * size. */
2143                 if (!S_ISREG(inode->i_mode) &&
2144                     !S_ISDIR(inode->i_mode))
2145                         return 0;
2146         }
2147
2148         if (rc) {
2149                 CERROR("failure %d inode %lu\n", rc, inode->i_ino);
2150                 return -abs(rc);
2151
2152         }
2153
2154         return 0;
2155 }
2156
2157 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2158                              __u64 ibits)
2159 {
2160         struct inode *inode = dentry->d_inode;
2161         struct ptlrpc_request *req = NULL;
2162         struct ll_sb_info *sbi;
2163         struct obd_export *exp;
2164         int rc = 0;
2165         ENTRY;
2166
2167         if (!inode) {
2168                 CERROR("REPORT THIS LINE TO PETER\n");
2169                 RETURN(0);
2170         }
2171         sbi = ll_i2sbi(inode);
2172
2173         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2174                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2175
2176         exp = ll_i2mdexp(inode);
2177
2178         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
2179          *      But under CMD case, it caused some lock issues, should be fixed
2180          *      with new CMD ibits lock. See bug 12718 */
2181         if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) {
2182                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2183                 struct md_op_data *op_data;
2184
2185                 /* Call getattr by fid, so do not provide name at all. */
2186                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2187                                              dentry->d_inode, NULL, 0, 0,
2188                                              LUSTRE_OPC_ANY, NULL);
2189                 if (IS_ERR(op_data))
2190                         RETURN(PTR_ERR(op_data));
2191
2192                 oit.it_create_mode |= M_CHECK_STALE;
2193                 rc = md_intent_lock(exp, op_data, NULL, 0,
2194                                     /* we are not interested in name
2195                                        based lookup */
2196                                     &oit, 0, &req,
2197                                     ll_md_blocking_ast, 0);
2198                 ll_finish_md_op_data(op_data);
2199                 oit.it_create_mode &= ~M_CHECK_STALE;
2200                 if (rc < 0) {
2201                         rc = ll_inode_revalidate_fini(inode, rc);
2202                         GOTO (out, rc);
2203                 }
2204
2205                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2206                 if (rc != 0) {
2207                         ll_intent_release(&oit);
2208                         GOTO(out, rc);
2209                 }
2210
2211                 /* Unlinked? Unhash dentry, so it is not picked up later by
2212                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2213                    here to preserve get_cwd functionality on 2.6.
2214                    Bug 10503 */
2215                 if (!dentry->d_inode->i_nlink) {
2216                         cfs_spin_lock(&ll_lookup_lock);
2217                         spin_lock(&dcache_lock);
2218                         ll_drop_dentry(dentry);
2219                         spin_unlock(&dcache_lock);
2220                         cfs_spin_unlock(&ll_lookup_lock);
2221                 }
2222
2223                 ll_lookup_finish_locks(&oit, dentry);
2224         } else if (!ll_have_md_lock(dentry->d_inode, ibits, LCK_MINMODE)) {
2225                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2226                 obd_valid valid = OBD_MD_FLGETATTR;
2227                 struct md_op_data *op_data;
2228                 int ealen = 0;
2229
2230                 if (S_ISREG(inode->i_mode)) {
2231                         rc = ll_get_max_mdsize(sbi, &ealen);
2232                         if (rc)
2233                                 RETURN(rc);
2234                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2235                 }
2236
2237                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2238                                              0, ealen, LUSTRE_OPC_ANY,
2239                                              NULL);
2240                 if (op_data == NULL)
2241                         RETURN(-ENOMEM);
2242
2243                 op_data->op_valid = valid;
2244                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2245                  * capa for this inode. Because we only keep capas of dirs
2246                  * fresh. */
2247                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2248                 ll_finish_md_op_data(op_data);
2249                 if (rc) {
2250                         rc = ll_inode_revalidate_fini(inode, rc);
2251                         RETURN(rc);
2252                 }
2253
2254                 rc = ll_prep_inode(&inode, req, NULL);
2255         }
2256 out:
2257         ptlrpc_req_finished(req);
2258         return rc;
2259 }
2260
2261 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it)
2262 {
2263         struct inode *inode = dentry->d_inode;
2264         int rc;
2265         ENTRY;
2266
2267         rc = __ll_inode_revalidate_it(dentry, it, MDS_INODELOCK_UPDATE |
2268                                                   MDS_INODELOCK_LOOKUP);
2269
2270         /* if object not yet allocated, don't validate size */
2271         if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) {
2272                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2273                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2274                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2275                 RETURN(0);
2276         }
2277
2278         /* cl_glimpse_size will prefer locally cached writes if they extend
2279          * the file */
2280
2281         if (rc == 0)
2282                 rc = cl_glimpse_size(inode);
2283
2284         RETURN(rc);
2285 }
2286
2287 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2288                   struct lookup_intent *it, struct kstat *stat)
2289 {
2290         struct inode *inode = de->d_inode;
2291         struct ll_inode_info *lli = ll_i2info(inode);
2292         int res = 0;
2293
2294         res = ll_inode_revalidate_it(de, it);
2295         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETATTR, 1);
2296
2297         if (res)
2298                 return res;
2299
2300         stat->dev = inode->i_sb->s_dev;
2301         if (ll_need_32bit_api(ll_i2sbi(inode)))
2302                 stat->ino = cl_fid_build_ino32(&lli->lli_fid);
2303         else
2304                 stat->ino = inode->i_ino;
2305
2306         stat->mode = inode->i_mode;
2307         stat->nlink = inode->i_nlink;
2308         stat->uid = inode->i_uid;
2309         stat->gid = inode->i_gid;
2310         stat->rdev = kdev_t_to_nr(inode->i_rdev);
2311         stat->atime = inode->i_atime;
2312         stat->mtime = inode->i_mtime;
2313         stat->ctime = inode->i_ctime;
2314 #ifdef HAVE_INODE_BLKSIZE
2315         stat->blksize = inode->i_blksize;
2316 #else
2317         stat->blksize = 1 << inode->i_blkbits;
2318 #endif
2319
2320         stat->size = i_size_read(inode);
2321         stat->blocks = inode->i_blocks;
2322
2323         return 0;
2324 }
2325 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2326 {
2327         struct lookup_intent it = { .it_op = IT_GETATTR };
2328
2329         return ll_getattr_it(mnt, de, &it, stat);
2330 }
2331
2332 #ifdef HAVE_LINUX_FIEMAP_H
2333 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2334                 __u64 start, __u64 len)
2335 {
2336         int rc;
2337         size_t num_bytes;
2338         struct ll_user_fiemap *fiemap;
2339         unsigned int extent_count = fieinfo->fi_extents_max;
2340
2341         num_bytes = sizeof(*fiemap) + (extent_count *
2342                                        sizeof(struct ll_fiemap_extent));
2343         OBD_VMALLOC(fiemap, num_bytes);
2344
2345         if (fiemap == NULL)
2346                 RETURN(-ENOMEM);
2347
2348         fiemap->fm_flags = fieinfo->fi_flags;
2349         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2350         fiemap->fm_start = start;
2351         fiemap->fm_length = len;
2352         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2353                sizeof(struct ll_fiemap_extent));
2354
2355         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2356
2357         fieinfo->fi_flags = fiemap->fm_flags;
2358         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2359         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2360                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2361
2362         OBD_VFREE(fiemap, num_bytes);
2363         return rc;
2364 }
2365 #endif
2366
2367
2368 static
2369 int lustre_check_acl(struct inode *inode, int mask)
2370 {
2371 #ifdef CONFIG_FS_POSIX_ACL
2372         struct ll_inode_info *lli = ll_i2info(inode);
2373         struct posix_acl *acl;
2374         int rc;
2375         ENTRY;
2376
2377         cfs_spin_lock(&lli->lli_lock);
2378         acl = posix_acl_dup(lli->lli_posix_acl);
2379         cfs_spin_unlock(&lli->lli_lock);
2380
2381         if (!acl)
2382                 RETURN(-EAGAIN);
2383
2384         rc = posix_acl_permission(inode, acl, mask);
2385         posix_acl_release(acl);
2386
2387         RETURN(rc);
2388 #else
2389         return -EAGAIN;
2390 #endif
2391 }
2392
2393 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
2394 #ifndef HAVE_INODE_PERMISION_2ARGS
2395 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2396 #else
2397 int ll_inode_permission(struct inode *inode, int mask)
2398 #endif
2399 {
2400         int rc = 0;
2401         ENTRY;
2402
2403        /* as root inode are NOT getting validated in lookup operation,
2404         * need to do it before permission check. */
2405
2406         if (inode == inode->i_sb->s_root->d_inode) {
2407                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2408
2409                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2410                                               MDS_INODELOCK_LOOKUP);
2411                 if (rc)
2412                         RETURN(rc);
2413         }
2414
2415         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
2416                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
2417
2418         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2419                 return lustre_check_remote_perm(inode, mask);
2420
2421         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2422         rc = generic_permission(inode, mask, lustre_check_acl);
2423
2424         RETURN(rc);
2425 }
2426 #else
2427 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2428 {
2429         int mode = inode->i_mode;
2430         int rc;
2431
2432         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
2433                inode->i_ino, inode->i_generation, inode, mask);
2434
2435         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2436                 return lustre_check_remote_perm(inode, mask);
2437
2438         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2439
2440         if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
2441             (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
2442                 return -EROFS;
2443         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
2444                 return -EACCES;
2445         if (cfs_curproc_fsuid() == inode->i_uid) {
2446                 mode >>= 6;
2447         } else if (1) {
2448                 if (((mode >> 3) & mask & S_IRWXO) != mask)
2449                         goto check_groups;
2450                 rc = lustre_check_acl(inode, mask);
2451                 if (rc == -EAGAIN)
2452                         goto check_groups;
2453                 if (rc == -EACCES)
2454                         goto check_capabilities;
2455                 return rc;
2456         } else {
2457 check_groups:
2458                 if (cfs_curproc_is_in_groups(inode->i_gid))
2459                         mode >>= 3;
2460         }
2461         if ((mode & mask & S_IRWXO) == mask)
2462                 return 0;
2463
2464 check_capabilities:
2465         if (!(mask & MAY_EXEC) ||
2466             (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
2467                 if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
2468                         return 0;
2469
2470         if (cfs_capable(CFS_CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) ||
2471             (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))))
2472                 return 0;
2473
2474         return -EACCES;
2475 }
2476 #endif
2477
2478 #ifdef HAVE_FILE_READV
2479 #define READ_METHOD readv
2480 #define READ_FUNCTION ll_file_readv
2481 #define WRITE_METHOD writev
2482 #define WRITE_FUNCTION ll_file_writev
2483 #else
2484 #define READ_METHOD aio_read
2485 #define READ_FUNCTION ll_file_aio_read
2486 #define WRITE_METHOD aio_write
2487 #define WRITE_FUNCTION ll_file_aio_write
2488 #endif
2489
2490 /* -o localflock - only provides locally consistent flock locks */
2491 struct file_operations ll_file_operations = {
2492         .read           = ll_file_read,
2493         .READ_METHOD    = READ_FUNCTION,
2494         .write          = ll_file_write,
2495         .WRITE_METHOD   = WRITE_FUNCTION,
2496         .ioctl          = ll_file_ioctl,
2497         .open           = ll_file_open,
2498         .release        = ll_file_release,
2499         .mmap           = ll_file_mmap,
2500         .llseek         = ll_file_seek,
2501 #ifdef HAVE_KERNEL_SENDFILE
2502         .sendfile       = ll_file_sendfile,
2503 #endif
2504 #ifdef HAVE_KERNEL_SPLICE_READ
2505         .splice_read    = ll_file_splice_read,
2506 #endif
2507         .fsync          = ll_fsync,
2508         .flush          = ll_flush
2509 };
2510
2511 struct file_operations ll_file_operations_flock = {
2512         .read           = ll_file_read,
2513         .READ_METHOD    = READ_FUNCTION,
2514         .write          = ll_file_write,
2515         .WRITE_METHOD   = WRITE_FUNCTION,
2516         .ioctl          = ll_file_ioctl,
2517         .open           = ll_file_open,
2518         .release        = ll_file_release,
2519         .mmap           = ll_file_mmap,
2520         .llseek         = ll_file_seek,
2521 #ifdef HAVE_KERNEL_SENDFILE
2522         .sendfile       = ll_file_sendfile,
2523 #endif
2524 #ifdef HAVE_KERNEL_SPLICE_READ
2525         .splice_read    = ll_file_splice_read,
2526 #endif
2527         .fsync          = ll_fsync,
2528         .flush          = ll_flush,
2529 #ifdef HAVE_F_OP_FLOCK
2530         .flock          = ll_file_flock,
2531 #endif
2532         .lock           = ll_file_flock
2533 };
2534
2535 /* These are for -o noflock - to return ENOSYS on flock calls */
2536 struct file_operations ll_file_operations_noflock = {
2537         .read           = ll_file_read,
2538         .READ_METHOD    = READ_FUNCTION,
2539         .write          = ll_file_write,
2540         .WRITE_METHOD   = WRITE_FUNCTION,
2541         .ioctl          = ll_file_ioctl,
2542         .open           = ll_file_open,
2543         .release        = ll_file_release,
2544         .mmap           = ll_file_mmap,
2545         .llseek         = ll_file_seek,
2546 #ifdef HAVE_KERNEL_SENDFILE
2547         .sendfile       = ll_file_sendfile,
2548 #endif
2549 #ifdef HAVE_KERNEL_SPLICE_READ
2550         .splice_read    = ll_file_splice_read,
2551 #endif
2552         .fsync          = ll_fsync,
2553         .flush          = ll_flush,
2554 #ifdef HAVE_F_OP_FLOCK
2555         .flock          = ll_file_noflock,
2556 #endif
2557         .lock           = ll_file_noflock
2558 };
2559
2560 struct inode_operations ll_file_inode_operations = {
2561 #ifdef HAVE_VFS_INTENT_PATCHES
2562         .setattr_raw    = ll_setattr_raw,
2563 #endif
2564         .setattr        = ll_setattr,
2565         .truncate       = ll_truncate,
2566         .getattr        = ll_getattr,
2567         .permission     = ll_inode_permission,
2568         .setxattr       = ll_setxattr,
2569         .getxattr       = ll_getxattr,
2570         .listxattr      = ll_listxattr,
2571         .removexattr    = ll_removexattr,
2572 #ifdef  HAVE_LINUX_FIEMAP_H
2573         .fiemap         = ll_fiemap,
2574 #endif
2575 };
2576
2577 /* dynamic ioctl number support routins */
2578 static struct llioc_ctl_data {
2579         cfs_rw_semaphore_t      ioc_sem;
2580         cfs_list_t              ioc_head;
2581 } llioc = {
2582         __RWSEM_INITIALIZER(llioc.ioc_sem),
2583         CFS_LIST_HEAD_INIT(llioc.ioc_head)
2584 };
2585
2586
2587 struct llioc_data {
2588         cfs_list_t              iocd_list;
2589         unsigned int            iocd_size;
2590         llioc_callback_t        iocd_cb;
2591         unsigned int            iocd_count;
2592         unsigned int            iocd_cmd[0];
2593 };
2594
2595 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
2596 {
2597         unsigned int size;
2598         struct llioc_data *in_data = NULL;
2599         ENTRY;
2600
2601         if (cb == NULL || cmd == NULL ||
2602             count > LLIOC_MAX_CMD || count < 0)
2603                 RETURN(NULL);
2604
2605         size = sizeof(*in_data) + count * sizeof(unsigned int);
2606         OBD_ALLOC(in_data, size);
2607         if (in_data == NULL)
2608                 RETURN(NULL);
2609
2610         memset(in_data, 0, sizeof(*in_data));
2611         in_data->iocd_size = size;
2612         in_data->iocd_cb = cb;
2613         in_data->iocd_count = count;
2614         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
2615
2616         cfs_down_write(&llioc.ioc_sem);
2617         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
2618         cfs_up_write(&llioc.ioc_sem);
2619
2620         RETURN(in_data);
2621 }
2622
2623 void ll_iocontrol_unregister(void *magic)
2624 {
2625         struct llioc_data *tmp;
2626
2627         if (magic == NULL)
2628                 return;
2629
2630         cfs_down_write(&llioc.ioc_sem);
2631         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
2632                 if (tmp == magic) {
2633                         unsigned int size = tmp->iocd_size;
2634
2635                         cfs_list_del(&tmp->iocd_list);
2636                         cfs_up_write(&llioc.ioc_sem);
2637
2638                         OBD_FREE(tmp, size);
2639                         return;
2640                 }
2641         }
2642         cfs_up_write(&llioc.ioc_sem);
2643
2644         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
2645 }
2646
2647 EXPORT_SYMBOL(ll_iocontrol_register);
2648 EXPORT_SYMBOL(ll_iocontrol_unregister);
2649
2650 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
2651                         unsigned int cmd, unsigned long arg, int *rcp)
2652 {
2653         enum llioc_iter ret = LLIOC_CONT;
2654         struct llioc_data *data;
2655         int rc = -EINVAL, i;
2656
2657         cfs_down_read(&llioc.ioc_sem);
2658         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
2659                 for (i = 0; i < data->iocd_count; i++) {
2660                         if (cmd != data->iocd_cmd[i])
2661                                 continue;
2662
2663                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
2664                         break;
2665                 }
2666
2667                 if (ret == LLIOC_STOP)
2668                         break;
2669         }
2670         cfs_up_read(&llioc.ioc_sem);
2671
2672         if (rcp)
2673                 *rcp = rc;
2674         return ret;
2675 }