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 "adfs.h" 12 #include "dir_fplus.h" 13 14 static int 15 adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir) 16 { 17 struct adfs_bigdirheader *h; 18 struct adfs_bigdirtail *t; 19 unsigned long block; 20 unsigned int blk, size; 21 int i, ret = -EIO; 22 23 dir->nr_buffers = 0; 24 25 block = __adfs_block_map(sb, id, 0); 26 if (!block) { 27 adfs_error(sb, "dir object %X has a hole at offset 0", id); 28 goto out; 29 } 30 31 dir->bh[0] = sb_bread(sb, block); 32 if (!dir->bh[0]) 33 goto out; 34 dir->nr_buffers += 1; 35 36 h = (struct adfs_bigdirheader *)dir->bh[0]->b_data; 37 size = le32_to_cpu(h->bigdirsize); 38 if (size != sz) { 39 printk(KERN_WARNING "adfs: adfs_fplus_read: directory header size\n" 40 " does not match directory size\n"); 41 } 42 43 if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 || 44 h->bigdirversion[2] != 0 || size & 2047 || 45 h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) 46 goto out; 47 48 size >>= sb->s_blocksize_bits; 49 for (blk = 1; blk < size; blk++) { 50 block = __adfs_block_map(sb, id, blk); 51 if (!block) { 52 adfs_error(sb, "dir object %X has a hole at offset %d", id, blk); 53 goto out; 54 } 55 56 dir->bh[blk] = sb_bread(sb, block); 57 if (!dir->bh[blk]) 58 goto out; 59 dir->nr_buffers = blk; 60 } 61 62 t = (struct adfs_bigdirtail *)(dir->bh[size - 1]->b_data + (sb->s_blocksize - 8)); 63 64 if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) || 65 t->bigdirendmasseq != h->startmasseq || 66 t->reserved[0] != 0 || t->reserved[1] != 0) 67 goto out; 68 69 dir->parent_id = le32_to_cpu(h->bigdirparent); 70 dir->sb = sb; 71 return 0; 72 out: 73 for (i = 0; i < dir->nr_buffers; i++) 74 brelse(dir->bh[i]); 75 dir->sb = NULL; 76 return ret; 77 } 78 79 static int 80 adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos) 81 { 82 struct adfs_bigdirheader *h = (struct adfs_bigdirheader *)dir->bh[0]->b_data; 83 int ret = -ENOENT; 84 85 if (fpos <= le32_to_cpu(h->bigdirentries)) { 86 dir->pos = fpos; 87 ret = 0; 88 } 89 90 return ret; 91 } 92 93 static void 94 dir_memcpy(struct adfs_dir *dir, unsigned int offset, void *to, int len) 95 { 96 struct super_block *sb = dir->sb; 97 unsigned int buffer, partial, remainder; 98 99 buffer = offset >> sb->s_blocksize_bits; 100 offset &= sb->s_blocksize - 1; 101 102 partial = sb->s_blocksize - offset; 103 104 if (partial >= len) 105 memcpy(to, dir->bh[buffer]->b_data + offset, len); 106 else { 107 char *c = (char *)to; 108 109 remainder = len - partial; 110 111 memcpy(c, dir->bh[buffer]->b_data + offset, partial); 112 memcpy(c + partial, dir->bh[buffer + 1]->b_data, remainder); 113 } 114 } 115 116 static int 117 adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj) 118 { 119 struct adfs_bigdirheader *h = (struct adfs_bigdirheader *)dir->bh[0]->b_data; 120 struct adfs_bigdirentry bde; 121 unsigned int offset; 122 int i, ret = -ENOENT; 123 124 if (dir->pos >= le32_to_cpu(h->bigdirentries)) 125 goto out; 126 127 offset = offsetof(struct adfs_bigdirheader, bigdirname); 128 offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3); 129 offset += dir->pos * sizeof(struct adfs_bigdirentry); 130 131 dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry)); 132 133 obj->loadaddr = le32_to_cpu(bde.bigdirload); 134 obj->execaddr = le32_to_cpu(bde.bigdirexec); 135 obj->size = le32_to_cpu(bde.bigdirlen); 136 obj->file_id = le32_to_cpu(bde.bigdirindaddr); 137 obj->attr = le32_to_cpu(bde.bigdirattr); 138 obj->name_len = le32_to_cpu(bde.bigdirobnamelen); 139 140 offset = offsetof(struct adfs_bigdirheader, bigdirname); 141 offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3); 142 offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry); 143 offset += le32_to_cpu(bde.bigdirobnameptr); 144 145 dir_memcpy(dir, offset, obj->name, obj->name_len); 146 for (i = 0; i < obj->name_len; i++) 147 if (obj->name[i] == '/') 148 obj->name[i] = '.'; 149 150 dir->pos += 1; 151 ret = 0; 152 out: 153 return ret; 154 } 155 156 static int 157 adfs_fplus_sync(struct adfs_dir *dir) 158 { 159 int err = 0; 160 int i; 161 162 for (i = dir->nr_buffers - 1; i >= 0; i--) { 163 struct buffer_head *bh = dir->bh[i]; 164 sync_dirty_buffer(bh); 165 if (buffer_req(bh) && !buffer_uptodate(bh)) 166 err = -EIO; 167 } 168 169 return err; 170 } 171 172 static void 173 adfs_fplus_free(struct adfs_dir *dir) 174 { 175 int i; 176 177 for (i = 0; i < dir->nr_buffers; i++) 178 brelse(dir->bh[i]); 179 dir->sb = NULL; 180 } 181 182 struct adfs_dir_ops adfs_fplus_dir_ops = { 183 .read = adfs_fplus_read, 184 .setpos = adfs_fplus_setpos, 185 .getnext = adfs_fplus_getnext, 186 .sync = adfs_fplus_sync, 187 .free = adfs_fplus_free 188 }; 189