vxfs_lookup.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2000-2001 Christoph Hellwig.
   4  * Copyright (c) 2016 Krzysztof Blaszkowski
   5  */
   6
   7 /*
   8  * Veritas filesystem driver - lookup and other directory related code.
   9  */
  10 #include <linux/fs.h>
  11 #include <linux/time.h>
  12 #include <linux/mm.h>
  13 #include <linux/highmem.h>
  14 #include <linux/kernel.h>
  15 #include <linux/pagemap.h>
  16
  17 #include "vxfs.h"
  18 #include "vxfs_dir.h"
  19 #include "vxfs_inode.h"
  20 #include "vxfs_extern.h"
  21
  22 /*
  23  * Number of VxFS blocks per page.
  24  */
  25 #define VXFS_BLOCK_PER_PAGE(sbp)  ((PAGE_SIZE / (sbp)->s_blocksize))
  26
  27
  28 static struct dentry *  vxfs_lookup(struct inode *, struct dentry *, unsigned int);
  29 static int              vxfs_readdir(struct file *, struct dir_context *);
  30
  31 const struct inode_operations vxfs_dir_inode_ops = {
  32         .lookup =               vxfs_lookup,
  33 };
  34
  35 const struct file_operations vxfs_dir_operations = {
  36         .llseek =               generic_file_llseek,
  37         .read =                 generic_read_dir,
  38         .iterate_shared =       vxfs_readdir,
  39 };
  40
  41
  42 /**
  43  * vxfs_find_entry - find a mathing directory entry for a dentry
  44  * @ip:         directory inode
  45  * @dp:         dentry for which we want to find a direct
  46  * @ppp:        gets filled with the page the return value sits in
  47  *
  48  * Description:
  49  *   vxfs_find_entry finds a &struct vxfs_direct for the VFS directory
  50  *   cache entry @dp.  @ppp will be filled with the page the return
  51  *   value resides in.
  52  *
  53  * Returns:
  54  *   The wanted direct on success, else a NULL pointer.
  55  */
  56 static struct vxfs_direct *
  57 vxfs_find_entry(struct inode *ip, struct dentry *dp, struct page **ppp)
  58 {
  59         u_long bsize = ip->i_sb->s_blocksize;
  60         const char *name = dp->d_name.name;
  61         int namelen = dp->d_name.len;
  62         loff_t limit = VXFS_DIRROUND(ip->i_size);
  63         struct vxfs_direct *de_exit = NULL;
  64         loff_t pos = 0;
  65         struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
  66
  67         while (pos < limit) {
  68                 struct page *pp;
  69                 char *kaddr;
  70                 int pg_ofs = pos & ~PAGE_MASK;
  71
  72                 pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
  73                 if (IS_ERR(pp))
  74                         return NULL;
  75                 kaddr = (char *)page_address(pp);
  76
  77                 while (pg_ofs < PAGE_SIZE && pos < limit) {
  78                         struct vxfs_direct *de;
  79
  80                         if ((pos & (bsize - 1)) < 4) {
  81                                 struct vxfs_dirblk *dbp =
  82                                         (struct vxfs_dirblk *)
  83                                          (kaddr + (pos & ~PAGE_MASK));
  84                                 int overhead = VXFS_DIRBLKOV(sbi, dbp);
  85
  86                                 pos += overhead;
  87                                 pg_ofs += overhead;
  88                         }
  89                         de = (struct vxfs_direct *)(kaddr + pg_ofs);
  90
  91                         if (!de->d_reclen) {
  92                                 pos += bsize - 1;
  93                                 pos &= ~(bsize - 1);
  94                                 break;
  95                         }
  96
  97                         pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
  98                         pos += fs16_to_cpu(sbi, de->d_reclen);
  99                         if (!de->d_ino)
 100                                 continue;
 101
 102                         if (namelen != fs16_to_cpu(sbi, de->d_namelen))
 103                                 continue;
 104                         if (!memcmp(name, de->d_name, namelen)) {
 105                                 *ppp = pp;
 106                                 de_exit = de;
 107                                 break;
 108                         }
 109                 }
 110                 if (!de_exit)
 111                         vxfs_put_page(pp);
 112                 else
 113                         break;
 114         }
 115
 116         return de_exit;
 117 }
 118
 119 /**
 120  * vxfs_inode_by_name - find inode number for dentry
 121  * @dip:        directory to search in
 122  * @dp:         dentry we search for
 123  *
 124  * Description:
 125  *   vxfs_inode_by_name finds out the inode number of
 126  *   the path component described by @dp in @dip.
 127  *
 128  * Returns:
 129  *   The wanted inode number on success, else Zero.
 130  */
 131 static ino_t
 132 vxfs_inode_by_name(struct inode *dip, struct dentry *dp)
 133 {
 134         struct vxfs_direct              *de;
 135         struct page                     *pp;
 136         ino_t                           ino = 0;
 137
 138         de = vxfs_find_entry(dip, dp, &pp);
 139         if (de) {
 140                 ino = fs32_to_cpu(VXFS_SBI(dip->i_sb), de->d_ino);
 141                 kunmap(pp);
 142                 put_page(pp);
 143         }
 144
 145         return (ino);
 146 }
 147
 148 /**
 149  * vxfs_lookup - lookup pathname component
 150  * @dip:        dir in which we lookup
 151  * @dp:         dentry we lookup
 152  * @flags:      lookup flags
 153  *
 154  * Description:
 155  *   vxfs_lookup tries to lookup the pathname component described
 156  *   by @dp in @dip.
 157  *
 158  * Returns:
 159  *   A NULL-pointer on success, else a negative error code encoded
 160  *   in the return pointer.
 161  */
 162 static struct dentry *
 163 vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags)
 164 {
 165         struct inode            *ip = NULL;
 166         ino_t                   ino;
 167
 168         if (dp->d_name.len > VXFS_NAMELEN)
 169                 return ERR_PTR(-ENAMETOOLONG);
 170
 171         ino = vxfs_inode_by_name(dip, dp);
 172         if (ino)
 173                 ip = vxfs_iget(dip->i_sb, ino);
 174         return d_splice_alias(ip, dp);
 175 }
 176
 177 /**
 178  * vxfs_readdir - read a directory
 179  * @fp:         the directory to read
 180  * @retp:       return buffer
 181  * @filler:     filldir callback
 182  *
 183  * Description:
 184  *   vxfs_readdir fills @retp with directory entries from @fp
 185  *   using the VFS supplied callback @filler.
 186  *
 187  * Returns:
 188  *   Zero.
 189  */
 190 static int
 191 vxfs_readdir(struct file *fp, struct dir_context *ctx)
 192 {
 193         struct inode            *ip = file_inode(fp);
 194         struct super_block      *sbp = ip->i_sb;
 195         u_long                  bsize = sbp->s_blocksize;
 196         loff_t                  pos, limit;
 197         struct vxfs_sb_info     *sbi = VXFS_SBI(sbp);
 198
 199         if (ctx->pos == 0) {
 200                 if (!dir_emit_dot(fp, ctx))
 201                         goto out;
 202                 ctx->pos++;
 203         }
 204         if (ctx->pos == 1) {
 205                 if (!dir_emit(ctx, "..", 2, VXFS_INO(ip)->vii_dotdot, DT_DIR))
 206                         goto out;
 207                 ctx->pos++;
 208         }
 209
 210         limit = VXFS_DIRROUND(ip->i_size);
 211         if (ctx->pos > limit)
 212                 goto out;
 213
 214         pos = ctx->pos & ~3L;
 215
 216         while (pos < limit) {
 217                 struct page *pp;
 218                 char *kaddr;
 219                 int pg_ofs = pos & ~PAGE_MASK;
 220                 int rc = 0;
 221
 222                 pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
 223                 if (IS_ERR(pp))
 224                         return -ENOMEM;
 225
 226                 kaddr = (char *)page_address(pp);
 227
 228                 while (pg_ofs < PAGE_SIZE && pos < limit) {
 229                         struct vxfs_direct *de;
 230
 231                         if ((pos & (bsize - 1)) < 4) {
 232                                 struct vxfs_dirblk *dbp =
 233                                         (struct vxfs_dirblk *)
 234                                          (kaddr + (pos & ~PAGE_MASK));
 235                                 int overhead = VXFS_DIRBLKOV(sbi, dbp);
 236
 237                                 pos += overhead;
 238                                 pg_ofs += overhead;
 239                         }
 240                         de = (struct vxfs_direct *)(kaddr + pg_ofs);
 241
 242                         if (!de->d_reclen) {
 243                                 pos += bsize - 1;
 244                                 pos &= ~(bsize - 1);
 245                                 break;
 246                         }
 247
 248                         pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
 249                         pos += fs16_to_cpu(sbi, de->d_reclen);
 250                         if (!de->d_ino)
 251                                 continue;
 252
 253                         rc = dir_emit(ctx, de->d_name,
 254                                         fs16_to_cpu(sbi, de->d_namelen),
 255                                         fs32_to_cpu(sbi, de->d_ino),
 256                                         DT_UNKNOWN);
 257                         if (!rc) {
 258                                 /* the dir entry was not read, fix pos. */
 259                                 pos -= fs16_to_cpu(sbi, de->d_reclen);
 260                                 break;
 261                         }
 262                 }
 263                 vxfs_put_page(pp);
 264                 if (!rc)
 265                         break;
 266         }
 267
 268         ctx->pos = pos | 2;
 269
 270 out:
 271         return 0;
 272 }