f04ba2ed1e1aa4ce5240021fba76a963f2b646cd
[releases.git] / 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 }