X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fliblustre%2Fnamei.c;h=f01f44888113a8c00b4cedbcfcc364bdc7057bcb;hb=113303973ec9f8484eb2355a1a6ef3c4c7fd6a56;hp=3929e2cd05b970f43b99370765755b95149de76b;hpb=a888a27ac14736d3df8e730a3909d026d6f40f49;p=fs%2Flustre-release.git diff --git a/lustre/liblustre/namei.c b/lustre/liblustre/namei.c index 3929e2c..f01f448 100644 --- a/lustre/liblustre/namei.c +++ b/lustre/liblustre/namei.c @@ -1,9 +1,9 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * Lustre Light Super operations + * Lustre Light name resolution * - * Copyright (c) 2002, 2003 Cluster File Systems, Inc. + * Copyright (c) 2002-2004 Cluster File Systems, Inc. * * This file is part of Lustre, http://www.lustre.org. * @@ -29,20 +29,25 @@ #include #include #include -#include +#include #include +#ifdef HAVE_XTIO_H +#include +#endif #include #include #include #include +#ifdef HAVE_FILE_H #include +#endif #undef LIST_HEAD #include "llite_lib.h" -static void ll_intent_drop_lock(struct lookup_intent *it) +void ll_intent_drop_lock(struct lookup_intent *it) { struct lustre_handle *handle; @@ -58,7 +63,7 @@ static void ll_intent_drop_lock(struct lookup_intent *it) } } -static void ll_intent_release(struct lookup_intent *it) +void ll_intent_release(struct lookup_intent *it) { ENTRY; @@ -70,6 +75,7 @@ static void ll_intent_release(struct lookup_intent *it) EXIT; } +#if 0 /* * remove the stale inode from pnode */ @@ -94,22 +100,24 @@ void unhook_stale_inode(struct pnode *pno) EXIT; return; } +#endif void llu_lookup_finish_locks(struct lookup_intent *it, struct pnode *pnode) { + struct inode *inode; LASSERT(it); LASSERT(pnode); - if (it && pnode->p_base->pb_ino != NULL) { - struct inode *inode = pnode->p_base->pb_ino; - CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%lu)\n", - inode, llu_i2info(inode)->lli_st_ino, + inode = pnode->p_base->pb_ino; + if (it->d.lustre.it_lock_mode && inode != NULL) { + CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%llu/%lu)\n", + inode, (long long)llu_i2stat(inode)->st_ino, llu_i2info(inode)->lli_st_generation); mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode); } - /* drop IT_LOOKUP locks */ - if (it->it_op == IT_LOOKUP) + /* drop lookup/getattr locks */ + if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR) ll_intent_release(it); } @@ -140,23 +148,28 @@ int llu_mdc_blocking_ast(struct ldlm_lock *lock, case LDLM_CB_CANCELING: { struct inode *inode = llu_inode_from_lock(lock); struct llu_inode_info *lli; + struct intnl_stat *st; + __u64 bits = lock->l_policy_data.l_inodebits.bits; /* Invalidate all dentries associated with this inode */ if (inode == NULL) break; lli = llu_i2info(inode); + st = llu_i2stat(inode); - clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &lli->lli_flags); + if (bits & MDS_INODELOCK_UPDATE) + clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &lli->lli_flags); - if (lock->l_resource->lr_name.name[0] != lli->lli_st_ino || - lock->l_resource->lr_name.name[1] != lli->lli_st_generation) { - LDLM_ERROR(lock, "data mismatch with ino %lu/%lu", - lli->lli_st_ino, lli->lli_st_generation); + if (lock->l_resource->lr_name.name[0] != st->st_ino || + lock->l_resource->lr_name.name[1] !=lli->lli_st_generation){ + LDLM_ERROR(lock, "data mismatch with ino %llu/%lu", + (long long)st->st_ino,lli->lli_st_generation); } - if (S_ISDIR(lli->lli_st_mode)) { - CDEBUG(D_INODE, "invalidating inode %lu\n", - lli->lli_st_ino); + if (S_ISDIR(st->st_mode) && + (bits & MDS_INODELOCK_UPDATE)) { + CDEBUG(D_INODE, "invalidating inode %llu\n", + (long long)st->st_ino); llu_invalidate_inode_pages(inode); } @@ -203,20 +216,20 @@ static int pnode_revalidate_finish(struct ptlrpc_request *req, RETURN(rc); } -int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) +static int llu_pb_revalidate(struct pnode *pnode, int flags, + struct lookup_intent *it) { struct pnode_base *pb = pnode->p_base; - struct ll_fid pfid, cfid; struct it_cb_data icbd; - struct ll_uctxt ctxt; + struct mdc_op_data op_data; struct ptlrpc_request *req = NULL; struct lookup_intent lookup_it = { .it_op = IT_LOOKUP }; struct obd_export *exp; int rc; ENTRY; - CDEBUG(D_VFSTRACE, "VFS Op:name=%s,intent=%x\n", - pb->pb_name.name, it ? it->it_op : 0); + CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,intent=%x\n", + (int)pb->pb_name.len, pb->pb_name.name, it ? it->it_op : 0); /* We don't want to cache negative dentries, so return 0 immediately. * We believe that this is safe, that negative dentries cannot be @@ -226,26 +239,16 @@ int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) RETURN(0); } - /* check stale inode */ - if (llu_i2info(pb->pb_ino)->lli_stale_flag) - unhook_stale_inode(pnode); - - /* check again because unhook_stale_inode() might generate - * negative pnode */ - if (pb->pb_ino == NULL) { - CDEBUG(D_INODE, "negative pb\n"); - RETURN(0); - } - /* This is due to bad interaction with libsysio. remove this when we * switched to libbsdio XXX */ { struct llu_inode_info *lli = llu_i2info(pb->pb_ino); + struct intnl_stat *st = llu_i2stat(pb->pb_ino); if (lli->lli_it) { - CDEBUG(D_INODE, "inode %lu still have intent " + CDEBUG(D_INODE, "inode %llu still have intent " "%p(opc 0x%x), release it\n", - lli->lli_st_ino, lli->lli_it, + (long long) st->st_ino, lli->lli_it, lli->lli_it->it_op); ll_intent_release(lli->lli_it); OBD_FREE(lli->lli_it, sizeof(*lli->lli_it)); @@ -254,8 +257,6 @@ int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) } exp = llu_i2mdcexp(pb->pb_ino); - ll_inode2fid(&pfid, pnode->p_parent->p_base->pb_ino); - ll_inode2fid(&cfid, pb->pb_ino); icbd.icbd_parent = pnode->p_parent->p_base->pb_ino; icbd.icbd_child = pnode; @@ -264,12 +265,12 @@ int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) it->it_op_release = ll_intent_release; } - ll_i2uctxt(&ctxt, pnode->p_parent->p_base->pb_ino, pb->pb_ino); + llu_prepare_mdc_op_data(&op_data, pnode->p_parent->p_base->pb_ino, + pb->pb_ino, pb->pb_name.name,pb->pb_name.len,0); - rc = mdc_intent_lock(exp, &ctxt, &pfid, - pb->pb_name.name, pb->pb_name.len, - NULL, 0, &cfid, it, flags, &req, - llu_mdc_blocking_ast); + rc = mdc_intent_lock(exp, &op_data, NULL, 0, it, flags, + &req, llu_mdc_blocking_ast, + LDLM_FL_CANCEL_ON_BLOCK); /* If req is NULL, then mdc_intent_lock only tried to do a lock match; * if all was well, it will return 1 if it found locks, 0 otherwise. */ if (req == NULL && rc >= 0) @@ -278,15 +279,20 @@ int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) if (rc < 0) GOTO(out, rc = 0); - rc = pnode_revalidate_finish(req, 1, it, pnode); + rc = pnode_revalidate_finish(req, DLM_REPLY_REC_OFF, it, pnode); + if (rc != 0) { + ll_intent_release(it); + GOTO(out, rc = 0); + } + rc = 1; /* Note: ll_intent_lock may cause a callback, check this! */ - if (it->it_op & (IT_OPEN | IT_GETATTR)) + if (it->it_op & IT_OPEN) LL_SAVE_INTENT(pb->pb_ino, it); - RETURN(1); + out: - if (req) + if (req && rc == 1) ptlrpc_req_finished(req); if (rc == 0) { LASSERT(pb->pb_ino); @@ -294,9 +300,6 @@ int llu_pb_revalidate(struct pnode *pnode, int flags, struct lookup_intent *it) pb->pb_ino = NULL; } else { llu_lookup_finish_locks(it, pnode); - llu_i2info(pb->pb_ino)->lli_stale_flag = 0; - if (it->it_op & (IT_OPEN | IT_GETATTR)) - LL_SAVE_INTENT(pb->pb_ino, it); } RETURN(rc); } @@ -311,37 +314,63 @@ static int lookup_it_finish(struct ptlrpc_request *request, int offset, 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 mdc_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 - * Note: libsysio require the inode must be generated here */ - if ((it->it_op & IT_CREAT) || !it_disposition(it, DISP_LOOKUP_NEG)) { + 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 = mdc_req2lustre_md(request, offset, sbi->ll_osc_exp, &md); if (rc) RETURN(rc); inode = llu_iget(parent->i_fs, &md); - if (!inode) { + if (!inode || IS_ERR(inode)) { /* free the lsm if we allocated one above */ if (md.lsm != NULL) obd_free_memmd(sbi->ll_osc_exp, &md.lsm); - RETURN(-ENOMEM); + RETURN(inode ? PTR_ERR(inode) : -ENOMEM); } else if (md.lsm != NULL && llu_i2info(inode)->lli_smd != md.lsm) { obd_free_memmd(sbi->ll_osc_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(lli->lli_st_mode) && + if (it->it_op == IT_GETATTR && S_ISREG(st->st_mode) && lli->lli_smd != NULL) { struct lov_stripe_md *lsm = lli->lli_smd; - struct ost_lvb lvb; ldlm_error_t rc; LASSERT(lsm->lsm_object_id != 0); @@ -349,19 +378,18 @@ static int lookup_it_finish(struct ptlrpc_request *request, int offset, /* bug 2334: drop MDS lock before acquiring OST lock */ ll_intent_drop_lock(it); - rc = llu_glimpse_size(inode, &lvb); + rc = llu_glimpse_size(inode); if (rc) { I_RELE(inode); RETURN(rc); } - lli->lli_st_size = lvb.lvb_size; } } else { ENTRY; } /* intent will be further used in cases of open()/getattr() */ - if (inode && (it->it_op & (IT_OPEN | IT_GETATTR))) + if (inode && (it->it_op & IT_OPEN)) LL_SAVE_INTENT(inode, it); child->p_base->pb_ino = inode; @@ -372,7 +400,7 @@ static int lookup_it_finish(struct ptlrpc_request *request, int offset, struct inode *llu_inode_from_lock(struct ldlm_lock *lock) { struct inode *inode; - l_lock(&lock->l_resource->lr_namespace->ns_lock); + lock_res_and_lock(lock); if (lock->l_ast_data) { inode = (struct inode *)lock->l_ast_data; @@ -380,15 +408,14 @@ struct inode *llu_inode_from_lock(struct ldlm_lock *lock) } else inode = NULL; - l_unlock(&lock->l_resource->lr_namespace->ns_lock); + unlock_res_and_lock(lock); return inode; } static int llu_lookup_it(struct inode *parent, struct pnode *pnode, struct lookup_intent *it, int flags) { - struct ll_fid pfid; - struct ll_uctxt ctxt; + struct mdc_op_data op_data; struct it_cb_data icbd; struct ptlrpc_request *req = NULL; struct lookup_intent lookup_it = { .it_op = IT_LOOKUP }; @@ -405,19 +432,18 @@ static int llu_lookup_it(struct inode *parent, struct pnode *pnode, icbd.icbd_child = pnode; icbd.icbd_parent = parent; - icbd.icbd_child = pnode; - ll_inode2fid(&pfid, parent); - ll_i2uctxt(&ctxt, parent, NULL); - - rc = mdc_intent_lock(llu_i2mdcexp(parent), &ctxt, &pfid, - pnode->p_base->pb_name.name, - pnode->p_base->pb_name.len, - NULL, 0, NULL, it, flags, &req, - llu_mdc_blocking_ast); + + llu_prepare_mdc_op_data(&op_data, parent, NULL, + pnode->p_base->pb_name.name, + pnode->p_base->pb_name.len, flags); + + rc = mdc_intent_lock(llu_i2mdcexp(parent), &op_data, NULL, 0, it, + flags, &req, llu_mdc_blocking_ast, + LDLM_FL_CANCEL_ON_BLOCK); if (rc < 0) GOTO(out, rc); - - rc = lookup_it_finish(req, 1, it, &icbd); + + rc = lookup_it_finish(req, DLM_REPLY_REC_OFF, it, &icbd); if (rc != 0) { ll_intent_release(it); GOTO(out, rc); @@ -484,6 +510,12 @@ translate_lookup_intent(struct intent *intent, const char *path) if (it->it_flags & O_CREAT) { it->it_op |= IT_CREAT; it->it_create_mode = *((int*)intent->int_arg1); + /* bug 7278: libsysio hack. For O_EXCL, libsysio depends on + this lookup to return negative result, but then there is no + way to find out original intent in ll_iop_open(). So we just + clear O_EXCL from libsysio flags here to avoid checking + for negative result. O_EXCL will be enforced by MDS. */ + *((int*)intent->int_arg2) &= ~O_EXCL; } if (intent->int_opmask & INT_GETATTR) @@ -518,6 +550,8 @@ int llu_iop_lookup(struct pnode *pnode, int rc; ENTRY; + liblustre_wait_event(0); + *inop = NULL; /* the mount root inode have no name, so don't call @@ -526,7 +560,7 @@ int llu_iop_lookup(struct pnode *pnode, if (pnode->p_mount->mnt_root == pnode) { struct inode *i = pnode->p_base->pb_ino; *inop = i; - return 0; + RETURN(0); } if (!pnode->p_base->pb_name.len) @@ -538,7 +572,7 @@ int llu_iop_lookup(struct pnode *pnode, if (llu_pb_revalidate(pnode, 0, it)) { LASSERT(pnode->p_base->pb_ino); *inop = pnode->p_base->pb_ino; - RETURN(0); + GOTO(out, rc = 0); } rc = llu_lookup_it(pnode->p_parent->p_base->pb_ino, pnode, it, 0); @@ -549,6 +583,7 @@ int llu_iop_lookup(struct pnode *pnode, *inop = pnode->p_base->pb_ino; } +out: + liblustre_wait_event(0); RETURN(rc); } -