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 #ifdef HAVE_LOCKS_LOCK_FILE_WAIT
2922         if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
2923             !(flags & LDLM_FL_TEST_LOCK))
2924                 rc2  = locks_lock_file_wait(file, file_lock);
2925 #else
2926         if ((file_lock->fl_flags & FL_FLOCK) &&
2927             (rc == 0 || file_lock->fl_type == F_UNLCK))
2928                 rc2  = flock_lock_file_wait(file, file_lock);
2929         if ((file_lock->fl_flags & FL_POSIX) &&
2930             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2931             !(flags & LDLM_FL_TEST_LOCK))
2932                 rc2  = posix_lock_file_wait(file, file_lock);
2933 #endif /* HAVE_LOCKS_LOCK_FILE_WAIT */
2934
2935         if (rc2 && file_lock->fl_type != F_UNLCK) {
2936                 einfo.ei_mode = LCK_NL;
2937                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data,
2938                            &lockh, flags);
2939                 rc = rc2;
2940         }
2941
2942         ll_finish_md_op_data(op_data);
2943
2944         RETURN(rc);
2945 }
2946
2947 int ll_get_fid_by_name(struct inode *parent, const char *name,
2948                        int namelen, struct lu_fid *fid,
2949                        struct inode **inode)
2950 {
2951         struct md_op_data       *op_data = NULL;
2952         struct mdt_body         *body;
2953         struct ptlrpc_request   *req;
2954         int                     rc;
2955         ENTRY;
2956
2957         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
2958                                      LUSTRE_OPC_ANY, NULL);
2959         if (IS_ERR(op_data))
2960                 RETURN(PTR_ERR(op_data));
2961
2962         op_data->op_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
2963         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
2964         ll_finish_md_op_data(op_data);
2965         if (rc < 0)
2966                 RETURN(rc);
2967
2968         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2969         if (body == NULL)
2970                 GOTO(out_req, rc = -EFAULT);
2971         if (fid != NULL)
2972                 *fid = body->mbo_fid1;
2973
2974         if (inode != NULL)
2975                 rc = ll_prep_inode(inode, req, parent->i_sb, NULL);
2976 out_req:
2977         ptlrpc_req_finished(req);
2978         RETURN(rc);
2979 }
2980
2981 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
2982                const char *name, int namelen)
2983 {
2984         struct dentry         *dchild = NULL;
2985         struct inode          *child_inode = NULL;
2986         struct md_op_data     *op_data;
2987         struct ptlrpc_request *request = NULL;
2988         struct obd_client_handle *och = NULL;
2989         struct qstr           qstr;
2990         struct mdt_body         *body;
2991         int                    rc;
2992         __u64                   data_version = 0;
2993         ENTRY;
2994
2995         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
2996                name, PFID(ll_inode2fid(parent)), mdtidx);
2997
2998         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
2999                                      0, LUSTRE_OPC_ANY, NULL);
3000         if (IS_ERR(op_data))
3001                 RETURN(PTR_ERR(op_data));
3002
3003         /* Get child FID first */
3004         qstr.hash = full_name_hash(name, namelen);
3005         qstr.name = name;
3006         qstr.len = namelen;
3007         dchild = d_lookup(file->f_path.dentry, &qstr);
3008         if (dchild != NULL) {
3009                 if (dchild->d_inode != NULL)
3010                         child_inode = igrab(dchild->d_inode);
3011                 dput(dchild);
3012         }
3013
3014         if (child_inode == NULL) {
3015                 rc = ll_get_fid_by_name(parent, name, namelen,
3016                                         &op_data->op_fid3, &child_inode);
3017                 if (rc != 0)
3018                         GOTO(out_free, rc);
3019         }
3020
3021         if (child_inode == NULL)
3022                 GOTO(out_free, rc = -EINVAL);
3023
3024         mutex_lock(&child_inode->i_mutex);
3025         op_data->op_fid3 = *ll_inode2fid(child_inode);
3026         if (!fid_is_sane(&op_data->op_fid3)) {
3027                 CERROR("%s: migrate %s, but FID "DFID" is insane\n",
3028                        ll_get_fsname(parent->i_sb, NULL, 0), name,
3029                        PFID(&op_data->op_fid3));
3030                 GOTO(out_unlock, rc = -EINVAL);
3031         }
3032
3033         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
3034         if (rc < 0)
3035                 GOTO(out_unlock, rc);
3036
3037         if (rc == mdtidx) {
3038                 CDEBUG(D_INFO, "%s: "DFID" is already on MDT%04x\n", name,
3039                        PFID(&op_data->op_fid3), mdtidx);
3040                 GOTO(out_unlock, rc = 0);
3041         }
3042 again:
3043         if (S_ISREG(child_inode->i_mode)) {
3044                 och = ll_lease_open(child_inode, NULL, FMODE_WRITE, 0);
3045                 if (IS_ERR(och)) {
3046                         rc = PTR_ERR(och);
3047                         och = NULL;
3048                         GOTO(out_unlock, rc);
3049                 }
3050
3051                 rc = ll_data_version(child_inode, &data_version,
3052                                      LL_DV_WR_FLUSH);
3053                 if (rc != 0)
3054                         GOTO(out_close, rc);
3055
3056                 op_data->op_handle = och->och_fh;
3057                 op_data->op_data = och->och_mod;
3058                 op_data->op_data_version = data_version;
3059                 op_data->op_lease_handle = och->och_lease_handle;
3060                 op_data->op_bias |= MDS_RENAME_MIGRATE;
3061         }
3062
3063         op_data->op_mds = mdtidx;
3064         op_data->op_cli_flags = CLI_MIGRATE;
3065         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3066                        namelen, name, namelen, &request);
3067         if (rc == 0)
3068                 ll_update_times(request, parent);
3069
3070         if (request != NULL) {
3071                 body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
3072                 if (body == NULL) {
3073                         ptlrpc_req_finished(request);
3074                         GOTO(out_close, rc = -EPROTO);
3075                 }
3076
3077                 /* If the server does release layout lock, then we cleanup
3078                  * the client och here, otherwise release it in out_close: */
3079                 if (och != NULL &&
3080                     body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED) {
3081                         obd_mod_put(och->och_mod);
3082                         md_clear_open_replay_data(ll_i2sbi(parent)->ll_md_exp,
3083                                                   och);
3084                         och->och_fh.cookie = DEAD_HANDLE_MAGIC;
3085                         OBD_FREE_PTR(och);
3086                         och = NULL;
3087                 }
3088                 ptlrpc_req_finished(request);
3089         }
3090
3091         /* Try again if the file layout has changed. */
3092         if (rc == -EAGAIN && S_ISREG(child_inode->i_mode)) {
3093                 request = NULL;
3094                 goto again;
3095         }
3096 out_close:
3097         if (och != NULL) /* close the file */
3098                 ll_lease_close(och, child_inode, NULL);
3099         if (rc == 0)
3100                 clear_nlink(child_inode);
3101 out_unlock:
3102         mutex_unlock(&child_inode->i_mutex);
3103         iput(child_inode);
3104 out_free:
3105         ll_finish_md_op_data(op_data);
3106         RETURN(rc);
3107 }
3108
3109 static int
3110 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3111 {
3112         ENTRY;
3113
3114         RETURN(-ENOSYS);
3115 }
3116
3117 /**
3118  * test if some locks matching bits and l_req_mode are acquired
3119  * - bits can be in different locks
3120  * - if found clear the common lock bits in *bits
3121  * - the bits not found, are kept in *bits
3122  * \param inode [IN]
3123  * \param bits [IN] searched lock bits [IN]
3124  * \param l_req_mode [IN] searched lock mode
3125  * \retval boolean, true iff all bits are found
3126  */
3127 int ll_have_md_lock(struct inode *inode, __u64 *bits, enum ldlm_mode l_req_mode)
3128 {
3129         struct lustre_handle lockh;
3130         union ldlm_policy_data policy;
3131         enum ldlm_mode mode = (l_req_mode == LCK_MINMODE) ?
3132                               (LCK_CR | LCK_CW | LCK_PR | LCK_PW) : l_req_mode;
3133         struct lu_fid *fid;
3134         __u64 flags;
3135         int i;
3136         ENTRY;
3137
3138         if (!inode)
3139                RETURN(0);
3140
3141         fid = &ll_i2info(inode)->lli_fid;
3142         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3143                ldlm_lockname[mode]);
3144
3145         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3146         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3147                 policy.l_inodebits.bits = *bits & (1 << i);
3148                 if (policy.l_inodebits.bits == 0)
3149                         continue;
3150
3151                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3152                                   &policy, mode, &lockh)) {
3153                         struct ldlm_lock *lock;
3154
3155                         lock = ldlm_handle2lock(&lockh);
3156                         if (lock) {
3157                                 *bits &=
3158                                       ~(lock->l_policy_data.l_inodebits.bits);
3159                                 LDLM_LOCK_PUT(lock);
3160                         } else {
3161                                 *bits &= ~policy.l_inodebits.bits;
3162                         }
3163                 }
3164         }
3165         RETURN(*bits == 0);
3166 }
3167
3168 enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
3169                                struct lustre_handle *lockh, __u64 flags,
3170                                enum ldlm_mode mode)
3171 {
3172         union ldlm_policy_data policy = { .l_inodebits = { bits } };
3173         struct lu_fid *fid;
3174         enum ldlm_mode rc;
3175         ENTRY;
3176
3177         fid = &ll_i2info(inode)->lli_fid;
3178         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3179
3180         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3181                            fid, LDLM_IBITS, &policy, mode, lockh);
3182
3183         RETURN(rc);
3184 }
3185
3186 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3187 {
3188         /* Already unlinked. Just update nlink and return success */
3189         if (rc == -ENOENT) {
3190                 clear_nlink(inode);
3191                 /* If it is striped directory, and there is bad stripe
3192                  * Let's revalidate the dentry again, instead of returning
3193                  * error */
3194                 if (S_ISDIR(inode->i_mode) &&
3195                     ll_i2info(inode)->lli_lsm_md != NULL)
3196                         return 0;
3197
3198                 /* This path cannot be hit for regular files unless in
3199                  * case of obscure races, so no need to to validate
3200                  * size. */
3201                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3202                         return 0;
3203         } else if (rc != 0) {
3204                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
3205                              "%s: revalidate FID "DFID" error: rc = %d\n",
3206                              ll_get_fsname(inode->i_sb, NULL, 0),
3207                              PFID(ll_inode2fid(inode)), rc);
3208         }
3209
3210         return rc;
3211 }
3212
3213 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3214 {
3215         struct inode *inode = dentry->d_inode;
3216         struct ptlrpc_request *req = NULL;
3217         struct obd_export *exp;
3218         int rc = 0;
3219         ENTRY;
3220
3221         LASSERT(inode != NULL);
3222
3223         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
3224                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
3225
3226         exp = ll_i2mdexp(inode);
3227
3228         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3229          *      But under CMD case, it caused some lock issues, should be fixed
3230          *      with new CMD ibits lock. See bug 12718 */
3231         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3232                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3233                 struct md_op_data *op_data;
3234
3235                 if (ibits == MDS_INODELOCK_LOOKUP)
3236                         oit.it_op = IT_LOOKUP;
3237
3238                 /* Call getattr by fid, so do not provide name at all. */
3239                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
3240                                              dentry->d_inode, NULL, 0, 0,
3241                                              LUSTRE_OPC_ANY, NULL);
3242                 if (IS_ERR(op_data))
3243                         RETURN(PTR_ERR(op_data));
3244
3245                 rc = md_intent_lock(exp, op_data, &oit, &req,
3246                                     &ll_md_blocking_ast, 0);
3247                 ll_finish_md_op_data(op_data);
3248                 if (rc < 0) {
3249                         rc = ll_inode_revalidate_fini(inode, rc);
3250                         GOTO (out, rc);
3251                 }
3252
3253                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3254                 if (rc != 0) {
3255                         ll_intent_release(&oit);
3256                         GOTO(out, rc);
3257                 }
3258
3259                 /* Unlinked? Unhash dentry, so it is not picked up later by
3260                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3261                    here to preserve get_cwd functionality on 2.6.
3262                    Bug 10503 */
3263                 if (!dentry->d_inode->i_nlink)
3264                         d_lustre_invalidate(dentry, 0);
3265
3266                 ll_lookup_finish_locks(&oit, dentry);
3267         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3268                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3269                 u64 valid = OBD_MD_FLGETATTR;
3270                 struct md_op_data *op_data;
3271                 int ealen = 0;
3272
3273                 if (S_ISREG(inode->i_mode)) {
3274                         rc = ll_get_default_mdsize(sbi, &ealen);
3275                         if (rc)
3276                                 RETURN(rc);
3277                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3278                 }
3279
3280                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3281                                              0, ealen, LUSTRE_OPC_ANY,
3282                                              NULL);
3283                 if (IS_ERR(op_data))
3284                         RETURN(PTR_ERR(op_data));
3285
3286                 op_data->op_valid = valid;
3287                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3288                 ll_finish_md_op_data(op_data);
3289                 if (rc) {
3290                         rc = ll_inode_revalidate_fini(inode, rc);
3291                         RETURN(rc);
3292                 }
3293
3294                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3295         }
3296 out:
3297         ptlrpc_req_finished(req);
3298         return rc;
3299 }
3300
3301 static int ll_merge_md_attr(struct inode *inode)
3302 {
3303         struct cl_attr attr = { 0 };
3304         int rc;
3305
3306         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
3307         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
3308                            &attr, ll_md_blocking_ast);
3309         if (rc != 0)
3310                 RETURN(rc);
3311
3312         set_nlink(inode, attr.cat_nlink);
3313         inode->i_blocks = attr.cat_blocks;
3314         i_size_write(inode, attr.cat_size);
3315
3316         ll_i2info(inode)->lli_atime = attr.cat_atime;
3317         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
3318         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
3319
3320         RETURN(0);
3321 }
3322
3323 static int
3324 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3325 {
3326         struct inode    *inode = dentry->d_inode;
3327         int              rc;
3328         ENTRY;
3329
3330         rc = __ll_inode_revalidate(dentry, ibits);
3331         if (rc != 0)
3332                 RETURN(rc);
3333
3334         /* if object isn't regular file, don't validate size */
3335         if (!S_ISREG(inode->i_mode)) {
3336                 if (S_ISDIR(inode->i_mode) &&
3337                     ll_i2info(inode)->lli_lsm_md != NULL) {
3338                         rc = ll_merge_md_attr(inode);
3339                         if (rc != 0)
3340                                 RETURN(rc);
3341                 }
3342
3343                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_atime;
3344                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_mtime;
3345                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_ctime;
3346         } else {
3347                 /* In case of restore, the MDT has the right size and has
3348                  * already send it back without granting the layout lock,
3349                  * inode is up-to-date so glimpse is useless.
3350                  * Also to glimpse we need the layout, in case of a running
3351                  * restore the MDT holds the layout lock so the glimpse will
3352                  * block up to the end of restore (getattr will block)
3353                  */
3354                 if (!ll_file_test_flag(ll_i2info(inode), LLIF_FILE_RESTORING))
3355                         rc = ll_glimpse_size(inode);
3356         }
3357         RETURN(rc);
3358 }
3359
3360 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
3361 {
3362         struct inode *inode = de->d_inode;
3363         struct ll_sb_info *sbi = ll_i2sbi(inode);
3364         struct ll_inode_info *lli = ll_i2info(inode);
3365         int res = 0;
3366
3367         res = ll_inode_revalidate(de, MDS_INODELOCK_UPDATE |
3368                                       MDS_INODELOCK_LOOKUP);
3369         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
3370
3371         if (res)
3372                 return res;
3373
3374         stat->dev = inode->i_sb->s_dev;
3375         if (ll_need_32bit_api(sbi))
3376                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
3377         else
3378                 stat->ino = inode->i_ino;
3379         stat->mode = inode->i_mode;
3380         stat->uid = inode->i_uid;
3381         stat->gid = inode->i_gid;
3382         stat->rdev = inode->i_rdev;
3383         stat->atime = inode->i_atime;
3384         stat->mtime = inode->i_mtime;
3385         stat->ctime = inode->i_ctime;
3386         stat->blksize = 1 << inode->i_blkbits;
3387
3388         stat->nlink = inode->i_nlink;
3389         stat->size = i_size_read(inode);
3390         stat->blocks = inode->i_blocks;
3391
3392         return 0;
3393 }
3394
3395 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3396                      __u64 start, __u64 len)
3397 {
3398         int             rc;
3399         size_t          num_bytes;
3400         struct fiemap   *fiemap;
3401         unsigned int    extent_count = fieinfo->fi_extents_max;
3402
3403         num_bytes = sizeof(*fiemap) + (extent_count *
3404                                        sizeof(struct fiemap_extent));
3405         OBD_ALLOC_LARGE(fiemap, num_bytes);
3406
3407         if (fiemap == NULL)
3408                 RETURN(-ENOMEM);
3409
3410         fiemap->fm_flags = fieinfo->fi_flags;
3411         fiemap->fm_extent_count = fieinfo->fi_extents_max;
3412         fiemap->fm_start = start;
3413         fiemap->fm_length = len;
3414         if (extent_count > 0 &&
3415             copy_from_user(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
3416                            sizeof(struct fiemap_extent)) != 0)
3417                 GOTO(out, rc = -EFAULT);
3418
3419         rc = ll_do_fiemap(inode, fiemap, num_bytes);
3420
3421         fieinfo->fi_flags = fiemap->fm_flags;
3422         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
3423         if (extent_count > 0 &&
3424             copy_to_user(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
3425                          fiemap->fm_mapped_extents *
3426                          sizeof(struct fiemap_extent)) != 0)
3427                 GOTO(out, rc = -EFAULT);
3428 out:
3429         OBD_FREE_LARGE(fiemap, num_bytes);
3430         return rc;
3431 }
3432
3433 struct posix_acl *ll_get_acl(struct inode *inode, int type)
3434 {
3435         struct ll_inode_info *lli = ll_i2info(inode);
3436         struct posix_acl *acl = NULL;
3437         ENTRY;
3438
3439         spin_lock(&lli->lli_lock);
3440         /* VFS' acl_permission_check->check_acl will release the refcount */
3441         acl = posix_acl_dup(lli->lli_posix_acl);
3442         spin_unlock(&lli->lli_lock);
3443
3444         RETURN(acl);
3445 }
3446
3447 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
3448 static int
3449 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
3450 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
3451 # else
3452 ll_check_acl(struct inode *inode, int mask)
3453 # endif
3454 {
3455 # ifdef CONFIG_FS_POSIX_ACL
3456         struct posix_acl *acl;
3457         int rc;
3458         ENTRY;
3459
3460 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
3461         if (flags & IPERM_FLAG_RCU)
3462                 return -ECHILD;
3463 #  endif
3464         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
3465
3466         if (!acl)
3467                 RETURN(-EAGAIN);
3468
3469         rc = posix_acl_permission(inode, acl, mask);
3470         posix_acl_release(acl);
3471
3472         RETURN(rc);
3473 # else /* !CONFIG_FS_POSIX_ACL */
3474         return -EAGAIN;
3475 # endif /* CONFIG_FS_POSIX_ACL */
3476 }
3477 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
3478
3479 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
3480 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
3481 #else
3482 # ifdef HAVE_INODE_PERMISION_2ARGS
3483 int ll_inode_permission(struct inode *inode, int mask)
3484 # else
3485 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
3486 # endif
3487 #endif
3488 {
3489         int rc = 0;
3490         struct ll_sb_info *sbi;
3491         struct root_squash_info *squash;
3492         struct cred *cred = NULL;
3493         const struct cred *old_cred = NULL;
3494         cfs_cap_t cap;
3495         bool squash_id = false;
3496         ENTRY;
3497
3498 #ifdef MAY_NOT_BLOCK
3499         if (mask & MAY_NOT_BLOCK)
3500                 return -ECHILD;
3501 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
3502         if (flags & IPERM_FLAG_RCU)
3503                 return -ECHILD;
3504 #endif
3505
3506        /* as root inode are NOT getting validated in lookup operation,
3507         * need to do it before permission check. */
3508
3509         if (inode == inode->i_sb->s_root->d_inode) {
3510                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
3511                                            MDS_INODELOCK_LOOKUP);
3512                 if (rc)
3513                         RETURN(rc);
3514         }
3515
3516         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
3517                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
3518
3519         /* squash fsuid/fsgid if needed */
3520         sbi = ll_i2sbi(inode);
3521         squash = &sbi->ll_squash;
3522         if (unlikely(squash->rsi_uid != 0 &&
3523                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
3524                      !(sbi->ll_flags & LL_SBI_NOROOTSQUASH))) {
3525                         squash_id = true;
3526         }
3527         if (squash_id) {
3528                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
3529                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
3530                        squash->rsi_uid, squash->rsi_gid);
3531
3532                 /* update current process's credentials
3533                  * and FS capability */
3534                 cred = prepare_creds();
3535                 if (cred == NULL)
3536                         RETURN(-ENOMEM);
3537
3538                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
3539                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
3540                 for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
3541                         if ((1 << cap) & CFS_CAP_FS_MASK)
3542                                 cap_lower(cred->cap_effective, cap);
3543                 }
3544                 old_cred = override_creds(cred);
3545         }
3546
3547         ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM, 1);
3548
3549         if (sbi->ll_flags & LL_SBI_RMT_CLIENT)
3550                 rc = lustre_check_remote_perm(inode, mask);
3551         else
3552                 rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3553
3554         /* restore current process's credentials and FS capability */
3555         if (squash_id) {
3556                 revert_creds(old_cred);
3557                 put_cred(cred);
3558         }
3559
3560         RETURN(rc);
3561 }
3562
3563 /* -o localflock - only provides locally consistent flock locks */
3564 struct file_operations ll_file_operations = {
3565 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
3566 # ifdef HAVE_SYNC_READ_WRITE
3567         .read           = new_sync_read,
3568         .write          = new_sync_write,
3569 # endif
3570         .read_iter      = ll_file_read_iter,
3571         .write_iter     = ll_file_write_iter,
3572 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3573         .read           = ll_file_read,
3574         .aio_read       = ll_file_aio_read,
3575         .write          = ll_file_write,
3576         .aio_write      = ll_file_aio_write,
3577 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3578         .unlocked_ioctl = ll_file_ioctl,
3579         .open           = ll_file_open,
3580         .release        = ll_file_release,
3581         .mmap           = ll_file_mmap,
3582         .llseek         = ll_file_seek,
3583         .splice_read    = ll_file_splice_read,
3584         .fsync          = ll_fsync,
3585         .flush          = ll_flush
3586 };
3587
3588 struct file_operations ll_file_operations_flock = {
3589 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
3590 # ifdef HAVE_SYNC_READ_WRITE
3591         .read           = new_sync_read,
3592         .write          = new_sync_write,
3593 # endif /* HAVE_SYNC_READ_WRITE */
3594         .read_iter      = ll_file_read_iter,
3595         .write_iter     = ll_file_write_iter,
3596 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3597         .read           = ll_file_read,
3598         .aio_read       = ll_file_aio_read,
3599         .write          = ll_file_write,
3600         .aio_write      = ll_file_aio_write,
3601 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3602         .unlocked_ioctl = ll_file_ioctl,
3603         .open           = ll_file_open,
3604         .release        = ll_file_release,
3605         .mmap           = ll_file_mmap,
3606         .llseek         = ll_file_seek,
3607         .splice_read    = ll_file_splice_read,
3608         .fsync          = ll_fsync,
3609         .flush          = ll_flush,
3610         .flock          = ll_file_flock,
3611         .lock           = ll_file_flock
3612 };
3613
3614 /* These are for -o noflock - to return ENOSYS on flock calls */
3615 struct file_operations ll_file_operations_noflock = {
3616 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
3617 # ifdef HAVE_SYNC_READ_WRITE
3618         .read           = new_sync_read,
3619         .write          = new_sync_write,
3620 # endif /* HAVE_SYNC_READ_WRITE */
3621         .read_iter      = ll_file_read_iter,
3622         .write_iter     = ll_file_write_iter,
3623 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3624         .read           = ll_file_read,
3625         .aio_read       = ll_file_aio_read,
3626         .write          = ll_file_write,
3627         .aio_write      = ll_file_aio_write,
3628 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
3629         .unlocked_ioctl = ll_file_ioctl,
3630         .open           = ll_file_open,
3631         .release        = ll_file_release,
3632         .mmap           = ll_file_mmap,
3633         .llseek         = ll_file_seek,
3634         .splice_read    = ll_file_splice_read,
3635         .fsync          = ll_fsync,
3636         .flush          = ll_flush,
3637         .flock          = ll_file_noflock,
3638         .lock           = ll_file_noflock
3639 };
3640
3641 struct inode_operations ll_file_inode_operations = {
3642         .setattr        = ll_setattr,
3643         .getattr        = ll_getattr,
3644         .permission     = ll_inode_permission,
3645         .setxattr       = ll_setxattr,
3646         .getxattr       = ll_getxattr,
3647         .listxattr      = ll_listxattr,
3648         .removexattr    = ll_removexattr,
3649         .fiemap         = ll_fiemap,
3650 #ifdef HAVE_IOP_GET_ACL
3651         .get_acl        = ll_get_acl,
3652 #endif
3653 };
3654
3655 /* dynamic ioctl number support routins */
3656 static struct llioc_ctl_data {
3657         struct rw_semaphore     ioc_sem;
3658         struct list_head        ioc_head;
3659 } llioc = {
3660         __RWSEM_INITIALIZER(llioc.ioc_sem),
3661         LIST_HEAD_INIT(llioc.ioc_head)
3662 };
3663
3664
3665 struct llioc_data {
3666         struct list_head        iocd_list;
3667         unsigned int            iocd_size;
3668         llioc_callback_t        iocd_cb;
3669         unsigned int            iocd_count;
3670         unsigned int            iocd_cmd[0];
3671 };
3672
3673 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3674 {
3675         unsigned int size;
3676         struct llioc_data *in_data = NULL;
3677         ENTRY;
3678
3679         if (cb == NULL || cmd == NULL ||
3680             count > LLIOC_MAX_CMD || count < 0)
3681                 RETURN(NULL);
3682
3683         size = sizeof(*in_data) + count * sizeof(unsigned int);
3684         OBD_ALLOC(in_data, size);
3685         if (in_data == NULL)
3686                 RETURN(NULL);
3687
3688         memset(in_data, 0, sizeof(*in_data));
3689         in_data->iocd_size = size;
3690         in_data->iocd_cb = cb;
3691         in_data->iocd_count = count;
3692         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3693
3694         down_write(&llioc.ioc_sem);
3695         list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3696         up_write(&llioc.ioc_sem);
3697
3698         RETURN(in_data);
3699 }
3700
3701 void ll_iocontrol_unregister(void *magic)
3702 {
3703         struct llioc_data *tmp;
3704
3705         if (magic == NULL)
3706                 return;
3707
3708         down_write(&llioc.ioc_sem);
3709         list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3710                 if (tmp == magic) {
3711                         unsigned int size = tmp->iocd_size;
3712
3713                         list_del(&tmp->iocd_list);
3714                         up_write(&llioc.ioc_sem);
3715
3716                         OBD_FREE(tmp, size);
3717                         return;
3718                 }
3719         }
3720         up_write(&llioc.ioc_sem);
3721
3722         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3723 }
3724
3725 EXPORT_SYMBOL(ll_iocontrol_register);
3726 EXPORT_SYMBOL(ll_iocontrol_unregister);
3727
3728 static enum llioc_iter
3729 ll_iocontrol_call(struct inode *inode, struct file *file,
3730                   unsigned int cmd, unsigned long arg, int *rcp)
3731 {
3732         enum llioc_iter ret = LLIOC_CONT;
3733         struct llioc_data *data;
3734         int rc = -EINVAL, i;
3735
3736         down_read(&llioc.ioc_sem);
3737         list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3738                 for (i = 0; i < data->iocd_count; i++) {
3739                         if (cmd != data->iocd_cmd[i])
3740                                 continue;
3741
3742                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3743                         break;
3744                 }
3745
3746                 if (ret == LLIOC_STOP)
3747                         break;
3748         }
3749         up_read(&llioc.ioc_sem);
3750
3751         if (rcp)
3752                 *rcp = rc;
3753         return ret;
3754 }
3755
3756 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3757 {
3758         struct ll_inode_info *lli = ll_i2info(inode);
3759         struct cl_object *obj = lli->lli_clob;
3760         struct cl_env_nest nest;
3761         struct lu_env *env;
3762         int rc;
3763         ENTRY;
3764
3765         if (obj == NULL)
3766                 RETURN(0);
3767
3768         env = cl_env_nested_get(&nest);
3769         if (IS_ERR(env))
3770                 RETURN(PTR_ERR(env));
3771
3772         rc = cl_conf_set(env, lli->lli_clob, conf);
3773         if (rc < 0)
3774                 GOTO(out, rc);
3775
3776         if (conf->coc_opc == OBJECT_CONF_SET) {
3777                 struct ldlm_lock *lock = conf->coc_lock;
3778                 struct cl_layout cl = {
3779                         .cl_layout_gen = 0,
3780                 };
3781
3782                 LASSERT(lock != NULL);
3783                 LASSERT(ldlm_has_layout(lock));
3784
3785                 /* it can only be allowed to match after layout is
3786                  * applied to inode otherwise false layout would be
3787                  * seen. Applying layout shoud happen before dropping
3788                  * the intent lock. */
3789                 ldlm_lock_allow_match(lock);
3790
3791                 rc = cl_object_layout_get(env, obj, &cl);
3792                 if (rc < 0)
3793                         GOTO(out, rc);
3794
3795                 CDEBUG(D_VFSTRACE,
3796                        DFID": layout version change: %u -> %u\n",
3797                        PFID(&lli->lli_fid), ll_layout_version_get(lli),
3798                        cl.cl_layout_gen);
3799                 ll_layout_version_set(lli, cl.cl_layout_gen);
3800         }
3801
3802 out:
3803         cl_env_nested_put(&nest, env);
3804
3805         RETURN(rc);
3806 }
3807
3808 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3809 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3810
3811 {
3812         struct ll_sb_info *sbi = ll_i2sbi(inode);
3813         struct ptlrpc_request *req;
3814         struct mdt_body *body;
3815         void *lvbdata;
3816         void *lmm;
3817         int lmmsize;
3818         int rc;
3819         ENTRY;
3820
3821         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
3822                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
3823                lock->l_lvb_data, lock->l_lvb_len);
3824
3825         if (lock->l_lvb_data != NULL)
3826                 RETURN(0);
3827
3828         /* if layout lock was granted right away, the layout is returned
3829          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3830          * blocked and then granted via completion ast, we have to fetch
3831          * layout here. Please note that we can't use the LVB buffer in
3832          * completion AST because it doesn't have a large enough buffer */
3833         rc = ll_get_default_mdsize(sbi, &lmmsize);
3834         if (rc == 0)
3835                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode),
3836                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3837                                 lmmsize, 0, &req);
3838         if (rc < 0)
3839                 RETURN(rc);
3840
3841         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3842         if (body == NULL)
3843                 GOTO(out, rc = -EPROTO);
3844
3845         lmmsize = body->mbo_eadatasize;
3846         if (lmmsize == 0) /* empty layout */
3847                 GOTO(out, rc = 0);
3848
3849         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3850         if (lmm == NULL)
3851                 GOTO(out, rc = -EFAULT);
3852
3853         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3854         if (lvbdata == NULL)
3855                 GOTO(out, rc = -ENOMEM);
3856
3857         memcpy(lvbdata, lmm, lmmsize);
3858         lock_res_and_lock(lock);
3859         if (unlikely(lock->l_lvb_data == NULL)) {
3860                 lock->l_lvb_type = LVB_T_LAYOUT;
3861                 lock->l_lvb_data = lvbdata;
3862                 lock->l_lvb_len = lmmsize;
3863                 lvbdata = NULL;
3864         }
3865         unlock_res_and_lock(lock);
3866
3867         if (lvbdata)
3868                 OBD_FREE_LARGE(lvbdata, lmmsize);
3869
3870         EXIT;
3871
3872 out:
3873         ptlrpc_req_finished(req);
3874         return rc;
3875 }
3876
3877 /**
3878  * Apply the layout to the inode. Layout lock is held and will be released
3879  * in this function.
3880  */
3881 static int ll_layout_lock_set(struct lustre_handle *lockh, enum ldlm_mode mode,
3882                               struct inode *inode)
3883 {
3884         struct ll_inode_info *lli = ll_i2info(inode);
3885         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3886         struct ldlm_lock *lock;
3887         struct cl_object_conf conf;
3888         int rc = 0;
3889         bool lvb_ready;
3890         bool wait_layout = false;
3891         ENTRY;
3892
3893         LASSERT(lustre_handle_is_used(lockh));
3894
3895         lock = ldlm_handle2lock(lockh);
3896         LASSERT(lock != NULL);
3897         LASSERT(ldlm_has_layout(lock));
3898
3899         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured",
3900                    PFID(&lli->lli_fid), inode);
3901
3902         /* in case this is a caching lock and reinstate with new inode */
3903         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3904
3905         lock_res_and_lock(lock);
3906         lvb_ready = ldlm_is_lvb_ready(lock);
3907         unlock_res_and_lock(lock);
3908         /* checking lvb_ready is racy but this is okay. The worst case is
3909          * that multi processes may configure the file on the same time. */
3910
3911         if (lvb_ready)
3912                 GOTO(out, rc = 0);
3913
3914         rc = ll_layout_fetch(inode, lock);
3915         if (rc < 0)
3916                 GOTO(out, rc);
3917
3918         /* for layout lock, lmm is stored in lock's lvb.
3919          * lvb_data is immutable if the lock is held so it's safe to access it
3920          * without res lock.
3921          *
3922          * set layout to file. Unlikely this will fail as old layout was
3923          * surely eliminated */
3924         memset(&conf, 0, sizeof conf);
3925         conf.coc_opc = OBJECT_CONF_SET;
3926         conf.coc_inode = inode;
3927         conf.coc_lock = lock;
3928         conf.u.coc_layout.lb_buf = lock->l_lvb_data;
3929         conf.u.coc_layout.lb_len = lock->l_lvb_len;
3930         rc = ll_layout_conf(inode, &conf);
3931
3932         /* refresh layout failed, need to wait */
3933         wait_layout = rc == -EBUSY;
3934         EXIT;
3935
3936 out:
3937         LDLM_LOCK_PUT(lock);
3938         ldlm_lock_decref(lockh, mode);
3939
3940         /* wait for IO to complete if it's still being used. */
3941         if (wait_layout) {
3942                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
3943                        ll_get_fsname(inode->i_sb, NULL, 0),
3944                        PFID(&lli->lli_fid), inode);
3945
3946                 memset(&conf, 0, sizeof conf);
3947                 conf.coc_opc = OBJECT_CONF_WAIT;
3948                 conf.coc_inode = inode;
3949                 rc = ll_layout_conf(inode, &conf);
3950                 if (rc == 0)
3951                         rc = -EAGAIN;
3952
3953                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
3954                        ll_get_fsname(inode->i_sb, NULL, 0),
3955                        PFID(&lli->lli_fid), rc);
3956         }
3957         RETURN(rc);
3958 }
3959
3960 static int ll_layout_refresh_locked(struct inode *inode)
3961 {
3962         struct ll_inode_info  *lli = ll_i2info(inode);
3963         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3964         struct md_op_data     *op_data;
3965         struct lookup_intent    it;
3966         struct lustre_handle    lockh;
3967         enum ldlm_mode          mode;
3968         struct ldlm_enqueue_info einfo = {
3969                 .ei_type = LDLM_IBITS,
3970                 .ei_mode = LCK_CR,
3971                 .ei_cb_bl = &ll_md_blocking_ast,
3972                 .ei_cb_cp = &ldlm_completion_ast,
3973         };
3974         int rc;
3975         ENTRY;
3976
3977 again:
3978         /* mostly layout lock is caching on the local side, so try to match
3979          * it before grabbing layout lock mutex. */
3980         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
3981                                LCK_CR | LCK_CW | LCK_PR | LCK_PW);
3982         if (mode != 0) { /* hit cached lock */
3983                 rc = ll_layout_lock_set(&lockh, mode, inode);
3984                 if (rc == -EAGAIN)
3985                         goto again;
3986
3987                 RETURN(rc);
3988         }
3989
3990         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3991                                      0, 0, LUSTRE_OPC_ANY, NULL);
3992         if (IS_ERR(op_data))
3993                 RETURN(PTR_ERR(op_data));
3994
3995         /* have to enqueue one */
3996         memset(&it, 0, sizeof(it));
3997         it.it_op = IT_LAYOUT;
3998         lockh.cookie = 0ULL;
3999
4000         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
4001                           ll_get_fsname(inode->i_sb, NULL, 0),
4002                           PFID(&lli->lli_fid), inode);
4003
4004         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL, &it, op_data, &lockh, 0);
4005         if (it.d.lustre.it_data != NULL)
4006                 ptlrpc_req_finished(it.d.lustre.it_data);
4007         it.d.lustre.it_data = NULL;
4008
4009         ll_finish_md_op_data(op_data);
4010
4011         mode = it.d.lustre.it_lock_mode;
4012         it.d.lustre.it_lock_mode = 0;
4013         ll_intent_drop_lock(&it);
4014
4015         if (rc == 0) {
4016                 /* set lock data in case this is a new lock */
4017                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
4018                 rc = ll_layout_lock_set(&lockh, mode, inode);
4019                 if (rc == -EAGAIN)
4020                         goto again;
4021         }
4022
4023         RETURN(rc);
4024 }
4025
4026 /**
4027  * This function checks if there exists a LAYOUT lock on the client side,
4028  * or enqueues it if it doesn't have one in cache.
4029  *
4030  * This function will not hold layout lock so it may be revoked any time after
4031  * this function returns. Any operations depend on layout should be redone
4032  * in that case.
4033  *
4034  * This function should be called before lov_io_init() to get an uptodate
4035  * layout version, the caller should save the version number and after IO
4036  * is finished, this function should be called again to verify that layout
4037  * is not changed during IO time.
4038  */
4039 int ll_layout_refresh(struct inode *inode, __u32 *gen)
4040 {
4041         struct ll_inode_info    *lli = ll_i2info(inode);
4042         struct ll_sb_info       *sbi = ll_i2sbi(inode);
4043         int rc;
4044         ENTRY;
4045
4046         *gen = ll_layout_version_get(lli);
4047         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK) || *gen != CL_LAYOUT_GEN_NONE)
4048                 RETURN(0);
4049
4050         /* sanity checks */
4051         LASSERT(fid_is_sane(ll_inode2fid(inode)));
4052         LASSERT(S_ISREG(inode->i_mode));
4053
4054         /* take layout lock mutex to enqueue layout lock exclusively. */
4055         mutex_lock(&lli->lli_layout_mutex);
4056
4057         rc = ll_layout_refresh_locked(inode);
4058         if (rc < 0)
4059                 GOTO(out, rc);
4060
4061         *gen = ll_layout_version_get(lli);
4062 out:
4063         mutex_unlock(&lli->lli_layout_mutex);
4064
4065         RETURN(rc);
4066 }
4067
4068 /**
4069  *  This function send a restore request to the MDT
4070  */
4071 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
4072 {
4073         struct hsm_user_request *hur;
4074         int                      len, rc;
4075         ENTRY;
4076
4077         len = sizeof(struct hsm_user_request) +
4078               sizeof(struct hsm_user_item);
4079         OBD_ALLOC(hur, len);
4080         if (hur == NULL)
4081                 RETURN(-ENOMEM);
4082
4083         hur->hur_request.hr_action = HUA_RESTORE;
4084         hur->hur_request.hr_archive_id = 0;
4085         hur->hur_request.hr_flags = 0;
4086         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
4087                sizeof(hur->hur_user_item[0].hui_fid));
4088         hur->hur_user_item[0].hui_extent.offset = offset;
4089         hur->hur_user_item[0].hui_extent.length = length;
4090         hur->hur_request.hr_itemcount = 1;
4091         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, ll_i2sbi(inode)->ll_md_exp,
4092                            len, hur, NULL);
4093         OBD_FREE(hur, len);
4094         RETURN(rc);
4095 }