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