1 /*
2  * Copyright (c) 2000-2001 Christoph Hellwig.
3  * Copyright (c) 2016 Krzysztof Blaszkowski
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions, and the following disclaimer,
11  *    without modification.
12  * 2. The name of the author may not be used to endorse or promote products
13  *    derived from this software without specific prior written permission.
14  *
15  * Alternatively, this software may be distributed under the terms of the
16  * GNU General Public License ("GPL").
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 /*
32  * Veritas filesystem driver - lookup and other directory related code.
33  */
34 #include <linux/fs.h>
35 #include <linux/time.h>
36 #include <linux/mm.h>
37 #include <linux/highmem.h>
38 #include <linux/kernel.h>
39 #include <linux/pagemap.h>
40 
41 #include "vxfs.h"
42 #include "vxfs_dir.h"
43 #include "vxfs_inode.h"
44 #include "vxfs_extern.h"
45 
46 /*
47  * Number of VxFS blocks per page.
48  */
49 #define VXFS_BLOCK_PER_PAGE(sbp)  ((PAGE_SIZE / (sbp)->s_blocksize))
50 
51 
52 static struct dentry *	vxfs_lookup(struct inode *, struct dentry *, unsigned int);
53 static int		vxfs_readdir(struct file *, struct dir_context *);
54 
55 const struct inode_operations vxfs_dir_inode_ops = {
56 	.lookup =		vxfs_lookup,
57 };
58 
59 const struct file_operations vxfs_dir_operations = {
60 	.llseek =		generic_file_llseek,
61 	.read =			generic_read_dir,
62 	.iterate_shared =	vxfs_readdir,
63 };
64 
65 
66 /**
67  * vxfs_find_entry - find a mathing directory entry for a dentry
68  * @ip:		directory inode
69  * @dp:		dentry for which we want to find a direct
70  * @ppp:	gets filled with the page the return value sits in
71  *
72  * Description:
73  *   vxfs_find_entry finds a &struct vxfs_direct for the VFS directory
74  *   cache entry @dp.  @ppp will be filled with the page the return
75  *   value resides in.
76  *
77  * Returns:
78  *   The wanted direct on success, else a NULL pointer.
79  */
80 static struct vxfs_direct *
vxfs_find_entry(struct inode * ip,struct dentry * dp,struct page ** ppp)81 vxfs_find_entry(struct inode *ip, struct dentry *dp, struct page **ppp)
82 {
83 	u_long bsize = ip->i_sb->s_blocksize;
84 	const char *name = dp->d_name.name;
85 	int namelen = dp->d_name.len;
86 	loff_t limit = VXFS_DIRROUND(ip->i_size);
87 	struct vxfs_direct *de_exit = NULL;
88 	loff_t pos = 0;
89 	struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
90 
91 	while (pos < limit) {
92 		struct page *pp;
93 		char *kaddr;
94 		int pg_ofs = pos & ~PAGE_MASK;
95 
96 		pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
97 		if (IS_ERR(pp))
98 			return NULL;
99 		kaddr = (char *)page_address(pp);
100 
101 		while (pg_ofs < PAGE_SIZE && pos < limit) {
102 			struct vxfs_direct *de;
103 
104 			if ((pos & (bsize - 1)) < 4) {
105 				struct vxfs_dirblk *dbp =
106 					(struct vxfs_dirblk *)
107 					 (kaddr + (pos & ~PAGE_MASK));
108 				int overhead = VXFS_DIRBLKOV(sbi, dbp);
109 
110 				pos += overhead;
111 				pg_ofs += overhead;
112 			}
113 			de = (struct vxfs_direct *)(kaddr + pg_ofs);
114 
115 			if (!de->d_reclen) {
116 				pos += bsize - 1;
117 				pos &= ~(bsize - 1);
118 				break;
119 			}
120 
121 			pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
122 			pos += fs16_to_cpu(sbi, de->d_reclen);
123 			if (!de->d_ino)
124 				continue;
125 
126 			if (namelen != fs16_to_cpu(sbi, de->d_namelen))
127 				continue;
128 			if (!memcmp(name, de->d_name, namelen)) {
129 				*ppp = pp;
130 				de_exit = de;
131 				break;
132 			}
133 		}
134 		if (!de_exit)
135 			vxfs_put_page(pp);
136 		else
137 			break;
138 	}
139 
140 	return de_exit;
141 }
142 
143 /**
144  * vxfs_inode_by_name - find inode number for dentry
145  * @dip:	directory to search in
146  * @dp:		dentry we search for
147  *
148  * Description:
149  *   vxfs_inode_by_name finds out the inode number of
150  *   the path component described by @dp in @dip.
151  *
152  * Returns:
153  *   The wanted inode number on success, else Zero.
154  */
155 static ino_t
vxfs_inode_by_name(struct inode * dip,struct dentry * dp)156 vxfs_inode_by_name(struct inode *dip, struct dentry *dp)
157 {
158 	struct vxfs_direct		*de;
159 	struct page			*pp;
160 	ino_t				ino = 0;
161 
162 	de = vxfs_find_entry(dip, dp, &pp);
163 	if (de) {
164 		ino = fs32_to_cpu(VXFS_SBI(dip->i_sb), de->d_ino);
165 		kunmap(pp);
166 		put_page(pp);
167 	}
168 
169 	return (ino);
170 }
171 
172 /**
173  * vxfs_lookup - lookup pathname component
174  * @dip:	dir in which we lookup
175  * @dp:		dentry we lookup
176  * @flags:	lookup flags
177  *
178  * Description:
179  *   vxfs_lookup tries to lookup the pathname component described
180  *   by @dp in @dip.
181  *
182  * Returns:
183  *   A NULL-pointer on success, else a negative error code encoded
184  *   in the return pointer.
185  */
186 static struct dentry *
vxfs_lookup(struct inode * dip,struct dentry * dp,unsigned int flags)187 vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags)
188 {
189 	struct inode		*ip = NULL;
190 	ino_t			ino;
191 
192 	if (dp->d_name.len > VXFS_NAMELEN)
193 		return ERR_PTR(-ENAMETOOLONG);
194 
195 	ino = vxfs_inode_by_name(dip, dp);
196 	if (ino)
197 		ip = vxfs_iget(dip->i_sb, ino);
198 	return d_splice_alias(ip, dp);
199 }
200 
201 /**
202  * vxfs_readdir - read a directory
203  * @fp:		the directory to read
204  * @retp:	return buffer
205  * @filler:	filldir callback
206  *
207  * Description:
208  *   vxfs_readdir fills @retp with directory entries from @fp
209  *   using the VFS supplied callback @filler.
210  *
211  * Returns:
212  *   Zero.
213  */
214 static int
vxfs_readdir(struct file * fp,struct dir_context * ctx)215 vxfs_readdir(struct file *fp, struct dir_context *ctx)
216 {
217 	struct inode		*ip = file_inode(fp);
218 	struct super_block	*sbp = ip->i_sb;
219 	u_long			bsize = sbp->s_blocksize;
220 	loff_t			pos, limit;
221 	struct vxfs_sb_info	*sbi = VXFS_SBI(sbp);
222 
223 	if (ctx->pos == 0) {
224 		if (!dir_emit_dot(fp, ctx))
225 			goto out;
226 		ctx->pos++;
227 	}
228 	if (ctx->pos == 1) {
229 		if (!dir_emit(ctx, "..", 2, VXFS_INO(ip)->vii_dotdot, DT_DIR))
230 			goto out;
231 		ctx->pos++;
232 	}
233 
234 	limit = VXFS_DIRROUND(ip->i_size);
235 	if (ctx->pos > limit)
236 		goto out;
237 
238 	pos = ctx->pos & ~3L;
239 
240 	while (pos < limit) {
241 		struct page *pp;
242 		char *kaddr;
243 		int pg_ofs = pos & ~PAGE_MASK;
244 		int rc = 0;
245 
246 		pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
247 		if (IS_ERR(pp))
248 			return -ENOMEM;
249 
250 		kaddr = (char *)page_address(pp);
251 
252 		while (pg_ofs < PAGE_SIZE && pos < limit) {
253 			struct vxfs_direct *de;
254 
255 			if ((pos & (bsize - 1)) < 4) {
256 				struct vxfs_dirblk *dbp =
257 					(struct vxfs_dirblk *)
258 					 (kaddr + (pos & ~PAGE_MASK));
259 				int overhead = VXFS_DIRBLKOV(sbi, dbp);
260 
261 				pos += overhead;
262 				pg_ofs += overhead;
263 			}
264 			de = (struct vxfs_direct *)(kaddr + pg_ofs);
265 
266 			if (!de->d_reclen) {
267 				pos += bsize - 1;
268 				pos &= ~(bsize - 1);
269 				break;
270 			}
271 
272 			pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
273 			pos += fs16_to_cpu(sbi, de->d_reclen);
274 			if (!de->d_ino)
275 				continue;
276 
277 			rc = dir_emit(ctx, de->d_name,
278 					fs16_to_cpu(sbi, de->d_namelen),
279 					fs32_to_cpu(sbi, de->d_ino),
280 					DT_UNKNOWN);
281 			if (!rc) {
282 				/* the dir entry was not read, fix pos. */
283 				pos -= fs16_to_cpu(sbi, de->d_reclen);
284 				break;
285 			}
286 		}
287 		vxfs_put_page(pp);
288 		if (!rc)
289 			break;
290 	}
291 
292 	ctx->pos = pos | 2;
293 
294 out:
295 	return 0;
296 }
297