lustre/llite/file.c

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