lustre/llite/file.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2013, Intel Corporation.
  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 <linux/pagemap.h>
  46 #include <linux/file.h>
  47 #include <linux/sched.h>
  48 #include "llite_internal.h"
  49 #include <lustre/ll_fiemap.h>
  50 #include <lustre_ioctl.h>
  51
  52 #include "cl_object.h"
  53
  54 static int
  55 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
  56
  57 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
  58                           bool *lease_broken);
  59
  60 static enum llioc_iter
  61 ll_iocontrol_call(struct inode *inode, struct file *file,
  62                   unsigned int cmd, unsigned long arg, int *rcp);
  63
  64 static struct ll_file_data *ll_file_data_get(void)
  65 {
  66         struct ll_file_data *fd;
  67
  68         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
  69         if (fd == NULL)
  70                 return NULL;
  71
  72         fd->fd_write_failed = false;
  73
  74         return fd;
  75 }
  76
  77 static void ll_file_data_put(struct ll_file_data *fd)
  78 {
  79         if (fd != NULL)
  80                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
  81 }
  82
  83 void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
  84                           struct lustre_handle *fh)
  85 {
  86         op_data->op_fid1 = ll_i2info(inode)->lli_fid;
  87         op_data->op_attr.ia_mode = inode->i_mode;
  88         op_data->op_attr.ia_atime = inode->i_atime;
  89         op_data->op_attr.ia_mtime = inode->i_mtime;
  90         op_data->op_attr.ia_ctime = inode->i_ctime;
  91         op_data->op_attr.ia_size = i_size_read(inode);
  92         op_data->op_attr_blocks = inode->i_blocks;
  93         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
  94         op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch;
  95         if (fh)
  96                 op_data->op_handle = *fh;
  97         op_data->op_capa1 = ll_mdscapa_get(inode);
  98
  99         if (LLIF_DATA_MODIFIED & ll_i2info(inode)->lli_flags)
 100                 op_data->op_bias |= MDS_DATA_MODIFIED;
 101 }
 102
 103 /**
 104  * Closes the IO epoch and packs all the attributes into @op_data for
 105  * the CLOSE rpc.
 106  */
 107 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
 108                              struct obd_client_handle *och)
 109 {
 110         ENTRY;
 111
 112         op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
 113                                         ATTR_MTIME | ATTR_MTIME_SET |
 114                                         ATTR_CTIME | ATTR_CTIME_SET;
 115
 116         if (!(och->och_flags & FMODE_WRITE))
 117                 goto out;
 118
 119         if (!exp_connect_som(ll_i2mdexp(inode)) || !S_ISREG(inode->i_mode))
 120                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 121         else
 122                 ll_ioepoch_close(inode, op_data, &och, 0);
 123
 124 out:
 125         ll_pack_inode2opdata(inode, op_data, &och->och_fh);
 126         ll_prep_md_op_data(op_data, inode, NULL, NULL,
 127                            0, 0, LUSTRE_OPC_ANY, NULL);
 128         EXIT;
 129 }
 130
 131 static int ll_close_inode_openhandle(struct obd_export *md_exp,
 132                                      struct inode *inode,
 133                                      struct obd_client_handle *och,
 134                                      const __u64 *data_version)
 135 {
 136         struct obd_export *exp = ll_i2mdexp(inode);
 137         struct md_op_data *op_data;
 138         struct ptlrpc_request *req = NULL;
 139         struct obd_device *obd = class_exp2obd(exp);
 140         int epoch_close = 1;
 141         int rc;
 142         ENTRY;
 143
 144         if (obd == NULL) {
 145                 /*
 146                  * XXX: in case of LMV, is this correct to access
 147                  * ->exp_handle?
 148                  */
 149                 CERROR("Invalid MDC connection handle "LPX64"\n",
 150                        ll_i2mdexp(inode)->exp_handle.h_cookie);
 151                 GOTO(out, rc = 0);
 152         }
 153
 154         OBD_ALLOC_PTR(op_data);
 155         if (op_data == NULL)
 156                 GOTO(out, rc = -ENOMEM); // XXX We leak openhandle and request here.
 157
 158         ll_prepare_close(inode, op_data, och);
 159         if (data_version != NULL) {
 160                 /* Pass in data_version implies release. */
 161                 op_data->op_bias |= MDS_HSM_RELEASE;
 162                 op_data->op_data_version = *data_version;
 163                 op_data->op_lease_handle = och->och_lease_handle;
 164                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 165         }
 166         epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE);
 167         rc = md_close(md_exp, op_data, och->och_mod, &req);
 168         if (rc == -EAGAIN) {
 169                 /* This close must have the epoch closed. */
 170                 LASSERT(epoch_close);
 171                 /* MDS has instructed us to obtain Size-on-MDS attribute from
 172                  * OSTs and send setattr to back to MDS. */
 173                 rc = ll_som_update(inode, op_data);
 174                 if (rc) {
 175                         CERROR("%s: inode "DFID" mdc Size-on-MDS update"
 176                                " failed: rc = %d\n",
 177                                ll_i2mdexp(inode)->exp_obd->obd_name,
 178                                PFID(ll_inode2fid(inode)), rc);
 179                         rc = 0;
 180                 }
 181         } else if (rc) {
 182                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
 183                        ll_i2mdexp(inode)->exp_obd->obd_name,
 184                        PFID(ll_inode2fid(inode)), rc);
 185         }
 186
 187         /* DATA_MODIFIED flag was successfully sent on close, cancel data
 188          * modification flag. */
 189         if (rc == 0 && (op_data->op_bias & MDS_DATA_MODIFIED)) {
 190                 struct ll_inode_info *lli = ll_i2info(inode);
 191
 192                 spin_lock(&lli->lli_lock);
 193                 lli->lli_flags &= ~LLIF_DATA_MODIFIED;
 194                 spin_unlock(&lli->lli_lock);
 195         }
 196
 197         if (rc == 0) {
 198                 rc = ll_objects_destroy(req, inode);
 199                 if (rc)
 200                         CERROR("%s: inode "DFID
 201                                " ll_objects destroy: rc = %d\n",
 202                                ll_i2mdexp(inode)->exp_obd->obd_name,
 203                                PFID(ll_inode2fid(inode)), rc);
 204         }
 205
 206         if (rc == 0 && op_data->op_bias & MDS_HSM_RELEASE) {
 207                 struct mdt_body *body;
 208                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 209                 if (!(body->mbo_valid & OBD_MD_FLRELEASED))
 210                         rc = -EBUSY;
 211         }
 212
 213         ll_finish_md_op_data(op_data);
 214         EXIT;
 215 out:
 216
 217         if (exp_connect_som(exp) && !epoch_close &&
 218             S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) {
 219                 ll_queue_done_writing(inode, LLIF_DONE_WRITING);
 220         } else {
 221                 md_clear_open_replay_data(md_exp, och);
 222                 /* Free @och if it is not waiting for DONE_WRITING. */
 223                 och->och_fh.cookie = DEAD_HANDLE_MAGIC;
 224                 OBD_FREE_PTR(och);
 225         }
 226         if (req) /* This is close request */
 227                 ptlrpc_req_finished(req);
 228         return rc;
 229 }
 230
 231 int ll_md_real_close(struct inode *inode, fmode_t fmode)
 232 {
 233         struct ll_inode_info *lli = ll_i2info(inode);
 234         struct obd_client_handle **och_p;
 235         struct obd_client_handle *och;
 236         __u64 *och_usecount;
 237         int rc = 0;
 238         ENTRY;
 239
 240         if (fmode & FMODE_WRITE) {
 241                 och_p = &lli->lli_mds_write_och;
 242                 och_usecount = &lli->lli_open_fd_write_count;
 243         } else if (fmode & FMODE_EXEC) {
 244                 och_p = &lli->lli_mds_exec_och;
 245                 och_usecount = &lli->lli_open_fd_exec_count;
 246         } else {
 247                 LASSERT(fmode & FMODE_READ);
 248                 och_p = &lli->lli_mds_read_och;
 249                 och_usecount = &lli->lli_open_fd_read_count;
 250         }
 251
 252         mutex_lock(&lli->lli_och_mutex);
 253         if (*och_usecount > 0) {
 254                 /* There are still users of this handle, so skip
 255                  * freeing it. */
 256                 mutex_unlock(&lli->lli_och_mutex);
 257                 RETURN(0);
 258         }
 259
 260         och = *och_p;
 261         *och_p = NULL;
 262         mutex_unlock(&lli->lli_och_mutex);
 263
 264         if (och != NULL) {
 265                 /* There might be a race and this handle may already
 266                  * be closed. */
 267                 rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
 268                                                inode, och, NULL);
 269         }
 270
 271         RETURN(rc);
 272 }
 273
 274 static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 275                        struct file *file)
 276 {
 277         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 278         struct ll_inode_info *lli = ll_i2info(inode);
 279         int rc = 0;
 280         ENTRY;
 281
 282         /* clear group lock, if present */
 283         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
 284                 ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid);
 285
 286         if (fd->fd_lease_och != NULL) {
 287                 bool lease_broken;
 288
 289                 /* Usually the lease is not released when the
 290                  * application crashed, we need to release here. */
 291                 rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken);
 292                 CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n",
 293                         PFID(&lli->lli_fid), rc, lease_broken);
 294
 295                 fd->fd_lease_och = NULL;
 296         }
 297
 298         if (fd->fd_och != NULL) {
 299                 rc = ll_close_inode_openhandle(md_exp, inode, fd->fd_och, NULL);
 300                 fd->fd_och = NULL;
 301                 GOTO(out, rc);
 302         }
 303
 304         /* Let's see if we have good enough OPEN lock on the file and if
 305            we can skip talking to MDS */
 306         if (file->f_dentry->d_inode) { /* Can this ever be false? */
 307                 int lockmode;
 308                 __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
 309                 struct lustre_handle lockh;
 310                 struct inode *inode = file->f_dentry->d_inode;
 311                 ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
 312
 313                 mutex_lock(&lli->lli_och_mutex);
 314                 if (fd->fd_omode & FMODE_WRITE) {
 315                         lockmode = LCK_CW;
 316                         LASSERT(lli->lli_open_fd_write_count);
 317                         lli->lli_open_fd_write_count--;
 318                 } else if (fd->fd_omode & FMODE_EXEC) {
 319                         lockmode = LCK_PR;
 320                         LASSERT(lli->lli_open_fd_exec_count);
 321                         lli->lli_open_fd_exec_count--;
 322                 } else {
 323                         lockmode = LCK_CR;
 324                         LASSERT(lli->lli_open_fd_read_count);
 325                         lli->lli_open_fd_read_count--;
 326                 }
 327                 mutex_unlock(&lli->lli_och_mutex);
 328
 329                 if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
 330                                    LDLM_IBITS, &policy, lockmode,
 331                                    &lockh)) {
 332                         rc = ll_md_real_close(file->f_dentry->d_inode,
 333                                               fd->fd_omode);
 334                 }
 335         } else {
 336                 CERROR("released file has negative dentry: file = %p, "
 337                        "dentry = %p, name = %s\n",
 338                        file, file->f_dentry, file->f_dentry->d_name.name);
 339         }
 340
 341 out:
 342         LUSTRE_FPRIVATE(file) = NULL;
 343         ll_file_data_put(fd);
 344         ll_capa_close(inode);
 345
 346         RETURN(rc);
 347 }
 348
 349 /* While this returns an error code, fput() the caller does not, so we need
 350  * to make every effort to clean up all of our state here.  Also, applications
 351  * rarely check close errors and even if an error is returned they will not
 352  * re-try the close call.
 353  */
 354 int ll_file_release(struct inode *inode, struct file *file)
 355 {
 356         struct ll_file_data *fd;
 357         struct ll_sb_info *sbi = ll_i2sbi(inode);
 358         struct ll_inode_info *lli = ll_i2info(inode);
 359         int rc;
 360         ENTRY;
 361
 362         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
 363                PFID(ll_inode2fid(inode)), inode);
 364
 365 #ifdef CONFIG_FS_POSIX_ACL
 366         if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
 367             inode == inode->i_sb->s_root->d_inode) {
 368                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 369
 370                 LASSERT(fd != NULL);
 371                 if (unlikely(fd->fd_flags & LL_FILE_RMTACL)) {
 372                         fd->fd_flags &= ~LL_FILE_RMTACL;
 373                         rct_del(&sbi->ll_rct, current_pid());
 374                         et_search_free(&sbi->ll_et, current_pid());
 375                 }
 376         }
 377 #endif
 378
 379         if (inode->i_sb->s_root != file->f_dentry)
 380                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
 381         fd = LUSTRE_FPRIVATE(file);
 382         LASSERT(fd != NULL);
 383
 384         /* The last ref on @file, maybe not the the owner pid of statahead,
 385          * because parent and child process can share the same file handle. */
 386         if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd)
 387                 ll_deauthorize_statahead(inode, fd);
 388
 389         if (inode->i_sb->s_root == file->f_dentry) {
 390                 LUSTRE_FPRIVATE(file) = NULL;
 391                 ll_file_data_put(fd);
 392                 RETURN(0);
 393         }
 394
 395         if (!S_ISDIR(inode->i_mode)) {
 396                 if (lli->lli_clob != NULL)
 397                         lov_read_and_clear_async_rc(lli->lli_clob);
 398                 lli->lli_async_rc = 0;
 399         }
 400
 401         rc = ll_md_close(sbi->ll_md_exp, inode, file);
 402
 403         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
 404                 libcfs_debug_dumplog();
 405
 406         RETURN(rc);
 407 }
 408
 409 static int ll_intent_file_open(struct file *file, void *lmm, int lmmsize,
 410                                 struct lookup_intent *itp)
 411 {
 412         struct dentry *de = file->f_dentry;
 413         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
 414         struct dentry *parent = de->d_parent;
 415         const char *name = NULL;
 416         int len = 0;
 417         struct md_op_data *op_data;
 418         struct ptlrpc_request *req = NULL;
 419         int rc;
 420         ENTRY;
 421
 422         LASSERT(parent != NULL);
 423         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
 424
 425         /* if server supports open-by-fid, or file name is invalid, don't pack
 426          * name in open request */
 427         if (!(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID) &&
 428             lu_name_is_valid_2(de->d_name.name, de->d_name.len)) {
 429                 name = de->d_name.name;
 430                 len = de->d_name.len;
 431         }
 432
 433         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
 434                                      name, len, 0, LUSTRE_OPC_ANY, NULL);
 435         if (IS_ERR(op_data))
 436                 RETURN(PTR_ERR(op_data));
 437         op_data->op_data = lmm;
 438         op_data->op_data_size = lmmsize;
 439
 440         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
 441                             &ll_md_blocking_ast, 0);
 442         ll_finish_md_op_data(op_data);
 443         if (rc == -ESTALE) {
 444                 /* reason for keep own exit path - don`t flood log
 445                  * with messages with -ESTALE errors.
 446                  */
 447                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
 448                      it_open_error(DISP_OPEN_OPEN, itp))
 449                         GOTO(out, rc);
 450                 ll_release_openhandle(de, itp);
 451                 GOTO(out, rc);
 452         }
 453
 454         if (it_disposition(itp, DISP_LOOKUP_NEG))
 455                 GOTO(out, rc = -ENOENT);
 456
 457         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
 458                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
 459                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
 460                 GOTO(out, rc);
 461         }
 462
 463         rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
 464         if (!rc && itp->d.lustre.it_lock_mode)
 465                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, NULL);
 466
 467 out:
 468         ptlrpc_req_finished(req);
 469         ll_intent_drop_lock(itp);
 470
 471         RETURN(rc);
 472 }
 473
 474 /**
 475  * Assign an obtained @ioepoch to client's inode. No lock is needed, MDS does
 476  * not believe attributes if a few ioepoch holders exist. Attributes for
 477  * previous ioepoch if new one is opened are also skipped by MDS.
 478  */
 479 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch)
 480 {
 481         if (ioepoch && lli->lli_ioepoch != ioepoch) {
 482                 lli->lli_ioepoch = ioepoch;
 483                 CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
 484                        ioepoch, PFID(&lli->lli_fid));
 485         }
 486 }
 487
 488 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 489                        struct obd_client_handle *och)
 490 {
 491         struct ptlrpc_request *req = it->d.lustre.it_data;
 492         struct mdt_body *body;
 493
 494         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 495         och->och_fh = body->mbo_handle;
 496         och->och_fid = body->mbo_fid1;
 497         och->och_lease_handle.cookie = it->d.lustre.it_lock_handle;
 498         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
 499         och->och_flags = it->it_flags;
 500
 501         return md_set_open_replay_data(md_exp, och, it);
 502 }
 503
 504 static int ll_local_open(struct file *file, struct lookup_intent *it,
 505                          struct ll_file_data *fd, struct obd_client_handle *och)
 506 {
 507         struct inode *inode = file->f_dentry->d_inode;
 508         struct ll_inode_info *lli = ll_i2info(inode);
 509         ENTRY;
 510
 511         LASSERT(!LUSTRE_FPRIVATE(file));
 512
 513         LASSERT(fd != NULL);
 514
 515         if (och) {
 516                 struct ptlrpc_request *req = it->d.lustre.it_data;
 517                 struct mdt_body *body;
 518                 int rc;
 519
 520                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
 521                 if (rc != 0)
 522                         RETURN(rc);
 523
 524                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 525                 ll_ioepoch_open(lli, body->mbo_ioepoch);
 526         }
 527
 528         LUSTRE_FPRIVATE(file) = fd;
 529         ll_readahead_init(inode, &fd->fd_ras);
 530         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
 531
 532         /* ll_cl_context initialize */
 533         rwlock_init(&fd->fd_lock);
 534         INIT_LIST_HEAD(&fd->fd_lccs);
 535
 536         RETURN(0);
 537 }
 538
 539 /* Open a file, and (for the very first open) create objects on the OSTs at
 540  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
 541  * creation or open until ll_lov_setstripe() ioctl is called.
 542  *
 543  * If we already have the stripe MD locally then we don't request it in
 544  * md_open(), by passing a lmm_size = 0.
 545  *
 546  * It is up to the application to ensure no other processes open this file
 547  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
 548  * used.  We might be able to avoid races of that sort by getting lli_open_sem
 549  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
 550  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
 551  */
 552 int ll_file_open(struct inode *inode, struct file *file)
 553 {
 554         struct ll_inode_info *lli = ll_i2info(inode);
 555         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
 556                                           .it_flags = file->f_flags };
 557         struct obd_client_handle **och_p = NULL;
 558         __u64 *och_usecount = NULL;
 559         struct ll_file_data *fd;
 560         int rc = 0;
 561         ENTRY;
 562
 563         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
 564                PFID(ll_inode2fid(inode)), inode, file->f_flags);
 565
 566         it = file->private_data; /* XXX: compat macro */
 567         file->private_data = NULL; /* prevent ll_local_open assertion */
 568
 569         fd = ll_file_data_get();
 570         if (fd == NULL)
 571                 GOTO(out_openerr, rc = -ENOMEM);
 572
 573         fd->fd_file = file;
 574         if (S_ISDIR(inode->i_mode))
 575                 ll_authorize_statahead(inode, fd);
 576
 577         if (inode->i_sb->s_root == file->f_dentry) {
 578                 LUSTRE_FPRIVATE(file) = fd;
 579                 RETURN(0);
 580         }
 581
 582         if (!it || !it->d.lustre.it_disposition) {
 583                 /* Convert f_flags into access mode. We cannot use file->f_mode,
 584                  * because everything but O_ACCMODE mask was stripped from
 585                  * there */
 586                 if ((oit.it_flags + 1) & O_ACCMODE)
 587                         oit.it_flags++;
 588                 if (file->f_flags & O_TRUNC)
 589                         oit.it_flags |= FMODE_WRITE;
 590
 591                 /* kernel only call f_op->open in dentry_open.  filp_open calls
 592                  * dentry_open after call to open_namei that checks permissions.
 593                  * Only nfsd_open call dentry_open directly without checking
 594                  * permissions and because of that this code below is safe. */
 595                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
 596                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
 597
 598                 /* We do not want O_EXCL here, presumably we opened the file
 599                  * already? XXX - NFS implications? */
 600                 oit.it_flags &= ~O_EXCL;
 601
 602                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
 603                  * created if necessary, then "IT_CREAT" should be set to keep
 604                  * consistent with it */
 605                 if (oit.it_flags & O_CREAT)
 606                         oit.it_op |= IT_CREAT;
 607
 608                 it = &oit;
 609         }
 610
 611 restart:
 612         /* Let's see if we have file open on MDS already. */
 613         if (it->it_flags & FMODE_WRITE) {
 614                 och_p = &lli->lli_mds_write_och;
 615                 och_usecount = &lli->lli_open_fd_write_count;
 616         } else if (it->it_flags & FMODE_EXEC) {
 617                 och_p = &lli->lli_mds_exec_och;
 618                 och_usecount = &lli->lli_open_fd_exec_count;
 619          } else {
 620                 och_p = &lli->lli_mds_read_och;
 621                 och_usecount = &lli->lli_open_fd_read_count;
 622         }
 623
 624         mutex_lock(&lli->lli_och_mutex);
 625         if (*och_p) { /* Open handle is present */
 626                 if (it_disposition(it, DISP_OPEN_OPEN)) {
 627                         /* Well, there's extra open request that we do not need,
 628                            let's close it somehow. This will decref request. */
 629                         rc = it_open_error(DISP_OPEN_OPEN, it);
 630                         if (rc) {
 631                                 mutex_unlock(&lli->lli_och_mutex);
 632                                 GOTO(out_openerr, rc);
 633                         }
 634
 635                         ll_release_openhandle(file->f_dentry, it);
 636                 }
 637                 (*och_usecount)++;
 638
 639                 rc = ll_local_open(file, it, fd, NULL);
 640                 if (rc) {
 641                         (*och_usecount)--;
 642                         mutex_unlock(&lli->lli_och_mutex);
 643                         GOTO(out_openerr, rc);
 644                 }
 645         } else {
 646                 LASSERT(*och_usecount == 0);
 647                 if (!it->d.lustre.it_disposition) {
 648                         /* We cannot just request lock handle now, new ELC code
 649                            means that one of other OPEN locks for this file
 650                            could be cancelled, and since blocking ast handler
 651                            would attempt to grab och_mutex as well, that would
 652                            result in a deadlock */
 653                         mutex_unlock(&lli->lli_och_mutex);
 654                         /*
 655                          * Normally called under two situations:
 656                          * 1. NFS export.
 657                          * 2. A race/condition on MDS resulting in no open
 658                          *    handle to be returned from LOOKUP|OPEN request,
 659                          *    for example if the target entry was a symlink.
 660                          *
 661                          * Always fetch MDS_OPEN_LOCK if this is not setstripe.
 662                          *
 663                          * Always specify MDS_OPEN_BY_FID because we don't want
 664                          * to get file with different fid.
 665                          */
 666                         it->it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID;
 667                         rc = ll_intent_file_open(file, NULL, 0, it);
 668                         if (rc)
 669                                 GOTO(out_openerr, rc);
 670
 671                         goto restart;
 672                 }
 673                 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
 674                 if (!*och_p)
 675                         GOTO(out_och_free, rc = -ENOMEM);
 676
 677                 (*och_usecount)++;
 678
 679                 /* md_intent_lock() didn't get a request ref if there was an
 680                  * open error, so don't do cleanup on the request here
 681                  * (bug 3430) */
 682                 /* XXX (green): Should not we bail out on any error here, not
 683                  * just open error? */
 684                 rc = it_open_error(DISP_OPEN_OPEN, it);
 685                 if (rc != 0)
 686                         GOTO(out_och_free, rc);
 687
 688                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
 689                          "inode %p: disposition %x, status %d\n", inode,
 690                          it_disposition(it, ~0), it->d.lustre.it_status);
 691
 692                 rc = ll_local_open(file, it, fd, *och_p);
 693                 if (rc)
 694                         GOTO(out_och_free, rc);
 695         }
 696         mutex_unlock(&lli->lli_och_mutex);
 697         fd = NULL;
 698
 699         /* Must do this outside lli_och_mutex lock to prevent deadlock where
 700            different kind of OPEN lock for this same inode gets cancelled
 701            by ldlm_cancel_lru */
 702         if (!S_ISREG(inode->i_mode))
 703                 GOTO(out_och_free, rc);
 704
 705         ll_capa_open(inode);
 706
 707         if (!lli->lli_has_smd &&
 708             (cl_is_lov_delay_create(file->f_flags) ||
 709              (file->f_mode & FMODE_WRITE) == 0)) {
 710                 CDEBUG(D_INODE, "object creation was delayed\n");
 711                 GOTO(out_och_free, rc);
 712         }
 713         cl_lov_delay_create_clear(&file->f_flags);
 714         GOTO(out_och_free, rc);
 715
 716 out_och_free:
 717         if (rc) {
 718                 if (och_p && *och_p) {
 719                         OBD_FREE(*och_p, sizeof (struct obd_client_handle));
 720                         *och_p = NULL; /* OBD_FREE writes some magic there */
 721                         (*och_usecount)--;
 722                 }
 723                 mutex_unlock(&lli->lli_och_mutex);
 724
 725 out_openerr:
 726                 if (lli->lli_opendir_key == fd)
 727                         ll_deauthorize_statahead(inode, fd);
 728                 if (fd != NULL)
 729                         ll_file_data_put(fd);
 730         } else {
 731                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
 732         }
 733
 734         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
 735                 ptlrpc_req_finished(it->d.lustre.it_data);
 736                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
 737         }
 738
 739         return rc;
 740 }
 741
 742 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
 743                         struct ldlm_lock_desc *desc, void *data, int flag)
 744 {
 745         int rc;
 746         struct lustre_handle lockh;
 747         ENTRY;
 748
 749         switch (flag) {
 750         case LDLM_CB_BLOCKING:
 751                 ldlm_lock2handle(lock, &lockh);
 752                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
 753                 if (rc < 0) {
 754                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 755                         RETURN(rc);
 756                 }
 757                 break;
 758         case LDLM_CB_CANCELING:
 759                 /* do nothing */
 760                 break;
 761         }
 762         RETURN(0);
 763 }
 764
 765 /**
 766  * Acquire a lease and open the file.
 767  */
 768 static struct obd_client_handle *
 769 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
 770               __u64 open_flags)
 771 {
 772         struct lookup_intent it = { .it_op = IT_OPEN };
 773         struct ll_sb_info *sbi = ll_i2sbi(inode);
 774         struct md_op_data *op_data;
 775         struct ptlrpc_request *req = NULL;
 776         struct lustre_handle old_handle = { 0 };
 777         struct obd_client_handle *och = NULL;
 778         int rc;
 779         int rc2;
 780         ENTRY;
 781
 782         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
 783                 RETURN(ERR_PTR(-EINVAL));
 784
 785         if (file != NULL) {
 786                 struct ll_inode_info *lli = ll_i2info(inode);
 787                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 788                 struct obd_client_handle **och_p;
 789                 __u64 *och_usecount;
 790
 791                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
 792                         RETURN(ERR_PTR(-EPERM));
 793
 794                 /* Get the openhandle of the file */
 795                 rc = -EBUSY;
 796                 mutex_lock(&lli->lli_och_mutex);
 797                 if (fd->fd_lease_och != NULL) {
 798                         mutex_unlock(&lli->lli_och_mutex);
 799                         RETURN(ERR_PTR(rc));
 800                 }
 801
 802                 if (fd->fd_och == NULL) {
 803                         if (file->f_mode & FMODE_WRITE) {
 804                                 LASSERT(lli->lli_mds_write_och != NULL);
 805                                 och_p = &lli->lli_mds_write_och;
 806                                 och_usecount = &lli->lli_open_fd_write_count;
 807                         } else {
 808                                 LASSERT(lli->lli_mds_read_och != NULL);
 809                                 och_p = &lli->lli_mds_read_och;
 810                                 och_usecount = &lli->lli_open_fd_read_count;
 811                         }
 812                         if (*och_usecount == 1) {
 813                                 fd->fd_och = *och_p;
 814                                 *och_p = NULL;
 815                                 *och_usecount = 0;
 816                                 rc = 0;
 817                         }
 818                 }
 819                 mutex_unlock(&lli->lli_och_mutex);
 820                 if (rc < 0) /* more than 1 opener */
 821                         RETURN(ERR_PTR(rc));
 822
 823                 LASSERT(fd->fd_och != NULL);
 824                 old_handle = fd->fd_och->och_fh;
 825         }
 826
 827         OBD_ALLOC_PTR(och);
 828         if (och == NULL)
 829                 RETURN(ERR_PTR(-ENOMEM));
 830
 831         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
 832                                         LUSTRE_OPC_ANY, NULL);
 833         if (IS_ERR(op_data))
 834                 GOTO(out, rc = PTR_ERR(op_data));
 835
 836         /* To tell the MDT this openhandle is from the same owner */
 837         op_data->op_handle = old_handle;
 838
 839         it.it_flags = fmode | open_flags;
 840         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
 841         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
 842                             &ll_md_blocking_lease_ast,
 843         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
 844          * it can be cancelled which may mislead applications that the lease is
 845          * broken;
 846          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
 847          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
 848          * doesn't deal with openhandle, so normal openhandle will be leaked. */
 849                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
 850         ll_finish_md_op_data(op_data);
 851         ptlrpc_req_finished(req);
 852         if (rc < 0)
 853                 GOTO(out_release_it, rc);
 854
 855         if (it_disposition(&it, DISP_LOOKUP_NEG))
 856                 GOTO(out_release_it, rc = -ENOENT);
 857
 858         rc = it_open_error(DISP_OPEN_OPEN, &it);
 859         if (rc)
 860                 GOTO(out_release_it, rc);
 861
 862         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
 863         ll_och_fill(sbi->ll_md_exp, &it, och);
 864
 865         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
 866                 GOTO(out_close, rc = -EOPNOTSUPP);
 867
 868         /* already get lease, handle lease lock */
 869         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
 870         if (it.d.lustre.it_lock_mode == 0 ||
 871             it.d.lustre.it_lock_bits != MDS_INODELOCK_OPEN) {
 872                 /* open lock must return for lease */
 873                 CERROR(DFID "lease granted but no open lock, %d/"LPU64".\n",
 874                         PFID(ll_inode2fid(inode)), it.d.lustre.it_lock_mode,
 875                         it.d.lustre.it_lock_bits);
 876                 GOTO(out_close, rc = -EPROTO);
 877         }
 878
 879         ll_intent_release(&it);
 880         RETURN(och);
 881
 882 out_close:
 883         /* Cancel open lock */
 884         if (it.d.lustre.it_lock_mode != 0) {
 885                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
 886                                             it.d.lustre.it_lock_mode);
 887                 it.d.lustre.it_lock_mode = 0;
 888                 och->och_lease_handle.cookie = 0ULL;
 889         }
 890         rc2 = ll_close_inode_openhandle(sbi->ll_md_exp, inode, och, NULL);
 891         if (rc2 < 0)
 892                 CERROR("%s: error closing file "DFID": %d\n",
 893                        ll_get_fsname(inode->i_sb, NULL, 0),
 894                        PFID(&ll_i2info(inode)->lli_fid), rc2);
 895         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
 896 out_release_it:
 897         ll_intent_release(&it);
 898 out:
 899         if (och != NULL)
 900                 OBD_FREE_PTR(och);
 901         RETURN(ERR_PTR(rc));
 902 }
 903
 904 /**
 905  * Release lease and close the file.
 906  * It will check if the lease has ever broken.
 907  */
 908 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
 909                           bool *lease_broken)
 910 {
 911         struct ldlm_lock *lock;
 912         bool cancelled = true;
 913         int rc;
 914         ENTRY;
 915
 916         lock = ldlm_handle2lock(&och->och_lease_handle);
 917         if (lock != NULL) {
 918                 lock_res_and_lock(lock);
 919                 cancelled = ldlm_is_cancel(lock);
 920                 unlock_res_and_lock(lock);
 921                 LDLM_LOCK_PUT(lock);
 922         }
 923
 924         CDEBUG(D_INODE, "lease for "DFID" broken? %d\n",
 925                 PFID(&ll_i2info(inode)->lli_fid), cancelled);
 926
 927         if (!cancelled)
 928                 ldlm_cli_cancel(&och->och_lease_handle, 0);
 929         if (lease_broken != NULL)
 930                 *lease_broken = cancelled;
 931
 932         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
 933                                        NULL);
 934         RETURN(rc);
 935 }
 936
 937 /* Fills the obdo with the attributes for the lsm */
 938 static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp,
 939                           struct obd_capa *capa, struct obdo *obdo,
 940                           __u64 ioepoch, int dv_flags)
 941 {
 942         struct ptlrpc_request_set *set;
 943         struct obd_info            oinfo = { { { 0 } } };
 944         int                        rc;
 945
 946         ENTRY;
 947
 948         LASSERT(lsm != NULL);
 949
 950         oinfo.oi_md = lsm;
 951         oinfo.oi_oa = obdo;
 952         oinfo.oi_oa->o_oi = lsm->lsm_oi;
 953         oinfo.oi_oa->o_mode = S_IFREG;
 954         oinfo.oi_oa->o_ioepoch = ioepoch;
 955         oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
 956                                OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
 957                                OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
 958                                OBD_MD_FLMTIME | OBD_MD_FLCTIME |
 959                                OBD_MD_FLGROUP | OBD_MD_FLEPOCH |
 960                                OBD_MD_FLDATAVERSION;
 961         oinfo.oi_capa = capa;
 962         if (dv_flags & (LL_DV_WR_FLUSH | LL_DV_RD_FLUSH)) {
 963                 oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
 964                 oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
 965                 if (dv_flags & LL_DV_WR_FLUSH)
 966                         oinfo.oi_oa->o_flags |= OBD_FL_FLUSH;
 967         }
 968
 969         set = ptlrpc_prep_set();
 970         if (set == NULL) {
 971                 CERROR("cannot allocate ptlrpc set: rc = %d\n", -ENOMEM);
 972                 rc = -ENOMEM;
 973         } else {
 974                 rc = obd_getattr_async(exp, &oinfo, set);
 975                 if (rc == 0)
 976                         rc = ptlrpc_set_wait(set);
 977                 ptlrpc_set_destroy(set);
 978         }
 979         if (rc == 0) {
 980                 oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
 981                                          OBD_MD_FLATIME | OBD_MD_FLMTIME |
 982                                          OBD_MD_FLCTIME | OBD_MD_FLSIZE |
 983                                          OBD_MD_FLDATAVERSION | OBD_MD_FLFLAGS);
 984                 if (dv_flags & LL_DV_WR_FLUSH &&
 985                     !(oinfo.oi_oa->o_valid & OBD_MD_FLFLAGS &&
 986                       oinfo.oi_oa->o_flags & OBD_FL_FLUSH))
 987                         RETURN(-ENOTSUPP);
 988         }
 989         RETURN(rc);
 990 }
 991
 992 /**
 993   * Performs the getattr on the inode and updates its fields.
 994   * If @sync != 0, perform the getattr under the server-side lock.
 995   */
 996 int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
 997                      __u64 ioepoch, int sync)
 998 {
 999         struct obd_capa      *capa = ll_mdscapa_get(inode);
1000         struct lov_stripe_md *lsm;
1001         int rc;
1002         ENTRY;
1003
1004         lsm = ccc_inode_lsm_get(inode);
1005         rc = ll_lsm_getattr(lsm, ll_i2dtexp(inode),
1006                                 capa, obdo, ioepoch, sync ? LL_DV_RD_FLUSH : 0);
1007         capa_put(capa);
1008         if (rc == 0) {
1009                 struct ost_id *oi = lsm ? &lsm->lsm_oi : &obdo->o_oi;
1010
1011                 obdo_refresh_inode(inode, obdo, obdo->o_valid);
1012                 CDEBUG(D_INODE, "objid "DOSTID" size %llu, blocks %llu,"
1013                        " blksize %lu\n", POSTID(oi), i_size_read(inode),
1014                        (unsigned long long)inode->i_blocks,
1015                        1UL << inode->i_blkbits);
1016         }
1017         ccc_inode_lsm_put(inode, lsm);
1018         RETURN(rc);
1019 }
1020
1021 int ll_merge_lvb(const struct lu_env *env, struct inode *inode)
1022 {
1023         struct ll_inode_info *lli = ll_i2info(inode);
1024         struct cl_object *obj = lli->lli_clob;
1025         struct cl_attr *attr = ccc_env_thread_attr(env);
1026         struct ost_lvb lvb;
1027         int rc = 0;
1028
1029         ENTRY;
1030
1031         ll_inode_size_lock(inode);
1032         /* merge timestamps the most recently obtained from mds with
1033            timestamps obtained from osts */
1034         LTIME_S(inode->i_atime) = lli->lli_lvb.lvb_atime;
1035         LTIME_S(inode->i_mtime) = lli->lli_lvb.lvb_mtime;
1036         LTIME_S(inode->i_ctime) = lli->lli_lvb.lvb_ctime;
1037
1038         lvb.lvb_size = i_size_read(inode);
1039         lvb.lvb_blocks = inode->i_blocks;
1040         lvb.lvb_mtime = LTIME_S(inode->i_mtime);
1041         lvb.lvb_atime = LTIME_S(inode->i_atime);
1042         lvb.lvb_ctime = LTIME_S(inode->i_ctime);
1043
1044         cl_object_attr_lock(obj);
1045         rc = cl_object_attr_get(env, obj, attr);
1046         cl_object_attr_unlock(obj);
1047
1048         if (rc == 0) {
1049                 if (lvb.lvb_atime < attr->cat_atime)
1050                         lvb.lvb_atime = attr->cat_atime;
1051                 if (lvb.lvb_ctime < attr->cat_ctime)
1052                         lvb.lvb_ctime = attr->cat_ctime;
1053                 if (lvb.lvb_mtime < attr->cat_mtime)
1054                         lvb.lvb_mtime = attr->cat_mtime;
1055
1056                 CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
1057                                 PFID(&lli->lli_fid), attr->cat_size);
1058                 cl_isize_write_nolock(inode, attr->cat_size);
1059
1060                 inode->i_blocks = attr->cat_blocks;
1061
1062                 LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
1063                 LTIME_S(inode->i_atime) = lvb.lvb_atime;
1064                 LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
1065         }
1066         ll_inode_size_unlock(inode);
1067
1068         RETURN(rc);
1069 }
1070
1071 int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
1072                      lstat_t *st)
1073 {
1074         struct obdo obdo = { 0 };
1075         int rc;
1076
1077         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0);
1078         if (rc == 0) {
1079                 st->st_size   = obdo.o_size;
1080                 st->st_blocks = obdo.o_blocks;
1081                 st->st_mtime  = obdo.o_mtime;
1082                 st->st_atime  = obdo.o_atime;
1083                 st->st_ctime  = obdo.o_ctime;
1084         }
1085         return rc;
1086 }
1087
1088 static bool file_is_noatime(const struct file *file)
1089 {
1090         const struct vfsmount *mnt = file->f_path.mnt;
1091         const struct inode *inode = file->f_path.dentry->d_inode;
1092
1093         /* Adapted from file_accessed() and touch_atime().*/
1094         if (file->f_flags & O_NOATIME)
1095                 return true;
1096
1097         if (inode->i_flags & S_NOATIME)
1098                 return true;
1099
1100         if (IS_NOATIME(inode))
1101                 return true;
1102
1103         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1104                 return true;
1105
1106         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1107                 return true;
1108
1109         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1110                 return true;
1111
1112         return false;
1113 }
1114
1115 static void ll_io_init(struct cl_io *io, const struct file *file, int write)
1116 {
1117         struct inode *inode = file->f_dentry->d_inode;
1118
1119         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
1120         if (write) {
1121                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
1122                 io->u.ci_wr.wr_sync = file->f_flags & O_SYNC ||
1123                                       file->f_flags & O_DIRECT ||
1124                                       IS_SYNC(inode);
1125         }
1126         io->ci_obj     = ll_i2info(inode)->lli_clob;
1127         io->ci_lockreq = CILR_MAYBE;
1128         if (ll_file_nolock(file)) {
1129                 io->ci_lockreq = CILR_NEVER;
1130                 io->ci_no_srvlock = 1;
1131         } else if (file->f_flags & O_APPEND) {
1132                 io->ci_lockreq = CILR_MANDATORY;
1133         }
1134
1135         io->ci_noatime = file_is_noatime(file);
1136 }
1137
1138 static ssize_t
1139 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1140                    struct file *file, enum cl_io_type iot,
1141                    loff_t *ppos, size_t count)
1142 {
1143         struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
1144         struct ll_file_data  *fd  = LUSTRE_FPRIVATE(file);
1145         struct cl_io         *io;
1146         ssize_t               result;
1147         struct range_lock     range;
1148         ENTRY;
1149
1150         CDEBUG(D_VFSTRACE, "file: %s, type: %d ppos: "LPU64", count: %zu\n",
1151                 file->f_dentry->d_name.name, iot, *ppos, count);
1152
1153 restart:
1154         io = ccc_env_thread_io(env);
1155         ll_io_init(io, file, iot == CIT_WRITE);
1156
1157         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
1158                 struct vvp_io *vio = vvp_env_io(env);
1159                 struct ccc_io *cio = ccc_env_io(env);
1160                 bool range_locked = false;
1161
1162                 if (file->f_flags & O_APPEND)
1163                         range_lock_init(&range, 0, LUSTRE_EOF);
1164                 else
1165                         range_lock_init(&range, *ppos, *ppos + count - 1);
1166                 cio->cui_fd  = LUSTRE_FPRIVATE(file);
1167                 vio->cui_io_subtype = args->via_io_subtype;
1168
1169                 switch (vio->cui_io_subtype) {
1170                 case IO_NORMAL:
1171                         cio->cui_iov = args->u.normal.via_iov;
1172                         cio->cui_nrsegs = args->u.normal.via_nrsegs;
1173                         cio->cui_tot_nrsegs = cio->cui_nrsegs;
1174                         cio->cui_iocb = args->u.normal.via_iocb;
1175                         if ((iot == CIT_WRITE) &&
1176                             !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1177                                 CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1178                                        RL_PARA(&range));
1179                                 result = range_lock(&lli->lli_write_tree,
1180                                                     &range);
1181                                 if (result < 0)
1182                                         GOTO(out, result);
1183
1184                                 range_locked = true;
1185                         }
1186                         down_read(&lli->lli_trunc_sem);
1187                         break;
1188                 case IO_SPLICE:
1189                         vio->u.splice.cui_pipe = args->u.splice.via_pipe;
1190                         vio->u.splice.cui_flags = args->u.splice.via_flags;
1191                         break;
1192                 default:
1193                         CERROR("Unknow IO type - %u\n", vio->cui_io_subtype);
1194                         LBUG();
1195                 }
1196
1197                 ll_cl_add(file, env, io);
1198                 result = cl_io_loop(env, io);
1199                 ll_cl_remove(file, env);
1200
1201                 if (args->via_io_subtype == IO_NORMAL)
1202                         up_read(&lli->lli_trunc_sem);
1203                 if (range_locked) {
1204                         CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1205                                RL_PARA(&range));
1206                         range_unlock(&lli->lli_write_tree, &range);
1207                 }
1208         } else {
1209                 /* cl_io_rw_init() handled IO */
1210                 result = io->ci_result;
1211         }
1212
1213         if (io->ci_nob > 0) {
1214                 result = io->ci_nob;
1215                 *ppos = io->u.ci_wr.wr.crw_pos;
1216         }
1217         GOTO(out, result);
1218 out:
1219         cl_io_fini(env, io);
1220         /* If any bit been read/written (result != 0), we just return
1221          * short read/write instead of restart io. */
1222         if ((result == 0 || result == -ENODATA) && io->ci_need_restart) {
1223                 CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zu\n",
1224                        iot == CIT_READ ? "read" : "write",
1225                        file->f_dentry->d_name.name, *ppos, count);
1226                 LASSERTF(io->ci_nob == 0, "%zd\n", io->ci_nob);
1227                 goto restart;
1228         }
1229
1230         if (iot == CIT_READ) {
1231                 if (result >= 0)
1232                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1233                                            LPROC_LL_READ_BYTES, result);
1234         } else if (iot == CIT_WRITE) {
1235                 if (result >= 0) {
1236                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1237                                            LPROC_LL_WRITE_BYTES, result);
1238                         fd->fd_write_failed = false;
1239                 } else if (result != -ERESTARTSYS) {
1240                         fd->fd_write_failed = true;
1241                 }
1242         }
1243         CDEBUG(D_VFSTRACE, "iot: %d, result: %zd\n", iot, result);
1244
1245         return result;
1246 }
1247
1248
1249 /*
1250  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1251  */
1252 static int ll_file_get_iov_count(const struct iovec *iov,
1253                                  unsigned long *nr_segs, size_t *count)
1254 {
1255         size_t cnt = 0;
1256         unsigned long seg;
1257
1258         for (seg = 0; seg < *nr_segs; seg++) {
1259                 const struct iovec *iv = &iov[seg];
1260
1261                 /*
1262                  * If any segment has a negative length, or the cumulative
1263                  * length ever wraps negative then return -EINVAL.
1264                  */
1265                 cnt += iv->iov_len;
1266                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1267                         return -EINVAL;
1268                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
1269                         continue;
1270                 if (seg == 0)
1271                         return -EFAULT;
1272                 *nr_segs = seg;
1273                 cnt -= iv->iov_len;   /* This segment is no good */
1274                 break;
1275         }
1276         *count = cnt;
1277         return 0;
1278 }
1279
1280 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1281                                 unsigned long nr_segs, loff_t pos)
1282 {
1283         struct lu_env      *env;
1284         struct vvp_io_args *args;
1285         size_t              count;
1286         ssize_t             result;
1287         int                 refcheck;
1288         ENTRY;
1289
1290         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1291         if (result)
1292                 RETURN(result);
1293
1294         env = cl_env_get(&refcheck);
1295         if (IS_ERR(env))
1296                 RETURN(PTR_ERR(env));
1297
1298         args = vvp_env_args(env, IO_NORMAL);
1299         args->u.normal.via_iov = (struct iovec *)iov;
1300         args->u.normal.via_nrsegs = nr_segs;
1301         args->u.normal.via_iocb = iocb;
1302
1303         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1304                                     &iocb->ki_pos, count);
1305         cl_env_put(env, &refcheck);
1306         RETURN(result);
1307 }
1308
1309 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
1310                             loff_t *ppos)
1311 {
1312         struct lu_env *env;
1313         struct iovec  *local_iov;
1314         struct kiocb  *kiocb;
1315         ssize_t        result;
1316         int            refcheck;
1317         ENTRY;
1318
1319         env = cl_env_get(&refcheck);
1320         if (IS_ERR(env))
1321                 RETURN(PTR_ERR(env));
1322
1323         local_iov = &vvp_env_info(env)->vti_local_iov;
1324         kiocb = &vvp_env_info(env)->vti_kiocb;
1325         local_iov->iov_base = (void __user *)buf;
1326         local_iov->iov_len = count;
1327         init_sync_kiocb(kiocb, file);
1328         kiocb->ki_pos = *ppos;
1329 #ifdef HAVE_KIOCB_KI_LEFT
1330         kiocb->ki_left = count;
1331 #else
1332         kiocb->ki_nbytes = count;
1333 #endif
1334
1335         result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1336         *ppos = kiocb->ki_pos;
1337
1338         cl_env_put(env, &refcheck);
1339         RETURN(result);
1340 }
1341
1342 /*
1343  * Write to a file (through the page cache).
1344  * AIO stuff
1345  */
1346 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1347                                  unsigned long nr_segs, loff_t pos)
1348 {
1349         struct lu_env      *env;
1350         struct vvp_io_args *args;
1351         size_t              count;
1352         ssize_t             result;
1353         int                 refcheck;
1354         ENTRY;
1355
1356         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1357         if (result)
1358                 RETURN(result);
1359
1360         env = cl_env_get(&refcheck);
1361         if (IS_ERR(env))
1362                 RETURN(PTR_ERR(env));
1363
1364         args = vvp_env_args(env, IO_NORMAL);
1365         args->u.normal.via_iov = (struct iovec *)iov;
1366         args->u.normal.via_nrsegs = nr_segs;
1367         args->u.normal.via_iocb = iocb;
1368
1369         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1370                                   &iocb->ki_pos, count);
1371         cl_env_put(env, &refcheck);
1372         RETURN(result);
1373 }
1374
1375 static ssize_t ll_file_write(struct file *file, const char __user *buf,
1376                              size_t count, loff_t *ppos)
1377 {
1378         struct lu_env *env;
1379         struct iovec  *local_iov;
1380         struct kiocb  *kiocb;
1381         ssize_t        result;
1382         int            refcheck;
1383         ENTRY;
1384
1385         env = cl_env_get(&refcheck);
1386         if (IS_ERR(env))
1387                 RETURN(PTR_ERR(env));
1388
1389         local_iov = &vvp_env_info(env)->vti_local_iov;
1390         kiocb = &vvp_env_info(env)->vti_kiocb;
1391         local_iov->iov_base = (void __user *)buf;
1392         local_iov->iov_len = count;
1393         init_sync_kiocb(kiocb, file);
1394         kiocb->ki_pos = *ppos;
1395 #ifdef HAVE_KIOCB_KI_LEFT
1396         kiocb->ki_left = count;
1397 #else
1398         kiocb->ki_nbytes = count;
1399 #endif
1400
1401         result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1402         *ppos = kiocb->ki_pos;
1403
1404         cl_env_put(env, &refcheck);
1405         RETURN(result);
1406 }
1407
1408 /*
1409  * Send file content (through pagecache) somewhere with helper
1410  */
1411 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1412                                    struct pipe_inode_info *pipe, size_t count,
1413                                    unsigned int flags)
1414 {
1415         struct lu_env      *env;
1416         struct vvp_io_args *args;
1417         ssize_t             result;
1418         int                 refcheck;
1419         ENTRY;
1420
1421         env = cl_env_get(&refcheck);
1422         if (IS_ERR(env))
1423                 RETURN(PTR_ERR(env));
1424
1425         args = vvp_env_args(env, IO_SPLICE);
1426         args->u.splice.via_pipe = pipe;
1427         args->u.splice.via_flags = flags;
1428
1429         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1430         cl_env_put(env, &refcheck);
1431         RETURN(result);
1432 }
1433
1434 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1435                              __u64  flags, struct lov_user_md *lum,
1436                              int lum_size)
1437 {
1438         struct lov_stripe_md *lsm = NULL;
1439         struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
1440         int rc = 0;
1441         ENTRY;
1442
1443         lsm = ccc_inode_lsm_get(inode);
1444         if (lsm != NULL) {
1445                 ccc_inode_lsm_put(inode, lsm);
1446                 CDEBUG(D_IOCTL, "stripe already exists for inode "DFID"\n",
1447                        PFID(ll_inode2fid(inode)));
1448                 GOTO(out, rc = -EEXIST);
1449         }
1450
1451         ll_inode_size_lock(inode);
1452         oit.it_flags |= MDS_OPEN_BY_FID;
1453         rc = ll_intent_file_open(file, lum, lum_size, &oit);
1454         if (rc)
1455                 GOTO(out_unlock, rc);
1456         rc = oit.d.lustre.it_status;
1457         if (rc < 0)
1458                 GOTO(out_req_free, rc);
1459
1460         ll_release_openhandle(file->f_dentry, &oit);
1461
1462 out_unlock:
1463         ll_inode_size_unlock(inode);
1464         ll_intent_release(&oit);
1465         ccc_inode_lsm_put(inode, lsm);
1466 out:
1467         cl_lov_delay_create_clear(&file->f_flags);
1468         RETURN(rc);
1469 out_req_free:
1470         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
1471         goto out;
1472 }
1473
1474 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1475                              struct lov_mds_md **lmmp, int *lmm_size,
1476                              struct ptlrpc_request **request)
1477 {
1478         struct ll_sb_info *sbi = ll_i2sbi(inode);
1479         struct mdt_body  *body;
1480         struct lov_mds_md *lmm = NULL;
1481         struct ptlrpc_request *req = NULL;
1482         struct md_op_data *op_data;
1483         int rc, lmmsize;
1484
1485         rc = ll_get_default_mdsize(sbi, &lmmsize);
1486         if (rc)
1487                 RETURN(rc);
1488
1489         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1490                                      strlen(filename), lmmsize,
1491                                      LUSTRE_OPC_ANY, NULL);
1492         if (IS_ERR(op_data))
1493                 RETURN(PTR_ERR(op_data));
1494
1495         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1496         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1497         ll_finish_md_op_data(op_data);
1498         if (rc < 0) {
1499                 CDEBUG(D_INFO, "md_getattr_name failed "
1500                        "on %s: rc %d\n", filename, rc);
1501                 GOTO(out, rc);
1502         }
1503
1504         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1505         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1506
1507         lmmsize = body->mbo_eadatasize;
1508
1509         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1510                         lmmsize == 0) {
1511                 GOTO(out, rc = -ENODATA);
1512         }
1513
1514         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1515         LASSERT(lmm != NULL);
1516
1517         if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1518             (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1519                 GOTO(out, rc = -EPROTO);
1520         }
1521
1522         /*
1523          * This is coming from the MDS, so is probably in
1524          * little endian.  We convert it to host endian before
1525          * passing it to userspace.
1526          */
1527         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1528                 int stripe_count;
1529
1530                 stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1531                 if (le32_to_cpu(lmm->lmm_pattern) & LOV_PATTERN_F_RELEASED)
1532                         stripe_count = 0;
1533
1534                 /* if function called for directory - we should
1535                  * avoid swab not existent lsm objects */
1536                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1537                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1538                         if (S_ISREG(body->mbo_mode))
1539                                 lustre_swab_lov_user_md_objects(
1540                                     ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1541                                     stripe_count);
1542                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1543                         lustre_swab_lov_user_md_v3(
1544                                 (struct lov_user_md_v3 *)lmm);
1545                         if (S_ISREG(body->mbo_mode))
1546                                 lustre_swab_lov_user_md_objects(
1547                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1548                                  stripe_count);
1549                 }
1550         }
1551
1552 out:
1553         *lmmp = lmm;
1554         *lmm_size = lmmsize;
1555         *request = req;
1556         return rc;
1557 }
1558
1559 static int ll_lov_setea(struct inode *inode, struct file *file,
1560                             unsigned long arg)
1561 {
1562         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1563         struct lov_user_md      *lump;
1564         int                      lum_size = sizeof(struct lov_user_md) +
1565                                             sizeof(struct lov_user_ost_data);
1566         int                      rc;
1567         ENTRY;
1568
1569         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1570                 RETURN(-EPERM);
1571
1572         OBD_ALLOC_LARGE(lump, lum_size);
1573         if (lump == NULL)
1574                 RETURN(-ENOMEM);
1575
1576         if (copy_from_user(lump, (struct lov_user_md __user *)arg, lum_size)) {
1577                 OBD_FREE_LARGE(lump, lum_size);
1578                 RETURN(-EFAULT);
1579         }
1580
1581         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1582
1583         OBD_FREE_LARGE(lump, lum_size);
1584         RETURN(rc);
1585 }
1586
1587 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1588                             unsigned long arg)
1589 {
1590         struct lov_user_md __user *lum = (struct lov_user_md __user *)arg;
1591         struct lov_user_md        *klum;
1592         int                        lum_size, rc;
1593         __u64                      flags = FMODE_WRITE;
1594         ENTRY;
1595
1596         rc = ll_copy_user_md(lum, &klum);
1597         if (rc < 0)
1598                 RETURN(rc);
1599
1600         lum_size = rc;
1601         rc = ll_lov_setstripe_ea_info(inode, file, flags, klum, lum_size);
1602         if (rc == 0) {
1603                 struct lov_stripe_md *lsm;
1604                 __u32 gen;
1605
1606                 put_user(0, &lum->lmm_stripe_count);
1607
1608                 ll_layout_refresh(inode, &gen);
1609                 lsm = ccc_inode_lsm_get(inode);
1610                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1611                                    0, lsm, lum);
1612                 ccc_inode_lsm_put(inode, lsm);
1613         }
1614
1615         OBD_FREE(klum, lum_size);
1616         RETURN(rc);
1617 }
1618
1619 static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1620 {
1621         struct lov_stripe_md *lsm;
1622         int rc = -ENODATA;
1623         ENTRY;
1624
1625         lsm = ccc_inode_lsm_get(inode);
1626         if (lsm != NULL)
1627                 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0,
1628                                    lsm, (void __user *)arg);
1629         ccc_inode_lsm_put(inode, lsm);
1630         RETURN(rc);
1631 }
1632
1633 static int
1634 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1635 {
1636         struct ll_inode_info   *lli = ll_i2info(inode);
1637         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1638         struct ccc_grouplock    grouplock;
1639         int                     rc;
1640         ENTRY;
1641
1642         if (ll_file_nolock(file))
1643                 RETURN(-EOPNOTSUPP);
1644
1645         spin_lock(&lli->lli_lock);
1646         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1647                 CWARN("group lock already existed with gid %lu\n",
1648                       fd->fd_grouplock.cg_gid);
1649                 spin_unlock(&lli->lli_lock);
1650                 RETURN(-EINVAL);
1651         }
1652         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1653         spin_unlock(&lli->lli_lock);
1654
1655         rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1656                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1657         if (rc)
1658                 RETURN(rc);
1659
1660         spin_lock(&lli->lli_lock);
1661         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1662                 spin_unlock(&lli->lli_lock);
1663                 CERROR("another thread just won the race\n");
1664                 cl_put_grouplock(&grouplock);
1665                 RETURN(-EINVAL);
1666         }
1667
1668         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1669         fd->fd_grouplock = grouplock;
1670         spin_unlock(&lli->lli_lock);
1671
1672         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1673         RETURN(0);
1674 }
1675
1676 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1677 {
1678         struct ll_inode_info   *lli = ll_i2info(inode);
1679         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1680         struct ccc_grouplock    grouplock;
1681         ENTRY;
1682
1683         spin_lock(&lli->lli_lock);
1684         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1685                 spin_unlock(&lli->lli_lock);
1686                 CWARN("no group lock held\n");
1687                 RETURN(-EINVAL);
1688         }
1689         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1690
1691         if (fd->fd_grouplock.cg_gid != arg) {
1692                 CWARN("group lock %lu doesn't match current id %lu\n",
1693                        arg, fd->fd_grouplock.cg_gid);
1694                 spin_unlock(&lli->lli_lock);
1695                 RETURN(-EINVAL);
1696         }
1697
1698         grouplock = fd->fd_grouplock;
1699         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1700         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1701         spin_unlock(&lli->lli_lock);
1702
1703         cl_put_grouplock(&grouplock);
1704         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1705         RETURN(0);
1706 }
1707
1708 /**
1709  * Close inode open handle
1710  *
1711  * \param dentry [in]     dentry which contains the inode
1712  * \param it     [in,out] intent which contains open info and result
1713  *
1714  * \retval 0     success
1715  * \retval <0    failure
1716  */
1717 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1718 {
1719         struct inode *inode = dentry->d_inode;
1720         struct obd_client_handle *och;
1721         int rc;
1722         ENTRY;
1723
1724         LASSERT(inode);
1725
1726         /* Root ? Do nothing. */
1727         if (dentry->d_inode->i_sb->s_root == dentry)
1728                 RETURN(0);
1729
1730         /* No open handle to close? Move away */
1731         if (!it_disposition(it, DISP_OPEN_OPEN))
1732                 RETURN(0);
1733
1734         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1735
1736         OBD_ALLOC(och, sizeof(*och));
1737         if (!och)
1738                 GOTO(out, rc = -ENOMEM);
1739
1740         ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
1741
1742         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1743                                        inode, och, NULL);
1744 out:
1745         /* this one is in place of ll_file_open */
1746         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1747                 ptlrpc_req_finished(it->d.lustre.it_data);
1748                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1749         }
1750         RETURN(rc);
1751 }
1752
1753 /**
1754  * Get size for inode for which FIEMAP mapping is requested.
1755  * Make the FIEMAP get_info call and returns the result.
1756  */
1757 static int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1758                         size_t num_bytes)
1759 {
1760         struct obd_export *exp = ll_i2dtexp(inode);
1761         struct lov_stripe_md *lsm = NULL;
1762         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1763         __u32 vallen = num_bytes;
1764         int rc;
1765         ENTRY;
1766
1767         /* Checks for fiemap flags */
1768         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1769                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1770                 return -EBADR;
1771         }
1772
1773         /* Check for FIEMAP_FLAG_SYNC */
1774         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1775                 rc = filemap_fdatawrite(inode->i_mapping);
1776                 if (rc)
1777                         return rc;
1778         }
1779
1780         lsm = ccc_inode_lsm_get(inode);
1781         if (lsm == NULL)
1782                 return -ENOENT;
1783
1784         /* If the stripe_count > 1 and the application does not understand
1785          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1786          */
1787         if (lsm->lsm_stripe_count > 1 &&
1788             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1789                 GOTO(out, rc = -EOPNOTSUPP);
1790
1791         fm_key.oa.o_oi = lsm->lsm_oi;
1792         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1793
1794         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1795         obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1796         /* If filesize is 0, then there would be no objects for mapping */
1797         if (fm_key.oa.o_size == 0) {
1798                 fiemap->fm_mapped_extents = 0;
1799                 GOTO(out, rc = 0);
1800         }
1801
1802         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1803
1804         rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1805                           fiemap, lsm);
1806         if (rc)
1807                 CERROR("obd_get_info failed: rc = %d\n", rc);
1808
1809 out:
1810         ccc_inode_lsm_put(inode, lsm);
1811         RETURN(rc);
1812 }
1813
1814 int ll_fid2path(struct inode *inode, void __user *arg)
1815 {
1816         struct obd_export       *exp = ll_i2mdexp(inode);
1817         const struct getinfo_fid2path __user *gfin = arg;
1818         __u32                    pathlen;
1819         struct getinfo_fid2path *gfout;
1820         size_t                   outsize;
1821         int                      rc;
1822
1823         ENTRY;
1824
1825         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1826             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1827                 RETURN(-EPERM);
1828
1829         /* Only need to get the buflen */
1830         if (get_user(pathlen, &gfin->gf_pathlen))
1831                 RETURN(-EFAULT);
1832
1833         if (pathlen > PATH_MAX)
1834                 RETURN(-EINVAL);
1835
1836         outsize = sizeof(*gfout) + pathlen;
1837         OBD_ALLOC(gfout, outsize);
1838         if (gfout == NULL)
1839                 RETURN(-ENOMEM);
1840
1841         if (copy_from_user(gfout, arg, sizeof(*gfout)))
1842                 GOTO(gf_free, rc = -EFAULT);
1843
1844         /* Call mdc_iocontrol */
1845         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1846         if (rc != 0)
1847                 GOTO(gf_free, rc);
1848
1849         if (copy_to_user(arg, gfout, outsize))
1850                 rc = -EFAULT;
1851
1852 gf_free:
1853         OBD_FREE(gfout, outsize);
1854         RETURN(rc);
1855 }
1856
1857 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1858 {
1859         struct ll_user_fiemap *fiemap_s;
1860         size_t num_bytes, ret_bytes;
1861         unsigned int extent_count;
1862         int rc = 0;
1863
1864         /* Get the extent count so we can calculate the size of
1865          * required fiemap buffer */
1866         if (get_user(extent_count,
1867             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1868                 RETURN(-EFAULT);
1869
1870         if (extent_count >=
1871             (SIZE_MAX - sizeof(*fiemap_s)) / sizeof(struct ll_fiemap_extent))
1872                 RETURN(-EINVAL);
1873         num_bytes = sizeof(*fiemap_s) + (extent_count *
1874                                          sizeof(struct ll_fiemap_extent));
1875
1876         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1877         if (fiemap_s == NULL)
1878                 RETURN(-ENOMEM);
1879
1880         /* get the fiemap value */
1881         if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1882                            sizeof(*fiemap_s)))
1883                 GOTO(error, rc = -EFAULT);
1884
1885         /* If fm_extent_count is non-zero, read the first extent since
1886          * it is used to calculate end_offset and device from previous
1887          * fiemap call. */
1888         if (extent_count) {
1889                 if (copy_from_user(&fiemap_s->fm_extents[0],
1890                     (char __user *)arg + sizeof(*fiemap_s),
1891                     sizeof(struct ll_fiemap_extent)))
1892                         GOTO(error, rc = -EFAULT);
1893         }
1894
1895         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1896         if (rc)
1897                 GOTO(error, rc);
1898
1899         ret_bytes = sizeof(struct ll_user_fiemap);
1900
1901         if (extent_count != 0)
1902                 ret_bytes += (fiemap_s->fm_mapped_extents *
1903                                  sizeof(struct ll_fiemap_extent));
1904
1905         if (copy_to_user((void __user *)arg, fiemap_s, ret_bytes))
1906                 rc = -EFAULT;
1907
1908 error:
1909         OBD_FREE_LARGE(fiemap_s, num_bytes);
1910         RETURN(rc);
1911 }
1912
1913 /*
1914  * Read the data_version for inode.
1915  *
1916  * This value is computed using stripe object version on OST.
1917  * Version is computed using server side locking.
1918  *
1919  * @param sync if do sync on the OST side;
1920  *              0: no sync
1921  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
1922  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
1923  */
1924 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
1925 {
1926         struct lov_stripe_md    *lsm = NULL;
1927         struct ll_sb_info       *sbi = ll_i2sbi(inode);
1928         struct obdo             *obdo = NULL;
1929         int                      rc;
1930         ENTRY;
1931
1932         /* If no stripe, we consider version is 0. */
1933         lsm = ccc_inode_lsm_get(inode);
1934         if (!lsm_has_objects(lsm)) {
1935                 *data_version = 0;
1936                 CDEBUG(D_INODE, "No object for inode\n");
1937                 GOTO(out, rc = 0);
1938         }
1939
1940         OBD_ALLOC_PTR(obdo);
1941         if (obdo == NULL)
1942                 GOTO(out, rc = -ENOMEM);
1943
1944         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, flags);
1945         if (rc == 0) {
1946                 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1947                         rc = -EOPNOTSUPP;
1948                 else
1949                         *data_version = obdo->o_data_version;
1950         }
1951
1952         OBD_FREE_PTR(obdo);
1953         EXIT;
1954 out:
1955         ccc_inode_lsm_put(inode, lsm);
1956         RETURN(rc);
1957 }
1958
1959 /*
1960  * Trigger a HSM release request for the provided inode.
1961  */
1962 int ll_hsm_release(struct inode *inode)
1963 {
1964         struct cl_env_nest nest;
1965         struct lu_env *env;
1966         struct obd_client_handle *och = NULL;
1967         __u64 data_version = 0;
1968         int rc;
1969         ENTRY;
1970
1971         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
1972                ll_get_fsname(inode->i_sb, NULL, 0),
1973                PFID(&ll_i2info(inode)->lli_fid));
1974
1975         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
1976         if (IS_ERR(och))
1977                 GOTO(out, rc = PTR_ERR(och));
1978
1979         /* Grab latest data_version and [am]time values */
1980         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
1981         if (rc != 0)
1982                 GOTO(out, rc);
1983
1984         env = cl_env_nested_get(&nest);
1985         if (IS_ERR(env))
1986                 GOTO(out, rc = PTR_ERR(env));
1987
1988         ll_merge_lvb(env, inode);
1989         cl_env_nested_put(&nest, env);
1990
1991         /* Release the file.
1992          * NB: lease lock handle is released in mdc_hsm_release_pack() because
1993          * we still need it to pack l_remote_handle to MDT. */
1994         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
1995                                        &data_version);
1996         och = NULL;
1997
1998         EXIT;
1999 out:
2000         if (och != NULL && !IS_ERR(och)) /* close the file */
2001                 ll_lease_close(och, inode, NULL);
2002
2003         return rc;
2004 }
2005
2006 struct ll_swap_stack {
2007         struct iattr             ia1, ia2;
2008         __u64                    dv1, dv2;
2009         struct inode            *inode1, *inode2;
2010         bool                     check_dv1, check_dv2;
2011 };
2012
2013 static int ll_swap_layouts(struct file *file1, struct file *file2,
2014                            struct lustre_swap_layouts *lsl)
2015 {
2016         struct mdc_swap_layouts  msl;
2017         struct md_op_data       *op_data;
2018         __u32                    gid;
2019         __u64                    dv;
2020         struct ll_swap_stack    *llss = NULL;
2021         int                      rc;
2022
2023         OBD_ALLOC_PTR(llss);
2024         if (llss == NULL)
2025                 RETURN(-ENOMEM);
2026
2027         llss->inode1 = file1->f_dentry->d_inode;
2028         llss->inode2 = file2->f_dentry->d_inode;
2029
2030         if (!S_ISREG(llss->inode2->i_mode))
2031                 GOTO(free, rc = -EINVAL);
2032
2033         if (inode_permission(llss->inode1, MAY_WRITE) ||
2034             inode_permission(llss->inode2, MAY_WRITE))
2035                 GOTO(free, rc = -EPERM);
2036
2037         if (llss->inode2->i_sb != llss->inode1->i_sb)
2038                 GOTO(free, rc = -EXDEV);
2039
2040         /* we use 2 bool because it is easier to swap than 2 bits */
2041         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2042                 llss->check_dv1 = true;
2043
2044         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2045                 llss->check_dv2 = true;
2046
2047         /* we cannot use lsl->sl_dvX directly because we may swap them */
2048         llss->dv1 = lsl->sl_dv1;
2049         llss->dv2 = lsl->sl_dv2;
2050
2051         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2052         if (rc == 0) /* same file, done! */
2053                 GOTO(free, rc = 0);
2054
2055         if (rc < 0) { /* sequentialize it */
2056                 swap(llss->inode1, llss->inode2);
2057                 swap(file1, file2);
2058                 swap(llss->dv1, llss->dv2);
2059                 swap(llss->check_dv1, llss->check_dv2);
2060         }
2061
2062         gid = lsl->sl_gid;
2063         if (gid != 0) { /* application asks to flush dirty cache */
2064                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2065                 if (rc < 0)
2066                         GOTO(free, rc);
2067
2068                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2069                 if (rc < 0) {
2070                         ll_put_grouplock(llss->inode1, file1, gid);
2071                         GOTO(free, rc);
2072                 }
2073         }
2074
2075         /* to be able to restore mtime and atime after swap
2076          * we need to first save them */
2077         if (lsl->sl_flags &
2078             (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
2079                 llss->ia1.ia_mtime = llss->inode1->i_mtime;
2080                 llss->ia1.ia_atime = llss->inode1->i_atime;
2081                 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
2082                 llss->ia2.ia_mtime = llss->inode2->i_mtime;
2083                 llss->ia2.ia_atime = llss->inode2->i_atime;
2084                 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
2085         }
2086
2087         /* ultimate check, before swaping the layouts we check if
2088          * dataversion has changed (if requested) */
2089         if (llss->check_dv1) {
2090                 rc = ll_data_version(llss->inode1, &dv, 0);
2091                 if (rc)
2092                         GOTO(putgl, rc);
2093                 if (dv != llss->dv1)
2094                         GOTO(putgl, rc = -EAGAIN);
2095         }
2096
2097         if (llss->check_dv2) {
2098                 rc = ll_data_version(llss->inode2, &dv, 0);
2099                 if (rc)
2100                         GOTO(putgl, rc);
2101                 if (dv != llss->dv2)
2102                         GOTO(putgl, rc = -EAGAIN);
2103         }
2104
2105         /* struct md_op_data is used to send the swap args to the mdt
2106          * only flags is missing, so we use struct mdc_swap_layouts
2107          * through the md_op_data->op_data */
2108         /* flags from user space have to be converted before they are send to
2109          * server, no flag is sent today, they are only used on the client */
2110         msl.msl_flags = 0;
2111         rc = -ENOMEM;
2112         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2113                                      0, LUSTRE_OPC_ANY, &msl);
2114         if (IS_ERR(op_data))
2115                 GOTO(free, rc = PTR_ERR(op_data));
2116
2117         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2118                            sizeof(*op_data), op_data, NULL);
2119         ll_finish_md_op_data(op_data);
2120
2121 putgl:
2122         if (gid != 0) {
2123                 ll_put_grouplock(llss->inode2, file2, gid);
2124                 ll_put_grouplock(llss->inode1, file1, gid);
2125         }
2126
2127         /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */
2128         if (rc != 0)
2129                 GOTO(free, rc);
2130
2131         /* clear useless flags */
2132         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
2133                 llss->ia1.ia_valid &= ~ATTR_MTIME;
2134                 llss->ia2.ia_valid &= ~ATTR_MTIME;
2135         }
2136
2137         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
2138                 llss->ia1.ia_valid &= ~ATTR_ATIME;
2139                 llss->ia2.ia_valid &= ~ATTR_ATIME;
2140         }
2141
2142         /* update time if requested */
2143         rc = 0;
2144         if (llss->ia2.ia_valid != 0) {
2145                 mutex_lock(&llss->inode1->i_mutex);
2146                 rc = ll_setattr(file1->f_dentry, &llss->ia2);
2147                 mutex_unlock(&llss->inode1->i_mutex);
2148         }
2149
2150         if (llss->ia1.ia_valid != 0) {
2151                 int rc1;
2152
2153                 mutex_lock(&llss->inode2->i_mutex);
2154                 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
2155                 mutex_unlock(&llss->inode2->i_mutex);
2156                 if (rc == 0)
2157                         rc = rc1;
2158         }
2159
2160 free:
2161         if (llss != NULL)
2162                 OBD_FREE_PTR(llss);
2163
2164         RETURN(rc);
2165 }
2166
2167 static int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2168 {
2169         struct md_op_data       *op_data;
2170         int                      rc;
2171
2172         /* Non-root users are forbidden to set or clear flags which are
2173          * NOT defined in HSM_USER_MASK. */
2174         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2175             !cfs_capable(CFS_CAP_SYS_ADMIN))
2176                 RETURN(-EPERM);
2177
2178         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2179                                      LUSTRE_OPC_ANY, hss);
2180         if (IS_ERR(op_data))
2181                 RETURN(PTR_ERR(op_data));
2182
2183         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2184                            sizeof(*op_data), op_data, NULL);
2185
2186         ll_finish_md_op_data(op_data);
2187
2188         RETURN(rc);
2189 }
2190
2191 static int ll_hsm_import(struct inode *inode, struct file *file,
2192                          struct hsm_user_import *hui)
2193 {
2194         struct hsm_state_set    *hss = NULL;
2195         struct iattr            *attr = NULL;
2196         int                      rc;
2197         ENTRY;
2198
2199         if (!S_ISREG(inode->i_mode))
2200                 RETURN(-EINVAL);
2201
2202         /* set HSM flags */
2203         OBD_ALLOC_PTR(hss);
2204         if (hss == NULL)
2205                 GOTO(out, rc = -ENOMEM);
2206
2207         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2208         hss->hss_archive_id = hui->hui_archive_id;
2209         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2210         rc = ll_hsm_state_set(inode, hss);
2211         if (rc != 0)
2212                 GOTO(out, rc);
2213
2214         OBD_ALLOC_PTR(attr);
2215         if (attr == NULL)
2216                 GOTO(out, rc = -ENOMEM);
2217
2218         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2219         attr->ia_mode |= S_IFREG;
2220         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2221         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2222         attr->ia_size = hui->hui_size;
2223         attr->ia_mtime.tv_sec = hui->hui_mtime;
2224         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2225         attr->ia_atime.tv_sec = hui->hui_atime;
2226         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2227
2228         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2229                          ATTR_UID | ATTR_GID |
2230                          ATTR_MTIME | ATTR_MTIME_SET |
2231                          ATTR_ATIME | ATTR_ATIME_SET;
2232
2233         mutex_lock(&inode->i_mutex);
2234
2235         rc = ll_setattr_raw(file->f_dentry, attr, true);
2236         if (rc == -ENODATA)
2237                 rc = 0;
2238
2239         mutex_unlock(&inode->i_mutex);
2240
2241 out:
2242         if (hss != NULL)
2243                 OBD_FREE_PTR(hss);
2244
2245         if (attr != NULL)
2246                 OBD_FREE_PTR(attr);
2247
2248         RETURN(rc);
2249 }
2250
2251 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2252 {
2253         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2254                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2255 }
2256
2257 static long
2258 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2259 {
2260         struct inode            *inode = file->f_dentry->d_inode;
2261         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2262         int                      flags, rc;
2263         ENTRY;
2264
2265         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
2266                PFID(ll_inode2fid(inode)), inode, cmd);
2267         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2268
2269         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2270         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2271                 RETURN(-ENOTTY);
2272
2273         switch(cmd) {
2274         case LL_IOC_GETFLAGS:
2275                 /* Get the current value of the file flags */
2276                 return put_user(fd->fd_flags, (int __user *)arg);
2277         case LL_IOC_SETFLAGS:
2278         case LL_IOC_CLRFLAGS:
2279                 /* Set or clear specific file flags */
2280                 /* XXX This probably needs checks to ensure the flags are
2281                  *     not abused, and to handle any flag side effects.
2282                  */
2283                 if (get_user(flags, (int __user *) arg))
2284                         RETURN(-EFAULT);
2285
2286                 if (cmd == LL_IOC_SETFLAGS) {
2287                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2288                             !(file->f_flags & O_DIRECT)) {
2289                                 CERROR("%s: unable to disable locking on "
2290                                        "non-O_DIRECT file\n", current->comm);
2291                                 RETURN(-EINVAL);
2292                         }
2293
2294                         fd->fd_flags |= flags;
2295                 } else {
2296                         fd->fd_flags &= ~flags;
2297                 }
2298                 RETURN(0);
2299         case LL_IOC_LOV_SETSTRIPE:
2300                 RETURN(ll_lov_setstripe(inode, file, arg));
2301         case LL_IOC_LOV_SETEA:
2302                 RETURN(ll_lov_setea(inode, file, arg));
2303         case LL_IOC_LOV_SWAP_LAYOUTS: {
2304                 struct file *file2;
2305                 struct lustre_swap_layouts lsl;
2306
2307                 if (copy_from_user(&lsl, (char __user *)arg,
2308                                        sizeof(struct lustre_swap_layouts)))
2309                         RETURN(-EFAULT);
2310
2311                 if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */
2312                         RETURN(-EPERM);
2313
2314                 file2 = fget(lsl.sl_fd);
2315                 if (file2 == NULL)
2316                         RETURN(-EBADF);
2317
2318                 rc = -EPERM;
2319                 if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */
2320                         rc = ll_swap_layouts(file, file2, &lsl);
2321                 fput(file2);
2322                 RETURN(rc);
2323         }
2324         case LL_IOC_LOV_GETSTRIPE:
2325                 RETURN(ll_lov_getstripe(inode, arg));
2326         case FSFILT_IOC_FIEMAP:
2327                 RETURN(ll_ioctl_fiemap(inode, arg));
2328         case FSFILT_IOC_GETFLAGS:
2329         case FSFILT_IOC_SETFLAGS:
2330                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2331         case FSFILT_IOC_GETVERSION_OLD:
2332         case FSFILT_IOC_GETVERSION:
2333                 RETURN(put_user(inode->i_generation, (int __user *)arg));
2334         case LL_IOC_GROUP_LOCK:
2335                 RETURN(ll_get_grouplock(inode, file, arg));
2336         case LL_IOC_GROUP_UNLOCK:
2337                 RETURN(ll_put_grouplock(inode, file, arg));
2338         case IOC_OBD_STATFS:
2339                 RETURN(ll_obd_statfs(inode, (void __user *)arg));
2340
2341         /* We need to special case any other ioctls we want to handle,
2342          * to send them to the MDS/OST as appropriate and to properly
2343          * network encode the arg field.
2344         case FSFILT_IOC_SETVERSION_OLD:
2345         case FSFILT_IOC_SETVERSION:
2346         */
2347         case LL_IOC_FLUSHCTX:
2348                 RETURN(ll_flush_ctx(inode));
2349         case LL_IOC_PATH2FID: {
2350                 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
2351                                  sizeof(struct lu_fid)))
2352                         RETURN(-EFAULT);
2353
2354                 RETURN(0);
2355         }
2356         case LL_IOC_GETPARENT:
2357                 RETURN(ll_getparent(file, (void __user *)arg));
2358
2359         case OBD_IOC_FID2PATH:
2360                 RETURN(ll_fid2path(inode, (void __user *)arg));
2361         case LL_IOC_DATA_VERSION: {
2362                 struct ioc_data_version idv;
2363                 int rc;
2364
2365                 if (copy_from_user(&idv, (char __user *)arg, sizeof(idv)))
2366                         RETURN(-EFAULT);
2367
2368                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
2369                 rc = ll_data_version(inode, &idv.idv_version, idv.idv_flags);
2370
2371                 if (rc == 0 &&
2372                     copy_to_user((char __user *)arg, &idv, sizeof(idv)))
2373                         RETURN(-EFAULT);
2374
2375                 RETURN(rc);
2376         }
2377
2378         case LL_IOC_GET_MDTIDX: {
2379                 int mdtidx;
2380
2381                 mdtidx = ll_get_mdt_idx(inode);
2382                 if (mdtidx < 0)
2383                         RETURN(mdtidx);
2384
2385                 if (put_user((int)mdtidx, (int __user *)arg))
2386                         RETURN(-EFAULT);
2387
2388                 RETURN(0);
2389         }
2390         case OBD_IOC_GETDTNAME:
2391         case OBD_IOC_GETMDNAME:
2392                 RETURN(ll_get_obd_name(inode, cmd, arg));
2393         case LL_IOC_HSM_STATE_GET: {
2394                 struct md_op_data       *op_data;
2395                 struct hsm_user_state   *hus;
2396                 int                      rc;
2397
2398                 OBD_ALLOC_PTR(hus);
2399                 if (hus == NULL)
2400                         RETURN(-ENOMEM);
2401
2402                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2403                                              LUSTRE_OPC_ANY, hus);
2404                 if (IS_ERR(op_data)) {
2405                         OBD_FREE_PTR(hus);
2406                         RETURN(PTR_ERR(op_data));
2407                 }
2408
2409                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2410                                    op_data, NULL);
2411
2412                 if (copy_to_user((void __user *)arg, hus, sizeof(*hus)))
2413                         rc = -EFAULT;
2414
2415                 ll_finish_md_op_data(op_data);
2416                 OBD_FREE_PTR(hus);
2417                 RETURN(rc);
2418         }
2419         case LL_IOC_HSM_STATE_SET: {
2420                 struct hsm_state_set    *hss;
2421                 int                      rc;
2422
2423                 OBD_ALLOC_PTR(hss);
2424                 if (hss == NULL)
2425                         RETURN(-ENOMEM);
2426
2427                 if (copy_from_user(hss, (char __user *)arg, sizeof(*hss))) {
2428                         OBD_FREE_PTR(hss);
2429                         RETURN(-EFAULT);
2430                 }
2431
2432                 rc = ll_hsm_state_set(inode, hss);
2433
2434                 OBD_FREE_PTR(hss);
2435                 RETURN(rc);
2436         }
2437         case LL_IOC_HSM_ACTION: {
2438                 struct md_op_data               *op_data;
2439                 struct hsm_current_action       *hca;
2440                 int                              rc;
2441
2442                 OBD_ALLOC_PTR(hca);
2443                 if (hca == NULL)
2444                         RETURN(-ENOMEM);
2445
2446                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2447                                              LUSTRE_OPC_ANY, hca);
2448                 if (IS_ERR(op_data)) {
2449                         OBD_FREE_PTR(hca);
2450                         RETURN(PTR_ERR(op_data));
2451                 }
2452
2453                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2454                                    op_data, NULL);
2455
2456                 if (copy_to_user((char __user *)arg, hca, sizeof(*hca)))
2457                         rc = -EFAULT;
2458
2459                 ll_finish_md_op_data(op_data);
2460                 OBD_FREE_PTR(hca);
2461                 RETURN(rc);
2462         }
2463         case LL_IOC_SET_LEASE: {
2464                 struct ll_inode_info *lli = ll_i2info(inode);
2465                 struct obd_client_handle *och = NULL;
2466                 bool lease_broken;
2467                 fmode_t fmode;
2468
2469                 switch (arg) {
2470                 case LL_LEASE_WRLCK:
2471                         if (!(file->f_mode & FMODE_WRITE))
2472                                 RETURN(-EPERM);
2473                         fmode = FMODE_WRITE;
2474                         break;
2475                 case LL_LEASE_RDLCK:
2476                         if (!(file->f_mode & FMODE_READ))
2477                                 RETURN(-EPERM);
2478                         fmode = FMODE_READ;
2479                         break;
2480                 case LL_LEASE_UNLCK:
2481                         mutex_lock(&lli->lli_och_mutex);
2482                         if (fd->fd_lease_och != NULL) {
2483                                 och = fd->fd_lease_och;
2484                                 fd->fd_lease_och = NULL;
2485                         }
2486                         mutex_unlock(&lli->lli_och_mutex);
2487
2488                         if (och == NULL)
2489                                 RETURN(-ENOLCK);
2490
2491                         fmode = och->och_flags;
2492                         rc = ll_lease_close(och, inode, &lease_broken);
2493                         if (rc < 0)
2494                                 RETURN(rc);
2495
2496                         if (lease_broken)
2497                                 fmode = 0;
2498
2499                         RETURN(ll_lease_type_from_fmode(fmode));
2500                 default:
2501                         RETURN(-EINVAL);
2502                 }
2503
2504                 CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
2505
2506                 /* apply for lease */
2507                 och = ll_lease_open(inode, file, fmode, 0);
2508                 if (IS_ERR(och))
2509                         RETURN(PTR_ERR(och));
2510
2511                 rc = 0;
2512                 mutex_lock(&lli->lli_och_mutex);
2513                 if (fd->fd_lease_och == NULL) {
2514                         fd->fd_lease_och = och;
2515                         och = NULL;
2516                 }
2517                 mutex_unlock(&lli->lli_och_mutex);
2518                 if (och != NULL) {
2519                         /* impossible now that only excl is supported for now */
2520                         ll_lease_close(och, inode, &lease_broken);
2521                         rc = -EBUSY;
2522                 }
2523                 RETURN(rc);
2524         }
2525         case LL_IOC_GET_LEASE: {
2526                 struct ll_inode_info *lli = ll_i2info(inode);
2527                 struct ldlm_lock *lock = NULL;
2528                 fmode_t fmode = 0;
2529
2530                 mutex_lock(&lli->lli_och_mutex);
2531                 if (fd->fd_lease_och != NULL) {
2532                         struct obd_client_handle *och = fd->fd_lease_och;
2533
2534                         lock = ldlm_handle2lock(&och->och_lease_handle);
2535                         if (lock != NULL) {
2536                                 lock_res_and_lock(lock);
2537                                 if (!ldlm_is_cancel(lock))
2538                                         fmode = och->och_flags;
2539
2540                                 unlock_res_and_lock(lock);
2541                                 LDLM_LOCK_PUT(lock);
2542                         }
2543                 }
2544                 mutex_unlock(&lli->lli_och_mutex);
2545
2546                 RETURN(ll_lease_type_from_fmode(fmode));
2547         }
2548         case LL_IOC_HSM_IMPORT: {
2549                 struct hsm_user_import *hui;
2550
2551                 OBD_ALLOC_PTR(hui);
2552                 if (hui == NULL)
2553                         RETURN(-ENOMEM);
2554
2555                 if (copy_from_user(hui, (void __user *)arg, sizeof(*hui))) {
2556                         OBD_FREE_PTR(hui);
2557                         RETURN(-EFAULT);
2558                 }
2559
2560                 rc = ll_hsm_import(inode, file, hui);
2561
2562                 OBD_FREE_PTR(hui);
2563                 RETURN(rc);
2564         }
2565
2566         default: {
2567                 int err;
2568
2569                 if (LLIOC_STOP ==
2570                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2571                         RETURN(err);
2572
2573                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2574                                      (void __user *)arg));
2575         }
2576         }
2577 }
2578
2579 #ifndef HAVE_FILE_LLSEEK_SIZE
2580 static inline loff_t
2581 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2582 {
2583         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2584                 return -EINVAL;
2585         if (offset > maxsize)
2586                 return -EINVAL;
2587
2588         if (offset != file->f_pos) {
2589                 file->f_pos = offset;
2590                 file->f_version = 0;
2591         }
2592         return offset;
2593 }
2594
2595 static loff_t
2596 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2597                 loff_t maxsize, loff_t eof)
2598 {
2599         struct inode *inode = file->f_dentry->d_inode;
2600
2601         switch (origin) {
2602         case SEEK_END:
2603                 offset += eof;
2604                 break;
2605         case SEEK_CUR:
2606                 /*
2607                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2608                  * position-querying operation.  Avoid rewriting the "same"
2609                  * f_pos value back to the file because a concurrent read(),
2610                  * write() or lseek() might have altered it
2611                  */
2612                 if (offset == 0)
2613                         return file->f_pos;
2614                 /*
2615                  * f_lock protects against read/modify/write race with other
2616                  * SEEK_CURs. Note that parallel writes and reads behave
2617                  * like SEEK_SET.
2618                  */
2619                 mutex_lock(&inode->i_mutex);
2620                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2621                 mutex_unlock(&inode->i_mutex);
2622                 return offset;
2623         case SEEK_DATA:
2624                 /*
2625                  * In the generic case the entire file is data, so as long as
2626                  * offset isn't at the end of the file then the offset is data.
2627                  */
2628                 if (offset >= eof)
2629                         return -ENXIO;
2630                 break;
2631         case SEEK_HOLE:
2632                 /*
2633                  * There is a virtual hole at the end of the file, so as long as
2634                  * offset isn't i_size or larger, return i_size.
2635                  */
2636                 if (offset >= eof)
2637                         return -ENXIO;
2638                 offset = eof;
2639                 break;
2640         }
2641
2642         return llseek_execute(file, offset, maxsize);
2643 }
2644 #endif
2645
2646 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2647 {
2648         struct inode *inode = file->f_dentry->d_inode;
2649         loff_t retval, eof = 0;
2650
2651         ENTRY;
2652         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2653                            (origin == SEEK_CUR) ? file->f_pos : 0);
2654         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
2655                PFID(ll_inode2fid(inode)), inode, retval, retval,
2656                origin);
2657         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2658
2659         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2660                 retval = ll_glimpse_size(inode);
2661                 if (retval != 0)
2662                         RETURN(retval);
2663                 eof = i_size_read(inode);
2664         }
2665
2666         retval = ll_generic_file_llseek_size(file, offset, origin,
2667                                           ll_file_maxbytes(inode), eof);
2668         RETURN(retval);
2669 }
2670
2671 static int ll_flush(struct file *file, fl_owner_t id)
2672 {
2673         struct inode *inode = file->f_dentry->d_inode;
2674         struct ll_inode_info *lli = ll_i2info(inode);
2675         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2676         int rc, err;
2677
2678         LASSERT(!S_ISDIR(inode->i_mode));
2679
2680         /* catch async errors that were recorded back when async writeback
2681          * failed for pages in this mapping. */
2682         rc = lli->lli_async_rc;
2683         lli->lli_async_rc = 0;
2684         if (lli->lli_clob != NULL) {
2685                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2686                 if (rc == 0)
2687                         rc = err;
2688         }
2689
2690         /* The application has been told write failure already.
2691          * Do not report failure again. */
2692         if (fd->fd_write_failed)
2693                 return 0;
2694         return rc ? -EIO : 0;
2695 }
2696
2697 /**
2698  * Called to make sure a portion of file has been written out.
2699  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
2700  *
2701  * Return how many pages have been written.
2702  */
2703 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2704                        enum cl_fsync_mode mode, int ignore_layout)
2705 {
2706         struct cl_env_nest nest;
2707         struct lu_env *env;
2708         struct cl_io *io;
2709         struct obd_capa *capa = NULL;
2710         struct cl_fsync_io *fio;
2711         int result;
2712         ENTRY;
2713
2714         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2715             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2716                 RETURN(-EINVAL);
2717
2718         env = cl_env_nested_get(&nest);
2719         if (IS_ERR(env))
2720                 RETURN(PTR_ERR(env));
2721
2722         capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2723
2724         io = ccc_env_thread_io(env);
2725         io->ci_obj = cl_i2info(inode)->lli_clob;
2726         io->ci_ignore_layout = ignore_layout;
2727
2728         /* initialize parameters for sync */
2729         fio = &io->u.ci_fsync;
2730         fio->fi_capa = capa;
2731         fio->fi_start = start;
2732         fio->fi_end = end;
2733         fio->fi_fid = ll_inode2fid(inode);
2734         fio->fi_mode = mode;
2735         fio->fi_nr_written = 0;
2736
2737         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2738                 result = cl_io_loop(env, io);
2739         else
2740                 result = io->ci_result;
2741         if (result == 0)
2742                 result = fio->fi_nr_written;
2743         cl_io_fini(env, io);
2744         cl_env_nested_put(&nest, env);
2745
2746         capa_put(capa);
2747
2748         RETURN(result);
2749 }
2750
2751 /*
2752  * When dentry is provided (the 'else' case), *file->f_dentry may be
2753  * null and dentry must be used directly rather than pulled from
2754  * *file->f_dentry as is done otherwise.
2755  */
2756
2757 #ifdef HAVE_FILE_FSYNC_4ARGS
2758 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2759 {
2760         struct dentry *dentry = file->f_dentry;
2761 #elif defined(HAVE_FILE_FSYNC_2ARGS)
2762 int ll_fsync(struct file *file, int datasync)
2763 {
2764         struct dentry *dentry = file->f_dentry;
2765         loff_t start = 0;
2766         loff_t end = LLONG_MAX;
2767 #else
2768 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
2769 {
2770         loff_t start = 0;
2771         loff_t end = LLONG_MAX;
2772 #endif
2773         struct inode *inode = dentry->d_inode;
2774         struct ll_inode_info *lli = ll_i2info(inode);
2775         struct ptlrpc_request *req;
2776         struct obd_capa *oc;
2777         int rc, err;
2778         ENTRY;
2779
2780         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
2781                PFID(ll_inode2fid(inode)), inode);
2782         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2783
2784 #ifdef HAVE_FILE_FSYNC_4ARGS
2785         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2786         mutex_lock(&inode->i_mutex);
2787 #else
2788         /* fsync's caller has already called _fdata{sync,write}, we want
2789          * that IO to finish before calling the osc and mdc sync methods */
2790         rc = filemap_fdatawait(inode->i_mapping);
2791 #endif
2792
2793         /* catch async errors that were recorded back when async writeback
2794          * failed for pages in this mapping. */
2795         if (!S_ISDIR(inode->i_mode)) {
2796                 err = lli->lli_async_rc;
2797                 lli->lli_async_rc = 0;
2798                 if (rc == 0)
2799                         rc = err;
2800                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2801                 if (rc == 0)
2802                         rc = err;
2803         }
2804
2805         oc = ll_mdscapa_get(inode);
2806         err = md_fsync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2807                        &req);
2808         capa_put(oc);
2809         if (!rc)
2810                 rc = err;
2811         if (!err)
2812                 ptlrpc_req_finished(req);
2813
2814         if (S_ISREG(inode->i_mode)) {
2815                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2816
2817                 err = cl_sync_file_range(inode, start, end, CL_FSYNC_ALL, 0);
2818                 if (rc == 0 && err < 0)
2819                         rc = err;
2820                 if (rc < 0)
2821                         fd->fd_write_failed = true;
2822                 else
2823                         fd->fd_write_failed = false;
2824         }
2825
2826 #ifdef HAVE_FILE_FSYNC_4ARGS
2827         mutex_unlock(&inode->i_mutex);
2828 #endif
2829         RETURN(rc);
2830 }
2831
2832 static int
2833 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2834 {
2835         struct inode *inode = file->f_dentry->d_inode;
2836         struct ll_sb_info *sbi = ll_i2sbi(inode);
2837         struct ldlm_enqueue_info einfo = {
2838                 .ei_type        = LDLM_FLOCK,
2839                 .ei_cb_cp       = ldlm_flock_completion_ast,
2840                 .ei_cbdata      = file_lock,
2841         };
2842         struct md_op_data *op_data;
2843         struct lustre_handle lockh = {0};
2844         ldlm_policy_data_t flock = {{0}};
2845         int fl_type = file_lock->fl_type;
2846         __u64 flags = 0;
2847         int rc;
2848         int rc2 = 0;
2849         ENTRY;
2850
2851         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
2852                PFID(ll_inode2fid(inode)), file_lock);
2853
2854         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2855
2856         if (file_lock->fl_flags & FL_FLOCK) {
2857                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2858                 /* flocks are whole-file locks */
2859                 flock.l_flock.end = OFFSET_MAX;
2860                 /* For flocks owner is determined by the local file desctiptor*/
2861                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2862         } else if (file_lock->fl_flags & FL_POSIX) {
2863                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2864                 flock.l_flock.start = file_lock->fl_start;
2865                 flock.l_flock.end = file_lock->fl_end;
2866         } else {
2867                 RETURN(-EINVAL);
2868         }
2869         flock.l_flock.pid = file_lock->fl_pid;
2870
2871         /* Somewhat ugly workaround for svc lockd.
2872          * lockd installs custom fl_lmops->lm_compare_owner that checks
2873          * for the fl_owner to be the same (which it always is on local node
2874          * I guess between lockd processes) and then compares pid.
2875          * As such we assign pid to the owner field to make it all work,
2876          * conflict with normal locks is unlikely since pid space and
2877          * pointer space for current->files are not intersecting */
2878         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2879                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2880
2881         switch (fl_type) {
2882         case F_RDLCK:
2883                 einfo.ei_mode = LCK_PR;
2884                 break;
2885         case F_UNLCK:
2886                 /* An unlock request may or may not have any relation to
2887                  * existing locks so we may not be able to pass a lock handle
2888                  * via a normal ldlm_lock_cancel() request. The request may even
2889                  * unlock a byte range in the middle of an existing lock. In
2890                  * order to process an unlock request we need all of the same
2891                  * information that is given with a normal read or write record
2892                  * lock request. To avoid creating another ldlm unlock (cancel)
2893                  * message we'll treat a LCK_NL flock request as an unlock. */
2894                 einfo.ei_mode = LCK_NL;
2895                 break;
2896         case F_WRLCK:
2897                 einfo.ei_mode = LCK_PW;
2898                 break;
2899         default:
2900                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n", fl_type);
2901                 RETURN (-ENOTSUPP);
2902         }
2903
2904         switch (cmd) {
2905         case F_SETLKW:
2906 #ifdef F_SETLKW64
2907         case F_SETLKW64:
2908 #endif
2909                 flags = 0;
2910                 break;
2911         case F_SETLK:
2912 #ifdef F_SETLK64
2913         case F_SETLK64:
2914 #endif
2915                 flags = LDLM_FL_BLOCK_NOWAIT;
2916                 break;
2917         case F_GETLK:
2918 #ifdef F_GETLK64
2919         case F_GETLK64:
2920 #endif
2921                 flags = LDLM_FL_TEST_LOCK;
2922                 break;
2923         default:
2924                 CERROR("unknown fcntl lock command: %d\n", cmd);
2925                 RETURN (-EINVAL);
2926         }
2927
2928         /* Save the old mode so that if the mode in the lock changes we
2929          * can decrement the appropriate reader or writer refcount. */
2930         file_lock->fl_type = einfo.ei_mode;
2931
2932         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2933                                      LUSTRE_OPC_ANY, NULL);
2934         if (IS_ERR(op_data))
2935                 RETURN(PTR_ERR(op_data));
2936
2937         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags="LPX64", mode=%u, "
2938                "start="LPU64", end="LPU64"\n", PFID(ll_inode2fid(inode)),
2939                flock.l_flock.pid, flags, einfo.ei_mode,
2940                flock.l_flock.start, flock.l_flock.end);
2941
2942         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data, &lockh,
2943                         flags);
2944
2945         /* Restore the file lock type if not TEST lock. */
2946         if (!(flags & LDLM_FL_TEST_LOCK))
2947                 file_lock->fl_type = fl_type;
2948
2949         if ((file_lock->fl_flags & FL_FLOCK) &&
2950             (rc == 0 || file_lock->fl_type == F_UNLCK))
2951                 rc2  = flock_lock_file_wait(file, file_lock);
2952         if ((file_lock->fl_flags & FL_POSIX) &&
2953             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2954             !(flags & LDLM_FL_TEST_LOCK))
2955                 rc2  = posix_lock_file_wait(file, file_lock);
2956
2957         if (rc2 && file_lock->fl_type != F_UNLCK) {
2958                 einfo.ei_mode = LCK_NL;
2959                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data,
2960                            &lockh, flags);
2961                 rc = rc2;
2962         }
2963
2964         ll_finish_md_op_data(op_data);
2965
2966         RETURN(rc);
2967 }
2968
2969 int ll_get_fid_by_name(struct inode *parent, const char *name,
2970                        int namelen, struct lu_fid *fid)
2971 {
2972         struct md_op_data       *op_data = NULL;
2973         struct mdt_body         *body;
2974         struct ptlrpc_request   *req;
2975         int                     rc;
2976         ENTRY;
2977
2978         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
2979                                      LUSTRE_OPC_ANY, NULL);
2980         if (IS_ERR(op_data))
2981                 RETURN(PTR_ERR(op_data));
2982
2983         op_data->op_valid = OBD_MD_FLID;
2984         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
2985         ll_finish_md_op_data(op_data);
2986         if (rc < 0)
2987                 RETURN(rc);
2988
2989         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2990         if (body == NULL)
2991                 GOTO(out_req, rc = -EFAULT);
2992         if (fid != NULL)
2993                 *fid = body->mbo_fid1;
2994 out_req:
2995         ptlrpc_req_finished(req);
2996         RETURN(rc);
2997 }
2998
2999 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
3000                const char *name, int namelen)
3001 {
3002         struct dentry         *dchild = NULL;
3003         struct inode          *child_inode = NULL;
3004         struct md_op_data     *op_data;
3005         struct ptlrpc_request *request = NULL;
3006         struct qstr           qstr;
3007         int                    rc;
3008         ENTRY;
3009
3010         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
3011                name, PFID(ll_inode2fid(parent)), mdtidx);
3012
3013         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
3014                                      0, LUSTRE_OPC_ANY, NULL);
3015         if (IS_ERR(op_data))
3016                 RETURN(PTR_ERR(op_data));
3017
3018         /* Get child FID first */
3019         qstr.hash = full_name_hash(name, namelen);
3020         qstr.name = name;
3021         qstr.len = namelen;
3022         dchild = d_lookup(file->f_dentry, &qstr);
3023         if (dchild != NULL && dchild->d_inode != NULL) {
3024                 op_data->op_fid3 = *ll_inode2fid(dchild->d_inode);
3025                 if (dchild->d_inode != NULL) {
3026                         child_inode = igrab(dchild->d_inode);
3027                         ll_invalidate_aliases(child_inode);
3028                 }
3029                 dput(dchild);
3030         } else {
3031                 rc = ll_get_fid_by_name(parent, name, namelen,
3032                                         &op_data->op_fid3);
3033                 if (rc != 0)
3034                         GOTO(out_free, rc);
3035         }
3036
3037         if (!fid_is_sane(&op_data->op_fid3)) {
3038                 CERROR("%s: migrate %s , but fid "DFID" is insane\n",
3039                        ll_get_fsname(parent->i_sb, NULL, 0), name,
3040                        PFID(&op_data->op_fid3));
3041                 GOTO(out_free, rc = -EINVAL);
3042         }
3043
3044         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
3045         if (rc < 0)
3046                 GOTO(out_free, rc);
3047
3048         if (rc == mdtidx) {
3049                 CDEBUG(D_INFO, "%s:"DFID" is already on MDT%d.\n", name,
3050                        PFID(&op_data->op_fid3), mdtidx);
3051                 GOTO(out_free, rc = 0);
3052         }
3053
3054         op_data->op_mds = mdtidx;
3055         op_data->op_cli_flags = CLI_MIGRATE;
3056         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3057                        namelen, name, namelen, &request);
3058         if (rc == 0)
3059                 ll_update_times(request, parent);
3060
3061         ptlrpc_req_finished(request);
3062         if (rc != 0)
3063                 GOTO(out_free, rc);
3064
3065 out_free:
3066         if (child_inode != NULL) {
3067                 clear_nlink(child_inode);
3068                 iput(child_inode);
3069         }
3070
3071         ll_finish_md_op_data(op_data);
3072         RETURN(rc);
3073 }
3074
3075 static int
3076 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3077 {
3078         ENTRY;
3079
3080         RETURN(-ENOSYS);
3081 }
3082
3083 /**
3084  * test if some locks matching bits and l_req_mode are acquired
3085  * - bits can be in different locks
3086  * - if found clear the common lock bits in *bits
3087  * - the bits not found, are kept in *bits
3088  * \param inode [IN]
3089  * \param bits [IN] searched lock bits [IN]
3090  * \param l_req_mode [IN] searched lock mode
3091  * \retval boolean, true iff all bits are found
3092  */
3093 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
3094 {
3095         struct lustre_handle lockh;
3096         ldlm_policy_data_t policy;
3097         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
3098                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
3099         struct lu_fid *fid;
3100         __u64 flags;
3101         int i;
3102         ENTRY;
3103
3104         if (!inode)
3105                RETURN(0);
3106
3107         fid = &ll_i2info(inode)->lli_fid;
3108         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3109                ldlm_lockname[mode]);
3110
3111         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3112         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3113                 policy.l_inodebits.bits = *bits & (1 << i);
3114                 if (policy.l_inodebits.bits == 0)
3115                         continue;
3116
3117                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3118                                   &policy, mode, &lockh)) {
3119                         struct ldlm_lock *lock;
3120
3121                         lock = ldlm_handle2lock(&lockh);
3122                         if (lock) {
3123                                 *bits &=
3124                                       ~(lock->l_policy_data.l_inodebits.bits);
3125                                 LDLM_LOCK_PUT(lock);
3126                         } else {
3127                                 *bits &= ~policy.l_inodebits.bits;
3128                         }
3129                 }
3130         }
3131         RETURN(*bits == 0);
3132 }
3133
3134 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
3135                             struct lustre_handle *lockh, __u64 flags,
3136                             ldlm_mode_t mode)
3137 {
3138         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
3139         struct lu_fid *fid;
3140         ldlm_mode_t rc;
3141         ENTRY;
3142
3143         fid = &ll_i2info(inode)->lli_fid;
3144         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3145
3146         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3147                            fid, LDLM_IBITS, &policy, mode, lockh);
3148
3149         RETURN(rc);
3150 }
3151
3152 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3153 {
3154         /* Already unlinked. Just update nlink and return success */
3155         if (rc == -ENOENT) {
3156                 clear_nlink(inode);
3157                 /* This path cannot be hit for regular files unless in
3158                  * case of obscure races, so no need to to validate
3159                  * size. */
3160                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3161                         return 0;
3162         } else if (rc != 0) {
3163                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
3164                              "%s: revalidate FID "DFID" error: rc = %d\n",
3165                              ll_get_fsname(inode->i_sb, NULL, 0),
3166                              PFID(ll_inode2fid(inode)), rc);
3167         }
3168
3169         return rc;
3170 }
3171
3172 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3173 {
3174         struct inode *inode = dentry->d_inode;
3175         struct ptlrpc_request *req = NULL;
3176         struct obd_export *exp;
3177         int rc = 0;
3178         ENTRY;
3179
3180         LASSERT(inode != NULL);
3181
3182         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
3183                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
3184
3185         exp = ll_i2mdexp(inode);
3186
3187         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3188          *      But under CMD case, it caused some lock issues, should be fixed
3189          *      with new CMD ibits lock. See bug 12718 */
3190         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3191                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3192                 struct md_op_data *op_data;
3193
3194                 if (ibits == MDS_INODELOCK_LOOKUP)
3195                         oit.it_op = IT_LOOKUP;
3196
3197                 /* Call getattr by fid, so do not provide name at all. */
3198                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
3199                                              dentry->d_inode, NULL, 0, 0,
3200                                              LUSTRE_OPC_ANY, NULL);
3201                 if (IS_ERR(op_data))
3202                         RETURN(PTR_ERR(op_data));
3203
3204                 rc = md_intent_lock(exp, op_data, &oit, &req,
3205                                     &ll_md_blocking_ast, 0);
3206                 ll_finish_md_op_data(op_data);
3207                 if (rc < 0) {
3208                         rc = ll_inode_revalidate_fini(inode, rc);
3209                         GOTO (out, rc);
3210                 }
3211
3212                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3213                 if (rc != 0) {
3214                         ll_intent_release(&oit);
3215                         GOTO(out, rc);
3216                 }
3217
3218                 /* Unlinked? Unhash dentry, so it is not picked up later by
3219                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3220                    here to preserve get_cwd functionality on 2.6.
3221                    Bug 10503 */
3222                 if (!dentry->d_inode->i_nlink)
3223                         d_lustre_invalidate(dentry, 0);
3224
3225                 ll_lookup_finish_locks(&oit, dentry);
3226         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3227                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3228                 obd_valid valid = OBD_MD_FLGETATTR;
3229                 struct md_op_data *op_data;
3230                 int ealen = 0;
3231
3232                 if (S_ISREG(inode->i_mode)) {
3233                         rc = ll_get_default_mdsize(sbi, &ealen);
3234                         if (rc)
3235                                 RETURN(rc);
3236                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3237                 }
3238
3239                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3240                                              0, ealen, LUSTRE_OPC_ANY,
3241                                              NULL);
3242                 if (IS_ERR(op_data))
3243                         RETURN(PTR_ERR(op_data));
3244
3245                 op_data->op_valid = valid;
3246                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
3247                  * capa for this inode. Because we only keep capas of dirs
3248                  * fresh. */
3249                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3250                 ll_finish_md_op_data(op_data);
3251                 if (rc) {
3252                         rc = ll_inode_revalidate_fini(inode, rc);
3253                         RETURN(rc);
3254                 }
3255
3256                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3257         }
3258 out:
3259         ptlrpc_req_finished(req);
3260         return rc;
3261 }
3262
3263 static int ll_merge_md_attr(struct inode *inode)
3264 {
3265         struct cl_attr attr = { 0 };
3266         int rc;
3267
3268         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
3269         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
3270                            &attr);
3271         if (rc != 0)
3272                 RETURN(rc);
3273
3274         ll_i2info(inode)->lli_stripe_dir_size = attr.cat_size;
3275         ll_i2info(inode)->lli_stripe_dir_nlink = attr.cat_nlink;
3276
3277         ll_i2info(inode)->lli_lvb.lvb_atime = attr.cat_atime;
3278         ll_i2info(inode)->lli_lvb.lvb_mtime = attr.cat_mtime;
3279         ll_i2info(inode)->lli_lvb.lvb_ctime = attr.cat_ctime;
3280
3281         RETURN(0);
3282 }
3283
3284 static int
3285 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3286 {
3287         struct inode    *inode = dentry->d_inode;
3288         int              rc;
3289         ENTRY;
3290
3291         rc = __ll_inode_revalidate(dentry, ibits);
3292         if (rc != 0)
3293                 RETURN(rc);
3294
3295         /* if object isn't regular file, don't validate size */
3296         if (!S_ISREG(inode->i_mode)) {
3297                 if (S_ISDIR(inode->i_mode) &&
3298                     ll_i2info(inode)->lli_lsm_md != NULL) {
3299                         rc = ll_merge_md_attr(inode);
3300                         if (rc != 0)
3301                                 RETURN(rc);
3302                 }
3303
3304                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
3305                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
3306                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
3307         } else {
3308                 /* In case of restore, the MDT has the right size and has
3309                  * already send it back without granting the layout lock,
3310                  * inode is up-to-date so glimpse is useless.
3311                  * Also to glimpse we need the layout, in case of a running
3312                  * restore the MDT holds the layout lock so the glimpse will
3313                  * block up to the end of restore (getattr will block)
3314                  */
3315                 if (!(ll_i2info(inode)->lli_flags & LLIF_FILE_RESTORING))
3316                         rc = ll_glimpse_size(inode);
3317         }
3318         RETURN(rc);
3319 }
3320
3321 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
3322 {
3323         struct inode *inode = de->d_inode;
3324         struct ll_sb_info *sbi = ll_i2sbi(inode);
3325         struct ll_inode_info *lli = ll_i2info(inode);
3326         int res = 0;
3327
3328         res = ll_inode_revalidate(de, MDS_INODELOCK_UPDATE |
3329                                       MDS_INODELOCK_LOOKUP);
3330         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
3331
3332         if (res)
3333                 return res;
3334
3335         stat->dev = inode->i_sb->s_dev;
3336         if (ll_need_32bit_api(sbi))
3337                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
3338         else
3339                 stat->ino = inode->i_ino;
3340         stat->mode = inode->i_mode;
3341         stat->uid = inode->i_uid;
3342         stat->gid = inode->i_gid;
3343         stat->rdev = inode->i_rdev;
3344         stat->atime = inode->i_atime;
3345         stat->mtime = inode->i_mtime;
3346         stat->ctime = inode->i_ctime;
3347         stat->blksize = 1 << inode->i_blkbits;
3348         stat->blocks = inode->i_blocks;
3349
3350         if (S_ISDIR(inode->i_mode) &&
3351                 ll_i2info(inode)->lli_lsm_md != NULL) {
3352                 stat->nlink = lli->lli_stripe_dir_nlink;
3353                 stat->size = lli->lli_stripe_dir_size;
3354         } else {
3355                 stat->nlink = inode->i_nlink;
3356                 stat->size = i_size_read(inode);
3357         }
3358
3359         return 0;
3360 }
3361
3362 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3363                      __u64 start, __u64 len)
3364 {
3365         int rc;
3366         size_t num_bytes;
3367         struct ll_user_fiemap *fiemap;
3368         unsigned int extent_count = fieinfo->fi_extents_max;
3369
3370         num_bytes = sizeof(*fiemap) + (extent_count *
3371                                        sizeof(struct ll_fiemap_extent));
3372         OBD_ALLOC_LARGE(fiemap, num_bytes);
3373
3374         if (fiemap == NULL)
3375                 RETURN(-ENOMEM);
3376
3377         fiemap->fm_flags = fieinfo->fi_flags;
3378         fiemap->fm_extent_count = fieinfo->fi_extents_max;
3379         fiemap->fm_start = start;
3380         fiemap->fm_length = len;
3381         if (extent_count > 0)
3382                 memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
3383                        sizeof(struct ll_fiemap_extent));
3384
3385         rc = ll_do_fiemap(inode, fiemap, num_bytes);
3386
3387         fieinfo->fi_flags = fiemap->fm_flags;
3388         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
3389         if (extent_count > 0)
3390                 memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
3391                        fiemap->fm_mapped_extents *
3392                        sizeof(struct ll_fiemap_extent));
3393
3394         OBD_FREE_LARGE(fiemap, num_bytes);
3395         return rc;
3396 }
3397
3398 struct posix_acl *ll_get_acl(struct inode *inode, int type)
3399 {
3400         struct ll_inode_info *lli = ll_i2info(inode);
3401         struct posix_acl *acl = NULL;
3402         ENTRY;
3403
3404         spin_lock(&lli->lli_lock);
3405         /* VFS' acl_permission_check->check_acl will release the refcount */
3406         acl = posix_acl_dup(lli->lli_posix_acl);
3407         spin_unlock(&lli->lli_lock);
3408
3409         RETURN(acl);
3410 }
3411
3412 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
3413 static int
3414 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
3415 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
3416 # else
3417 ll_check_acl(struct inode *inode, int mask)
3418 # endif
3419 {
3420 # ifdef CONFIG_FS_POSIX_ACL
3421         struct posix_acl *acl;
3422         int rc;
3423         ENTRY;
3424
3425 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
3426         if (flags & IPERM_FLAG_RCU)
3427                 return -ECHILD;
3428 #  endif
3429         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
3430
3431         if (!acl)
3432                 RETURN(-EAGAIN);
3433
3434         rc = posix_acl_permission(inode, acl, mask);
3435         posix_acl_release(acl);
3436
3437         RETURN(rc);
3438 # else /* !CONFIG_FS_POSIX_ACL */
3439         return -EAGAIN;
3440 # endif /* CONFIG_FS_POSIX_ACL */
3441 }
3442 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
3443
3444 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
3445 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
3446 #else
3447 # ifdef HAVE_INODE_PERMISION_2ARGS
3448 int ll_inode_permission(struct inode *inode, int mask)
3449 # else
3450 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
3451 # endif
3452 #endif
3453 {
3454         int rc = 0;
3455         struct ll_sb_info *sbi;
3456         struct root_squash_info *squash;
3457         struct cred *cred = NULL;
3458         const struct cred *old_cred = NULL;
3459         cfs_cap_t cap;
3460         bool squash_id = false;
3461         ENTRY;
3462
3463 #ifdef MAY_NOT_BLOCK
3464         if (mask & MAY_NOT_BLOCK)
3465                 return -ECHILD;
3466 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
3467         if (flags & IPERM_FLAG_RCU)
3468                 return -ECHILD;
3469 #endif
3470
3471        /* as root inode are NOT getting validated in lookup operation,
3472         * need to do it before permission check. */
3473
3474         if (inode == inode->i_sb->s_root->d_inode) {
3475                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
3476                                            MDS_INODELOCK_LOOKUP);
3477                 if (rc)
3478                         RETURN(rc);
3479         }
3480
3481         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
3482                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
3483
3484         /* squash fsuid/fsgid if needed */
3485         sbi = ll_i2sbi(inode);
3486         squash = &sbi->ll_squash;
3487         if (unlikely(squash->rsi_uid != 0 &&
3488                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
3489                      !(sbi->ll_flags & LL_SBI_NOROOTSQUASH))) {
3490                         squash_id = true;
3491         }
3492         if (squash_id) {
3493                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
3494                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
3495                        squash->rsi_uid, squash->rsi_gid);
3496
3497                 /* update current process's credentials
3498                  * and FS capability */
3499                 cred = prepare_creds();
3500                 if (cred == NULL)
3501                         RETURN(-ENOMEM);
3502
3503                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
3504                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
3505                 for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
3506                         if ((1 << cap) & CFS_CAP_FS_MASK)
3507                                 cap_lower(cred->cap_effective, cap);
3508                 }
3509                 old_cred = override_creds(cred);
3510         }
3511
3512         ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM, 1);
3513
3514         if (sbi->ll_flags & LL_SBI_RMT_CLIENT)
3515                 rc = lustre_check_remote_perm(inode, mask);
3516         else
3517                 rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3518
3519         /* restore current process's credentials and FS capability */
3520         if (squash_id) {
3521                 revert_creds(old_cred);
3522                 put_cred(cred);
3523         }
3524
3525         RETURN(rc);
3526 }
3527
3528 /* -o localflock - only provides locally consistent flock locks */
3529 struct file_operations ll_file_operations = {
3530         .read           = ll_file_read,
3531         .aio_read    = ll_file_aio_read,
3532         .write          = ll_file_write,
3533         .aio_write   = ll_file_aio_write,
3534         .unlocked_ioctl = ll_file_ioctl,
3535         .open           = ll_file_open,
3536         .release        = ll_file_release,
3537         .mmap           = ll_file_mmap,
3538         .llseek         = ll_file_seek,
3539         .splice_read    = ll_file_splice_read,
3540         .fsync          = ll_fsync,
3541         .flush          = ll_flush
3542 };
3543
3544 struct file_operations ll_file_operations_flock = {
3545         .read           = ll_file_read,
3546         .aio_read    = ll_file_aio_read,
3547         .write          = ll_file_write,
3548         .aio_write   = ll_file_aio_write,
3549         .unlocked_ioctl = ll_file_ioctl,
3550         .open           = ll_file_open,
3551         .release        = ll_file_release,
3552         .mmap           = ll_file_mmap,
3553         .llseek         = ll_file_seek,
3554         .splice_read    = ll_file_splice_read,
3555         .fsync          = ll_fsync,
3556         .flush          = ll_flush,
3557         .flock          = ll_file_flock,
3558         .lock           = ll_file_flock
3559 };
3560
3561 /* These are for -o noflock - to return ENOSYS on flock calls */
3562 struct file_operations ll_file_operations_noflock = {
3563         .read           = ll_file_read,
3564         .aio_read    = ll_file_aio_read,
3565         .write          = ll_file_write,
3566         .aio_write   = ll_file_aio_write,
3567         .unlocked_ioctl = ll_file_ioctl,
3568         .open           = ll_file_open,
3569         .release        = ll_file_release,
3570         .mmap           = ll_file_mmap,
3571         .llseek         = ll_file_seek,
3572         .splice_read    = ll_file_splice_read,
3573         .fsync          = ll_fsync,
3574         .flush          = ll_flush,
3575         .flock          = ll_file_noflock,
3576         .lock           = ll_file_noflock
3577 };
3578
3579 struct inode_operations ll_file_inode_operations = {
3580         .setattr        = ll_setattr,
3581         .getattr        = ll_getattr,
3582         .permission     = ll_inode_permission,
3583         .setxattr       = ll_setxattr,
3584         .getxattr       = ll_getxattr,
3585         .listxattr      = ll_listxattr,
3586         .removexattr    = ll_removexattr,
3587         .fiemap         = ll_fiemap,
3588 #ifdef HAVE_IOP_GET_ACL
3589         .get_acl        = ll_get_acl,
3590 #endif
3591 };
3592
3593 /* dynamic ioctl number support routins */
3594 static struct llioc_ctl_data {
3595         struct rw_semaphore     ioc_sem;
3596         struct list_head        ioc_head;
3597 } llioc = {
3598         __RWSEM_INITIALIZER(llioc.ioc_sem),
3599         LIST_HEAD_INIT(llioc.ioc_head)
3600 };
3601
3602
3603 struct llioc_data {
3604         struct list_head        iocd_list;
3605         unsigned int            iocd_size;
3606         llioc_callback_t        iocd_cb;
3607         unsigned int            iocd_count;
3608         unsigned int            iocd_cmd[0];
3609 };
3610
3611 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3612 {
3613         unsigned int size;
3614         struct llioc_data *in_data = NULL;
3615         ENTRY;
3616
3617         if (cb == NULL || cmd == NULL ||
3618             count > LLIOC_MAX_CMD || count < 0)
3619                 RETURN(NULL);
3620
3621         size = sizeof(*in_data) + count * sizeof(unsigned int);
3622         OBD_ALLOC(in_data, size);
3623         if (in_data == NULL)
3624                 RETURN(NULL);
3625
3626         memset(in_data, 0, sizeof(*in_data));
3627         in_data->iocd_size = size;
3628         in_data->iocd_cb = cb;
3629         in_data->iocd_count = count;
3630         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3631
3632         down_write(&llioc.ioc_sem);
3633         list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3634         up_write(&llioc.ioc_sem);
3635
3636         RETURN(in_data);
3637 }
3638
3639 void ll_iocontrol_unregister(void *magic)
3640 {
3641         struct llioc_data *tmp;
3642
3643         if (magic == NULL)
3644                 return;
3645
3646         down_write(&llioc.ioc_sem);
3647         list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3648                 if (tmp == magic) {
3649                         unsigned int size = tmp->iocd_size;
3650
3651                         list_del(&tmp->iocd_list);
3652                         up_write(&llioc.ioc_sem);
3653
3654                         OBD_FREE(tmp, size);
3655                         return;
3656                 }
3657         }
3658         up_write(&llioc.ioc_sem);
3659
3660         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3661 }
3662
3663 EXPORT_SYMBOL(ll_iocontrol_register);
3664 EXPORT_SYMBOL(ll_iocontrol_unregister);
3665
3666 static enum llioc_iter
3667 ll_iocontrol_call(struct inode *inode, struct file *file,
3668                   unsigned int cmd, unsigned long arg, int *rcp)
3669 {
3670         enum llioc_iter ret = LLIOC_CONT;
3671         struct llioc_data *data;
3672         int rc = -EINVAL, i;
3673
3674         down_read(&llioc.ioc_sem);
3675         list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3676                 for (i = 0; i < data->iocd_count; i++) {
3677                         if (cmd != data->iocd_cmd[i])
3678                                 continue;
3679
3680                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3681                         break;
3682                 }
3683
3684                 if (ret == LLIOC_STOP)
3685                         break;
3686         }
3687         up_read(&llioc.ioc_sem);
3688
3689         if (rcp)
3690                 *rcp = rc;
3691         return ret;
3692 }
3693
3694 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3695 {
3696         struct ll_inode_info *lli = ll_i2info(inode);
3697         struct cl_env_nest nest;
3698         struct lu_env *env;
3699         int result;
3700         ENTRY;
3701
3702         if (lli->lli_clob == NULL)
3703                 RETURN(0);
3704
3705         env = cl_env_nested_get(&nest);
3706         if (IS_ERR(env))
3707                 RETURN(PTR_ERR(env));
3708
3709         result = cl_conf_set(env, lli->lli_clob, conf);
3710         cl_env_nested_put(&nest, env);
3711
3712         if (conf->coc_opc == OBJECT_CONF_SET) {
3713                 struct ldlm_lock *lock = conf->coc_lock;
3714
3715                 LASSERT(lock != NULL);
3716                 LASSERT(ldlm_has_layout(lock));
3717                 if (result == 0) {
3718                         struct lustre_md *md = conf->u.coc_md;
3719                         __u32 gen = LL_LAYOUT_GEN_EMPTY;
3720
3721                         /* it can only be allowed to match after layout is
3722                          * applied to inode otherwise false layout would be
3723                          * seen. Applying layout shoud happen before dropping
3724                          * the intent lock. */
3725                         ldlm_lock_allow_match(lock);
3726
3727                         lli->lli_has_smd = lsm_has_objects(md->lsm);
3728                         if (md->lsm != NULL)
3729                                 gen = md->lsm->lsm_layout_gen;
3730
3731                         CDEBUG(D_VFSTRACE,
3732                                DFID ": layout version change: %u -> %u\n",
3733                                PFID(&lli->lli_fid), ll_layout_version_get(lli),
3734                                gen);
3735                         ll_layout_version_set(lli, gen);
3736                 }
3737         }
3738         RETURN(result);
3739 }
3740
3741 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3742 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3743
3744 {
3745         struct ll_sb_info *sbi = ll_i2sbi(inode);
3746         struct obd_capa *oc;
3747         struct ptlrpc_request *req;
3748         struct mdt_body *body;
3749         void *lvbdata;
3750         void *lmm;
3751         int lmmsize;
3752         int rc;
3753         ENTRY;
3754
3755         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
3756                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
3757                lock->l_lvb_data, lock->l_lvb_len);
3758
3759         if ((lock->l_lvb_data != NULL) && ldlm_is_lvb_ready(lock))
3760                 RETURN(0);
3761
3762         /* if layout lock was granted right away, the layout is returned
3763          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3764          * blocked and then granted via completion ast, we have to fetch
3765          * layout here. Please note that we can't use the LVB buffer in
3766          * completion AST because it doesn't have a large enough buffer */
3767         oc = ll_mdscapa_get(inode);
3768         rc = ll_get_default_mdsize(sbi, &lmmsize);
3769         if (rc == 0)
3770                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
3771                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3772                                 lmmsize, 0, &req);
3773         capa_put(oc);
3774         if (rc < 0)
3775                 RETURN(rc);
3776
3777         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3778         if (body == NULL)
3779                 GOTO(out, rc = -EPROTO);
3780
3781         lmmsize = body->mbo_eadatasize;
3782         if (lmmsize == 0) /* empty layout */
3783                 GOTO(out, rc = 0);
3784
3785         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3786         if (lmm == NULL)
3787                 GOTO(out, rc = -EFAULT);
3788
3789         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3790         if (lvbdata == NULL)
3791                 GOTO(out, rc = -ENOMEM);
3792
3793         memcpy(lvbdata, lmm, lmmsize);
3794         lock_res_and_lock(lock);
3795         if (lock->l_lvb_data != NULL)
3796                 OBD_FREE_LARGE(lock->l_lvb_data, lock->l_lvb_len);
3797
3798         lock->l_lvb_data = lvbdata;
3799         lock->l_lvb_len = lmmsize;
3800         unlock_res_and_lock(lock);
3801
3802         EXIT;
3803
3804 out:
3805         ptlrpc_req_finished(req);
3806         return rc;
3807 }
3808
3809 /**
3810  * Apply the layout to the inode. Layout lock is held and will be released
3811  * in this function.
3812  */
3813 static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
3814                                 struct inode *inode, __u32 *gen, bool reconf)
3815 {
3816         struct ll_inode_info *lli = ll_i2info(inode);
3817         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3818         struct ldlm_lock *lock;
3819         struct lustre_md md = { NULL };
3820         struct cl_object_conf conf;
3821         int rc = 0;
3822         bool lvb_ready;
3823         bool wait_layout = false;
3824         ENTRY;
3825
3826         LASSERT(lustre_handle_is_used(lockh));
3827
3828         lock = ldlm_handle2lock(lockh);
3829         LASSERT(lock != NULL);
3830         LASSERT(ldlm_has_layout(lock));
3831
3832         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured: %d",
3833                    PFID(&lli->lli_fid), inode, reconf);
3834
3835         /* in case this is a caching lock and reinstate with new inode */
3836         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3837
3838         lock_res_and_lock(lock);
3839         lvb_ready = ldlm_is_lvb_ready(lock);
3840         unlock_res_and_lock(lock);
3841         /* checking lvb_ready is racy but this is okay. The worst case is
3842          * that multi processes may configure the file on the same time. */
3843
3844         if (lvb_ready || !reconf) {
3845                 rc = -ENODATA;
3846                 if (lvb_ready) {
3847                         /* layout_gen must be valid if layout lock is not
3848                          * cancelled and stripe has already set */
3849                         *gen = ll_layout_version_get(lli);
3850                         rc = 0;
3851                 }
3852                 GOTO(out, rc);
3853         }
3854
3855         rc = ll_layout_fetch(inode, lock);
3856         if (rc < 0)
3857                 GOTO(out, rc);
3858
3859         /* for layout lock, lmm is returned in lock's lvb.
3860          * lvb_data is immutable if the lock is held so it's safe to access it
3861          * without res lock. See the description in ldlm_lock_decref_internal()
3862          * for the condition to free lvb_data of layout lock */
3863         if (lock->l_lvb_data != NULL) {
3864                 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
3865                                   lock->l_lvb_data, lock->l_lvb_len);
3866                 if (rc >= 0) {
3867                         *gen = LL_LAYOUT_GEN_EMPTY;
3868                         if (md.lsm != NULL)
3869                                 *gen = md.lsm->lsm_layout_gen;
3870                         rc = 0;
3871                 } else {
3872                         CERROR("%s: file "DFID" unpackmd error: %d\n",
3873                                 ll_get_fsname(inode->i_sb, NULL, 0),
3874                                 PFID(&lli->lli_fid), rc);
3875                 }
3876         }
3877         if (rc < 0)
3878                 GOTO(out, rc);
3879
3880         /* set layout to file. Unlikely this will fail as old layout was
3881          * surely eliminated */
3882         memset(&conf, 0, sizeof conf);
3883         conf.coc_opc = OBJECT_CONF_SET;
3884         conf.coc_inode = inode;
3885         conf.coc_lock = lock;
3886         conf.u.coc_md = &md;
3887         rc = ll_layout_conf(inode, &conf);
3888
3889         if (md.lsm != NULL)
3890                 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3891
3892         /* refresh layout failed, need to wait */
3893         wait_layout = rc == -EBUSY;
3894         EXIT;
3895
3896 out:
3897         LDLM_LOCK_PUT(lock);
3898         ldlm_lock_decref(lockh, mode);
3899
3900         /* wait for IO to complete if it's still being used. */
3901         if (wait_layout) {
3902                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
3903                        ll_get_fsname(inode->i_sb, NULL, 0),
3904                        PFID(&lli->lli_fid), inode);
3905
3906                 memset(&conf, 0, sizeof conf);
3907                 conf.coc_opc = OBJECT_CONF_WAIT;
3908                 conf.coc_inode = inode;
3909                 rc = ll_layout_conf(inode, &conf);
3910                 if (rc == 0)
3911                         rc = -EAGAIN;
3912
3913                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
3914                        ll_get_fsname(inode->i_sb, NULL, 0),
3915                        PFID(&lli->lli_fid), rc);
3916         }
3917         RETURN(rc);
3918 }
3919
3920 /**
3921  * This function checks if there exists a LAYOUT lock on the client side,
3922  * or enqueues it if it doesn't have one in cache.
3923  *
3924  * This function will not hold layout lock so it may be revoked any time after
3925  * this function returns. Any operations depend on layout should be redone
3926  * in that case.
3927  *
3928  * This function should be called before lov_io_init() to get an uptodate
3929  * layout version, the caller should save the version number and after IO
3930  * is finished, this function should be called again to verify that layout
3931  * is not changed during IO time.
3932  */
3933 int ll_layout_refresh(struct inode *inode, __u32 *gen)
3934 {
3935         struct ll_inode_info  *lli = ll_i2info(inode);
3936         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3937         struct md_op_data     *op_data;
3938         struct lookup_intent   it;
3939         struct lustre_handle   lockh;
3940         ldlm_mode_t            mode;
3941         struct ldlm_enqueue_info einfo = {
3942                 .ei_type = LDLM_IBITS,
3943                 .ei_mode = LCK_CR,
3944                 .ei_cb_bl = &ll_md_blocking_ast,
3945                 .ei_cb_cp = &ldlm_completion_ast,
3946         };
3947         int rc;
3948         ENTRY;
3949
3950         *gen = ll_layout_version_get(lli);
3951         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK) || *gen != LL_LAYOUT_GEN_NONE)
3952                 RETURN(0);
3953
3954         /* sanity checks */
3955         LASSERT(fid_is_sane(ll_inode2fid(inode)));
3956         LASSERT(S_ISREG(inode->i_mode));
3957
3958         /* take layout lock mutex to enqueue layout lock exclusively. */
3959         mutex_lock(&lli->lli_layout_mutex);
3960
3961 again:
3962         /* mostly layout lock is caching on the local side, so try to match
3963          * it before grabbing layout lock mutex. */
3964         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
3965                                LCK_CR | LCK_CW | LCK_PR | LCK_PW);
3966         if (mode != 0) { /* hit cached lock */
3967                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3968                 if (rc == -EAGAIN)
3969                         goto again;
3970
3971                 mutex_unlock(&lli->lli_layout_mutex);
3972                 RETURN(rc);
3973         }
3974
3975         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3976                                      0, 0, LUSTRE_OPC_ANY, NULL);
3977         if (IS_ERR(op_data)) {
3978                 mutex_unlock(&lli->lli_layout_mutex);
3979                 RETURN(PTR_ERR(op_data));
3980         }
3981
3982         /* have to enqueue one */
3983         memset(&it, 0, sizeof(it));
3984         it.it_op = IT_LAYOUT;
3985         lockh.cookie = 0ULL;
3986
3987         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
3988                           ll_get_fsname(inode->i_sb, NULL, 0),
3989                           PFID(&lli->lli_fid), inode);
3990
3991         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL, &it, op_data, &lockh, 0);
3992         if (it.d.lustre.it_data != NULL)
3993                 ptlrpc_req_finished(it.d.lustre.it_data);
3994         it.d.lustre.it_data = NULL;
3995
3996         ll_finish_md_op_data(op_data);
3997
3998         mode = it.d.lustre.it_lock_mode;
3999         it.d.lustre.it_lock_mode = 0;
4000         ll_intent_drop_lock(&it);
4001
4002         if (rc == 0) {
4003                 /* set lock data in case this is a new lock */
4004                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
4005                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
4006                 if (rc == -EAGAIN)
4007                         goto again;
4008         }
4009         mutex_unlock(&lli->lli_layout_mutex);
4010
4011         RETURN(rc);
4012 }
4013
4014 /**
4015  *  This function send a restore request to the MDT
4016  */
4017 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
4018 {
4019         struct hsm_user_request *hur;
4020         int                      len, rc;
4021         ENTRY;
4022
4023         len = sizeof(struct hsm_user_request) +
4024               sizeof(struct hsm_user_item);
4025         OBD_ALLOC(hur, len);
4026         if (hur == NULL)
4027                 RETURN(-ENOMEM);
4028
4029         hur->hur_request.hr_action = HUA_RESTORE;
4030         hur->hur_request.hr_archive_id = 0;
4031         hur->hur_request.hr_flags = 0;
4032         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
4033                sizeof(hur->hur_user_item[0].hui_fid));
4034         hur->hur_user_item[0].hui_extent.offset = offset;
4035         hur->hur_user_item[0].hui_extent.length = length;
4036         hur->hur_request.hr_itemcount = 1;
4037         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, cl_i2sbi(inode)->ll_md_exp,
4038                            len, hur, NULL);
4039         OBD_FREE(hur, len);
4040         RETURN(rc);
4041 }
4042