X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fllite_nfs.c;h=754e49da9db72616f15517fe277e0ec514505aab;hb=fceb71c7cf419731a0e061ed6e09659cd149c9ff;hp=c9ddcdc0a815f8b18abbe556929945a003e7f127;hpb=df9e7e34174572e678b95d0c5ea88b05b4acbda8;p=fs%2Flustre-release.git diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c index c9ddcdc..754e49d 100644 --- a/lustre/llite/llite_nfs.c +++ b/lustre/llite/llite_nfs.c @@ -3,7 +3,10 @@ * * NFS export of Lustre Light File System * - * Copyright (c) 2002, 2003 Cluster File Systems, Inc. + * Copyright (c) 2002, 2006 Cluster File Systems, Inc. + * + * Author: Yury Umanets + * Huang Hua * * This file is part of Lustre, http://www.lustre.org. * @@ -22,175 +25,215 @@ */ #define DEBUG_SUBSYSTEM S_LLITE -#include +#include #include "llite_internal.h" +#ifdef HAVE_LINUX_EXPORTFS_H +#include +#endif -__u32 get_uuid2int(const char *name, int len) -{ - __u32 key0 = 0x12a3fe2d, key1 = 0x37abe8f9; - while (len--) { - __u32 key = key1 + (key0 ^ (*name++ * 7152373)); - if (key & 0x80000000) key -= 0x7fffffff; - key1 = key0; - key0 = key; - } - return (key0 << 1); -} - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -static int ll_nfs_test_inode(struct inode *inode, unsigned long ino, - void *opaque) -#else static int ll_nfs_test_inode(struct inode *inode, void *opaque) -#endif { - struct lustre_id *iid = opaque; - - if (inode->i_ino == id_ino(iid) && - inode->i_generation == id_gen(iid)) - return 1; - - return 0; + return lu_fid_eq(&ll_i2info(inode)->lli_fid, + (struct lu_fid *)opaque); } -static struct inode * search_inode_for_lustre(struct super_block *sb, - unsigned long ino, - unsigned long generation, - int mode) + +static struct inode *search_inode_for_lustre(struct super_block *sb, + struct lu_fid *fid, + int mode) { + struct ll_sb_info *sbi = ll_s2sbi(sb); struct ptlrpc_request *req = NULL; - struct ll_sb_info *sbi = ll_s2sbi(sb); - struct lustre_id id; - __u64 valid = 0; - int eadatalen = 0, rc; - struct inode *inode = NULL; - struct lustre_id iid; - - id_ino(&iid) = (__u64)ino; - id_gen(&iid) = generation; - inode = ILOOKUP(sb, ino, ll_nfs_test_inode, &iid); + struct inode *inode = NULL; + unsigned long valid = 0; + int eadatalen = 0; + ino_t ino = ll_fid_build_ino(sbi, fid); + int rc; + ENTRY; + CDEBUG(D_INFO, "searching inode for:(%lu,"DFID")\n", ino, PFID(fid)); + + inode = ILOOKUP(sb, ino, ll_nfs_test_inode, fid); if (inode) - return inode; + RETURN(inode); + if (S_ISREG(mode)) { - eadatalen = obd_size_diskmd(sbi->ll_dt_exp, NULL); + rc = ll_get_max_mdsize(sbi, &eadatalen); + if (rc) + RETURN(ERR_PTR(rc)); valid |= OBD_MD_FLEASIZE; } - id_type(&id) = mode; - id_ino(&id) = (__u64)ino; - id_gen(&id) = generation; - rc = md_getattr(sbi->ll_md_exp, &id, valid, NULL, - eadatalen, &req); + rc = md_getattr(sbi->ll_md_exp, fid, NULL, valid, eadatalen, &req); if (rc) { - CERROR("failure %d inode %lu\n", rc, ino); - return ERR_PTR(rc); + CERROR("can't get object attrs, fid "DFID", rc %d\n", + PFID(fid), rc); + RETURN(ERR_PTR(rc)); } - rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp, - &inode, req, 0, sb); - if (rc) { - ptlrpc_req_finished(req); - return ERR_PTR(rc); - } + rc = ll_prep_inode(&inode, req, REPLY_REC_OFF, sb); ptlrpc_req_finished(req); + if (rc) + RETURN(ERR_PTR(rc)); - return inode; + RETURN(inode); } extern struct dentry_operations ll_d_ops; -static struct dentry *ll_iget_for_nfs(struct super_block *sb, unsigned long ino, - __u32 generation, umode_t mode) +static struct dentry *ll_iget_for_nfs(struct super_block *sb, + struct lu_fid *fid, + umode_t mode) { - struct inode *inode; + struct inode *inode; struct dentry *result; - struct list_head *lp; + ENTRY; - if (ino == 0) - return ERR_PTR(-ESTALE); + CDEBUG(D_INFO, "Get dentry for fid: "DFID"\n", PFID(fid)); + if (!fid_is_sane(fid)) + RETURN(ERR_PTR(-ESTALE)); - inode = search_inode_for_lustre(sb, ino, generation, mode); - if (IS_ERR(inode)) { - return ERR_PTR(PTR_ERR(inode)); - } - if (is_bad_inode(inode) || - (generation && inode->i_generation != generation)){ + inode = search_inode_for_lustre(sb, fid, mode); + if (IS_ERR(inode)) + RETURN(ERR_PTR(PTR_ERR(inode))); + + if (is_bad_inode(inode)) { /* we didn't find the right inode.. */ - CERROR(" Inode %lu, Bad count: %lu %d or version %u %u\n", - inode->i_ino, (unsigned long)inode->i_nlink, - atomic_read(&inode->i_count), inode->i_generation, - generation); + CERROR("can't get inode by fid "DFID"\n", + PFID(fid)); iput(inode); - return ERR_PTR(-ESTALE); + RETURN(ERR_PTR(-ESTALE)); } - /* now to find a dentry. - * If possible, get a well-connected one - */ - spin_lock(&dcache_lock); - for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) { - result = list_entry(lp,struct dentry, d_alias); - if (!(result->d_flags & DCACHE_DISCONNECTED)) { - dget_locked(result); - ll_set_dflags(result, DCACHE_REFERENCED); - spin_unlock(&dcache_lock); - iput(inode); - return result; - } - } - spin_unlock(&dcache_lock); - result = d_alloc_root(inode); - if (result == NULL) { + result = d_alloc_anon(inode); + if (!result) { iput(inode); - return ERR_PTR(-ENOMEM); + RETURN(ERR_PTR(-ENOMEM)); } - result->d_flags |= DCACHE_DISCONNECTED; - ll_set_dd(result); result->d_op = &ll_d_ops; - return result; + RETURN(result); +} + +/* + * This length is counted as amount of __u32, + * It is composed of a fid and a mode + */ +#define ONE_FH_LEN (sizeof(struct lu_fid)/4 + 1) + +static struct dentry *ll_decode_fh(struct super_block *sb, __u32 *fh, int fh_len, + int fh_type, + int (*acceptable)(void *, struct dentry *), + void *context) +{ + struct lu_fid *parent = NULL; + struct lu_fid *child; + struct dentry *entry; + ENTRY; + + CDEBUG(D_INFO, "decoding for "DFID" fh_len=%d fh_type=%d\n", + PFID((struct lu_fid*)fh), fh_len, fh_type); + + if (fh_type != 1 && fh_type != 2) + RETURN(ERR_PTR(-ESTALE)); + if (fh_len < ONE_FH_LEN * fh_type) + RETURN(ERR_PTR(-ESTALE)); + + child = (struct lu_fid*)fh; + if (fh_type == 2) + parent = (struct lu_fid*)(fh + ONE_FH_LEN); + + entry = sb->s_export_op->find_exported_dentry(sb, child, parent, + acceptable, context); + RETURN(entry); } -struct dentry *ll_fh_to_dentry(struct super_block *sb, __u32 *data, int len, - int fhtype, int parent) +/* The return value is file handle type: + * 1 -- contains child file handle; + * 2 -- contains child file handle and parent file handle; + * 255 -- error. + */ +static int ll_encode_fh(struct dentry *de, __u32 *fh, int *plen, int connectable) { - switch (fhtype) { - case 2: - if (len < 5) - break; - if (parent) - return ll_iget_for_nfs(sb, data[3], 0, data[4]); - case 1: - if (len < 3) - break; - if (parent) - break; - return ll_iget_for_nfs(sb, data[0], data[1], data[2]); - default: break; + struct inode *inode = de->d_inode; + struct lu_fid *fid = ll_inode2fid(inode); + ENTRY; + + CDEBUG(D_INFO, "encoding for (%lu,"DFID") maxlen=%d minlen=%d\n", + inode->i_ino, PFID(fid), *plen, ONE_FH_LEN); + + if (*plen < ONE_FH_LEN) + RETURN(255); + + memcpy((char*)fh, fid, sizeof(*fid)); + *(fh + ONE_FH_LEN - 1) = (__u32)(S_IFMT & inode->i_mode); + + if (de->d_parent && *plen >= ONE_FH_LEN * 2) { + struct inode *parent = de->d_parent->d_inode; + fh += ONE_FH_LEN; + memcpy((char*)fh, &ll_i2info(parent)->lli_fid, sizeof(*fid)); + *(fh + ONE_FH_LEN - 1) = (__u32)(S_IFMT & parent->i_mode); + *plen = ONE_FH_LEN * 2; + RETURN(2); + } else { + *plen = ONE_FH_LEN; + RETURN(1); } - return ERR_PTR(-EINVAL); } -int ll_dentry_to_fh(struct dentry *dentry, __u32 *datap, int *lenp, - int need_parent) +static struct dentry *ll_get_dentry(struct super_block *sb, void *data) { - if (*lenp < 3) - return 255; - *datap++ = dentry->d_inode->i_ino; - *datap++ = dentry->d_inode->i_generation; - *datap++ = (__u32)(S_IFMT & dentry->d_inode->i_mode); - - if (*lenp == 3 || S_ISDIR(dentry->d_inode->i_mode)) { - *lenp = 3; - return 1; - } - if (dentry->d_parent) { - *datap++ = dentry->d_parent->d_inode->i_ino; - *datap++ = (__u32)(S_IFMT & dentry->d_parent->d_inode->i_mode); - - *lenp = 5; - return 2; - } - *lenp = 3; - return 1; + struct lu_fid *fid; + struct dentry *entry; + __u32 mode; + ENTRY; + + fid = (struct lu_fid *)data; + mode = *((__u32*)data + ONE_FH_LEN - 1); + + entry = ll_iget_for_nfs(sb, fid, mode); + RETURN(entry); } + +static struct dentry *ll_get_parent(struct dentry *dchild) +{ + struct ptlrpc_request *req = NULL; + struct inode *dir = dchild->d_inode; + struct ll_sb_info *sbi; + struct dentry *result = NULL; + struct mdt_body *body; + static char dotdot[] = ".."; + int rc; + ENTRY; + + LASSERT(dir && S_ISDIR(dir->i_mode)); + + sbi = ll_s2sbi(dir->i_sb); + + CDEBUG(D_INFO, "getting parent for (%lu,"DFID")\n", + dir->i_ino, PFID(ll_inode2fid(dir))); + + rc = md_getattr_name(sbi->ll_md_exp, ll_inode2fid(dir), NULL, + dotdot, strlen(dotdot) + 1, 0, 0, &req); + if (rc) { + CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino); + RETURN(ERR_PTR(rc)); + } + body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + + LASSERT(body->valid & OBD_MD_FLID); + + CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n", + PFID(ll_inode2fid(dir)), PFID(&body->fid1)); + + result = ll_iget_for_nfs(dir->i_sb, &body->fid1, S_IFDIR); + + ptlrpc_req_finished(req); + RETURN(result); +} + +struct export_operations lustre_export_operations = { + .get_parent = ll_get_parent, + .get_dentry = ll_get_dentry, + .encode_fh = ll_encode_fh, + .decode_fh = ll_decode_fh, +};