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