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);
}
int llu_iop_open(struct pnode *pnode, int flags, mode_t mode)
{
struct inode *inode = pnode->p_base->pb_ino;
struct llu_inode_info *lli = llu_i2info(inode);
struct intnl_stat *st = llu_i2stat(inode);
struct ll_file_data *fd;
struct ptlrpc_request *request;
struct lookup_intent *it;
struct lov_stripe_md *lsm;
int rc = 0;
ENTRY;
liblustre_wait_event(0);
/* don't do anything for '/' */
if (llu_is_root_inode(inode))
RETURN(0);
CDEBUG(D_VFSTRACE, "VFS Op:inode=%llu\n", (long long)st->st_ino);
LL_GET_INTENT(inode, it);
if (!it->d.lustre.it_disposition) {
LBUG();
}
rc = it_open_error(DISP_OPEN_OPEN, it);
if (rc)
GOTO(out_release, rc);
rc = llu_local_open(lli, it);
if (rc)
LBUG();
if (!S_ISREG(st->st_mode))
GOTO(out_release, rc = 0);
fd = lli->lli_file_data;
lsm = lli->lli_smd;
if (lsm)
flags &= ~O_LOV_DELAY_CREATE;
/*XXX: open_flags are overwritten and the previous ones are lost */
lli->lli_open_flags = flags & ~(O_CREAT | O_EXCL | O_TRUNC);
out_release:
request = it->d.lustre.it_data;
ptlrpc_req_finished(request);
it->it_op_release(it);
OBD_FREE(it, sizeof(*it));
/* libsysio hasn't done anything for O_TRUNC. here we
* simply simulate it as open(...); truncate(...); */
if (rc == 0 && (flags & O_TRUNC) && S_ISREG(st->st_mode)) {
struct iattr attr;
memset(&attr, 0, sizeof(attr));
attr.ia_size = 0;
attr.ia_valid |= ATTR_SIZE | ATTR_RAW;
rc = llu_setattr_raw(inode, &attr);
if (rc)
CERROR("error %d truncate in open()\n", rc);
}
liblustre_wait_event(0);
RETURN(rc);
}
