static void ll_intent_release(struct lookup_intent *it)
{
ENTRY;
ll_intent_drop_lock(it);
it->it_magic = 0;
it->it_op_release = 0;
it->d.lustre.it_disposition = 0;
it->d.lustre.it_data = NULL;
EXIT;
}
void ll_intent_release(struct lookup_intent *it)
{
ENTRY;
CDEBUG(D_INFO, "intent %p released\n", it);
ll_intent_drop_lock(it);
/* We are still holding extra reference on a request, need to free it */
if (it_disposition(it, DISP_ENQ_OPEN_REF))
ptlrpc_req_finished(it->d.lustre.it_data); /* ll_file_open */
if (it_disposition(it, DISP_ENQ_CREATE_REF)) /* create rec */
ptlrpc_req_finished(it->d.lustre.it_data);
if (it_disposition(it, DISP_ENQ_COMPLETE)) /* saved req from revalidate
* to lookup */
ptlrpc_req_finished(it->d.lustre.it_data);
it->d.lustre.it_disposition = 0;
it->d.lustre.it_data = NULL;
EXIT;
}
void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
{
LASSERT(it != NULL);
LASSERT(dentry != NULL);
if (it->d.lustre.it_lock_mode && dentry->d_inode != NULL) {
struct inode *inode = dentry->d_inode;
struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
inode, inode->i_ino, inode->i_generation);
ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL);
}
/* drop lookup or getattr locks immediately */
if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR) {
/* on 2.6 there are situation when several lookups and
* revalidations may be requested during single operation.
* therefore, we don't release intent here -bzzz */
ll_intent_drop_lock(it);
}
}
static int lookup_it_finish(struct ptlrpc_request *request, int offset,
struct lookup_intent *it,
struct inode *parent, struct pnode *child)
{
struct llu_sb_info *sbi = llu_i2sbi(parent);
struct inode *inode = NULL;
int rc;
/* libsysio require us generate inode right away if success.
* so if mds created new inode for us we need make sure it
* succeeded. thus for any error we can't delay to the
* llu_file_open() time. */
if (it_disposition(it, DISP_OPEN_CREATE) &&
it_open_error(DISP_OPEN_CREATE, it)) {
CDEBUG(D_INODE, "detect mds create error\n");
return it_open_error(DISP_OPEN_CREATE, it);
}
if (it_disposition(it, DISP_OPEN_OPEN) &&
it_open_error(DISP_OPEN_OPEN, it)) {
CDEBUG(D_INODE, "detect mds open error\n");
/* undo which did by md_intent_lock */
if (it_disposition(it, DISP_OPEN_CREATE) &&
!it_open_error(DISP_OPEN_CREATE, it)) {
LASSERT(request);
LASSERT(atomic_read(&request->rq_refcount) > 1);
CDEBUG(D_INODE, "dec a ref of req %p\n", request);
ptlrpc_req_finished(request);
}
return it_open_error(DISP_OPEN_OPEN, it);
}
/* NB 1 request reference will be taken away by ll_intent_lock()
* when I return
*/
if (!it_disposition(it, DISP_LOOKUP_NEG) || (it->it_op & IT_CREAT)) {
struct lustre_md md;
struct llu_inode_info *lli;
struct intnl_stat *st;
ENTRY;
if (it_disposition(it, DISP_OPEN_CREATE))
ptlrpc_req_finished(request);
rc = md_get_lustre_md(sbi->ll_md_exp, request,
sbi->ll_dt_exp, sbi->ll_md_exp, &md);
if (rc)
RETURN(rc);
inode = llu_iget(parent->i_fs, &md);
if (!inode || IS_ERR(inode)) {
/* free the lsm if we allocated one above */
if (md.lsm != NULL)
obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
RETURN(inode ? PTR_ERR(inode) : -ENOMEM);
} else if (md.lsm != NULL) {
obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
}
lli = llu_i2info(inode);
st = llu_i2stat(inode);
/* If this is a stat, get the authoritative file size */
if (it->it_op == IT_GETATTR && S_ISREG(st->st_mode) &&
lli->lli_has_smd) {
ldlm_error_t rc;
/* bug 2334: drop MDS lock before acquiring OST lock */
ll_intent_drop_lock(it);
rc = cl_glimpse_size(inode);
if (rc) {
I_RELE(inode);
RETURN(rc);
}
}
} else {
ENTRY;
}
/* intent will be further used in cases of open()/getattr() */
if (inode && (it->it_op & IT_OPEN))
LL_SAVE_INTENT(inode, it);
child->p_base->pb_ino = inode;
RETURN(0);
}
