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.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2016, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/llite/file.c
  33  *
  34  * Author: Peter Braam <braam@clusterfs.com>
  35  * Author: Phil Schwan <phil@clusterfs.com>
  36  * Author: Andreas Dilger <adilger@clusterfs.com>
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_LLITE
  40 #include <lustre_dlm.h>
  41 #include <linux/pagemap.h>
  42 #include <linux/file.h>
  43 #include <linux/sched.h>
  44 #include <linux/user_namespace.h>
  45 #ifdef HAVE_UIDGID_HEADER
  46 # include <linux/uidgid.h>
  47 #endif
  48
  49 #include <uapi/linux/lustre/lustre_ioctl.h>
  50 #include <lustre_swab.h>
  51
  52 #include "cl_object.h"
  53 #include "llite_internal.h"
  54 #include "vvp_internal.h"
  55
  56 static int
  57 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
  58
  59 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
  60                           bool *lease_broken);
  61
  62 static struct ll_file_data *ll_file_data_get(void)
  63 {
  64         struct ll_file_data *fd;
  65
  66         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
  67         if (fd == NULL)
  68                 return NULL;
  69
  70         fd->fd_write_failed = false;
  71
  72         return fd;
  73 }
  74
  75 static void ll_file_data_put(struct ll_file_data *fd)
  76 {
  77         if (fd != NULL)
  78                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
  79 }
  80
  81 /**
  82  * Packs all the attributes into @op_data for the CLOSE rpc.
  83  */
  84 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
  85                              struct obd_client_handle *och)
  86 {
  87         ENTRY;
  88
  89         ll_prep_md_op_data(op_data, inode, NULL, NULL,
  90                            0, 0, LUSTRE_OPC_ANY, NULL);
  91
  92         op_data->op_attr.ia_mode = inode->i_mode;
  93         op_data->op_attr.ia_atime = inode->i_atime;
  94         op_data->op_attr.ia_mtime = inode->i_mtime;
  95         op_data->op_attr.ia_ctime = inode->i_ctime;
  96         op_data->op_attr.ia_size = i_size_read(inode);
  97         op_data->op_attr.ia_valid |= ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
  98                                      ATTR_MTIME | ATTR_MTIME_SET |
  99                                      ATTR_CTIME | ATTR_CTIME_SET;
 100         op_data->op_attr_blocks = inode->i_blocks;
 101         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
 102         op_data->op_handle = och->och_fh;
 103
 104         if (och->och_flags & FMODE_WRITE &&
 105             ll_file_test_and_clear_flag(ll_i2info(inode), LLIF_DATA_MODIFIED))
 106                 /* For HSM: if inode data has been modified, pack it so that
 107                  * MDT can set data dirty flag in the archive. */
 108                 op_data->op_bias |= MDS_DATA_MODIFIED;
 109
 110         EXIT;
 111 }
 112
 113 /**
 114  * Perform a close, possibly with a bias.
 115  * The meaning of "data" depends on the value of "bias".
 116  *
 117  * If \a bias is MDS_HSM_RELEASE then \a data is a pointer to the data version.
 118  * If \a bias is MDS_CLOSE_LAYOUT_SWAP then \a data is a pointer to the inode to
 119  * swap layouts with.
 120  */
 121 static int ll_close_inode_openhandle(struct inode *inode,
 122                                      struct obd_client_handle *och,
 123                                      enum mds_op_bias bias, void *data)
 124 {
 125         struct obd_export *md_exp = ll_i2mdexp(inode);
 126         const struct ll_inode_info *lli = ll_i2info(inode);
 127         struct md_op_data *op_data;
 128         struct ptlrpc_request *req = NULL;
 129         int rc;
 130         ENTRY;
 131
 132         if (class_exp2obd(md_exp) == NULL) {
 133                 CERROR("%s: invalid MDC connection handle closing "DFID"\n",
 134                        ll_get_fsname(inode->i_sb, NULL, 0),
 135                        PFID(&lli->lli_fid));
 136                 GOTO(out, rc = 0);
 137         }
 138
 139         OBD_ALLOC_PTR(op_data);
 140         /* We leak openhandle and request here on error, but not much to be
 141          * done in OOM case since app won't retry close on error either. */
 142         if (op_data == NULL)
 143                 GOTO(out, rc = -ENOMEM);
 144
 145         ll_prepare_close(inode, op_data, och);
 146         switch (bias) {
 147         case MDS_CLOSE_LAYOUT_MERGE:
 148                 /* merge blocks from the victim inode */
 149                 op_data->op_attr_blocks += ((struct inode *)data)->i_blocks;
 150                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 151         case MDS_CLOSE_LAYOUT_SWAP:
 152                 LASSERT(data != NULL);
 153                 op_data->op_bias |= bias;
 154                 op_data->op_data_version = 0;
 155                 op_data->op_lease_handle = och->och_lease_handle;
 156                 op_data->op_fid2 = *ll_inode2fid(data);
 157                 break;
 158
 159         case MDS_CLOSE_RESYNC_DONE: {
 160                 struct ll_ioc_lease *ioc = data;
 161
 162                 LASSERT(data != NULL);
 163                 op_data->op_attr_blocks +=
 164                         ioc->lil_count * op_data->op_attr_blocks;
 165                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 166                 op_data->op_bias |= MDS_CLOSE_RESYNC_DONE;
 167
 168                 op_data->op_lease_handle = och->och_lease_handle;
 169                 op_data->op_data = &ioc->lil_ids[0];
 170                 op_data->op_data_size =
 171                         ioc->lil_count * sizeof(ioc->lil_ids[0]);
 172                 break;
 173         }
 174
 175         case MDS_HSM_RELEASE:
 176                 LASSERT(data != NULL);
 177                 op_data->op_bias |= MDS_HSM_RELEASE;
 178                 op_data->op_data_version = *(__u64 *)data;
 179                 op_data->op_lease_handle = och->och_lease_handle;
 180                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
 181                 break;
 182
 183         default:
 184                 LASSERT(data == NULL);
 185                 break;
 186         }
 187
 188         rc = md_close(md_exp, op_data, och->och_mod, &req);
 189         if (rc != 0 && rc != -EINTR)
 190                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
 191                        md_exp->exp_obd->obd_name, PFID(&lli->lli_fid), rc);
 192
 193         if (rc == 0 && op_data->op_bias & bias) {
 194                 struct mdt_body *body;
 195
 196                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 197                 if (!(body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED))
 198                         rc = -EBUSY;
 199         }
 200
 201         ll_finish_md_op_data(op_data);
 202         EXIT;
 203 out:
 204
 205         md_clear_open_replay_data(md_exp, och);
 206         och->och_fh.cookie = DEAD_HANDLE_MAGIC;
 207         OBD_FREE_PTR(och);
 208
 209         ptlrpc_req_finished(req);       /* This is close request */
 210         return rc;
 211 }
 212
 213 int ll_md_real_close(struct inode *inode, fmode_t fmode)
 214 {
 215         struct ll_inode_info *lli = ll_i2info(inode);
 216         struct obd_client_handle **och_p;
 217         struct obd_client_handle *och;
 218         __u64 *och_usecount;
 219         int rc = 0;
 220         ENTRY;
 221
 222         if (fmode & FMODE_WRITE) {
 223                 och_p = &lli->lli_mds_write_och;
 224                 och_usecount = &lli->lli_open_fd_write_count;
 225         } else if (fmode & FMODE_EXEC) {
 226                 och_p = &lli->lli_mds_exec_och;
 227                 och_usecount = &lli->lli_open_fd_exec_count;
 228         } else {
 229                 LASSERT(fmode & FMODE_READ);
 230                 och_p = &lli->lli_mds_read_och;
 231                 och_usecount = &lli->lli_open_fd_read_count;
 232         }
 233
 234         mutex_lock(&lli->lli_och_mutex);
 235         if (*och_usecount > 0) {
 236                 /* There are still users of this handle, so skip
 237                  * freeing it. */
 238                 mutex_unlock(&lli->lli_och_mutex);
 239                 RETURN(0);
 240         }
 241
 242         och = *och_p;
 243         *och_p = NULL;
 244         mutex_unlock(&lli->lli_och_mutex);
 245
 246         if (och != NULL) {
 247                 /* There might be a race and this handle may already
 248                  * be closed. */
 249                 rc = ll_close_inode_openhandle(inode, och, 0, NULL);
 250         }
 251
 252         RETURN(rc);
 253 }
 254
 255 static int ll_md_close(struct inode *inode, struct file *file)
 256 {
 257         union ldlm_policy_data policy = {
 258                 .l_inodebits    = { MDS_INODELOCK_OPEN },
 259         };
 260         __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
 261         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 262         struct ll_inode_info *lli = ll_i2info(inode);
 263         struct lustre_handle lockh;
 264         enum ldlm_mode lockmode;
 265         int rc = 0;
 266         ENTRY;
 267
 268         /* clear group lock, if present */
 269         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
 270                 ll_put_grouplock(inode, file, fd->fd_grouplock.lg_gid);
 271
 272         if (fd->fd_lease_och != NULL) {
 273                 bool lease_broken;
 274
 275                 /* Usually the lease is not released when the
 276                  * application crashed, we need to release here. */
 277                 rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken);
 278                 CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n",
 279                         PFID(&lli->lli_fid), rc, lease_broken);
 280
 281                 fd->fd_lease_och = NULL;
 282         }
 283
 284         if (fd->fd_och != NULL) {
 285                 rc = ll_close_inode_openhandle(inode, fd->fd_och, 0, NULL);
 286                 fd->fd_och = NULL;
 287                 GOTO(out, rc);
 288         }
 289
 290         /* Let's see if we have good enough OPEN lock on the file and if
 291            we can skip talking to MDS */
 292         mutex_lock(&lli->lli_och_mutex);
 293         if (fd->fd_omode & FMODE_WRITE) {
 294                 lockmode = LCK_CW;
 295                 LASSERT(lli->lli_open_fd_write_count);
 296                 lli->lli_open_fd_write_count--;
 297         } else if (fd->fd_omode & FMODE_EXEC) {
 298                 lockmode = LCK_PR;
 299                 LASSERT(lli->lli_open_fd_exec_count);
 300                 lli->lli_open_fd_exec_count--;
 301         } else {
 302                 lockmode = LCK_CR;
 303                 LASSERT(lli->lli_open_fd_read_count);
 304                 lli->lli_open_fd_read_count--;
 305         }
 306         mutex_unlock(&lli->lli_och_mutex);
 307
 308         if (!md_lock_match(ll_i2mdexp(inode), flags, ll_inode2fid(inode),
 309                            LDLM_IBITS, &policy, lockmode, &lockh))
 310                 rc = ll_md_real_close(inode, fd->fd_omode);
 311
 312 out:
 313         LUSTRE_FPRIVATE(file) = NULL;
 314         ll_file_data_put(fd);
 315
 316         RETURN(rc);
 317 }
 318
 319 /* While this returns an error code, fput() the caller does not, so we need
 320  * to make every effort to clean up all of our state here.  Also, applications
 321  * rarely check close errors and even if an error is returned they will not
 322  * re-try the close call.
 323  */
 324 int ll_file_release(struct inode *inode, struct file *file)
 325 {
 326         struct ll_file_data *fd;
 327         struct ll_sb_info *sbi = ll_i2sbi(inode);
 328         struct ll_inode_info *lli = ll_i2info(inode);
 329         int rc;
 330         ENTRY;
 331
 332         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
 333                PFID(ll_inode2fid(inode)), inode);
 334
 335         if (inode->i_sb->s_root != file_dentry(file))
 336                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
 337         fd = LUSTRE_FPRIVATE(file);
 338         LASSERT(fd != NULL);
 339
 340         /* The last ref on @file, maybe not the the owner pid of statahead,
 341          * because parent and child process can share the same file handle. */
 342         if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd)
 343                 ll_deauthorize_statahead(inode, fd);
 344
 345         if (inode->i_sb->s_root == file_dentry(file)) {
 346                 LUSTRE_FPRIVATE(file) = NULL;
 347                 ll_file_data_put(fd);
 348                 RETURN(0);
 349         }
 350
 351         if (!S_ISDIR(inode->i_mode)) {
 352                 if (lli->lli_clob != NULL)
 353                         lov_read_and_clear_async_rc(lli->lli_clob);
 354                 lli->lli_async_rc = 0;
 355         }
 356
 357         rc = ll_md_close(inode, file);
 358
 359         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
 360                 libcfs_debug_dumplog();
 361
 362         RETURN(rc);
 363 }
 364
 365 static int ll_intent_file_open(struct dentry *de, void *lmm, int lmmsize,
 366                                 struct lookup_intent *itp)
 367 {
 368         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
 369         struct dentry *parent = de->d_parent;
 370         const char *name = NULL;
 371         int len = 0;
 372         struct md_op_data *op_data;
 373         struct ptlrpc_request *req = NULL;
 374         int rc;
 375         ENTRY;
 376
 377         LASSERT(parent != NULL);
 378         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
 379
 380         /* if server supports open-by-fid, or file name is invalid, don't pack
 381          * name in open request */
 382         if (!(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID) &&
 383             lu_name_is_valid_2(de->d_name.name, de->d_name.len)) {
 384                 name = de->d_name.name;
 385                 len = de->d_name.len;
 386         }
 387
 388         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
 389                                      name, len, 0, LUSTRE_OPC_ANY, NULL);
 390         if (IS_ERR(op_data))
 391                 RETURN(PTR_ERR(op_data));
 392         op_data->op_data = lmm;
 393         op_data->op_data_size = lmmsize;
 394
 395         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
 396                             &ll_md_blocking_ast, 0);
 397         ll_finish_md_op_data(op_data);
 398         if (rc == -ESTALE) {
 399                 /* reason for keep own exit path - don`t flood log
 400                  * with messages with -ESTALE errors.
 401                  */
 402                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
 403                      it_open_error(DISP_OPEN_OPEN, itp))
 404                         GOTO(out, rc);
 405                 ll_release_openhandle(de, itp);
 406                 GOTO(out, rc);
 407         }
 408
 409         if (it_disposition(itp, DISP_LOOKUP_NEG))
 410                 GOTO(out, rc = -ENOENT);
 411
 412         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
 413                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
 414                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
 415                 GOTO(out, rc);
 416         }
 417
 418         rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
 419         if (!rc && itp->it_lock_mode)
 420                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, NULL);
 421
 422 out:
 423         ptlrpc_req_finished(req);
 424         ll_intent_drop_lock(itp);
 425
 426         /* We did open by fid, but by the time we got to the server,
 427          * the object disappeared. If this is a create, we cannot really
 428          * tell the userspace that the file it was trying to create
 429          * does not exist. Instead let's return -ESTALE, and the VFS will
 430          * retry the create with LOOKUP_REVAL that we are going to catch
 431          * in ll_revalidate_dentry() and use lookup then.
 432          */
 433         if (rc == -ENOENT && itp->it_op & IT_CREAT)
 434                 rc = -ESTALE;
 435
 436         RETURN(rc);
 437 }
 438
 439 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 440                        struct obd_client_handle *och)
 441 {
 442         struct mdt_body *body;
 443
 444         body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
 445         och->och_fh = body->mbo_handle;
 446         och->och_fid = body->mbo_fid1;
 447         och->och_lease_handle.cookie = it->it_lock_handle;
 448         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
 449         och->och_flags = it->it_flags;
 450
 451         return md_set_open_replay_data(md_exp, och, it);
 452 }
 453
 454 static int ll_local_open(struct file *file, struct lookup_intent *it,
 455                          struct ll_file_data *fd, struct obd_client_handle *och)
 456 {
 457         struct inode *inode = file_inode(file);
 458         ENTRY;
 459
 460         LASSERT(!LUSTRE_FPRIVATE(file));
 461
 462         LASSERT(fd != NULL);
 463
 464         if (och) {
 465                 int rc;
 466
 467                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
 468                 if (rc != 0)
 469                         RETURN(rc);
 470         }
 471
 472         LUSTRE_FPRIVATE(file) = fd;
 473         ll_readahead_init(inode, &fd->fd_ras);
 474         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
 475
 476         /* ll_cl_context initialize */
 477         rwlock_init(&fd->fd_lock);
 478         INIT_LIST_HEAD(&fd->fd_lccs);
 479
 480         RETURN(0);
 481 }
 482
 483 /* Open a file, and (for the very first open) create objects on the OSTs at
 484  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
 485  * creation or open until ll_lov_setstripe() ioctl is called.
 486  *
 487  * If we already have the stripe MD locally then we don't request it in
 488  * md_open(), by passing a lmm_size = 0.
 489  *
 490  * It is up to the application to ensure no other processes open this file
 491  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
 492  * used.  We might be able to avoid races of that sort by getting lli_open_sem
 493  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
 494  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
 495  */
 496 int ll_file_open(struct inode *inode, struct file *file)
 497 {
 498         struct ll_inode_info *lli = ll_i2info(inode);
 499         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
 500                                           .it_flags = file->f_flags };
 501         struct obd_client_handle **och_p = NULL;
 502         __u64 *och_usecount = NULL;
 503         struct ll_file_data *fd;
 504         int rc = 0;
 505         ENTRY;
 506
 507         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
 508                PFID(ll_inode2fid(inode)), inode, file->f_flags);
 509
 510         it = file->private_data; /* XXX: compat macro */
 511         file->private_data = NULL; /* prevent ll_local_open assertion */
 512
 513         fd = ll_file_data_get();
 514         if (fd == NULL)
 515                 GOTO(out_openerr, rc = -ENOMEM);
 516
 517         fd->fd_file = file;
 518         if (S_ISDIR(inode->i_mode))
 519                 ll_authorize_statahead(inode, fd);
 520
 521         if (inode->i_sb->s_root == file_dentry(file)) {
 522                 LUSTRE_FPRIVATE(file) = fd;
 523                 RETURN(0);
 524         }
 525
 526         if (!it || !it->it_disposition) {
 527                 /* Convert f_flags into access mode. We cannot use file->f_mode,
 528                  * because everything but O_ACCMODE mask was stripped from
 529                  * there */
 530                 if ((oit.it_flags + 1) & O_ACCMODE)
 531                         oit.it_flags++;
 532                 if (file->f_flags & O_TRUNC)
 533                         oit.it_flags |= FMODE_WRITE;
 534
 535                 /* kernel only call f_op->open in dentry_open.  filp_open calls
 536                  * dentry_open after call to open_namei that checks permissions.
 537                  * Only nfsd_open call dentry_open directly without checking
 538                  * permissions and because of that this code below is safe. */
 539                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
 540                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
 541
 542                 /* We do not want O_EXCL here, presumably we opened the file
 543                  * already? XXX - NFS implications? */
 544                 oit.it_flags &= ~O_EXCL;
 545
 546                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
 547                  * created if necessary, then "IT_CREAT" should be set to keep
 548                  * consistent with it */
 549                 if (oit.it_flags & O_CREAT)
 550                         oit.it_op |= IT_CREAT;
 551
 552                 it = &oit;
 553         }
 554
 555 restart:
 556         /* Let's see if we have file open on MDS already. */
 557         if (it->it_flags & FMODE_WRITE) {
 558                 och_p = &lli->lli_mds_write_och;
 559                 och_usecount = &lli->lli_open_fd_write_count;
 560         } else if (it->it_flags & FMODE_EXEC) {
 561                 och_p = &lli->lli_mds_exec_och;
 562                 och_usecount = &lli->lli_open_fd_exec_count;
 563          } else {
 564                 och_p = &lli->lli_mds_read_och;
 565                 och_usecount = &lli->lli_open_fd_read_count;
 566         }
 567
 568         mutex_lock(&lli->lli_och_mutex);
 569         if (*och_p) { /* Open handle is present */
 570                 if (it_disposition(it, DISP_OPEN_OPEN)) {
 571                         /* Well, there's extra open request that we do not need,
 572                            let's close it somehow. This will decref request. */
 573                         rc = it_open_error(DISP_OPEN_OPEN, it);
 574                         if (rc) {
 575                                 mutex_unlock(&lli->lli_och_mutex);
 576                                 GOTO(out_openerr, rc);
 577                         }
 578
 579                         ll_release_openhandle(file_dentry(file), it);
 580                 }
 581                 (*och_usecount)++;
 582
 583                 rc = ll_local_open(file, it, fd, NULL);
 584                 if (rc) {
 585                         (*och_usecount)--;
 586                         mutex_unlock(&lli->lli_och_mutex);
 587                         GOTO(out_openerr, rc);
 588                 }
 589         } else {
 590                 LASSERT(*och_usecount == 0);
 591                 if (!it->it_disposition) {
 592                         struct ll_dentry_data *ldd = ll_d2d(file->f_path.dentry);
 593                         /* We cannot just request lock handle now, new ELC code
 594                            means that one of other OPEN locks for this file
 595                            could be cancelled, and since blocking ast handler
 596                            would attempt to grab och_mutex as well, that would
 597                            result in a deadlock */
 598                         mutex_unlock(&lli->lli_och_mutex);
 599                         /*
 600                          * Normally called under two situations:
 601                          * 1. NFS export.
 602                          * 2. A race/condition on MDS resulting in no open
 603                          *    handle to be returned from LOOKUP|OPEN request,
 604                          *    for example if the target entry was a symlink.
 605                          *
 606                          *  Only fetch MDS_OPEN_LOCK if this is in NFS path,
 607                          *  marked by a bit set in ll_iget_for_nfs. Clear the
 608                          *  bit so that it's not confusing later callers.
 609                          *
 610                          *  NB; when ldd is NULL, it must have come via normal
 611                          *  lookup path only, since ll_iget_for_nfs always calls
 612                          *  ll_d_init().
 613                          */
 614                         if (ldd && ldd->lld_nfs_dentry) {
 615                                 ldd->lld_nfs_dentry = 0;
 616                                 it->it_flags |= MDS_OPEN_LOCK;
 617                         }
 618
 619                          /*
 620                          * Always specify MDS_OPEN_BY_FID because we don't want
 621                          * to get file with different fid.
 622                          */
 623                         it->it_flags |= MDS_OPEN_BY_FID;
 624                         rc = ll_intent_file_open(file_dentry(file), NULL, 0,
 625                                                  it);
 626                         if (rc)
 627                                 GOTO(out_openerr, rc);
 628
 629                         goto restart;
 630                 }
 631                 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
 632                 if (!*och_p)
 633                         GOTO(out_och_free, rc = -ENOMEM);
 634
 635                 (*och_usecount)++;
 636
 637                 /* md_intent_lock() didn't get a request ref if there was an
 638                  * open error, so don't do cleanup on the request here
 639                  * (bug 3430) */
 640                 /* XXX (green): Should not we bail out on any error here, not
 641                  * just open error? */
 642                 rc = it_open_error(DISP_OPEN_OPEN, it);
 643                 if (rc != 0)
 644                         GOTO(out_och_free, rc);
 645
 646                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
 647                          "inode %p: disposition %x, status %d\n", inode,
 648                          it_disposition(it, ~0), it->it_status);
 649
 650                 rc = ll_local_open(file, it, fd, *och_p);
 651                 if (rc)
 652                         GOTO(out_och_free, rc);
 653         }
 654         mutex_unlock(&lli->lli_och_mutex);
 655         fd = NULL;
 656
 657         /* Must do this outside lli_och_mutex lock to prevent deadlock where
 658            different kind of OPEN lock for this same inode gets cancelled
 659            by ldlm_cancel_lru */
 660         if (!S_ISREG(inode->i_mode))
 661                 GOTO(out_och_free, rc);
 662
 663         cl_lov_delay_create_clear(&file->f_flags);
 664         GOTO(out_och_free, rc);
 665
 666 out_och_free:
 667         if (rc) {
 668                 if (och_p && *och_p) {
 669                         OBD_FREE(*och_p, sizeof (struct obd_client_handle));
 670                         *och_p = NULL; /* OBD_FREE writes some magic there */
 671                         (*och_usecount)--;
 672                 }
 673                 mutex_unlock(&lli->lli_och_mutex);
 674
 675 out_openerr:
 676                 if (lli->lli_opendir_key == fd)
 677                         ll_deauthorize_statahead(inode, fd);
 678                 if (fd != NULL)
 679                         ll_file_data_put(fd);
 680         } else {
 681                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
 682         }
 683
 684         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
 685                 ptlrpc_req_finished(it->it_request);
 686                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
 687         }
 688
 689         return rc;
 690 }
 691
 692 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
 693                         struct ldlm_lock_desc *desc, void *data, int flag)
 694 {
 695         int rc;
 696         struct lustre_handle lockh;
 697         ENTRY;
 698
 699         switch (flag) {
 700         case LDLM_CB_BLOCKING:
 701                 ldlm_lock2handle(lock, &lockh);
 702                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
 703                 if (rc < 0) {
 704                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
 705                         RETURN(rc);
 706                 }
 707                 break;
 708         case LDLM_CB_CANCELING:
 709                 /* do nothing */
 710                 break;
 711         }
 712         RETURN(0);
 713 }
 714
 715 /**
 716  * When setting a lease on a file, we take ownership of the lli_mds_*_och
 717  * and save it as fd->fd_och so as to force client to reopen the file even
 718  * if it has an open lock in cache already.
 719  */
 720 static int ll_lease_och_acquire(struct inode *inode, struct file *file,
 721                                 struct lustre_handle *old_handle)
 722 {
 723         struct ll_inode_info *lli = ll_i2info(inode);
 724         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 725         struct obd_client_handle **och_p;
 726         __u64 *och_usecount;
 727         int rc = 0;
 728         ENTRY;
 729
 730         /* Get the openhandle of the file */
 731         mutex_lock(&lli->lli_och_mutex);
 732         if (fd->fd_lease_och != NULL)
 733                 GOTO(out_unlock, rc = -EBUSY);
 734
 735         if (fd->fd_och == NULL) {
 736                 if (file->f_mode & FMODE_WRITE) {
 737                         LASSERT(lli->lli_mds_write_och != NULL);
 738                         och_p = &lli->lli_mds_write_och;
 739                         och_usecount = &lli->lli_open_fd_write_count;
 740                 } else {
 741                         LASSERT(lli->lli_mds_read_och != NULL);
 742                         och_p = &lli->lli_mds_read_och;
 743                         och_usecount = &lli->lli_open_fd_read_count;
 744                 }
 745
 746                 if (*och_usecount > 1)
 747                         GOTO(out_unlock, rc = -EBUSY);
 748
 749                 fd->fd_och = *och_p;
 750                 *och_usecount = 0;
 751                 *och_p = NULL;
 752         }
 753
 754         *old_handle = fd->fd_och->och_fh;
 755
 756         EXIT;
 757 out_unlock:
 758         mutex_unlock(&lli->lli_och_mutex);
 759         return rc;
 760 }
 761
 762 /**
 763  * Release ownership on lli_mds_*_och when putting back a file lease.
 764  */
 765 static int ll_lease_och_release(struct inode *inode, struct file *file)
 766 {
 767         struct ll_inode_info *lli = ll_i2info(inode);
 768         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 769         struct obd_client_handle **och_p;
 770         struct obd_client_handle *old_och = NULL;
 771         __u64 *och_usecount;
 772         int rc = 0;
 773         ENTRY;
 774
 775         mutex_lock(&lli->lli_och_mutex);
 776         if (file->f_mode & FMODE_WRITE) {
 777                 och_p = &lli->lli_mds_write_och;
 778                 och_usecount = &lli->lli_open_fd_write_count;
 779         } else {
 780                 och_p = &lli->lli_mds_read_och;
 781                 och_usecount = &lli->lli_open_fd_read_count;
 782         }
 783
 784         /* The file may have been open by another process (broken lease) so
 785          * *och_p is not NULL. In this case we should simply increase usecount
 786          * and close fd_och.
 787          */
 788         if (*och_p != NULL) {
 789                 old_och = fd->fd_och;
 790                 (*och_usecount)++;
 791         } else {
 792                 *och_p = fd->fd_och;
 793                 *och_usecount = 1;
 794         }
 795         fd->fd_och = NULL;
 796         mutex_unlock(&lli->lli_och_mutex);
 797
 798         if (old_och != NULL)
 799                 rc = ll_close_inode_openhandle(inode, old_och, 0, NULL);
 800
 801         RETURN(rc);
 802 }
 803
 804 /**
 805  * Acquire a lease and open the file.
 806  */
 807 static struct obd_client_handle *
 808 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
 809               __u64 open_flags)
 810 {
 811         struct lookup_intent it = { .it_op = IT_OPEN };
 812         struct ll_sb_info *sbi = ll_i2sbi(inode);
 813         struct md_op_data *op_data;
 814         struct ptlrpc_request *req = NULL;
 815         struct lustre_handle old_handle = { 0 };
 816         struct obd_client_handle *och = NULL;
 817         int rc;
 818         int rc2;
 819         ENTRY;
 820
 821         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
 822                 RETURN(ERR_PTR(-EINVAL));
 823
 824         if (file != NULL) {
 825                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
 826                         RETURN(ERR_PTR(-EPERM));
 827
 828                 rc = ll_lease_och_acquire(inode, file, &old_handle);
 829                 if (rc)
 830                         RETURN(ERR_PTR(rc));
 831         }
 832
 833         OBD_ALLOC_PTR(och);
 834         if (och == NULL)
 835                 RETURN(ERR_PTR(-ENOMEM));
 836
 837         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
 838                                         LUSTRE_OPC_ANY, NULL);
 839         if (IS_ERR(op_data))
 840                 GOTO(out, rc = PTR_ERR(op_data));
 841
 842         /* To tell the MDT this openhandle is from the same owner */
 843         op_data->op_handle = old_handle;
 844
 845         it.it_flags = fmode | open_flags;
 846         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
 847         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
 848                             &ll_md_blocking_lease_ast,
 849         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
 850          * it can be cancelled which may mislead applications that the lease is
 851          * broken;
 852          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
 853          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
 854          * doesn't deal with openhandle, so normal openhandle will be leaked. */
 855                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
 856         ll_finish_md_op_data(op_data);
 857         ptlrpc_req_finished(req);
 858         if (rc < 0)
 859                 GOTO(out_release_it, rc);
 860
 861         if (it_disposition(&it, DISP_LOOKUP_NEG))
 862                 GOTO(out_release_it, rc = -ENOENT);
 863
 864         rc = it_open_error(DISP_OPEN_OPEN, &it);
 865         if (rc)
 866                 GOTO(out_release_it, rc);
 867
 868         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
 869         ll_och_fill(sbi->ll_md_exp, &it, och);
 870
 871         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
 872                 GOTO(out_close, rc = -EOPNOTSUPP);
 873
 874         /* already get lease, handle lease lock */
 875         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
 876         if (it.it_lock_mode == 0 ||
 877             it.it_lock_bits != MDS_INODELOCK_OPEN) {
 878                 /* open lock must return for lease */
 879                 CERROR(DFID "lease granted but no open lock, %d/%llu.\n",
 880                         PFID(ll_inode2fid(inode)), it.it_lock_mode,
 881                         it.it_lock_bits);
 882                 GOTO(out_close, rc = -EPROTO);
 883         }
 884
 885         ll_intent_release(&it);
 886         RETURN(och);
 887
 888 out_close:
 889         /* Cancel open lock */
 890         if (it.it_lock_mode != 0) {
 891                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
 892                                             it.it_lock_mode);
 893                 it.it_lock_mode = 0;
 894                 och->och_lease_handle.cookie = 0ULL;
 895         }
 896         rc2 = ll_close_inode_openhandle(inode, och, 0, NULL);
 897         if (rc2 < 0)
 898                 CERROR("%s: error closing file "DFID": %d\n",
 899                        ll_get_fsname(inode->i_sb, NULL, 0),
 900                        PFID(&ll_i2info(inode)->lli_fid), rc2);
 901         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
 902 out_release_it:
 903         ll_intent_release(&it);
 904 out:
 905         if (och != NULL)
 906                 OBD_FREE_PTR(och);
 907         RETURN(ERR_PTR(rc));
 908 }
 909
 910 /**
 911  * Check whether a layout swap can be done between two inodes.
 912  *
 913  * \param[in] inode1  First inode to check
 914  * \param[in] inode2  Second inode to check
 915  *
 916  * \retval 0 on success, layout swap can be performed between both inodes
 917  * \retval negative error code if requirements are not met
 918  */
 919 static int ll_check_swap_layouts_validity(struct inode *inode1,
 920                                           struct inode *inode2)
 921 {
 922         if (!S_ISREG(inode1->i_mode) || !S_ISREG(inode2->i_mode))
 923                 return -EINVAL;
 924
 925         if (inode_permission(inode1, MAY_WRITE) ||
 926             inode_permission(inode2, MAY_WRITE))
 927                 return -EPERM;
 928
 929         if (inode1->i_sb != inode2->i_sb)
 930                 return -EXDEV;
 931
 932         return 0;
 933 }
 934
 935 static int ll_swap_layouts_close(struct obd_client_handle *och,
 936                                  struct inode *inode, struct inode *inode2,
 937                                  int intent)
 938 {
 939         const struct lu_fid     *fid1 = ll_inode2fid(inode);
 940         const struct lu_fid     *fid2;
 941         enum mds_op_bias         bias;
 942         int                      rc;
 943         ENTRY;
 944
 945         CDEBUG(D_INODE, "%s: biased close of file "DFID"\n",
 946                ll_get_fsname(inode->i_sb, NULL, 0), PFID(fid1));
 947
 948         rc = ll_check_swap_layouts_validity(inode, inode2);
 949         if (rc < 0)
 950                 GOTO(out_free_och, rc);
 951
 952         /* We now know that inode2 is a lustre inode */
 953         fid2 = ll_inode2fid(inode2);
 954
 955         rc = lu_fid_cmp(fid1, fid2);
 956         if (rc == 0)
 957                 GOTO(out_free_och, rc = -EINVAL);
 958
 959         switch (intent) {
 960         case SWAP_LAYOUTS_CLOSE:
 961                 bias = MDS_CLOSE_LAYOUT_SWAP;
 962                 break;
 963         case MERGE_LAYOUTS_CLOSE:
 964                 bias = MDS_CLOSE_LAYOUT_MERGE;
 965                 break;
 966         default:
 967                 GOTO(out_free_och, rc = -EOPNOTSUPP);
 968         }
 969
 970         /* Close the file and {swap,merge} layouts between inode & inode2.
 971          * NB: lease lock handle is released in mdc_close_layout_swap_pack()
 972          * because we still need it to pack l_remote_handle to MDT. */
 973         rc = ll_close_inode_openhandle(inode, och, bias, inode2);
 974
 975         och = NULL; /* freed in ll_close_inode_openhandle() */
 976
 977 out_free_och:
 978         if (och != NULL)
 979                 OBD_FREE_PTR(och);
 980
 981         RETURN(rc);
 982 }
 983
 984 /**
 985  * Release lease and close the file.
 986  * It will check if the lease has ever broken.
 987  */
 988 static int ll_lease_close_intent(struct obd_client_handle *och,
 989                                  struct inode *inode,
 990                                  bool *lease_broken, enum mds_op_bias bias,
 991                                  void *data)
 992 {
 993         struct ldlm_lock *lock;
 994         bool cancelled = true;
 995         int rc;
 996         ENTRY;
 997
 998         lock = ldlm_handle2lock(&och->och_lease_handle);
 999         if (lock != NULL) {
1000                 lock_res_and_lock(lock);
1001                 cancelled = ldlm_is_cancel(lock);
1002                 unlock_res_and_lock(lock);
1003                 LDLM_LOCK_PUT(lock);
1004         }
1005
1006         CDEBUG(D_INODE, "lease for "DFID" broken? %d, bias: %x\n",
1007                PFID(&ll_i2info(inode)->lli_fid), cancelled, bias);
1008
1009         if (lease_broken != NULL)
1010                 *lease_broken = cancelled;
1011
1012         if (!cancelled && !bias)
1013                 ldlm_cli_cancel(&och->och_lease_handle, 0);
1014
1015         if (cancelled) { /* no need to excute intent */
1016                 bias = 0;
1017                 data = NULL;
1018         }
1019
1020         rc = ll_close_inode_openhandle(inode, och, bias, data);
1021         RETURN(rc);
1022 }
1023
1024 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
1025                           bool *lease_broken)
1026 {
1027         return ll_lease_close_intent(och, inode, lease_broken, 0, NULL);
1028 }
1029
1030 /**
1031  * After lease is taken, send the RPC MDS_REINT_RESYNC to the MDT
1032  */
1033 static int ll_lease_file_resync(struct obd_client_handle *och,
1034                                 struct inode *inode)
1035 {
1036         struct ll_sb_info *sbi = ll_i2sbi(inode);
1037         struct md_op_data *op_data;
1038         __u64 data_version_unused;
1039         int rc;
1040         ENTRY;
1041
1042         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
1043                                      LUSTRE_OPC_ANY, NULL);
1044         if (IS_ERR(op_data))
1045                 RETURN(PTR_ERR(op_data));
1046
1047         /* before starting file resync, it's necessary to clean up page cache
1048          * in client memory, otherwise once the layout version is increased,
1049          * writing back cached data will be denied the OSTs. */
1050         rc = ll_data_version(inode, &data_version_unused, LL_DV_WR_FLUSH);
1051         if (rc)
1052                 GOTO(out, rc);
1053
1054         op_data->op_handle = och->och_lease_handle;
1055         rc = md_file_resync(sbi->ll_md_exp, op_data);
1056         if (rc)
1057                 GOTO(out, rc);
1058
1059         EXIT;
1060 out:
1061         ll_finish_md_op_data(op_data);
1062         return rc;
1063 }
1064
1065 int ll_merge_attr(const struct lu_env *env, struct inode *inode)
1066 {
1067         struct ll_inode_info *lli = ll_i2info(inode);
1068         struct cl_object *obj = lli->lli_clob;
1069         struct cl_attr *attr = vvp_env_thread_attr(env);
1070         s64 atime;
1071         s64 mtime;
1072         s64 ctime;
1073         int rc = 0;
1074
1075         ENTRY;
1076
1077         ll_inode_size_lock(inode);
1078
1079         /* Merge timestamps the most recently obtained from MDS with
1080          * timestamps obtained from OSTs.
1081          *
1082          * Do not overwrite atime of inode because it may be refreshed
1083          * by file_accessed() function. If the read was served by cache
1084          * data, there is no RPC to be sent so that atime may not be
1085          * transferred to OSTs at all. MDT only updates atime at close time
1086          * if it's at least 'mdd.*.atime_diff' older.
1087          * All in all, the atime in Lustre does not strictly comply with
1088          * POSIX. Solving this problem needs to send an RPC to MDT for each
1089          * read, this will hurt performance. */
1090         if (LTIME_S(inode->i_atime) < lli->lli_atime || lli->lli_update_atime) {
1091                 LTIME_S(inode->i_atime) = lli->lli_atime;
1092                 lli->lli_update_atime = 0;
1093         }
1094         LTIME_S(inode->i_mtime) = lli->lli_mtime;
1095         LTIME_S(inode->i_ctime) = lli->lli_ctime;
1096
1097         atime = LTIME_S(inode->i_atime);
1098         mtime = LTIME_S(inode->i_mtime);
1099         ctime = LTIME_S(inode->i_ctime);
1100
1101         cl_object_attr_lock(obj);
1102         rc = cl_object_attr_get(env, obj, attr);
1103         cl_object_attr_unlock(obj);
1104
1105         if (rc != 0)
1106                 GOTO(out_size_unlock, rc = (rc == -ENODATA ? 0 : rc));
1107
1108         if (atime < attr->cat_atime)
1109                 atime = attr->cat_atime;
1110
1111         if (ctime < attr->cat_ctime)
1112                 ctime = attr->cat_ctime;
1113
1114         if (mtime < attr->cat_mtime)
1115                 mtime = attr->cat_mtime;
1116
1117         CDEBUG(D_VFSTRACE, DFID" updating i_size %llu\n",
1118                PFID(&lli->lli_fid), attr->cat_size);
1119
1120         i_size_write(inode, attr->cat_size);
1121         inode->i_blocks = attr->cat_blocks;
1122
1123         LTIME_S(inode->i_atime) = atime;
1124         LTIME_S(inode->i_mtime) = mtime;
1125         LTIME_S(inode->i_ctime) = ctime;
1126
1127 out_size_unlock:
1128         ll_inode_size_unlock(inode);
1129
1130         RETURN(rc);
1131 }
1132
1133 /**
1134  * Set designated mirror for I/O.
1135  *
1136  * So far only read, write, and truncated can support to issue I/O to
1137  * designated mirror.
1138  */
1139 void ll_io_set_mirror(struct cl_io *io, const struct file *file)
1140 {
1141         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1142
1143         /* clear layout version for generic(non-resync) I/O in case it carries
1144          * stale layout version due to I/O restart */
1145         io->ci_layout_version = 0;
1146
1147         /* FLR: disable non-delay for designated mirror I/O because obviously
1148          * only one mirror is available */
1149         if (fd->fd_designated_mirror > 0) {
1150                 io->ci_ndelay = 0;
1151                 io->ci_designated_mirror = fd->fd_designated_mirror;
1152                 io->ci_layout_version = fd->fd_layout_version;
1153                 io->ci_pio = 0; /* doesn't have a mechanism to pass mirror
1154                                  * io to ptasks */
1155         }
1156
1157         CDEBUG(D_VFSTRACE, "%s: desiginated mirror: %d\n",
1158                file->f_path.dentry->d_name.name, io->ci_designated_mirror);
1159 }
1160
1161 static bool file_is_noatime(const struct file *file)
1162 {
1163         const struct vfsmount *mnt = file->f_path.mnt;
1164         const struct inode *inode = file_inode((struct file *)file);
1165
1166         /* Adapted from file_accessed() and touch_atime().*/
1167         if (file->f_flags & O_NOATIME)
1168                 return true;
1169
1170         if (inode->i_flags & S_NOATIME)
1171                 return true;
1172
1173         if (IS_NOATIME(inode))
1174                 return true;
1175
1176         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1177                 return true;
1178
1179         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1180                 return true;
1181
1182         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1183                 return true;
1184
1185         return false;
1186 }
1187
1188 static int ll_file_io_ptask(struct cfs_ptask *ptask);
1189
1190 static void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot)
1191 {
1192         struct inode *inode = file_inode(file);
1193         struct ll_file_data *fd  = LUSTRE_FPRIVATE(file);
1194
1195         memset(&io->u.ci_rw.rw_iter, 0, sizeof(io->u.ci_rw.rw_iter));
1196         init_sync_kiocb(&io->u.ci_rw.rw_iocb, file);
1197         io->u.ci_rw.rw_file = file;
1198         io->u.ci_rw.rw_ptask = ll_file_io_ptask;
1199         io->u.ci_rw.rw_nonblock = !!(file->f_flags & O_NONBLOCK);
1200         io->ci_lock_no_expand = fd->ll_lock_no_expand;
1201
1202         if (iot == CIT_WRITE) {
1203                 io->u.ci_rw.rw_append = !!(file->f_flags & O_APPEND);
1204                 io->u.ci_rw.rw_sync   = !!(file->f_flags & O_SYNC ||
1205                                            file->f_flags & O_DIRECT ||
1206                                            IS_SYNC(inode));
1207         }
1208         io->ci_obj = ll_i2info(inode)->lli_clob;
1209         io->ci_lockreq = CILR_MAYBE;
1210         if (ll_file_nolock(file)) {
1211                 io->ci_lockreq = CILR_NEVER;
1212                 io->ci_no_srvlock = 1;
1213         } else if (file->f_flags & O_APPEND) {
1214                 io->ci_lockreq = CILR_MANDATORY;
1215         }
1216         io->ci_noatime = file_is_noatime(file);
1217         if (ll_i2sbi(inode)->ll_flags & LL_SBI_PIO)
1218                 io->ci_pio = !io->u.ci_rw.rw_append;
1219         else
1220                 io->ci_pio = 0;
1221
1222         /* FLR: only use non-delay I/O for read as there is only one
1223          * avaliable mirror for write. */
1224         io->ci_ndelay = !(iot == CIT_WRITE);
1225
1226         ll_io_set_mirror(io, file);
1227 }
1228
1229 static int ll_file_io_ptask(struct cfs_ptask *ptask)
1230 {
1231         struct cl_io_pt *pt = ptask->pt_cbdata;
1232         struct file *file = pt->cip_file;
1233         struct lu_env *env;
1234         struct cl_io *io;
1235         loff_t pos = pt->cip_pos;
1236         int rc;
1237         __u16 refcheck;
1238         ENTRY;
1239
1240         CDEBUG(D_VFSTRACE, "%s: %s range: [%llu, %llu)\n",
1241                 file_dentry(file)->d_name.name,
1242                 pt->cip_iot == CIT_READ ? "read" : "write",
1243                 pos, pos + pt->cip_count);
1244
1245         env = cl_env_get(&refcheck);
1246         if (IS_ERR(env))
1247                 RETURN(PTR_ERR(env));
1248
1249         io = vvp_env_thread_io(env);
1250         ll_io_init(io, file, pt->cip_iot);
1251         io->u.ci_rw.rw_iter = pt->cip_iter;
1252         io->u.ci_rw.rw_iocb = pt->cip_iocb;
1253         io->ci_pio = 0; /* It's already in parallel task */
1254
1255         rc = cl_io_rw_init(env, io, pt->cip_iot, pos,
1256                            pt->cip_count - pt->cip_result);
1257         if (!rc) {
1258                 struct vvp_io *vio = vvp_env_io(env);
1259
1260                 vio->vui_io_subtype = IO_NORMAL;
1261                 vio->vui_fd = LUSTRE_FPRIVATE(file);
1262
1263                 ll_cl_add(file, env, io, LCC_RW);
1264                 rc = cl_io_loop(env, io);
1265                 ll_cl_remove(file, env);
1266         } else {
1267                 /* cl_io_rw_init() handled IO */
1268                 rc = io->ci_result;
1269         }
1270
1271         if (OBD_FAIL_CHECK_RESET(OBD_FAIL_LLITE_PTASK_IO_FAIL, 0)) {
1272                 if (io->ci_nob > 0)
1273                         io->ci_nob /= 2;
1274                 rc = -EIO;
1275         }
1276
1277         if (io->ci_nob > 0) {
1278                 pt->cip_result += io->ci_nob;
1279                 iov_iter_advance(&pt->cip_iter, io->ci_nob);
1280                 pos += io->ci_nob;
1281                 pt->cip_iocb.ki_pos = pos;
1282 #ifdef HAVE_KIOCB_KI_LEFT
1283                 pt->cip_iocb.ki_left = pt->cip_count - pt->cip_result;
1284 #elif defined(HAVE_KI_NBYTES)
1285                 pt->cip_iocb.ki_nbytes = pt->cip_count - pt->cip_result;
1286 #endif
1287         }
1288
1289         cl_io_fini(env, io);
1290         cl_env_put(env, &refcheck);
1291
1292         pt->cip_need_restart = io->ci_need_restart;
1293
1294         CDEBUG(D_VFSTRACE, "%s: %s ret: %zd, rc: %d\n",
1295                 file_dentry(file)->d_name.name,
1296                 pt->cip_iot == CIT_READ ? "read" : "write",
1297                 pt->cip_result, rc);
1298
1299         RETURN(pt->cip_result > 0 ? 0 : rc);
1300 }
1301
1302 static ssize_t
1303 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1304                    struct file *file, enum cl_io_type iot,
1305                    loff_t *ppos, size_t count)
1306 {
1307         struct range_lock       range;
1308         struct vvp_io           *vio = vvp_env_io(env);
1309         struct inode            *inode = file_inode(file);
1310         struct ll_inode_info    *lli = ll_i2info(inode);
1311         struct ll_file_data     *fd  = LUSTRE_FPRIVATE(file);
1312         struct cl_io            *io;
1313         loff_t                  pos = *ppos;
1314         ssize_t                 result = 0;
1315         int                     rc = 0;
1316         unsigned                retried = 0;
1317         bool                    restarted = false;
1318
1319         ENTRY;
1320
1321         CDEBUG(D_VFSTRACE, "%s: %s range: [%llu, %llu)\n",
1322                 file_dentry(file)->d_name.name,
1323                 iot == CIT_READ ? "read" : "write", pos, pos + count);
1324
1325 restart:
1326         io = vvp_env_thread_io(env);
1327         ll_io_init(io, file, iot);
1328         if (args->via_io_subtype == IO_NORMAL) {
1329                 io->u.ci_rw.rw_iter = *args->u.normal.via_iter;
1330                 io->u.ci_rw.rw_iocb = *args->u.normal.via_iocb;
1331         }
1332         if (args->via_io_subtype != IO_NORMAL || restarted)
1333                 io->ci_pio = 0;
1334         io->ci_ndelay_tried = retried;
1335
1336         if (cl_io_rw_init(env, io, iot, pos, count) == 0) {
1337                 bool range_locked = false;
1338
1339                 if (file->f_flags & O_APPEND)
1340                         range_lock_init(&range, 0, LUSTRE_EOF);
1341                 else
1342                         range_lock_init(&range, pos, pos + count - 1);
1343
1344                 vio->vui_fd  = LUSTRE_FPRIVATE(file);
1345                 vio->vui_io_subtype = args->via_io_subtype;
1346
1347                 switch (vio->vui_io_subtype) {
1348                 case IO_NORMAL:
1349                         /* Direct IO reads must also take range lock,
1350                          * or multiple reads will try to work on the same pages
1351                          * See LU-6227 for details. */
1352                         if (((iot == CIT_WRITE) ||
1353                             (iot == CIT_READ && (file->f_flags & O_DIRECT))) &&
1354                             !(vio->vui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1355                                 CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1356                                        RL_PARA(&range));
1357                                 rc = range_lock(&lli->lli_write_tree, &range);
1358                                 if (rc < 0)
1359                                         GOTO(out, rc);
1360
1361                                 range_locked = true;
1362                         }
1363                         break;
1364                 case IO_SPLICE:
1365                         vio->u.splice.vui_pipe = args->u.splice.via_pipe;
1366                         vio->u.splice.vui_flags = args->u.splice.via_flags;
1367                         break;
1368                 default:
1369                         CERROR("unknown IO subtype %u\n", vio->vui_io_subtype);
1370                         LBUG();
1371                 }
1372
1373                 ll_cl_add(file, env, io, LCC_RW);
1374                 if (io->ci_pio && iot == CIT_WRITE && !IS_NOSEC(inode) &&
1375                     !lli->lli_inode_locked) {
1376                         inode_lock(inode);
1377                         lli->lli_inode_locked = 1;
1378                 }
1379                 rc = cl_io_loop(env, io);
1380                 if (lli->lli_inode_locked) {
1381                         lli->lli_inode_locked = 0;
1382                         inode_unlock(inode);
1383                 }
1384                 ll_cl_remove(file, env);
1385
1386                 if (range_locked) {
1387                         CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1388                                RL_PARA(&range));
1389                         range_unlock(&lli->lli_write_tree, &range);
1390                 }
1391         } else {
1392                 /* cl_io_rw_init() handled IO */
1393                 rc = io->ci_result;
1394         }
1395
1396         if (io->ci_nob > 0) {
1397                 result += io->ci_nob;
1398                 count  -= io->ci_nob;
1399
1400                 if (args->via_io_subtype == IO_NORMAL) {
1401                         iov_iter_advance(args->u.normal.via_iter, io->ci_nob);
1402                         pos += io->ci_nob;
1403                         args->u.normal.via_iocb->ki_pos = pos;
1404 #ifdef HAVE_KIOCB_KI_LEFT
1405                         args->u.normal.via_iocb->ki_left = count;
1406 #elif defined(HAVE_KI_NBYTES)
1407                         args->u.normal.via_iocb->ki_nbytes = count;
1408 #endif
1409                 } else {
1410                         /* for splice */
1411                         pos = io->u.ci_rw.rw_range.cir_pos;
1412                 }
1413         }
1414 out:
1415         cl_io_fini(env, io);
1416
1417         CDEBUG(D_VFSTRACE,
1418                "%s: %d io complete with rc: %d, result: %zd, restart: %d\n",
1419                file->f_path.dentry->d_name.name,
1420                iot, rc, result, io->ci_need_restart);
1421
1422         if ((rc == 0 || rc == -ENODATA) && count > 0 && io->ci_need_restart) {
1423                 CDEBUG(D_VFSTRACE,
1424                         "%s: restart %s range: [%llu, %llu) ret: %zd, rc: %d\n",
1425                         file_dentry(file)->d_name.name,
1426                         iot == CIT_READ ? "read" : "write",
1427                         pos, pos + count, result, rc);
1428                 /* preserve the tried count for FLR */
1429                 retried = io->ci_ndelay_tried;
1430                 restarted = true;
1431                 goto restart;
1432         }
1433
1434         if (iot == CIT_READ) {
1435                 if (result > 0)
1436                         ll_stats_ops_tally(ll_i2sbi(inode),
1437                                            LPROC_LL_READ_BYTES, result);
1438         } else if (iot == CIT_WRITE) {
1439                 if (result > 0) {
1440                         ll_stats_ops_tally(ll_i2sbi(inode),
1441                                            LPROC_LL_WRITE_BYTES, result);
1442                         fd->fd_write_failed = false;
1443                 } else if (result == 0 && rc == 0) {
1444                         rc = io->ci_result;
1445                         if (rc < 0)
1446                                 fd->fd_write_failed = true;
1447                         else
1448                                 fd->fd_write_failed = false;
1449                 } else if (rc != -ERESTARTSYS) {
1450                         fd->fd_write_failed = true;
1451                 }
1452         }
1453
1454         CDEBUG(D_VFSTRACE, "%s: %s *ppos: %llu, pos: %llu, ret: %zd, rc: %d\n",
1455                 file_dentry(file)->d_name.name,
1456                 iot == CIT_READ ? "read" : "write", *ppos, pos, result, rc);
1457
1458         *ppos = pos;
1459
1460         RETURN(result > 0 ? result : rc);
1461 }
1462
1463 /**
1464  * The purpose of fast read is to overcome per I/O overhead and improve IOPS
1465  * especially for small I/O.
1466  *
1467  * To serve a read request, CLIO has to create and initialize a cl_io and
1468  * then request DLM lock. This has turned out to have siginificant overhead
1469  * and affects the performance of small I/O dramatically.
1470  *
1471  * It's not necessary to create a cl_io for each I/O. Under the help of read
1472  * ahead, most of the pages being read are already in memory cache and we can
1473  * read those pages directly because if the pages exist, the corresponding DLM
1474  * lock must exist so that page content must be valid.
1475  *
1476  * In fast read implementation, the llite speculatively finds and reads pages
1477  * in memory cache. There are three scenarios for fast read:
1478  *   - If the page exists and is uptodate, kernel VM will provide the data and
1479  *     CLIO won't be intervened;
1480  *   - If the page was brought into memory by read ahead, it will be exported
1481  *     and read ahead parameters will be updated;
1482  *   - Otherwise the page is not in memory, we can't do fast read. Therefore,
1483  *     it will go back and invoke normal read, i.e., a cl_io will be created
1484  *     and DLM lock will be requested.
1485  *
1486  * POSIX compliance: posix standard states that read is intended to be atomic.
1487  * Lustre read implementation is in line with Linux kernel read implementation
1488  * and neither of them complies with POSIX standard in this matter. Fast read
1489  * doesn't make the situation worse on single node but it may interleave write
1490  * results from multiple nodes due to short read handling in ll_file_aio_read().
1491  *
1492  * \param env - lu_env
1493  * \param iocb - kiocb from kernel
1494  * \param iter - user space buffers where the data will be copied
1495  *
1496  * \retval - number of bytes have been read, or error code if error occurred.
1497  */
1498 static ssize_t
1499 ll_do_fast_read(struct kiocb *iocb, struct iov_iter *iter)
1500 {
1501         ssize_t result;
1502
1503         if (!ll_sbi_has_fast_read(ll_i2sbi(file_inode(iocb->ki_filp))))
1504                 return 0;
1505
1506         /* NB: we can't do direct IO for fast read because it will need a lock
1507          * to make IO engine happy. */
1508         if (iocb->ki_filp->f_flags & O_DIRECT)
1509                 return 0;
1510
1511         result = generic_file_read_iter(iocb, iter);
1512
1513         /* If the first page is not in cache, generic_file_aio_read() will be
1514          * returned with -ENODATA.
1515          * See corresponding code in ll_readpage(). */
1516         if (result == -ENODATA)
1517                 result = 0;
1518
1519         if (result > 0)
1520                 ll_stats_ops_tally(ll_i2sbi(file_inode(iocb->ki_filp)),
1521                                 LPROC_LL_READ_BYTES, result);
1522
1523         return result;
1524 }
1525
1526 /*
1527  * Read from a file (through the page cache).
1528  */
1529 static ssize_t ll_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
1530 {
1531         struct lu_env *env;
1532         struct vvp_io_args *args;
1533         ssize_t result;
1534         ssize_t rc2;
1535         __u16 refcheck;
1536
1537         result = ll_do_fast_read(iocb, to);
1538         if (result < 0 || iov_iter_count(to) == 0)
1539                 GOTO(out, result);
1540
1541         env = cl_env_get(&refcheck);
1542         if (IS_ERR(env))
1543                 return PTR_ERR(env);
1544
1545         args = ll_env_args(env, IO_NORMAL);
1546         args->u.normal.via_iter = to;
1547         args->u.normal.via_iocb = iocb;
1548
1549         rc2 = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1550                                  &iocb->ki_pos, iov_iter_count(to));
1551         if (rc2 > 0)
1552                 result += rc2;
1553         else if (result == 0)
1554                 result = rc2;
1555
1556         cl_env_put(env, &refcheck);
1557 out:
1558         return result;
1559 }
1560
1561 /*
1562  * Write to a file (through the page cache).
1563  */
1564 static ssize_t ll_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1565 {
1566         struct vvp_io_args *args;
1567         struct lu_env *env;
1568         ssize_t result;
1569         __u16 refcheck;
1570
1571         env = cl_env_get(&refcheck);
1572         if (IS_ERR(env))
1573                 return PTR_ERR(env);
1574
1575         args = ll_env_args(env, IO_NORMAL);
1576         args->u.normal.via_iter = from;
1577         args->u.normal.via_iocb = iocb;
1578
1579         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1580                                     &iocb->ki_pos, iov_iter_count(from));
1581         cl_env_put(env, &refcheck);
1582         return result;
1583 }
1584
1585 #ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
1586 /*
1587  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1588  */
1589 static int ll_file_get_iov_count(const struct iovec *iov,
1590                                  unsigned long *nr_segs, size_t *count)
1591 {
1592         size_t cnt = 0;
1593         unsigned long seg;
1594
1595         for (seg = 0; seg < *nr_segs; seg++) {
1596                 const struct iovec *iv = &iov[seg];
1597
1598                 /*
1599                  * If any segment has a negative length, or the cumulative
1600                  * length ever wraps negative then return -EINVAL.
1601                  */
1602                 cnt += iv->iov_len;
1603                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1604                         return -EINVAL;
1605                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
1606                         continue;
1607                 if (seg == 0)
1608                         return -EFAULT;
1609                 *nr_segs = seg;
1610                 cnt -= iv->iov_len;     /* This segment is no good */
1611                 break;
1612         }
1613         *count = cnt;
1614         return 0;
1615 }
1616
1617 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1618                                 unsigned long nr_segs, loff_t pos)
1619 {
1620         struct iov_iter to;
1621         size_t iov_count;
1622         ssize_t result;
1623         ENTRY;
1624
1625         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count);
1626         if (result)
1627                 RETURN(result);
1628
1629 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
1630         iov_iter_init(&to, READ, iov, nr_segs, iov_count);
1631 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
1632         iov_iter_init(&to, iov, nr_segs, iov_count, 0);
1633 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
1634
1635         result = ll_file_read_iter(iocb, &to);
1636
1637         RETURN(result);
1638 }
1639
1640 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
1641                             loff_t *ppos)
1642 {
1643         struct iovec   iov = { .iov_base = buf, .iov_len = count };
1644         struct kiocb   kiocb;
1645         ssize_t        result;
1646         ENTRY;
1647
1648         init_sync_kiocb(&kiocb, file);
1649         kiocb.ki_pos = *ppos;
1650 #ifdef HAVE_KIOCB_KI_LEFT
1651         kiocb.ki_left = count;
1652 #elif defined(HAVE_KI_NBYTES)
1653         kiocb.i_nbytes = count;
1654 #endif
1655
1656         result = ll_file_aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
1657         *ppos = kiocb.ki_pos;
1658
1659         RETURN(result);
1660 }
1661
1662 /*
1663  * Write to a file (through the page cache).
1664  * AIO stuff
1665  */
1666 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1667                                  unsigned long nr_segs, loff_t pos)
1668 {
1669         struct iov_iter from;
1670         size_t iov_count;
1671         ssize_t result;
1672         ENTRY;
1673
1674         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count);
1675         if (result)
1676                 RETURN(result);
1677
1678 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
1679         iov_iter_init(&from, WRITE, iov, nr_segs, iov_count);
1680 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
1681         iov_iter_init(&from, iov, nr_segs, iov_count, 0);
1682 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
1683
1684         result = ll_file_write_iter(iocb, &from);
1685
1686         RETURN(result);
1687 }
1688
1689 static ssize_t ll_file_write(struct file *file, const char __user *buf,
1690                              size_t count, loff_t *ppos)
1691 {
1692         struct lu_env *env;
1693         struct iovec   iov = { .iov_base = (void __user *)buf,
1694                                .iov_len = count };
1695         struct kiocb  *kiocb;
1696         ssize_t        result;
1697         __u16          refcheck;
1698         ENTRY;
1699
1700         env = cl_env_get(&refcheck);
1701         if (IS_ERR(env))
1702                 RETURN(PTR_ERR(env));
1703
1704         kiocb = &ll_env_info(env)->lti_kiocb;
1705         init_sync_kiocb(kiocb, file);
1706         kiocb->ki_pos = *ppos;
1707 #ifdef HAVE_KIOCB_KI_LEFT
1708         kiocb->ki_left = count;
1709 #elif defined(HAVE_KI_NBYTES)
1710         kiocb->ki_nbytes = count;
1711 #endif
1712
1713         result = ll_file_aio_write(kiocb, &iov, 1, kiocb->ki_pos);
1714         *ppos = kiocb->ki_pos;
1715
1716         cl_env_put(env, &refcheck);
1717         RETURN(result);
1718 }
1719 #endif /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
1720
1721 /*
1722  * Send file content (through pagecache) somewhere with helper
1723  */
1724 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1725                                    struct pipe_inode_info *pipe, size_t count,
1726                                    unsigned int flags)
1727 {
1728         struct lu_env      *env;
1729         struct vvp_io_args *args;
1730         ssize_t             result;
1731         __u16               refcheck;
1732         ENTRY;
1733
1734         env = cl_env_get(&refcheck);
1735         if (IS_ERR(env))
1736                 RETURN(PTR_ERR(env));
1737
1738         args = ll_env_args(env, IO_SPLICE);
1739         args->u.splice.via_pipe = pipe;
1740         args->u.splice.via_flags = flags;
1741
1742         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1743         cl_env_put(env, &refcheck);
1744         RETURN(result);
1745 }
1746
1747 int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
1748                              __u64 flags, struct lov_user_md *lum, int lum_size)
1749 {
1750         struct lookup_intent oit = {
1751                 .it_op = IT_OPEN,
1752                 .it_flags = flags | MDS_OPEN_BY_FID,
1753         };
1754         int rc;
1755         ENTRY;
1756
1757         ll_inode_size_lock(inode);
1758         rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
1759         if (rc < 0)
1760                 GOTO(out_unlock, rc);
1761
1762         ll_release_openhandle(dentry, &oit);
1763
1764 out_unlock:
1765         ll_inode_size_unlock(inode);
1766         ll_intent_release(&oit);
1767
1768         RETURN(rc);
1769 }
1770
1771 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1772                              struct lov_mds_md **lmmp, int *lmm_size,
1773                              struct ptlrpc_request **request)
1774 {
1775         struct ll_sb_info *sbi = ll_i2sbi(inode);
1776         struct mdt_body  *body;
1777         struct lov_mds_md *lmm = NULL;
1778         struct ptlrpc_request *req = NULL;
1779         struct md_op_data *op_data;
1780         int rc, lmmsize;
1781
1782         rc = ll_get_default_mdsize(sbi, &lmmsize);
1783         if (rc)
1784                 RETURN(rc);
1785
1786         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1787                                      strlen(filename), lmmsize,
1788                                      LUSTRE_OPC_ANY, NULL);
1789         if (IS_ERR(op_data))
1790                 RETURN(PTR_ERR(op_data));
1791
1792         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1793         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1794         ll_finish_md_op_data(op_data);
1795         if (rc < 0) {
1796                 CDEBUG(D_INFO, "md_getattr_name failed "
1797                        "on %s: rc %d\n", filename, rc);
1798                 GOTO(out, rc);
1799         }
1800
1801         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1802         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1803
1804         lmmsize = body->mbo_eadatasize;
1805
1806         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1807                         lmmsize == 0) {
1808                 GOTO(out, rc = -ENODATA);
1809         }
1810
1811         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1812         LASSERT(lmm != NULL);
1813
1814         if (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1) &&
1815             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3) &&
1816             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_COMP_V1))
1817                 GOTO(out, rc = -EPROTO);
1818
1819         /*
1820          * This is coming from the MDS, so is probably in
1821          * little endian.  We convert it to host endian before
1822          * passing it to userspace.
1823          */
1824         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1825                 int stripe_count;
1826
1827                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
1828                     lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1829                         stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1830                         if (le32_to_cpu(lmm->lmm_pattern) &
1831                             LOV_PATTERN_F_RELEASED)
1832                                 stripe_count = 0;
1833                 }
1834
1835                 /* if function called for directory - we should
1836                  * avoid swab not existent lsm objects */
1837                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1838                         lustre_swab_lov_user_md_v1(
1839                                         (struct lov_user_md_v1 *)lmm);
1840                         if (S_ISREG(body->mbo_mode))
1841                                 lustre_swab_lov_user_md_objects(
1842                                     ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1843                                     stripe_count);
1844                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1845                         lustre_swab_lov_user_md_v3(
1846                                         (struct lov_user_md_v3 *)lmm);
1847                         if (S_ISREG(body->mbo_mode))
1848                                 lustre_swab_lov_user_md_objects(
1849                                     ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1850                                     stripe_count);
1851                 } else if (lmm->lmm_magic ==
1852                            cpu_to_le32(LOV_MAGIC_COMP_V1)) {
1853                         lustre_swab_lov_comp_md_v1(
1854                                         (struct lov_comp_md_v1 *)lmm);
1855                 }
1856         }
1857
1858 out:
1859         *lmmp = lmm;
1860         *lmm_size = lmmsize;
1861         *request = req;
1862         return rc;
1863 }
1864
1865 static int ll_lov_setea(struct inode *inode, struct file *file,
1866                         void __user *arg)
1867 {
1868         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1869         struct lov_user_md      *lump;
1870         int                      lum_size = sizeof(struct lov_user_md) +
1871                                             sizeof(struct lov_user_ost_data);
1872         int                      rc;
1873         ENTRY;
1874
1875         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1876                 RETURN(-EPERM);
1877
1878         OBD_ALLOC_LARGE(lump, lum_size);
1879         if (lump == NULL)
1880                 RETURN(-ENOMEM);
1881
1882         if (copy_from_user(lump, arg, lum_size))
1883                 GOTO(out_lump, rc = -EFAULT);
1884
1885         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, lump,
1886                                       lum_size);
1887         cl_lov_delay_create_clear(&file->f_flags);
1888
1889 out_lump:
1890         OBD_FREE_LARGE(lump, lum_size);
1891         RETURN(rc);
1892 }
1893
1894 static int ll_file_getstripe(struct inode *inode, void __user *lum, size_t size)
1895 {
1896         struct lu_env   *env;
1897         __u16           refcheck;
1898         int             rc;
1899         ENTRY;
1900
1901         env = cl_env_get(&refcheck);
1902         if (IS_ERR(env))
1903                 RETURN(PTR_ERR(env));
1904
1905         rc = cl_object_getstripe(env, ll_i2info(inode)->lli_clob, lum, size);
1906         cl_env_put(env, &refcheck);
1907         RETURN(rc);
1908 }
1909
1910 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1911                             void __user *arg)
1912 {
1913         struct lov_user_md __user *lum = (struct lov_user_md __user *)arg;
1914         struct lov_user_md        *klum;
1915         int                        lum_size, rc;
1916         __u64                      flags = FMODE_WRITE;
1917         ENTRY;
1918
1919         rc = ll_copy_user_md(lum, &klum);
1920         if (rc < 0)
1921                 RETURN(rc);
1922
1923         lum_size = rc;
1924         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, klum,
1925                                       lum_size);
1926         if (!rc) {
1927                 __u32 gen;
1928
1929                 rc = put_user(0, &lum->lmm_stripe_count);
1930                 if (rc)
1931                         GOTO(out, rc);
1932
1933                 rc = ll_layout_refresh(inode, &gen);
1934                 if (rc)
1935                         GOTO(out, rc);
1936
1937                 rc = ll_file_getstripe(inode, arg, lum_size);
1938         }
1939         cl_lov_delay_create_clear(&file->f_flags);
1940
1941 out:
1942         OBD_FREE(klum, lum_size);
1943         RETURN(rc);
1944 }
1945
1946 static int
1947 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1948 {
1949         struct ll_inode_info *lli = ll_i2info(inode);
1950         struct cl_object *obj = lli->lli_clob;
1951         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1952         struct ll_grouplock grouplock;
1953         int rc;
1954         ENTRY;
1955
1956         if (arg == 0) {
1957                 CWARN("group id for group lock must not be 0\n");
1958                 RETURN(-EINVAL);
1959         }
1960
1961         if (ll_file_nolock(file))
1962                 RETURN(-EOPNOTSUPP);
1963
1964         spin_lock(&lli->lli_lock);
1965         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1966                 CWARN("group lock already existed with gid %lu\n",
1967                       fd->fd_grouplock.lg_gid);
1968                 spin_unlock(&lli->lli_lock);
1969                 RETURN(-EINVAL);
1970         }
1971         LASSERT(fd->fd_grouplock.lg_lock == NULL);
1972         spin_unlock(&lli->lli_lock);
1973
1974         /**
1975          * XXX: group lock needs to protect all OST objects while PFL
1976          * can add new OST objects during the IO, so we'd instantiate
1977          * all OST objects before getting its group lock.
1978          */
1979         if (obj) {
1980                 struct lu_env *env;
1981                 __u16 refcheck;
1982                 struct cl_layout cl = {
1983                         .cl_is_composite = false,
1984                 };
1985
1986                 env = cl_env_get(&refcheck);
1987                 if (IS_ERR(env))
1988                         RETURN(PTR_ERR(env));
1989
1990                 rc = cl_object_layout_get(env, obj, &cl);
1991                 if (!rc && cl.cl_is_composite)
1992                         rc = ll_layout_write_intent(inode, 0, OBD_OBJECT_EOF);
1993
1994                 cl_env_put(env, &refcheck);
1995                 if (rc)
1996                         RETURN(rc);
1997         }
1998
1999         rc = cl_get_grouplock(ll_i2info(inode)->lli_clob,
2000                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
2001         if (rc)
2002                 RETURN(rc);
2003
2004         spin_lock(&lli->lli_lock);
2005         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
2006                 spin_unlock(&lli->lli_lock);
2007                 CERROR("another thread just won the race\n");
2008                 cl_put_grouplock(&grouplock);
2009                 RETURN(-EINVAL);
2010         }
2011
2012         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
2013         fd->fd_grouplock = grouplock;
2014         spin_unlock(&lli->lli_lock);
2015
2016         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
2017         RETURN(0);
2018 }
2019
2020 static int ll_put_grouplock(struct inode *inode, struct file *file,
2021                             unsigned long arg)
2022 {
2023         struct ll_inode_info   *lli = ll_i2info(inode);
2024         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
2025         struct ll_grouplock     grouplock;
2026         ENTRY;
2027
2028         spin_lock(&lli->lli_lock);
2029         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
2030                 spin_unlock(&lli->lli_lock);
2031                 CWARN("no group lock held\n");
2032                 RETURN(-EINVAL);
2033         }
2034
2035         LASSERT(fd->fd_grouplock.lg_lock != NULL);
2036
2037         if (fd->fd_grouplock.lg_gid != arg) {
2038                 CWARN("group lock %lu doesn't match current id %lu\n",
2039                       arg, fd->fd_grouplock.lg_gid);
2040                 spin_unlock(&lli->lli_lock);
2041                 RETURN(-EINVAL);
2042         }
2043
2044         grouplock = fd->fd_grouplock;
2045         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
2046         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
2047         spin_unlock(&lli->lli_lock);
2048
2049         cl_put_grouplock(&grouplock);
2050         CDEBUG(D_INFO, "group lock %lu released\n", arg);
2051         RETURN(0);
2052 }
2053
2054 /**
2055  * Close inode open handle
2056  *
2057  * \param dentry [in]     dentry which contains the inode
2058  * \param it     [in,out] intent which contains open info and result
2059  *
2060  * \retval 0     success
2061  * \retval <0    failure
2062  */
2063 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
2064 {
2065         struct inode *inode = dentry->d_inode;
2066         struct obd_client_handle *och;
2067         int rc;
2068         ENTRY;
2069
2070         LASSERT(inode);
2071
2072         /* Root ? Do nothing. */
2073         if (dentry->d_inode->i_sb->s_root == dentry)
2074                 RETURN(0);
2075
2076         /* No open handle to close? Move away */
2077         if (!it_disposition(it, DISP_OPEN_OPEN))
2078                 RETURN(0);
2079
2080         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
2081
2082         OBD_ALLOC(och, sizeof(*och));
2083         if (!och)
2084                 GOTO(out, rc = -ENOMEM);
2085
2086         ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
2087
2088         rc = ll_close_inode_openhandle(inode, och, 0, NULL);
2089 out:
2090         /* this one is in place of ll_file_open */
2091         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
2092                 ptlrpc_req_finished(it->it_request);
2093                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
2094         }
2095         RETURN(rc);
2096 }
2097
2098 /**
2099  * Get size for inode for which FIEMAP mapping is requested.
2100  * Make the FIEMAP get_info call and returns the result.
2101  * \param fiemap        kernel buffer to hold extens
2102  * \param num_bytes     kernel buffer size
2103  */
2104 static int ll_do_fiemap(struct inode *inode, struct fiemap *fiemap,
2105                         size_t num_bytes)
2106 {
2107         struct lu_env                   *env;
2108         __u16                           refcheck;
2109         int                             rc = 0;
2110         struct ll_fiemap_info_key       fmkey = { .lfik_name = KEY_FIEMAP, };
2111         ENTRY;
2112
2113         /* Checks for fiemap flags */
2114         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
2115                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
2116                 return -EBADR;
2117         }
2118
2119         /* Check for FIEMAP_FLAG_SYNC */
2120         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
2121                 rc = filemap_fdatawrite(inode->i_mapping);
2122                 if (rc)
2123                         return rc;
2124         }
2125
2126         env = cl_env_get(&refcheck);
2127         if (IS_ERR(env))
2128                 RETURN(PTR_ERR(env));
2129
2130         if (i_size_read(inode) == 0) {
2131                 rc = ll_glimpse_size(inode);
2132                 if (rc)
2133                         GOTO(out, rc);
2134         }
2135
2136         fmkey.lfik_oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
2137         obdo_from_inode(&fmkey.lfik_oa, inode, OBD_MD_FLSIZE);
2138         obdo_set_parent_fid(&fmkey.lfik_oa, &ll_i2info(inode)->lli_fid);
2139
2140         /* If filesize is 0, then there would be no objects for mapping */
2141         if (fmkey.lfik_oa.o_size == 0) {
2142                 fiemap->fm_mapped_extents = 0;
2143                 GOTO(out, rc = 0);
2144         }
2145
2146         fmkey.lfik_fiemap = *fiemap;
2147
2148         rc = cl_object_fiemap(env, ll_i2info(inode)->lli_clob,
2149                               &fmkey, fiemap, &num_bytes);
2150 out:
2151         cl_env_put(env, &refcheck);
2152         RETURN(rc);
2153 }
2154
2155 int ll_fid2path(struct inode *inode, void __user *arg)
2156 {
2157         struct obd_export       *exp = ll_i2mdexp(inode);
2158         const struct getinfo_fid2path __user *gfin = arg;
2159         __u32                    pathlen;
2160         struct getinfo_fid2path *gfout;
2161         size_t                   outsize;
2162         int                      rc;
2163
2164         ENTRY;
2165
2166         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
2167             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
2168                 RETURN(-EPERM);
2169
2170         /* Only need to get the buflen */
2171         if (get_user(pathlen, &gfin->gf_pathlen))
2172                 RETURN(-EFAULT);
2173
2174         if (pathlen > PATH_MAX)
2175                 RETURN(-EINVAL);
2176
2177         outsize = sizeof(*gfout) + pathlen;
2178         OBD_ALLOC(gfout, outsize);
2179         if (gfout == NULL)
2180                 RETURN(-ENOMEM);
2181
2182         if (copy_from_user(gfout, arg, sizeof(*gfout)))
2183                 GOTO(gf_free, rc = -EFAULT);
2184         /* append root FID after gfout to let MDT know the root FID so that it
2185          * can lookup the correct path, this is mainly for fileset.
2186          * old server without fileset mount support will ignore this. */
2187         *gfout->gf_u.gf_root_fid = *ll_inode2fid(inode);
2188
2189         /* Call mdc_iocontrol */
2190         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
2191         if (rc != 0)
2192                 GOTO(gf_free, rc);
2193
2194         if (copy_to_user(arg, gfout, outsize))
2195                 rc = -EFAULT;
2196
2197 gf_free:
2198         OBD_FREE(gfout, outsize);
2199         RETURN(rc);
2200 }
2201
2202 static int
2203 ll_ioc_data_version(struct inode *inode, struct ioc_data_version *ioc)
2204 {
2205         struct cl_object *obj = ll_i2info(inode)->lli_clob;
2206         struct lu_env *env;
2207         struct cl_io *io;
2208         __u16  refcheck;
2209         int result;
2210
2211         ENTRY;
2212
2213         ioc->idv_version = 0;
2214         ioc->idv_layout_version = UINT_MAX;
2215
2216         /* If no file object initialized, we consider its version is 0. */
2217         if (obj == NULL)
2218                 RETURN(0);
2219
2220         env = cl_env_get(&refcheck);
2221         if (IS_ERR(env))
2222                 RETURN(PTR_ERR(env));
2223
2224         io = vvp_env_thread_io(env);
2225         io->ci_obj = obj;
2226         io->u.ci_data_version.dv_data_version = 0;
2227         io->u.ci_data_version.dv_layout_version = UINT_MAX;
2228         io->u.ci_data_version.dv_flags = ioc->idv_flags;
2229
2230 restart:
2231         if (cl_io_init(env, io, CIT_DATA_VERSION, io->ci_obj) == 0)
2232                 result = cl_io_loop(env, io);
2233         else
2234                 result = io->ci_result;
2235
2236         ioc->idv_version = io->u.ci_data_version.dv_data_version;
2237         ioc->idv_layout_version = io->u.ci_data_version.dv_layout_version;
2238
2239         cl_io_fini(env, io);
2240
2241         if (unlikely(io->ci_need_restart))
2242                 goto restart;
2243
2244         cl_env_put(env, &refcheck);
2245
2246         RETURN(result);
2247 }
2248
2249 /*
2250  * Read the data_version for inode.
2251  *
2252  * This value is computed using stripe object version on OST.
2253  * Version is computed using server side locking.
2254  *
2255  * @param flags if do sync on the OST side;
2256  *              0: no sync
2257  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
2258  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
2259  */
2260 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
2261 {
2262         struct ioc_data_version ioc = { .idv_flags = flags };
2263         int rc;
2264
2265         rc = ll_ioc_data_version(inode, &ioc);
2266         if (!rc)
2267                 *data_version = ioc.idv_version;
2268
2269         return rc;
2270 }
2271
2272 /*
2273  * Trigger a HSM release request for the provided inode.
2274  */
2275 int ll_hsm_release(struct inode *inode)
2276 {
2277         struct lu_env *env;
2278         struct obd_client_handle *och = NULL;
2279         __u64 data_version = 0;
2280         int rc;
2281         __u16 refcheck;
2282         ENTRY;
2283
2284         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
2285                ll_get_fsname(inode->i_sb, NULL, 0),
2286                PFID(&ll_i2info(inode)->lli_fid));
2287
2288         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
2289         if (IS_ERR(och))
2290                 GOTO(out, rc = PTR_ERR(och));
2291
2292         /* Grab latest data_version and [am]time values */
2293         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
2294         if (rc != 0)
2295                 GOTO(out, rc);
2296
2297         env = cl_env_get(&refcheck);
2298         if (IS_ERR(env))
2299                 GOTO(out, rc = PTR_ERR(env));
2300
2301         ll_merge_attr(env, inode);
2302         cl_env_put(env, &refcheck);
2303
2304         /* Release the file.
2305          * NB: lease lock handle is released in mdc_hsm_release_pack() because
2306          * we still need it to pack l_remote_handle to MDT. */
2307         rc = ll_close_inode_openhandle(inode, och, MDS_HSM_RELEASE,
2308                                        &data_version);
2309         och = NULL;
2310
2311         EXIT;
2312 out:
2313         if (och != NULL && !IS_ERR(och)) /* close the file */
2314                 ll_lease_close(och, inode, NULL);
2315
2316         return rc;
2317 }
2318
2319 struct ll_swap_stack {
2320         __u64                    dv1;
2321         __u64                    dv2;
2322         struct inode            *inode1;
2323         struct inode            *inode2;
2324         bool                     check_dv1;
2325         bool                     check_dv2;
2326 };
2327
2328 static int ll_swap_layouts(struct file *file1, struct file *file2,
2329                            struct lustre_swap_layouts *lsl)
2330 {
2331         struct mdc_swap_layouts  msl;
2332         struct md_op_data       *op_data;
2333         __u32                    gid;
2334         __u64                    dv;
2335         struct ll_swap_stack    *llss = NULL;
2336         int                      rc;
2337
2338         OBD_ALLOC_PTR(llss);
2339         if (llss == NULL)
2340                 RETURN(-ENOMEM);
2341
2342         llss->inode1 = file_inode(file1);
2343         llss->inode2 = file_inode(file2);
2344
2345         rc = ll_check_swap_layouts_validity(llss->inode1, llss->inode2);
2346         if (rc < 0)
2347                 GOTO(free, rc);
2348
2349         /* we use 2 bool because it is easier to swap than 2 bits */
2350         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2351                 llss->check_dv1 = true;
2352
2353         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2354                 llss->check_dv2 = true;
2355
2356         /* we cannot use lsl->sl_dvX directly because we may swap them */
2357         llss->dv1 = lsl->sl_dv1;
2358         llss->dv2 = lsl->sl_dv2;
2359
2360         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2361         if (rc == 0) /* same file, done! */
2362                 GOTO(free, rc);
2363
2364         if (rc < 0) { /* sequentialize it */
2365                 swap(llss->inode1, llss->inode2);
2366                 swap(file1, file2);
2367                 swap(llss->dv1, llss->dv2);
2368                 swap(llss->check_dv1, llss->check_dv2);
2369         }
2370
2371         gid = lsl->sl_gid;
2372         if (gid != 0) { /* application asks to flush dirty cache */
2373                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2374                 if (rc < 0)
2375                         GOTO(free, rc);
2376
2377                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2378                 if (rc < 0) {
2379                         ll_put_grouplock(llss->inode1, file1, gid);
2380                         GOTO(free, rc);
2381                 }
2382         }
2383
2384         /* ultimate check, before swaping the layouts we check if
2385          * dataversion has changed (if requested) */
2386         if (llss->check_dv1) {
2387                 rc = ll_data_version(llss->inode1, &dv, 0);
2388                 if (rc)
2389                         GOTO(putgl, rc);
2390                 if (dv != llss->dv1)
2391                         GOTO(putgl, rc = -EAGAIN);
2392         }
2393
2394         if (llss->check_dv2) {
2395                 rc = ll_data_version(llss->inode2, &dv, 0);
2396                 if (rc)
2397                         GOTO(putgl, rc);
2398                 if (dv != llss->dv2)
2399                         GOTO(putgl, rc = -EAGAIN);
2400         }
2401
2402         /* struct md_op_data is used to send the swap args to the mdt
2403          * only flags is missing, so we use struct mdc_swap_layouts
2404          * through the md_op_data->op_data */
2405         /* flags from user space have to be converted before they are send to
2406          * server, no flag is sent today, they are only used on the client */
2407         msl.msl_flags = 0;
2408         rc = -ENOMEM;
2409         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2410                                      0, LUSTRE_OPC_ANY, &msl);
2411         if (IS_ERR(op_data))
2412                 GOTO(free, rc = PTR_ERR(op_data));
2413
2414         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2415                            sizeof(*op_data), op_data, NULL);
2416         ll_finish_md_op_data(op_data);
2417
2418         if (rc < 0)
2419                 GOTO(putgl, rc);
2420
2421 putgl:
2422         if (gid != 0) {
2423                 ll_put_grouplock(llss->inode2, file2, gid);
2424                 ll_put_grouplock(llss->inode1, file1, gid);
2425         }
2426
2427 free:
2428         if (llss != NULL)
2429                 OBD_FREE_PTR(llss);
2430
2431         RETURN(rc);
2432 }
2433
2434 int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2435 {
2436         struct md_op_data       *op_data;
2437         int                      rc;
2438         ENTRY;
2439
2440         /* Detect out-of range masks */
2441         if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK)
2442                 RETURN(-EINVAL);
2443
2444         /* Non-root users are forbidden to set or clear flags which are
2445          * NOT defined in HSM_USER_MASK. */
2446         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2447             !cfs_capable(CFS_CAP_SYS_ADMIN))
2448                 RETURN(-EPERM);
2449
2450         /* Detect out-of range archive id */
2451         if ((hss->hss_valid & HSS_ARCHIVE_ID) &&
2452             (hss->hss_archive_id > LL_HSM_MAX_ARCHIVE))
2453                 RETURN(-EINVAL);
2454
2455         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2456                                      LUSTRE_OPC_ANY, hss);
2457         if (IS_ERR(op_data))
2458                 RETURN(PTR_ERR(op_data));
2459
2460         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2461                            sizeof(*op_data), op_data, NULL);
2462
2463         ll_finish_md_op_data(op_data);
2464
2465         RETURN(rc);
2466 }
2467
2468 static int ll_hsm_import(struct inode *inode, struct file *file,
2469                          struct hsm_user_import *hui)
2470 {
2471         struct hsm_state_set    *hss = NULL;
2472         struct iattr            *attr = NULL;
2473         int                      rc;
2474         ENTRY;
2475
2476         if (!S_ISREG(inode->i_mode))
2477                 RETURN(-EINVAL);
2478
2479         /* set HSM flags */
2480         OBD_ALLOC_PTR(hss);
2481         if (hss == NULL)
2482                 GOTO(out, rc = -ENOMEM);
2483
2484         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2485         hss->hss_archive_id = hui->hui_archive_id;
2486         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2487         rc = ll_hsm_state_set(inode, hss);
2488         if (rc != 0)
2489                 GOTO(out, rc);
2490
2491         OBD_ALLOC_PTR(attr);
2492         if (attr == NULL)
2493                 GOTO(out, rc = -ENOMEM);
2494
2495         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2496         attr->ia_mode |= S_IFREG;
2497         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2498         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2499         attr->ia_size = hui->hui_size;
2500         attr->ia_mtime.tv_sec = hui->hui_mtime;
2501         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2502         attr->ia_atime.tv_sec = hui->hui_atime;
2503         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2504
2505         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2506                          ATTR_UID | ATTR_GID |
2507                          ATTR_MTIME | ATTR_MTIME_SET |
2508                          ATTR_ATIME | ATTR_ATIME_SET;
2509
2510         inode_lock(inode);
2511
2512         rc = ll_setattr_raw(file_dentry(file), attr, true);
2513         if (rc == -ENODATA)
2514                 rc = 0;
2515
2516         inode_unlock(inode);
2517
2518 out:
2519         if (hss != NULL)
2520                 OBD_FREE_PTR(hss);
2521
2522         if (attr != NULL)
2523                 OBD_FREE_PTR(attr);
2524
2525         RETURN(rc);
2526 }
2527
2528 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2529 {
2530         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2531                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2532 }
2533
2534 static int ll_file_futimes_3(struct file *file, const struct ll_futimes_3 *lfu)
2535 {
2536         struct inode *inode = file_inode(file);
2537         struct iattr ia = {
2538                 .ia_valid = ATTR_ATIME | ATTR_ATIME_SET |
2539                             ATTR_MTIME | ATTR_MTIME_SET |
2540                             ATTR_CTIME | ATTR_CTIME_SET,
2541                 .ia_atime = {
2542                         .tv_sec = lfu->lfu_atime_sec,
2543                         .tv_nsec = lfu->lfu_atime_nsec,
2544                 },
2545                 .ia_mtime = {
2546                         .tv_sec = lfu->lfu_mtime_sec,
2547                         .tv_nsec = lfu->lfu_mtime_nsec,
2548                 },
2549                 .ia_ctime = {
2550                         .tv_sec = lfu->lfu_ctime_sec,
2551                         .tv_nsec = lfu->lfu_ctime_nsec,
2552                 },
2553         };
2554         int rc;
2555         ENTRY;
2556
2557         if (!capable(CAP_SYS_ADMIN))
2558                 RETURN(-EPERM);
2559
2560         if (!S_ISREG(inode->i_mode))
2561                 RETURN(-EINVAL);
2562
2563         inode_lock(inode);
2564         rc = ll_setattr_raw(file_dentry(file), &ia, false);
2565         inode_unlock(inode);
2566
2567         RETURN(rc);
2568 }
2569
2570 static enum cl_lock_mode cl_mode_user_to_kernel(enum lock_mode_user mode)
2571 {
2572         switch (mode) {
2573         case MODE_READ_USER:
2574                 return CLM_READ;
2575         case MODE_WRITE_USER:
2576                 return CLM_WRITE;
2577         default:
2578                 return -EINVAL;
2579         }
2580 }
2581
2582 static const char *const user_lockname[] = LOCK_MODE_NAMES;
2583
2584 /* Used to allow the upper layers of the client to request an LDLM lock
2585  * without doing an actual read or write.
2586  *
2587  * Used for ladvise lockahead to manually request specific locks.
2588  *
2589  * \param[in] file      file this ladvise lock request is on
2590  * \param[in] ladvise   ladvise struct describing this lock request
2591  *
2592  * \retval 0            success, no detailed result available (sync requests
2593  *                      and requests sent to the server [not handled locally]
2594  *                      cannot return detailed results)
2595  * \retval LLA_RESULT_{SAME,DIFFERENT} - detailed result of the lock request,
2596  *                                       see definitions for details.
2597  * \retval negative     negative errno on error
2598  */
2599 int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise)
2600 {
2601         struct lu_env *env = NULL;
2602         struct cl_io *io  = NULL;
2603         struct cl_lock *lock = NULL;
2604         struct cl_lock_descr *descr = NULL;
2605         struct dentry *dentry = file->f_path.dentry;
2606         struct inode *inode = dentry->d_inode;
2607         enum cl_lock_mode cl_mode;
2608         off_t start = ladvise->lla_start;
2609         off_t end = ladvise->lla_end;
2610         int result;
2611         __u16 refcheck;
2612
2613         ENTRY;
2614
2615         CDEBUG(D_VFSTRACE, "Lock request: file=%.*s, inode=%p, mode=%s "
2616                "start=%llu, end=%llu\n", dentry->d_name.len,
2617                dentry->d_name.name, dentry->d_inode,
2618                user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
2619                (__u64) end);
2620
2621         cl_mode = cl_mode_user_to_kernel(ladvise->lla_lockahead_mode);
2622         if (cl_mode < 0)
2623                 GOTO(out, result = cl_mode);
2624
2625         /* Get IO environment */
2626         result = cl_io_get(inode, &env, &io, &refcheck);
2627         if (result <= 0)
2628                 GOTO(out, result);
2629
2630         result = cl_io_init(env, io, CIT_MISC, io->ci_obj);
2631         if (result > 0) {
2632                 /*
2633                  * nothing to do for this io. This currently happens when
2634                  * stripe sub-object's are not yet created.
2635                  */
2636                 result = io->ci_result;
2637         } else if (result == 0) {
2638                 lock = vvp_env_lock(env);
2639                 descr = &lock->cll_descr;
2640
2641                 descr->cld_obj   = io->ci_obj;
2642                 /* Convert byte offsets to pages */
2643                 descr->cld_start = cl_index(io->ci_obj, start);
2644                 descr->cld_end   = cl_index(io->ci_obj, end);
2645                 descr->cld_mode  = cl_mode;
2646                 /* CEF_MUST is used because we do not want to convert a
2647                  * lockahead request to a lockless lock */
2648                 descr->cld_enq_flags = CEF_MUST | CEF_LOCK_NO_EXPAND |
2649                                        CEF_NONBLOCK;
2650
2651                 if (ladvise->lla_peradvice_flags & LF_ASYNC)
2652                         descr->cld_enq_flags |= CEF_SPECULATIVE;
2653
2654                 result = cl_lock_request(env, io, lock);
2655
2656                 /* On success, we need to release the lock */
2657                 if (result >= 0)
2658                         cl_lock_release(env, lock);
2659         }
2660         cl_io_fini(env, io);
2661         cl_env_put(env, &refcheck);
2662
2663         /* -ECANCELED indicates a matching lock with a different extent
2664          * was already present, and -EEXIST indicates a matching lock
2665          * on exactly the same extent was already present.
2666          * We convert them to positive values for userspace to make
2667          * recognizing true errors easier.
2668          * Note we can only return these detailed results on async requests,
2669          * as sync requests look the same as i/o requests for locking. */
2670         if (result == -ECANCELED)
2671                 result = LLA_RESULT_DIFFERENT;
2672         else if (result == -EEXIST)
2673                 result = LLA_RESULT_SAME;
2674
2675 out:
2676         RETURN(result);
2677 }
2678 static const char *const ladvise_names[] = LU_LADVISE_NAMES;
2679
2680 static int ll_ladvise_sanity(struct inode *inode,
2681                              struct llapi_lu_ladvise *ladvise)
2682 {
2683         enum lu_ladvise_type advice = ladvise->lla_advice;
2684         /* Note the peradvice flags is a 32 bit field, so per advice flags must
2685          * be in the first 32 bits of enum ladvise_flags */
2686         __u32 flags = ladvise->lla_peradvice_flags;
2687         /* 3 lines at 80 characters per line, should be plenty */
2688         int rc = 0;
2689
2690         if (advice > LU_LADVISE_MAX || advice == LU_LADVISE_INVALID) {
2691                 rc = -EINVAL;
2692                 CDEBUG(D_VFSTRACE, "%s: advice with value '%d' not recognized,"
2693                        "last supported advice is %s (value '%d'): rc = %d\n",
2694                        ll_get_fsname(inode->i_sb, NULL, 0), advice,
2695                        ladvise_names[LU_LADVISE_MAX-1], LU_LADVISE_MAX-1, rc);
2696                 GOTO(out, rc);
2697         }
2698
2699         /* Per-advice checks */
2700         switch (advice) {
2701         case LU_LADVISE_LOCKNOEXPAND:
2702                 if (flags & ~LF_LOCKNOEXPAND_MASK) {
2703                         rc = -EINVAL;
2704                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
2705                                "rc = %d\n",
2706                                ll_get_fsname(inode->i_sb, NULL, 0), flags,
2707                                ladvise_names[advice], rc);
2708                         GOTO(out, rc);
2709                 }
2710                 break;
2711         case LU_LADVISE_LOCKAHEAD:
2712                 /* Currently only READ and WRITE modes can be requested */
2713                 if (ladvise->lla_lockahead_mode >= MODE_MAX_USER ||
2714                     ladvise->lla_lockahead_mode == 0) {
2715                         rc = -EINVAL;
2716                         CDEBUG(D_VFSTRACE, "%s: Invalid mode (%d) for %s: "
2717                                "rc = %d\n",
2718                                ll_get_fsname(inode->i_sb, NULL, 0),
2719                                ladvise->lla_lockahead_mode,
2720                                ladvise_names[advice], rc);
2721                         GOTO(out, rc);
2722                 }
2723         case LU_LADVISE_WILLREAD:
2724         case LU_LADVISE_DONTNEED:
2725         default:
2726                 /* Note fall through above - These checks apply to all advices
2727                  * except LOCKNOEXPAND */
2728                 if (flags & ~LF_DEFAULT_MASK) {
2729                         rc = -EINVAL;
2730                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
2731                                "rc = %d\n",
2732                                ll_get_fsname(inode->i_sb, NULL, 0), flags,
2733                                ladvise_names[advice], rc);
2734                         GOTO(out, rc);
2735                 }
2736                 if (ladvise->lla_start >= ladvise->lla_end) {
2737                         rc = -EINVAL;
2738                         CDEBUG(D_VFSTRACE, "%s: Invalid range (%llu to %llu) "
2739                                "for %s: rc = %d\n",
2740                                ll_get_fsname(inode->i_sb, NULL, 0),
2741                                ladvise->lla_start, ladvise->lla_end,
2742                                ladvise_names[advice], rc);
2743                         GOTO(out, rc);
2744                 }
2745                 break;
2746         }
2747
2748 out:
2749         return rc;
2750 }
2751 #undef ERRSIZE
2752
2753 /*
2754  * Give file access advices
2755  *
2756  * The ladvise interface is similar to Linux fadvise() system call, except it
2757  * forwards the advices directly from Lustre client to server. The server side
2758  * codes will apply appropriate read-ahead and caching techniques for the
2759  * corresponding files.
2760  *
2761  * A typical workload for ladvise is e.g. a bunch of different clients are
2762  * doing small random reads of a file, so prefetching pages into OSS cache
2763  * with big linear reads before the random IO is a net benefit. Fetching
2764  * all that data into each client cache with fadvise() may not be, due to
2765  * much more data being sent to the client.
2766  */
2767 static int ll_ladvise(struct inode *inode, struct file *file, __u64 flags,
2768                       struct llapi_lu_ladvise *ladvise)
2769 {
2770         struct lu_env *env;
2771         struct cl_io *io;
2772         struct cl_ladvise_io *lio;
2773         int rc;
2774         __u16 refcheck;
2775         ENTRY;
2776
2777         env = cl_env_get(&refcheck);
2778         if (IS_ERR(env))
2779                 RETURN(PTR_ERR(env));
2780
2781         io = vvp_env_thread_io(env);
2782         io->ci_obj = ll_i2info(inode)->lli_clob;
2783
2784         /* initialize parameters for ladvise */
2785         lio = &io->u.ci_ladvise;
2786         lio->li_start = ladvise->lla_start;
2787         lio->li_end = ladvise->lla_end;
2788         lio->li_fid = ll_inode2fid(inode);
2789         lio->li_advice = ladvise->lla_advice;
2790         lio->li_flags = flags;
2791
2792         if (cl_io_init(env, io, CIT_LADVISE, io->ci_obj) == 0)
2793                 rc = cl_io_loop(env, io);
2794         else
2795                 rc = io->ci_result;
2796
2797         cl_io_fini(env, io);
2798         cl_env_put(env, &refcheck);
2799         RETURN(rc);
2800 }
2801
2802 static int ll_lock_noexpand(struct file *file, int flags)
2803 {
2804         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2805
2806         fd->ll_lock_no_expand = !(flags & LF_UNSET);
2807
2808         return 0;
2809 }
2810
2811 int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
2812                         unsigned long arg)
2813 {
2814         struct fsxattr fsxattr;
2815
2816         if (copy_from_user(&fsxattr,
2817                            (const struct fsxattr __user *)arg,
2818                            sizeof(fsxattr)))
2819                 RETURN(-EFAULT);
2820
2821         fsxattr.fsx_projid = ll_i2info(inode)->lli_projid;
2822         if (copy_to_user((struct fsxattr __user *)arg,
2823                          &fsxattr, sizeof(fsxattr)))
2824                 RETURN(-EFAULT);
2825
2826         RETURN(0);
2827 }
2828
2829 int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
2830                         unsigned long arg)
2831 {
2832
2833         struct md_op_data *op_data;
2834         struct ptlrpc_request *req = NULL;
2835         int rc = 0;
2836         struct fsxattr fsxattr;
2837
2838         /* only root could change project ID */
2839         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
2840                 RETURN(-EPERM);
2841
2842         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2843                                      LUSTRE_OPC_ANY, NULL);
2844         if (IS_ERR(op_data))
2845                 RETURN(PTR_ERR(op_data));
2846
2847         if (copy_from_user(&fsxattr,
2848                            (const struct fsxattr __user *)arg,
2849                            sizeof(fsxattr)))
2850                 GOTO(out_fsxattr1, rc = -EFAULT);
2851
2852         op_data->op_projid = fsxattr.fsx_projid;
2853         op_data->op_attr.ia_valid |= MDS_ATTR_PROJID;
2854         rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data, NULL,
2855                         0, &req);
2856         ptlrpc_req_finished(req);
2857
2858 out_fsxattr1:
2859         ll_finish_md_op_data(op_data);
2860         RETURN(rc);
2861 }
2862
2863 static long ll_file_unlock_lease(struct file *file, struct ll_ioc_lease *ioc,
2864                                  unsigned long arg)
2865 {
2866         struct inode            *inode = file_inode(file);
2867         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2868         struct ll_inode_info    *lli = ll_i2info(inode);
2869         struct obd_client_handle *och = NULL;
2870         bool lease_broken;
2871         fmode_t fmode = 0;
2872         enum mds_op_bias bias = 0;
2873         void *data = NULL;
2874         size_t data_size = 0;
2875         long rc;
2876         ENTRY;
2877
2878         mutex_lock(&lli->lli_och_mutex);
2879         if (fd->fd_lease_och != NULL) {
2880                 och = fd->fd_lease_och;
2881                 fd->fd_lease_och = NULL;
2882         }
2883         mutex_unlock(&lli->lli_och_mutex);
2884
2885         if (och == NULL)
2886                 GOTO(out, rc = -ENOLCK);
2887
2888         fmode = och->och_flags;
2889
2890         if (ioc->lil_flags & LL_LEASE_RESYNC_DONE) {
2891                 if (ioc->lil_count > IOC_IDS_MAX)
2892                         GOTO(out, rc = -EINVAL);
2893
2894                 data_size = offsetof(typeof(*ioc), lil_ids[ioc->lil_count]);
2895                 OBD_ALLOC(data, data_size);
2896                 if (!data)
2897                         GOTO(out, rc = -ENOMEM);
2898
2899                 if (copy_from_user(data, (void __user *)arg, data_size))
2900                         GOTO(out, rc = -EFAULT);
2901
2902                 bias = MDS_CLOSE_RESYNC_DONE;
2903         }
2904
2905         rc = ll_lease_close_intent(och, inode, &lease_broken, bias, data);
2906         if (rc < 0)
2907                 GOTO(out, rc);
2908
2909         rc = ll_lease_och_release(inode, file);
2910         if (rc < 0)
2911                 GOTO(out, rc);
2912
2913         if (lease_broken)
2914                 fmode = 0;
2915         EXIT;
2916
2917 out:
2918         if (data)
2919                 OBD_FREE(data, data_size);
2920         if (!rc)
2921                 rc = ll_lease_type_from_fmode(fmode);
2922         RETURN(rc);
2923 }
2924
2925 static long ll_file_set_lease(struct file *file, struct ll_ioc_lease *ioc,
2926                               unsigned long arg)
2927 {
2928         struct inode *inode = file_inode(file);
2929         struct ll_inode_info *lli = ll_i2info(inode);
2930         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2931         struct obd_client_handle *och = NULL;
2932         __u64 open_flags = 0;
2933         bool lease_broken;
2934         fmode_t fmode;
2935         long rc;
2936         ENTRY;
2937
2938         switch (ioc->lil_mode) {
2939         case LL_LEASE_WRLCK:
2940                 if (!(file->f_mode & FMODE_WRITE))
2941                         RETURN(-EPERM);
2942                 fmode = FMODE_WRITE;
2943                 break;
2944         case LL_LEASE_RDLCK:
2945                 if (!(file->f_mode & FMODE_READ))
2946                         RETURN(-EPERM);
2947                 fmode = FMODE_READ;
2948                 break;
2949         case LL_LEASE_UNLCK:
2950                 RETURN(ll_file_unlock_lease(file, ioc, arg));
2951         default:
2952                 RETURN(-EINVAL);
2953         }
2954
2955         CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
2956
2957         /* apply for lease */
2958         if (ioc->lil_flags & LL_LEASE_RESYNC)
2959                 open_flags = MDS_OPEN_RESYNC;
2960         och = ll_lease_open(inode, file, fmode, open_flags);
2961         if (IS_ERR(och))
2962                 RETURN(PTR_ERR(och));
2963
2964         if (ioc->lil_flags & LL_LEASE_RESYNC) {
2965                 rc = ll_lease_file_resync(och, inode);
2966                 if (rc) {
2967                         ll_lease_close(och, inode, NULL);
2968                         RETURN(rc);
2969                 }
2970                 rc = ll_layout_refresh(inode, &fd->fd_layout_version);
2971                 if (rc) {
2972                         ll_lease_close(och, inode, NULL);
2973                         RETURN(rc);
2974                 }
2975         }
2976
2977         rc = 0;
2978         mutex_lock(&lli->lli_och_mutex);
2979         if (fd->fd_lease_och == NULL) {
2980                 fd->fd_lease_och = och;
2981                 och = NULL;
2982         }
2983         mutex_unlock(&lli->lli_och_mutex);
2984         if (och != NULL) {
2985                 /* impossible now that only excl is supported for now */
2986                 ll_lease_close(och, inode, &lease_broken);
2987                 rc = -EBUSY;
2988         }
2989         RETURN(rc);
2990 }
2991
2992 static long
2993 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2994 {
2995         struct inode            *inode = file_inode(file);
2996         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2997         int                      flags, rc;
2998         ENTRY;
2999
3000         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
3001                PFID(ll_inode2fid(inode)), inode, cmd);
3002         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
3003
3004         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
3005         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
3006                 RETURN(-ENOTTY);
3007
3008         switch(cmd) {
3009         case LL_IOC_GETFLAGS:
3010                 /* Get the current value of the file flags */
3011                 return put_user(fd->fd_flags, (int __user *)arg);
3012         case LL_IOC_SETFLAGS:
3013         case LL_IOC_CLRFLAGS:
3014                 /* Set or clear specific file flags */
3015                 /* XXX This probably needs checks to ensure the flags are
3016                  *     not abused, and to handle any flag side effects.
3017                  */
3018                 if (get_user(flags, (int __user *) arg))
3019                         RETURN(-EFAULT);
3020
3021                 if (cmd == LL_IOC_SETFLAGS) {
3022                         if ((flags & LL_FILE_IGNORE_LOCK) &&
3023                             !(file->f_flags & O_DIRECT)) {
3024                                 CERROR("%s: unable to disable locking on "
3025                                        "non-O_DIRECT file\n", current->comm);
3026                                 RETURN(-EINVAL);
3027                         }
3028
3029                         fd->fd_flags |= flags;
3030                 } else {
3031                         fd->fd_flags &= ~flags;
3032                 }
3033                 RETURN(0);
3034         case LL_IOC_LOV_SETSTRIPE:
3035         case LL_IOC_LOV_SETSTRIPE_NEW:
3036                 RETURN(ll_lov_setstripe(inode, file, (void __user *)arg));
3037         case LL_IOC_LOV_SETEA:
3038                 RETURN(ll_lov_setea(inode, file, (void __user *)arg));
3039         case LL_IOC_LOV_SWAP_LAYOUTS: {
3040                 struct file *file2;
3041                 struct lustre_swap_layouts lsl;
3042                 __u64 intent;
3043
3044                 if (copy_from_user(&lsl, (char __user *)arg,
3045                                    sizeof(struct lustre_swap_layouts)))
3046                         RETURN(-EFAULT);
3047
3048                 if ((file->f_flags & O_ACCMODE) == O_RDONLY)
3049                         RETURN(-EPERM);
3050
3051                 file2 = fget(lsl.sl_fd);
3052                 if (file2 == NULL)
3053                         RETURN(-EBADF);
3054
3055                 /* O_WRONLY or O_RDWR */
3056                 if ((file2->f_flags & O_ACCMODE) == O_RDONLY)
3057                         GOTO(out, rc = -EPERM);
3058
3059                 intent = lsl.sl_flags & INTENT_LAYOUTS_CLOSE;
3060                 if (intent) {
3061                         struct inode                    *inode2;
3062                         struct ll_inode_info            *lli;
3063                         struct obd_client_handle        *och = NULL;
3064
3065                         lli = ll_i2info(inode);
3066                         mutex_lock(&lli->lli_och_mutex);
3067                         if (fd->fd_lease_och != NULL) {
3068                                 och = fd->fd_lease_och;
3069                                 fd->fd_lease_och = NULL;
3070                         }
3071                         mutex_unlock(&lli->lli_och_mutex);
3072                         if (och == NULL)
3073                                 GOTO(out, rc = -ENOLCK);
3074                         inode2 = file_inode(file2);
3075                         rc = ll_swap_layouts_close(och, inode, inode2, intent);
3076                 } else {
3077                         rc = ll_swap_layouts(file, file2, &lsl);
3078                 }
3079 out:
3080                 fput(file2);
3081                 RETURN(rc);
3082         }
3083         case LL_IOC_LOV_GETSTRIPE:
3084         case LL_IOC_LOV_GETSTRIPE_NEW:
3085                 RETURN(ll_file_getstripe(inode, (void __user *)arg, 0));
3086         case FSFILT_IOC_GETFLAGS:
3087         case FSFILT_IOC_SETFLAGS:
3088                 RETURN(ll_iocontrol(inode, file, cmd, arg));
3089         case FSFILT_IOC_GETVERSION_OLD:
3090         case FSFILT_IOC_GETVERSION:
3091                 RETURN(put_user(inode->i_generation, (int __user *)arg));
3092         case LL_IOC_GROUP_LOCK:
3093                 RETURN(ll_get_grouplock(inode, file, arg));
3094         case LL_IOC_GROUP_UNLOCK:
3095                 RETURN(ll_put_grouplock(inode, file, arg));
3096         case IOC_OBD_STATFS:
3097                 RETURN(ll_obd_statfs(inode, (void __user *)arg));
3098
3099         /* We need to special case any other ioctls we want to handle,
3100          * to send them to the MDS/OST as appropriate and to properly
3101          * network encode the arg field.
3102         case FSFILT_IOC_SETVERSION_OLD:
3103         case FSFILT_IOC_SETVERSION:
3104         */
3105         case LL_IOC_FLUSHCTX:
3106                 RETURN(ll_flush_ctx(inode));
3107         case LL_IOC_PATH2FID: {
3108                 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
3109                                  sizeof(struct lu_fid)))
3110                         RETURN(-EFAULT);
3111
3112                 RETURN(0);
3113         }
3114         case LL_IOC_GETPARENT:
3115                 RETURN(ll_getparent(file, (struct getparent __user *)arg));
3116
3117         case OBD_IOC_FID2PATH:
3118                 RETURN(ll_fid2path(inode, (void __user *)arg));
3119         case LL_IOC_DATA_VERSION: {
3120                 struct ioc_data_version idv;
3121                 int rc;
3122
3123                 if (copy_from_user(&idv, (char __user *)arg, sizeof(idv)))
3124                         RETURN(-EFAULT);
3125
3126                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
3127                 rc = ll_ioc_data_version(inode, &idv);
3128
3129                 if (rc == 0 &&
3130                     copy_to_user((char __user *)arg, &idv, sizeof(idv)))
3131                         RETURN(-EFAULT);
3132
3133                 RETURN(rc);
3134         }
3135
3136         case LL_IOC_GET_MDTIDX: {
3137                 int mdtidx;
3138
3139                 mdtidx = ll_get_mdt_idx(inode);
3140                 if (mdtidx < 0)
3141                         RETURN(mdtidx);
3142
3143                 if (put_user((int)mdtidx, (int __user *)arg))
3144                         RETURN(-EFAULT);
3145
3146                 RETURN(0);
3147         }
3148         case OBD_IOC_GETDTNAME:
3149         case OBD_IOC_GETMDNAME:
3150                 RETURN(ll_get_obd_name(inode, cmd, arg));
3151         case LL_IOC_HSM_STATE_GET: {
3152                 struct md_op_data       *op_data;
3153                 struct hsm_user_state   *hus;
3154                 int                      rc;
3155
3156                 OBD_ALLOC_PTR(hus);
3157                 if (hus == NULL)
3158                         RETURN(-ENOMEM);
3159
3160                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3161                                              LUSTRE_OPC_ANY, hus);
3162                 if (IS_ERR(op_data)) {
3163                         OBD_FREE_PTR(hus);
3164                         RETURN(PTR_ERR(op_data));
3165                 }
3166
3167                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
3168                                    op_data, NULL);
3169
3170                 if (copy_to_user((void __user *)arg, hus, sizeof(*hus)))
3171                         rc = -EFAULT;
3172
3173                 ll_finish_md_op_data(op_data);
3174                 OBD_FREE_PTR(hus);
3175                 RETURN(rc);
3176         }
3177         case LL_IOC_HSM_STATE_SET: {
3178                 struct hsm_state_set    *hss;
3179                 int                      rc;
3180
3181                 OBD_ALLOC_PTR(hss);
3182                 if (hss == NULL)
3183                         RETURN(-ENOMEM);
3184
3185                 if (copy_from_user(hss, (char __user *)arg, sizeof(*hss))) {
3186                         OBD_FREE_PTR(hss);
3187                         RETURN(-EFAULT);
3188                 }
3189
3190                 rc = ll_hsm_state_set(inode, hss);
3191
3192                 OBD_FREE_PTR(hss);
3193                 RETURN(rc);
3194         }
3195         case LL_IOC_HSM_ACTION: {
3196                 struct md_op_data               *op_data;
3197                 struct hsm_current_action       *hca;
3198                 int                              rc;
3199
3200                 OBD_ALLOC_PTR(hca);
3201                 if (hca == NULL)
3202                         RETURN(-ENOMEM);
3203
3204                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3205                                              LUSTRE_OPC_ANY, hca);
3206                 if (IS_ERR(op_data)) {
3207                         OBD_FREE_PTR(hca);
3208                         RETURN(PTR_ERR(op_data));
3209                 }
3210
3211                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
3212                                    op_data, NULL);
3213
3214                 if (copy_to_user((char __user *)arg, hca, sizeof(*hca)))
3215                         rc = -EFAULT;
3216
3217                 ll_finish_md_op_data(op_data);
3218                 OBD_FREE_PTR(hca);
3219                 RETURN(rc);
3220         }
3221         case LL_IOC_SET_LEASE_OLD: {
3222                 struct ll_ioc_lease ioc = { .lil_mode = (__u32)arg };
3223
3224                 RETURN(ll_file_set_lease(file, &ioc, 0));
3225         }
3226         case LL_IOC_SET_LEASE: {
3227                 struct ll_ioc_lease ioc;
3228
3229                 if (copy_from_user(&ioc, (void __user *)arg, sizeof(ioc)))
3230                         RETURN(-EFAULT);
3231
3232                 RETURN(ll_file_set_lease(file, &ioc, arg));
3233         }
3234         case LL_IOC_GET_LEASE: {
3235                 struct ll_inode_info *lli = ll_i2info(inode);
3236                 struct ldlm_lock *lock = NULL;
3237                 fmode_t fmode = 0;
3238
3239                 mutex_lock(&lli->lli_och_mutex);
3240                 if (fd->fd_lease_och != NULL) {
3241                         struct obd_client_handle *och = fd->fd_lease_och;
3242
3243                         lock = ldlm_handle2lock(&och->och_lease_handle);
3244                         if (lock != NULL) {
3245                                 lock_res_and_lock(lock);
3246                                 if (!ldlm_is_cancel(lock))
3247                                         fmode = och->och_flags;
3248
3249                                 unlock_res_and_lock(lock);
3250                                 LDLM_LOCK_PUT(lock);
3251                         }
3252                 }
3253                 mutex_unlock(&lli->lli_och_mutex);
3254
3255                 RETURN(ll_lease_type_from_fmode(fmode));
3256         }
3257         case LL_IOC_HSM_IMPORT: {
3258                 struct hsm_user_import *hui;
3259
3260                 OBD_ALLOC_PTR(hui);
3261                 if (hui == NULL)
3262                         RETURN(-ENOMEM);
3263
3264                 if (copy_from_user(hui, (void __user *)arg, sizeof(*hui))) {
3265                         OBD_FREE_PTR(hui);
3266                         RETURN(-EFAULT);
3267                 }
3268
3269                 rc = ll_hsm_import(inode, file, hui);
3270
3271                 OBD_FREE_PTR(hui);
3272                 RETURN(rc);
3273         }
3274         case LL_IOC_FUTIMES_3: {
3275                 struct ll_futimes_3 lfu;
3276
3277                 if (copy_from_user(&lfu,
3278                                    (const struct ll_futimes_3 __user *)arg,
3279                                    sizeof(lfu)))
3280                         RETURN(-EFAULT);
3281
3282                 RETURN(ll_file_futimes_3(file, &lfu));
3283         }
3284         case LL_IOC_LADVISE: {
3285                 struct llapi_ladvise_hdr *k_ladvise_hdr;
3286                 struct llapi_ladvise_hdr __user *u_ladvise_hdr;
3287                 int i;
3288                 int num_advise;
3289                 int alloc_size = sizeof(*k_ladvise_hdr);
3290
3291                 rc = 0;
3292                 u_ladvise_hdr = (void __user *)arg;
3293                 OBD_ALLOC_PTR(k_ladvise_hdr);
3294                 if (k_ladvise_hdr == NULL)
3295                         RETURN(-ENOMEM);
3296
3297                 if (copy_from_user(k_ladvise_hdr, u_ladvise_hdr, alloc_size))
3298                         GOTO(out_ladvise, rc = -EFAULT);
3299
3300                 if (k_ladvise_hdr->lah_magic != LADVISE_MAGIC ||
3301                     k_ladvise_hdr->lah_count < 1)
3302                         GOTO(out_ladvise, rc = -EINVAL);
3303
3304                 num_advise = k_ladvise_hdr->lah_count;
3305                 if (num_advise >= LAH_COUNT_MAX)
3306                         GOTO(out_ladvise, rc = -EFBIG);
3307
3308                 OBD_FREE_PTR(k_ladvise_hdr);
3309                 alloc_size = offsetof(typeof(*k_ladvise_hdr),
3310                                       lah_advise[num_advise]);
3311                 OBD_ALLOC(k_ladvise_hdr, alloc_size);
3312                 if (k_ladvise_hdr == NULL)
3313                         RETURN(-ENOMEM);
3314
3315                 /*
3316                  * TODO: submit multiple advices to one server in a single RPC
3317                  */
3318                 if (copy_from_user(k_ladvise_hdr, u_ladvise_hdr, alloc_size))
3319                         GOTO(out_ladvise, rc = -EFAULT);
3320
3321                 for (i = 0; i < num_advise; i++) {
3322                         struct llapi_lu_ladvise *k_ladvise =
3323                                         &k_ladvise_hdr->lah_advise[i];
3324                         struct llapi_lu_ladvise __user *u_ladvise =
3325                                         &u_ladvise_hdr->lah_advise[i];
3326
3327                         rc = ll_ladvise_sanity(inode, k_ladvise);
3328                         if (rc)
3329                                 GOTO(out_ladvise, rc);
3330
3331                         switch (k_ladvise->lla_advice) {
3332                         case LU_LADVISE_LOCKNOEXPAND:
3333                                 rc = ll_lock_noexpand(file,
3334                                                k_ladvise->lla_peradvice_flags);
3335                                 GOTO(out_ladvise, rc);
3336                         case LU_LADVISE_LOCKAHEAD:
3337
3338                                 rc = ll_file_lock_ahead(file, k_ladvise);
3339
3340                                 if (rc < 0)
3341                                         GOTO(out_ladvise, rc);
3342
3343                                 if (put_user(rc,
3344                                              &u_ladvise->lla_lockahead_result))
3345                                         GOTO(out_ladvise, rc = -EFAULT);
3346                                 break;
3347                         default:
3348                                 rc = ll_ladvise(inode, file,
3349                                                 k_ladvise_hdr->lah_flags,
3350                                                 k_ladvise);
3351                                 if (rc)
3352                                         GOTO(out_ladvise, rc);
3353                                 break;
3354                         }
3355
3356                 }
3357
3358 out_ladvise:
3359                 OBD_FREE(k_ladvise_hdr, alloc_size);
3360                 RETURN(rc);
3361         }
3362         case LL_IOC_FLR_SET_MIRROR: {
3363                 /* mirror I/O must be direct to avoid polluting page cache
3364                  * by stale data. */
3365                 if (!(file->f_flags & O_DIRECT))
3366                         RETURN(-EINVAL);
3367
3368                 fd->fd_designated_mirror = (__u32)arg;
3369                 RETURN(0);
3370         }
3371         case LL_IOC_FSGETXATTR:
3372                 RETURN(ll_ioctl_fsgetxattr(inode, cmd, arg));
3373         case LL_IOC_FSSETXATTR:
3374                 RETURN(ll_ioctl_fssetxattr(inode, cmd, arg));
3375         case BLKSSZGET:
3376                 RETURN(put_user(PAGE_SIZE, (int __user *)arg));
3377         default:
3378                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
3379                                      (void __user *)arg));
3380         }
3381 }
3382
3383 #ifndef HAVE_FILE_LLSEEK_SIZE
3384 static inline loff_t
3385 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
3386 {
3387         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
3388                 return -EINVAL;
3389         if (offset > maxsize)
3390                 return -EINVAL;
3391
3392         if (offset != file->f_pos) {
3393                 file->f_pos = offset;
3394                 file->f_version = 0;
3395         }
3396         return offset;
3397 }
3398
3399 static loff_t
3400 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
3401                 loff_t maxsize, loff_t eof)
3402 {
3403         struct inode *inode = file_inode(file);
3404
3405         switch (origin) {
3406         case SEEK_END:
3407                 offset += eof;
3408                 break;
3409         case SEEK_CUR:
3410                 /*
3411                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
3412                  * position-querying operation.  Avoid rewriting the "same"
3413                  * f_pos value back to the file because a concurrent read(),
3414                  * write() or lseek() might have altered it
3415                  */
3416                 if (offset == 0)
3417                         return file->f_pos;
3418                 /*
3419                  * f_lock protects against read/modify/write race with other
3420                  * SEEK_CURs. Note that parallel writes and reads behave
3421                  * like SEEK_SET.
3422                  */
3423                 inode_lock(inode);
3424                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
3425                 inode_unlock(inode);
3426                 return offset;
3427         case SEEK_DATA:
3428                 /*
3429                  * In the generic case the entire file is data, so as long as
3430                  * offset isn't at the end of the file then the offset is data.
3431                  */
3432                 if (offset >= eof)
3433                         return -ENXIO;
3434                 break;
3435         case SEEK_HOLE:
3436                 /*
3437                  * There is a virtual hole at the end of the file, so as long as
3438                  * offset isn't i_size or larger, return i_size.
3439                  */
3440                 if (offset >= eof)
3441                         return -ENXIO;
3442                 offset = eof;
3443                 break;
3444         }
3445
3446         return llseek_execute(file, offset, maxsize);
3447 }
3448 #endif
3449
3450 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
3451 {
3452         struct inode *inode = file_inode(file);
3453         loff_t retval, eof = 0;
3454
3455         ENTRY;
3456         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
3457                            (origin == SEEK_CUR) ? file->f_pos : 0);
3458         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
3459                PFID(ll_inode2fid(inode)), inode, retval, retval,
3460                origin);
3461         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
3462
3463         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
3464                 retval = ll_glimpse_size(inode);
3465                 if (retval != 0)
3466                         RETURN(retval);
3467                 eof = i_size_read(inode);
3468         }
3469
3470         retval = ll_generic_file_llseek_size(file, offset, origin,
3471                                           ll_file_maxbytes(inode), eof);
3472         RETURN(retval);
3473 }
3474
3475 static int ll_flush(struct file *file, fl_owner_t id)
3476 {
3477         struct inode *inode = file_inode(file);
3478         struct ll_inode_info *lli = ll_i2info(inode);
3479         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
3480         int rc, err;
3481
3482         LASSERT(!S_ISDIR(inode->i_mode));
3483
3484         /* catch async errors that were recorded back when async writeback
3485          * failed for pages in this mapping. */
3486         rc = lli->lli_async_rc;
3487         lli->lli_async_rc = 0;
3488         if (lli->lli_clob != NULL) {
3489                 err = lov_read_and_clear_async_rc(lli->lli_clob);
3490                 if (rc == 0)
3491                         rc = err;
3492         }
3493
3494         /* The application has been told write failure already.
3495          * Do not report failure again. */
3496         if (fd->fd_write_failed)
3497                 return 0;
3498         return rc ? -EIO : 0;
3499 }
3500
3501 /**
3502  * Called to make sure a portion of file has been written out.
3503  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
3504  *
3505  * Return how many pages have been written.
3506  */
3507 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
3508                        enum cl_fsync_mode mode, int ignore_layout)
3509 {
3510         struct lu_env *env;
3511         struct cl_io *io;
3512         struct cl_fsync_io *fio;
3513         int result;
3514         __u16 refcheck;
3515         ENTRY;
3516
3517         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
3518             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
3519                 RETURN(-EINVAL);
3520
3521         env = cl_env_get(&refcheck);
3522         if (IS_ERR(env))
3523                 RETURN(PTR_ERR(env));
3524
3525         io = vvp_env_thread_io(env);
3526         io->ci_obj = ll_i2info(inode)->lli_clob;
3527         io->ci_ignore_layout = ignore_layout;
3528
3529         /* initialize parameters for sync */
3530         fio = &io->u.ci_fsync;
3531         fio->fi_start = start;
3532         fio->fi_end = end;
3533         fio->fi_fid = ll_inode2fid(inode);
3534         fio->fi_mode = mode;
3535         fio->fi_nr_written = 0;
3536
3537         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
3538                 result = cl_io_loop(env, io);
3539         else
3540                 result = io->ci_result;
3541         if (result == 0)
3542                 result = fio->fi_nr_written;
3543         cl_io_fini(env, io);
3544         cl_env_put(env, &refcheck);
3545
3546         RETURN(result);
3547 }
3548
3549 /*
3550  * When dentry is provided (the 'else' case), file_dentry() may be
3551  * null and dentry must be used directly rather than pulled from
3552  * file_dentry() as is done otherwise.
3553  */
3554
3555 #ifdef HAVE_FILE_FSYNC_4ARGS
3556 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
3557 {
3558         struct dentry *dentry = file_dentry(file);
3559         bool lock_inode;
3560 #elif defined(HAVE_FILE_FSYNC_2ARGS)
3561 int ll_fsync(struct file *file, int datasync)
3562 {
3563         struct dentry *dentry = file_dentry(file);
3564         loff_t start = 0;
3565         loff_t end = LLONG_MAX;
3566 #else
3567 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
3568 {
3569         loff_t start = 0;
3570         loff_t end = LLONG_MAX;
3571 #endif
3572         struct inode *inode = dentry->d_inode;
3573         struct ll_inode_info *lli = ll_i2info(inode);
3574         struct ptlrpc_request *req;
3575         int rc, err;
3576         ENTRY;
3577
3578         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
3579                PFID(ll_inode2fid(inode)), inode);
3580         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
3581
3582 #ifdef HAVE_FILE_FSYNC_4ARGS
3583         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
3584         lock_inode = !lli->lli_inode_locked;
3585         if (lock_inode)
3586                 inode_lock(inode);
3587 #else
3588         /* fsync's caller has already called _fdata{sync,write}, we want
3589          * that IO to finish before calling the osc and mdc sync methods */
3590         rc = filemap_fdatawait(inode->i_mapping);
3591 #endif
3592
3593         /* catch async errors that were recorded back when async writeback
3594          * failed for pages in this mapping. */
3595         if (!S_ISDIR(inode->i_mode)) {
3596                 err = lli->lli_async_rc;
3597                 lli->lli_async_rc = 0;
3598                 if (rc == 0)
3599                         rc = err;
3600                 if (lli->lli_clob != NULL) {
3601                         err = lov_read_and_clear_async_rc(lli->lli_clob);
3602                         if (rc == 0)
3603                                 rc = err;
3604                 }
3605         }
3606
3607         err = md_fsync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), &req);
3608         if (!rc)
3609                 rc = err;
3610         if (!err)
3611                 ptlrpc_req_finished(req);
3612
3613         if (S_ISREG(inode->i_mode)) {
3614                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
3615
3616                 err = cl_sync_file_range(inode, start, end, CL_FSYNC_ALL, 0);
3617                 if (rc == 0 && err < 0)
3618                         rc = err;
3619                 if (rc < 0)
3620                         fd->fd_write_failed = true;
3621                 else
3622                         fd->fd_write_failed = false;
3623         }
3624
3625 #ifdef HAVE_FILE_FSYNC_4ARGS
3626         if (lock_inode)
3627                 inode_unlock(inode);
3628 #endif
3629         RETURN(rc);
3630 }
3631
3632 static int
3633 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
3634 {
3635         struct inode *inode = file_inode(file);
3636         struct ll_sb_info *sbi = ll_i2sbi(inode);
3637         struct ldlm_enqueue_info einfo = {
3638                 .ei_type        = LDLM_FLOCK,
3639                 .ei_cb_cp       = ldlm_flock_completion_ast,
3640                 .ei_cbdata      = file_lock,
3641         };
3642         struct md_op_data *op_data;
3643         struct lustre_handle lockh = { 0 };
3644         union ldlm_policy_data flock = { { 0 } };
3645         int fl_type = file_lock->fl_type;
3646         __u64 flags = 0;
3647         int rc;
3648         int rc2 = 0;
3649         ENTRY;
3650
3651         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
3652                PFID(ll_inode2fid(inode)), file_lock);
3653
3654         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
3655
3656         if (file_lock->fl_flags & FL_FLOCK) {
3657                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
3658                 /* flocks are whole-file locks */
3659                 flock.l_flock.end = OFFSET_MAX;
3660                 /* For flocks owner is determined by the local file desctiptor*/
3661                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
3662         } else if (file_lock->fl_flags & FL_POSIX) {
3663                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
3664                 flock.l_flock.start = file_lock->fl_start;
3665                 flock.l_flock.end = file_lock->fl_end;
3666         } else {
3667                 RETURN(-EINVAL);
3668         }
3669         flock.l_flock.pid = file_lock->fl_pid;
3670
3671         /* Somewhat ugly workaround for svc lockd.
3672          * lockd installs custom fl_lmops->lm_compare_owner that checks
3673          * for the fl_owner to be the same (which it always is on local node
3674          * I guess between lockd processes) and then compares pid.
3675          * As such we assign pid to the owner field to make it all work,
3676          * conflict with normal locks is unlikely since pid space and
3677          * pointer space for current->files are not intersecting */
3678         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
3679                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
3680
3681         switch (fl_type) {
3682         case F_RDLCK:
3683                 einfo.ei_mode = LCK_PR;
3684                 break;
3685         case F_UNLCK:
3686                 /* An unlock request may or may not have any relation to
3687                  * existing locks so we may not be able to pass a lock handle
3688                  * via a normal ldlm_lock_cancel() request. The request may even
3689                  * unlock a byte range in the middle of an existing lock. In
3690                  * order to process an unlock request we need all of the same
3691                  * information that is given with a normal read or write record
3692                  * lock request. To avoid creating another ldlm unlock (cancel)
3693                  * message we'll treat a LCK_NL flock request as an unlock. */
3694                 einfo.ei_mode = LCK_NL;
3695                 break;
3696         case F_WRLCK:
3697                 einfo.ei_mode = LCK_PW;
3698                 break;
3699         default:
3700                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n", fl_type);
3701                 RETURN (-ENOTSUPP);
3702         }
3703
3704         switch (cmd) {
3705         case F_SETLKW:
3706 #ifdef F_SETLKW64
3707         case F_SETLKW64:
3708 #endif
3709                 flags = 0;
3710                 break;
3711         case F_SETLK:
3712 #ifdef F_SETLK64
3713         case F_SETLK64:
3714 #endif
3715                 flags = LDLM_FL_BLOCK_NOWAIT;
3716                 break;
3717         case F_GETLK:
3718 #ifdef F_GETLK64
3719         case F_GETLK64:
3720 #endif
3721                 flags = LDLM_FL_TEST_LOCK;
3722                 break;
3723         default:
3724                 CERROR("unknown fcntl lock command: %d\n", cmd);
3725                 RETURN (-EINVAL);
3726         }
3727
3728         /* Save the old mode so that if the mode in the lock changes we
3729          * can decrement the appropriate reader or writer refcount. */
3730         file_lock->fl_type = einfo.ei_mode;
3731
3732         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3733                                      LUSTRE_OPC_ANY, NULL);
3734         if (IS_ERR(op_data))
3735                 RETURN(PTR_ERR(op_data));
3736
3737         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags=%#llx, mode=%u, "
3738                "start=%llu, end=%llu\n", PFID(ll_inode2fid(inode)),
3739                flock.l_flock.pid, flags, einfo.ei_mode,
3740                flock.l_flock.start, flock.l_flock.end);
3741
3742         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data, &lockh,
3743                         flags);
3744
3745         /* Restore the file lock type if not TEST lock. */
3746         if (!(flags & LDLM_FL_TEST_LOCK))
3747                 file_lock->fl_type = fl_type;
3748
3749 #ifdef HAVE_LOCKS_LOCK_FILE_WAIT
3750         if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
3751             !(flags & LDLM_FL_TEST_LOCK))
3752                 rc2  = locks_lock_file_wait(file, file_lock);
3753 #else
3754         if ((file_lock->fl_flags & FL_FLOCK) &&
3755             (rc == 0 || file_lock->fl_type == F_UNLCK))
3756                 rc2  = flock_lock_file_wait(file, file_lock);
3757         if ((file_lock->fl_flags & FL_POSIX) &&
3758             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
3759             !(flags & LDLM_FL_TEST_LOCK))
3760                 rc2  = posix_lock_file_wait(file, file_lock);
3761 #endif /* HAVE_LOCKS_LOCK_FILE_WAIT */
3762
3763         if (rc2 && file_lock->fl_type != F_UNLCK) {
3764                 einfo.ei_mode = LCK_NL;
3765                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, op_data,
3766                            &lockh, flags);
3767                 rc = rc2;
3768         }
3769
3770         ll_finish_md_op_data(op_data);
3771
3772         RETURN(rc);
3773 }
3774
3775 int ll_get_fid_by_name(struct inode *parent, const char *name,
3776                        int namelen, struct lu_fid *fid,
3777                        struct inode **inode)
3778 {
3779         struct md_op_data       *op_data = NULL;
3780         struct mdt_body         *body;
3781         struct ptlrpc_request   *req;
3782         int                     rc;
3783         ENTRY;
3784
3785         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
3786                                      LUSTRE_OPC_ANY, NULL);
3787         if (IS_ERR(op_data))
3788                 RETURN(PTR_ERR(op_data));
3789
3790         op_data->op_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
3791         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
3792         ll_finish_md_op_data(op_data);
3793         if (rc < 0)
3794                 RETURN(rc);
3795
3796         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3797         if (body == NULL)
3798                 GOTO(out_req, rc = -EFAULT);
3799         if (fid != NULL)
3800                 *fid = body->mbo_fid1;
3801
3802         if (inode != NULL)
3803                 rc = ll_prep_inode(inode, req, parent->i_sb, NULL);
3804 out_req:
3805         ptlrpc_req_finished(req);
3806         RETURN(rc);
3807 }
3808
3809 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
3810                const char *name, int namelen)
3811 {
3812         struct dentry         *dchild = NULL;
3813         struct inode          *child_inode = NULL;
3814         struct md_op_data     *op_data;
3815         struct ptlrpc_request *request = NULL;
3816         struct obd_client_handle *och = NULL;
3817         struct qstr           qstr;
3818         struct mdt_body         *body;
3819         int                    rc;
3820         __u64                   data_version = 0;
3821         ENTRY;
3822
3823         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
3824                name, PFID(ll_inode2fid(parent)), mdtidx);
3825
3826         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
3827                                      0, LUSTRE_OPC_ANY, NULL);
3828         if (IS_ERR(op_data))
3829                 RETURN(PTR_ERR(op_data));
3830
3831         /* Get child FID first */
3832         qstr.hash = ll_full_name_hash(file_dentry(file), name, namelen);
3833         qstr.name = name;
3834         qstr.len = namelen;
3835         dchild = d_lookup(file_dentry(file), &qstr);
3836         if (dchild != NULL) {
3837                 if (dchild->d_inode != NULL)
3838                         child_inode = igrab(dchild->d_inode);
3839                 dput(dchild);
3840         }
3841
3842         if (child_inode == NULL) {
3843                 rc = ll_get_fid_by_name(parent, name, namelen,
3844                                         &op_data->op_fid3, &child_inode);
3845                 if (rc != 0)
3846                         GOTO(out_free, rc);
3847         }
3848
3849         if (child_inode == NULL)
3850                 GOTO(out_free, rc = -EINVAL);
3851
3852         /*
3853          * lfs migrate command needs to be blocked on the client
3854          * by checking the migrate FID against the FID of the
3855          * filesystem root.
3856          */
3857         if (child_inode == parent->i_sb->s_root->d_inode)
3858                 GOTO(out_iput, rc = -EINVAL);
3859
3860         inode_lock(child_inode);
3861         op_data->op_fid3 = *ll_inode2fid(child_inode);
3862         if (!fid_is_sane(&op_data->op_fid3)) {
3863                 CERROR("%s: migrate %s, but FID "DFID" is insane\n",
3864                        ll_get_fsname(parent->i_sb, NULL, 0), name,
3865                        PFID(&op_data->op_fid3));
3866                 GOTO(out_unlock, rc = -EINVAL);
3867         }
3868
3869         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
3870         if (rc < 0)
3871                 GOTO(out_unlock, rc);
3872
3873         if (rc == mdtidx) {
3874                 CDEBUG(D_INFO, "%s: "DFID" is already on MDT%04x\n", name,
3875                        PFID(&op_data->op_fid3), mdtidx);
3876                 GOTO(out_unlock, rc = 0);
3877         }
3878 again:
3879         if (S_ISREG(child_inode->i_mode)) {
3880                 och = ll_lease_open(child_inode, NULL, FMODE_WRITE, 0);
3881                 if (IS_ERR(och)) {
3882                         rc = PTR_ERR(och);
3883                         och = NULL;
3884                         GOTO(out_unlock, rc);
3885                 }
3886
3887                 rc = ll_data_version(child_inode, &data_version,
3888                                      LL_DV_WR_FLUSH);
3889                 if (rc != 0)
3890                         GOTO(out_close, rc);
3891
3892                 op_data->op_handle = och->och_fh;
3893                 op_data->op_data = och->och_mod;
3894                 op_data->op_data_version = data_version;
3895                 op_data->op_lease_handle = och->och_lease_handle;
3896                 op_data->op_bias |= MDS_RENAME_MIGRATE;
3897         }
3898
3899         op_data->op_mds = mdtidx;
3900         op_data->op_cli_flags = CLI_MIGRATE;
3901         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3902                        namelen, name, namelen, &request);
3903         if (rc == 0) {
3904                 LASSERT(request != NULL);
3905                 ll_update_times(request, parent);
3906
3907                 body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
3908                 LASSERT(body != NULL);
3909
3910                 /* If the server does release layout lock, then we cleanup
3911                  * the client och here, otherwise release it in out_close: */
3912                 if (och != NULL &&
3913                     body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED) {
3914                         obd_mod_put(och->och_mod);
3915                         md_clear_open_replay_data(ll_i2sbi(parent)->ll_md_exp,
3916                                                   och);
3917                         och->och_fh.cookie = DEAD_HANDLE_MAGIC;
3918                         OBD_FREE_PTR(och);
3919                         och = NULL;
3920                 }
3921         }
3922
3923         if (request != NULL) {
3924                 ptlrpc_req_finished(request);
3925                 request = NULL;
3926         }
3927
3928         /* Try again if the file layout has changed. */
3929         if (rc == -EAGAIN && S_ISREG(child_inode->i_mode))
3930                 goto again;
3931
3932 out_close:
3933         if (och != NULL) /* close the file */
3934                 ll_lease_close(och, child_inode, NULL);
3935         if (rc == 0)
3936                 clear_nlink(child_inode);
3937 out_unlock:
3938         inode_unlock(child_inode);
3939 out_iput:
3940         iput(child_inode);
3941 out_free:
3942         ll_finish_md_op_data(op_data);
3943         RETURN(rc);
3944 }
3945
3946 static int
3947 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3948 {
3949         ENTRY;
3950
3951         RETURN(-ENOSYS);
3952 }
3953
3954 /**
3955  * test if some locks matching bits and l_req_mode are acquired
3956  * - bits can be in different locks
3957  * - if found clear the common lock bits in *bits
3958  * - the bits not found, are kept in *bits
3959  * \param inode [IN]
3960  * \param bits [IN] searched lock bits [IN]
3961  * \param l_req_mode [IN] searched lock mode
3962  * \retval boolean, true iff all bits are found
3963  */
3964 int ll_have_md_lock(struct inode *inode, __u64 *bits, enum ldlm_mode l_req_mode)
3965 {
3966         struct lustre_handle lockh;
3967         union ldlm_policy_data policy;
3968         enum ldlm_mode mode = (l_req_mode == LCK_MINMODE) ?
3969                               (LCK_CR | LCK_CW | LCK_PR | LCK_PW) : l_req_mode;
3970         struct lu_fid *fid;
3971         __u64 flags;
3972         int i;
3973         ENTRY;
3974
3975         if (!inode)
3976                RETURN(0);
3977
3978         fid = &ll_i2info(inode)->lli_fid;
3979         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3980                ldlm_lockname[mode]);
3981
3982         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3983         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3984                 policy.l_inodebits.bits = *bits & (1 << i);
3985                 if (policy.l_inodebits.bits == 0)
3986                         continue;
3987
3988                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3989                                   &policy, mode, &lockh)) {
3990                         struct ldlm_lock *lock;
3991
3992                         lock = ldlm_handle2lock(&lockh);
3993                         if (lock) {
3994                                 *bits &=
3995                                       ~(lock->l_policy_data.l_inodebits.bits);
3996                                 LDLM_LOCK_PUT(lock);
3997                         } else {
3998                                 *bits &= ~policy.l_inodebits.bits;
3999                         }
4000                 }
4001         }
4002         RETURN(*bits == 0);
4003 }
4004
4005 enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
4006                                struct lustre_handle *lockh, __u64 flags,
4007                                enum ldlm_mode mode)
4008 {
4009         union ldlm_policy_data policy = { .l_inodebits = { bits } };
4010         struct lu_fid *fid;
4011         enum ldlm_mode rc;
4012         ENTRY;
4013
4014         fid = &ll_i2info(inode)->lli_fid;
4015         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
4016
4017         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
4018                            fid, LDLM_IBITS, &policy, mode, lockh);
4019
4020         RETURN(rc);
4021 }
4022
4023 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
4024 {
4025         /* Already unlinked. Just update nlink and return success */
4026         if (rc == -ENOENT) {
4027                 clear_nlink(inode);
4028                 /* If it is striped directory, and there is bad stripe
4029                  * Let's revalidate the dentry again, instead of returning
4030                  * error */
4031                 if (S_ISDIR(inode->i_mode) &&
4032                     ll_i2info(inode)->lli_lsm_md != NULL)
4033                         return 0;
4034
4035                 /* This path cannot be hit for regular files unless in
4036                  * case of obscure races, so no need to to validate
4037                  * size. */
4038                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
4039                         return 0;
4040         } else if (rc != 0) {
4041                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
4042                              "%s: revalidate FID "DFID" error: rc = %d\n",
4043                              ll_get_fsname(inode->i_sb, NULL, 0),
4044                              PFID(ll_inode2fid(inode)), rc);
4045         }
4046
4047         return rc;
4048 }
4049
4050 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
4051 {
4052         struct inode *inode = dentry->d_inode;
4053         struct ptlrpc_request *req = NULL;
4054         struct obd_export *exp;
4055         int rc = 0;
4056         ENTRY;
4057
4058         LASSERT(inode != NULL);
4059
4060         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
4061                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
4062
4063         exp = ll_i2mdexp(inode);
4064
4065         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
4066          *      But under CMD case, it caused some lock issues, should be fixed
4067          *      with new CMD ibits lock. See bug 12718 */
4068         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
4069                 struct lookup_intent oit = { .it_op = IT_GETATTR };
4070                 struct md_op_data *op_data;
4071
4072                 if (ibits == MDS_INODELOCK_LOOKUP)
4073                         oit.it_op = IT_LOOKUP;
4074
4075                 /* Call getattr by fid, so do not provide name at all. */
4076                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
4077                                              dentry->d_inode, NULL, 0, 0,
4078                                              LUSTRE_OPC_ANY, NULL);
4079                 if (IS_ERR(op_data))
4080                         RETURN(PTR_ERR(op_data));
4081
4082                 rc = md_intent_lock(exp, op_data, &oit, &req,
4083                                     &ll_md_blocking_ast, 0);
4084                 ll_finish_md_op_data(op_data);
4085                 if (rc < 0) {
4086                         rc = ll_inode_revalidate_fini(inode, rc);
4087                         GOTO (out, rc);
4088                 }
4089
4090                 rc = ll_revalidate_it_finish(req, &oit, dentry);
4091                 if (rc != 0) {
4092                         ll_intent_release(&oit);
4093                         GOTO(out, rc);
4094                 }
4095
4096                 /* Unlinked? Unhash dentry, so it is not picked up later by
4097                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
4098                    here to preserve get_cwd functionality on 2.6.
4099                    Bug 10503 */
4100                 if (!dentry->d_inode->i_nlink) {
4101                         ll_lock_dcache(inode);
4102                         d_lustre_invalidate(dentry, 0);
4103                         ll_unlock_dcache(inode);
4104                 }
4105
4106                 ll_lookup_finish_locks(&oit, dentry);
4107         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
4108                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
4109                 u64 valid = OBD_MD_FLGETATTR;
4110                 struct md_op_data *op_data;
4111                 int ealen = 0;
4112
4113                 if (S_ISREG(inode->i_mode)) {
4114                         rc = ll_get_default_mdsize(sbi, &ealen);
4115                         if (rc)
4116                                 RETURN(rc);
4117                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
4118                 }
4119
4120                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
4121                                              0, ealen, LUSTRE_OPC_ANY,
4122                                              NULL);
4123                 if (IS_ERR(op_data))
4124                         RETURN(PTR_ERR(op_data));
4125
4126                 op_data->op_valid = valid;
4127                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
4128                 ll_finish_md_op_data(op_data);
4129                 if (rc) {
4130                         rc = ll_inode_revalidate_fini(inode, rc);
4131                         RETURN(rc);
4132                 }
4133
4134                 rc = ll_prep_inode(&inode, req, NULL, NULL);
4135         }
4136 out:
4137         ptlrpc_req_finished(req);
4138         return rc;
4139 }
4140
4141 static int ll_merge_md_attr(struct inode *inode)
4142 {
4143         struct cl_attr attr = { 0 };
4144         int rc;
4145
4146         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
4147         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
4148                            &attr, ll_md_blocking_ast);
4149         if (rc != 0)
4150                 RETURN(rc);
4151
4152         set_nlink(inode, attr.cat_nlink);
4153         inode->i_blocks = attr.cat_blocks;
4154         i_size_write(inode, attr.cat_size);
4155
4156         ll_i2info(inode)->lli_atime = attr.cat_atime;
4157         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
4158         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
4159
4160         RETURN(0);
4161 }
4162
4163 static int
4164 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
4165 {
4166         struct inode    *inode = dentry->d_inode;
4167         int              rc;
4168         ENTRY;
4169
4170         rc = __ll_inode_revalidate(dentry, ibits);
4171         if (rc != 0)
4172                 RETURN(rc);
4173
4174         /* if object isn't regular file, don't validate size */
4175         if (!S_ISREG(inode->i_mode)) {
4176                 if (S_ISDIR(inode->i_mode) &&
4177                     ll_i2info(inode)->lli_lsm_md != NULL) {
4178                         rc = ll_merge_md_attr(inode);
4179                         if (rc != 0)
4180                                 RETURN(rc);
4181                 }
4182
4183                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_atime;
4184                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_mtime;
4185                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_ctime;
4186         } else {
4187                 /* In case of restore, the MDT has the right size and has
4188                  * already send it back without granting the layout lock,
4189                  * inode is up-to-date so glimpse is useless.
4190                  * Also to glimpse we need the layout, in case of a running
4191                  * restore the MDT holds the layout lock so the glimpse will
4192                  * block up to the end of restore (getattr will block)
4193                  */
4194                 if (!ll_file_test_flag(ll_i2info(inode), LLIF_FILE_RESTORING))
4195                         rc = ll_glimpse_size(inode);
4196         }
4197         RETURN(rc);
4198 }
4199
4200 static inline dev_t ll_compat_encode_dev(dev_t dev)
4201 {
4202         /* The compat_sys_*stat*() syscalls will fail unless the
4203          * device majors and minors are both less than 256. Note that
4204          * the value returned here will be passed through
4205          * old_encode_dev() in cp_compat_stat(). And so we are not
4206          * trying to return a valid compat (u16) device number, just
4207          * one that will pass the old_valid_dev() check. */
4208
4209         return MKDEV(MAJOR(dev) & 0xff, MINOR(dev) & 0xff);
4210 }
4211
4212 #ifdef HAVE_INODEOPS_ENHANCED_GETATTR
4213 int ll_getattr(const struct path *path, struct kstat *stat,
4214                u32 request_mask, unsigned int flags)
4215
4216 {
4217         struct dentry *de = path->dentry;
4218 #else
4219 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
4220 {
4221 #endif
4222         struct inode *inode = de->d_inode;
4223         struct ll_sb_info *sbi = ll_i2sbi(inode);
4224         struct ll_inode_info *lli = ll_i2info(inode);
4225         int res = 0;
4226
4227         res = ll_inode_revalidate(de, MDS_INODELOCK_UPDATE |
4228                                       MDS_INODELOCK_LOOKUP);
4229         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
4230
4231         if (res)
4232                 return res;
4233
4234         OBD_FAIL_TIMEOUT(OBD_FAIL_GETATTR_DELAY, 30);
4235
4236         if (ll_need_32bit_api(sbi)) {
4237                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
4238                 stat->dev = ll_compat_encode_dev(inode->i_sb->s_dev);
4239                 stat->rdev = ll_compat_encode_dev(inode->i_rdev);
4240         } else {
4241                 stat->ino = inode->i_ino;
4242                 stat->dev = inode->i_sb->s_dev;
4243                 stat->rdev = inode->i_rdev;
4244         }
4245
4246         stat->mode = inode->i_mode;
4247         stat->uid = inode->i_uid;
4248         stat->gid = inode->i_gid;
4249         stat->atime = inode->i_atime;
4250         stat->mtime = inode->i_mtime;
4251         stat->ctime = inode->i_ctime;
4252         stat->blksize = sbi->ll_stat_blksize ?: 1 << inode->i_blkbits;
4253
4254         stat->nlink = inode->i_nlink;
4255         stat->size = i_size_read(inode);
4256         stat->blocks = inode->i_blocks;
4257
4258         return 0;
4259 }
4260
4261 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
4262                      __u64 start, __u64 len)
4263 {
4264         int             rc;
4265         size_t          num_bytes;
4266         struct fiemap   *fiemap;
4267         unsigned int    extent_count = fieinfo->fi_extents_max;
4268
4269         num_bytes = sizeof(*fiemap) + (extent_count *
4270                                        sizeof(struct fiemap_extent));
4271         OBD_ALLOC_LARGE(fiemap, num_bytes);
4272
4273         if (fiemap == NULL)
4274                 RETURN(-ENOMEM);
4275
4276         fiemap->fm_flags = fieinfo->fi_flags;
4277         fiemap->fm_extent_count = fieinfo->fi_extents_max;
4278         fiemap->fm_start = start;
4279         fiemap->fm_length = len;
4280         if (extent_count > 0 &&
4281             copy_from_user(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
4282                            sizeof(struct fiemap_extent)) != 0)
4283                 GOTO(out, rc = -EFAULT);
4284
4285         rc = ll_do_fiemap(inode, fiemap, num_bytes);
4286
4287         fieinfo->fi_flags = fiemap->fm_flags;
4288         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
4289         if (extent_count > 0 &&
4290             copy_to_user(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
4291                          fiemap->fm_mapped_extents *
4292                          sizeof(struct fiemap_extent)) != 0)
4293                 GOTO(out, rc = -EFAULT);
4294 out:
4295         OBD_FREE_LARGE(fiemap, num_bytes);
4296         return rc;
4297 }
4298
4299 struct posix_acl *ll_get_acl(struct inode *inode, int type)
4300 {
4301         struct ll_inode_info *lli = ll_i2info(inode);
4302         struct posix_acl *acl = NULL;
4303         ENTRY;
4304
4305         spin_lock(&lli->lli_lock);
4306         /* VFS' acl_permission_check->check_acl will release the refcount */
4307         acl = posix_acl_dup(lli->lli_posix_acl);
4308         spin_unlock(&lli->lli_lock);
4309
4310         RETURN(acl);
4311 }
4312
4313 #ifdef HAVE_IOP_SET_ACL
4314 #ifdef CONFIG_FS_POSIX_ACL
4315 int ll_set_acl(struct inode *inode, struct posix_acl *acl, int type)
4316 {
4317         const char *name = NULL;
4318         char *value = NULL;
4319         size_t size = 0;
4320         int rc = 0;
4321         ENTRY;
4322
4323         switch (type) {
4324         case ACL_TYPE_ACCESS:
4325                 if (acl) {
4326                         rc = posix_acl_update_mode(inode, &inode->i_mode, &acl);
4327                         if (rc)
4328                                 GOTO(out, rc);
4329                 }
4330                 name = XATTR_NAME_POSIX_ACL_ACCESS;
4331                 break;
4332         case ACL_TYPE_DEFAULT:
4333                 if (!S_ISDIR(inode->i_mode))
4334                         GOTO(out, rc = acl ? -EACCES : 0);
4335                 name = XATTR_NAME_POSIX_ACL_DEFAULT;
4336                 break;
4337         default:
4338                 GOTO(out, rc = -EINVAL);
4339         }
4340
4341         if (acl) {
4342                 size = posix_acl_xattr_size(acl->a_count);
4343                 value = kmalloc(size, GFP_NOFS);
4344                 if (value == NULL)
4345                         GOTO(out, rc = -ENOMEM);
4346
4347                 rc = posix_acl_to_xattr(&init_user_ns, acl, value, size);
4348                 if (rc < 0)
4349                         GOTO(out_free, rc);
4350         }
4351
4352         /* dentry is only used for *.lov attributes so it's safe to be NULL */
4353         rc = __vfs_setxattr(NULL, inode, name, value, size, XATTR_CREATE);
4354 out_free:
4355         kfree(value);
4356 out:
4357         if (!rc)
4358                 set_cached_acl(inode, type, acl);
4359         else
4360                 forget_cached_acl(inode, type);
4361         RETURN(rc);
4362 }
4363 #endif /* CONFIG_FS_POSIX_ACL */
4364 #endif /* HAVE_IOP_SET_ACL */
4365
4366 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
4367 static int
4368 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
4369 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
4370 # else
4371 ll_check_acl(struct inode *inode, int mask)
4372 # endif
4373 {
4374 # ifdef CONFIG_FS_POSIX_ACL
4375         struct posix_acl *acl;
4376         int rc;
4377         ENTRY;
4378
4379 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
4380         if (flags & IPERM_FLAG_RCU)
4381                 return -ECHILD;
4382 #  endif
4383         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
4384
4385         if (!acl)
4386                 RETURN(-EAGAIN);
4387
4388         rc = posix_acl_permission(inode, acl, mask);
4389         posix_acl_release(acl);
4390
4391         RETURN(rc);
4392 # else /* !CONFIG_FS_POSIX_ACL */
4393         return -EAGAIN;
4394 # endif /* CONFIG_FS_POSIX_ACL */
4395 }
4396 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
4397
4398 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
4399 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
4400 #else
4401 # ifdef HAVE_INODE_PERMISION_2ARGS
4402 int ll_inode_permission(struct inode *inode, int mask)
4403 # else
4404 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
4405 # endif
4406 #endif
4407 {
4408         int rc = 0;
4409         struct ll_sb_info *sbi;
4410         struct root_squash_info *squash;
4411         struct cred *cred = NULL;
4412         const struct cred *old_cred = NULL;
4413         cfs_cap_t cap;
4414         bool squash_id = false;
4415         ENTRY;
4416
4417 #ifdef MAY_NOT_BLOCK
4418         if (mask & MAY_NOT_BLOCK)
4419                 return -ECHILD;
4420 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
4421         if (flags & IPERM_FLAG_RCU)
4422                 return -ECHILD;
4423 #endif
4424
4425        /* as root inode are NOT getting validated in lookup operation,
4426         * need to do it before permission check. */
4427
4428         if (inode == inode->i_sb->s_root->d_inode) {
4429                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
4430                                            MDS_INODELOCK_LOOKUP);
4431                 if (rc)
4432                         RETURN(rc);
4433         }
4434
4435         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
4436                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
4437
4438         /* squash fsuid/fsgid if needed */
4439         sbi = ll_i2sbi(inode);
4440         squash = &sbi->ll_squash;
4441         if (unlikely(squash->rsi_uid != 0 &&
4442                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
4443                      !(sbi->ll_flags & LL_SBI_NOROOTSQUASH))) {
4444                         squash_id = true;
4445         }
4446         if (squash_id) {
4447                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
4448                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
4449                        squash->rsi_uid, squash->rsi_gid);
4450
4451                 /* update current process's credentials
4452                  * and FS capability */
4453                 cred = prepare_creds();
4454                 if (cred == NULL)
4455                         RETURN(-ENOMEM);
4456
4457                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
4458                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
4459                 for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
4460                         if ((1 << cap) & CFS_CAP_FS_MASK)
4461                                 cap_lower(cred->cap_effective, cap);
4462                 }
4463                 old_cred = override_creds(cred);
4464         }
4465
4466         ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM, 1);
4467         rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
4468         /* restore current process's credentials and FS capability */
4469         if (squash_id) {
4470                 revert_creds(old_cred);
4471                 put_cred(cred);
4472         }
4473
4474         RETURN(rc);
4475 }
4476
4477 /* -o localflock - only provides locally consistent flock locks */
4478 struct file_operations ll_file_operations = {
4479 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
4480 # ifdef HAVE_SYNC_READ_WRITE
4481         .read           = new_sync_read,
4482         .write          = new_sync_write,
4483 # endif
4484         .read_iter      = ll_file_read_iter,
4485         .write_iter     = ll_file_write_iter,
4486 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4487         .read           = ll_file_read,
4488         .aio_read       = ll_file_aio_read,
4489         .write          = ll_file_write,
4490         .aio_write      = ll_file_aio_write,
4491 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4492         .unlocked_ioctl = ll_file_ioctl,
4493         .open           = ll_file_open,
4494         .release        = ll_file_release,
4495         .mmap           = ll_file_mmap,
4496         .llseek         = ll_file_seek,
4497         .splice_read    = ll_file_splice_read,
4498         .fsync          = ll_fsync,
4499         .flush          = ll_flush
4500 };
4501
4502 struct file_operations ll_file_operations_flock = {
4503 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
4504 # ifdef HAVE_SYNC_READ_WRITE
4505         .read           = new_sync_read,
4506         .write          = new_sync_write,
4507 # endif /* HAVE_SYNC_READ_WRITE */
4508         .read_iter      = ll_file_read_iter,
4509         .write_iter     = ll_file_write_iter,
4510 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4511         .read           = ll_file_read,
4512         .aio_read       = ll_file_aio_read,
4513         .write          = ll_file_write,
4514         .aio_write      = ll_file_aio_write,
4515 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4516         .unlocked_ioctl = ll_file_ioctl,
4517         .open           = ll_file_open,
4518         .release        = ll_file_release,
4519         .mmap           = ll_file_mmap,
4520         .llseek         = ll_file_seek,
4521         .splice_read    = ll_file_splice_read,
4522         .fsync          = ll_fsync,
4523         .flush          = ll_flush,
4524         .flock          = ll_file_flock,
4525         .lock           = ll_file_flock
4526 };
4527
4528 /* These are for -o noflock - to return ENOSYS on flock calls */
4529 struct file_operations ll_file_operations_noflock = {
4530 #ifdef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
4531 # ifdef HAVE_SYNC_READ_WRITE
4532         .read           = new_sync_read,
4533         .write          = new_sync_write,
4534 # endif /* HAVE_SYNC_READ_WRITE */
4535         .read_iter      = ll_file_read_iter,
4536         .write_iter     = ll_file_write_iter,
4537 #else /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4538         .read           = ll_file_read,
4539         .aio_read       = ll_file_aio_read,
4540         .write          = ll_file_write,
4541         .aio_write      = ll_file_aio_write,
4542 #endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
4543         .unlocked_ioctl = ll_file_ioctl,
4544         .open           = ll_file_open,
4545         .release        = ll_file_release,
4546         .mmap           = ll_file_mmap,
4547         .llseek         = ll_file_seek,
4548         .splice_read    = ll_file_splice_read,
4549         .fsync          = ll_fsync,
4550         .flush          = ll_flush,
4551         .flock          = ll_file_noflock,
4552         .lock           = ll_file_noflock
4553 };
4554
4555 struct inode_operations ll_file_inode_operations = {
4556         .setattr        = ll_setattr,
4557         .getattr        = ll_getattr,
4558         .permission     = ll_inode_permission,
4559 #ifdef HAVE_IOP_XATTR
4560         .setxattr       = ll_setxattr,
4561         .getxattr       = ll_getxattr,
4562         .removexattr    = ll_removexattr,
4563 #endif
4564         .listxattr      = ll_listxattr,
4565         .fiemap         = ll_fiemap,
4566 #ifdef HAVE_IOP_GET_ACL
4567         .get_acl        = ll_get_acl,
4568 #endif
4569 #ifdef HAVE_IOP_SET_ACL
4570         .set_acl        = ll_set_acl,
4571 #endif
4572 };
4573
4574 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
4575 {
4576         struct ll_inode_info *lli = ll_i2info(inode);
4577         struct cl_object *obj = lli->lli_clob;
4578         struct lu_env *env;
4579         int rc;
4580         __u16 refcheck;
4581         ENTRY;
4582
4583         if (obj == NULL)
4584                 RETURN(0);
4585
4586         env = cl_env_get(&refcheck);
4587         if (IS_ERR(env))
4588                 RETURN(PTR_ERR(env));
4589
4590         rc = cl_conf_set(env, lli->lli_clob, conf);
4591         if (rc < 0)
4592                 GOTO(out, rc);
4593
4594         if (conf->coc_opc == OBJECT_CONF_SET) {
4595                 struct ldlm_lock *lock = conf->coc_lock;
4596                 struct cl_layout cl = {
4597                         .cl_layout_gen = 0,
4598                 };
4599
4600                 LASSERT(lock != NULL);
4601                 LASSERT(ldlm_has_layout(lock));
4602
4603                 /* it can only be allowed to match after layout is
4604                  * applied to inode otherwise false layout would be
4605                  * seen. Applying layout shoud happen before dropping
4606                  * the intent lock. */
4607                 ldlm_lock_allow_match(lock);
4608
4609                 rc = cl_object_layout_get(env, obj, &cl);
4610                 if (rc < 0)
4611                         GOTO(out, rc);
4612
4613                 CDEBUG(D_VFSTRACE,
4614                        DFID": layout version change: %u -> %u\n",
4615                        PFID(&lli->lli_fid), ll_layout_version_get(lli),
4616                        cl.cl_layout_gen);
4617                 ll_layout_version_set(lli, cl.cl_layout_gen);
4618         }
4619
4620 out:
4621         cl_env_put(env, &refcheck);
4622
4623         RETURN(rc);
4624 }
4625
4626 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
4627 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
4628
4629 {
4630         struct ll_sb_info *sbi = ll_i2sbi(inode);
4631         struct ptlrpc_request *req;
4632         struct mdt_body *body;
4633         void *lvbdata;
4634         void *lmm;
4635         int lmmsize;
4636         int rc;
4637         ENTRY;
4638
4639         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
4640                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
4641                lock->l_lvb_data, lock->l_lvb_len);
4642
4643         if (lock->l_lvb_data != NULL)
4644                 RETURN(0);
4645
4646         /* if layout lock was granted right away, the layout is returned
4647          * within DLM_LVB of dlm reply; otherwise if the lock was ever
4648          * blocked and then granted via completion ast, we have to fetch
4649          * layout here. Please note that we can't use the LVB buffer in
4650          * completion AST because it doesn't have a large enough buffer */
4651         rc = ll_get_default_mdsize(sbi, &lmmsize);
4652         if (rc == 0)
4653                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode),
4654                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
4655                                 lmmsize, 0, &req);
4656         if (rc < 0)
4657                 RETURN(rc);
4658
4659         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
4660         if (body == NULL)
4661                 GOTO(out, rc = -EPROTO);
4662
4663         lmmsize = body->mbo_eadatasize;
4664         if (lmmsize == 0) /* empty layout */
4665                 GOTO(out, rc = 0);
4666
4667         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
4668         if (lmm == NULL)
4669                 GOTO(out, rc = -EFAULT);
4670
4671         OBD_ALLOC_LARGE(lvbdata, lmmsize);
4672         if (lvbdata == NULL)
4673                 GOTO(out, rc = -ENOMEM);
4674
4675         memcpy(lvbdata, lmm, lmmsize);
4676         lock_res_and_lock(lock);
4677         if (unlikely(lock->l_lvb_data == NULL)) {
4678                 lock->l_lvb_type = LVB_T_LAYOUT;
4679                 lock->l_lvb_data = lvbdata;
4680                 lock->l_lvb_len = lmmsize;
4681                 lvbdata = NULL;
4682         }
4683         unlock_res_and_lock(lock);
4684
4685         if (lvbdata)
4686                 OBD_FREE_LARGE(lvbdata, lmmsize);
4687
4688         EXIT;
4689
4690 out:
4691         ptlrpc_req_finished(req);
4692         return rc;
4693 }
4694
4695 /**
4696  * Apply the layout to the inode. Layout lock is held and will be released
4697  * in this function.
4698  */
4699 static int ll_layout_lock_set(struct lustre_handle *lockh, enum ldlm_mode mode,
4700                               struct inode *inode)
4701 {
4702         struct ll_inode_info *lli = ll_i2info(inode);
4703         struct ll_sb_info    *sbi = ll_i2sbi(inode);
4704         struct ldlm_lock *lock;
4705         struct cl_object_conf conf;
4706         int rc = 0;
4707         bool lvb_ready;
4708         bool wait_layout = false;
4709         ENTRY;
4710
4711         LASSERT(lustre_handle_is_used(lockh));
4712
4713         lock = ldlm_handle2lock(lockh);
4714         LASSERT(lock != NULL);
4715         LASSERT(ldlm_has_layout(lock));
4716
4717         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured",
4718                    PFID(&lli->lli_fid), inode);
4719
4720         /* in case this is a caching lock and reinstate with new inode */
4721         md_set_lock_data(sbi->ll_md_exp, lockh, inode, NULL);
4722
4723         lock_res_and_lock(lock);
4724         lvb_ready = ldlm_is_lvb_ready(lock);
4725         unlock_res_and_lock(lock);
4726
4727         /* checking lvb_ready is racy but this is okay. The worst case is
4728          * that multi processes may configure the file on the same time. */
4729         if (lvb_ready)
4730                 GOTO(out, rc = 0);
4731
4732         rc = ll_layout_fetch(inode, lock);
4733         if (rc < 0)
4734                 GOTO(out, rc);
4735
4736         /* for layout lock, lmm is stored in lock's lvb.
4737          * lvb_data is immutable if the lock is held so it's safe to access it
4738          * without res lock.
4739          *
4740          * set layout to file. Unlikely this will fail as old layout was
4741          * surely eliminated */
4742         memset(&conf, 0, sizeof conf);
4743         conf.coc_opc = OBJECT_CONF_SET;
4744         conf.coc_inode = inode;
4745         conf.coc_lock = lock;
4746         conf.u.coc_layout.lb_buf = lock->l_lvb_data;
4747         conf.u.coc_layout.lb_len = lock->l_lvb_len;
4748         rc = ll_layout_conf(inode, &conf);
4749
4750         /* refresh layout failed, need to wait */
4751         wait_layout = rc == -EBUSY;
4752         EXIT;
4753 out:
4754         LDLM_LOCK_PUT(lock);
4755         ldlm_lock_decref(lockh, mode);
4756
4757         /* wait for IO to complete if it's still being used. */
4758         if (wait_layout) {
4759                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
4760                        ll_get_fsname(inode->i_sb, NULL, 0),
4761                        PFID(&lli->lli_fid), inode);
4762
4763                 memset(&conf, 0, sizeof conf);
4764                 conf.coc_opc = OBJECT_CONF_WAIT;
4765                 conf.coc_inode = inode;
4766                 rc = ll_layout_conf(inode, &conf);
4767                 if (rc == 0)
4768                         rc = -EAGAIN;
4769
4770                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
4771                        ll_get_fsname(inode->i_sb, NULL, 0),
4772                        PFID(&lli->lli_fid), rc);
4773         }
4774         RETURN(rc);
4775 }
4776
4777 /**
4778  * Issue layout intent RPC to MDS.
4779  * \param inode [in]    file inode
4780  * \param intent [in]   layout intent
4781  *
4782  * \retval 0    on success
4783  * \retval < 0  error code
4784  */
4785 static int ll_layout_intent(struct inode *inode, struct layout_intent *intent)
4786 {
4787         struct ll_inode_info  *lli = ll_i2info(inode);
4788         struct ll_sb_info     *sbi = ll_i2sbi(inode);
4789         struct md_op_data     *op_data;
4790         struct lookup_intent it;
4791         struct ptlrpc_request *req;
4792         int rc;
4793         ENTRY;
4794
4795         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
4796                                      0, 0, LUSTRE_OPC_ANY, NULL);
4797         if (IS_ERR(op_data))
4798                 RETURN(PTR_ERR(op_data));
4799
4800         op_data->op_data = intent;
4801         op_data->op_data_size = sizeof(*intent);
4802
4803         memset(&it, 0, sizeof(it));
4804         it.it_op = IT_LAYOUT;
4805         if (intent->li_opc == LAYOUT_INTENT_WRITE ||
4806             intent->li_opc == LAYOUT_INTENT_TRUNC)
4807                 it.it_flags = FMODE_WRITE;
4808
4809         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
4810                           ll_get_fsname(inode->i_sb, NULL, 0),
4811                           PFID(&lli->lli_fid), inode);
4812
4813         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
4814                             &ll_md_blocking_ast, 0);
4815         if (it.it_request != NULL)
4816                 ptlrpc_req_finished(it.it_request);
4817         it.it_request = NULL;
4818
4819         ll_finish_md_op_data(op_data);
4820
4821         /* set lock data in case this is a new lock */
4822         if (!rc)
4823                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
4824
4825         ll_intent_drop_lock(&it);
4826
4827         RETURN(rc);
4828 }
4829
4830 /**
4831  * This function checks if there exists a LAYOUT lock on the client side,
4832  * or enqueues it if it doesn't have one in cache.
4833  *
4834  * This function will not hold layout lock so it may be revoked any time after
4835  * this function returns. Any operations depend on layout should be redone
4836  * in that case.
4837  *
4838  * This function should be called before lov_io_init() to get an uptodate
4839  * layout version, the caller should save the version number and after IO
4840  * is finished, this function should be called again to verify that layout
4841  * is not changed during IO time.
4842  */
4843 int ll_layout_refresh(struct inode *inode, __u32 *gen)
4844 {
4845         struct ll_inode_info    *lli = ll_i2info(inode);
4846         struct ll_sb_info       *sbi = ll_i2sbi(inode);
4847         struct lustre_handle lockh;
4848         struct layout_intent intent = {
4849                 .li_opc = LAYOUT_INTENT_ACCESS,
4850         };
4851         enum ldlm_mode mode;
4852         int rc;
4853         ENTRY;
4854
4855         *gen = ll_layout_version_get(lli);
4856         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK) || *gen != CL_LAYOUT_GEN_NONE)
4857                 RETURN(0);
4858
4859         /* sanity checks */
4860         LASSERT(fid_is_sane(ll_inode2fid(inode)));
4861         LASSERT(S_ISREG(inode->i_mode));
4862
4863         /* take layout lock mutex to enqueue layout lock exclusively. */
4864         mutex_lock(&lli->lli_layout_mutex);
4865
4866         while (1) {
4867                 /* mostly layout lock is caching on the local side, so try to
4868                  * match it before grabbing layout lock mutex. */
4869                 mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
4870                                        LCK_CR | LCK_CW | LCK_PR | LCK_PW);
4871                 if (mode != 0) { /* hit cached lock */
4872                         rc = ll_layout_lock_set(&lockh, mode, inode);
4873                         if (rc == -EAGAIN)
4874                                 continue;
4875                         break;
4876                 }
4877
4878                 rc = ll_layout_intent(inode, &intent);
4879                 if (rc != 0)
4880                         break;
4881         }
4882
4883         if (rc == 0)
4884                 *gen = ll_layout_version_get(lli);
4885         mutex_unlock(&lli->lli_layout_mutex);
4886
4887         RETURN(rc);
4888 }
4889
4890 /**
4891  * Issue layout intent RPC indicating where in a file an IO is about to write.
4892  *
4893  * \param[in] inode     file inode.
4894  * \param[in] start     start offset of fille in bytes where an IO is about to
4895  *                      write.
4896  * \param[in] end       exclusive end offset in bytes of the write range.
4897  *
4898  * \retval 0    on success
4899  * \retval < 0  error code
4900  */
4901 int ll_layout_write_intent(struct inode *inode, __u64 start, __u64 end)
4902 {
4903         struct layout_intent intent = {
4904                 .li_opc = LAYOUT_INTENT_WRITE,
4905                 .li_extent.e_start = start,
4906                 .li_extent.e_end = end,
4907         };
4908         int rc;
4909         ENTRY;
4910
4911         rc = ll_layout_intent(inode, &intent);
4912
4913         RETURN(rc);
4914 }
4915
4916 /**
4917  *  This function send a restore request to the MDT
4918  */
4919 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
4920 {
4921         struct hsm_user_request *hur;
4922         int                      len, rc;
4923         ENTRY;
4924
4925         len = sizeof(struct hsm_user_request) +
4926               sizeof(struct hsm_user_item);
4927         OBD_ALLOC(hur, len);
4928         if (hur == NULL)
4929                 RETURN(-ENOMEM);
4930
4931         hur->hur_request.hr_action = HUA_RESTORE;
4932         hur->hur_request.hr_archive_id = 0;
4933         hur->hur_request.hr_flags = 0;
4934         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
4935                sizeof(hur->hur_user_item[0].hui_fid));
4936         hur->hur_user_item[0].hui_extent.offset = offset;
4937         hur->hur_user_item[0].hui_extent.length = length;
4938         hur->hur_request.hr_itemcount = 1;
4939         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, ll_i2sbi(inode)->ll_md_exp,
4940                            len, hur, NULL);
4941         OBD_FREE(hur, len);
4942         RETURN(rc);
4943 }