Merge branch 'for-5.6' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[platform/kernel/linux-starfive.git] / fs / adfs / dir.c
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 };