X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Ffile.c;h=a82ff307e4a6fff4ea530dfc923e4754368fc640;hp=cc6214c527e66ac0acb47ed9871e625ae8b497b1;hb=92a189ca69c59312c802cb9aed0f0386735d9617;hpb=9fe4b52ad2ffadf125d9b5c78bb2ff9a01725707 diff --git a/lustre/llite/file.c b/lustre/llite/file.c index cc6214c..a82ff30 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -27,7 +27,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2011, 2013, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -52,10 +52,15 @@ struct ll_file_data *ll_file_data_get(void) { - struct ll_file_data *fd; + struct ll_file_data *fd; + + OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, __GFP_IO); + if (fd == NULL) + return NULL; - OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, CFS_ALLOC_IO); - return fd; + fd->fd_write_failed = false; + + return fd; } static void ll_file_data_put(struct ll_file_data *fd) @@ -80,6 +85,9 @@ void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data, if (fh) op_data->op_handle = *fh; op_data->op_capa1 = ll_mdscapa_get(inode); + + if (LLIF_DATA_MODIFIED & ll_i2info(inode)->lli_flags) + op_data->op_bias |= MDS_DATA_MODIFIED; } /** @@ -91,8 +99,9 @@ static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data, { ENTRY; - op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME_SET | - ATTR_MTIME_SET | ATTR_CTIME_SET; + op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET | + ATTR_MTIME | ATTR_MTIME_SET | + ATTR_CTIME | ATTR_CTIME_SET; if (!(och->och_flags & FMODE_WRITE)) goto out; @@ -110,8 +119,9 @@ out: } static int ll_close_inode_openhandle(struct obd_export *md_exp, - struct inode *inode, - struct obd_client_handle *och) + struct inode *inode, + struct obd_client_handle *och, + const __u64 *data_version) { struct obd_export *exp = ll_i2mdexp(inode); struct md_op_data *op_data; @@ -135,7 +145,14 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp, if (op_data == NULL) GOTO(out, rc = -ENOMEM); // XXX We leak openhandle and request here. - ll_prepare_close(inode, op_data, och); + ll_prepare_close(inode, op_data, och); + if (data_version != NULL) { + /* Pass in data_version implies release. */ + op_data->op_bias |= MDS_HSM_RELEASE; + op_data->op_data_version = *data_version; + op_data->op_lease_handle = och->och_lease_handle; + op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS; + } epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE); rc = md_close(md_exp, op_data, och->och_mod, &req); if (rc == -EAGAIN) { @@ -153,7 +170,16 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp, CERROR("inode %lu mdc close failed: rc = %d\n", inode->i_ino, rc); } - ll_finish_md_op_data(op_data); + + /* DATA_MODIFIED flag was successfully sent on close, cancel data + * modification flag. */ + if (rc == 0 && (op_data->op_bias & MDS_DATA_MODIFIED)) { + struct ll_inode_info *lli = ll_i2info(inode); + + spin_lock(&lli->lli_lock); + lli->lli_flags &= ~LLIF_DATA_MODIFIED; + spin_unlock(&lli->lli_lock); + } if (rc == 0) { rc = ll_objects_destroy(req, inode); @@ -162,6 +188,14 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp, inode->i_ino, rc); } + if (rc == 0 && op_data->op_bias & MDS_HSM_RELEASE) { + struct mdt_body *body; + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (!(body->valid & OBD_MD_FLRELEASED)) + rc = -EBUSY; + } + + ll_finish_md_op_data(op_data); EXIT; out: @@ -200,20 +234,20 @@ int ll_md_real_close(struct inode *inode, int flags) och_usecount = &lli->lli_open_fd_read_count; } - cfs_mutex_lock(&lli->lli_och_mutex); + mutex_lock(&lli->lli_och_mutex); if (*och_usecount) { /* There are still users of this handle, so skip freeing it. */ - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); RETURN(0); } och=*och_p; *och_p = NULL; - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); if (och) { /* There might be a race and somebody have freed this och already */ rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, - inode, och); + inode, och, NULL); } RETURN(rc); @@ -231,6 +265,24 @@ int ll_md_close(struct obd_export *md_exp, struct inode *inode, if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED)) ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid); + if (fd->fd_lease_och != NULL) { + bool lease_broken; + + /* Usually the lease is not released when the + * application crashed, we need to release here. */ + rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken); + CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n", + PFID(&lli->lli_fid), rc, lease_broken); + + fd->fd_lease_och = NULL; + } + + if (fd->fd_och != NULL) { + rc = ll_close_inode_openhandle(md_exp, inode, fd->fd_och, NULL); + fd->fd_och = NULL; + GOTO(out, rc); + } + /* Let's see if we have good enough OPEN lock on the file and if we can skip talking to MDS */ if (file->f_dentry->d_inode) { /* Can this ever be false? */ @@ -240,7 +292,7 @@ int ll_md_close(struct obd_export *md_exp, struct inode *inode, struct inode *inode = file->f_dentry->d_inode; ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}}; - cfs_mutex_lock(&lli->lli_och_mutex); + mutex_lock(&lli->lli_och_mutex); if (fd->fd_omode & FMODE_WRITE) { lockmode = LCK_CW; LASSERT(lli->lli_open_fd_write_count); @@ -254,7 +306,7 @@ int ll_md_close(struct obd_export *md_exp, struct inode *inode, LASSERT(lli->lli_open_fd_read_count); lli->lli_open_fd_read_count--; } - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); if (!md_lock_match(md_exp, flags, ll_inode2fid(inode), LDLM_IBITS, &policy, lockmode, @@ -267,15 +319,14 @@ int ll_md_close(struct obd_export *md_exp, struct inode *inode, file, file->f_dentry, file->f_dentry->d_name.name); } - LUSTRE_FPRIVATE(file) = NULL; - ll_file_data_put(fd); - ll_capa_close(inode); +out: + LUSTRE_FPRIVATE(file) = NULL; + ll_file_data_put(fd); + ll_capa_close(inode); - RETURN(rc); + RETURN(rc); } -int lov_test_and_clear_async_rc(struct lov_stripe_md *lsm); - /* While this returns an error code, fput() the caller does not, so we need * to make every effort to clean up all of our state here. Also, applications * rarely check close errors and even if an error is returned they will not @@ -286,7 +337,6 @@ int ll_file_release(struct inode *inode, struct file *file) struct ll_file_data *fd; struct ll_sb_info *sbi = ll_i2sbi(inode); struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; int rc; ENTRY; @@ -326,8 +376,7 @@ int ll_file_release(struct inode *inode, struct file *file) } if (!S_ISDIR(inode->i_mode)) { - if (lsm) - lov_test_and_clear_async_rc(lsm); + lov_read_and_clear_async_rc(lli->lli_clob); lli->lli_async_rc = 0; } @@ -344,8 +393,6 @@ static int ll_intent_file_open(struct file *file, void *lmm, { struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode); struct dentry *parent = file->f_dentry->d_parent; - const char *name = file->f_dentry->d_name.name; - const int len = file->f_dentry->d_name.len; struct md_op_data *op_data; struct ptlrpc_request *req; __u32 opc = LUSTRE_OPC_ANY; @@ -370,12 +417,14 @@ static int ll_intent_file_open(struct file *file, void *lmm, opc = LUSTRE_OPC_CREATE; } - op_data = ll_prep_md_op_data(NULL, parent->d_inode, - file->f_dentry->d_inode, name, len, - O_RDWR, opc, NULL); + op_data = ll_prep_md_op_data(NULL, parent->d_inode, + file->f_dentry->d_inode, NULL, 0, + O_RDWR, opc, NULL); + if (IS_ERR(op_data)) RETURN(PTR_ERR(op_data)); + itp->it_flags |= MDS_OPEN_BY_FID; rc = md_intent_lock(sbi->ll_md_exp, op_data, lmm, lmmsize, itp, 0 /*unused */, &req, ll_md_blocking_ast, 0); ll_finish_md_op_data(op_data); @@ -399,7 +448,7 @@ static int ll_intent_file_open(struct file *file, void *lmm, GOTO(out, rc); } - rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL); + rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL, itp); if (!rc && itp->d.lustre.it_lock_mode) ll_set_lock_data(sbi->ll_md_exp, file->f_dentry->d_inode, itp, NULL); @@ -426,24 +475,20 @@ void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch) } } -static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli, - struct lookup_intent *it, struct obd_client_handle *och) +static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it, + struct obd_client_handle *och) { - struct ptlrpc_request *req = it->d.lustre.it_data; - struct mdt_body *body; - - LASSERT(och); - - body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); - LASSERT(body != NULL); /* reply already checked out */ + struct ptlrpc_request *req = it->d.lustre.it_data; + struct mdt_body *body; - memcpy(&och->och_fh, &body->handle, sizeof(body->handle)); - och->och_magic = OBD_CLIENT_HANDLE_MAGIC; - och->och_fid = lli->lli_fid; - och->och_flags = it->it_flags; - ll_ioepoch_open(lli, body->ioepoch); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + och->och_fh = body->handle; + och->och_fid = body->fid1; + och->och_lease_handle.cookie = it->d.lustre.it_lock_handle; + och->och_magic = OBD_CLIENT_HANDLE_MAGIC; + och->och_flags = it->it_flags; - return md_set_open_replay_data(md_exp, och, req); + return md_set_open_replay_data(md_exp, och, req); } int ll_local_open(struct file *file, struct lookup_intent *it, @@ -462,21 +507,19 @@ int ll_local_open(struct file *file, struct lookup_intent *it, struct mdt_body *body; int rc; - rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, lli, it, och); - if (rc) - RETURN(rc); + rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och); + if (rc != 0) + RETURN(rc); - body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); - if ((it->it_flags & FMODE_WRITE) && - (body->valid & OBD_MD_FLSIZE)) - CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n", - lli->lli_ioepoch, PFID(&lli->lli_fid)); - } + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + ll_ioepoch_open(lli, body->ioepoch); + } + + LUSTRE_FPRIVATE(file) = fd; + ll_readahead_init(inode, &fd->fd_ras); + fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC); - LUSTRE_FPRIVATE(file) = fd; - ll_readahead_init(inode, &fd->fd_ras); - fd->fd_omode = it->it_flags; - RETURN(0); + RETURN(0); } /* Open a file, and (for the very first open) create objects on the OSTs at @@ -497,7 +540,6 @@ int ll_file_open(struct inode *inode, struct file *file) struct ll_inode_info *lli = ll_i2info(inode); struct lookup_intent *it, oit = { .it_op = IT_OPEN, .it_flags = file->f_flags }; - struct lov_stripe_md *lsm; struct obd_client_handle **och_p = NULL; __u64 *och_usecount = NULL; struct ll_file_data *fd; @@ -510,21 +552,21 @@ int ll_file_open(struct inode *inode, struct file *file) it = file->private_data; /* XXX: compat macro */ file->private_data = NULL; /* prevent ll_local_open assertion */ - fd = ll_file_data_get(); - if (fd == NULL) - GOTO(out_och_free, rc = -ENOMEM); - - fd->fd_file = file; - if (S_ISDIR(inode->i_mode)) { - cfs_spin_lock(&lli->lli_sa_lock); - if (lli->lli_opendir_key == NULL && lli->lli_sai == NULL && - lli->lli_opendir_pid == 0) { - lli->lli_opendir_key = fd; - lli->lli_opendir_pid = cfs_curproc_pid(); - opendir_set = 1; - } - cfs_spin_unlock(&lli->lli_sa_lock); - } + fd = ll_file_data_get(); + if (fd == NULL) + GOTO(out_openerr, rc = -ENOMEM); + + fd->fd_file = file; + if (S_ISDIR(inode->i_mode)) { + spin_lock(&lli->lli_sa_lock); + if (lli->lli_opendir_key == NULL && lli->lli_sai == NULL && + lli->lli_opendir_pid == 0) { + lli->lli_opendir_key = fd; + lli->lli_opendir_pid = cfs_curproc_pid(); + opendir_set = 1; + } + spin_unlock(&lli->lli_sa_lock); + } if (inode->i_sb->s_root == file->f_dentry) { LUSTRE_FPRIVATE(file) = fd; @@ -573,14 +615,14 @@ restart: och_usecount = &lli->lli_open_fd_read_count; } - cfs_mutex_lock(&lli->lli_och_mutex); + mutex_lock(&lli->lli_och_mutex); if (*och_p) { /* Open handle is present */ if (it_disposition(it, DISP_OPEN_OPEN)) { /* Well, there's extra open request that we do not need, let's close it somehow. This will decref request. */ rc = it_open_error(DISP_OPEN_OPEN, it); if (rc) { - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); GOTO(out_openerr, rc); } @@ -591,7 +633,7 @@ restart: rc = ll_local_open(file, it, fd, NULL); if (rc) { (*och_usecount)--; - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); GOTO(out_openerr, rc); } } else { @@ -602,7 +644,7 @@ restart: could be cancelled, and since blocking ast handler would attempt to grab och_mutex as well, that would result in a deadlock */ - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); it->it_create_mode |= M_CHECK_STALE; rc = ll_intent_file_open(file, NULL, 0, it); it->it_create_mode &= ~M_CHECK_STALE; @@ -632,7 +674,7 @@ restart: if (rc) GOTO(out_och_free, rc); } - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); fd = NULL; /* Must do this outside lli_och_mutex lock to prevent deadlock where @@ -643,8 +685,7 @@ restart: ll_capa_open(inode); - lsm = lli->lli_smd; - if (lsm == NULL) { + if (!lli->lli_has_smd) { if (file->f_flags & O_LOV_DELAY_CREATE || !(file->f_mode & FMODE_WRITE)) { CDEBUG(D_INODE, "object creation was delayed\n"); @@ -655,18 +696,13 @@ restart: GOTO(out_och_free, rc); out_och_free: - if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) { - ptlrpc_req_finished(it->d.lustre.it_data); - it_clear_disposition(it, DISP_ENQ_OPEN_REF); - } - if (rc) { if (och_p && *och_p) { OBD_FREE(*och_p, sizeof (struct obd_client_handle)); *och_p = NULL; /* OBD_FREE writes some magic there */ (*och_usecount)--; } - cfs_mutex_unlock(&lli->lli_och_mutex); + mutex_unlock(&lli->lli_och_mutex); out_openerr: if (opendir_set != 0) @@ -677,9 +713,209 @@ out_openerr: ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1); } + if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) { + ptlrpc_req_finished(it->d.lustre.it_data); + it_clear_disposition(it, DISP_ENQ_OPEN_REF); + } + return rc; } +static int ll_md_blocking_lease_ast(struct ldlm_lock *lock, + struct ldlm_lock_desc *desc, void *data, int flag) +{ + int rc; + struct lustre_handle lockh; + ENTRY; + + switch (flag) { + case LDLM_CB_BLOCKING: + ldlm_lock2handle(lock, &lockh); + rc = ldlm_cli_cancel(&lockh, LCF_ASYNC); + if (rc < 0) { + CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc); + RETURN(rc); + } + break; + case LDLM_CB_CANCELING: + /* do nothing */ + break; + } + RETURN(0); +} + +/** + * Acquire a lease and open the file. + */ +struct obd_client_handle *ll_lease_open(struct inode *inode, struct file *file, + fmode_t fmode, __u64 open_flags) +{ + struct lookup_intent it = { .it_op = IT_OPEN }; + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct md_op_data *op_data; + struct ptlrpc_request *req; + struct lustre_handle old_handle = { 0 }; + struct obd_client_handle *och = NULL; + int rc; + int rc2; + ENTRY; + + if (fmode != FMODE_WRITE && fmode != FMODE_READ) + RETURN(ERR_PTR(-EINVAL)); + + if (file != NULL) { + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct obd_client_handle **och_p; + __u64 *och_usecount; + + if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC)) + RETURN(ERR_PTR(-EPERM)); + + /* Get the openhandle of the file */ + rc = -EBUSY; + mutex_lock(&lli->lli_och_mutex); + if (fd->fd_lease_och != NULL) { + mutex_unlock(&lli->lli_och_mutex); + RETURN(ERR_PTR(rc)); + } + + if (fd->fd_och == NULL) { + if (file->f_mode & FMODE_WRITE) { + LASSERT(lli->lli_mds_write_och != NULL); + och_p = &lli->lli_mds_write_och; + och_usecount = &lli->lli_open_fd_write_count; + } else { + LASSERT(lli->lli_mds_read_och != NULL); + och_p = &lli->lli_mds_read_och; + och_usecount = &lli->lli_open_fd_read_count; + } + if (*och_usecount == 1) { + fd->fd_och = *och_p; + *och_p = NULL; + *och_usecount = 0; + rc = 0; + } + } + mutex_unlock(&lli->lli_och_mutex); + if (rc < 0) /* more than 1 opener */ + RETURN(ERR_PTR(rc)); + + LASSERT(fd->fd_och != NULL); + old_handle = fd->fd_och->och_fh; + } + + OBD_ALLOC_PTR(och); + if (och == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0, + LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) + GOTO(out, rc = PTR_ERR(op_data)); + + /* To tell the MDT this openhandle is from the same owner */ + op_data->op_handle = old_handle; + + it.it_flags = fmode | open_flags; + it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE; + rc = md_intent_lock(sbi->ll_md_exp, op_data, NULL, 0, &it, 0, &req, + ll_md_blocking_lease_ast, + /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise + * it can be cancelled which may mislead applications that the lease is + * broken; + * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal + * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast + * doesn't deal with openhandle, so normal openhandle will be leaked. */ + LDLM_FL_NO_LRU | LDLM_FL_EXCL); + ll_finish_md_op_data(op_data); + if (req != NULL) { + ptlrpc_req_finished(req); + it_clear_disposition(&it, DISP_ENQ_COMPLETE); + } + if (rc < 0) + GOTO(out_release_it, rc); + + if (it_disposition(&it, DISP_LOOKUP_NEG)) + GOTO(out_release_it, rc = -ENOENT); + + rc = it_open_error(DISP_OPEN_OPEN, &it); + if (rc) + GOTO(out_release_it, rc); + + LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF)); + ll_och_fill(sbi->ll_md_exp, &it, och); + + if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */ + GOTO(out_close, rc = -EOPNOTSUPP); + + /* already get lease, handle lease lock */ + ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL); + if (it.d.lustre.it_lock_mode == 0 || + it.d.lustre.it_lock_bits != MDS_INODELOCK_OPEN) { + /* open lock must return for lease */ + CERROR(DFID "lease granted but no open lock, %d/%Lu.\n", + PFID(ll_inode2fid(inode)), it.d.lustre.it_lock_mode, + it.d.lustre.it_lock_bits); + GOTO(out_close, rc = -EPROTO); + } + + ll_intent_release(&it); + RETURN(och); + +out_close: + rc2 = ll_close_inode_openhandle(sbi->ll_md_exp, inode, och, NULL); + if (rc2) + CERROR("Close openhandle returned %d\n", rc2); + + /* cancel open lock */ + if (it.d.lustre.it_lock_mode != 0) { + ldlm_lock_decref_and_cancel(&och->och_lease_handle, + it.d.lustre.it_lock_mode); + it.d.lustre.it_lock_mode = 0; + } +out_release_it: + ll_intent_release(&it); +out: + OBD_FREE_PTR(och); + RETURN(ERR_PTR(rc)); +} +EXPORT_SYMBOL(ll_lease_open); + +/** + * Release lease and close the file. + * It will check if the lease has ever broken. + */ +int ll_lease_close(struct obd_client_handle *och, struct inode *inode, + bool *lease_broken) +{ + struct ldlm_lock *lock; + bool cancelled = true; + int rc; + ENTRY; + + lock = ldlm_handle2lock(&och->och_lease_handle); + if (lock != NULL) { + lock_res_and_lock(lock); + cancelled = ldlm_is_cancel(lock); + unlock_res_and_lock(lock); + ldlm_lock_put(lock); + } + + CDEBUG(D_INODE, "lease for "DFID" broken? %d\n", + PFID(&ll_i2info(inode)->lli_fid), cancelled); + + if (!cancelled) + ldlm_cli_cancel(&och->och_lease_handle, 0); + if (lease_broken != NULL) + *lease_broken = cancelled; + + rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och, + NULL); + RETURN(rc); +} +EXPORT_SYMBOL(ll_lease_close); + /* Fills the obdo with the attributes for the lsm */ static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp, struct obd_capa *capa, struct obdo *obdo, @@ -695,8 +931,7 @@ static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp, oinfo.oi_md = lsm; oinfo.oi_oa = obdo; - oinfo.oi_oa->o_id = lsm->lsm_object_id; - oinfo.oi_oa->o_seq = lsm->lsm_object_seq; + oinfo.oi_oa->o_oi = lsm->lsm_oi; oinfo.oi_oa->o_mode = S_IFREG; oinfo.oi_oa->o_ioepoch = ioepoch; oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | @@ -736,55 +971,71 @@ static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp, int ll_inode_getattr(struct inode *inode, struct obdo *obdo, __u64 ioepoch, int sync) { - struct ll_inode_info *lli = ll_i2info(inode); - struct obd_capa *capa = ll_mdscapa_get(inode); - int rc; - ENTRY; + struct obd_capa *capa = ll_mdscapa_get(inode); + struct lov_stripe_md *lsm; + int rc; + ENTRY; - rc = ll_lsm_getattr(lli->lli_smd, ll_i2dtexp(inode), - capa, obdo, ioepoch, sync); - capa_put(capa); - if (rc == 0) { - obdo_refresh_inode(inode, obdo, obdo->o_valid); - CDEBUG(D_INODE, - "objid "LPX64" size %llu, blocks %llu, blksize %lu\n", - lli->lli_smd->lsm_object_id, i_size_read(inode), - (unsigned long long)inode->i_blocks, - (unsigned long)ll_inode_blksize(inode)); - } - RETURN(rc); + lsm = ccc_inode_lsm_get(inode); + rc = ll_lsm_getattr(lsm, ll_i2dtexp(inode), + capa, obdo, ioepoch, sync); + capa_put(capa); + if (rc == 0) { + struct ost_id *oi = lsm ? &lsm->lsm_oi : &obdo->o_oi; + + obdo_refresh_inode(inode, obdo, obdo->o_valid); + CDEBUG(D_INODE, "objid "DOSTID" size %llu, blocks %llu," + " blksize %lu\n", POSTID(oi), i_size_read(inode), + (unsigned long long)inode->i_blocks, + (unsigned long)ll_inode_blksize(inode)); + } + ccc_inode_lsm_put(inode, lsm); + RETURN(rc); } -int ll_merge_lvb(struct inode *inode) +int ll_merge_lvb(const struct lu_env *env, struct inode *inode) { - struct ll_inode_info *lli = ll_i2info(inode); - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ost_lvb lvb; - int rc; + struct ll_inode_info *lli = ll_i2info(inode); + struct cl_object *obj = lli->lli_clob; + struct cl_attr *attr = ccc_env_thread_attr(env); + struct ost_lvb lvb; + int rc = 0; - ENTRY; - - ll_inode_size_lock(inode, 1); - inode_init_lvb(inode, &lvb); - - /* merge timestamps the most resently obtained from mds with - timestamps obtained from osts */ - lvb.lvb_atime = lli->lli_lvb.lvb_atime; - lvb.lvb_mtime = lli->lli_lvb.lvb_mtime; - lvb.lvb_ctime = lli->lli_lvb.lvb_ctime; - rc = obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0); - cl_isize_write_nolock(inode, lvb.lvb_size); - - CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n", - PFID(&lli->lli_fid), lvb.lvb_size); - inode->i_blocks = lvb.lvb_blocks; + ENTRY; - LTIME_S(inode->i_mtime) = lvb.lvb_mtime; - LTIME_S(inode->i_atime) = lvb.lvb_atime; - LTIME_S(inode->i_ctime) = lvb.lvb_ctime; - ll_inode_size_unlock(inode, 1); + ll_inode_size_lock(inode); + /* merge timestamps the most recently obtained from mds with + timestamps obtained from osts */ + LTIME_S(inode->i_atime) = lli->lli_lvb.lvb_atime; + LTIME_S(inode->i_mtime) = lli->lli_lvb.lvb_mtime; + LTIME_S(inode->i_ctime) = lli->lli_lvb.lvb_ctime; + inode_init_lvb(inode, &lvb); + + cl_object_attr_lock(obj); + rc = cl_object_attr_get(env, obj, attr); + cl_object_attr_unlock(obj); + + if (rc == 0) { + if (lvb.lvb_atime < attr->cat_atime) + lvb.lvb_atime = attr->cat_atime; + if (lvb.lvb_ctime < attr->cat_ctime) + lvb.lvb_ctime = attr->cat_ctime; + if (lvb.lvb_mtime < attr->cat_mtime) + lvb.lvb_mtime = attr->cat_mtime; + + CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n", + PFID(&lli->lli_fid), attr->cat_size); + cl_isize_write_nolock(inode, attr->cat_size); + + inode->i_blocks = attr->cat_blocks; + + LTIME_S(inode->i_mtime) = lvb.lvb_mtime; + LTIME_S(inode->i_atime) = lvb.lvb_atime; + LTIME_S(inode->i_ctime) = lvb.lvb_ctime; + } + ll_inode_size_unlock(inode); - RETURN(rc); + RETURN(rc); } int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm, @@ -811,7 +1062,9 @@ void ll_io_init(struct cl_io *io, const struct file *file, int write) io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK; if (write) { io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND); - io->u.ci_wr.wr_sync = file->f_flags & O_SYNC || IS_SYNC(inode); + io->u.ci_wr.wr_sync = file->f_flags & O_SYNC || + file->f_flags & O_DIRECT || + IS_SYNC(inode); } io->ci_obj = ll_i2info(inode)->lli_clob; io->ci_lockreq = CILR_MAYBE; @@ -823,15 +1076,18 @@ void ll_io_init(struct cl_io *io, const struct file *file, int write) } } -static ssize_t ll_file_io_generic(const struct lu_env *env, - struct vvp_io_args *args, struct file *file, - enum cl_io_type iot, loff_t *ppos, size_t count) +static ssize_t +ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args, + struct file *file, enum cl_io_type iot, + loff_t *ppos, size_t count) { - struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode); + struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); struct cl_io *io; ssize_t result; ENTRY; +restart: io = ccc_env_thread_io(env); ll_io_init(io, file, iot == CIT_WRITE); @@ -848,17 +1104,15 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, cio->cui_iov = args->u.normal.via_iov; cio->cui_nrsegs = args->u.normal.via_nrsegs; cio->cui_tot_nrsegs = cio->cui_nrsegs; -#ifndef HAVE_FILE_WRITEV cio->cui_iocb = args->u.normal.via_iocb; -#endif if ((iot == CIT_WRITE) && !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) { - if (cfs_mutex_lock_interruptible(&lli-> + if (mutex_lock_interruptible(&lli-> lli_write_mutex)) GOTO(out, result = -ERESTARTSYS); write_mutex_locked = 1; } else if (iot == CIT_READ) { - cfs_down_read(&lli->lli_trunc_sem); + down_read(&lli->lli_trunc_sem); } break; case IO_SENDFILE: @@ -875,9 +1129,9 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, } result = cl_io_loop(env, io); if (write_mutex_locked) - cfs_mutex_unlock(&lli->lli_write_mutex); + mutex_unlock(&lli->lli_write_mutex); else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ) - cfs_up_read(&lli->lli_trunc_sem); + up_read(&lli->lli_trunc_sem); } else { /* cl_io_rw_init() handled IO */ result = io->ci_result; @@ -890,6 +1144,15 @@ static ssize_t ll_file_io_generic(const struct lu_env *env, GOTO(out, result); out: cl_io_fini(env, io); + /* If any bit been read/written (result != 0), we just return + * short read/write instead of restart io. */ + if ((result == 0 || result == -ENODATA) && io->ci_need_restart) { + CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zd\n", + iot == CIT_READ ? "read" : "write", + file->f_dentry->d_name.name, *ppos, count); + LASSERTF(io->ci_nob == 0, "%zd", io->ci_nob); + goto restart; + } if (iot == CIT_READ) { if (result >= 0) @@ -899,13 +1162,13 @@ out: if (result >= 0) { ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode), LPROC_LL_WRITE_BYTES, result); - lli->lli_write_rc = 0; - } else { - lli->lli_write_rc = result; - } - } + fd->fd_write_failed = false; + } else if (result != -ERESTARTSYS) { + fd->fd_write_failed = true; + } + } - return result; + return result; } @@ -940,56 +1203,6 @@ static int ll_file_get_iov_count(const struct iovec *iov, return 0; } -#ifdef HAVE_FILE_READV -static ssize_t ll_file_readv(struct file *file, const struct iovec *iov, - unsigned long nr_segs, loff_t *ppos) -{ - struct lu_env *env; - struct vvp_io_args *args; - size_t count; - ssize_t result; - int refcheck; - ENTRY; - - result = ll_file_get_iov_count(iov, &nr_segs, &count); - if (result) - RETURN(result); - - env = cl_env_get(&refcheck); - if (IS_ERR(env)) - RETURN(PTR_ERR(env)); - - args = vvp_env_args(env, IO_NORMAL); - args->u.normal.via_iov = (struct iovec *)iov; - args->u.normal.via_nrsegs = nr_segs; - - result = ll_file_io_generic(env, args, file, CIT_READ, ppos, count); - cl_env_put(env, &refcheck); - RETURN(result); -} - -static ssize_t ll_file_read(struct file *file, char *buf, size_t count, - loff_t *ppos) -{ - struct lu_env *env; - struct iovec *local_iov; - ssize_t result; - int refcheck; - ENTRY; - - env = cl_env_get(&refcheck); - if (IS_ERR(env)) - RETURN(PTR_ERR(env)); - - local_iov = &vvp_env_info(env)->vti_local_iov; - local_iov->iov_base = (void __user *)buf; - local_iov->iov_len = count; - result = ll_file_readv(file, local_iov, 1, ppos); - cl_env_put(env, &refcheck); - RETURN(result); -} - -#else static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) { @@ -1047,62 +1260,11 @@ static ssize_t ll_file_read(struct file *file, char *buf, size_t count, cl_env_put(env, &refcheck); RETURN(result); } -#endif /* * Write to a file (through the page cache). + * AIO stuff */ -#ifdef HAVE_FILE_WRITEV -static ssize_t ll_file_writev(struct file *file, const struct iovec *iov, - unsigned long nr_segs, loff_t *ppos) -{ - struct lu_env *env; - struct vvp_io_args *args; - size_t count; - ssize_t result; - int refcheck; - ENTRY; - - result = ll_file_get_iov_count(iov, &nr_segs, &count); - if (result) - RETURN(result); - - env = cl_env_get(&refcheck); - if (IS_ERR(env)) - RETURN(PTR_ERR(env)); - - args = vvp_env_args(env, IO_NORMAL); - args->u.normal.via_iov = (struct iovec *)iov; - args->u.normal.via_nrsegs = nr_segs; - - result = ll_file_io_generic(env, args, file, CIT_WRITE, ppos, count); - cl_env_put(env, &refcheck); - RETURN(result); -} - -static ssize_t ll_file_write(struct file *file, const char *buf, size_t count, - loff_t *ppos) -{ - struct lu_env *env; - struct iovec *local_iov; - ssize_t result; - int refcheck; - ENTRY; - - env = cl_env_get(&refcheck); - if (IS_ERR(env)) - RETURN(PTR_ERR(env)); - - local_iov = &vvp_env_info(env)->vti_local_iov; - local_iov->iov_base = (void __user *)buf; - local_iov->iov_len = count; - - result = ll_file_writev(file, local_iov, 1, ppos); - cl_env_put(env, &refcheck); - RETURN(result); -} - -#else /* AIO stuff */ static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos) { @@ -1160,37 +1322,7 @@ static ssize_t ll_file_write(struct file *file, const char *buf, size_t count, cl_env_put(env, &refcheck); RETURN(result); } -#endif - - -#ifdef HAVE_KERNEL_SENDFILE -/* - * Send file content (through pagecache) somewhere with helper - */ -static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count, - read_actor_t actor, void *target) -{ - struct lu_env *env; - struct vvp_io_args *args; - ssize_t result; - int refcheck; - ENTRY; - - env = cl_env_get(&refcheck); - if (IS_ERR(env)) - RETURN(PTR_ERR(env)); - - args = vvp_env_args(env, IO_SENDFILE); - args->u.sendfile.via_target = target; - args->u.sendfile.via_actor = actor; - - result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count); - cl_env_put(env, &refcheck); - RETURN(result); -} -#endif -#ifdef HAVE_KERNEL_SPLICE_READ /* * Send file content (through pagecache) somewhere with helper */ @@ -1216,27 +1348,26 @@ static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos, cl_env_put(env, &refcheck); RETURN(result); } -#endif -static int ll_lov_recreate(struct inode *inode, obd_id id, obd_seq seq, +static int ll_lov_recreate(struct inode *inode, struct ost_id *oi, obd_count ost_idx) { - struct obd_export *exp = ll_i2dtexp(inode); - struct obd_trans_info oti = { 0 }; - struct obdo *oa = NULL; - int lsm_size; - int rc = 0; - struct lov_stripe_md *lsm, *lsm2; - ENTRY; + struct obd_export *exp = ll_i2dtexp(inode); + struct obd_trans_info oti = { 0 }; + struct obdo *oa = NULL; + int lsm_size; + int rc = 0; + struct lov_stripe_md *lsm = NULL, *lsm2; + ENTRY; - OBDO_ALLOC(oa); - if (oa == NULL) - RETURN(-ENOMEM); + OBDO_ALLOC(oa); + if (oa == NULL) + RETURN(-ENOMEM); - ll_inode_size_lock(inode, 0); - lsm = ll_i2info(inode)->lli_smd; - if (lsm == NULL) + lsm = ccc_inode_lsm_get(inode); + if (!lsm_has_objects(lsm)) GOTO(out, rc = -ENOENT); + lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) * (lsm->lsm_stripe_count)); @@ -1244,8 +1375,7 @@ static int ll_lov_recreate(struct inode *inode, obd_id id, obd_seq seq, if (lsm2 == NULL) GOTO(out, rc = -ENOMEM); - oa->o_id = id; - oa->o_seq = seq; + oa->o_oi = *oi; oa->o_nlink = ost_idx; oa->o_flags |= OBD_FL_RECREATE_OBJS; oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP; @@ -1253,68 +1383,72 @@ static int ll_lov_recreate(struct inode *inode, obd_id id, obd_seq seq, OBD_MD_FLMTIME | OBD_MD_FLCTIME); obdo_set_parent_fid(oa, &ll_i2info(inode)->lli_fid); memcpy(lsm2, lsm, lsm_size); - rc = obd_create(NULL, exp, oa, &lsm2, &oti); + ll_inode_size_lock(inode); + rc = obd_create(NULL, exp, oa, &lsm2, &oti); + ll_inode_size_unlock(inode); - OBD_FREE_LARGE(lsm2, lsm_size); - GOTO(out, rc); + OBD_FREE_LARGE(lsm2, lsm_size); + GOTO(out, rc); out: - ll_inode_size_unlock(inode, 0); - OBDO_FREE(oa); - return rc; + ccc_inode_lsm_put(inode, lsm); + OBDO_FREE(oa); + return rc; } static int ll_lov_recreate_obj(struct inode *inode, unsigned long arg) { - struct ll_recreate_obj ucreat; - ENTRY; + struct ll_recreate_obj ucreat; + struct ost_id oi; + ENTRY; - if (!cfs_capable(CFS_CAP_SYS_ADMIN)) - RETURN(-EPERM); + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); - if (cfs_copy_from_user(&ucreat, (struct ll_recreate_obj *)arg, - sizeof(struct ll_recreate_obj))) - RETURN(-EFAULT); + if (copy_from_user(&ucreat, (struct ll_recreate_obj *)arg, + sizeof(ucreat))) + RETURN(-EFAULT); - RETURN(ll_lov_recreate(inode, ucreat.lrc_id, 0, - ucreat.lrc_ost_idx)); + ostid_set_seq_mdt0(&oi); + ostid_set_id(&oi, ucreat.lrc_id); + RETURN(ll_lov_recreate(inode, &oi, ucreat.lrc_ost_idx)); } static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg) { - struct lu_fid fid; - obd_id id; - obd_count ost_idx; + struct lu_fid fid; + struct ost_id oi; + obd_count ost_idx; ENTRY; - if (!cfs_capable(CFS_CAP_SYS_ADMIN)) - RETURN(-EPERM); + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); - if (cfs_copy_from_user(&fid, (struct lu_fid *)arg, - sizeof(struct lu_fid))) - RETURN(-EFAULT); + if (copy_from_user(&fid, (struct lu_fid *)arg, sizeof(fid))) + RETURN(-EFAULT); - id = fid_oid(&fid) | ((fid_seq(&fid) & 0xffff) << 32); - ost_idx = (fid_seq(&fid) >> 16) & 0xffff; - RETURN(ll_lov_recreate(inode, id, 0, ost_idx)); + fid_to_ostid(&fid, &oi); + ost_idx = (fid_seq(&fid) >> 16) & 0xffff; + RETURN(ll_lov_recreate(inode, &oi, ost_idx)); } int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, - int flags, struct lov_user_md *lum, int lum_size) + __u64 flags, struct lov_user_md *lum, + int lum_size) { - struct lov_stripe_md *lsm; - struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags}; - int rc = 0; - ENTRY; + struct lov_stripe_md *lsm = NULL; + struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags}; + int rc = 0; + ENTRY; - ll_inode_size_lock(inode, 0); - lsm = ll_i2info(inode)->lli_smd; - if (lsm) { - ll_inode_size_unlock(inode, 0); - CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n", - inode->i_ino); - RETURN(-EEXIST); - } + lsm = ccc_inode_lsm_get(inode); + if (lsm != NULL) { + ccc_inode_lsm_put(inode, lsm); + CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n", + inode->i_ino); + RETURN(-EEXIST); + } + ll_inode_size_lock(inode); rc = ll_intent_file_open(file, lum, lum_size, &oit); if (rc) GOTO(out, rc); @@ -1325,12 +1459,13 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file, ll_release_openhandle(file->f_dentry, &oit); out: - ll_inode_size_unlock(inode, 0); - ll_intent_release(&oit); - RETURN(rc); + ll_inode_size_unlock(inode); + ll_intent_release(&oit); + ccc_inode_lsm_put(inode, lsm); + RETURN(rc); out_req_free: - ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data); - goto out; + ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data); + goto out; } int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, @@ -1387,6 +1522,12 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, * passing it to userspace. */ if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) { + int stripe_count; + + stripe_count = le16_to_cpu(lmm->lmm_stripe_count); + if (le32_to_cpu(lmm->lmm_pattern) & LOV_PATTERN_F_RELEASED) + stripe_count = 0; + /* if function called for directory - we should * avoid swab not existent lsm objects */ if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) { @@ -1394,13 +1535,13 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, if (S_ISREG(body->mode)) lustre_swab_lov_user_md_objects( ((struct lov_user_md_v1 *)lmm)->lmm_objects, - ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count); + stripe_count); } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) { lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm); if (S_ISREG(body->mode)) lustre_swab_lov_user_md_objects( ((struct lov_user_md_v3 *)lmm)->lmm_objects, - ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count); + stripe_count); } } @@ -1414,74 +1555,81 @@ out: static int ll_lov_setea(struct inode *inode, struct file *file, unsigned long arg) { - int flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE; - struct lov_user_md *lump; - int lum_size = sizeof(struct lov_user_md) + - sizeof(struct lov_user_ost_data); - int rc; - ENTRY; + __u64 flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE; + struct lov_user_md *lump; + int lum_size = sizeof(struct lov_user_md) + + sizeof(struct lov_user_ost_data); + int rc; + ENTRY; - if (!cfs_capable(CFS_CAP_SYS_ADMIN)) - RETURN(-EPERM); + if (!cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); - OBD_ALLOC_LARGE(lump, lum_size); - if (lump == NULL) { + OBD_ALLOC_LARGE(lump, lum_size); + if (lump == NULL) RETURN(-ENOMEM); - } - if (cfs_copy_from_user(lump, (struct lov_user_md *)arg, lum_size)) { - OBD_FREE_LARGE(lump, lum_size); - RETURN(-EFAULT); - } - rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size); + if (copy_from_user(lump, (struct lov_user_md *)arg, lum_size)) { + OBD_FREE_LARGE(lump, lum_size); + RETURN(-EFAULT); + } + + rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size); - OBD_FREE_LARGE(lump, lum_size); - RETURN(rc); + OBD_FREE_LARGE(lump, lum_size); + RETURN(rc); } static int ll_lov_setstripe(struct inode *inode, struct file *file, - unsigned long arg) -{ - struct lov_user_md_v3 lumv3; - struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3; - struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg; - struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg; - int lum_size; - int rc; - int flags = FMODE_WRITE; - ENTRY; + unsigned long arg) +{ + struct lov_user_md_v3 lumv3; + struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3; + struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg; + struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg; + int lum_size, rc; + __u64 flags = FMODE_WRITE; + ENTRY; - /* first try with v1 which is smaller than v3 */ - lum_size = sizeof(struct lov_user_md_v1); - if (cfs_copy_from_user(lumv1, lumv1p, lum_size)) - RETURN(-EFAULT); + /* first try with v1 which is smaller than v3 */ + lum_size = sizeof(struct lov_user_md_v1); + if (copy_from_user(lumv1, lumv1p, lum_size)) + RETURN(-EFAULT); - if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) { - lum_size = sizeof(struct lov_user_md_v3); - if (cfs_copy_from_user(&lumv3, lumv3p, lum_size)) - RETURN(-EFAULT); - } + if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) { + lum_size = sizeof(struct lov_user_md_v3); + if (copy_from_user(&lumv3, lumv3p, lum_size)) + RETURN(-EFAULT); + } - rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size); - if (rc == 0) { - put_user(0, &lumv1p->lmm_stripe_count); - rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), - 0, ll_i2info(inode)->lli_smd, - (void *)arg); - } - RETURN(rc); + rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size); + if (rc == 0) { + struct lov_stripe_md *lsm; + __u32 gen; + + put_user(0, &lumv1p->lmm_stripe_count); + + ll_layout_refresh(inode, &gen); + lsm = ccc_inode_lsm_get(inode); + rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), + 0, lsm, (void *)arg); + ccc_inode_lsm_put(inode, lsm); + } + RETURN(rc); } static int ll_lov_getstripe(struct inode *inode, unsigned long arg) { - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; - int rc = -ENODATA; - ENTRY; + struct lov_stripe_md *lsm; + int rc = -ENODATA; + ENTRY; - if (lsm != NULL) - rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, - lsm, (void *)arg); - RETURN(rc); + lsm = ccc_inode_lsm_get(inode); + if (lsm != NULL) + rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, + lsm, (void *)arg); + ccc_inode_lsm_put(inode, lsm); + RETURN(rc); } int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg) @@ -1495,47 +1643,47 @@ int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg) if (ll_file_nolock(file)) RETURN(-EOPNOTSUPP); - cfs_spin_lock(&lli->lli_lock); - if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { - CWARN("group lock already existed with gid %lu\n", - fd->fd_grouplock.cg_gid); - cfs_spin_unlock(&lli->lli_lock); - RETURN(-EINVAL); - } - LASSERT(fd->fd_grouplock.cg_lock == NULL); - cfs_spin_unlock(&lli->lli_lock); + spin_lock(&lli->lli_lock); + if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { + CWARN("group lock already existed with gid %lu\n", + fd->fd_grouplock.cg_gid); + spin_unlock(&lli->lli_lock); + RETURN(-EINVAL); + } + LASSERT(fd->fd_grouplock.cg_lock == NULL); + spin_unlock(&lli->lli_lock); + + rc = cl_get_grouplock(cl_i2info(inode)->lli_clob, + arg, (file->f_flags & O_NONBLOCK), &grouplock); + if (rc) + RETURN(rc); + + spin_lock(&lli->lli_lock); + if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { + spin_unlock(&lli->lli_lock); + CERROR("another thread just won the race\n"); + cl_put_grouplock(&grouplock); + RETURN(-EINVAL); + } - rc = cl_get_grouplock(cl_i2info(inode)->lli_clob, - arg, (file->f_flags & O_NONBLOCK), &grouplock); - if (rc) - RETURN(rc); - - cfs_spin_lock(&lli->lli_lock); - if (fd->fd_flags & LL_FILE_GROUP_LOCKED) { - cfs_spin_unlock(&lli->lli_lock); - CERROR("another thread just won the race\n"); - cl_put_grouplock(&grouplock); - RETURN(-EINVAL); - } - - fd->fd_flags |= LL_FILE_GROUP_LOCKED; - fd->fd_grouplock = grouplock; - cfs_spin_unlock(&lli->lli_lock); + fd->fd_flags |= LL_FILE_GROUP_LOCKED; + fd->fd_grouplock = grouplock; + spin_unlock(&lli->lli_lock); - CDEBUG(D_INFO, "group lock %lu obtained\n", arg); - RETURN(0); + CDEBUG(D_INFO, "group lock %lu obtained\n", arg); + RETURN(0); } int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg) { - struct ll_inode_info *lli = ll_i2info(inode); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); - struct ccc_grouplock grouplock; - ENTRY; + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ccc_grouplock grouplock; + ENTRY; - cfs_spin_lock(&lli->lli_lock); - if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) { - cfs_spin_unlock(&lli->lli_lock); + spin_lock(&lli->lli_lock); + if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) { + spin_unlock(&lli->lli_lock); CWARN("no group lock held\n"); RETURN(-EINVAL); } @@ -1544,18 +1692,18 @@ int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg) if (fd->fd_grouplock.cg_gid != arg) { CWARN("group lock %lu doesn't match current id %lu\n", arg, fd->fd_grouplock.cg_gid); - cfs_spin_unlock(&lli->lli_lock); - RETURN(-EINVAL); - } + spin_unlock(&lli->lli_lock); + RETURN(-EINVAL); + } - grouplock = fd->fd_grouplock; - memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock)); - fd->fd_flags &= ~LL_FILE_GROUP_LOCKED; - cfs_spin_unlock(&lli->lli_lock); + grouplock = fd->fd_grouplock; + memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock)); + fd->fd_flags &= ~LL_FILE_GROUP_LOCKED; + spin_unlock(&lli->lli_lock); - cl_put_grouplock(&grouplock); - CDEBUG(D_INFO, "group lock %lu released\n", arg); - RETURN(0); + cl_put_grouplock(&grouplock); + CDEBUG(D_INFO, "group lock %lu released\n", arg); + RETURN(0); } /** @@ -1590,18 +1738,17 @@ int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it) if (!och) GOTO(out, rc = -ENOMEM); - ll_och_fill(ll_i2sbi(inode)->ll_md_exp, - ll_i2info(inode), it, och); + ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och); rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, - inode, och); - out: - /* this one is in place of ll_file_open */ - if (it_disposition(it, DISP_ENQ_OPEN_REF)) { - ptlrpc_req_finished(it->d.lustre.it_data); - it_clear_disposition(it, DISP_ENQ_OPEN_REF); - } - RETURN(rc); + inode, och, NULL); +out: + /* this one is in place of ll_file_open */ + if (it_disposition(it, DISP_ENQ_OPEN_REF)) { + ptlrpc_req_finished(it->d.lustre.it_data); + it_clear_disposition(it, DISP_ENQ_OPEN_REF); + } + RETURN(rc); } /** @@ -1611,8 +1758,8 @@ int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it) int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap, int num_bytes) { - struct obd_export *exp = ll_i2dtexp(inode); - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; + struct obd_export *exp = ll_i2dtexp(inode); + struct lov_stripe_md *lsm = NULL; struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, }; int vallen = num_bytes; int rc; @@ -1631,15 +1778,18 @@ int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap, return rc; } - /* If the stripe_count > 1 and the application does not understand - * DEVICE_ORDER flag, then it cannot interpret the extents correctly. - */ - if (lsm->lsm_stripe_count > 1 && - !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER)) - return -EOPNOTSUPP; + lsm = ccc_inode_lsm_get(inode); + if (lsm == NULL) + return -ENOENT; + + /* If the stripe_count > 1 and the application does not understand + * DEVICE_ORDER flag, then it cannot interpret the extents correctly. + */ + if (lsm->lsm_stripe_count > 1 && + !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER)) + GOTO(out, rc = -EOPNOTSUPP); - fm_key.oa.o_id = lsm->lsm_object_id; - fm_key.oa.o_seq = lsm->lsm_object_seq; + fm_key.oa.o_oi = lsm->lsm_oi; fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP; obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE); @@ -1647,7 +1797,7 @@ int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap, /* If filesize is 0, then there would be no objects for mapping */ if (fm_key.oa.o_size == 0) { fiemap->fm_mapped_extents = 0; - RETURN(0); + GOTO(out, rc = 0); } memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap)); @@ -1657,43 +1807,51 @@ int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap, if (rc) CERROR("obd_get_info failed: rc = %d\n", rc); - RETURN(rc); +out: + ccc_inode_lsm_put(inode, lsm); + RETURN(rc); } -int ll_fid2path(struct obd_export *exp, void *arg) +int ll_fid2path(struct inode *inode, void *arg) { - struct getinfo_fid2path *gfout, *gfin; - int outsize, rc; - ENTRY; + struct obd_export *exp = ll_i2mdexp(inode); + struct getinfo_fid2path *gfout, *gfin; + int outsize, rc; + ENTRY; - /* Need to get the buflen */ - OBD_ALLOC_PTR(gfin); - if (gfin == NULL) - RETURN(-ENOMEM); - if (cfs_copy_from_user(gfin, arg, sizeof(*gfin))) { - OBD_FREE_PTR(gfin); - RETURN(-EFAULT); - } + if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) && + !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH)) + RETURN(-EPERM); + + /* Need to get the buflen */ + OBD_ALLOC_PTR(gfin); + if (gfin == NULL) + RETURN(-ENOMEM); + if (copy_from_user(gfin, arg, sizeof(*gfin))) { + OBD_FREE_PTR(gfin); + RETURN(-EFAULT); + } - outsize = sizeof(*gfout) + gfin->gf_pathlen; - OBD_ALLOC(gfout, outsize); - if (gfout == NULL) { - OBD_FREE_PTR(gfin); - RETURN(-ENOMEM); - } - memcpy(gfout, gfin, sizeof(*gfout)); - OBD_FREE_PTR(gfin); + outsize = sizeof(*gfout) + gfin->gf_pathlen; + OBD_ALLOC(gfout, outsize); + if (gfout == NULL) { + OBD_FREE_PTR(gfin); + RETURN(-ENOMEM); + } + memcpy(gfout, gfin, sizeof(*gfout)); + OBD_FREE_PTR(gfin); - /* Call mdc_iocontrol */ - rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL); - if (rc) - GOTO(gf_free, rc); - if (cfs_copy_to_user(arg, gfout, outsize)) - rc = -EFAULT; + /* Call mdc_iocontrol */ + rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL); + if (rc) + GOTO(gf_free, rc); + + if (copy_to_user(arg, gfout, outsize)) + rc = -EFAULT; gf_free: - OBD_FREE(gfout, outsize); - RETURN(rc); + OBD_FREE(gfout, outsize); + RETURN(rc); } static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg) @@ -1715,10 +1873,10 @@ static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg) if (fiemap_s == NULL) RETURN(-ENOMEM); - /* get the fiemap value */ - if (copy_from_user(fiemap_s,(struct ll_user_fiemap __user *)arg, - sizeof(*fiemap_s))) - GOTO(error, rc = -EFAULT); + /* get the fiemap value */ + if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg, + sizeof(*fiemap_s))) + GOTO(error, rc = -EFAULT); /* If fm_extent_count is non-zero, read the first extent since * it is used to calculate end_offset and device from previous @@ -1740,8 +1898,8 @@ static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg) ret_bytes += (fiemap_s->fm_mapped_extents * sizeof(struct ll_fiemap_extent)); - if (copy_to_user((void *)arg, fiemap_s, ret_bytes)) - rc = -EFAULT; + if (copy_to_user((void *)arg, fiemap_s, ret_bytes)) + rc = -EFAULT; error: OBD_FREE_LARGE(fiemap_s, num_bytes); @@ -1755,48 +1913,338 @@ error: * Version is computed using server side locking. * * @param extent_lock Take extent lock. Not needed if a process is already - * holding the OST object group locks. + * holding the OST object group locks. */ -static int ll_data_version(struct inode *inode, __u64 *data_version, - int extent_lock) +int ll_data_version(struct inode *inode, __u64 *data_version, + int extent_lock) { - struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct obdo *obdo = NULL; - int rc; - ENTRY; + struct lov_stripe_md *lsm = NULL; + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct obdo *obdo = NULL; + int rc; + ENTRY; - /* If no stripe, we consider version is 0. */ - if (!lsm) { - *data_version = 0; - CDEBUG(D_INODE, "No object for inode\n"); - RETURN(0); - } + /* If no stripe, we consider version is 0. */ + lsm = ccc_inode_lsm_get(inode); + if (!lsm_has_objects(lsm)) { + *data_version = 0; + CDEBUG(D_INODE, "No object for inode\n"); + GOTO(out, rc = 0); + } - OBD_ALLOC_PTR(obdo); - if (obdo == NULL) - RETURN(-ENOMEM); + OBD_ALLOC_PTR(obdo); + if (obdo == NULL) + GOTO(out, rc = -ENOMEM); - rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock); - if (!rc) { - if (!(obdo->o_valid & OBD_MD_FLDATAVERSION)) - rc = -EOPNOTSUPP; - else - *data_version = obdo->o_data_version; - } + rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock); + if (rc == 0) { + if (!(obdo->o_valid & OBD_MD_FLDATAVERSION)) + rc = -EOPNOTSUPP; + else + *data_version = obdo->o_data_version; + } - OBD_FREE_PTR(obdo); + OBD_FREE_PTR(obdo); + EXIT; +out: + ccc_inode_lsm_put(inode, lsm); + RETURN(rc); +} - RETURN(rc); +/* + * Trigger a HSM release request for the provided inode. + */ +int ll_hsm_release(struct inode *inode) +{ + struct cl_env_nest nest; + struct lu_env *env; + struct obd_client_handle *och = NULL; + __u64 data_version = 0; + int rc; + ENTRY; + + CDEBUG(D_INODE, "%s: Releasing file "DFID".\n", + ll_get_fsname(inode->i_sb, NULL, 0), + PFID(&ll_i2info(inode)->lli_fid)); + + och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE); + if (IS_ERR(och)) + GOTO(out, rc = PTR_ERR(och)); + + /* Grab latest data_version and [am]time values */ + rc = ll_data_version(inode, &data_version, 1); + if (rc != 0) + GOTO(out, rc); + + env = cl_env_nested_get(&nest); + if (IS_ERR(env)) + GOTO(out, rc = PTR_ERR(env)); + + ll_merge_lvb(env, inode); + cl_env_nested_put(&nest, env); + + /* Release the file. + * NB: lease lock handle is released in mdc_hsm_release_pack() because + * we still need it to pack l_remote_handle to MDT. */ + rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och, + &data_version); + och = NULL; + + EXIT; +out: + if (och != NULL && !IS_ERR(och)) /* close the file */ + ll_lease_close(och, inode, NULL); + + return rc; } -long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +struct ll_swap_stack { + struct iattr ia1, ia2; + __u64 dv1, dv2; + struct inode *inode1, *inode2; + bool check_dv1, check_dv2; +}; + +static int ll_swap_layouts(struct file *file1, struct file *file2, + struct lustre_swap_layouts *lsl) { - struct inode *inode = file->f_dentry->d_inode; - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); - int flags; + struct mdc_swap_layouts msl; + struct md_op_data *op_data; + __u32 gid; + __u64 dv; + struct ll_swap_stack *llss = NULL; + int rc; - ENTRY; + OBD_ALLOC_PTR(llss); + if (llss == NULL) + RETURN(-ENOMEM); + + llss->inode1 = file1->f_dentry->d_inode; + llss->inode2 = file2->f_dentry->d_inode; + + if (!S_ISREG(llss->inode2->i_mode)) + GOTO(free, rc = -EINVAL); + + if (inode_permission(llss->inode1, MAY_WRITE) || + inode_permission(llss->inode2, MAY_WRITE)) + GOTO(free, rc = -EPERM); + + if (llss->inode2->i_sb != llss->inode1->i_sb) + GOTO(free, rc = -EXDEV); + + /* we use 2 bool because it is easier to swap than 2 bits */ + if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1) + llss->check_dv1 = true; + + if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2) + llss->check_dv2 = true; + + /* we cannot use lsl->sl_dvX directly because we may swap them */ + llss->dv1 = lsl->sl_dv1; + llss->dv2 = lsl->sl_dv2; + + rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2)); + if (rc == 0) /* same file, done! */ + GOTO(free, rc = 0); + + if (rc < 0) { /* sequentialize it */ + swap(llss->inode1, llss->inode2); + swap(file1, file2); + swap(llss->dv1, llss->dv2); + swap(llss->check_dv1, llss->check_dv2); + } + + gid = lsl->sl_gid; + if (gid != 0) { /* application asks to flush dirty cache */ + rc = ll_get_grouplock(llss->inode1, file1, gid); + if (rc < 0) + GOTO(free, rc); + + rc = ll_get_grouplock(llss->inode2, file2, gid); + if (rc < 0) { + ll_put_grouplock(llss->inode1, file1, gid); + GOTO(free, rc); + } + } + + /* to be able to restore mtime and atime after swap + * we need to first save them */ + if (lsl->sl_flags & + (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) { + llss->ia1.ia_mtime = llss->inode1->i_mtime; + llss->ia1.ia_atime = llss->inode1->i_atime; + llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME; + llss->ia2.ia_mtime = llss->inode2->i_mtime; + llss->ia2.ia_atime = llss->inode2->i_atime; + llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME; + } + + /* ultimate check, before swaping the layouts we check if + * dataversion has changed (if requested) */ + if (llss->check_dv1) { + rc = ll_data_version(llss->inode1, &dv, 0); + if (rc) + GOTO(putgl, rc); + if (dv != llss->dv1) + GOTO(putgl, rc = -EAGAIN); + } + + if (llss->check_dv2) { + rc = ll_data_version(llss->inode2, &dv, 0); + if (rc) + GOTO(putgl, rc); + if (dv != llss->dv2) + GOTO(putgl, rc = -EAGAIN); + } + + /* struct md_op_data is used to send the swap args to the mdt + * only flags is missing, so we use struct mdc_swap_layouts + * through the md_op_data->op_data */ + /* flags from user space have to be converted before they are send to + * server, no flag is sent today, they are only used on the client */ + msl.msl_flags = 0; + rc = -ENOMEM; + op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0, + 0, LUSTRE_OPC_ANY, &msl); + if (IS_ERR(op_data)) + GOTO(free, rc = PTR_ERR(op_data)); + + rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1), + sizeof(*op_data), op_data, NULL); + ll_finish_md_op_data(op_data); + +putgl: + if (gid != 0) { + ll_put_grouplock(llss->inode2, file2, gid); + ll_put_grouplock(llss->inode1, file1, gid); + } + + /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */ + if (rc != 0) + GOTO(free, rc); + + /* clear useless flags */ + if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) { + llss->ia1.ia_valid &= ~ATTR_MTIME; + llss->ia2.ia_valid &= ~ATTR_MTIME; + } + + if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) { + llss->ia1.ia_valid &= ~ATTR_ATIME; + llss->ia2.ia_valid &= ~ATTR_ATIME; + } + + /* update time if requested */ + rc = 0; + if (llss->ia2.ia_valid != 0) { + mutex_lock(&llss->inode1->i_mutex); + rc = ll_setattr(file1->f_dentry, &llss->ia2); + mutex_unlock(&llss->inode1->i_mutex); + } + + if (llss->ia1.ia_valid != 0) { + int rc1; + + mutex_lock(&llss->inode2->i_mutex); + rc1 = ll_setattr(file2->f_dentry, &llss->ia1); + mutex_unlock(&llss->inode2->i_mutex); + if (rc == 0) + rc = rc1; + } + +free: + if (llss != NULL) + OBD_FREE_PTR(llss); + + RETURN(rc); +} + +static int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss) +{ + struct md_op_data *op_data; + int rc; + + /* Non-root users are forbidden to set or clear flags which are + * NOT defined in HSM_USER_MASK. */ + if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) && + !cfs_capable(CFS_CAP_SYS_ADMIN)) + RETURN(-EPERM); + + op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0, + LUSTRE_OPC_ANY, hss); + if (IS_ERR(op_data)) + RETURN(PTR_ERR(op_data)); + + rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode), + sizeof(*op_data), op_data, NULL); + + ll_finish_md_op_data(op_data); + + RETURN(rc); +} + +static int ll_hsm_import(struct inode *inode, struct file *file, + struct hsm_user_import *hui) +{ + struct hsm_state_set *hss = NULL; + struct iattr *attr = NULL; + int rc; + ENTRY; + + if (!S_ISREG(inode->i_mode)) + RETURN(-EINVAL); + + /* set HSM flags */ + OBD_ALLOC_PTR(hss); + if (hss == NULL) + GOTO(out, rc = -ENOMEM); + + hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID; + hss->hss_archive_id = hui->hui_archive_id; + hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED; + rc = ll_hsm_state_set(inode, hss); + if (rc != 0) + GOTO(out, rc); + + OBD_ALLOC_PTR(attr); + if (attr == NULL) + GOTO(out, rc = -ENOMEM); + + attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO); + attr->ia_mode |= S_IFREG; + attr->ia_uid = hui->hui_uid; + attr->ia_gid = hui->hui_gid; + attr->ia_size = hui->hui_size; + attr->ia_mtime.tv_sec = hui->hui_mtime; + attr->ia_mtime.tv_nsec = hui->hui_mtime_ns; + attr->ia_atime.tv_sec = hui->hui_atime; + attr->ia_atime.tv_nsec = hui->hui_atime_ns; + + attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE | + ATTR_UID | ATTR_GID | + ATTR_MTIME | ATTR_MTIME_SET | + ATTR_ATIME | ATTR_ATIME_SET; + + rc = ll_setattr_raw(file->f_dentry, attr, true); + if (rc == -ENODATA) + rc = 0; + +out: + if (hss != NULL) + OBD_FREE_PTR(hss); + + if (attr != NULL) + OBD_FREE_PTR(attr); + + RETURN(rc); +} + +long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + int flags, rc; + ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino, inode->i_generation, inode, cmd); @@ -1836,6 +2284,27 @@ long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) RETURN(ll_lov_setstripe(inode, file, arg)); case LL_IOC_LOV_SETEA: RETURN(ll_lov_setea(inode, file, arg)); + case LL_IOC_LOV_SWAP_LAYOUTS: { + struct file *file2; + struct lustre_swap_layouts lsl; + + if (copy_from_user(&lsl, (char *)arg, + sizeof(struct lustre_swap_layouts))) + RETURN(-EFAULT); + + if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */ + RETURN(-EPERM); + + file2 = fget(lsl.sl_fd); + if (file2 == NULL) + RETURN(-EBADF); + + rc = -EPERM; + if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */ + rc = ll_swap_layouts(file, file2, &lsl); + fput(file2); + RETURN(rc); + } case LL_IOC_LOV_GETSTRIPE: RETURN(ll_lov_getstripe(inode, arg)); case LL_IOC_RECREATE_OBJ: @@ -1863,33 +2332,32 @@ long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) case FSFILT_IOC_SETVERSION_OLD: case FSFILT_IOC_SETVERSION: */ - case LL_IOC_FLUSHCTX: - RETURN(ll_flush_ctx(inode)); - case LL_IOC_PATH2FID: { - if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode), - sizeof(struct lu_fid))) - RETURN(-EFAULT); - - RETURN(0); - } - case OBD_IOC_FID2PATH: - RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg)); - case LL_IOC_DATA_VERSION: { - struct ioc_data_version idv; - int rc; + case LL_IOC_FLUSHCTX: + RETURN(ll_flush_ctx(inode)); + case LL_IOC_PATH2FID: { + if (copy_to_user((void *)arg, ll_inode2fid(inode), + sizeof(struct lu_fid))) + RETURN(-EFAULT); + + RETURN(0); + } + case OBD_IOC_FID2PATH: + RETURN(ll_fid2path(inode, (void *)arg)); + case LL_IOC_DATA_VERSION: { + struct ioc_data_version idv; + int rc; - if (cfs_copy_from_user(&idv, (char *)arg, sizeof(idv))) - RETURN(-EFAULT); + if (copy_from_user(&idv, (char *)arg, sizeof(idv))) + RETURN(-EFAULT); - rc = ll_data_version(inode, &idv.idv_version, - !(idv.idv_flags & LL_DV_NOFLUSH)); + rc = ll_data_version(inode, &idv.idv_version, + !(idv.idv_flags & LL_DV_NOFLUSH)); - if (rc == 0 && - cfs_copy_to_user((char *) arg, &idv, sizeof(idv))) - RETURN(-EFAULT); + if (rc == 0 && copy_to_user((char *) arg, &idv, sizeof(idv))) + RETURN(-EFAULT); - RETURN(rc); - } + RETURN(rc); + } case LL_IOC_GET_MDTIDX: { int mdtidx; @@ -1903,85 +2371,306 @@ long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) RETURN(0); } - case OBD_IOC_GETDTNAME: - case OBD_IOC_GETMDNAME: - RETURN(ll_get_obd_name(inode, cmd, arg)); - default: { - int err; - - if (LLIOC_STOP == - ll_iocontrol_call(inode, file, cmd, arg, &err)) - RETURN(err); - - RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL, - (void *)arg)); - } - } + case OBD_IOC_GETDTNAME: + case OBD_IOC_GETMDNAME: + RETURN(ll_get_obd_name(inode, cmd, arg)); + case LL_IOC_HSM_STATE_GET: { + struct md_op_data *op_data; + struct hsm_user_state *hus; + int rc; + + OBD_ALLOC_PTR(hus); + if (hus == NULL) + RETURN(-ENOMEM); + + op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0, + LUSTRE_OPC_ANY, hus); + if (IS_ERR(op_data)) { + OBD_FREE_PTR(hus); + RETURN(PTR_ERR(op_data)); + } + + rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data), + op_data, NULL); + + if (copy_to_user((void *)arg, hus, sizeof(*hus))) + rc = -EFAULT; + + ll_finish_md_op_data(op_data); + OBD_FREE_PTR(hus); + RETURN(rc); + } + case LL_IOC_HSM_STATE_SET: { + struct hsm_state_set *hss; + int rc; + + OBD_ALLOC_PTR(hss); + if (hss == NULL) + RETURN(-ENOMEM); + + if (copy_from_user(hss, (char *)arg, sizeof(*hss))) { + OBD_FREE_PTR(hss); + RETURN(-EFAULT); + } + + rc = ll_hsm_state_set(inode, hss); + + OBD_FREE_PTR(hss); + RETURN(rc); + } + case LL_IOC_HSM_ACTION: { + struct md_op_data *op_data; + struct hsm_current_action *hca; + int rc; + + OBD_ALLOC_PTR(hca); + if (hca == NULL) + RETURN(-ENOMEM); + + op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0, + LUSTRE_OPC_ANY, hca); + if (IS_ERR(op_data)) { + OBD_FREE_PTR(hca); + RETURN(PTR_ERR(op_data)); + } + + rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data), + op_data, NULL); + + if (copy_to_user((char *)arg, hca, sizeof(*hca))) + rc = -EFAULT; + + ll_finish_md_op_data(op_data); + OBD_FREE_PTR(hca); + RETURN(rc); + } + case LL_IOC_SET_LEASE: { + struct ll_inode_info *lli = ll_i2info(inode); + struct obd_client_handle *och = NULL; + bool lease_broken; + fmode_t mode = 0; + + switch (arg) { + case F_WRLCK: + if (!(file->f_mode & FMODE_WRITE)) + RETURN(-EPERM); + mode = FMODE_WRITE; + break; + case F_RDLCK: + if (!(file->f_mode & FMODE_READ)) + RETURN(-EPERM); + mode = FMODE_READ; + break; + case F_UNLCK: + mutex_lock(&lli->lli_och_mutex); + if (fd->fd_lease_och != NULL) { + och = fd->fd_lease_och; + fd->fd_lease_och = NULL; + } + mutex_unlock(&lli->lli_och_mutex); + + if (och != NULL) { + mode = och->och_flags &(FMODE_READ|FMODE_WRITE); + rc = ll_lease_close(och, inode, &lease_broken); + if (rc == 0 && lease_broken) + mode = 0; + } else { + rc = -ENOLCK; + } + + /* return the type of lease or error */ + RETURN(rc < 0 ? rc : (int)mode); + default: + RETURN(-EINVAL); + } + + CDEBUG(D_INODE, "Set lease with mode %d\n", mode); + + /* apply for lease */ + och = ll_lease_open(inode, file, mode, 0); + if (IS_ERR(och)) + RETURN(PTR_ERR(och)); + + rc = 0; + mutex_lock(&lli->lli_och_mutex); + if (fd->fd_lease_och == NULL) { + fd->fd_lease_och = och; + och = NULL; + } + mutex_unlock(&lli->lli_och_mutex); + if (och != NULL) { + /* impossible now that only excl is supported for now */ + ll_lease_close(och, inode, &lease_broken); + rc = -EBUSY; + } + RETURN(rc); + } + case LL_IOC_GET_LEASE: { + struct ll_inode_info *lli = ll_i2info(inode); + struct ldlm_lock *lock = NULL; + + rc = 0; + mutex_lock(&lli->lli_och_mutex); + if (fd->fd_lease_och != NULL) { + struct obd_client_handle *och = fd->fd_lease_och; + + lock = ldlm_handle2lock(&och->och_lease_handle); + if (lock != NULL) { + lock_res_and_lock(lock); + if (!ldlm_is_cancel(lock)) + rc = och->och_flags & + (FMODE_READ | FMODE_WRITE); + unlock_res_and_lock(lock); + ldlm_lock_put(lock); + } + } + mutex_unlock(&lli->lli_och_mutex); + RETURN(rc); + } + case LL_IOC_HSM_IMPORT: { + struct hsm_user_import *hui; + + OBD_ALLOC_PTR(hui); + if (hui == NULL) + RETURN(-ENOMEM); + + if (copy_from_user(hui, (void *)arg, sizeof(*hui))) { + OBD_FREE_PTR(hui); + RETURN(-EFAULT); + } + + rc = ll_hsm_import(inode, file, hui); + + OBD_FREE_PTR(hui); + RETURN(rc); + } + default: { + int err; + + if (LLIOC_STOP == + ll_iocontrol_call(inode, file, cmd, arg, &err)) + RETURN(err); + + RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL, + (void *)arg)); + } + } } -loff_t ll_file_seek(struct file *file, loff_t offset, int origin) +#ifndef HAVE_FILE_LLSEEK_SIZE +static inline loff_t +llseek_execute(struct file *file, loff_t offset, loff_t maxsize) { - struct inode *inode = file->f_dentry->d_inode; - loff_t retval; - ENTRY; - retval = offset + ((origin == 2) ? i_size_read(inode) : - (origin == 1) ? file->f_pos : 0); - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%s)\n", - inode->i_ino, inode->i_generation, inode, retval, retval, - origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET"); - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1); - - if (origin == 2) { /* SEEK_END */ - int rc; + if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET)) + return -EINVAL; + if (offset > maxsize) + return -EINVAL; - rc = ll_glimpse_size(inode); - if (rc != 0) - RETURN(rc); + if (offset != file->f_pos) { + file->f_pos = offset; + file->f_version = 0; + } + return offset; +} + +static loff_t +generic_file_llseek_size(struct file *file, loff_t offset, int origin, + loff_t maxsize, loff_t eof) +{ + struct inode *inode = file->f_dentry->d_inode; + + switch (origin) { + case SEEK_END: + offset += eof; + break; + case SEEK_CUR: + /* + * Here we special-case the lseek(fd, 0, SEEK_CUR) + * position-querying operation. Avoid rewriting the "same" + * f_pos value back to the file because a concurrent read(), + * write() or lseek() might have altered it + */ + if (offset == 0) + return file->f_pos; + /* + * f_lock protects against read/modify/write race with other + * SEEK_CURs. Note that parallel writes and reads behave + * like SEEK_SET. + */ + mutex_lock(&inode->i_mutex); + offset = llseek_execute(file, file->f_pos + offset, maxsize); + mutex_unlock(&inode->i_mutex); + return offset; + case SEEK_DATA: + /* + * In the generic case the entire file is data, so as long as + * offset isn't at the end of the file then the offset is data. + */ + if (offset >= eof) + return -ENXIO; + break; + case SEEK_HOLE: + /* + * There is a virtual hole at the end of the file, so as long as + * offset isn't i_size or larger, return i_size. + */ + if (offset >= eof) + return -ENXIO; + offset = eof; + break; + } - offset += i_size_read(inode); - } else if (origin == 1) { /* SEEK_CUR */ - offset += file->f_pos; - } + return llseek_execute(file, offset, maxsize); +} +#endif - retval = -EINVAL; - if (offset >= 0 && offset <= ll_file_maxbytes(inode)) { - if (offset != file->f_pos) { - file->f_pos = offset; - } - retval = offset; - } +loff_t ll_file_seek(struct file *file, loff_t offset, int origin) +{ + struct inode *inode = file->f_dentry->d_inode; + loff_t retval, eof = 0; - RETURN(retval); + ENTRY; + retval = offset + ((origin == SEEK_END) ? i_size_read(inode) : + (origin == SEEK_CUR) ? file->f_pos : 0); + CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%d)\n", + inode->i_ino, inode->i_generation, inode, retval, retval, + origin); + ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1); + + if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) { + retval = ll_glimpse_size(inode); + if (retval != 0) + RETURN(retval); + eof = i_size_read(inode); + } + + retval = ll_generic_file_llseek_size(file, offset, origin, + ll_file_maxbytes(inode), eof); + RETURN(retval); } -#ifdef HAVE_FLUSH_OWNER_ID int ll_flush(struct file *file, fl_owner_t id) -#else -int ll_flush(struct file *file) -#endif { - struct inode *inode = file->f_dentry->d_inode; - struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; - int rc, err; - - LASSERT(!S_ISDIR(inode->i_mode)); + struct inode *inode = file->f_dentry->d_inode; + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + int rc, err; - /* the application should know write failure already. */ - if (lli->lli_write_rc) - return 0; + LASSERT(!S_ISDIR(inode->i_mode)); - /* catch async errors that were recorded back when async writeback - * failed for pages in this mapping. */ - rc = lli->lli_async_rc; - lli->lli_async_rc = 0; - if (lsm) { - err = lov_test_and_clear_async_rc(lsm); - if (rc == 0) - rc = err; - } + /* catch async errors that were recorded back when async writeback + * failed for pages in this mapping. */ + rc = lli->lli_async_rc; + lli->lli_async_rc = 0; + err = lov_read_and_clear_async_rc(lli->lli_clob); + if (rc == 0) + rc = err; - return rc ? -EIO : 0; + /* The application has been told write failure already. + * Do not report failure again. */ + if (fd->fd_write_failed) + return 0; + return rc ? -EIO : 0; } /** @@ -1991,7 +2680,7 @@ int ll_flush(struct file *file) * Return how many pages have been written. */ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end, - enum cl_fsync_mode mode) + enum cl_fsync_mode mode, int ignore_layout) { struct cl_env_nest nest; struct lu_env *env; @@ -2013,6 +2702,7 @@ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end, io = ccc_env_thread_io(env); io->ci_obj = cl_i2info(inode)->lli_clob; + io->ci_ignore_layout = ignore_layout; /* initialize parameters for sync */ fio = &io->u.ci_fsync; @@ -2037,28 +2727,43 @@ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end, RETURN(result); } +/* + * When dentry is provided (the 'else' case), *file->f_dentry may be + * null and dentry must be used directly rather than pulled from + * *file->f_dentry as is done otherwise. + */ + #ifdef HAVE_FILE_FSYNC_4ARGS -int ll_fsync(struct file *file, loff_t start, loff_t end, int data) +int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync) +{ + struct dentry *dentry = file->f_dentry; #elif defined(HAVE_FILE_FSYNC_2ARGS) -int ll_fsync(struct file *file, int data) +int ll_fsync(struct file *file, int datasync) +{ + struct dentry *dentry = file->f_dentry; #else -int ll_fsync(struct file *file, struct dentry *dentry, int data) -#endif +int ll_fsync(struct file *file, struct dentry *dentry, int datasync) { - struct inode *inode = file->f_dentry->d_inode; +#endif + struct inode *inode = dentry->d_inode; struct ll_inode_info *lli = ll_i2info(inode); - struct lov_stripe_md *lsm = lli->lli_smd; struct ptlrpc_request *req; struct obd_capa *oc; int rc, err; ENTRY; + CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino, inode->i_generation, inode); ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1); +#ifdef HAVE_FILE_FSYNC_4ARGS + rc = filemap_write_and_wait_range(inode->i_mapping, start, end); + mutex_lock(&inode->i_mutex); +#else /* fsync's caller has already called _fdata{sync,write}, we want * that IO to finish before calling the osc and mdc sync methods */ rc = filemap_fdatawait(inode->i_mapping); +#endif /* catch async errors that were recorded back when async writeback * failed for pages in this mapping. */ @@ -2067,11 +2772,9 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) lli->lli_async_rc = 0; if (rc == 0) rc = err; - if (lsm) { - err = lov_test_and_clear_async_rc(lsm); - if (rc == 0) - rc = err; - } + err = lov_read_and_clear_async_rc(lli->lli_clob); + if (rc == 0) + rc = err; } oc = ll_mdscapa_get(inode); @@ -2083,30 +2786,41 @@ int ll_fsync(struct file *file, struct dentry *dentry, int data) if (!err) ptlrpc_req_finished(req); - if (data && lsm) { + if (datasync && S_ISREG(inode->i_mode)) { + struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + err = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF, - CL_FSYNC_ALL); + CL_FSYNC_ALL, 0); if (rc == 0 && err < 0) - rc = err; - lli->lli_write_rc = rc < 0 ? rc : 0; - } + rc = err; + if (rc < 0) + fd->fd_write_failed = true; + else + fd->fd_write_failed = false; + } - RETURN(rc); +#ifdef HAVE_FILE_FSYNC_4ARGS + mutex_unlock(&inode->i_mutex); +#endif + RETURN(rc); } int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) { - struct inode *inode = file->f_dentry->d_inode; - struct ll_sb_info *sbi = ll_i2sbi(inode); - struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK, - .ei_cb_cp =ldlm_flock_completion_ast, - .ei_cbdata = file_lock }; - struct md_op_data *op_data; - struct lustre_handle lockh = {0}; - ldlm_policy_data_t flock = {{0}}; - int flags = 0; - int rc; - ENTRY; + struct inode *inode = file->f_dentry->d_inode; + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct ldlm_enqueue_info einfo = { + .ei_type = LDLM_FLOCK, + .ei_cb_cp = ldlm_flock_completion_ast, + .ei_cbdata = file_lock, + }; + struct md_op_data *op_data; + struct lustre_handle lockh = {0}; + ldlm_policy_data_t flock = {{0}}; + int flags = 0; + int rc; + int rc2 = 0; + ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n", inode->i_ino, file_lock); @@ -2128,15 +2842,15 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) } flock.l_flock.pid = file_lock->fl_pid; - /* Somewhat ugly workaround for svc lockd. - * lockd installs custom fl_lmops->fl_compare_owner that checks - * for the fl_owner to be the same (which it always is on local node - * I guess between lockd processes) and then compares pid. - * As such we assign pid to the owner field to make it all work, - * conflict with normal locks is unlikely since pid space and - * pointer space for current->files are not intersecting */ - if (file_lock->fl_lmops && file_lock->fl_lmops->fl_compare_owner) - flock.l_flock.owner = (unsigned long)file_lock->fl_pid; + /* Somewhat ugly workaround for svc lockd. + * lockd installs custom fl_lmops->lm_compare_owner that checks + * for the fl_owner to be the same (which it always is on local node + * I guess between lockd processes) and then compares pid. + * As such we assign pid to the owner field to make it all work, + * conflict with normal locks is unlikely since pid space and + * pointer space for current->files are not intersecting */ + if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner) + flock.l_flock.owner = (unsigned long)file_lock->fl_pid; switch (file_lock->fl_type) { case F_RDLCK: @@ -2201,15 +2915,22 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock) rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL, op_data, &lockh, &flock, 0, NULL /* req */, flags); - ll_finish_md_op_data(op_data); - if ((file_lock->fl_flags & FL_FLOCK) && (rc == 0 || file_lock->fl_type == F_UNLCK)) - flock_lock_file_wait(file, file_lock); + rc2 = flock_lock_file_wait(file, file_lock); if ((file_lock->fl_flags & FL_POSIX) && (rc == 0 || file_lock->fl_type == F_UNLCK) && !(flags & LDLM_FL_TEST_LOCK)) - posix_lock_file_wait(file, file_lock); + rc2 = posix_lock_file_wait(file, file_lock); + + if (rc2 && file_lock->fl_type != F_UNLCK) { + einfo.ei_mode = LCK_NL; + md_enqueue(sbi->ll_md_exp, &einfo, NULL, + op_data, &lockh, &flock, 0, NULL /* req */, flags); + rc = rc2; + } + + ll_finish_md_op_data(op_data); RETURN(rc); } @@ -2238,7 +2959,7 @@ int ll_have_md_lock(struct inode *inode, __u64 *bits, ldlm_mode_t l_req_mode) ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ? (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode; struct lu_fid *fid; - int flags; + __u64 flags; int i; ENTRY; @@ -2249,11 +2970,11 @@ int ll_have_md_lock(struct inode *inode, __u64 *bits, ldlm_mode_t l_req_mode) CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid), ldlm_lockname[mode]); - flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK; - for (i = 0; i < MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) { - policy.l_inodebits.bits = *bits & (1 << i); - if (policy.l_inodebits.bits == 0) - continue; + flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK; + for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) { + policy.l_inodebits.bits = *bits & (1 << i); + if (policy.l_inodebits.bits == 0) + continue; if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy, mode, &lockh)) { @@ -2273,42 +2994,40 @@ int ll_have_md_lock(struct inode *inode, __u64 *bits, ldlm_mode_t l_req_mode) } ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits, - struct lustre_handle *lockh) + struct lustre_handle *lockh, __u64 flags, + ldlm_mode_t mode) { ldlm_policy_data_t policy = { .l_inodebits = {bits}}; struct lu_fid *fid; ldlm_mode_t rc; - int flags; ENTRY; fid = &ll_i2info(inode)->lli_fid; CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid)); - flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING; - rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy, - LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh); - RETURN(rc); -} + rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags, + fid, LDLM_IBITS, &policy, mode, lockh); -static int ll_inode_revalidate_fini(struct inode *inode, int rc) { - if (rc == -ENOENT) { /* Already unlinked. Just update nlink - * and return success */ - inode->i_nlink = 0; - /* This path cannot be hit for regular files unless in - * case of obscure races, so no need to to validate - * size. */ - if (!S_ISREG(inode->i_mode) && - !S_ISDIR(inode->i_mode)) - return 0; - } - - if (rc) { - CERROR("failure %d inode %lu\n", rc, inode->i_ino); - return -abs(rc); + RETURN(rc); +} - } +static int ll_inode_revalidate_fini(struct inode *inode, int rc) +{ + /* Already unlinked. Just update nlink and return success */ + if (rc == -ENOENT) { + clear_nlink(inode); + /* This path cannot be hit for regular files unless in + * case of obscure races, so no need to to validate + * size. */ + if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode)) + return 0; + } else if (rc != 0) { + CERROR("%s: revalidate FID "DFID" error: rc = %d\n", + ll_get_fsname(inode->i_sb, NULL, 0), + PFID(ll_inode2fid(inode)), rc); + } - return 0; + return rc; } int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, @@ -2320,10 +3039,7 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, int rc = 0; ENTRY; - if (!inode) { - CERROR("REPORT THIS LINE TO PETER\n"); - RETURN(0); - } + LASSERT(inode != NULL); CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n", inode->i_ino, inode->i_generation, inode, dentry->d_name.name); @@ -2333,7 +3049,7 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC. * But under CMD case, it caused some lock issues, should be fixed * with new CMD ibits lock. See bug 12718 */ - if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) { + if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) { struct lookup_intent oit = { .it_op = IT_GETATTR }; struct md_op_data *op_data; @@ -2371,7 +3087,7 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, here to preserve get_cwd functionality on 2.6. Bug 10503 */ if (!dentry->d_inode->i_nlink) - d_lustre_invalidate(dentry); + d_lustre_invalidate(dentry, 0); ll_lookup_finish_locks(&oit, dentry); } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) { @@ -2404,7 +3120,7 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, RETURN(rc); } - rc = ll_prep_inode(&inode, req, NULL); + rc = ll_prep_inode(&inode, req, NULL, NULL); } out: ptlrpc_req_finished(req); @@ -2412,29 +3128,33 @@ out: } int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it, - __u64 ibits) + __u64 ibits) { - struct inode *inode = dentry->d_inode; - int rc; - ENTRY; - - rc = __ll_inode_revalidate_it(dentry, it, ibits); - - /* if object not yet allocated, don't validate size */ - if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL) { - LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime; - LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime; - LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime; - RETURN(0); - } - - /* ll_glimpse_size will prefer locally cached writes if they extend - * the file */ - - if (rc == 0) - rc = ll_glimpse_size(inode); + struct inode *inode = dentry->d_inode; + int rc; + ENTRY; - RETURN(rc); + rc = __ll_inode_revalidate_it(dentry, it, ibits); + if (rc != 0) + RETURN(rc); + + /* if object isn't regular file, don't validate size */ + if (!S_ISREG(inode->i_mode)) { + LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime; + LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime; + LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime; + } else { + /* In case of restore, the MDT has the right size and has + * already send it back without granting the layout lock, + * inode is up-to-date so glimpse is useless. + * Also to glimpse we need the layout, in case of a running + * restore the MDT holds the layout lock so the glimpse will + * block up to the end of restore (getattr will block) + */ + if (!(ll_i2info(inode)->lli_flags & LLIF_FILE_RESTORING)) + rc = ll_glimpse_size(inode); + } + RETURN(rc); } int ll_getattr_it(struct vfsmount *mnt, struct dentry *de, @@ -2461,15 +3181,11 @@ int ll_getattr_it(struct vfsmount *mnt, struct dentry *de, stat->nlink = inode->i_nlink; stat->uid = inode->i_uid; stat->gid = inode->i_gid; - stat->rdev = kdev_t_to_nr(inode->i_rdev); + stat->rdev = inode->i_rdev; stat->atime = inode->i_atime; stat->mtime = inode->i_mtime; stat->ctime = inode->i_ctime; -#ifdef HAVE_INODE_BLKSIZE - stat->blksize = inode->i_blksize; -#else - stat->blksize = 1 << inode->i_blkbits; -#endif + stat->blksize = 1 << inode->i_blkbits; stat->size = i_size_read(inode); stat->blocks = inode->i_blocks; @@ -2518,39 +3234,51 @@ int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, } #endif +struct posix_acl * ll_get_acl(struct inode *inode, int type) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct posix_acl *acl = NULL; + ENTRY; + + spin_lock(&lli->lli_lock); + /* VFS' acl_permission_check->check_acl will release the refcount */ + acl = posix_acl_dup(lli->lli_posix_acl); + spin_unlock(&lli->lli_lock); + RETURN(acl); +} + +#ifndef HAVE_GENERIC_PERMISSION_2ARGS static int -#ifdef HAVE_GENERIC_PERMISSION_4ARGS -lustre_check_acl(struct inode *inode, int mask, unsigned int flags) -#else -lustre_check_acl(struct inode *inode, int mask) -#endif +# ifdef HAVE_GENERIC_PERMISSION_4ARGS +ll_check_acl(struct inode *inode, int mask, unsigned int flags) +# else +ll_check_acl(struct inode *inode, int mask) +# endif { -#ifdef CONFIG_FS_POSIX_ACL - struct ll_inode_info *lli = ll_i2info(inode); - struct posix_acl *acl; - int rc; - ENTRY; +# ifdef CONFIG_FS_POSIX_ACL + struct posix_acl *acl; + int rc; + ENTRY; -#ifdef IPERM_FLAG_RCU - if (flags & IPERM_FLAG_RCU) - return -ECHILD; -#endif - cfs_spin_lock(&lli->lli_lock); - acl = posix_acl_dup(lli->lli_posix_acl); - cfs_spin_unlock(&lli->lli_lock); +# ifdef HAVE_GENERIC_PERMISSION_4ARGS + if (flags & IPERM_FLAG_RCU) + return -ECHILD; +# endif + acl = ll_get_acl(inode, ACL_TYPE_ACCESS); - if (!acl) - RETURN(-EAGAIN); + if (!acl) + RETURN(-EAGAIN); - rc = posix_acl_permission(inode, acl, mask); - posix_acl_release(acl); + rc = posix_acl_permission(inode, acl, mask); + posix_acl_release(acl); - RETURN(rc); -#else - return -EAGAIN; -#endif + RETURN(rc); +# else /* !CONFIG_FS_POSIX_ACL */ + return -EAGAIN; +# endif /* CONFIG_FS_POSIX_ACL */ } +#endif /* HAVE_GENERIC_PERMISSION_2ARGS */ #ifdef HAVE_GENERIC_PERMISSION_4ARGS int ll_inode_permission(struct inode *inode, int mask, unsigned int flags) @@ -2565,7 +3293,10 @@ int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd) int rc = 0; ENTRY; -#ifdef IPERM_FLAG_RCU +#ifdef MAY_NOT_BLOCK + if (mask & MAY_NOT_BLOCK) + return -ECHILD; +#elif defined(HAVE_GENERIC_PERMISSION_4ARGS) if (flags & IPERM_FLAG_RCU) return -ECHILD; #endif @@ -2582,67 +3313,45 @@ int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd) RETURN(rc); } - CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n", - inode->i_ino, inode->i_generation, inode, inode->i_mode, mask); + CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n", + inode->i_ino, inode->i_generation, inode, inode->i_mode, mask); - if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT) - return lustre_check_remote_perm(inode, mask); + if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT) + return lustre_check_remote_perm(inode, mask); - ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1); - rc = ll_generic_permission(inode, mask, flags, lustre_check_acl); + ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1); + rc = ll_generic_permission(inode, mask, flags, ll_check_acl); - RETURN(rc); + RETURN(rc); } -#ifdef HAVE_FILE_READV -#define READ_METHOD readv -#define READ_FUNCTION ll_file_readv -#define WRITE_METHOD writev -#define WRITE_FUNCTION ll_file_writev -#else -#define READ_METHOD aio_read -#define READ_FUNCTION ll_file_aio_read -#define WRITE_METHOD aio_write -#define WRITE_FUNCTION ll_file_aio_write -#endif - /* -o localflock - only provides locally consistent flock locks */ struct file_operations ll_file_operations = { .read = ll_file_read, - .READ_METHOD = READ_FUNCTION, + .aio_read = ll_file_aio_read, .write = ll_file_write, - .WRITE_METHOD = WRITE_FUNCTION, + .aio_write = ll_file_aio_write, .unlocked_ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#ifdef HAVE_KERNEL_SENDFILE - .sendfile = ll_file_sendfile, -#endif -#ifdef HAVE_KERNEL_SPLICE_READ .splice_read = ll_file_splice_read, -#endif .fsync = ll_fsync, .flush = ll_flush }; struct file_operations ll_file_operations_flock = { .read = ll_file_read, - .READ_METHOD = READ_FUNCTION, + .aio_read = ll_file_aio_read, .write = ll_file_write, - .WRITE_METHOD = WRITE_FUNCTION, + .aio_write = ll_file_aio_write, .unlocked_ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#ifdef HAVE_KERNEL_SENDFILE - .sendfile = ll_file_sendfile, -#endif -#ifdef HAVE_KERNEL_SPLICE_READ .splice_read = ll_file_splice_read, -#endif .fsync = ll_fsync, .flush = ll_flush, .flock = ll_file_flock, @@ -2652,20 +3361,15 @@ struct file_operations ll_file_operations_flock = { /* These are for -o noflock - to return ENOSYS on flock calls */ struct file_operations ll_file_operations_noflock = { .read = ll_file_read, - .READ_METHOD = READ_FUNCTION, + .aio_read = ll_file_aio_read, .write = ll_file_write, - .WRITE_METHOD = WRITE_FUNCTION, + .aio_write = ll_file_aio_write, .unlocked_ioctl = ll_file_ioctl, .open = ll_file_open, .release = ll_file_release, .mmap = ll_file_mmap, .llseek = ll_file_seek, -#ifdef HAVE_KERNEL_SENDFILE - .sendfile = ll_file_sendfile, -#endif -#ifdef HAVE_KERNEL_SPLICE_READ .splice_read = ll_file_splice_read, -#endif .fsync = ll_fsync, .flush = ll_flush, .flock = ll_file_noflock, @@ -2673,22 +3377,24 @@ struct file_operations ll_file_operations_noflock = { }; struct inode_operations ll_file_inode_operations = { - .setattr = ll_setattr, - .truncate = ll_truncate, - .getattr = ll_getattr, - .permission = ll_inode_permission, - .setxattr = ll_setxattr, - .getxattr = ll_getxattr, - .listxattr = ll_listxattr, - .removexattr = ll_removexattr, + .setattr = ll_setattr, + .getattr = ll_getattr, + .permission = ll_inode_permission, + .setxattr = ll_setxattr, + .getxattr = ll_getxattr, + .listxattr = ll_listxattr, + .removexattr = ll_removexattr, #ifdef HAVE_LINUX_FIEMAP_H - .fiemap = ll_fiemap, + .fiemap = ll_fiemap, +#endif +#ifdef HAVE_IOP_GET_ACL + .get_acl = ll_get_acl, #endif }; /* dynamic ioctl number support routins */ static struct llioc_ctl_data { - cfs_rw_semaphore_t ioc_sem; + struct rw_semaphore ioc_sem; cfs_list_t ioc_head; } llioc = { __RWSEM_INITIALIZER(llioc.ioc_sem), @@ -2725,9 +3431,9 @@ void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd) in_data->iocd_count = count; memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count); - cfs_down_write(&llioc.ioc_sem); + down_write(&llioc.ioc_sem); cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head); - cfs_up_write(&llioc.ioc_sem); + up_write(&llioc.ioc_sem); RETURN(in_data); } @@ -2739,19 +3445,19 @@ void ll_iocontrol_unregister(void *magic) if (magic == NULL) return; - cfs_down_write(&llioc.ioc_sem); + down_write(&llioc.ioc_sem); cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) { if (tmp == magic) { unsigned int size = tmp->iocd_size; cfs_list_del(&tmp->iocd_list); - cfs_up_write(&llioc.ioc_sem); + up_write(&llioc.ioc_sem); OBD_FREE(tmp, size); return; } } - cfs_up_write(&llioc.ioc_sem); + up_write(&llioc.ioc_sem); CWARN("didn't find iocontrol register block with magic: %p\n", magic); } @@ -2766,7 +3472,7 @@ enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file, struct llioc_data *data; int rc = -EINVAL, i; - cfs_down_read(&llioc.ioc_sem); + down_read(&llioc.ioc_sem); cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) { for (i = 0; i < data->iocd_count; i++) { if (cmd != data->iocd_cmd[i]) @@ -2779,9 +3485,357 @@ enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file, if (ret == LLIOC_STOP) break; } - cfs_up_read(&llioc.ioc_sem); + up_read(&llioc.ioc_sem); if (rcp) *rcp = rc; return ret; } + +int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct cl_env_nest nest; + struct lu_env *env; + int result; + ENTRY; + + if (lli->lli_clob == NULL) + RETURN(0); + + env = cl_env_nested_get(&nest); + if (IS_ERR(env)) + RETURN(PTR_ERR(env)); + + result = cl_conf_set(env, lli->lli_clob, conf); + cl_env_nested_put(&nest, env); + + if (conf->coc_opc == OBJECT_CONF_SET) { + struct ldlm_lock *lock = conf->coc_lock; + + LASSERT(lock != NULL); + LASSERT(ldlm_has_layout(lock)); + if (result == 0) { + /* it can only be allowed to match after layout is + * applied to inode otherwise false layout would be + * seen. Applying layout shoud happen before dropping + * the intent lock. */ + ldlm_lock_allow_match(lock); + } + } + RETURN(result); +} + +/* Fetch layout from MDT with getxattr request, if it's not ready yet */ +static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock) + +{ + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct obd_capa *oc; + struct ptlrpc_request *req; + struct mdt_body *body; + void *lvbdata; + void *lmm; + int lmmsize; + int rc; + ENTRY; + + CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n", + PFID(ll_inode2fid(inode)), !!(lock->l_flags & LDLM_FL_LVB_READY), + lock->l_lvb_data, lock->l_lvb_len); + + if ((lock->l_lvb_data != NULL) && (lock->l_flags & LDLM_FL_LVB_READY)) + RETURN(0); + + /* if layout lock was granted right away, the layout is returned + * within DLM_LVB of dlm reply; otherwise if the lock was ever + * blocked and then granted via completion ast, we have to fetch + * layout here. Please note that we can't use the LVB buffer in + * completion AST because it doesn't have a large enough buffer */ + oc = ll_mdscapa_get(inode); + rc = ll_get_max_mdsize(sbi, &lmmsize); + if (rc == 0) + rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc, + OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0, + lmmsize, 0, &req); + capa_put(oc); + if (rc < 0) + RETURN(rc); + + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (body == NULL || body->eadatasize > lmmsize) + GOTO(out, rc = -EPROTO); + + lmmsize = body->eadatasize; + if (lmmsize == 0) /* empty layout */ + GOTO(out, rc = 0); + + lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize); + if (lmm == NULL) + GOTO(out, rc = -EFAULT); + + OBD_ALLOC_LARGE(lvbdata, lmmsize); + if (lvbdata == NULL) + GOTO(out, rc = -ENOMEM); + + memcpy(lvbdata, lmm, lmmsize); + lock_res_and_lock(lock); + if (lock->l_lvb_data != NULL) + OBD_FREE_LARGE(lock->l_lvb_data, lock->l_lvb_len); + + lock->l_lvb_data = lvbdata; + lock->l_lvb_len = lmmsize; + unlock_res_and_lock(lock); + + EXIT; + +out: + ptlrpc_req_finished(req); + return rc; +} + +/** + * Apply the layout to the inode. Layout lock is held and will be released + * in this function. + */ +static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode, + struct inode *inode, __u32 *gen, bool reconf) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct ldlm_lock *lock; + struct lustre_md md = { NULL }; + struct cl_object_conf conf; + int rc = 0; + bool lvb_ready; + bool wait_layout = false; + ENTRY; + + LASSERT(lustre_handle_is_used(lockh)); + + lock = ldlm_handle2lock(lockh); + LASSERT(lock != NULL); + LASSERT(ldlm_has_layout(lock)); + + LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n", + inode, PFID(&lli->lli_fid), reconf); + + /* in case this is a caching lock and reinstate with new inode */ + md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL); + + lock_res_and_lock(lock); + lvb_ready = !!(lock->l_flags & LDLM_FL_LVB_READY); + unlock_res_and_lock(lock); + /* checking lvb_ready is racy but this is okay. The worst case is + * that multi processes may configure the file on the same time. */ + + if (lvb_ready || !reconf) { + rc = -ENODATA; + if (lvb_ready) { + /* layout_gen must be valid if layout lock is not + * cancelled and stripe has already set */ + *gen = lli->lli_layout_gen; + rc = 0; + } + GOTO(out, rc); + } + + rc = ll_layout_fetch(inode, lock); + if (rc < 0) + GOTO(out, rc); + + /* for layout lock, lmm is returned in lock's lvb. + * lvb_data is immutable if the lock is held so it's safe to access it + * without res lock. See the description in ldlm_lock_decref_internal() + * for the condition to free lvb_data of layout lock */ + if (lock->l_lvb_data != NULL) { + rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm, + lock->l_lvb_data, lock->l_lvb_len); + if (rc >= 0) { + *gen = LL_LAYOUT_GEN_EMPTY; + if (md.lsm != NULL) + *gen = md.lsm->lsm_layout_gen; + rc = 0; + } else { + CERROR("%s: file "DFID" unpackmd error: %d\n", + ll_get_fsname(inode->i_sb, NULL, 0), + PFID(&lli->lli_fid), rc); + } + } + if (rc < 0) + GOTO(out, rc); + + /* set layout to file. Unlikely this will fail as old layout was + * surely eliminated */ + memset(&conf, 0, sizeof conf); + conf.coc_opc = OBJECT_CONF_SET; + conf.coc_inode = inode; + conf.coc_lock = lock; + conf.u.coc_md = &md; + rc = ll_layout_conf(inode, &conf); + + if (md.lsm != NULL) + obd_free_memmd(sbi->ll_dt_exp, &md.lsm); + + /* refresh layout failed, need to wait */ + wait_layout = rc == -EBUSY; + EXIT; + +out: + LDLM_LOCK_PUT(lock); + ldlm_lock_decref(lockh, mode); + + /* wait for IO to complete if it's still being used. */ + if (wait_layout) { + CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n", + ll_get_fsname(inode->i_sb, NULL, 0), + inode, PFID(&lli->lli_fid)); + + memset(&conf, 0, sizeof conf); + conf.coc_opc = OBJECT_CONF_WAIT; + conf.coc_inode = inode; + rc = ll_layout_conf(inode, &conf); + if (rc == 0) + rc = -EAGAIN; + + CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n", + PFID(&lli->lli_fid), rc); + } + RETURN(rc); +} + +/** + * This function checks if there exists a LAYOUT lock on the client side, + * or enqueues it if it doesn't have one in cache. + * + * This function will not hold layout lock so it may be revoked any time after + * this function returns. Any operations depend on layout should be redone + * in that case. + * + * This function should be called before lov_io_init() to get an uptodate + * layout version, the caller should save the version number and after IO + * is finished, this function should be called again to verify that layout + * is not changed during IO time. + */ +int ll_layout_refresh(struct inode *inode, __u32 *gen) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct ll_sb_info *sbi = ll_i2sbi(inode); + struct md_op_data *op_data; + struct lookup_intent it; + struct lustre_handle lockh; + ldlm_mode_t mode; + struct ldlm_enqueue_info einfo = { + .ei_type = LDLM_IBITS, + .ei_mode = LCK_CR, + .ei_cb_bl = ll_md_blocking_ast, + .ei_cb_cp = ldlm_completion_ast, + }; + int rc; + ENTRY; + + *gen = lli->lli_layout_gen; + if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK)) + RETURN(0); + + /* sanity checks */ + LASSERT(fid_is_sane(ll_inode2fid(inode))); + LASSERT(S_ISREG(inode->i_mode)); + + /* mostly layout lock is caching on the local side, so try to match + * it before grabbing layout lock mutex. */ + mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0, + LCK_CR | LCK_CW | LCK_PR | LCK_PW); + if (mode != 0) { /* hit cached lock */ + rc = ll_layout_lock_set(&lockh, mode, inode, gen, false); + if (rc == 0) + RETURN(0); + + /* better hold lli_layout_mutex to try again otherwise + * it will have starvation problem. */ + } + + /* take layout lock mutex to enqueue layout lock exclusively. */ + mutex_lock(&lli->lli_layout_mutex); + +again: + /* try again. Maybe somebody else has done this. */ + mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0, + LCK_CR | LCK_CW | LCK_PR | LCK_PW); + if (mode != 0) { /* hit cached lock */ + rc = ll_layout_lock_set(&lockh, mode, inode, gen, true); + if (rc == -EAGAIN) + goto again; + + mutex_unlock(&lli->lli_layout_mutex); + RETURN(rc); + } + + op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, + 0, 0, LUSTRE_OPC_ANY, NULL); + if (IS_ERR(op_data)) { + mutex_unlock(&lli->lli_layout_mutex); + RETURN(PTR_ERR(op_data)); + } + + /* have to enqueue one */ + memset(&it, 0, sizeof(it)); + it.it_op = IT_LAYOUT; + lockh.cookie = 0ULL; + + LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n", + ll_get_fsname(inode->i_sb, NULL, 0), inode, + PFID(&lli->lli_fid)); + + rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh, + NULL, 0, NULL, 0); + if (it.d.lustre.it_data != NULL) + ptlrpc_req_finished(it.d.lustre.it_data); + it.d.lustre.it_data = NULL; + + ll_finish_md_op_data(op_data); + + mode = it.d.lustre.it_lock_mode; + it.d.lustre.it_lock_mode = 0; + ll_intent_drop_lock(&it); + + if (rc == 0) { + /* set lock data in case this is a new lock */ + ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL); + rc = ll_layout_lock_set(&lockh, mode, inode, gen, true); + if (rc == -EAGAIN) + goto again; + } + mutex_unlock(&lli->lli_layout_mutex); + + RETURN(rc); +} + +/** + * This function send a restore request to the MDT + */ +int ll_layout_restore(struct inode *inode) +{ + struct hsm_user_request *hur; + int len, rc; + ENTRY; + + len = sizeof(struct hsm_user_request) + + sizeof(struct hsm_user_item); + OBD_ALLOC(hur, len); + if (hur == NULL) + RETURN(-ENOMEM); + + hur->hur_request.hr_action = HUA_RESTORE; + hur->hur_request.hr_archive_id = 0; + hur->hur_request.hr_flags = 0; + memcpy(&hur->hur_user_item[0].hui_fid, &ll_i2info(inode)->lli_fid, + sizeof(hur->hur_user_item[0].hui_fid)); + hur->hur_user_item[0].hui_extent.length = -1; + hur->hur_request.hr_itemcount = 1; + rc = obd_iocontrol(LL_IOC_HSM_REQUEST, cl_i2sbi(inode)->ll_md_exp, + len, hur, NULL); + OBD_FREE(hur, len); + RETURN(rc); +} +