Merge branch 'master' into for-upstream
[pandora-kernel.git] / fs / adfs / dir_f.c
1 /*
2  *  linux/fs/adfs/dir_f.c
3  *
4  * Copyright (C) 1997-1999 Russell King
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  *  E and F format directory handling
11  */
12 #include <linux/errno.h>
13 #include <linux/fs.h>
14 #include <linux/adfs_fs.h>
15 #include <linux/time.h>
16 #include <linux/stat.h>
17 #include <linux/spinlock.h>
18 #include <linux/buffer_head.h>
19 #include <linux/string.h>
20
21 #include "adfs.h"
22 #include "dir_f.h"
23
24 static void adfs_f_free(struct adfs_dir *dir);
25
26 /*
27  * Read an (unaligned) value of length 1..4 bytes
28  */
29 static inline unsigned int adfs_readval(unsigned char *p, int len)
30 {
31         unsigned int val = 0;
32
33         switch (len) {
34         case 4:         val |= p[3] << 24;
35         case 3:         val |= p[2] << 16;
36         case 2:         val |= p[1] << 8;
37         default:        val |= p[0];
38         }
39         return val;
40 }
41
42 static inline void adfs_writeval(unsigned char *p, int len, unsigned int val)
43 {
44         switch (len) {
45         case 4:         p[3] = val >> 24;
46         case 3:         p[2] = val >> 16;
47         case 2:         p[1] = val >> 8;
48         default:        p[0] = val;
49         }
50 }
51
52 static inline int adfs_readname(char *buf, char *ptr, int maxlen)
53 {
54         char *old_buf = buf;
55
56         while ((unsigned char)*ptr >= ' ' && maxlen--) {
57                 if (*ptr == '/')
58                         *buf++ = '.';
59                 else
60                         *buf++ = *ptr;
61                 ptr++;
62         }
63         *buf = '\0';
64
65         return buf - old_buf;
66 }
67
68 #define ror13(v) ((v >> 13) | (v << 19))
69
70 #define dir_u8(idx)                             \
71         ({ int _buf = idx >> blocksize_bits;    \
72            int _off = idx - (_buf << blocksize_bits);\
73           *(u8 *)(bh[_buf]->b_data + _off);     \
74         })
75
76 #define dir_u32(idx)                            \
77         ({ int _buf = idx >> blocksize_bits;    \
78            int _off = idx - (_buf << blocksize_bits);\
79           *(__le32 *)(bh[_buf]->b_data + _off); \
80         })
81
82 #define bufoff(_bh,_idx)                        \
83         ({ int _buf = _idx >> blocksize_bits;   \
84            int _off = _idx - (_buf << blocksize_bits);\
85           (u8 *)(_bh[_buf]->b_data + _off);     \
86         })
87
88 /*
89  * There are some algorithms that are nice in
90  * assembler, but a bitch in C...  This is one
91  * of them.
92  */
93 static u8
94 adfs_dir_checkbyte(const struct adfs_dir *dir)
95 {
96         struct buffer_head * const *bh = dir->bh;
97         const int blocksize_bits = dir->sb->s_blocksize_bits;
98         union { __le32 *ptr32; u8 *ptr8; } ptr, end;
99         u32 dircheck = 0;
100         int last = 5 - 26;
101         int i = 0;
102
103         /*
104          * Accumulate each word up to the last whole
105          * word of the last directory entry.  This
106          * can spread across several buffer heads.
107          */
108         do {
109                 last += 26;
110                 do {
111                         dircheck = le32_to_cpu(dir_u32(i)) ^ ror13(dircheck);
112
113                         i += sizeof(u32);
114                 } while (i < (last & ~3));
115         } while (dir_u8(last) != 0);
116
117         /*
118          * Accumulate the last few bytes.  These
119          * bytes will be within the same bh.
120          */
121         if (i != last) {
122                 ptr.ptr8 = bufoff(bh, i);
123                 end.ptr8 = ptr.ptr8 + last - i;
124
125                 do {
126                         dircheck = *ptr.ptr8++ ^ ror13(dircheck);
127                 } while (ptr.ptr8 < end.ptr8);
128         }
129
130         /*
131          * The directory tail is in the final bh
132          * Note that contary to the RISC OS PRMs,
133          * the first few bytes are NOT included
134          * in the check.  All bytes are in the
135          * same bh.
136          */
137         ptr.ptr8 = bufoff(bh, 2008);
138         end.ptr8 = ptr.ptr8 + 36;
139
140         do {
141                 __le32 v = *ptr.ptr32++;
142                 dircheck = le32_to_cpu(v) ^ ror13(dircheck);
143         } while (ptr.ptr32 < end.ptr32);
144
145         return (dircheck ^ (dircheck >> 8) ^ (dircheck >> 16) ^ (dircheck >> 24)) & 0xff;
146 }
147
148 /*
149  * Read and check that a directory is valid
150  */
151 static int
152 adfs_dir_read(struct super_block *sb, unsigned long object_id,
153               unsigned int size, struct adfs_dir *dir)
154 {
155         const unsigned int blocksize_bits = sb->s_blocksize_bits;
156         int blk = 0;
157
158         /*
159          * Directories which are not a multiple of 2048 bytes
160          * are considered bad v2 [3.6]
161          */
162         if (size & 2047)
163                 goto bad_dir;
164
165         size >>= blocksize_bits;
166
167         dir->nr_buffers = 0;
168         dir->sb = sb;
169
170         for (blk = 0; blk < size; blk++) {
171                 int phys;
172
173                 phys = __adfs_block_map(sb, object_id, blk);
174                 if (!phys) {
175                         adfs_error(sb, "dir object %lX has a hole at offset %d",
176                                    object_id, blk);
177                         goto release_buffers;
178                 }
179
180                 dir->bh[blk] = sb_bread(sb, phys);
181                 if (!dir->bh[blk])
182                         goto release_buffers;
183         }
184
185         memcpy(&dir->dirhead, bufoff(dir->bh, 0), sizeof(dir->dirhead));
186         memcpy(&dir->dirtail, bufoff(dir->bh, 2007), sizeof(dir->dirtail));
187
188         if (dir->dirhead.startmasseq != dir->dirtail.new.endmasseq ||
189             memcmp(&dir->dirhead.startname, &dir->dirtail.new.endname, 4))
190                 goto bad_dir;
191
192         if (memcmp(&dir->dirhead.startname, "Nick", 4) &&
193             memcmp(&dir->dirhead.startname, "Hugo", 4))
194                 goto bad_dir;
195
196         if (adfs_dir_checkbyte(dir) != dir->dirtail.new.dircheckbyte)
197                 goto bad_dir;
198
199         dir->nr_buffers = blk;
200
201         return 0;
202
203 bad_dir:
204         adfs_error(sb, "corrupted directory fragment %lX",
205                    object_id);
206 release_buffers:
207         for (blk -= 1; blk >= 0; blk -= 1)
208                 brelse(dir->bh[blk]);
209
210         dir->sb = NULL;
211
212         return -EIO;
213 }
214
215 /*
216  * convert a disk-based directory entry to a Linux ADFS directory entry
217  */
218 static inline void
219 adfs_dir2obj(struct object_info *obj, struct adfs_direntry *de)
220 {
221         obj->name_len = adfs_readname(obj->name, de->dirobname, ADFS_F_NAME_LEN);
222         obj->file_id  = adfs_readval(de->dirinddiscadd, 3);
223         obj->loadaddr = adfs_readval(de->dirload, 4);
224         obj->execaddr = adfs_readval(de->direxec, 4);
225         obj->size     = adfs_readval(de->dirlen,  4);
226         obj->attr     = de->newdiratts;
227 }
228
229 /*
230  * convert a Linux ADFS directory entry to a disk-based directory entry
231  */
232 static inline void
233 adfs_obj2dir(struct adfs_direntry *de, struct object_info *obj)
234 {
235         adfs_writeval(de->dirinddiscadd, 3, obj->file_id);
236         adfs_writeval(de->dirload, 4, obj->loadaddr);
237         adfs_writeval(de->direxec, 4, obj->execaddr);
238         adfs_writeval(de->dirlen,  4, obj->size);
239         de->newdiratts = obj->attr;
240 }
241
242 /*
243  * get a directory entry.  Note that the caller is responsible
244  * for holding the relevant locks.
245  */
246 static int
247 __adfs_dir_get(struct adfs_dir *dir, int pos, struct object_info *obj)
248 {
249         struct super_block *sb = dir->sb;
250         struct adfs_direntry de;
251         int thissize, buffer, offset;
252
253         buffer = pos >> sb->s_blocksize_bits;
254
255         if (buffer > dir->nr_buffers)
256                 return -EINVAL;
257
258         offset = pos & (sb->s_blocksize - 1);
259         thissize = sb->s_blocksize - offset;
260         if (thissize > 26)
261                 thissize = 26;
262
263         memcpy(&de, dir->bh[buffer]->b_data + offset, thissize);
264         if (thissize != 26)
265                 memcpy(((char *)&de) + thissize, dir->bh[buffer + 1]->b_data,
266                        26 - thissize);
267
268         if (!de.dirobname[0])
269                 return -ENOENT;
270
271         adfs_dir2obj(obj, &de);
272
273         return 0;
274 }
275
276 static int
277 __adfs_dir_put(struct adfs_dir *dir, int pos, struct object_info *obj)
278 {
279         struct super_block *sb = dir->sb;
280         struct adfs_direntry de;
281         int thissize, buffer, offset;
282
283         buffer = pos >> sb->s_blocksize_bits;
284
285         if (buffer > dir->nr_buffers)
286                 return -EINVAL;
287
288         offset = pos & (sb->s_blocksize - 1);
289         thissize = sb->s_blocksize - offset;
290         if (thissize > 26)
291                 thissize = 26;
292
293         /*
294          * Get the entry in total
295          */
296         memcpy(&de, dir->bh[buffer]->b_data + offset, thissize);
297         if (thissize != 26)
298                 memcpy(((char *)&de) + thissize, dir->bh[buffer + 1]->b_data,
299                        26 - thissize);
300
301         /*
302          * update it
303          */
304         adfs_obj2dir(&de, obj);
305
306         /*
307          * Put the new entry back
308          */
309         memcpy(dir->bh[buffer]->b_data + offset, &de, thissize);
310         if (thissize != 26)
311                 memcpy(dir->bh[buffer + 1]->b_data, ((char *)&de) + thissize,
312                        26 - thissize);
313
314         return 0;
315 }
316
317 /*
318  * the caller is responsible for holding the necessary
319  * locks.
320  */
321 static int
322 adfs_dir_find_entry(struct adfs_dir *dir, unsigned long object_id)
323 {
324         int pos, ret;
325
326         ret = -ENOENT;
327
328         for (pos = 5; pos < ADFS_NUM_DIR_ENTRIES * 26 + 5; pos += 26) {
329                 struct object_info obj;
330
331                 if (!__adfs_dir_get(dir, pos, &obj))
332                         break;
333
334                 if (obj.file_id == object_id) {
335                         ret = pos;
336                         break;
337                 }
338         }
339
340         return ret;
341 }
342
343 static int
344 adfs_f_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
345 {
346         int ret;
347
348         if (sz != ADFS_NEWDIR_SIZE)
349                 return -EIO;
350
351         ret = adfs_dir_read(sb, id, sz, dir);
352         if (ret)
353                 adfs_error(sb, "unable to read directory");
354         else
355                 dir->parent_id = adfs_readval(dir->dirtail.new.dirparent, 3);
356
357         return ret;
358 }
359
360 static int
361 adfs_f_setpos(struct adfs_dir *dir, unsigned int fpos)
362 {
363         if (fpos >= ADFS_NUM_DIR_ENTRIES)
364                 return -ENOENT;
365
366         dir->pos = 5 + fpos * 26;
367         return 0;
368 }
369
370 static int
371 adfs_f_getnext(struct adfs_dir *dir, struct object_info *obj)
372 {
373         unsigned int ret;
374
375         ret = __adfs_dir_get(dir, dir->pos, obj);
376         if (ret == 0)
377                 dir->pos += 26;
378
379         return ret;
380 }
381
382 static int
383 adfs_f_update(struct adfs_dir *dir, struct object_info *obj)
384 {
385         struct super_block *sb = dir->sb;
386         int ret, i;
387
388         ret = adfs_dir_find_entry(dir, obj->file_id);
389         if (ret < 0) {
390                 adfs_error(dir->sb, "unable to locate entry to update");
391                 goto out;
392         }
393
394         __adfs_dir_put(dir, ret, obj);
395  
396         /*
397          * Increment directory sequence number
398          */
399         dir->bh[0]->b_data[0] += 1;
400         dir->bh[dir->nr_buffers - 1]->b_data[sb->s_blocksize - 6] += 1;
401
402         ret = adfs_dir_checkbyte(dir);
403         /*
404          * Update directory check byte
405          */
406         dir->bh[dir->nr_buffers - 1]->b_data[sb->s_blocksize - 1] = ret;
407
408 #if 1
409         {
410         const unsigned int blocksize_bits = sb->s_blocksize_bits;
411
412         memcpy(&dir->dirhead, bufoff(dir->bh, 0), sizeof(dir->dirhead));
413         memcpy(&dir->dirtail, bufoff(dir->bh, 2007), sizeof(dir->dirtail));
414
415         if (dir->dirhead.startmasseq != dir->dirtail.new.endmasseq ||
416             memcmp(&dir->dirhead.startname, &dir->dirtail.new.endname, 4))
417                 goto bad_dir;
418
419         if (memcmp(&dir->dirhead.startname, "Nick", 4) &&
420             memcmp(&dir->dirhead.startname, "Hugo", 4))
421                 goto bad_dir;
422
423         if (adfs_dir_checkbyte(dir) != dir->dirtail.new.dircheckbyte)
424                 goto bad_dir;
425         }
426 #endif
427         for (i = dir->nr_buffers - 1; i >= 0; i--)
428                 mark_buffer_dirty(dir->bh[i]);
429
430         ret = 0;
431 out:
432         return ret;
433 #if 1
434 bad_dir:
435         adfs_error(dir->sb, "whoops!  I broke a directory!");
436         return -EIO;
437 #endif
438 }
439
440 static void
441 adfs_f_free(struct adfs_dir *dir)
442 {
443         int i;
444
445         for (i = dir->nr_buffers - 1; i >= 0; i--) {
446                 brelse(dir->bh[i]);
447                 dir->bh[i] = NULL;
448         }
449
450         dir->nr_buffers = 0;
451         dir->sb = NULL;
452 }
453
454 struct adfs_dir_ops adfs_f_dir_ops = {
455         .read           = adfs_f_read,
456         .setpos         = adfs_f_setpos,
457         .getnext        = adfs_f_getnext,
458         .update         = adfs_f_update,
459         .free           = adfs_f_free
460 };