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); } }