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  */
1700 static int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1701                         size_t num_bytes)
1702 {
1703         struct obd_export *exp = ll_i2dtexp(inode);
1704         struct lov_stripe_md *lsm = NULL;
1705         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1706         __u32 vallen = num_bytes;
1707         int rc;
1708         ENTRY;
1709
1710         /* Checks for fiemap flags */
1711         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1712                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1713                 return -EBADR;
1714         }
1715
1716         /* Check for FIEMAP_FLAG_SYNC */
1717         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1718                 rc = filemap_fdatawrite(inode->i_mapping);
1719                 if (rc)
1720                         return rc;
1721         }
1722
1723         lsm = ccc_inode_lsm_get(inode);
1724         if (lsm == NULL)
1725                 return -ENOENT;
1726
1727         /* If the stripe_count > 1 and the application does not understand
1728          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1729          */
1730         if (lsm->lsm_stripe_count > 1 &&
1731             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1732                 GOTO(out, rc = -EOPNOTSUPP);
1733
1734         fm_key.oa.o_oi = lsm->lsm_oi;
1735         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1736
1737         if (i_size_read(inode) == 0) {
1738                 rc = ll_glimpse_size(inode);
1739                 if (rc)
1740                         GOTO(out, rc);
1741         }
1742
1743         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1744         obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1745         /* If filesize is 0, then there would be no objects for mapping */
1746         if (fm_key.oa.o_size == 0) {
1747                 fiemap->fm_mapped_extents = 0;
1748                 GOTO(out, rc = 0);
1749         }
1750
1751         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1752
1753         rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1754                           fiemap, lsm);
1755         if (rc)
1756                 CERROR("obd_get_info failed: rc = %d\n", rc);
1757
1758 out:
1759         ccc_inode_lsm_put(inode, lsm);
1760         RETURN(rc);
1761 }
1762
1763 int ll_fid2path(struct inode *inode, void __user *arg)
1764 {
1765         struct obd_export       *exp = ll_i2mdexp(inode);
1766         const struct getinfo_fid2path __user *gfin = arg;
1767         __u32                    pathlen;
1768         struct getinfo_fid2path *gfout;
1769         size_t                   outsize;
1770         int                      rc;
1771
1772         ENTRY;
1773
1774         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1775             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1776                 RETURN(-EPERM);
1777
1778         /* Only need to get the buflen */
1779         if (get_user(pathlen, &gfin->gf_pathlen))
1780                 RETURN(-EFAULT);
1781
1782         if (pathlen > PATH_MAX)
1783                 RETURN(-EINVAL);
1784
1785         outsize = sizeof(*gfout) + pathlen;
1786         OBD_ALLOC(gfout, outsize);
1787         if (gfout == NULL)
1788                 RETURN(-ENOMEM);
1789
1790         if (copy_from_user(gfout, arg, sizeof(*gfout)))
1791                 GOTO(gf_free, rc = -EFAULT);
1792
1793         /* Call mdc_iocontrol */
1794         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1795         if (rc != 0)
1796                 GOTO(gf_free, rc);
1797
1798         if (copy_to_user(arg, gfout, outsize))
1799                 rc = -EFAULT;
1800
1801 gf_free:
1802         OBD_FREE(gfout, outsize);
1803         RETURN(rc);
1804 }
1805
1806 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1807 {
1808         struct ll_user_fiemap *fiemap_s;
1809         size_t num_bytes, ret_bytes;
1810         unsigned int extent_count;
1811         int rc = 0;
1812
1813         /* Get the extent count so we can calculate the size of
1814          * required fiemap buffer */
1815         if (get_user(extent_count,
1816             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1817                 RETURN(-EFAULT);
1818
1819         if (extent_count >=
1820             (SIZE_MAX - sizeof(*fiemap_s)) / sizeof(struct ll_fiemap_extent))
1821                 RETURN(-EINVAL);
1822         num_bytes = sizeof(*fiemap_s) + (extent_count *
1823                                          sizeof(struct ll_fiemap_extent));
1824
1825         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1826         if (fiemap_s == NULL)
1827                 RETURN(-ENOMEM);
1828
1829         /* get the fiemap value */
1830         if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1831                            sizeof(*fiemap_s)))
1832                 GOTO(error, rc = -EFAULT);
1833
1834         /* If fm_extent_count is non-zero, read the first extent since
1835          * it is used to calculate end_offset and device from previous
1836          * fiemap call. */
1837         if (extent_count) {
1838                 if (copy_from_user(&fiemap_s->fm_extents[0],
1839                     (char __user *)arg + sizeof(*fiemap_s),
1840                     sizeof(struct ll_fiemap_extent)))
1841                         GOTO(error, rc = -EFAULT);
1842         }
1843
1844         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1845         if (rc)
1846                 GOTO(error, rc);
1847
1848         ret_bytes = sizeof(struct ll_user_fiemap);
1849
1850         if (extent_count != 0)
1851                 ret_bytes += (fiemap_s->fm_mapped_extents *
1852                                  sizeof(struct ll_fiemap_extent));
1853
1854         if (copy_to_user((void __user *)arg, fiemap_s, ret_bytes))
1855                 rc = -EFAULT;
1856
1857 error:
1858         OBD_FREE_LARGE(fiemap_s, num_bytes);
1859         RETURN(rc);
1860 }
1861
1862 /*
1863  * Read the data_version for inode.
1864  *
1865  * This value is computed using stripe object version on OST.
1866  * Version is computed using server side locking.
1867  *
1868  * @param sync if do sync on the OST side;
1869  *              0: no sync
1870  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
1871  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
1872  */
1873 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
1874 {
1875         struct lov_stripe_md    *lsm = NULL;
1876         struct ll_sb_info       *sbi = ll_i2sbi(inode);
1877         struct obdo             *obdo = NULL;
1878         int                      rc;
1879         ENTRY;
1880
1881         /* If no stripe, we consider version is 0. */
1882         lsm = ccc_inode_lsm_get(inode);
1883         if (!lsm_has_objects(lsm)) {
1884                 *data_version = 0;
1885                 CDEBUG(D_INODE, "No object for inode\n");
1886                 GOTO(out, rc = 0);
1887         }
1888
1889         OBD_ALLOC_PTR(obdo);
1890         if (obdo == NULL)
1891                 GOTO(out, rc = -ENOMEM);
1892
1893         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, flags);
1894         if (rc == 0) {
1895                 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1896                         rc = -EOPNOTSUPP;
1897                 else
1898                         *data_version = obdo->o_data_version;
1899         }
1900
1901         OBD_FREE_PTR(obdo);
1902         EXIT;
1903 out:
1904         ccc_inode_lsm_put(inode, lsm);
1905         RETURN(rc);
1906 }
1907
1908 /*
1909  * Trigger a HSM release request for the provided inode.
1910  */
1911 int ll_hsm_release(struct inode *inode)
1912 {
1913         struct cl_env_nest nest;
1914         struct lu_env *env;
1915         struct obd_client_handle *och = NULL;
1916         __u64 data_version = 0;
1917         int rc;
1918         ENTRY;
1919
1920         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
1921                ll_get_fsname(inode->i_sb, NULL, 0),
1922                PFID(&ll_i2info(inode)->lli_fid));
1923
1924         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
1925         if (IS_ERR(och))
1926                 GOTO(out, rc = PTR_ERR(och));
1927
1928         /* Grab latest data_version and [am]time values */
1929         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
1930         if (rc != 0)
1931                 GOTO(out, rc);
1932
1933         env = cl_env_nested_get(&nest);
1934         if (IS_ERR(env))
1935                 GOTO(out, rc = PTR_ERR(env));
1936
1937         ll_merge_attr(env, inode);
1938         cl_env_nested_put(&nest, env);
1939
1940         /* Release the file.
1941          * NB: lease lock handle is released in mdc_hsm_release_pack() because
1942          * we still need it to pack l_remote_handle to MDT. */
1943         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
1944                                        &data_version);
1945         och = NULL;
1946
1947         EXIT;
1948 out:
1949         if (och != NULL && !IS_ERR(och)) /* close the file */
1950                 ll_lease_close(och, inode, NULL);
1951
1952         return rc;
1953 }
1954
1955 struct ll_swap_stack {
1956         struct iattr             ia1, ia2;
1957         __u64                    dv1, dv2;
1958         struct inode            *inode1, *inode2;
1959         bool                     check_dv1, check_dv2;
1960 };
1961
1962 static int ll_swap_layouts(struct file *file1, struct file *file2,
1963                            struct lustre_swap_layouts *lsl)
1964 {
1965         struct mdc_swap_layouts  msl;
1966         struct md_op_data       *op_data;
1967         __u32                    gid;
1968         __u64                    dv;
1969         struct ll_swap_stack    *llss = NULL;
1970         int                      rc;
1971
1972         OBD_ALLOC_PTR(llss);
1973         if (llss == NULL)
1974                 RETURN(-ENOMEM);
1975
1976         llss->inode1 = file1->f_dentry->d_inode;
1977         llss->inode2 = file2->f_dentry->d_inode;
1978
1979         if (!S_ISREG(llss->inode2->i_mode))
1980                 GOTO(free, rc = -EINVAL);
1981
1982         if (inode_permission(llss->inode1, MAY_WRITE) ||
1983             inode_permission(llss->inode2, MAY_WRITE))
1984                 GOTO(free, rc = -EPERM);
1985
1986         if (llss->inode2->i_sb != llss->inode1->i_sb)
1987                 GOTO(free, rc = -EXDEV);
1988
1989         /* we use 2 bool because it is easier to swap than 2 bits */
1990         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
1991                 llss->check_dv1 = true;
1992
1993         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
1994                 llss->check_dv2 = true;
1995
1996         /* we cannot use lsl->sl_dvX directly because we may swap them */
1997         llss->dv1 = lsl->sl_dv1;
1998         llss->dv2 = lsl->sl_dv2;
1999
2000         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2001         if (rc == 0) /* same file, done! */
2002                 GOTO(free, rc = 0);
2003
2004         if (rc < 0) { /* sequentialize it */
2005                 swap(llss->inode1, llss->inode2);
2006                 swap(file1, file2);
2007                 swap(llss->dv1, llss->dv2);
2008                 swap(llss->check_dv1, llss->check_dv2);
2009         }
2010
2011         gid = lsl->sl_gid;
2012         if (gid != 0) { /* application asks to flush dirty cache */
2013                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2014                 if (rc < 0)
2015                         GOTO(free, rc);
2016
2017                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2018                 if (rc < 0) {
2019                         ll_put_grouplock(llss->inode1, file1, gid);
2020                         GOTO(free, rc);
2021                 }
2022         }
2023
2024         /* to be able to restore mtime and atime after swap
2025          * we need to first save them */
2026         if (lsl->sl_flags &
2027             (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
2028                 llss->ia1.ia_mtime = llss->inode1->i_mtime;
2029                 llss->ia1.ia_atime = llss->inode1->i_atime;
2030                 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
2031                 llss->ia2.ia_mtime = llss->inode2->i_mtime;
2032                 llss->ia2.ia_atime = llss->inode2->i_atime;
2033                 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
2034         }
2035
2036         /* ultimate check, before swaping the layouts we check if
2037          * dataversion has changed (if requested) */
2038         if (llss->check_dv1) {
2039                 rc = ll_data_version(llss->inode1, &dv, 0);
2040                 if (rc)
2041                         GOTO(putgl, rc);
2042                 if (dv != llss->dv1)
2043                         GOTO(putgl, rc = -EAGAIN);
2044         }
2045
2046         if (llss->check_dv2) {
2047                 rc = ll_data_version(llss->inode2, &dv, 0);
2048                 if (rc)
2049                         GOTO(putgl, rc);
2050                 if (dv != llss->dv2)
2051                         GOTO(putgl, rc = -EAGAIN);
2052         }
2053
2054         /* struct md_op_data is used to send the swap args to the mdt
2055          * only flags is missing, so we use struct mdc_swap_layouts
2056          * through the md_op_data->op_data */
2057         /* flags from user space have to be converted before they are send to
2058          * server, no flag is sent today, they are only used on the client */
2059         msl.msl_flags = 0;
2060         rc = -ENOMEM;
2061         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2062                                      0, LUSTRE_OPC_ANY, &msl);
2063         if (IS_ERR(op_data))
2064                 GOTO(free, rc = PTR_ERR(op_data));
2065
2066         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2067                            sizeof(*op_data), op_data, NULL);
2068         ll_finish_md_op_data(op_data);
2069
2070 putgl:
2071         if (gid != 0) {
2072                 ll_put_grouplock(llss->inode2, file2, gid);
2073                 ll_put_grouplock(llss->inode1, file1, gid);
2074         }
2075
2076         /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */
2077         if (rc != 0)
2078                 GOTO(free, rc);
2079
2080         /* clear useless flags */
2081         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
2082                 llss->ia1.ia_valid &= ~ATTR_MTIME;
2083                 llss->ia2.ia_valid &= ~ATTR_MTIME;
2084         }
2085
2086         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
2087                 llss->ia1.ia_valid &= ~ATTR_ATIME;
2088                 llss->ia2.ia_valid &= ~ATTR_ATIME;
2089         }
2090
2091         /* update time if requested */
2092         rc = 0;
2093         if (llss->ia2.ia_valid != 0) {
2094                 mutex_lock(&llss->inode1->i_mutex);
2095                 rc = ll_setattr(file1->f_dentry, &llss->ia2);
2096                 mutex_unlock(&llss->inode1->i_mutex);
2097         }
2098
2099         if (llss->ia1.ia_valid != 0) {
2100                 int rc1;
2101
2102                 mutex_lock(&llss->inode2->i_mutex);
2103                 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
2104                 mutex_unlock(&llss->inode2->i_mutex);
2105                 if (rc == 0)
2106                         rc = rc1;
2107         }
2108
2109 free:
2110         if (llss != NULL)
2111                 OBD_FREE_PTR(llss);
2112
2113         RETURN(rc);
2114 }
2115
2116 static int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2117 {
2118         struct md_op_data       *op_data;
2119         int                      rc;
2120
2121         /* Non-root users are forbidden to set or clear flags which are
2122          * NOT defined in HSM_USER_MASK. */
2123         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2124             !cfs_capable(CFS_CAP_SYS_ADMIN))
2125                 RETURN(-EPERM);
2126
2127         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2128                                      LUSTRE_OPC_ANY, hss);
2129         if (IS_ERR(op_data))
2130                 RETURN(PTR_ERR(op_data));
2131
2132         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2133                            sizeof(*op_data), op_data, NULL);
2134
2135         ll_finish_md_op_data(op_data);
2136
2137         RETURN(rc);
2138 }
2139
2140 static int ll_hsm_import(struct inode *inode, struct file *file,
2141                          struct hsm_user_import *hui)
2142 {
2143         struct hsm_state_set    *hss = NULL;
2144         struct iattr            *attr = NULL;
2145         int                      rc;
2146         ENTRY;
2147
2148         if (!S_ISREG(inode->i_mode))
2149                 RETURN(-EINVAL);
2150
2151         /* set HSM flags */
2152         OBD_ALLOC_PTR(hss);
2153         if (hss == NULL)
2154                 GOTO(out, rc = -ENOMEM);
2155
2156         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2157         hss->hss_archive_id = hui->hui_archive_id;
2158         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2159         rc = ll_hsm_state_set(inode, hss);
2160         if (rc != 0)
2161                 GOTO(out, rc);
2162
2163         OBD_ALLOC_PTR(attr);
2164         if (attr == NULL)
2165                 GOTO(out, rc = -ENOMEM);
2166
2167         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2168         attr->ia_mode |= S_IFREG;
2169         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2170         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2171         attr->ia_size = hui->hui_size;
2172         attr->ia_mtime.tv_sec = hui->hui_mtime;
2173         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2174         attr->ia_atime.tv_sec = hui->hui_atime;
2175         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2176
2177         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2178                          ATTR_UID | ATTR_GID |
2179                          ATTR_MTIME | ATTR_MTIME_SET |
2180                          ATTR_ATIME | ATTR_ATIME_SET;
2181
2182         mutex_lock(&inode->i_mutex);
2183
2184         rc = ll_setattr_raw(file->f_dentry, attr, true);
2185         if (rc == -ENODATA)
2186                 rc = 0;
2187
2188         mutex_unlock(&inode->i_mutex);
2189
2190 out:
2191         if (hss != NULL)
2192                 OBD_FREE_PTR(hss);
2193
2194         if (attr != NULL)
2195                 OBD_FREE_PTR(attr);
2196
2197         RETURN(rc);
2198 }
2199
2200 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2201 {
2202         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2203                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2204 }
2205
2206 static long
2207 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2208 {
2209         struct inode            *inode = file->f_dentry->d_inode;
2210         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2211         int                      flags, rc;
2212         ENTRY;
2213
2214         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
2215                PFID(ll_inode2fid(inode)), inode, cmd);
2216         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2217
2218         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2219         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2220                 RETURN(-ENOTTY);
2221
2222         switch(cmd) {
2223         case LL_IOC_GETFLAGS:
2224                 /* Get the current value of the file flags */
2225                 return put_user(fd->fd_flags, (int __user *)arg);
2226         case LL_IOC_SETFLAGS:
2227         case LL_IOC_CLRFLAGS:
2228                 /* Set or clear specific file flags */
2229                 /* XXX This probably needs checks to ensure the flags are
2230                  *     not abused, and to handle any flag side effects.
2231                  */
2232                 if (get_user(flags, (int __user *) arg))
2233                         RETURN(-EFAULT);
2234
2235                 if (cmd == LL_IOC_SETFLAGS) {
2236                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2237                             !(file->f_flags & O_DIRECT)) {
2238                                 CERROR("%s: unable to disable locking on "
2239                                        "non-O_DIRECT file\n", current->comm);
2240                                 RETURN(-EINVAL);
2241                         }
2242
2243                         fd->fd_flags |= flags;
2244                 } else {
2245                         fd->fd_flags &= ~flags;
2246                 }
2247                 RETURN(0);
2248         case LL_IOC_LOV_SETSTRIPE:
2249                 RETURN(ll_lov_setstripe(inode, file, arg));
2250         case LL_IOC_LOV_SETEA:
2251                 RETURN(ll_lov_setea(inode, file, arg));
2252         case LL_IOC_LOV_SWAP_LAYOUTS: {
2253                 struct file *file2;
2254                 struct lustre_swap_layouts lsl;
2255
2256                 if (copy_from_user(&lsl, (char __user *)arg,
2257                                        sizeof(struct lustre_swap_layouts)))
2258                         RETURN(-EFAULT);
2259
2260                 if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */
2261                         RETURN(-EPERM);
2262
2263                 file2 = fget(lsl.sl_fd);
2264                 if (file2 == NULL)
2265                         RETURN(-EBADF);
2266
2267                 rc = -EPERM;
2268                 if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */
2269                         rc = ll_swap_layouts(file, file2, &lsl);
2270                 fput(file2);
2271                 RETURN(rc);
2272         }
2273         case LL_IOC_LOV_GETSTRIPE:
2274                 RETURN(ll_file_getstripe(inode,
2275                                          (struct lov_user_md __user *)arg));
2276         case FSFILT_IOC_FIEMAP:
2277                 RETURN(ll_ioctl_fiemap(inode, arg));
2278         case FSFILT_IOC_GETFLAGS:
2279         case FSFILT_IOC_SETFLAGS:
2280                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2281         case FSFILT_IOC_GETVERSION_OLD:
2282         case FSFILT_IOC_GETVERSION:
2283                 RETURN(put_user(inode->i_generation, (int __user *)arg));
2284         case LL_IOC_GROUP_LOCK:
2285                 RETURN(ll_get_grouplock(inode, file, arg));
2286         case LL_IOC_GROUP_UNLOCK:
2287                 RETURN(ll_put_grouplock(inode, file, arg));
2288         case IOC_OBD_STATFS:
2289                 RETURN(ll_obd_statfs(inode, (void __user *)arg));
2290
2291         /* We need to special case any other ioctls we want to handle,
2292          * to send them to the MDS/OST as appropriate and to properly
2293          * network encode the arg field.
2294         case FSFILT_IOC_SETVERSION_OLD:
2295         case FSFILT_IOC_SETVERSION:
2296         */
2297         case LL_IOC_FLUSHCTX:
2298                 RETURN(ll_flush_ctx(inode));
2299         case LL_IOC_PATH2FID: {
2300                 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
2301                                  sizeof(struct lu_fid)))
2302                         RETURN(-EFAULT);
2303
2304                 RETURN(0);
2305         }
2306         case LL_IOC_GETPARENT:
2307                 RETURN(ll_getparent(file, (struct getparent __user *)arg));
2308
2309         case OBD_IOC_FID2PATH:
2310                 RETURN(ll_fid2path(inode, (void __user *)arg));
2311         case LL_IOC_DATA_VERSION: {
2312                 struct ioc_data_version idv;
2313                 int rc;
2314
2315                 if (copy_from_user(&idv, (char __user *)arg, sizeof(idv)))
2316                         RETURN(-EFAULT);
2317
2318                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
2319                 rc = ll_data_version(inode, &idv.idv_version, idv.idv_flags);
2320
2321                 if (rc == 0 &&
2322                     copy_to_user((char __user *)arg, &idv, sizeof(idv)))
2323                         RETURN(-EFAULT);
2324
2325                 RETURN(rc);
2326         }
2327
2328         case LL_IOC_GET_MDTIDX: {
2329                 int mdtidx;
2330
2331                 mdtidx = ll_get_mdt_idx(inode);
2332                 if (mdtidx < 0)
2333                         RETURN(mdtidx);
2334
2335                 if (put_user((int)mdtidx, (int __user *)arg))
2336                         RETURN(-EFAULT);
2337
2338                 RETURN(0);
2339         }
2340         case OBD_IOC_GETDTNAME:
2341         case OBD_IOC_GETMDNAME:
2342                 RETURN(ll_get_obd_name(inode, cmd, arg));
2343         case LL_IOC_HSM_STATE_GET: {
2344                 struct md_op_data       *op_data;
2345                 struct hsm_user_state   *hus;
2346                 int                      rc;
2347
2348                 OBD_ALLOC_PTR(hus);
2349                 if (hus == NULL)
2350                         RETURN(-ENOMEM);
2351
2352                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2353                                              LUSTRE_OPC_ANY, hus);
2354                 if (IS_ERR(op_data)) {
2355                         OBD_FREE_PTR(hus);
2356                         RETURN(PTR_ERR(op_data));
2357                 }
2358
2359                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2360                                    op_data, NULL);
2361
2362                 if (copy_to_user((void __user *)arg, hus, sizeof(*hus)))
2363                         rc = -EFAULT;
2364
2365                 ll_finish_md_op_data(op_data);
2366                 OBD_FREE_PTR(hus);
2367                 RETURN(rc);
2368         }
2369         case LL_IOC_HSM_STATE_SET: {
2370                 struct hsm_state_set    *hss;
2371                 int                      rc;
2372
2373                 OBD_ALLOC_PTR(hss);
2374                 if (hss == NULL)
2375                         RETURN(-ENOMEM);
2376
2377                 if (copy_from_user(hss, (char __user *)arg, sizeof(*hss))) {
2378                         OBD_FREE_PTR(hss);
2379                         RETURN(-EFAULT);
2380                 }
2381
2382                 rc = ll_hsm_state_set(inode, hss);
2383
2384                 OBD_FREE_PTR(hss);
2385                 RETURN(rc);
2386         }
2387         case LL_IOC_HSM_ACTION: {
2388                 struct md_op_data               *op_data;
2389                 struct hsm_current_action       *hca;
2390                 int                              rc;
2391
2392                 OBD_ALLOC_PTR(hca);
2393                 if (hca == NULL)
2394                         RETURN(-ENOMEM);
2395
2396                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2397                                              LUSTRE_OPC_ANY, hca);
2398                 if (IS_ERR(op_data)) {
2399                         OBD_FREE_PTR(hca);
2400                         RETURN(PTR_ERR(op_data));
2401                 }
2402
2403                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2404                                    op_data, NULL);
2405
2406                 if (copy_to_user((char __user *)arg, hca, sizeof(*hca)))
2407                         rc = -EFAULT;
2408
2409                 ll_finish_md_op_data(op_data);
2410                 OBD_FREE_PTR(hca);
2411                 RETURN(rc);
2412         }
2413         case LL_IOC_SET_LEASE: {
2414                 struct ll_inode_info *lli = ll_i2info(inode);
2415                 struct obd_client_handle *och = NULL;
2416                 bool lease_broken;
2417                 fmode_t fmode;
2418
2419                 switch (arg) {
2420                 case LL_LEASE_WRLCK:
2421                         if (!(file->f_mode & FMODE_WRITE))
2422                                 RETURN(-EPERM);
2423                         fmode = FMODE_WRITE;
2424                         break;
2425                 case LL_LEASE_RDLCK:
2426                         if (!(file->f_mode & FMODE_READ))
2427                                 RETURN(-EPERM);
2428                         fmode = FMODE_READ;
2429                         break;
2430                 case LL_LEASE_UNLCK:
2431                         mutex_lock(&lli->lli_och_mutex);
2432                         if (fd->fd_lease_och != NULL) {
2433                                 och = fd->fd_lease_och;
2434                                 fd->fd_lease_och = NULL;
2435                         }
2436                         mutex_unlock(&lli->lli_och_mutex);
2437
2438                         if (och == NULL)
2439                                 RETURN(-ENOLCK);
2440
2441                         fmode = och->och_flags;
2442                         rc = ll_lease_close(och, inode, &lease_broken);
2443                         if (rc < 0)
2444                                 RETURN(rc);
2445
2446                         if (lease_broken)
2447                                 fmode = 0;
2448
2449                         RETURN(ll_lease_type_from_fmode(fmode));
2450                 default:
2451                         RETURN(-EINVAL);
2452                 }
2453
2454                 CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
2455
2456                 /* apply for lease */
2457                 och = ll_lease_open(inode, file, fmode, 0);
2458                 if (IS_ERR(och))
2459                         RETURN(PTR_ERR(och));
2460
2461                 rc = 0;
2462                 mutex_lock(&lli->lli_och_mutex);
2463                 if (fd->fd_lease_och == NULL) {
2464                         fd->fd_lease_och = och;
2465                         och = NULL;
2466                 }
2467                 mutex_unlock(&lli->lli_och_mutex);
2468                 if (och != NULL) {
2469                         /* impossible now that only excl is supported for now */
2470                         ll_lease_close(och, inode, &lease_broken);
2471                         rc = -EBUSY;
2472                 }
2473                 RETURN(rc);
2474         }
2475         case LL_IOC_GET_LEASE: {
2476                 struct ll_inode_info *lli = ll_i2info(inode);
2477                 struct ldlm_lock *lock = NULL;
2478                 fmode_t fmode = 0;
2479
2480                 mutex_lock(&lli->lli_och_mutex);
2481                 if (fd->fd_lease_och != NULL) {
2482                         struct obd_client_handle *och = fd->fd_lease_och;
2483
2484                         lock = ldlm_handle2lock(&och->och_lease_handle);
2485                         if (lock != NULL) {
2486                                 lock_res_and_lock(lock);
2487                                 if (!ldlm_is_cancel(lock))
2488                                         fmode = och->och_flags;
2489
2490                                 unlock_res_and_lock(lock);
2491                                 LDLM_LOCK_PUT(lock);
2492                         }
2493                 }
2494                 mutex_unlock(&lli->lli_och_mutex);
2495
2496                 RETURN(ll_lease_type_from_fmode(fmode));
2497         }
2498         case LL_IOC_HSM_IMPORT: {
2499                 struct hsm_user_import *hui;
2500
2501                 OBD_ALLOC_PTR(hui);
2502                 if (hui == NULL)
2503                         RETURN(-ENOMEM);
2504
2505                 if (copy_from_user(hui, (void __user *)arg, sizeof(*hui))) {
2506                         OBD_FREE_PTR(hui);
2507                         RETURN(-EFAULT);
2508                 }
2509
2510                 rc = ll_hsm_import(inode, file, hui);
2511
2512                 OBD_FREE_PTR(hui);
2513                 RETURN(rc);
2514         }
2515
2516         default: {
2517                 int err;
2518
2519                 if (LLIOC_STOP ==
2520                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2521                         RETURN(err);
2522
2523                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2524                                      (void __user *)arg));
2525         }
2526         }
2527 }
2528
2529 #ifndef HAVE_FILE_LLSEEK_SIZE
2530 static inline loff_t
2531 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2532 {
2533         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2534                 return -EINVAL;
2535         if (offset > maxsize)
2536                 return -EINVAL;
2537
2538         if (offset != file->f_pos) {
2539                 file->f_pos = offset;
2540                 file->f_version = 0;
2541         }
2542         return offset;
2543 }
2544
2545 static loff_t
2546 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2547                 loff_t maxsize, loff_t eof)
2548 {
2549         struct inode *inode = file->f_dentry->d_inode;
2550
2551         switch (origin) {
2552         case SEEK_END:
2553                 offset += eof;
2554                 break;
2555         case SEEK_CUR:
2556                 /*
2557                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2558                  * position-querying operation.  Avoid rewriting the "same"
2559                  * f_pos value back to the file because a concurrent read(),
2560                  * write() or lseek() might have altered it
2561                  */
2562                 if (offset == 0)
2563                         return file->f_pos;
2564                 /*
2565                  * f_lock protects against read/modify/write race with other
2566                  * SEEK_CURs. Note that parallel writes and reads behave
2567                  * like SEEK_SET.
2568                  */
2569                 mutex_lock(&inode->i_mutex);
2570                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2571                 mutex_unlock(&inode->i_mutex);
2572                 return offset;
2573         case SEEK_DATA:
2574                 /*
2575                  * In the generic case the entire file is data, so as long as
2576                  * offset isn't at the end of the file then the offset is data.
2577                  */
2578                 if (offset >= eof)
2579                         return -ENXIO;
2580                 break;
2581         case SEEK_HOLE:
2582                 /*
2583                  * There is a virtual hole at the end of the file, so as long as
2584                  * offset isn't i_size or larger, return i_size.
2585                  */
2586                 if (offset >= eof)
2587                         return -ENXIO;
2588                 offset = eof;
2589                 break;
2590         }
2591
2592         return llseek_execute(file, offset, maxsize);
2593 }
2594 #endif
2595
2596 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2597 {
2598         struct inode *inode = file->f_dentry->d_inode;
2599         loff_t retval, eof = 0;
2600
2601         ENTRY;
2602         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2603                            (origin == SEEK_CUR) ? file->f_pos : 0);
2604         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
2605                PFID(ll_inode2fid(inode)), inode, retval, retval,
2606                origin);
2607         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2608
2609         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2610                 retval = ll_glimpse_size(inode);
2611                 if (retval != 0)
2612                         RETURN(retval);
2613                 eof = i_size_read(inode);
2614         }
2615
2616         retval = ll_generic_file_llseek_size(file, offset, origin,
2617                                           ll_file_maxbytes(inode), eof);
2618         RETURN(retval);
2619 }
2620
2621 static int ll_flush(struct file *file, fl_owner_t id)
2622 {
2623         struct inode *inode = file->f_dentry->d_inode;
2624         struct ll_inode_info *lli = ll_i2info(inode);
2625         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2626         int rc, err;
2627
2628         LASSERT(!S_ISDIR(inode->i_mode));
2629
2630         /* catch async errors that were recorded back when async writeback
2631          * failed for pages in this mapping. */
2632         rc = lli->lli_async_rc;
2633         lli->lli_async_rc = 0;
2634         if (lli->lli_clob != NULL) {
2635                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2636                 if (rc == 0)
2637                         rc = err;
2638         }
2639
2640         /* The application has been told write failure already.
2641          * Do not report failure again. */
2642         if (fd->fd_write_failed)
2643                 return 0;
2644         return rc ? -EIO : 0;
2645 }
2646
2647 /**
2648  * Called to make sure a portion of file has been written out.
2649  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
2650  *
2651  * Return how many pages have been written.
2652  */
2653 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2654                        enum cl_fsync_mode mode, int ignore_layout)
2655 {
2656         struct cl_env_nest nest;
2657         struct lu_env *env;
2658         struct cl_io *io;
2659         struct obd_capa *capa = NULL;
2660         struct cl_fsync_io *fio;
2661         int result;
2662         ENTRY;
2663
2664         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2665             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2666                 RETURN(-EINVAL);
2667
2668         env = cl_env_nested_get(&nest);
2669         if (IS_ERR(env))
2670                 RETURN(PTR_ERR(env));
2671
2672         capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2673
2674         io = ccc_env_thread_io(env);
2675         io->ci_obj = ll_i2info(inode)->lli_clob;
2676         io->ci_ignore_layout = ignore_layout;
2677
2678         /* initialize parameters for sync */
2679         fio = &io->u.ci_fsync;
2680         fio->fi_capa = capa;
2681         fio->fi_start = start;
2682         fio->fi_end = end;
2683         fio->fi_fid = ll_inode2fid(inode);
2684         fio->fi_mode = mode;
2685         fio->fi_nr_written = 0;
2686
2687         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2688                 result = cl_io_loop(env, io);
2689         else
2690                 result = io->ci_result;
2691         if (result == 0)
2692                 result = fio->fi_nr_written;
2693         cl_io_fini(env, io);
2694         cl_env_nested_put(&nest, env);
2695
2696         capa_put(capa);
2697
2698         RETURN(result);
2699 }
2700
2701 /*
2702  * When dentry is provided (the 'else' case), *file->f_dentry may be
2703  * null and dentry must be used directly rather than pulled from
2704  * *file->f_dentry as is done otherwise.
2705  */
2706
2707 #ifdef HAVE_FILE_FSYNC_4ARGS
2708 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2709 {
2710         struct dentry *dentry = file->f_dentry;
2711 #elif defined(HAVE_FILE_FSYNC_2ARGS)
2712 int ll_fsync(struct file *file, int datasync)
2713 {
2714         struct dentry *dentry = file->f_dentry;
2715         loff_t start = 0;
2716         loff_t end = LLONG_MAX;
2717 #else
2718 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
2719 {
2720         loff_t start = 0;
2721         loff_t end = LLONG_MAX;
2722 #endif
2723         struct inode *inode = dentry->d_inode;
2724         struct ll_inode_info *lli = ll_i2info(inode);
2725         struct ptlrpc_request *req;
2726         struct obd_capa *oc;
2727         int rc, err;
2728         ENTRY;
2729
2730         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
2731                PFID(ll_inode2fid(inode)), inode);
2732         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2733
2734 #ifdef HAVE_FILE_FSYNC_4ARGS
2735         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2736         mutex_lock(&inode->i_mutex);
2737 #else
2738         /* fsync's caller has already called _fdata{sync,write}, we want
2739          * that IO to finish before calling the osc and mdc sync methods */
2740         rc = filemap_fdatawait(inode->i_mapping);
2741 #endif
2742
2743         /* catch async errors that were recorded back when async writeback
2744          * failed for pages in this mapping. */
2745         if (!S_ISDIR(inode->i_mode)) {
2746                 err = lli->lli_async_rc;
2747                 lli->lli_async_rc = 0;
2748                 if (rc == 0)
2749                         rc = err;
2750                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2751                 if (rc == 0)
2752                         rc = err;
2753         }
2754
2755         oc = ll_mdscapa_get(inode);
2756         err = md_fsync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2757                        &req);
2758         capa_put(oc);
2759         if (!rc)
2760                 rc = err;
2761         if (!err)
2762                 ptlrpc_req_finished(req);
2763
2764         if (S_ISREG(inode->i_mode)) {
2765                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2766
2767                 err = cl_sync_file_range(inode, start, end, CL_FSYNC_ALL, 0);
2768                 if (rc == 0 && err < 0)
2769                         rc = err;
2770                 if (rc < 0)
2771                         fd->fd_write_failed = true;
2772                 else
2773                         fd->fd_write_failed = false;
2774         }
2775
2776 #ifdef HAVE_FILE_FSYNC_4ARGS
2777         mutex_unlock(&inode->i_mutex);
2778 #endif
2779         RETURN(rc);
2780 }
2781
2782 static int
2783 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2784 {
2785         struct inode *inode = file->f_dentry->d_inode;
2786         struct ll_sb_info *sbi = ll_i2sbi(inode);
2787         struct ldlm_enqueue_info einfo = {
2788                 .ei_type        = LDLM_FLOCK,
2789                 .ei_cb_cp       = ldlm_flock_completion_ast,
2790                 .ei_cbdata      = file_lock,
2791         };
2792         struct md_op_data *op_data;
2793         struct lustre_handle lockh = {0};
2794         ldlm_policy_data_t flock = {{0}};
2795         int fl_type = file_lock->fl_type;
2796         __u64 flags = 0;
2797         int rc;
2798         int rc2 = 0;
2799         ENTRY;
2800
2801         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
2802                PFID(ll_inode2fid(inode)), file_lock);
2803
2804         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2805
2806         if (file_lock->fl_flags & FL_FLOCK) {
2807                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2808                 /* flocks are whole-file locks */
2809                 flock.l_flock.end = OFFSET_MAX;
2810                 /* For flocks owner is determined by the local file desctiptor*/
2811                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2812         } else if (file_lock->fl_flags & FL_POSIX) {
2813                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2814                 flock.l_flock.start = file_lock->fl_start;
2815                 flock.l_flock.end = file_lock->fl_end;
2816         } else {
2817                 RETURN(-EINVAL);
2818         }
2819         flock.l_flock.pid = file_lock->fl_pid;
2820
2821         /* Somewhat ugly workaround for svc lockd.
2822          * lockd installs custom fl_lmops->lm_compare_owner that checks
2823          * for the fl_owner to be the same (which it always is on local node
2824          * I guess between lockd processes) and then compares pid.
2825          * As such we assign pid to the owner field to make it all work,
2826          * conflict with normal locks is unlikely since pid space and
2827          * pointer space for current->files are not intersecting */
2828         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2829                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2830
2831         switch (fl_type) {
2832         case F_RDLCK:
2833                 einfo.ei_mode = LCK_PR;
2834                 break;
2835         case F_UNLCK:
2836                 /* An unlock request may or may not have any relation to
2837                  * existing locks so we may not be able to pass a lock handle
2838                  * via a normal ldlm_lock_cancel() request. The request may even
2839                  * unlock a byte range in the middle of an existing lock. In
2840                  * order to process an unlock request we need all of the same
2841                  * information that is given with a normal read or write record
2842                  * lock request. To avoid creating another ldlm unlock (cancel)
2843                  * message we'll treat a LCK_NL flock request as an unlock. */
2844                 einfo.ei_mode = LCK_NL;
2845                 break;
2846         case F_WRLCK:
2847                 einfo.ei_mode = LCK_PW;
2848                 break;
2849         default:
2850                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n", fl_type);
2851                 RETURN (-ENOTSUPP);
2852         }
2853
2854         switch (cmd) {
2855         case F_SETLKW:
2856 #ifdef F_SETLKW64
2857         case F_SETLKW64:
2858 #endif
2859                 flags = 0;
2860                 break;
2861         case F_SETLK:
2862 #ifdef F_SETLK64
2863         case F_SETLK64:
2864 #endif
2865                 flags = LDLM_FL_BLOCK_NOWAIT;
2866                 break;
2867         case F_GETLK:
2868 #ifdef F_GETLK64
2869         case F_GETLK64:
2870 #endif
2871                 flags = LDLM_FL_TEST_LOCK;
2872                 break;
2873         default:
2874                 CERROR("unknown fcntl lock command: %d\n", cmd);
2875                 RETURN (-EINVAL);
2876         }
2877
2878         /* Save the old mode so that if the mode in the lock changes we
2879          * can decrement the appropriate reader or writer refcount. */
2880         file_lock->fl_type = einfo.ei_mode;
2881
2882         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2883                                      LUSTRE_OPC_ANY, NULL);
2884         if (IS_ERR(op_data))
2885                 RETURN(PTR_ERR(op_data));
2886
2887         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags="LPX64", mode=%u, "
2888                "start="LPU64", end="LPU64"\n", PFID(ll_inode2fid(inode)),
2889                flock.l_flock.pid, flags, einfo.ei_mode,
2890                flock.l_flock.start, flock.l_flock.end);
2891
2892         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data, &lockh,
2893                         flags);
2894
2895         /* Restore the file lock type if not TEST lock. */
2896         if (!(flags & LDLM_FL_TEST_LOCK))
2897                 file_lock->fl_type = fl_type;
2898
2899         if ((file_lock->fl_flags & FL_FLOCK) &&
2900             (rc == 0 || file_lock->fl_type == F_UNLCK))
2901                 rc2  = flock_lock_file_wait(file, file_lock);
2902         if ((file_lock->fl_flags & FL_POSIX) &&
2903             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2904             !(flags & LDLM_FL_TEST_LOCK))
2905                 rc2  = posix_lock_file_wait(file, file_lock);
2906
2907         if (rc2 && file_lock->fl_type != F_UNLCK) {
2908                 einfo.ei_mode = LCK_NL;
2909                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data,
2910                            &lockh, flags);
2911                 rc = rc2;
2912         }
2913
2914         ll_finish_md_op_data(op_data);
2915
2916         RETURN(rc);
2917 }
2918
2919 int ll_get_fid_by_name(struct inode *parent, const char *name,
2920                        int namelen, struct lu_fid *fid)
2921 {
2922         struct md_op_data       *op_data = NULL;
2923         struct mdt_body         *body;
2924         struct ptlrpc_request   *req;
2925         int                     rc;
2926         ENTRY;
2927
2928         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
2929                                      LUSTRE_OPC_ANY, NULL);
2930         if (IS_ERR(op_data))
2931                 RETURN(PTR_ERR(op_data));
2932
2933         op_data->op_valid = OBD_MD_FLID;
2934         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
2935         ll_finish_md_op_data(op_data);
2936         if (rc < 0)
2937                 RETURN(rc);
2938
2939         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2940         if (body == NULL)
2941                 GOTO(out_req, rc = -EFAULT);
2942         if (fid != NULL)
2943                 *fid = body->mbo_fid1;
2944 out_req:
2945         ptlrpc_req_finished(req);
2946         RETURN(rc);
2947 }
2948
2949 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
2950                const char *name, int namelen)
2951 {
2952         struct dentry         *dchild = NULL;
2953         struct inode          *child_inode = NULL;
2954         struct md_op_data     *op_data;
2955         struct ptlrpc_request *request = NULL;
2956         struct qstr           qstr;
2957         int                    rc;
2958         ENTRY;
2959
2960         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
2961                name, PFID(ll_inode2fid(parent)), mdtidx);
2962
2963         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
2964                                      0, LUSTRE_OPC_ANY, NULL);
2965         if (IS_ERR(op_data))
2966                 RETURN(PTR_ERR(op_data));
2967
2968         /* Get child FID first */
2969         qstr.hash = full_name_hash(name, namelen);
2970         qstr.name = name;
2971         qstr.len = namelen;
2972         dchild = d_lookup(file->f_dentry, &qstr);
2973         if (dchild != NULL) {
2974                 if (dchild->d_inode != NULL) {
2975                         child_inode = igrab(dchild->d_inode);
2976                         if (child_inode != NULL) {
2977                                 mutex_lock(&child_inode->i_mutex);
2978                                 op_data->op_fid3 = *ll_inode2fid(child_inode);
2979                                 ll_invalidate_aliases(child_inode);
2980                         }
2981                 }
2982                 dput(dchild);
2983         } else {
2984                 rc = ll_get_fid_by_name(parent, name, namelen,
2985                                         &op_data->op_fid3);
2986                 if (rc != 0)
2987                         GOTO(out_free, rc);
2988         }
2989
2990         if (!fid_is_sane(&op_data->op_fid3)) {
2991                 CERROR("%s: migrate %s , but fid "DFID" is insane\n",
2992                        ll_get_fsname(parent->i_sb, NULL, 0), name,
2993                        PFID(&op_data->op_fid3));
2994                 GOTO(out_free, rc = -EINVAL);
2995         }
2996
2997         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
2998         if (rc < 0)
2999                 GOTO(out_free, rc);
3000
3001         if (rc == mdtidx) {
3002                 CDEBUG(D_INFO, "%s:"DFID" is already on MDT%d.\n", name,
3003                        PFID(&op_data->op_fid3), mdtidx);
3004                 GOTO(out_free, rc = 0);
3005         }
3006
3007         op_data->op_mds = mdtidx;
3008         op_data->op_cli_flags = CLI_MIGRATE;
3009         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3010                        namelen, name, namelen, &request);
3011         if (rc == 0)
3012                 ll_update_times(request, parent);
3013
3014         ptlrpc_req_finished(request);
3015         if (rc != 0)
3016                 GOTO(out_free, rc);
3017
3018 out_free:
3019         if (child_inode != NULL) {
3020                 clear_nlink(child_inode);
3021                 mutex_unlock(&child_inode->i_mutex);
3022                 iput(child_inode);
3023         }
3024
3025         ll_finish_md_op_data(op_data);
3026         RETURN(rc);
3027 }
3028
3029 static int
3030 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3031 {
3032         ENTRY;
3033
3034         RETURN(-ENOSYS);
3035 }
3036
3037 /**
3038  * test if some locks matching bits and l_req_mode are acquired
3039  * - bits can be in different locks
3040  * - if found clear the common lock bits in *bits
3041  * - the bits not found, are kept in *bits
3042  * \param inode [IN]
3043  * \param bits [IN] searched lock bits [IN]
3044  * \param l_req_mode [IN] searched lock mode
3045  * \retval boolean, true iff all bits are found
3046  */
3047 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
3048 {
3049         struct lustre_handle lockh;
3050         ldlm_policy_data_t policy;
3051         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
3052                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
3053         struct lu_fid *fid;
3054         __u64 flags;
3055         int i;
3056         ENTRY;
3057
3058         if (!inode)
3059                RETURN(0);
3060
3061         fid = &ll_i2info(inode)->lli_fid;
3062         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3063                ldlm_lockname[mode]);
3064
3065         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3066         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3067                 policy.l_inodebits.bits = *bits & (1 << i);
3068                 if (policy.l_inodebits.bits == 0)
3069                         continue;
3070
3071                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3072                                   &policy, mode, &lockh)) {
3073                         struct ldlm_lock *lock;
3074
3075                         lock = ldlm_handle2lock(&lockh);
3076                         if (lock) {
3077                                 *bits &=
3078                                       ~(lock->l_policy_data.l_inodebits.bits);
3079                                 LDLM_LOCK_PUT(lock);
3080                         } else {
3081                                 *bits &= ~policy.l_inodebits.bits;
3082                         }
3083                 }
3084         }
3085         RETURN(*bits == 0);
3086 }
3087
3088 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
3089                             struct lustre_handle *lockh, __u64 flags,
3090                             ldlm_mode_t mode)
3091 {
3092         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
3093         struct lu_fid *fid;
3094         ldlm_mode_t rc;
3095         ENTRY;
3096
3097         fid = &ll_i2info(inode)->lli_fid;
3098         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3099
3100         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3101                            fid, LDLM_IBITS, &policy, mode, lockh);
3102
3103         RETURN(rc);
3104 }
3105
3106 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3107 {
3108         /* Already unlinked. Just update nlink and return success */
3109         if (rc == -ENOENT) {
3110                 clear_nlink(inode);
3111                 /* This path cannot be hit for regular files unless in
3112                  * case of obscure races, so no need to to validate
3113                  * size. */
3114                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3115                         return 0;
3116         } else if (rc != 0) {
3117                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
3118                              "%s: revalidate FID "DFID" error: rc = %d\n",
3119                              ll_get_fsname(inode->i_sb, NULL, 0),
3120                              PFID(ll_inode2fid(inode)), rc);
3121         }
3122
3123         return rc;
3124 }
3125
3126 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3127 {
3128         struct inode *inode = dentry->d_inode;
3129         struct ptlrpc_request *req = NULL;
3130         struct obd_export *exp;
3131         int rc = 0;
3132         ENTRY;
3133
3134         LASSERT(inode != NULL);
3135
3136         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
3137                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
3138
3139         exp = ll_i2mdexp(inode);
3140
3141         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3142          *      But under CMD case, it caused some lock issues, should be fixed
3143          *      with new CMD ibits lock. See bug 12718 */
3144         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3145                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3146                 struct md_op_data *op_data;
3147
3148                 if (ibits == MDS_INODELOCK_LOOKUP)
3149                         oit.it_op = IT_LOOKUP;
3150
3151                 /* Call getattr by fid, so do not provide name at all. */
3152                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
3153                                              dentry->d_inode, NULL, 0, 0,
3154                                              LUSTRE_OPC_ANY, NULL);
3155                 if (IS_ERR(op_data))
3156                         RETURN(PTR_ERR(op_data));
3157
3158                 rc = md_intent_lock(exp, op_data, &oit, &req,
3159                                     &ll_md_blocking_ast, 0);
3160                 ll_finish_md_op_data(op_data);
3161                 if (rc < 0) {
3162                         rc = ll_inode_revalidate_fini(inode, rc);
3163                         GOTO (out, rc);
3164                 }
3165
3166                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3167                 if (rc != 0) {
3168                         ll_intent_release(&oit);
3169                         GOTO(out, rc);
3170                 }
3171
3172                 /* Unlinked? Unhash dentry, so it is not picked up later by
3173                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3174                    here to preserve get_cwd functionality on 2.6.
3175                    Bug 10503 */
3176                 if (!dentry->d_inode->i_nlink)
3177                         d_lustre_invalidate(dentry, 0);
3178
3179                 ll_lookup_finish_locks(&oit, dentry);
3180         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3181                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3182                 u64 valid = OBD_MD_FLGETATTR;
3183                 struct md_op_data *op_data;
3184                 int ealen = 0;
3185
3186                 if (S_ISREG(inode->i_mode)) {
3187                         rc = ll_get_default_mdsize(sbi, &ealen);
3188                         if (rc)
3189                                 RETURN(rc);
3190                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3191                 }
3192
3193                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3194                                              0, ealen, LUSTRE_OPC_ANY,
3195                                              NULL);
3196                 if (IS_ERR(op_data))
3197                         RETURN(PTR_ERR(op_data));
3198
3199                 op_data->op_valid = valid;
3200                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
3201                  * capa for this inode. Because we only keep capas of dirs
3202                  * fresh. */
3203                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3204                 ll_finish_md_op_data(op_data);
3205                 if (rc) {
3206                         rc = ll_inode_revalidate_fini(inode, rc);
3207                         RETURN(rc);
3208                 }
3209
3210                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3211         }
3212 out:
3213         ptlrpc_req_finished(req);
3214         return rc;
3215 }
3216
3217 static int ll_merge_md_attr(struct inode *inode)
3218 {
3219         struct cl_attr attr = { 0 };
3220         int rc;
3221
3222         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
3223         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
3224                            &attr, ll_md_blocking_ast);
3225         if (rc != 0)
3226                 RETURN(rc);
3227
3228         set_nlink(inode, attr.cat_nlink);
3229         inode->i_blocks = attr.cat_blocks;
3230         i_size_write(inode, attr.cat_size);
3231
3232         ll_i2info(inode)->lli_atime = attr.cat_atime;
3233         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
3234         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
3235
3236         RETURN(0);
3237 }
3238
3239 static int
3240 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3241 {
3242         struct inode    *inode = dentry->d_inode;
3243         int              rc;
3244         ENTRY;
3245
3246         rc = __ll_inode_revalidate(dentry, ibits);
3247         if (rc != 0)
3248                 RETURN(rc);
3249
3250         /* if object isn't regular file, don't validate size */
3251         if (!S_ISREG(inode->i_mode)) {
3252                 if (S_ISDIR(inode->i_mode) &&
3253                     ll_i2info(inode)->lli_lsm_md != NULL) {
3254                         rc = ll_merge_md_attr(inode);
3255                         if (rc != 0)
3256                                 RETURN(rc);
3257                 }
3258
3259                 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_atime;
3260                 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_mtime;
3261                 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_ctime;
3262         } else {
3263                 /* In case of restore, the MDT has the right size and has
3264                  * already send it back without granting the layout lock,
3265                  * inode is up-to-date so glimpse is useless.
3266                  * Also to glimpse we need the layout, in case of a running
3267                  * restore the MDT holds the layout lock so the glimpse will
3268                  * block up to the end of restore (getattr will block)
3269                  */
3270                 if (!(ll_i2info(inode)->lli_flags & LLIF_FILE_RESTORING))
3271                         rc = ll_glimpse_size(inode);
3272         }
3273         RETURN(rc);
3274 }
3275
3276 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
3277 {
3278         struct inode *inode = de->d_inode;
3279         struct ll_sb_info *sbi = ll_i2sbi(inode);
3280         struct ll_inode_info *lli = ll_i2info(inode);
3281         int res = 0;
3282
3283         res = ll_inode_revalidate(de, MDS_INODELOCK_UPDATE |
3284                                       MDS_INODELOCK_LOOKUP);
3285         ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
3286
3287         if (res)
3288                 return res;
3289
3290         stat->dev = inode->i_sb->s_dev;
3291         if (ll_need_32bit_api(sbi))
3292                 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
3293         else
3294                 stat->ino = inode->i_ino;
3295         stat->mode = inode->i_mode;
3296         stat->uid = inode->i_uid;
3297         stat->gid = inode->i_gid;
3298         stat->rdev = inode->i_rdev;
3299         stat->atime = inode->i_atime;
3300         stat->mtime = inode->i_mtime;
3301         stat->ctime = inode->i_ctime;
3302         stat->blksize = 1 << inode->i_blkbits;
3303
3304         stat->nlink = inode->i_nlink;
3305         stat->size = i_size_read(inode);
3306         stat->blocks = inode->i_blocks;
3307
3308         return 0;
3309 }
3310
3311 static int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3312                      __u64 start, __u64 len)
3313 {
3314         int rc;
3315         size_t num_bytes;
3316         struct ll_user_fiemap *fiemap;
3317         unsigned int extent_count = fieinfo->fi_extents_max;
3318
3319         num_bytes = sizeof(*fiemap) + (extent_count *
3320                                        sizeof(struct ll_fiemap_extent));
3321         OBD_ALLOC_LARGE(fiemap, num_bytes);
3322
3323         if (fiemap == NULL)
3324                 RETURN(-ENOMEM);
3325
3326         fiemap->fm_flags = fieinfo->fi_flags;
3327         fiemap->fm_extent_count = fieinfo->fi_extents_max;
3328         fiemap->fm_start = start;
3329         fiemap->fm_length = len;
3330         if (extent_count > 0)
3331                 memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
3332                        sizeof(struct ll_fiemap_extent));
3333
3334         rc = ll_do_fiemap(inode, fiemap, num_bytes);
3335
3336         fieinfo->fi_flags = fiemap->fm_flags;
3337         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
3338         if (extent_count > 0)
3339                 memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
3340                        fiemap->fm_mapped_extents *
3341                        sizeof(struct ll_fiemap_extent));
3342
3343         OBD_FREE_LARGE(fiemap, num_bytes);
3344         return rc;
3345 }
3346
3347 struct posix_acl *ll_get_acl(struct inode *inode, int type)
3348 {
3349         struct ll_inode_info *lli = ll_i2info(inode);
3350         struct posix_acl *acl = NULL;
3351         ENTRY;
3352
3353         spin_lock(&lli->lli_lock);
3354         /* VFS' acl_permission_check->check_acl will release the refcount */
3355         acl = posix_acl_dup(lli->lli_posix_acl);
3356         spin_unlock(&lli->lli_lock);
3357
3358         RETURN(acl);
3359 }
3360
3361 #ifndef HAVE_GENERIC_PERMISSION_2ARGS
3362 static int
3363 # ifdef HAVE_GENERIC_PERMISSION_4ARGS
3364 ll_check_acl(struct inode *inode, int mask, unsigned int flags)
3365 # else
3366 ll_check_acl(struct inode *inode, int mask)
3367 # endif
3368 {
3369 # ifdef CONFIG_FS_POSIX_ACL
3370         struct posix_acl *acl;
3371         int rc;
3372         ENTRY;
3373
3374 #  ifdef HAVE_GENERIC_PERMISSION_4ARGS
3375         if (flags & IPERM_FLAG_RCU)
3376                 return -ECHILD;
3377 #  endif
3378         acl = ll_get_acl(inode, ACL_TYPE_ACCESS);
3379
3380         if (!acl)
3381                 RETURN(-EAGAIN);
3382
3383         rc = posix_acl_permission(inode, acl, mask);
3384         posix_acl_release(acl);
3385
3386         RETURN(rc);
3387 # else /* !CONFIG_FS_POSIX_ACL */
3388         return -EAGAIN;
3389 # endif /* CONFIG_FS_POSIX_ACL */
3390 }
3391 #endif /* HAVE_GENERIC_PERMISSION_2ARGS */
3392
3393 #ifdef HAVE_GENERIC_PERMISSION_4ARGS
3394 int ll_inode_permission(struct inode *inode, int mask, unsigned int flags)
3395 #else
3396 # ifdef HAVE_INODE_PERMISION_2ARGS
3397 int ll_inode_permission(struct inode *inode, int mask)
3398 # else
3399 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
3400 # endif
3401 #endif
3402 {
3403         int rc = 0;
3404         struct ll_sb_info *sbi;
3405         struct root_squash_info *squash;
3406         struct cred *cred = NULL;
3407         const struct cred *old_cred = NULL;
3408         cfs_cap_t cap;
3409         bool squash_id = false;
3410         ENTRY;
3411
3412 #ifdef MAY_NOT_BLOCK
3413         if (mask & MAY_NOT_BLOCK)
3414                 return -ECHILD;
3415 #elif defined(HAVE_GENERIC_PERMISSION_4ARGS)
3416         if (flags & IPERM_FLAG_RCU)
3417                 return -ECHILD;
3418 #endif
3419
3420        /* as root inode are NOT getting validated in lookup operation,
3421         * need to do it before permission check. */
3422
3423         if (inode == inode->i_sb->s_root->d_inode) {
3424                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
3425                                            MDS_INODELOCK_LOOKUP);
3426                 if (rc)
3427                         RETURN(rc);
3428         }
3429
3430         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
3431                PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
3432
3433         /* squash fsuid/fsgid if needed */
3434         sbi = ll_i2sbi(inode);
3435         squash = &sbi->ll_squash;
3436         if (unlikely(squash->rsi_uid != 0 &&
3437                      uid_eq(current_fsuid(), GLOBAL_ROOT_UID) &&
3438                      !(sbi->ll_flags & LL_SBI_NOROOTSQUASH))) {
3439                         squash_id = true;
3440         }
3441         if (squash_id) {
3442                 CDEBUG(D_OTHER, "squash creds (%d:%d)=>(%d:%d)\n",
3443                        __kuid_val(current_fsuid()), __kgid_val(current_fsgid()),
3444                        squash->rsi_uid, squash->rsi_gid);
3445
3446                 /* update current process's credentials
3447                  * and FS capability */
3448                 cred = prepare_creds();
3449                 if (cred == NULL)
3450                         RETURN(-ENOMEM);
3451
3452                 cred->fsuid = make_kuid(&init_user_ns, squash->rsi_uid);
3453                 cred->fsgid = make_kgid(&init_user_ns, squash->rsi_gid);
3454                 for (cap = 0; cap < sizeof(cfs_cap_t) * 8; cap++) {
3455                         if ((1 << cap) & CFS_CAP_FS_MASK)
3456                                 cap_lower(cred->cap_effective, cap);
3457                 }
3458                 old_cred = override_creds(cred);
3459         }
3460
3461         ll_stats_ops_tally(sbi, LPROC_LL_INODE_PERM, 1);
3462
3463         if (sbi->ll_flags & LL_SBI_RMT_CLIENT)
3464                 rc = lustre_check_remote_perm(inode, mask);
3465         else
3466                 rc = ll_generic_permission(inode, mask, flags, ll_check_acl);
3467
3468         /* restore current process's credentials and FS capability */
3469         if (squash_id) {
3470                 revert_creds(old_cred);
3471                 put_cred(cred);
3472         }
3473
3474         RETURN(rc);
3475 }
3476
3477 /* -o localflock - only provides locally consistent flock locks */
3478 struct file_operations ll_file_operations = {
3479         .read           = ll_file_read,
3480         .aio_read    = ll_file_aio_read,
3481         .write          = ll_file_write,
3482         .aio_write   = ll_file_aio_write,
3483         .unlocked_ioctl = ll_file_ioctl,
3484         .open           = ll_file_open,
3485         .release        = ll_file_release,
3486         .mmap           = ll_file_mmap,
3487         .llseek         = ll_file_seek,
3488         .splice_read    = ll_file_splice_read,
3489         .fsync          = ll_fsync,
3490         .flush          = ll_flush
3491 };
3492
3493 struct file_operations ll_file_operations_flock = {
3494         .read           = ll_file_read,
3495         .aio_read    = ll_file_aio_read,
3496         .write          = ll_file_write,
3497         .aio_write   = ll_file_aio_write,
3498         .unlocked_ioctl = ll_file_ioctl,
3499         .open           = ll_file_open,
3500         .release        = ll_file_release,
3501         .mmap           = ll_file_mmap,
3502         .llseek         = ll_file_seek,
3503         .splice_read    = ll_file_splice_read,
3504         .fsync          = ll_fsync,
3505         .flush          = ll_flush,
3506         .flock          = ll_file_flock,
3507         .lock           = ll_file_flock
3508 };
3509
3510 /* These are for -o noflock - to return ENOSYS on flock calls */
3511 struct file_operations ll_file_operations_noflock = {
3512         .read           = ll_file_read,
3513         .aio_read    = ll_file_aio_read,
3514         .write          = ll_file_write,
3515         .aio_write   = ll_file_aio_write,
3516         .unlocked_ioctl = ll_file_ioctl,
3517         .open           = ll_file_open,
3518         .release        = ll_file_release,
3519         .mmap           = ll_file_mmap,
3520         .llseek         = ll_file_seek,
3521         .splice_read    = ll_file_splice_read,
3522         .fsync          = ll_fsync,
3523         .flush          = ll_flush,
3524         .flock          = ll_file_noflock,
3525         .lock           = ll_file_noflock
3526 };
3527
3528 struct inode_operations ll_file_inode_operations = {
3529         .setattr        = ll_setattr,
3530         .getattr        = ll_getattr,
3531         .permission     = ll_inode_permission,
3532         .setxattr       = ll_setxattr,
3533         .getxattr       = ll_getxattr,
3534         .listxattr      = ll_listxattr,
3535         .removexattr    = ll_removexattr,
3536         .fiemap         = ll_fiemap,
3537 #ifdef HAVE_IOP_GET_ACL
3538         .get_acl        = ll_get_acl,
3539 #endif
3540 };
3541
3542 /* dynamic ioctl number support routins */
3543 static struct llioc_ctl_data {
3544         struct rw_semaphore     ioc_sem;
3545         struct list_head        ioc_head;
3546 } llioc = {
3547         __RWSEM_INITIALIZER(llioc.ioc_sem),
3548         LIST_HEAD_INIT(llioc.ioc_head)
3549 };
3550
3551
3552 struct llioc_data {
3553         struct list_head        iocd_list;
3554         unsigned int            iocd_size;
3555         llioc_callback_t        iocd_cb;
3556         unsigned int            iocd_count;
3557         unsigned int            iocd_cmd[0];
3558 };
3559
3560 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
3561 {
3562         unsigned int size;
3563         struct llioc_data *in_data = NULL;
3564         ENTRY;
3565
3566         if (cb == NULL || cmd == NULL ||
3567             count > LLIOC_MAX_CMD || count < 0)
3568                 RETURN(NULL);
3569
3570         size = sizeof(*in_data) + count * sizeof(unsigned int);
3571         OBD_ALLOC(in_data, size);
3572         if (in_data == NULL)
3573                 RETURN(NULL);
3574
3575         memset(in_data, 0, sizeof(*in_data));
3576         in_data->iocd_size = size;
3577         in_data->iocd_cb = cb;
3578         in_data->iocd_count = count;
3579         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
3580
3581         down_write(&llioc.ioc_sem);
3582         list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
3583         up_write(&llioc.ioc_sem);
3584
3585         RETURN(in_data);
3586 }
3587
3588 void ll_iocontrol_unregister(void *magic)
3589 {
3590         struct llioc_data *tmp;
3591
3592         if (magic == NULL)
3593                 return;
3594
3595         down_write(&llioc.ioc_sem);
3596         list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
3597                 if (tmp == magic) {
3598                         unsigned int size = tmp->iocd_size;
3599
3600                         list_del(&tmp->iocd_list);
3601                         up_write(&llioc.ioc_sem);
3602
3603                         OBD_FREE(tmp, size);
3604                         return;
3605                 }
3606         }
3607         up_write(&llioc.ioc_sem);
3608
3609         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
3610 }
3611
3612 EXPORT_SYMBOL(ll_iocontrol_register);
3613 EXPORT_SYMBOL(ll_iocontrol_unregister);
3614
3615 static enum llioc_iter
3616 ll_iocontrol_call(struct inode *inode, struct file *file,
3617                   unsigned int cmd, unsigned long arg, int *rcp)
3618 {
3619         enum llioc_iter ret = LLIOC_CONT;
3620         struct llioc_data *data;
3621         int rc = -EINVAL, i;
3622
3623         down_read(&llioc.ioc_sem);
3624         list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
3625                 for (i = 0; i < data->iocd_count; i++) {
3626                         if (cmd != data->iocd_cmd[i])
3627                                 continue;
3628
3629                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
3630                         break;
3631                 }
3632
3633                 if (ret == LLIOC_STOP)
3634                         break;
3635         }
3636         up_read(&llioc.ioc_sem);
3637
3638         if (rcp)
3639                 *rcp = rc;
3640         return ret;
3641 }
3642
3643 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
3644 {
3645         struct ll_inode_info *lli = ll_i2info(inode);
3646         struct cl_env_nest nest;
3647         struct lu_env *env;
3648         int result;
3649         ENTRY;
3650
3651         if (lli->lli_clob == NULL)
3652                 RETURN(0);
3653
3654         env = cl_env_nested_get(&nest);
3655         if (IS_ERR(env))
3656                 RETURN(PTR_ERR(env));
3657
3658         result = cl_conf_set(env, lli->lli_clob, conf);
3659         cl_env_nested_put(&nest, env);
3660
3661         if (conf->coc_opc == OBJECT_CONF_SET) {
3662                 struct ldlm_lock *lock = conf->coc_lock;
3663
3664                 LASSERT(lock != NULL);
3665                 LASSERT(ldlm_has_layout(lock));
3666                 if (result == 0) {
3667                         struct lustre_md *md = conf->u.coc_md;
3668                         __u32 gen = LL_LAYOUT_GEN_EMPTY;
3669
3670                         /* it can only be allowed to match after layout is
3671                          * applied to inode otherwise false layout would be
3672                          * seen. Applying layout shoud happen before dropping
3673                          * the intent lock. */
3674                         ldlm_lock_allow_match(lock);
3675
3676                         lli->lli_has_smd = lsm_has_objects(md->lsm);
3677                         if (md->lsm != NULL)
3678                                 gen = md->lsm->lsm_layout_gen;
3679
3680                         CDEBUG(D_VFSTRACE,
3681                                DFID ": layout version change: %u -> %u\n",
3682                                PFID(&lli->lli_fid), ll_layout_version_get(lli),
3683                                gen);
3684                         ll_layout_version_set(lli, gen);
3685                 }
3686         }
3687         RETURN(result);
3688 }
3689
3690 /* Fetch layout from MDT with getxattr request, if it's not ready yet */
3691 static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
3692
3693 {
3694         struct ll_sb_info *sbi = ll_i2sbi(inode);
3695         struct obd_capa *oc;
3696         struct ptlrpc_request *req;
3697         struct mdt_body *body;
3698         void *lvbdata;
3699         void *lmm;
3700         int lmmsize;
3701         int rc;
3702         ENTRY;
3703
3704         CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
3705                PFID(ll_inode2fid(inode)), ldlm_is_lvb_ready(lock),
3706                lock->l_lvb_data, lock->l_lvb_len);
3707
3708         if ((lock->l_lvb_data != NULL) && ldlm_is_lvb_ready(lock))
3709                 RETURN(0);
3710
3711         /* if layout lock was granted right away, the layout is returned
3712          * within DLM_LVB of dlm reply; otherwise if the lock was ever
3713          * blocked and then granted via completion ast, we have to fetch
3714          * layout here. Please note that we can't use the LVB buffer in
3715          * completion AST because it doesn't have a large enough buffer */
3716         oc = ll_mdscapa_get(inode);
3717         rc = ll_get_default_mdsize(sbi, &lmmsize);
3718         if (rc == 0)
3719                 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
3720                                 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
3721                                 lmmsize, 0, &req);
3722         capa_put(oc);
3723         if (rc < 0)
3724                 RETURN(rc);
3725
3726         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3727         if (body == NULL)
3728                 GOTO(out, rc = -EPROTO);
3729
3730         lmmsize = body->mbo_eadatasize;
3731         if (lmmsize == 0) /* empty layout */
3732                 GOTO(out, rc = 0);
3733
3734         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
3735         if (lmm == NULL)
3736                 GOTO(out, rc = -EFAULT);
3737
3738         OBD_ALLOC_LARGE(lvbdata, lmmsize);
3739         if (lvbdata == NULL)
3740                 GOTO(out, rc = -ENOMEM);
3741
3742         memcpy(lvbdata, lmm, lmmsize);
3743         lock_res_and_lock(lock);
3744         if (lock->l_lvb_data != NULL)
3745                 OBD_FREE_LARGE(lock->l_lvb_data, lock->l_lvb_len);
3746
3747         lock->l_lvb_data = lvbdata;
3748         lock->l_lvb_len = lmmsize;
3749         unlock_res_and_lock(lock);
3750
3751         EXIT;
3752
3753 out:
3754         ptlrpc_req_finished(req);
3755         return rc;
3756 }
3757
3758 /**
3759  * Apply the layout to the inode. Layout lock is held and will be released
3760  * in this function.
3761  */
3762 static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
3763                                 struct inode *inode, __u32 *gen, bool reconf)
3764 {
3765         struct ll_inode_info *lli = ll_i2info(inode);
3766         struct ll_sb_info    *sbi = ll_i2sbi(inode);
3767         struct ldlm_lock *lock;
3768         struct lustre_md md = { NULL };
3769         struct cl_object_conf conf;
3770         int rc = 0;
3771         bool lvb_ready;
3772         bool wait_layout = false;
3773         ENTRY;
3774
3775         LASSERT(lustre_handle_is_used(lockh));
3776
3777         lock = ldlm_handle2lock(lockh);
3778         LASSERT(lock != NULL);
3779         LASSERT(ldlm_has_layout(lock));
3780
3781         LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured: %d",
3782                    PFID(&lli->lli_fid), inode, reconf);
3783
3784         /* in case this is a caching lock and reinstate with new inode */
3785         md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
3786
3787         lock_res_and_lock(lock);
3788         lvb_ready = ldlm_is_lvb_ready(lock);
3789         unlock_res_and_lock(lock);
3790         /* checking lvb_ready is racy but this is okay. The worst case is
3791          * that multi processes may configure the file on the same time. */
3792
3793         if (lvb_ready || !reconf) {
3794                 rc = -ENODATA;
3795                 if (lvb_ready) {
3796                         /* layout_gen must be valid if layout lock is not
3797                          * cancelled and stripe has already set */
3798                         *gen = ll_layout_version_get(lli);
3799                         rc = 0;
3800                 }
3801                 GOTO(out, rc);
3802         }
3803
3804         rc = ll_layout_fetch(inode, lock);
3805         if (rc < 0)
3806                 GOTO(out, rc);
3807
3808         /* for layout lock, lmm is returned in lock's lvb.
3809          * lvb_data is immutable if the lock is held so it's safe to access it
3810          * without res lock. See the description in ldlm_lock_decref_internal()
3811          * for the condition to free lvb_data of layout lock */
3812         if (lock->l_lvb_data != NULL) {
3813                 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
3814                                   lock->l_lvb_data, lock->l_lvb_len);
3815                 if (rc >= 0) {
3816                         *gen = LL_LAYOUT_GEN_EMPTY;
3817                         if (md.lsm != NULL)
3818                                 *gen = md.lsm->lsm_layout_gen;
3819                         rc = 0;
3820                 } else {
3821                         CERROR("%s: file "DFID" unpackmd error: %d\n",
3822                                 ll_get_fsname(inode->i_sb, NULL, 0),
3823                                 PFID(&lli->lli_fid), rc);
3824                 }
3825         }
3826         if (rc < 0)
3827                 GOTO(out, rc);
3828
3829         /* set layout to file. Unlikely this will fail as old layout was
3830          * surely eliminated */
3831         memset(&conf, 0, sizeof conf);
3832         conf.coc_opc = OBJECT_CONF_SET;
3833         conf.coc_inode = inode;
3834         conf.coc_lock = lock;
3835         conf.u.coc_md = &md;
3836         rc = ll_layout_conf(inode, &conf);
3837
3838         if (md.lsm != NULL)
3839                 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3840
3841         /* refresh layout failed, need to wait */
3842         wait_layout = rc == -EBUSY;
3843         EXIT;
3844
3845 out:
3846         LDLM_LOCK_PUT(lock);
3847         ldlm_lock_decref(lockh, mode);
3848
3849         /* wait for IO to complete if it's still being used. */
3850         if (wait_layout) {
3851                 CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
3852                        ll_get_fsname(inode->i_sb, NULL, 0),
3853                        PFID(&lli->lli_fid), inode);
3854
3855                 memset(&conf, 0, sizeof conf);
3856                 conf.coc_opc = OBJECT_CONF_WAIT;
3857                 conf.coc_inode = inode;
3858                 rc = ll_layout_conf(inode, &conf);
3859                 if (rc == 0)
3860                         rc = -EAGAIN;
3861
3862                 CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
3863                        ll_get_fsname(inode->i_sb, NULL, 0),
3864                        PFID(&lli->lli_fid), rc);
3865         }
3866         RETURN(rc);
3867 }
3868
3869 /**
3870  * This function checks if there exists a LAYOUT lock on the client side,
3871  * or enqueues it if it doesn't have one in cache.
3872  *
3873  * This function will not hold layout lock so it may be revoked any time after
3874  * this function returns. Any operations depend on layout should be redone
3875  * in that case.
3876  *
3877  * This function should be called before lov_io_init() to get an uptodate
3878  * layout version, the caller should save the version number and after IO
3879  * is finished, this function should be called again to verify that layout
3880  * is not changed during IO time.
3881  */
3882 int ll_layout_refresh(struct inode *inode, __u32 *gen)
3883 {
3884         struct ll_inode_info  *lli = ll_i2info(inode);
3885         struct ll_sb_info     *sbi = ll_i2sbi(inode);
3886         struct md_op_data     *op_data;
3887         struct lookup_intent   it;
3888         struct lustre_handle   lockh;
3889         ldlm_mode_t            mode;
3890         struct ldlm_enqueue_info einfo = {
3891                 .ei_type = LDLM_IBITS,
3892                 .ei_mode = LCK_CR,
3893                 .ei_cb_bl = &ll_md_blocking_ast,
3894                 .ei_cb_cp = &ldlm_completion_ast,
3895         };
3896         int rc;
3897         ENTRY;
3898
3899         *gen = ll_layout_version_get(lli);
3900         if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK) || *gen != LL_LAYOUT_GEN_NONE)
3901                 RETURN(0);
3902
3903         /* sanity checks */
3904         LASSERT(fid_is_sane(ll_inode2fid(inode)));
3905         LASSERT(S_ISREG(inode->i_mode));
3906
3907         /* take layout lock mutex to enqueue layout lock exclusively. */
3908         mutex_lock(&lli->lli_layout_mutex);
3909
3910 again:
3911         /* mostly layout lock is caching on the local side, so try to match
3912          * it before grabbing layout lock mutex. */
3913         mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0,
3914                                LCK_CR | LCK_CW | LCK_PR | LCK_PW);
3915         if (mode != 0) { /* hit cached lock */
3916                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3917                 if (rc == -EAGAIN)
3918                         goto again;
3919
3920                 mutex_unlock(&lli->lli_layout_mutex);
3921                 RETURN(rc);
3922         }
3923
3924         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3925                                      0, 0, LUSTRE_OPC_ANY, NULL);
3926         if (IS_ERR(op_data)) {
3927                 mutex_unlock(&lli->lli_layout_mutex);
3928                 RETURN(PTR_ERR(op_data));
3929         }
3930
3931         /* have to enqueue one */
3932         memset(&it, 0, sizeof(it));
3933         it.it_op = IT_LAYOUT;
3934         lockh.cookie = 0ULL;
3935
3936         LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)",
3937                           ll_get_fsname(inode->i_sb, NULL, 0),
3938                           PFID(&lli->lli_fid), inode);
3939
3940         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL, &it, op_data, &lockh, 0);
3941         if (it.d.lustre.it_data != NULL)
3942                 ptlrpc_req_finished(it.d.lustre.it_data);
3943         it.d.lustre.it_data = NULL;
3944
3945         ll_finish_md_op_data(op_data);
3946
3947         mode = it.d.lustre.it_lock_mode;
3948         it.d.lustre.it_lock_mode = 0;
3949         ll_intent_drop_lock(&it);
3950
3951         if (rc == 0) {
3952                 /* set lock data in case this is a new lock */
3953                 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
3954                 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3955                 if (rc == -EAGAIN)
3956                         goto again;
3957         }
3958         mutex_unlock(&lli->lli_layout_mutex);
3959
3960         RETURN(rc);
3961 }
3962
3963 /**
3964  *  This function send a restore request to the MDT
3965  */
3966 int ll_layout_restore(struct inode *inode, loff_t offset, __u64 length)
3967 {
3968         struct hsm_user_request *hur;
3969         int                      len, rc;
3970         ENTRY;
3971
3972         len = sizeof(struct hsm_user_request) +
3973               sizeof(struct hsm_user_item);
3974         OBD_ALLOC(hur, len);
3975         if (hur == NULL)
3976                 RETURN(-ENOMEM);
3977
3978         hur->hur_request.hr_action = HUA_RESTORE;
3979         hur->hur_request.hr_archive_id = 0;
3980         hur->hur_request.hr_flags = 0;
3981         memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid,
3982                sizeof(hur->hur_user_item[0].hui_fid));
3983         hur->hur_user_item[0].hui_extent.offset = offset;
3984         hur->hur_user_item[0].hui_extent.length = length;
3985         hur->hur_request.hr_itemcount = 1;
3986         rc = obd_iocontrol(LL_IOC_HSM_REQUEST, ll_i2sbi(inode)->ll_md_exp,
3987                            len, hur, NULL);
3988         OBD_FREE(hur, len);
3989         RETURN(rc);
3990 }