static int f2fs_readdir(struct file *file, struct dir_context *ctx) { struct inode *inode = file_inode(file); unsigned long npages = dir_blocks(inode); unsigned int bit_pos = 0; struct f2fs_dentry_block *dentry_blk = NULL; struct f2fs_dir_entry *de = NULL; struct page *dentry_page = NULL; struct file_ra_state *ra = &file->f_ra; unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK); unsigned char d_type = DT_UNKNOWN; bit_pos = ((unsigned long)ctx->pos % NR_DENTRY_IN_BLOCK); /* readahead for multi pages of dir */ if (npages - n > 1 && !ra_has_index(ra, n)) page_cache_sync_readahead(inode->i_mapping, ra, file, n, min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES)); for (; n < npages; n++) { dentry_page = get_lock_data_page(inode, n); if (IS_ERR(dentry_page)) continue; dentry_blk = kmap(dentry_page); while (bit_pos < NR_DENTRY_IN_BLOCK) { bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, NR_DENTRY_IN_BLOCK, bit_pos); if (bit_pos >= NR_DENTRY_IN_BLOCK) break; de = &dentry_blk->dentry[bit_pos]; if (de->file_type < F2FS_FT_MAX) d_type = f2fs_filetype_table[de->file_type]; else d_type = DT_UNKNOWN; if (!dir_emit(ctx, dentry_blk->filename[bit_pos], le16_to_cpu(de->name_len), le32_to_cpu(de->ino), d_type)) goto stop; bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); ctx->pos = n * NR_DENTRY_IN_BLOCK + bit_pos; } bit_pos = 0; ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK; kunmap(dentry_page); f2fs_put_page(dentry_page, 1); dentry_page = NULL; } stop: if (dentry_page && !IS_ERR(dentry_page)) { kunmap(dentry_page); f2fs_put_page(dentry_page, 1); } return 0; }
/* * Find an entry in the specified directory with the wanted name. * It returns the page where the entry was found (as a parameter - res_page), * and the entry itself. Page is returned mapped and unlocked. * Entry is guaranteed to be valid. */ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, struct qstr *child, struct page **res_page) { unsigned long npages = dir_blocks(dir); struct f2fs_dir_entry *de = NULL; f2fs_hash_t name_hash; unsigned int max_depth; unsigned int level; if (npages == 0) return NULL; *res_page = NULL; name_hash = f2fs_dentry_hash(child); max_depth = F2FS_I(dir)->i_current_depth; for (level = 0; level < max_depth; level++) { de = find_in_level(dir, level, child, name_hash, res_page); if (de) break; } if (!de && F2FS_I(dir)->chash != name_hash) { F2FS_I(dir)->chash = name_hash; F2FS_I(dir)->clevel = level - 1; } return de; }
bool f2fs_empty_dir(struct inode *dir) { unsigned long bidx; struct page *dentry_page; unsigned int bit_pos; struct f2fs_dentry_block *dentry_blk; unsigned long nblock = dir_blocks(dir); for (bidx = 0; bidx < nblock; bidx++) { dentry_page = get_lock_data_page(dir, bidx); if (IS_ERR(dentry_page)) { if (PTR_ERR(dentry_page) == -ENOENT) continue; else return false; } dentry_blk = kmap_atomic(dentry_page); if (bidx == 0) bit_pos = 2; else bit_pos = 0; bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, NR_DENTRY_IN_BLOCK, bit_pos); kunmap_atomic(dentry_blk); f2fs_put_page(dentry_page, 1); if (bit_pos < NR_DENTRY_IN_BLOCK) return false; } return true; }
static int f2fs_readdir(struct file *file, void *dirent, filldir_t filldir) { unsigned long pos = file->f_pos; unsigned int bit_pos = 0; struct inode *inode = file_inode(file); unsigned long npages = dir_blocks(inode); struct f2fs_dentry_block *dentry_blk = NULL; struct page *dentry_page = NULL; struct file_ra_state *ra = &file->f_ra; struct f2fs_dentry_ptr d; unsigned int n = 0; if (f2fs_has_inline_dentry(inode)) return f2fs_read_inline_dir(file, dirent, filldir); bit_pos = (pos % NR_DENTRY_IN_BLOCK); n = (pos / NR_DENTRY_IN_BLOCK); /* readahead for multi pages of dir */ if (npages - n > 1 && !ra_has_index(ra, n)) page_cache_sync_readahead(inode->i_mapping, ra, file, n, min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES)); for (; n < npages; n++) { dentry_page = get_lock_data_page(inode, n); if (IS_ERR(dentry_page)) continue; dentry_blk = kmap(dentry_page); make_dentry_ptr(&d, (void *)dentry_blk, 1); if (f2fs_fill_dentries(file, dirent, filldir, &d, n, bit_pos)) goto stop; bit_pos = 0; file->f_pos = (n + 1) * NR_DENTRY_IN_BLOCK; kunmap(dentry_page); f2fs_put_page(dentry_page, 1); dentry_page = NULL; } stop: if (dentry_page && !IS_ERR(dentry_page)) { kunmap(dentry_page); f2fs_put_page(dentry_page, 1); } return 0; }
/** * vxfs_find_entry - find a mathing directory entry for a dentry * @ip: directory inode * @dp: dentry for which we want to find a direct * @ppp: gets filled with the page the return value sits in * * Description: * vxfs_find_entry finds a &struct vxfs_direct for the VFS directory * cache entry @dp. @ppp will be filled with the page the return * value resides in. * * Returns: * The wanted direct on success, else a NULL pointer. */ static struct vxfs_direct * vxfs_find_entry(struct inode *ip, struct dentry *dp, struct page **ppp) { u_long npages, page, nblocks, pblocks, block; u_long bsize = ip->i_sb->s_blocksize; const char *name = dp->d_name.name; int namelen = dp->d_name.len; npages = dir_pages(ip); nblocks = dir_blocks(ip); pblocks = VXFS_BLOCK_PER_PAGE(ip->i_sb); for (page = 0; page < npages; page++) { caddr_t kaddr; struct page *pp; pp = vxfs_get_page(ip->i_mapping, page); if (IS_ERR(pp)) continue; kaddr = (caddr_t)page_address(pp); for (block = 0; block <= nblocks && block <= pblocks; block++) { caddr_t baddr, limit; struct vxfs_dirblk *dbp; struct vxfs_direct *de; baddr = kaddr + (block * bsize); limit = baddr + bsize - VXFS_DIRLEN(1); dbp = (struct vxfs_dirblk *)baddr; de = (struct vxfs_direct *)(baddr + VXFS_DIRBLKOV(dbp)); for (; (caddr_t)de <= limit; de = vxfs_next_entry(de)) { if (!de->d_reclen) break; if (!de->d_ino) continue; if (vxfs_match(namelen, name, de)) { *ppp = pp; return (de); } } } vxfs_put_page(pp); } return NULL; }
static int f2fs_readdir(struct file *file, void *dirent, filldir_t filldir) { unsigned long pos = file->f_pos; unsigned char *types = NULL; unsigned int bit_pos = 0, start_bit_pos = 0; int over = 0; struct inode *inode = file_inode(file); unsigned long npages = dir_blocks(inode); struct f2fs_dentry_block *dentry_blk = NULL; struct f2fs_dir_entry *de = NULL; struct page *dentry_page = NULL; unsigned int n = 0; unsigned char d_type = DT_UNKNOWN; int slots; types = f2fs_filetype_table; bit_pos = (pos % NR_DENTRY_IN_BLOCK); n = (pos / NR_DENTRY_IN_BLOCK); for ( ; n < npages; n++) { dentry_page = get_lock_data_page(inode, n); if (IS_ERR(dentry_page)) continue; start_bit_pos = bit_pos; dentry_blk = kmap(dentry_page); while (bit_pos < NR_DENTRY_IN_BLOCK) { d_type = DT_UNKNOWN; bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, NR_DENTRY_IN_BLOCK, bit_pos); if (bit_pos >= NR_DENTRY_IN_BLOCK) break; de = &dentry_blk->dentry[bit_pos]; if (types && de->file_type < F2FS_FT_MAX) d_type = types[de->file_type]; over = filldir(dirent, dentry_blk->filename[bit_pos], le16_to_cpu(de->name_len), (n * NR_DENTRY_IN_BLOCK) + bit_pos, le32_to_cpu(de->ino), d_type); if (over) { file->f_pos += bit_pos - start_bit_pos; goto stop; } slots = GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); bit_pos += slots; } bit_pos = 0; file->f_pos = (n + 1) * NR_DENTRY_IN_BLOCK; kunmap(dentry_page); f2fs_put_page(dentry_page, 1); dentry_page = NULL; } stop: if (dentry_page && !IS_ERR(dentry_page)) { kunmap(dentry_page); f2fs_put_page(dentry_page, 1); } return 0; }
/** * vxfs_readdir - read a directory * @fp: the directory to read * @retp: return buffer * @filler: filldir callback * * Description: * vxfs_readdir fills @retp with directory entries from @fp * using the VFS supplied callback @filler. * * Returns: * Zero. */ static int vxfs_readdir(struct file *fp, void *retp, filldir_t filler) { struct inode *ip = fp->f_path.dentry->d_inode; struct super_block *sbp = ip->i_sb; u_long bsize = sbp->s_blocksize; u_long page, npages, block, pblocks, nblocks, offset; loff_t pos; switch ((long)fp->f_pos) { case 0: if (filler(retp, ".", 1, fp->f_pos, ip->i_ino, DT_DIR) < 0) goto out; fp->f_pos++; /* fallthrough */ case 1: if (filler(retp, "..", 2, fp->f_pos, VXFS_INO(ip)->vii_dotdot, DT_DIR) < 0) goto out; fp->f_pos++; /* fallthrough */ } pos = fp->f_pos - 2; if (pos > VXFS_DIRROUND(ip->i_size)) return 0; npages = dir_pages(ip); nblocks = dir_blocks(ip); pblocks = VXFS_BLOCK_PER_PAGE(sbp); page = pos >> PAGE_CACHE_SHIFT; offset = pos & ~PAGE_CACHE_MASK; block = (u_long)(pos >> sbp->s_blocksize_bits) % pblocks; for (; page < npages; page++, block = 0) { caddr_t kaddr; struct page *pp; pp = vxfs_get_page(ip->i_mapping, page); if (IS_ERR(pp)) continue; kaddr = (caddr_t)page_address(pp); for (; block <= nblocks && block <= pblocks; block++) { caddr_t baddr, limit; struct vxfs_dirblk *dbp; struct vxfs_direct *de; baddr = kaddr + (block * bsize); limit = baddr + bsize - VXFS_DIRLEN(1); dbp = (struct vxfs_dirblk *)baddr; de = (struct vxfs_direct *) (offset ? (kaddr + offset) : (baddr + VXFS_DIRBLKOV(dbp))); for (; (caddr_t)de <= limit; de = vxfs_next_entry(de)) { int over; if (!de->d_reclen) break; if (!de->d_ino) continue; offset = (caddr_t)de - kaddr; over = filler(retp, de->d_name, de->d_namelen, ((page << PAGE_CACHE_SHIFT) | offset) + 2, de->d_ino, DT_UNKNOWN); if (over) { vxfs_put_page(pp); goto done; } } offset = 0; } vxfs_put_page(pp); offset = 0; } done: fp->f_pos = ((page << PAGE_CACHE_SHIFT) | offset) + 2; out: return 0; }
/** * vxfs_readdir - read a directory * @fp: the directory to read * @retp: return buffer * @filler: filldir callback * * Description: * vxfs_readdir fills @retp with directory entries from @fp * using the VFS supplied callback @filler. * * Returns: * Zero. */ static int vxfs_readdir(struct file *fp, struct dir_context *ctx) { struct inode *ip = file_inode(fp); struct super_block *sbp = ip->i_sb; u_long bsize = sbp->s_blocksize; u_long page, npages, block, pblocks, nblocks, offset; loff_t pos; if (ctx->pos == 0) { if (!dir_emit_dot(fp, ctx)) return 0; ctx->pos = 1; } if (ctx->pos == 1) { if (!dir_emit(ctx, "..", 2, VXFS_INO(ip)->vii_dotdot, DT_DIR)) return 0; ctx->pos = 2; } pos = ctx->pos - 2; if (pos > VXFS_DIRROUND(ip->i_size)) return 0; npages = dir_pages(ip); nblocks = dir_blocks(ip); pblocks = VXFS_BLOCK_PER_PAGE(sbp); page = pos >> PAGE_CACHE_SHIFT; offset = pos & ~PAGE_CACHE_MASK; block = (u_long)(pos >> sbp->s_blocksize_bits) % pblocks; for (; page < npages; page++, block = 0) { char *kaddr; struct page *pp; pp = vxfs_get_page(ip->i_mapping, page); if (IS_ERR(pp)) continue; kaddr = (char *)page_address(pp); for (; block <= nblocks && block <= pblocks; block++) { char *baddr, *limit; struct vxfs_dirblk *dbp; struct vxfs_direct *de; baddr = kaddr + (block * bsize); limit = baddr + bsize - VXFS_DIRLEN(1); dbp = (struct vxfs_dirblk *)baddr; de = (struct vxfs_direct *) (offset ? (kaddr + offset) : (baddr + VXFS_DIRBLKOV(dbp))); for (; (char *)de <= limit; de = vxfs_next_entry(de)) { if (!de->d_reclen) break; if (!de->d_ino) continue; offset = (char *)de - kaddr; ctx->pos = ((page << PAGE_CACHE_SHIFT) | offset) + 2; if (!dir_emit(ctx, de->d_name, de->d_namelen, de->d_ino, DT_UNKNOWN)) { vxfs_put_page(pp); return 0; } } offset = 0; } vxfs_put_page(pp); offset = 0; } ctx->pos = ((page << PAGE_CACHE_SHIFT) | offset) + 2; return 0; }