struct inode *search_inode_for_lustre(struct super_block *sb,
const struct lu_fid *fid)
{
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct ptlrpc_request *req = NULL;
struct inode *inode = NULL;
int eadatalen = 0;
unsigned long hash = cl_fid_build_ino(fid,
ll_need_32bit_api(sbi));
struct md_op_data *op_data;
int rc;
CDEBUG(D_INFO, "searching inode for:(%lu,"DFID")\n", hash, PFID(fid));
inode = ilookup5(sb, hash, ll_nfs_test_inode, (void *)fid);
if (inode)
return inode;
rc = ll_get_default_mdsize(sbi, &eadatalen);
if (rc)
return ERR_PTR(rc);
/* Because inode is NULL, ll_prep_md_op_data can not
* be used here. So we allocate op_data ourselves */
op_data = kzalloc(sizeof(*op_data), GFP_NOFS);
if (!op_data)
return ERR_PTR(-ENOMEM);
op_data->op_fid1 = *fid;
op_data->op_mode = eadatalen;
op_data->op_valid = OBD_MD_FLEASIZE;
/* mds_fid2dentry ignores f_type */
rc = md_getattr(sbi->ll_md_exp, op_data, &req);
kfree(op_data);
if (rc) {
CERROR("can't get object attrs, fid "DFID", rc %d\n",
PFID(fid), rc);
return ERR_PTR(rc);
}
rc = ll_prep_inode(&inode, req, sb, NULL);
ptlrpc_req_finished(req);
if (rc)
return ERR_PTR(rc);
return inode;
}
ssize_t llu_iop_filldirentries(struct inode *dir, _SYSIO_OFF_T *basep,
char *buf, size_t nbytes)
{
struct llu_inode_info *lli = llu_i2info(dir);
struct intnl_stat *st = llu_i2stat(dir);
loff_t pos = *basep;
struct ll_dir_chain chain;
struct page *page;
int filled = 0;
int rc;
int done;
__u16 type;
ENTRY;
liblustre_wait_event(0);
if (st->st_size == 0) {
CWARN("dir size is 0?\n");
RETURN(0);
}
if (pos == MDS_DIR_END_OFF)
/*
* end-of-file.
*/
RETURN(0);
rc = 0;
done = 0;
ll_dir_chain_init(&chain);
page = llu_dir_read_page(dir, pos, 0, &chain);
while (rc == 0 && !done) {
struct lu_dirpage *dp;
struct lu_dirent *ent;
if (!IS_ERR(page)) {
/*
* If page is empty (end of directoryis reached),
* use this value.
*/
__u64 hash = MDS_DIR_END_OFF;
__u64 next;
dp = page->addr;
for (ent = lu_dirent_start(dp); ent != NULL && !done;
ent = lu_dirent_next(ent)) {
char *name;
int namelen;
struct lu_fid fid;
__u64 ino;
hash = le64_to_cpu(ent->lde_hash);
namelen = le16_to_cpu(ent->lde_namelen);
if (hash < pos)
/*
* Skip until we find target hash
* value.
*/
continue;
if (namelen == 0)
/*
* Skip dummy record.
*/
continue;
fid = ent->lde_fid;
name = ent->lde_name;
fid_le_to_cpu(&fid, &fid);
ino = cl_fid_build_ino(&fid, 0);
type = ll_dirent_type_get(ent);
done = filldir(buf, nbytes, name, namelen,
(loff_t)hash, ino, type,
&filled);
}
next = le64_to_cpu(dp->ldp_hash_end);
OBD_PAGE_FREE(page);
if (!done) {
pos = next;
if (pos == MDS_DIR_END_OFF)
/*
* End of directory reached.
*/
done = 1;
else if (1 /* chain is exhausted*/)
/*
* Normal case: continue to the next
* page.
*/
page = llu_dir_read_page(dir, pos, 1,
&chain);
else {
/*
* go into overflow page.
*/
}
} else {
pos = hash;
if (filled == 0)
GOTO(out, filled = -EINVAL);
}
} else {
rc = PTR_ERR(page);
CERROR("error reading dir "DFID" at %lu: rc %d\n",
PFID(&lli->lli_fid), (unsigned long)pos, rc);
}
}
lli->lli_dir_pos = (loff_t)pos;
*basep = lli->lli_dir_pos;
out:
ll_dir_chain_fini(&chain);
liblustre_wait_event(0);
RETURN(filled);
}
int ll_dir_read(struct inode *inode, __u64 *ppos, struct md_op_data *op_data,
struct dir_context *ctx)
{
struct ll_sb_info *sbi = ll_i2sbi(inode);
__u64 pos = *ppos;
int is_api32 = ll_need_32bit_api(sbi);
int is_hash64 = sbi->ll_flags & LL_SBI_64BIT_HASH;
struct page *page;
bool done = false;
int rc = 0;
page = ll_get_dir_page(inode, op_data, pos);
while (rc == 0 && !done) {
struct lu_dirpage *dp;
struct lu_dirent *ent;
__u64 hash;
__u64 next;
if (IS_ERR(page)) {
rc = PTR_ERR(page);
break;
}
hash = MDS_DIR_END_OFF;
dp = page_address(page);
for (ent = lu_dirent_start(dp); ent && !done;
ent = lu_dirent_next(ent)) {
__u16 type;
int namelen;
struct lu_fid fid;
__u64 lhash;
__u64 ino;
hash = le64_to_cpu(ent->lde_hash);
if (hash < pos)
/*
* Skip until we find target hash
* value.
*/
continue;
namelen = le16_to_cpu(ent->lde_namelen);
if (namelen == 0)
/*
* Skip dummy record.
*/
continue;
if (is_api32 && is_hash64)
lhash = hash >> 32;
else
lhash = hash;
fid_le_to_cpu(&fid, &ent->lde_fid);
ino = cl_fid_build_ino(&fid, is_api32);
type = ll_dirent_type_get(ent);
ctx->pos = lhash;
/* For 'll_nfs_get_name_filldir()', it will try
* to access the 'ent' through its 'lde_name',
* so the parameter 'name' for 'ctx->actor()'
* must be part of the 'ent'.
*/
done = !dir_emit(ctx, ent->lde_name,
namelen, ino, type);
}
if (done) {
pos = hash;
ll_release_page(inode, page, false);
break;
}
next = le64_to_cpu(dp->ldp_hash_end);
pos = next;
if (pos == MDS_DIR_END_OFF) {
/*
* End of directory reached.
*/
done = 1;
ll_release_page(inode, page, false);
} else {
/*
* Normal case: continue to the next
* page.
*/
ll_release_page(inode, page,
le32_to_cpu(dp->ldp_flags) &
LDF_COLLIDE);
next = pos;
page = ll_get_dir_page(inode, op_data, pos);
}
}
