fs/adfs/dir_fplus.c

   1 /*
   2  *  linux/fs/adfs/dir_fplus.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 #include <linux/buffer_head.h>
  11 #include <linux/slab.h>
  12 #include "adfs.h"
  13 #include "dir_fplus.h"
  14
  15 static int
  16 adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
  17 {
  18         struct adfs_bigdirheader *h;
  19         struct adfs_bigdirtail *t;
  20         unsigned long block;
  21         unsigned int blk, size;
  22         int i, ret = -EIO;
  23
  24         dir->nr_buffers = 0;
  25
  26         /* start off using fixed bh set - only alloc for big dirs */
  27         dir->bh_fplus = &dir->bh[0];
  28
  29         block = __adfs_block_map(sb, id, 0);
  30         if (!block) {
  31                 adfs_error(sb, "dir object %X has a hole at offset 0", id);
  32                 goto out;
  33         }
  34
  35         dir->bh_fplus[0] = sb_bread(sb, block);
  36         if (!dir->bh_fplus[0])
  37                 goto out;
  38         dir->nr_buffers += 1;
  39
  40         h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data;
  41         size = le32_to_cpu(h->bigdirsize);
  42         if (size != sz) {
  43                 printk(KERN_WARNING "adfs: adfs_fplus_read:"
  44                                         " directory header size %X\n"
  45                                         " does not match directory size %X\n",
  46                                         size, sz);
  47         }
  48
  49         if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 ||
  50             h->bigdirversion[2] != 0 || size & 2047 ||
  51             h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) {
  52                 printk(KERN_WARNING "adfs: dir object %X has"
  53                                         " malformed dir header\n", id);
  54                 goto out;
  55         }
  56
  57         size >>= sb->s_blocksize_bits;
  58         if (size > ARRAY_SIZE(dir->bh)) {
  59                 /* this directory is too big for fixed bh set, must allocate */
  60                 struct buffer_head **bh_fplus =
  61                         kcalloc(size, sizeof(struct buffer_head *),
  62                                 GFP_KERNEL);
  63                 if (!bh_fplus) {
  64                         ret = -ENOMEM;
  65                         adfs_error(sb, "not enough memory for"
  66                                         " dir object %X (%d blocks)", id, size);
  67                         goto out;
  68                 }
  69                 dir->bh_fplus = bh_fplus;
  70                 /* copy over the pointer to the block that we've already read */
  71                 dir->bh_fplus[0] = dir->bh[0];
  72         }
  73
  74         for (blk = 1; blk < size; blk++) {
  75                 block = __adfs_block_map(sb, id, blk);
  76                 if (!block) {
  77                         adfs_error(sb, "dir object %X has a hole at offset %d", id, blk);
  78                         goto out;
  79                 }
  80
  81                 dir->bh_fplus[blk] = sb_bread(sb, block);
  82                 if (!dir->bh_fplus[blk]) {
  83                         adfs_error(sb,  "dir object %x failed read for offset %d, mapped block %lX",
  84                                    id, blk, block);
  85                         goto out;
  86                 }
  87
  88                 dir->nr_buffers += 1;
  89         }
  90
  91         t = (struct adfs_bigdirtail *)
  92                 (dir->bh_fplus[size - 1]->b_data + (sb->s_blocksize - 8));
  93
  94         if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
  95             t->bigdirendmasseq != h->startmasseq ||
  96             t->reserved[0] != 0 || t->reserved[1] != 0) {
  97                 printk(KERN_WARNING "adfs: dir object %X has "
  98                                         "malformed dir end\n", id);
  99                 goto out;
 100         }
 101
 102         dir->parent_id = le32_to_cpu(h->bigdirparent);
 103         dir->sb = sb;
 104         return 0;
 105
 106 out:
 107         if (dir->bh_fplus) {
 108                 for (i = 0; i < dir->nr_buffers; i++)
 109                         brelse(dir->bh_fplus[i]);
 110
 111                 if (&dir->bh[0] != dir->bh_fplus)
 112                         kfree(dir->bh_fplus);
 113
 114                 dir->bh_fplus = NULL;
 115         }
 116
 117         dir->nr_buffers = 0;
 118         dir->sb = NULL;
 119         return ret;
 120 }
 121
 122 static int
 123 adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
 124 {
 125         struct adfs_bigdirheader *h =
 126                 (struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
 127         int ret = -ENOENT;
 128
 129         if (fpos <= le32_to_cpu(h->bigdirentries)) {
 130                 dir->pos = fpos;
 131                 ret = 0;
 132         }
 133
 134         return ret;
 135 }
 136
 137 static void
 138 dir_memcpy(struct adfs_dir *dir, unsigned int offset, void *to, int len)
 139 {
 140         struct super_block *sb = dir->sb;
 141         unsigned int buffer, partial, remainder;
 142
 143         buffer = offset >> sb->s_blocksize_bits;
 144         offset &= sb->s_blocksize - 1;
 145
 146         partial = sb->s_blocksize - offset;
 147
 148         if (partial >= len)
 149                 memcpy(to, dir->bh_fplus[buffer]->b_data + offset, len);
 150         else {
 151                 char *c = (char *)to;
 152
 153                 remainder = len - partial;
 154
 155                 memcpy(c,
 156                         dir->bh_fplus[buffer]->b_data + offset,
 157                         partial);
 158
 159                 memcpy(c + partial,
 160                         dir->bh_fplus[buffer + 1]->b_data,
 161                         remainder);
 162         }
 163 }
 164
 165 static int
 166 adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
 167 {
 168         struct adfs_bigdirheader *h =
 169                 (struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
 170         struct adfs_bigdirentry bde;
 171         unsigned int offset;
 172         int i, ret = -ENOENT;
 173
 174         if (dir->pos >= le32_to_cpu(h->bigdirentries))
 175                 goto out;
 176
 177         offset = offsetof(struct adfs_bigdirheader, bigdirname);
 178         offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
 179         offset += dir->pos * sizeof(struct adfs_bigdirentry);
 180
 181         dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry));
 182
 183         obj->loadaddr = le32_to_cpu(bde.bigdirload);
 184         obj->execaddr = le32_to_cpu(bde.bigdirexec);
 185         obj->size     = le32_to_cpu(bde.bigdirlen);
 186         obj->file_id  = le32_to_cpu(bde.bigdirindaddr);
 187         obj->attr     = le32_to_cpu(bde.bigdirattr);
 188         obj->name_len = le32_to_cpu(bde.bigdirobnamelen);
 189
 190         offset = offsetof(struct adfs_bigdirheader, bigdirname);
 191         offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
 192         offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry);
 193         offset += le32_to_cpu(bde.bigdirobnameptr);
 194
 195         dir_memcpy(dir, offset, obj->name, obj->name_len);
 196         for (i = 0; i < obj->name_len; i++)
 197                 if (obj->name[i] == '/')
 198                         obj->name[i] = '.';
 199
 200         obj->filetype = -1;
 201
 202         /*
 203          * object is a file and is filetyped and timestamped?
 204          * RISC OS 12-bit filetype is stored in load_address[19:8]
 205          */
 206         if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) &&
 207                 (0xfff00000 == (0xfff00000 & obj->loadaddr))) {
 208                 obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);
 209
 210                 /* optionally append the ,xyz hex filetype suffix */
 211                 if (ADFS_SB(dir->sb)->s_ftsuffix)
 212                         obj->name_len +=
 213                                 append_filetype_suffix(
 214                                         &obj->name[obj->name_len],
 215                                         obj->filetype);
 216         }
 217
 218         dir->pos += 1;
 219         ret = 0;
 220 out:
 221         return ret;
 222 }
 223
 224 static int
 225 adfs_fplus_sync(struct adfs_dir *dir)
 226 {
 227         int err = 0;
 228         int i;
 229
 230         for (i = dir->nr_buffers - 1; i >= 0; i--) {
 231                 struct buffer_head *bh = dir->bh_fplus[i];
 232                 sync_dirty_buffer(bh);
 233                 if (buffer_req(bh) && !buffer_uptodate(bh))
 234                         err = -EIO;
 235         }
 236
 237         return err;
 238 }
 239
 240 static void
 241 adfs_fplus_free(struct adfs_dir *dir)
 242 {
 243         int i;
 244
 245         if (dir->bh_fplus) {
 246                 for (i = 0; i < dir->nr_buffers; i++)
 247                         brelse(dir->bh_fplus[i]);
 248
 249                 if (&dir->bh[0] != dir->bh_fplus)
 250                         kfree(dir->bh_fplus);
 251
 252                 dir->bh_fplus = NULL;
 253         }
 254
 255         dir->nr_buffers = 0;
 256         dir->sb = NULL;
 257 }
 258
 259 const struct adfs_dir_ops adfs_fplus_dir_ops = {
 260         .read           = adfs_fplus_read,
 261         .setpos         = adfs_fplus_setpos,
 262         .getnext        = adfs_fplus_getnext,
 263         .sync           = adfs_fplus_sync,
 264         .free           = adfs_fplus_free
 265 };