xref: /linux/fs/adfs/dir.c (revision 0be3ff0c) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/fs/adfs/dir.c
4  *
5  *  Copyright (C) 1999-2000 Russell King
6  *
7  *  Common directory handling for ADFS
8  */
9 #include <linux/slab.h>
10 #include "adfs.h"
11 
12 /*
13  * For future.  This should probably be per-directory.
14  */
15 static DECLARE_RWSEM(adfs_dir_rwsem);
16 
17 int adfs_dir_copyfrom(void *dst, struct adfs_dir *dir, unsigned int offset,
18 		      size_t len)
19 {
20 	struct super_block *sb = dir->sb;
21 	unsigned int index, remain;
22 
23 	index = offset >> sb->s_blocksize_bits;
24 	offset &= sb->s_blocksize - 1;
25 	remain = sb->s_blocksize - offset;
26 	if (index + (remain < len) >= dir->nr_buffers)
27 		return -EINVAL;
28 
29 	if (remain < len) {
30 		memcpy(dst, dir->bhs[index]->b_data + offset, remain);
31 		dst += remain;
32 		len -= remain;
33 		index += 1;
34 		offset = 0;
35 	}
36 
37 	memcpy(dst, dir->bhs[index]->b_data + offset, len);
38 
39 	return 0;
40 }
41 
42 int adfs_dir_copyto(struct adfs_dir *dir, unsigned int offset, const void *src,
43 		    size_t len)
44 {
45 	struct super_block *sb = dir->sb;
46 	unsigned int index, remain;
47 
48 	index = offset >> sb->s_blocksize_bits;
49 	offset &= sb->s_blocksize - 1;
50 	remain = sb->s_blocksize - offset;
51 	if (index + (remain < len) >= dir->nr_buffers)
52 		return -EINVAL;
53 
54 	if (remain < len) {
55 		memcpy(dir->bhs[index]->b_data + offset, src, remain);
56 		src += remain;
57 		len -= remain;
58 		index += 1;
59 		offset = 0;
60 	}
61 
62 	memcpy(dir->bhs[index]->b_data + offset, src, len);
63 
64 	return 0;
65 }
66 
67 static void __adfs_dir_cleanup(struct adfs_dir *dir)
68 {
69 	dir->nr_buffers = 0;
70 
71 	if (dir->bhs != dir->bh)
72 		kfree(dir->bhs);
73 	dir->bhs = NULL;
74 	dir->sb = NULL;
75 }
76 
77 void adfs_dir_relse(struct adfs_dir *dir)
78 {
79 	unsigned int i;
80 
81 	for (i = 0; i < dir->nr_buffers; i++)
82 		brelse(dir->bhs[i]);
83 
84 	__adfs_dir_cleanup(dir);
85 }
86 
87 static void adfs_dir_forget(struct adfs_dir *dir)
88 {
89 	unsigned int i;
90 
91 	for (i = 0; i < dir->nr_buffers; i++)
92 		bforget(dir->bhs[i]);
93 
94 	__adfs_dir_cleanup(dir);
95 }
96 
97 int adfs_dir_read_buffers(struct super_block *sb, u32 indaddr,
98 			  unsigned int size, struct adfs_dir *dir)
99 {
100 	struct buffer_head **bhs;
101 	unsigned int i, num;
102 	int block;
103 
104 	num = ALIGN(size, sb->s_blocksize) >> sb->s_blocksize_bits;
105 	if (num > ARRAY_SIZE(dir->bh)) {
106 		/* We only allow one extension */
107 		if (dir->bhs != dir->bh)
108 			return -EINVAL;
109 
110 		bhs = kcalloc(num, sizeof(*bhs), GFP_KERNEL);
111 		if (!bhs)
112 			return -ENOMEM;
113 
114 		if (dir->nr_buffers)
115 			memcpy(bhs, dir->bhs, dir->nr_buffers * sizeof(*bhs));
116 
117 		dir->bhs = bhs;
118 	}
119 
120 	for (i = dir->nr_buffers; i < num; i++) {
121 		block = __adfs_block_map(sb, indaddr, i);
122 		if (!block) {
123 			adfs_error(sb, "dir %06x has a hole at offset %u",
124 				   indaddr, i);
125 			goto error;
126 		}
127 
128 		dir->bhs[i] = sb_bread(sb, block);
129 		if (!dir->bhs[i]) {
130 			adfs_error(sb,
131 				   "dir %06x failed read at offset %u, mapped block 0x%08x",
132 				   indaddr, i, block);
133 			goto error;
134 		}
135 
136 		dir->nr_buffers++;
137 	}
138 	return 0;
139 
140 error:
141 	adfs_dir_relse(dir);
142 
143 	return -EIO;
144 }
145 
146 static int adfs_dir_read(struct super_block *sb, u32 indaddr,
147 			 unsigned int size, struct adfs_dir *dir)
148 {
149 	dir->sb = sb;
150 	dir->bhs = dir->bh;
151 	dir->nr_buffers = 0;
152 
153 	return ADFS_SB(sb)->s_dir->read(sb, indaddr, size, dir);
154 }
155 
156 static int adfs_dir_read_inode(struct super_block *sb, struct inode *inode,
157 			       struct adfs_dir *dir)
158 {
159 	int ret;
160 
161 	ret = adfs_dir_read(sb, ADFS_I(inode)->indaddr, inode->i_size, dir);
162 	if (ret)
163 		return ret;
164 
165 	if (ADFS_I(inode)->parent_id != dir->parent_id) {
166 		adfs_error(sb,
167 			   "parent directory id changed under me! (%06x but got %06x)\n",
168 			   ADFS_I(inode)->parent_id, dir->parent_id);
169 		adfs_dir_relse(dir);
170 		ret = -EIO;
171 	}
172 
173 	return ret;
174 }
175 
176 static void adfs_dir_mark_dirty(struct adfs_dir *dir)
177 {
178 	unsigned int i;
179 
180 	/* Mark the buffers dirty */
181 	for (i = 0; i < dir->nr_buffers; i++)
182 		mark_buffer_dirty(dir->bhs[i]);
183 }
184 
185 static int adfs_dir_sync(struct adfs_dir *dir)
186 {
187 	int err = 0;
188 	int i;
189 
190 	for (i = dir->nr_buffers - 1; i >= 0; i--) {
191 		struct buffer_head *bh = dir->bhs[i];
192 		sync_dirty_buffer(bh);
193 		if (buffer_req(bh) && !buffer_uptodate(bh))
194 			err = -EIO;
195 	}
196 
197 	return err;
198 }
199 
200 void adfs_object_fixup(struct adfs_dir *dir, struct object_info *obj)
201 {
202 	unsigned int dots, i;
203 
204 	/*
205 	 * RISC OS allows the use of '/' in directory entry names, so we need
206 	 * to fix these up.  '/' is typically used for FAT compatibility to
207 	 * represent '.', so do the same conversion here.  In any case, '.'
208 	 * will never be in a RISC OS name since it is used as the pathname
209 	 * separator.  Handle the case where we may generate a '.' or '..'
210 	 * name, replacing the first character with '^' (the RISC OS "parent
211 	 * directory" character.)
212 	 */
213 	for (i = dots = 0; i < obj->name_len; i++)
214 		if (obj->name[i] == '/') {
215 			obj->name[i] = '.';
216 			dots++;
217 		}
218 
219 	if (obj->name_len <= 2 && dots == obj->name_len)
220 		obj->name[0] = '^';
221 
222 	/*
223 	 * If the object is a file, and the user requested the ,xyz hex
224 	 * filetype suffix to the name, check the filetype and append.
225 	 */
226 	if (!(obj->attr & ADFS_NDA_DIRECTORY) && ADFS_SB(dir->sb)->s_ftsuffix) {
227 		u16 filetype = adfs_filetype(obj->loadaddr);
228 
229 		if (filetype != ADFS_FILETYPE_NONE) {
230 			obj->name[obj->name_len++] = ',';
231 			obj->name[obj->name_len++] = hex_asc_lo(filetype >> 8);
232 			obj->name[obj->name_len++] = hex_asc_lo(filetype >> 4);
233 			obj->name[obj->name_len++] = hex_asc_lo(filetype >> 0);
234 		}
235 	}
236 }
237 
238 static int adfs_iterate(struct file *file, struct dir_context *ctx)
239 {
240 	struct inode *inode = file_inode(file);
241 	struct super_block *sb = inode->i_sb;
242 	const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
243 	struct adfs_dir dir;
244 	int ret;
245 
246 	down_read(&adfs_dir_rwsem);
247 	ret = adfs_dir_read_inode(sb, inode, &dir);
248 	if (ret)
249 		goto unlock;
250 
251 	if (ctx->pos == 0) {
252 		if (!dir_emit_dot(file, ctx))
253 			goto unlock_relse;
254 		ctx->pos = 1;
255 	}
256 	if (ctx->pos == 1) {
257 		if (!dir_emit(ctx, "..", 2, dir.parent_id, DT_DIR))
258 			goto unlock_relse;
259 		ctx->pos = 2;
260 	}
261 
262 	ret = ops->iterate(&dir, ctx);
263 
264 unlock_relse:
265 	up_read(&adfs_dir_rwsem);
266 	adfs_dir_relse(&dir);
267 	return ret;
268 
269 unlock:
270 	up_read(&adfs_dir_rwsem);
271 	return ret;
272 }
273 
274 int
275 adfs_dir_update(struct super_block *sb, struct object_info *obj, int wait)
276 {
277 	const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
278 	struct adfs_dir dir;
279 	int ret;
280 
281 	if (!IS_ENABLED(CONFIG_ADFS_FS_RW))
282 		return -EINVAL;
283 
284 	if (!ops->update)
285 		return -EINVAL;
286 
287 	down_write(&adfs_dir_rwsem);
288 	ret = adfs_dir_read(sb, obj->parent_id, 0, &dir);
289 	if (ret)
290 		goto unlock;
291 
292 	ret = ops->update(&dir, obj);
293 	if (ret)
294 		goto forget;
295 
296 	ret = ops->commit(&dir);
297 	if (ret)
298 		goto forget;
299 	up_write(&adfs_dir_rwsem);
300 
301 	adfs_dir_mark_dirty(&dir);
302 
303 	if (wait)
304 		ret = adfs_dir_sync(&dir);
305 
306 	adfs_dir_relse(&dir);
307 	return ret;
308 
309 	/*
310 	 * If the updated failed because the entry wasn't found, we can
311 	 * just release the buffers. If it was any other error, forget
312 	 * the dirtied buffers so they aren't written back to the media.
313 	 */
314 forget:
315 	if (ret == -ENOENT)
316 		adfs_dir_relse(&dir);
317 	else
318 		adfs_dir_forget(&dir);
319 unlock:
320 	up_write(&adfs_dir_rwsem);
321 
322 	return ret;
323 }
324 
325 static unsigned char adfs_tolower(unsigned char c)
326 {
327 	if (c >= 'A' && c <= 'Z')
328 		c += 'a' - 'A';
329 	return c;
330 }
331 
332 static int __adfs_compare(const unsigned char *qstr, u32 qlen,
333 			  const char *str, u32 len)
334 {
335 	u32 i;
336 
337 	if (qlen != len)
338 		return 1;
339 
340 	for (i = 0; i < qlen; i++)
341 		if (adfs_tolower(qstr[i]) != adfs_tolower(str[i]))
342 			return 1;
343 
344 	return 0;
345 }
346 
347 static int adfs_dir_lookup_byname(struct inode *inode, const struct qstr *qstr,
348 				  struct object_info *obj)
349 {
350 	struct super_block *sb = inode->i_sb;
351 	const struct adfs_dir_ops *ops = ADFS_SB(sb)->s_dir;
352 	const unsigned char *name;
353 	struct adfs_dir dir;
354 	u32 name_len;
355 	int ret;
356 
357 	down_read(&adfs_dir_rwsem);
358 	ret = adfs_dir_read_inode(sb, inode, &dir);
359 	if (ret)
360 		goto unlock;
361 
362 	ret = ops->setpos(&dir, 0);
363 	if (ret)
364 		goto unlock_relse;
365 
366 	ret = -ENOENT;
367 	name = qstr->name;
368 	name_len = qstr->len;
369 	while (ops->getnext(&dir, obj) == 0) {
370 		if (!__adfs_compare(name, name_len, obj->name, obj->name_len)) {
371 			ret = 0;
372 			break;
373 		}
374 	}
375 	obj->parent_id = ADFS_I(inode)->indaddr;
376 
377 unlock_relse:
378 	up_read(&adfs_dir_rwsem);
379 	adfs_dir_relse(&dir);
380 	return ret;
381 
382 unlock:
383 	up_read(&adfs_dir_rwsem);
384 	return ret;
385 }
386 
387 const struct file_operations adfs_dir_operations = {
388 	.read		= generic_read_dir,
389 	.llseek		= generic_file_llseek,
390 	.iterate_shared	= adfs_iterate,
391 	.fsync		= generic_file_fsync,
392 };
393 
394 static int
395 adfs_hash(const struct dentry *parent, struct qstr *qstr)
396 {
397 	const unsigned char *name;
398 	unsigned long hash;
399 	u32 len;
400 
401 	if (qstr->len > ADFS_SB(parent->d_sb)->s_namelen)
402 		return -ENAMETOOLONG;
403 
404 	len = qstr->len;
405 	name = qstr->name;
406 	hash = init_name_hash(parent);
407 	while (len--)
408 		hash = partial_name_hash(adfs_tolower(*name++), hash);
409 	qstr->hash = end_name_hash(hash);
410 
411 	return 0;
412 }
413 
414 /*
415  * Compare two names, taking note of the name length
416  * requirements of the underlying filesystem.
417  */
418 static int adfs_compare(const struct dentry *dentry, unsigned int len,
419 			const char *str, const struct qstr *qstr)
420 {
421 	return __adfs_compare(qstr->name, qstr->len, str, len);
422 }
423 
424 const struct dentry_operations adfs_dentry_operations = {
425 	.d_hash		= adfs_hash,
426 	.d_compare	= adfs_compare,
427 };
428 
429 static struct dentry *
430 adfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
431 {
432 	struct inode *inode = NULL;
433 	struct object_info obj;
434 	int error;
435 
436 	error = adfs_dir_lookup_byname(dir, &dentry->d_name, &obj);
437 	if (error == 0) {
438 		/*
439 		 * This only returns NULL if get_empty_inode
440 		 * fails.
441 		 */
442 		inode = adfs_iget(dir->i_sb, &obj);
443 		if (!inode)
444 			inode = ERR_PTR(-EACCES);
445 	} else if (error != -ENOENT) {
446 		inode = ERR_PTR(error);
447 	}
448 	return d_splice_alias(inode, dentry);
449 }
450 
451 /*
452  * directories can handle most operations...
453  */
454 const struct inode_operations adfs_dir_inode_operations = {
455 	.lookup		= adfs_lookup,
456 	.setattr	= adfs_notify_change,
457 };
458