* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
static int client_common_fill_super(struct super_block *sb, char *md, char *dt,
struct vfsmount *mnt)
{
- struct inode *root = 0;
+ struct inode *root = NULL;
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct obd_device *obd;
struct obd_capa *oc = NULL;
struct obd_uuid *uuid;
struct md_op_data *op_data;
struct lustre_md lmd;
- obd_valid valid;
+ u64 valid;
int size, err, checksum;
ENTRY;
RETURN(rc);
}
+/**
+ * Get the value of the default_easize parameter.
+ *
+ * \see client_obd::cl_default_mds_easize
+ *
+ * \param[in] sbi superblock info for this filesystem
+ * \param[out] lmmsize pointer to storage location for value
+ *
+ * \retval 0 on success
+ * \retval negative negated errno on failure
+ */
int ll_get_default_mdsize(struct ll_sb_info *sbi, int *lmmsize)
{
int size, rc;
RETURN(rc);
}
+/**
+ * Set the default_easize parameter to the given value.
+ *
+ * \see client_obd::cl_default_mds_easize
+ *
+ * \param[in] sbi superblock info for this filesystem
+ * \param[in] lmmsize the size to set
+ *
+ * \retval 0 on success
+ * \retval negative negated errno on failure
+ */
+int ll_set_default_mdsize(struct ll_sb_info *sbi, int lmmsize)
+{
+ int rc;
+
+ if (lmmsize < sizeof(struct lov_mds_md) ||
+ lmmsize > OBD_MAX_DEFAULT_EA_SIZE)
+ return -EINVAL;
+
+ rc = obd_set_info_async(NULL, sbi->ll_md_exp,
+ sizeof(KEY_DEFAULT_EASIZE), KEY_DEFAULT_EASIZE,
+ sizeof(int), &lmmsize, NULL);
+
+ RETURN(rc);
+}
+
int ll_get_max_cookiesize(struct ll_sb_info *sbi, int *lmmsize)
{
int size, rc;
spin_lock_init(&lli->lli_sa_lock);
lli->lli_opendir_pid = 0;
lli->lli_sa_enabled = 0;
+ lli->lli_def_stripe_offset = -1;
} else {
mutex_init(&lli->lli_size_mutex);
lli->lli_symlink_name = NULL;
}
}
- /* Here is where the lsm is being initialized(fill lmo_info) after
- * client retrieve MD stripe information from MDT. */
- return md_update_lsm_md(ll_i2mdexp(inode), lsm, md->body,
- ll_md_blocking_ast);
+ return 0;
}
static inline int lli_lsm_md_eq(const struct lmv_stripe_md *lsm_md1,
RETURN(-EIO);
}
- rc = md_update_lsm_md(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
- md->body, ll_md_blocking_ast);
-
- RETURN(rc);
+ RETURN(0);
}
void ll_clear_inode(struct inode *inode)
if (body->mbo_valid & OBD_MD_FLATIME) {
if (body->mbo_atime > LTIME_S(inode->i_atime))
LTIME_S(inode->i_atime) = body->mbo_atime;
- lli->lli_lvb.lvb_atime = body->mbo_atime;
+ lli->lli_atime = body->mbo_atime;
}
if (body->mbo_valid & OBD_MD_FLMTIME) {
LTIME_S(inode->i_mtime), body->mbo_mtime);
LTIME_S(inode->i_mtime) = body->mbo_mtime;
}
- lli->lli_lvb.lvb_mtime = body->mbo_mtime;
+ lli->lli_mtime = body->mbo_mtime;
}
if (body->mbo_valid & OBD_MD_FLCTIME) {
if (body->mbo_ctime > LTIME_S(inode->i_ctime))
LTIME_S(inode->i_ctime) = body->mbo_ctime;
- lli->lli_lvb.lvb_ctime = body->mbo_ctime;
+ lli->lli_ctime = body->mbo_ctime;
}
if (body->mbo_valid & OBD_MD_FLMODE)
void ll_delete_inode(struct inode *inode)
{
- struct cl_inode_info *lli = cl_i2info(inode);
+ struct ll_inode_info *lli = ll_i2info(inode);
ENTRY;
if (S_ISREG(inode->i_mode) && lli->lli_clob != NULL)
return 0;
}
+/**
+ * Cleanup the open handle that is cached on MDT-side.
+ *
+ * For open case, the client side open handling thread may hit error
+ * after the MDT grant the open. Under such case, the client should
+ * send close RPC to the MDT as cleanup; otherwise, the open handle
+ * on the MDT will be leaked there until the client umount or evicted.
+ *
+ * In further, if someone unlinked the file, because the open handle
+ * holds the reference on such file/object, then it will block the
+ * subsequent threads that want to locate such object via FID.
+ *
+ * \param[in] sb super block for this file-system
+ * \param[in] open_req pointer to the original open request
+ */
+void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req)
+{
+ struct mdt_body *body;
+ struct md_op_data *op_data;
+ struct ptlrpc_request *close_req = NULL;
+ struct obd_export *exp = ll_s2sbi(sb)->ll_md_exp;
+ ENTRY;
+
+ body = req_capsule_server_get(&open_req->rq_pill, &RMF_MDT_BODY);
+ OBD_ALLOC_PTR(op_data);
+ if (op_data == NULL) {
+ CWARN("%s: cannot allocate op_data to release open handle for "
+ DFID"\n",
+ ll_get_fsname(sb, NULL, 0), PFID(&body->mbo_fid1));
+
+ RETURN_EXIT;
+ }
+
+ op_data->op_fid1 = body->mbo_fid1;
+ op_data->op_ioepoch = body->mbo_ioepoch;
+ op_data->op_handle = body->mbo_handle;
+ op_data->op_mod_time = cfs_time_current_sec();
+ md_close(exp, op_data, NULL, &close_req);
+ ptlrpc_req_finished(close_req);
+ ll_finish_md_op_data(op_data);
+
+ EXIT;
+}
+
int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
struct super_block *sb, struct lookup_intent *it)
{
struct ll_sb_info *sbi = NULL;
- struct lustre_md md = { 0 };
+ struct lustre_md md = { NULL };
int rc;
ENTRY;
- LASSERT(*inode || sb);
- sbi = sb ? ll_s2sbi(sb) : ll_i2sbi(*inode);
- rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp,
- sbi->ll_md_exp, &md);
- if (rc)
- RETURN(rc);
+ LASSERT(*inode || sb);
+ sbi = sb ? ll_s2sbi(sb) : ll_i2sbi(*inode);
+ rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp,
+ sbi->ll_md_exp, &md);
+ if (rc != 0)
+ GOTO(cleanup, rc);
if (*inode) {
rc = ll_update_inode(*inode, &md);
LDLM_LOCK_PUT(lock);
}
+ GOTO(out, rc = 0);
+
out:
if (md.lsm != NULL)
obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
md_free_lustre_md(sbi->ll_md_exp, &md);
- RETURN(rc);
+
+cleanup:
+ if (rc != 0 && it != NULL && it->it_op & IT_OPEN)
+ ll_open_cleanup(sb != NULL ? sb : (*inode)->i_sb, req);
+
+ return rc;
}
int ll_obd_statfs(struct inode *inode, void __user *arg)
ll_i2gids(op_data->op_suppgids, i1, i2);
op_data->op_fid1 = *ll_inode2fid(i1);
op_data->op_capa1 = ll_mdscapa_get(i1);
- if (S_ISDIR(i1->i_mode))
+ op_data->op_default_stripe_offset = -1;
+ if (S_ISDIR(i1->i_mode)) {
op_data->op_mea1 = ll_i2info(i1)->lli_lsm_md;
+ op_data->op_default_stripe_offset =
+ ll_i2info(i1)->lli_def_stripe_offset;
+ }
if (i2) {
op_data->op_fid2 = *ll_inode2fid(i2);
{
char *buf, *path = NULL;
struct dentry *dentry = NULL;
- struct ccc_object *obj = cl_inode2ccc(page->mapping->host);
+ struct vvp_object *obj = cl_inode2vvp(page->mapping->host);
/* this can be called inside spin lock so use GFP_ATOMIC. */
buf = (char *)__get_free_page(GFP_ATOMIC);
"%s: dirty page discard: %s/fid: "DFID"/%s may get corrupted "
"(rc %d)\n", ll_get_fsname(page->mapping->host->i_sb, NULL, 0),
s2lsi(page->mapping->host->i_sb)->lsi_lmd->lmd_dev,
- PFID(&obj->cob_header.coh_lu.loh_fid),
+ PFID(&obj->vob_header.coh_lu.loh_fid),
(path && !IS_ERR(path)) ? path : "", ioret);
if (dentry != NULL)
/**
* Parse linkea content to extract information about a given hardlink
*
- * \param[in] ldata - Initialized linkea data
- * \param[in] linkno - Link identifier
- * \param[out] gpout - Destination structure to fill with linkno,
- * parent FID and entry name
- * \param[in] size - Size of the gp_name buffer in gpout
+ * \param[in] ldata - Initialized linkea data
+ * \param[in] linkno - Link identifier
+ * \param[out] parent_fid - The entry's parent FID
+ * \param[out] ln - Entry name destination buffer
*
* \retval 0 on success
* \retval Appropriate negative error code on failure
*/
static int ll_linkea_decode(struct linkea_data *ldata, unsigned int linkno,
- struct getparent *gpout, size_t name_size)
+ struct lu_fid *parent_fid, struct lu_name *ln)
{
unsigned int idx;
- struct lu_name ln;
int rc;
ENTRY;
RETURN(-ENODATA);
linkea_first_entry(ldata);
- idx = 0;
- while (ldata->ld_lee != NULL) {
- linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen, &ln,
- &gpout->gp_fid);
+ for (idx = 0; ldata->ld_lee != NULL; idx++) {
+ linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen, ln,
+ parent_fid);
if (idx == linkno)
break;
linkea_next_entry(ldata);
- idx++;
}
if (idx < linkno)
RETURN(-ENODATA);
- if (ln.ln_namelen >= name_size)
- RETURN(-EOVERFLOW);
-
- gpout->gp_linkno = linkno;
- strlcpy(gpout->gp_name, ln.ln_name, name_size);
RETURN(0);
}
struct inode *inode = file->f_dentry->d_inode;
struct linkea_data *ldata;
struct lu_buf buf = LU_BUF_NULL;
- struct getparent *gpout;
+ struct lu_name ln;
+ struct lu_fid parent_fid;
__u32 linkno;
__u32 name_size;
- size_t out_size;
int rc;
ENTRY;
if (rc < 0)
GOTO(ldata_free, rc);
- out_size = sizeof(*gpout) + name_size;
- OBD_ALLOC(gpout, out_size);
- if (gpout == NULL)
- GOTO(lb_free, rc = -ENOMEM);
-
- if (copy_from_user(gpout, arg, sizeof(*gpout)))
- GOTO(gp_free, rc = -EFAULT);
-
rc = ll_getxattr(dentry, XATTR_NAME_LINK, buf.lb_buf, buf.lb_len);
if (rc < 0)
- GOTO(gp_free, rc);
+ GOTO(lb_free, rc);
- rc = ll_linkea_decode(ldata, linkno, gpout, name_size);
+ rc = ll_linkea_decode(ldata, linkno, &parent_fid, &ln);
if (rc < 0)
- GOTO(gp_free, rc);
+ GOTO(lb_free, rc);
+
+ if (ln.ln_namelen >= name_size)
+ GOTO(lb_free, rc = -EOVERFLOW);
+
+ if (copy_to_user(&arg->gp_fid, &parent_fid, sizeof(arg->gp_fid)))
+ GOTO(lb_free, rc = -EFAULT);
+
+ if (copy_to_user(&arg->gp_name, ln.ln_name, ln.ln_namelen))
+ GOTO(lb_free, rc = -EFAULT);
- if (copy_to_user(arg, gpout, out_size))
- GOTO(gp_free, rc = -EFAULT);
+ if (put_user('\0', arg->gp_name + ln.ln_namelen))
+ GOTO(lb_free, rc = -EFAULT);
-gp_free:
- OBD_FREE(gpout, out_size);
lb_free:
lu_buf_free(&buf);
ldata_free:
git://git.whamcloud.com / fs / lustre-release.git / blobdiff