From 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Sat, 16 Apr 2005 15:20:36 -0700 Subject: Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip! --- fs/freevxfs/vxfs_lookup.c | 328 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 328 insertions(+) create mode 100644 fs/freevxfs/vxfs_lookup.c (limited to 'fs/freevxfs/vxfs_lookup.c') diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c new file mode 100644 index 00000000000..506ae251d2c --- /dev/null +++ b/fs/freevxfs/vxfs_lookup.c @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2000-2001 Christoph Hellwig. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License ("GPL"). + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Veritas filesystem driver - lookup and other directory related code. + */ +#include +#include +#include +#include +#include +#include +#include + +#include "vxfs.h" +#include "vxfs_dir.h" +#include "vxfs_inode.h" +#include "vxfs_extern.h" + +/* + * Number of VxFS blocks per page. + */ +#define VXFS_BLOCK_PER_PAGE(sbp) ((PAGE_CACHE_SIZE / (sbp)->s_blocksize)) + + +static struct dentry * vxfs_lookup(struct inode *, struct dentry *, struct nameidata *); +static int vxfs_readdir(struct file *, void *, filldir_t); + +struct inode_operations vxfs_dir_inode_ops = { + .lookup = vxfs_lookup, +}; + +struct file_operations vxfs_dir_operations = { + .readdir = vxfs_readdir, +}; + + +static __inline__ u_long +dir_pages(struct inode *inode) +{ + return (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; +} + +static __inline__ u_long +dir_blocks(struct inode *ip) +{ + u_long bsize = ip->i_sb->s_blocksize; + return (ip->i_size + bsize - 1) & ~(bsize - 1); +} + +/* + * NOTE! unlike strncmp, vxfs_match returns 1 for success, 0 for failure. + * + * len <= VXFS_NAMELEN and de != NULL are guaranteed by caller. + */ +static __inline__ int +vxfs_match(int len, const char * const name, struct vxfs_direct *de) +{ + if (len != de->d_namelen) + return 0; + if (!de->d_ino) + return 0; + return !memcmp(name, de->d_name, len); +} + +static __inline__ struct vxfs_direct * +vxfs_next_entry(struct vxfs_direct *de) +{ + return ((struct vxfs_direct *)((char*)de + de->d_reclen)); +} + +/** + * 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; +} + +/** + * vxfs_inode_by_name - find inode number for dentry + * @dip: directory to search in + * @dp: dentry we seach for + * + * Description: + * vxfs_inode_by_name finds out the inode number of + * the path component described by @dp in @dip. + * + * Returns: + * The wanted inode number on success, else Zero. + */ +static ino_t +vxfs_inode_by_name(struct inode *dip, struct dentry *dp) +{ + struct vxfs_direct *de; + struct page *pp; + ino_t ino = 0; + + de = vxfs_find_entry(dip, dp, &pp); + if (de) { + ino = de->d_ino; + kunmap(pp); + page_cache_release(pp); + } + + return (ino); +} + +/** + * vxfs_lookup - lookup pathname component + * @dip: dir in which we lookup + * @dp: dentry we lookup + * @nd: lookup nameidata + * + * Description: + * vxfs_lookup tries to lookup the pathname component described + * by @dp in @dip. + * + * Returns: + * A NULL-pointer on success, else an negative error code encoded + * in the return pointer. + */ +static struct dentry * +vxfs_lookup(struct inode *dip, struct dentry *dp, struct nameidata *nd) +{ + struct inode *ip = NULL; + ino_t ino; + + if (dp->d_name.len > VXFS_NAMELEN) + return ERR_PTR(-ENAMETOOLONG); + + lock_kernel(); + ino = vxfs_inode_by_name(dip, dp); + if (ino) { + ip = iget(dip->i_sb, ino); + if (!ip) { + unlock_kernel(); + return ERR_PTR(-EACCES); + } + } + unlock_kernel(); + d_add(dp, ip); + return NULL; +} + +/** + * 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_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)) { + unlock_kernel(); + 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: + unlock_kernel(); + return 0; +} -- cgit v1.2.3-70-g09d2