| | 1 | /* |
| | 2 | * linux/fs/hpfs/dnode.c |
| | 3 | * |
| | 4 | * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999 |
| | 5 | * |
| | 6 | * handling directory dnode tree - adding, deleteing & searching for dirents |
| | 7 | */ |
| | 8 | |
| | 9 | #include "hpfs_fn.h" |
| | 10 | |
| | 11 | static loff_t get_pos(struct dnode *d, struct hpfs_dirent *fde) |
| | 12 | { |
| | 13 | struct hpfs_dirent *de; |
| | 14 | struct hpfs_dirent *de_end = dnode_end_de(d); |
| | 15 | int i = 1; |
| | 16 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) { |
| | 17 | if (de == fde) return ((loff_t) le32_to_cpu(d->self) << 4) | (loff_t)i; |
| | 18 | i++; |
| | 19 | } |
| | 20 | printk("HPFS: get_pos: not_found\n"); |
| | 21 | return ((loff_t)le32_to_cpu(d->self) << 4) | (loff_t)1; |
| | 22 | } |
| | 23 | |
| | 24 | void hpfs_add_pos(struct inode *inode, loff_t *pos) |
| | 25 | { |
| | 26 | struct hpfs_inode_info *hpfs_inode = hpfs_i(inode); |
| | 27 | int i = 0; |
| | 28 | loff_t **ppos; |
| | 29 | |
| | 30 | if (hpfs_inode->i_rddir_off) |
| | 31 | for (; hpfs_inode->i_rddir_off[i]; i++) |
| | 32 | if (hpfs_inode->i_rddir_off[i] == pos) return; |
| | 33 | if (!(i&0x0f)) { |
| | 34 | if (!(ppos = kmalloc((i+0x11) * sizeof(loff_t*), GFP_NOFS))) { |
| | 35 | printk("HPFS: out of memory for position list\n"); |
| | 36 | return; |
| | 37 | } |
| | 38 | if (hpfs_inode->i_rddir_off) { |
| | 39 | memcpy(ppos, hpfs_inode->i_rddir_off, i * sizeof(loff_t)); |
| | 40 | kfree(hpfs_inode->i_rddir_off); |
| | 41 | } |
| | 42 | hpfs_inode->i_rddir_off = ppos; |
| | 43 | } |
| | 44 | hpfs_inode->i_rddir_off[i] = pos; |
| | 45 | hpfs_inode->i_rddir_off[i + 1] = NULL; |
| | 46 | } |
| | 47 | |
| | 48 | void hpfs_del_pos(struct inode *inode, loff_t *pos) |
| | 49 | { |
| | 50 | struct hpfs_inode_info *hpfs_inode = hpfs_i(inode); |
| | 51 | loff_t **i, **j; |
| | 52 | |
| | 53 | if (!hpfs_inode->i_rddir_off) goto not_f; |
| | 54 | for (i = hpfs_inode->i_rddir_off; *i; i++) if (*i == pos) goto fnd; |
| | 55 | goto not_f; |
| | 56 | fnd: |
| | 57 | for (j = i + 1; *j; j++) ; |
| | 58 | *i = *(j - 1); |
| | 59 | *(j - 1) = NULL; |
| | 60 | if (j - 1 == hpfs_inode->i_rddir_off) { |
| | 61 | kfree(hpfs_inode->i_rddir_off); |
| | 62 | hpfs_inode->i_rddir_off = NULL; |
| | 63 | } |
| | 64 | return; |
| | 65 | not_f: |
| | 66 | /*printk("HPFS: warning: position pointer %p->%08x not found\n", pos, (int)*pos);*/ |
| | 67 | return; |
| | 68 | } |
| | 69 | |
| | 70 | static void for_all_poss(struct inode *inode, void (*f)(loff_t *, loff_t, loff_t), |
| | 71 | loff_t p1, loff_t p2) |
| | 72 | { |
| | 73 | struct hpfs_inode_info *hpfs_inode = hpfs_i(inode); |
| | 74 | loff_t **i; |
| | 75 | |
| | 76 | if (!hpfs_inode->i_rddir_off) return; |
| | 77 | for (i = hpfs_inode->i_rddir_off; *i; i++) (*f)(*i, p1, p2); |
| | 78 | return; |
| | 79 | } |
| | 80 | |
| | 81 | static void hpfs_pos_subst(loff_t *p, loff_t f, loff_t t) |
| | 82 | { |
| | 83 | if (*p == f) *p = t; |
| | 84 | } |
| | 85 | |
| | 86 | /*void hpfs_hpfs_pos_substd(loff_t *p, loff_t f, loff_t t) |
| | 87 | { |
| | 88 | if ((*p & ~0x3f) == (f & ~0x3f)) *p = (t & ~0x3f) | (*p & 0x3f); |
| | 89 | }*/ |
| | 90 | |
| | 91 | static void hpfs_pos_ins(loff_t *p, loff_t d, loff_t c) |
| | 92 | { |
| | 93 | if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) { |
| | 94 | int n = (*p & 0x3f) + c; |
| | 95 | if (n > 0x3f) printk("HPFS: hpfs_pos_ins: %08x + %d\n", (int)*p, (int)c >> 8); |
| | 96 | else *p = (*p & ~0x3f) | n; |
| | 97 | } |
| | 98 | } |
| | 99 | |
| | 100 | static void hpfs_pos_del(loff_t *p, loff_t d, loff_t c) |
| | 101 | { |
| | 102 | if ((*p & ~0x3f) == (d & ~0x3f) && (*p & 0x3f) >= (d & 0x3f)) { |
| | 103 | int n = (*p & 0x3f) - c; |
| | 104 | if (n < 1) printk("HPFS: hpfs_pos_ins: %08x - %d\n", (int)*p, (int)c >> 8); |
| | 105 | else *p = (*p & ~0x3f) | n; |
| | 106 | } |
| | 107 | } |
| | 108 | |
| | 109 | static struct hpfs_dirent *dnode_pre_last_de(struct dnode *d) |
| | 110 | { |
| | 111 | struct hpfs_dirent *de, *de_end, *dee = NULL, *deee = NULL; |
| | 112 | de_end = dnode_end_de(d); |
| | 113 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) { |
| | 114 | deee = dee; dee = de; |
| | 115 | } |
| | 116 | return deee; |
| | 117 | } |
| | 118 | |
| | 119 | static struct hpfs_dirent *dnode_last_de(struct dnode *d) |
| | 120 | { |
| | 121 | struct hpfs_dirent *de, *de_end, *dee = NULL; |
| | 122 | de_end = dnode_end_de(d); |
| | 123 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) { |
| | 124 | dee = de; |
| | 125 | } |
| | 126 | return dee; |
| | 127 | } |
| | 128 | |
| | 129 | static void set_last_pointer(struct super_block *s, struct dnode *d, dnode_secno ptr) |
| | 130 | { |
| | 131 | struct hpfs_dirent *de; |
| | 132 | if (!(de = dnode_last_de(d))) { |
| | 133 | hpfs_error(s, "set_last_pointer: empty dnode %08x", le32_to_cpu(d->self)); |
| | 134 | return; |
| | 135 | } |
| | 136 | if (hpfs_sb(s)->sb_chk) { |
| | 137 | if (de->down) { |
| | 138 | hpfs_error(s, "set_last_pointer: dnode %08x has already last pointer %08x", |
| | 139 | le32_to_cpu(d->self), de_down_pointer(de)); |
| | 140 | return; |
| | 141 | } |
| | 142 | if (le16_to_cpu(de->length) != 32) { |
| | 143 | hpfs_error(s, "set_last_pointer: bad last dirent in dnode %08x", le32_to_cpu(d->self)); |
| | 144 | return; |
| | 145 | } |
| | 146 | } |
| | 147 | if (ptr) { |
| | 148 | le32_add_cpu(&d->first_free, 4); |
| | 149 | if (le32_to_cpu(d->first_free) > 2048) { |
| | 150 | hpfs_error(s, "set_last_pointer: too long dnode %08x", le32_to_cpu(d->self)); |
| | 151 | le32_add_cpu(&d->first_free, -4); |
| | 152 | return; |
| | 153 | } |
| | 154 | de->length = cpu_to_le16(36); |
| | 155 | de->down = 1; |
| | 156 | *(__le32 *)((char *)de + 32) = cpu_to_le32(ptr); |
| | 157 | } |
| | 158 | } |
| | 159 | |
| | 160 | /* Add an entry to dnode and don't care if it grows over 2048 bytes */ |
| | 161 | |
| | 162 | struct hpfs_dirent *hpfs_add_de(struct super_block *s, struct dnode *d, |
| | 163 | const unsigned char *name, |
| | 164 | unsigned namelen, secno down_ptr) |
| | 165 | { |
| | 166 | struct hpfs_dirent *de; |
| | 167 | struct hpfs_dirent *de_end = dnode_end_de(d); |
| | 168 | unsigned d_size = de_size(namelen, down_ptr); |
| | 169 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) { |
| | 170 | int c = hpfs_compare_names(s, name, namelen, de->name, de->namelen, de->last); |
| | 171 | if (!c) { |
| | 172 | hpfs_error(s, "name (%c,%d) already exists in dnode %08x", *name, namelen, le32_to_cpu(d->self)); |
| | 173 | return NULL; |
| | 174 | } |
| | 175 | if (c < 0) break; |
| | 176 | } |
| | 177 | memmove((char *)de + d_size, de, (char *)de_end - (char *)de); |
| | 178 | memset(de, 0, d_size); |
| | 179 | if (down_ptr) { |
| | 180 | *(__le32 *)((char *)de + d_size - 4) = cpu_to_le32(down_ptr); |
| | 181 | de->down = 1; |
| | 182 | } |
| | 183 | de->length = cpu_to_le16(d_size); |
| | 184 | de->not_8x3 = hpfs_is_name_long(name, namelen); |
| | 185 | de->namelen = namelen; |
| | 186 | memcpy(de->name, name, namelen); |
| | 187 | le32_add_cpu(&d->first_free, d_size); |
| | 188 | return de; |
| | 189 | } |
| | 190 | |
| | 191 | /* Delete dirent and don't care about its subtree */ |
| | 192 | |
| | 193 | static void hpfs_delete_de(struct super_block *s, struct dnode *d, |
| | 194 | struct hpfs_dirent *de) |
| | 195 | { |
| | 196 | if (de->last) { |
| | 197 | hpfs_error(s, "attempt to delete last dirent in dnode %08x", le32_to_cpu(d->self)); |
| | 198 | return; |
| | 199 | } |
| | 200 | d->first_free = cpu_to_le32(le32_to_cpu(d->first_free) - le16_to_cpu(de->length)); |
| | 201 | memmove(de, de_next_de(de), le32_to_cpu(d->first_free) + (char *)d - (char *)de); |
| | 202 | } |
| | 203 | |
| | 204 | static void fix_up_ptrs(struct super_block *s, struct dnode *d) |
| | 205 | { |
| | 206 | struct hpfs_dirent *de; |
| | 207 | struct hpfs_dirent *de_end = dnode_end_de(d); |
| | 208 | dnode_secno dno = le32_to_cpu(d->self); |
| | 209 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) |
| | 210 | if (de->down) { |
| | 211 | struct quad_buffer_head qbh; |
| | 212 | struct dnode *dd; |
| | 213 | if ((dd = hpfs_map_dnode(s, de_down_pointer(de), &qbh))) { |
| | 214 | if (le32_to_cpu(dd->up) != dno || dd->root_dnode) { |
| | 215 | dd->up = cpu_to_le32(dno); |
| | 216 | dd->root_dnode = 0; |
| | 217 | hpfs_mark_4buffers_dirty(&qbh); |
| | 218 | } |
| | 219 | hpfs_brelse4(&qbh); |
| | 220 | } |
| | 221 | } |
| | 222 | } |
| | 223 | |
| | 224 | /* Add an entry to dnode and do dnode splitting if required */ |
| | 225 | |
| | 226 | static int hpfs_add_to_dnode(struct inode *i, dnode_secno dno, |
| | 227 | const unsigned char *name, unsigned namelen, |
| | 228 | struct hpfs_dirent *new_de, dnode_secno down_ptr) |
| | 229 | { |
| | 230 | struct quad_buffer_head qbh, qbh1, qbh2; |
| | 231 | struct dnode *d, *ad, *rd, *nd = NULL; |
| | 232 | dnode_secno adno, rdno; |
| | 233 | struct hpfs_dirent *de; |
| | 234 | struct hpfs_dirent nde; |
| | 235 | unsigned char *nname; |
| | 236 | int h; |
| | 237 | int pos; |
| | 238 | struct buffer_head *bh; |
| | 239 | struct fnode *fnode; |
| | 240 | int c1, c2 = 0; |
| | 241 | if (!(nname = kmalloc(256, GFP_NOFS))) { |
| | 242 | printk("HPFS: out of memory, can't add to dnode\n"); |
| | 243 | return 1; |
| | 244 | } |
| | 245 | go_up: |
| | 246 | if (namelen >= 256) { |
| | 247 | hpfs_error(i->i_sb, "hpfs_add_to_dnode: namelen == %d", namelen); |
| | 248 | kfree(nd); |
| | 249 | kfree(nname); |
| | 250 | return 1; |
| | 251 | } |
| | 252 | if (!(d = hpfs_map_dnode(i->i_sb, dno, &qbh))) { |
| | 253 | kfree(nd); |
| | 254 | kfree(nname); |
| | 255 | return 1; |
| | 256 | } |
| | 257 | go_up_a: |
| | 258 | if (hpfs_sb(i->i_sb)->sb_chk) |
| | 259 | if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "hpfs_add_to_dnode")) { |
| | 260 | hpfs_brelse4(&qbh); |
| | 261 | kfree(nd); |
| | 262 | kfree(nname); |
| | 263 | return 1; |
| | 264 | } |
| | 265 | if (le32_to_cpu(d->first_free) + de_size(namelen, down_ptr) <= 2048) { |
| | 266 | loff_t t; |
| | 267 | copy_de(de=hpfs_add_de(i->i_sb, d, name, namelen, down_ptr), new_de); |
| | 268 | t = get_pos(d, de); |
| | 269 | for_all_poss(i, hpfs_pos_ins, t, 1); |
| | 270 | for_all_poss(i, hpfs_pos_subst, 4, t); |
| | 271 | for_all_poss(i, hpfs_pos_subst, 5, t + 1); |
| | 272 | hpfs_mark_4buffers_dirty(&qbh); |
| | 273 | hpfs_brelse4(&qbh); |
| | 274 | kfree(nd); |
| | 275 | kfree(nname); |
| | 276 | return 0; |
| | 277 | } |
| | 278 | if (!nd) if (!(nd = kmalloc(0x924, GFP_NOFS))) { |
| | 279 | /* 0x924 is a max size of dnode after adding a dirent with |
| | 280 | max name length. We alloc this only once. There must |
| | 281 | not be any error while splitting dnodes, otherwise the |
| | 282 | whole directory, not only file we're adding, would |
| | 283 | be lost. */ |
| | 284 | printk("HPFS: out of memory for dnode splitting\n"); |
| | 285 | hpfs_brelse4(&qbh); |
| | 286 | kfree(nname); |
| | 287 | return 1; |
| | 288 | } |
| | 289 | memcpy(nd, d, le32_to_cpu(d->first_free)); |
| | 290 | copy_de(de = hpfs_add_de(i->i_sb, nd, name, namelen, down_ptr), new_de); |
| | 291 | for_all_poss(i, hpfs_pos_ins, get_pos(nd, de), 1); |
| | 292 | h = ((char *)dnode_last_de(nd) - (char *)nd) / 2 + 10; |
| | 293 | if (!(ad = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &adno, &qbh1))) { |
| | 294 | hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted"); |
| | 295 | hpfs_brelse4(&qbh); |
| | 296 | kfree(nd); |
| | 297 | kfree(nname); |
| | 298 | return 1; |
| | 299 | } |
| | 300 | i->i_size += 2048; |
| | 301 | i->i_blocks += 4; |
| | 302 | pos = 1; |
| | 303 | for (de = dnode_first_de(nd); (char *)de_next_de(de) - (char *)nd < h; de = de_next_de(de)) { |
| | 304 | copy_de(hpfs_add_de(i->i_sb, ad, de->name, de->namelen, de->down ? de_down_pointer(de) : 0), de); |
| | 305 | for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | pos, ((loff_t)adno << 4) | pos); |
| | 306 | pos++; |
| | 307 | } |
| | 308 | copy_de(new_de = &nde, de); |
| | 309 | memcpy(nname, de->name, de->namelen); |
| | 310 | name = nname; |
| | 311 | namelen = de->namelen; |
| | 312 | for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | pos, 4); |
| | 313 | down_ptr = adno; |
| | 314 | set_last_pointer(i->i_sb, ad, de->down ? de_down_pointer(de) : 0); |
| | 315 | de = de_next_de(de); |
| | 316 | memmove((char *)nd + 20, de, le32_to_cpu(nd->first_free) + (char *)nd - (char *)de); |
| | 317 | le32_add_cpu(&nd->first_free, -((char *)de - (char *)nd - 20)); |
| | 318 | memcpy(d, nd, le32_to_cpu(nd->first_free)); |
| | 319 | for_all_poss(i, hpfs_pos_del, (loff_t)dno << 4, pos); |
| | 320 | fix_up_ptrs(i->i_sb, ad); |
| | 321 | if (!d->root_dnode) { |
| | 322 | ad->up = d->up; |
| | 323 | dno = le32_to_cpu(ad->up); |
| | 324 | hpfs_mark_4buffers_dirty(&qbh); |
| | 325 | hpfs_brelse4(&qbh); |
| | 326 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 327 | hpfs_brelse4(&qbh1); |
| | 328 | goto go_up; |
| | 329 | } |
| | 330 | if (!(rd = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &rdno, &qbh2))) { |
| | 331 | hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted"); |
| | 332 | hpfs_brelse4(&qbh); |
| | 333 | hpfs_brelse4(&qbh1); |
| | 334 | kfree(nd); |
| | 335 | kfree(nname); |
| | 336 | return 1; |
| | 337 | } |
| | 338 | i->i_size += 2048; |
| | 339 | i->i_blocks += 4; |
| | 340 | rd->root_dnode = 1; |
| | 341 | rd->up = d->up; |
| | 342 | if (!(fnode = hpfs_map_fnode(i->i_sb, le32_to_cpu(d->up), &bh))) { |
| | 343 | hpfs_free_dnode(i->i_sb, rdno); |
| | 344 | hpfs_brelse4(&qbh); |
| | 345 | hpfs_brelse4(&qbh1); |
| | 346 | hpfs_brelse4(&qbh2); |
| | 347 | kfree(nd); |
| | 348 | kfree(nname); |
| | 349 | return 1; |
| | 350 | } |
| | 351 | fnode->u.external[0].disk_secno = cpu_to_le32(rdno); |
| | 352 | mark_buffer_dirty(bh); |
| | 353 | brelse(bh); |
| | 354 | hpfs_i(i)->i_dno = rdno; |
| | 355 | d->up = ad->up = cpu_to_le32(rdno); |
| | 356 | d->root_dnode = ad->root_dnode = 0; |
| | 357 | hpfs_mark_4buffers_dirty(&qbh); |
| | 358 | hpfs_brelse4(&qbh); |
| | 359 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 360 | hpfs_brelse4(&qbh1); |
| | 361 | qbh = qbh2; |
| | 362 | set_last_pointer(i->i_sb, rd, dno); |
| | 363 | dno = rdno; |
| | 364 | d = rd; |
| | 365 | goto go_up_a; |
| | 366 | } |
| | 367 | |
| | 368 | /* |
| | 369 | * Add an entry to directory btree. |
| | 370 | * I hate such crazy directory structure. |
| | 371 | * It's easy to read but terrible to write. |
| | 372 | * I wrote this directory code 4 times. |
| | 373 | * I hope, now it's finally bug-free. |
| | 374 | */ |
| | 375 | |
| | 376 | int hpfs_add_dirent(struct inode *i, |
| | 377 | const unsigned char *name, unsigned namelen, |
| | 378 | struct hpfs_dirent *new_de) |
| | 379 | { |
| | 380 | struct hpfs_inode_info *hpfs_inode = hpfs_i(i); |
| | 381 | struct dnode *d; |
| | 382 | struct hpfs_dirent *de, *de_end; |
| | 383 | struct quad_buffer_head qbh; |
| | 384 | dnode_secno dno; |
| | 385 | int c; |
| | 386 | int c1, c2 = 0; |
| | 387 | dno = hpfs_inode->i_dno; |
| | 388 | down: |
| | 389 | if (hpfs_sb(i->i_sb)->sb_chk) |
| | 390 | if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "hpfs_add_dirent")) return 1; |
| | 391 | if (!(d = hpfs_map_dnode(i->i_sb, dno, &qbh))) return 1; |
| | 392 | de_end = dnode_end_de(d); |
| | 393 | for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) { |
| | 394 | if (!(c = hpfs_compare_names(i->i_sb, name, namelen, de->name, de->namelen, de->last))) { |
| | 395 | hpfs_brelse4(&qbh); |
| | 396 | return -1; |
| | 397 | } |
| | 398 | if (c < 0) { |
| | 399 | if (de->down) { |
| | 400 | dno = de_down_pointer(de); |
| | 401 | hpfs_brelse4(&qbh); |
| | 402 | goto down; |
| | 403 | } |
| | 404 | break; |
| | 405 | } |
| | 406 | } |
| | 407 | hpfs_brelse4(&qbh); |
| | 408 | if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_ADD)) { |
| | 409 | c = 1; |
| | 410 | goto ret; |
| | 411 | } |
| | 412 | i->i_version++; |
| | 413 | c = hpfs_add_to_dnode(i, dno, name, namelen, new_de, 0); |
| | 414 | ret: |
| | 415 | return c; |
| | 416 | } |
| | 417 | |
| | 418 | /* |
| | 419 | * Find dirent with higher name in 'from' subtree and move it to 'to' dnode. |
| | 420 | * Return the dnode we moved from (to be checked later if it's empty) |
| | 421 | */ |
| | 422 | |
| | 423 | static secno move_to_top(struct inode *i, dnode_secno from, dnode_secno to) |
| | 424 | { |
| | 425 | dnode_secno dno, ddno; |
| | 426 | dnode_secno chk_up = to; |
| | 427 | struct dnode *dnode; |
| | 428 | struct quad_buffer_head qbh; |
| | 429 | struct hpfs_dirent *de, *nde; |
| | 430 | int a; |
| | 431 | loff_t t; |
| | 432 | int c1, c2 = 0; |
| | 433 | dno = from; |
| | 434 | while (1) { |
| | 435 | if (hpfs_sb(i->i_sb)->sb_chk) |
| | 436 | if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "move_to_top")) |
| | 437 | return 0; |
| | 438 | if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return 0; |
| | 439 | if (hpfs_sb(i->i_sb)->sb_chk) { |
| | 440 | if (le32_to_cpu(dnode->up) != chk_up) { |
| | 441 | hpfs_error(i->i_sb, "move_to_top: up pointer from %08x should be %08x, is %08x", |
| | 442 | dno, chk_up, le32_to_cpu(dnode->up)); |
| | 443 | hpfs_brelse4(&qbh); |
| | 444 | return 0; |
| | 445 | } |
| | 446 | chk_up = dno; |
| | 447 | } |
| | 448 | if (!(de = dnode_last_de(dnode))) { |
| | 449 | hpfs_error(i->i_sb, "move_to_top: dnode %08x has no last de", dno); |
| | 450 | hpfs_brelse4(&qbh); |
| | 451 | return 0; |
| | 452 | } |
| | 453 | if (!de->down) break; |
| | 454 | dno = de_down_pointer(de); |
| | 455 | hpfs_brelse4(&qbh); |
| | 456 | } |
| | 457 | while (!(de = dnode_pre_last_de(dnode))) { |
| | 458 | dnode_secno up = le32_to_cpu(dnode->up); |
| | 459 | hpfs_brelse4(&qbh); |
| | 460 | hpfs_free_dnode(i->i_sb, dno); |
| | 461 | i->i_size -= 2048; |
| | 462 | i->i_blocks -= 4; |
| | 463 | for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | 1, 5); |
| | 464 | if (up == to) return to; |
| | 465 | if (!(dnode = hpfs_map_dnode(i->i_sb, up, &qbh))) return 0; |
| | 466 | if (dnode->root_dnode) { |
| | 467 | hpfs_error(i->i_sb, "move_to_top: got to root_dnode while moving from %08x to %08x", from, to); |
| | 468 | hpfs_brelse4(&qbh); |
| | 469 | return 0; |
| | 470 | } |
| | 471 | de = dnode_last_de(dnode); |
| | 472 | if (!de || !de->down) { |
| | 473 | hpfs_error(i->i_sb, "move_to_top: dnode %08x doesn't point down to %08x", up, dno); |
| | 474 | hpfs_brelse4(&qbh); |
| | 475 | return 0; |
| | 476 | } |
| | 477 | le32_add_cpu(&dnode->first_free, -4); |
| | 478 | le16_add_cpu(&de->length, -4); |
| | 479 | de->down = 0; |
| | 480 | hpfs_mark_4buffers_dirty(&qbh); |
| | 481 | dno = up; |
| | 482 | } |
| | 483 | t = get_pos(dnode, de); |
| | 484 | for_all_poss(i, hpfs_pos_subst, t, 4); |
| | 485 | for_all_poss(i, hpfs_pos_subst, t + 1, 5); |
| | 486 | if (!(nde = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) { |
| | 487 | hpfs_error(i->i_sb, "out of memory for dirent - directory will be corrupted"); |
| | 488 | hpfs_brelse4(&qbh); |
| | 489 | return 0; |
| | 490 | } |
| | 491 | memcpy(nde, de, le16_to_cpu(de->length)); |
| | 492 | ddno = de->down ? de_down_pointer(de) : 0; |
| | 493 | hpfs_delete_de(i->i_sb, dnode, de); |
| | 494 | set_last_pointer(i->i_sb, dnode, ddno); |
| | 495 | hpfs_mark_4buffers_dirty(&qbh); |
| | 496 | hpfs_brelse4(&qbh); |
| | 497 | a = hpfs_add_to_dnode(i, to, nde->name, nde->namelen, nde, from); |
| | 498 | kfree(nde); |
| | 499 | if (a) return 0; |
| | 500 | return dno; |
| | 501 | } |
| | 502 | |
| | 503 | /* |
| | 504 | * Check if a dnode is empty and delete it from the tree |
| | 505 | * (chkdsk doesn't like empty dnodes) |
| | 506 | */ |
| | 507 | |
| | 508 | static void delete_empty_dnode(struct inode *i, dnode_secno dno) |
| | 509 | { |
| | 510 | struct hpfs_inode_info *hpfs_inode = hpfs_i(i); |
| | 511 | struct quad_buffer_head qbh; |
| | 512 | struct dnode *dnode; |
| | 513 | dnode_secno down, up, ndown; |
| | 514 | int p; |
| | 515 | struct hpfs_dirent *de; |
| | 516 | int c1, c2 = 0; |
| | 517 | try_it_again: |
| | 518 | if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "delete_empty_dnode")) return; |
| | 519 | if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return; |
| | 520 | if (le32_to_cpu(dnode->first_free) > 56) goto end; |
| | 521 | if (le32_to_cpu(dnode->first_free) == 52 || le32_to_cpu(dnode->first_free) == 56) { |
| | 522 | struct hpfs_dirent *de_end; |
| | 523 | int root = dnode->root_dnode; |
| | 524 | up = le32_to_cpu(dnode->up); |
| | 525 | de = dnode_first_de(dnode); |
| | 526 | down = de->down ? de_down_pointer(de) : 0; |
| | 527 | if (hpfs_sb(i->i_sb)->sb_chk) if (root && !down) { |
| | 528 | hpfs_error(i->i_sb, "delete_empty_dnode: root dnode %08x is empty", dno); |
| | 529 | goto end; |
| | 530 | } |
| | 531 | hpfs_brelse4(&qbh); |
| | 532 | hpfs_free_dnode(i->i_sb, dno); |
| | 533 | i->i_size -= 2048; |
| | 534 | i->i_blocks -= 4; |
| | 535 | if (root) { |
| | 536 | struct fnode *fnode; |
| | 537 | struct buffer_head *bh; |
| | 538 | struct dnode *d1; |
| | 539 | struct quad_buffer_head qbh1; |
| | 540 | if (hpfs_sb(i->i_sb)->sb_chk) |
| | 541 | if (up != i->i_ino) { |
| | 542 | hpfs_error(i->i_sb, |
| | 543 | "bad pointer to fnode, dnode %08x, pointing to %08x, should be %08lx", |
| | 544 | dno, up, (unsigned long)i->i_ino); |
| | 545 | return; |
| | 546 | } |
| | 547 | if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) { |
| | 548 | d1->up = cpu_to_le32(up); |
| | 549 | d1->root_dnode = 1; |
| | 550 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 551 | hpfs_brelse4(&qbh1); |
| | 552 | } |
| | 553 | if ((fnode = hpfs_map_fnode(i->i_sb, up, &bh))) { |
| | 554 | fnode->u.external[0].disk_secno = cpu_to_le32(down); |
| | 555 | mark_buffer_dirty(bh); |
| | 556 | brelse(bh); |
| | 557 | } |
| | 558 | hpfs_inode->i_dno = down; |
| | 559 | for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | 1, (loff_t) 12); |
| | 560 | return; |
| | 561 | } |
| | 562 | if (!(dnode = hpfs_map_dnode(i->i_sb, up, &qbh))) return; |
| | 563 | p = 1; |
| | 564 | de_end = dnode_end_de(dnode); |
| | 565 | for (de = dnode_first_de(dnode); de < de_end; de = de_next_de(de), p++) |
| | 566 | if (de->down) if (de_down_pointer(de) == dno) goto fnd; |
| | 567 | hpfs_error(i->i_sb, "delete_empty_dnode: pointer to dnode %08x not found in dnode %08x", dno, up); |
| | 568 | goto end; |
| | 569 | fnd: |
| | 570 | for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | 1, ((loff_t)up << 4) | p); |
| | 571 | if (!down) { |
| | 572 | de->down = 0; |
| | 573 | le16_add_cpu(&de->length, -4); |
| | 574 | le32_add_cpu(&dnode->first_free, -4); |
| | 575 | memmove(de_next_de(de), (char *)de_next_de(de) + 4, |
| | 576 | (char *)dnode + le32_to_cpu(dnode->first_free) - (char *)de_next_de(de)); |
| | 577 | } else { |
| | 578 | struct dnode *d1; |
| | 579 | struct quad_buffer_head qbh1; |
| | 580 | *(dnode_secno *) ((void *) de + le16_to_cpu(de->length) - 4) = down; |
| | 581 | if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) { |
| | 582 | d1->up = cpu_to_le32(up); |
| | 583 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 584 | hpfs_brelse4(&qbh1); |
| | 585 | } |
| | 586 | } |
| | 587 | } else { |
| | 588 | hpfs_error(i->i_sb, "delete_empty_dnode: dnode %08x, first_free == %03x", dno, le32_to_cpu(dnode->first_free)); |
| | 589 | goto end; |
| | 590 | } |
| | 591 | |
| | 592 | if (!de->last) { |
| | 593 | struct hpfs_dirent *de_next = de_next_de(de); |
| | 594 | struct hpfs_dirent *de_cp; |
| | 595 | struct dnode *d1; |
| | 596 | struct quad_buffer_head qbh1; |
| | 597 | if (!de_next->down) goto endm; |
| | 598 | ndown = de_down_pointer(de_next); |
| | 599 | if (!(de_cp = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) { |
| | 600 | printk("HPFS: out of memory for dtree balancing\n"); |
| | 601 | goto endm; |
| | 602 | } |
| | 603 | memcpy(de_cp, de, le16_to_cpu(de->length)); |
| | 604 | hpfs_delete_de(i->i_sb, dnode, de); |
| | 605 | hpfs_mark_4buffers_dirty(&qbh); |
| | 606 | hpfs_brelse4(&qbh); |
| | 607 | for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | p, 4); |
| | 608 | for_all_poss(i, hpfs_pos_del, ((loff_t)up << 4) | p, 1); |
| | 609 | if (de_cp->down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de_cp), &qbh1))) { |
| | 610 | d1->up = cpu_to_le32(ndown); |
| | 611 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 612 | hpfs_brelse4(&qbh1); |
| | 613 | } |
| | 614 | hpfs_add_to_dnode(i, ndown, de_cp->name, de_cp->namelen, de_cp, de_cp->down ? de_down_pointer(de_cp) : 0); |
| | 615 | /*printk("UP-TO-DNODE: %08x (ndown = %08x, down = %08x, dno = %08x)\n", up, ndown, down, dno);*/ |
| | 616 | dno = up; |
| | 617 | kfree(de_cp); |
| | 618 | goto try_it_again; |
| | 619 | } else { |
| | 620 | struct hpfs_dirent *de_prev = dnode_pre_last_de(dnode); |
| | 621 | struct hpfs_dirent *de_cp; |
| | 622 | struct dnode *d1; |
| | 623 | struct quad_buffer_head qbh1; |
| | 624 | dnode_secno dlp; |
| | 625 | if (!de_prev) { |
| | 626 | hpfs_error(i->i_sb, "delete_empty_dnode: empty dnode %08x", up); |
| | 627 | hpfs_mark_4buffers_dirty(&qbh); |
| | 628 | hpfs_brelse4(&qbh); |
| | 629 | dno = up; |
| | 630 | goto try_it_again; |
| | 631 | } |
| | 632 | if (!de_prev->down) goto endm; |
| | 633 | ndown = de_down_pointer(de_prev); |
| | 634 | if ((d1 = hpfs_map_dnode(i->i_sb, ndown, &qbh1))) { |
| | 635 | struct hpfs_dirent *del = dnode_last_de(d1); |
| | 636 | dlp = del->down ? de_down_pointer(del) : 0; |
| | 637 | if (!dlp && down) { |
| | 638 | if (le32_to_cpu(d1->first_free) > 2044) { |
| | 639 | if (hpfs_sb(i->i_sb)->sb_chk >= 2) { |
| | 640 | printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n"); |
| | 641 | printk("HPFS: warning: terminating balancing operation\n"); |
| | 642 | } |
| | 643 | hpfs_brelse4(&qbh1); |
| | 644 | goto endm; |
| | 645 | } |
| | 646 | if (hpfs_sb(i->i_sb)->sb_chk >= 2) { |
| | 647 | printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n"); |
| | 648 | printk("HPFS: warning: goin'on\n"); |
| | 649 | } |
| | 650 | le16_add_cpu(&del->length, 4); |
| | 651 | del->down = 1; |
| | 652 | le32_add_cpu(&d1->first_free, 4); |
| | 653 | } |
| | 654 | if (dlp && !down) { |
| | 655 | le16_add_cpu(&del->length, -4); |
| | 656 | del->down = 0; |
| | 657 | le32_add_cpu(&d1->first_free, -4); |
| | 658 | } else if (down) |
| | 659 | *(__le32 *) ((void *) del + le16_to_cpu(del->length) - 4) = cpu_to_le32(down); |
| | 660 | } else goto endm; |
| | 661 | if (!(de_cp = kmalloc(le16_to_cpu(de_prev->length), GFP_NOFS))) { |
| | 662 | printk("HPFS: out of memory for dtree balancing\n"); |
| | 663 | hpfs_brelse4(&qbh1); |
| | 664 | goto endm; |
| | 665 | } |
| | 666 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 667 | hpfs_brelse4(&qbh1); |
| | 668 | memcpy(de_cp, de_prev, le16_to_cpu(de_prev->length)); |
| | 669 | hpfs_delete_de(i->i_sb, dnode, de_prev); |
| | 670 | if (!de_prev->down) { |
| | 671 | le16_add_cpu(&de_prev->length, 4); |
| | 672 | de_prev->down = 1; |
| | 673 | le32_add_cpu(&dnode->first_free, 4); |
| | 674 | } |
| | 675 | *(__le32 *) ((void *) de_prev + le16_to_cpu(de_prev->length) - 4) = cpu_to_le32(ndown); |
| | 676 | hpfs_mark_4buffers_dirty(&qbh); |
| | 677 | hpfs_brelse4(&qbh); |
| | 678 | for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | (p - 1), 4); |
| | 679 | for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | p, ((loff_t)up << 4) | (p - 1)); |
| | 680 | if (down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de), &qbh1))) { |
| | 681 | d1->up = cpu_to_le32(ndown); |
| | 682 | hpfs_mark_4buffers_dirty(&qbh1); |
| | 683 | hpfs_brelse4(&qbh1); |
| | 684 | } |
| | 685 | hpfs_add_to_dnode(i, ndown, de_cp->name, de_cp->namelen, de_cp, dlp); |
| | 686 | dno = up; |
| | 687 | kfree(de_cp); |
| | 688 | goto try_it_again; |
| | 689 | } |
| | 690 | endm: |
| | 691 | hpfs_mark_4buffers_dirty(&qbh); |
| | 692 | end: |
| | 693 | hpfs_brelse4(&qbh); |
| | 694 | } |
| | 695 | |
| | 696 | |
| | 697 | /* Delete dirent from directory */ |
| | 698 | |
| | 699 | int hpfs_remove_dirent(struct inode *i, dnode_secno dno, struct hpfs_dirent *de, |
| | 700 | struct quad_buffer_head *qbh, int depth) |
| | 701 | { |
| | 702 | struct dnode *dnode = qbh->data; |
| | 703 | dnode_secno down = 0; |
| | 704 | loff_t t; |
| | 705 | if (de->first || de->last) { |
| | 706 | hpfs_error(i->i_sb, "hpfs_remove_dirent: attempt to delete first or last dirent in dnode %08x", dno); |
| | 707 | hpfs_brelse4(qbh); |
| | 708 | return 1; |
| | 709 | } |
| | 710 | if (de->down) down = de_down_pointer(de); |
| | 711 | if (depth && (de->down || (de == dnode_first_de(dnode) && de_next_de(de)->last))) { |
| | 712 | if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_DEL)) { |
| | 713 | hpfs_brelse4(qbh); |
| | 714 | return 2; |
| | 715 | } |
| | 716 | } |
| | 717 | i->i_version++; |
| | 718 | for_all_poss(i, hpfs_pos_del, (t = get_pos(dnode, de)) + 1, 1); |
| | 719 | hpfs_delete_de(i->i_sb, dnode, de); |
| | 720 | hpfs_mark_4buffers_dirty(qbh); |
| | 721 | hpfs_brelse4(qbh); |
| | 722 | if (down) { |
| | 723 | dnode_secno a = move_to_top(i, down, dno); |
| | 724 | for_all_poss(i, hpfs_pos_subst, 5, t); |
| | 725 | if (a) delete_empty_dnode(i, a); |
| | 726 | return !a; |
| | 727 | } |
| | 728 | delete_empty_dnode(i, dno); |
| | 729 | return 0; |
| | 730 | } |
| | 731 | |
| | 732 | void hpfs_count_dnodes(struct super_block *s, dnode_secno dno, int *n_dnodes, |
| | 733 | int *n_subdirs, int *n_items) |
| | 734 | { |
| | 735 | struct dnode *dnode; |
| | 736 | struct quad_buffer_head qbh; |
| | 737 | struct hpfs_dirent *de; |
| | 738 | dnode_secno ptr, odno = 0; |
| | 739 | int c1, c2 = 0; |
| | 740 | int d1, d2 = 0; |
| | 741 | go_down: |
| | 742 | if (n_dnodes) (*n_dnodes)++; |
| | 743 | if (hpfs_sb(s)->sb_chk) |
| | 744 | if (hpfs_stop_cycles(s, dno, &c1, &c2, "hpfs_count_dnodes #1")) return; |
| | 745 | ptr = 0; |
| | 746 | go_up: |
| | 747 | if (!(dnode = hpfs_map_dnode(s, dno, &qbh))) return; |
| | 748 | if (hpfs_sb(s)->sb_chk) if (odno && odno != -1 && le32_to_cpu(dnode->up) != odno) |
| | 749 | hpfs_error(s, "hpfs_count_dnodes: bad up pointer; dnode %08x, down %08x points to %08x", odno, dno, le32_to_cpu(dnode->up)); |
| | 750 | de = dnode_first_de(dnode); |
| | 751 | if (ptr) while(1) { |
| | 752 | if (de->down) if (de_down_pointer(de) == ptr) goto process_de; |
| | 753 | if (de->last) { |
| | 754 | hpfs_brelse4(&qbh); |
| | 755 | hpfs_error(s, "hpfs_count_dnodes: pointer to dnode %08x not found in dnode %08x, got here from %08x", |
| | 756 | ptr, dno, odno); |
| | 757 | return; |
| | 758 | } |
| | 759 | de = de_next_de(de); |
| | 760 | } |
| | 761 | next_de: |
| | 762 | if (de->down) { |
| | 763 | odno = dno; |
| | 764 | dno = de_down_pointer(de); |
| | 765 | hpfs_brelse4(&qbh); |
| | 766 | goto go_down; |
| | 767 | } |
| | 768 | process_de: |
| | 769 | if (!de->first && !de->last && de->directory && n_subdirs) (*n_subdirs)++; |
| | 770 | if (!de->first && !de->last && n_items) (*n_items)++; |
| | 771 | if ((de = de_next_de(de)) < dnode_end_de(dnode)) goto next_de; |
| | 772 | ptr = dno; |
| | 773 | dno = le32_to_cpu(dnode->up); |
| | 774 | if (dnode->root_dnode) { |
| | 775 | hpfs_brelse4(&qbh); |
| | 776 | return; |
| | 777 | } |
| | 778 | hpfs_brelse4(&qbh); |
| | 779 | if (hpfs_sb(s)->sb_chk) |
| | 780 | if (hpfs_stop_cycles(s, ptr, &d1, &d2, "hpfs_count_dnodes #2")) return; |
| | 781 | odno = -1; |
| | 782 | goto go_up; |
| | 783 | } |
| | 784 | |
| | 785 | static struct hpfs_dirent *map_nth_dirent(struct super_block *s, dnode_secno dno, int n, |
| | 786 | struct quad_buffer_head *qbh, struct dnode **dn) |
| | 787 | { |
| | 788 | int i; |
| | 789 | struct hpfs_dirent *de, *de_end; |
| | 790 | struct dnode *dnode; |
| | 791 | dnode = hpfs_map_dnode(s, dno, qbh); |
| | 792 | if (!dnode) return NULL; |
| | 793 | if (dn) *dn=dnode; |
| | 794 | de = dnode_first_de(dnode); |
| | 795 | de_end = dnode_end_de(dnode); |
| | 796 | for (i = 1; de < de_end; i++, de = de_next_de(de)) { |
| | 797 | if (i == n) { |
| | 798 | return de; |
| | 799 | } |
| | 800 | if (de->last) break; |
| | 801 | } |
| | 802 | hpfs_brelse4(qbh); |
| | 803 | hpfs_error(s, "map_nth_dirent: n too high; dnode = %08x, requested %08x", dno, n); |
| | 804 | return NULL; |
| | 805 | } |
| | 806 | |
| | 807 | dnode_secno hpfs_de_as_down_as_possible(struct super_block *s, dnode_secno dno) |
| | 808 | { |
| | 809 | struct quad_buffer_head qbh; |
| | 810 | dnode_secno d = dno; |
| | 811 | dnode_secno up = 0; |
| | 812 | struct hpfs_dirent *de; |
| | 813 | int c1, c2 = 0; |
| | 814 | |
| | 815 | again: |
| | 816 | if (hpfs_sb(s)->sb_chk) |
| | 817 | if (hpfs_stop_cycles(s, d, &c1, &c2, "hpfs_de_as_down_as_possible")) |
| | 818 | return d; |
| | 819 | if (!(de = map_nth_dirent(s, d, 1, &qbh, NULL))) return dno; |
| | 820 | if (hpfs_sb(s)->sb_chk) |
| | 821 | if (up && le32_to_cpu(((struct dnode *)qbh.data)->up) != up) |
| | 822 | hpfs_error(s, "hpfs_de_as_down_as_possible: bad up pointer; dnode %08x, down %08x points to %08x", up, d, le32_to_cpu(((struct dnode *)qbh.data)->up)); |
| | 823 | if (!de->down) { |
| | 824 | hpfs_brelse4(&qbh); |
| | 825 | return d; |
| | 826 | } |
| | 827 | up = d; |
| | 828 | d = de_down_pointer(de); |
| | 829 | hpfs_brelse4(&qbh); |
| | 830 | goto again; |
| | 831 | } |
| | 832 | |
| | 833 | struct hpfs_dirent *map_pos_dirent(struct inode *inode, loff_t *posp, |
| | 834 | struct quad_buffer_head *qbh) |
| | 835 | { |
| | 836 | loff_t pos; |
| | 837 | unsigned c; |
| | 838 | dnode_secno dno; |
| | 839 | struct hpfs_dirent *de, *d; |
| | 840 | struct hpfs_dirent *up_de; |
| | 841 | struct hpfs_dirent *end_up_de; |
| | 842 | struct dnode *dnode; |
| | 843 | struct dnode *up_dnode; |
| | 844 | struct quad_buffer_head qbh0; |
| | 845 | |
| | 846 | pos = *posp; |
| | 847 | dno = pos >> 6 << 2; |
| | 848 | pos &= 077; |
| | 849 | if (!(de = map_nth_dirent(inode->i_sb, dno, pos, qbh, &dnode))) |
| | 850 | goto bail; |
| | 851 | |
| | 852 | /* Going to the next dirent */ |
| | 853 | if ((d = de_next_de(de)) < dnode_end_de(dnode)) { |
| | 854 | if (!(++*posp & 077)) { |
| | 855 | hpfs_error(inode->i_sb, |
| | 856 | "map_pos_dirent: pos crossed dnode boundary; pos = %08llx", |
| | 857 | (unsigned long long)*posp); |
| | 858 | goto bail; |
| | 859 | } |
| | 860 | /* We're going down the tree */ |
| | 861 | if (d->down) { |
| | 862 | *posp = ((loff_t) hpfs_de_as_down_as_possible(inode->i_sb, de_down_pointer(d)) << 4) + 1; |
| | 863 | } |
| | 864 | |
| | 865 | return de; |
| | 866 | } |
| | 867 | |
| | 868 | /* Going up */ |
| | 869 | if (dnode->root_dnode) goto bail; |
| | 870 | |
| | 871 | if (!(up_dnode = hpfs_map_dnode(inode->i_sb, le32_to_cpu(dnode->up), &qbh0))) |
| | 872 | goto bail; |
| | 873 | |
| | 874 | end_up_de = dnode_end_de(up_dnode); |
| | 875 | c = 0; |
| | 876 | for (up_de = dnode_first_de(up_dnode); up_de < end_up_de; |
| | 877 | up_de = de_next_de(up_de)) { |
| | 878 | if (!(++c & 077)) hpfs_error(inode->i_sb, |
| | 879 | "map_pos_dirent: pos crossed dnode boundary; dnode = %08x", le32_to_cpu(dnode->up)); |
| | 880 | if (up_de->down && de_down_pointer(up_de) == dno) { |
| | 881 | *posp = ((loff_t) le32_to_cpu(dnode->up) << 4) + c; |
| | 882 | hpfs_brelse4(&qbh0); |
| | 883 | return de; |
| | 884 | } |
| | 885 | } |
| | 886 | |
| | 887 | hpfs_error(inode->i_sb, "map_pos_dirent: pointer to dnode %08x not found in parent dnode %08x", |
| | 888 | dno, le32_to_cpu(dnode->up)); |
| | 889 | hpfs_brelse4(&qbh0); |
| | 890 | |
| | 891 | bail: |
| | 892 | *posp = 12; |
| | 893 | return de; |
| | 894 | } |
| | 895 | |
| | 896 | /* Find a dirent in tree */ |
| | 897 | |
| | 898 | struct hpfs_dirent *map_dirent(struct inode *inode, dnode_secno dno, |
| | 899 | const unsigned char *name, unsigned len, |
| | 900 | dnode_secno *dd, struct quad_buffer_head *qbh) |
| | 901 | { |
| | 902 | struct dnode *dnode; |
| | 903 | struct hpfs_dirent *de; |
| | 904 | struct hpfs_dirent *de_end; |
| | 905 | int c1, c2 = 0; |
| | 906 | |
| | 907 | if (!S_ISDIR(inode->i_mode)) hpfs_error(inode->i_sb, "map_dirent: not a directory\n"); |
| | 908 | again: |
| | 909 | if (hpfs_sb(inode->i_sb)->sb_chk) |
| | 910 | if (hpfs_stop_cycles(inode->i_sb, dno, &c1, &c2, "map_dirent")) return NULL; |
| | 911 | if (!(dnode = hpfs_map_dnode(inode->i_sb, dno, qbh))) return NULL; |
| | 912 | |
| | 913 | de_end = dnode_end_de(dnode); |
| | 914 | for (de = dnode_first_de(dnode); de < de_end; de = de_next_de(de)) { |
| | 915 | int t = hpfs_compare_names(inode->i_sb, name, len, de->name, de->namelen, de->last); |
| | 916 | if (!t) { |
| | 917 | if (dd) *dd = dno; |
| | 918 | return de; |
| | 919 | } |
| | 920 | if (t < 0) { |
| | 921 | if (de->down) { |
| | 922 | dno = de_down_pointer(de); |
| | 923 | hpfs_brelse4(qbh); |
| | 924 | goto again; |
| | 925 | } |
| | 926 | break; |
| | 927 | } |
| | 928 | } |
| | 929 | hpfs_brelse4(qbh); |
| | 930 | return NULL; |
| | 931 | } |
| | 932 | |
| | 933 | /* |
| | 934 | * Remove empty directory. In normal cases it is only one dnode with two |
| | 935 | * entries, but we must handle also such obscure cases when it's a tree |
| | 936 | * of empty dnodes. |
| | 937 | */ |
| | 938 | |
| | 939 | void hpfs_remove_dtree(struct super_block *s, dnode_secno dno) |
| | 940 | { |
| | 941 | struct quad_buffer_head qbh; |
| | 942 | struct dnode *dnode; |
| | 943 | struct hpfs_dirent *de; |
| | 944 | dnode_secno d1, d2, rdno = dno; |
| | 945 | while (1) { |
| | 946 | if (!(dnode = hpfs_map_dnode(s, dno, &qbh))) return; |
| | 947 | de = dnode_first_de(dnode); |
| | 948 | if (de->last) { |
| | 949 | if (de->down) d1 = de_down_pointer(de); |
| | 950 | else goto error; |
| | 951 | hpfs_brelse4(&qbh); |
| | 952 | hpfs_free_dnode(s, dno); |
| | 953 | dno = d1; |
| | 954 | } else break; |
| | 955 | } |
| | 956 | if (!de->first) goto error; |
| | 957 | d1 = de->down ? de_down_pointer(de) : 0; |
| | 958 | de = de_next_de(de); |
| | 959 | if (!de->last) goto error; |
| | 960 | d2 = de->down ? de_down_pointer(de) : 0; |
| | 961 | hpfs_brelse4(&qbh); |
| | 962 | hpfs_free_dnode(s, dno); |
| | 963 | do { |
| | 964 | while (d1) { |
| | 965 | if (!(dnode = hpfs_map_dnode(s, dno = d1, &qbh))) return; |
| | 966 | de = dnode_first_de(dnode); |
| | 967 | if (!de->last) goto error; |
| | 968 | d1 = de->down ? de_down_pointer(de) : 0; |
| | 969 | hpfs_brelse4(&qbh); |
| | 970 | hpfs_free_dnode(s, dno); |
| | 971 | } |
| | 972 | d1 = d2; |
| | 973 | d2 = 0; |
| | 974 | } while (d1); |
| | 975 | return; |
| | 976 | error: |
| | 977 | hpfs_brelse4(&qbh); |
| | 978 | hpfs_free_dnode(s, dno); |
| | 979 | hpfs_error(s, "directory %08x is corrupted or not empty", rdno); |
| | 980 | } |
| | 981 | |
| | 982 | /* |
| | 983 | * Find dirent for specified fnode. Use truncated 15-char name in fnode as |
| | 984 | * a help for searching. |
| | 985 | */ |
| | 986 | |
| | 987 | struct hpfs_dirent *map_fnode_dirent(struct super_block *s, fnode_secno fno, |
| | 988 | struct fnode *f, struct quad_buffer_head *qbh) |
| | 989 | { |
| | 990 | unsigned char *name1; |
| | 991 | unsigned char *name2; |
| | 992 | int name1len, name2len; |
| | 993 | struct dnode *d; |
| | 994 | dnode_secno dno, downd; |
| | 995 | struct fnode *upf; |
| | 996 | struct buffer_head *bh; |
| | 997 | struct hpfs_dirent *de, *de_end; |
| | 998 | int c; |
| | 999 | int c1, c2 = 0; |
| | 1000 | int d1, d2 = 0; |
| | 1001 | name1 = f->name; |
| | 1002 | if (!(name2 = kmalloc(256, GFP_NOFS))) { |
| | 1003 | printk("HPFS: out of memory, can't map dirent\n"); |
| | 1004 | return NULL; |
| | 1005 | } |
| | 1006 | if (f->len <= 15) |
| | 1007 | memcpy(name2, name1, name1len = name2len = f->len); |
| | 1008 | else { |
| | 1009 | memcpy(name2, name1, 15); |
| | 1010 | memset(name2 + 15, 0xff, 256 - 15); |
| | 1011 | /*name2[15] = 0xff;*/ |
| | 1012 | name1len = 15; name2len = 256; |
| | 1013 | } |
| | 1014 | if (!(upf = hpfs_map_fnode(s, le32_to_cpu(f->up), &bh))) { |
| | 1015 | kfree(name2); |
| | 1016 | return NULL; |
| | 1017 | } |
| | 1018 | if (!fnode_is_dir(upf)) { |
| | 1019 | brelse(bh); |
| | 1020 | hpfs_error(s, "fnode %08x has non-directory parent %08x", fno, le32_to_cpu(f->up)); |
| | 1021 | kfree(name2); |
| | 1022 | return NULL; |
| | 1023 | } |
| | 1024 | dno = le32_to_cpu(upf->u.external[0].disk_secno); |
| | 1025 | brelse(bh); |
| | 1026 | go_down: |
| | 1027 | downd = 0; |
| | 1028 | go_up: |
| | 1029 | if (!(d = hpfs_map_dnode(s, dno, qbh))) { |
| | 1030 | kfree(name2); |
| | 1031 | return NULL; |
| | 1032 | } |
| | 1033 | de_end = dnode_end_de(d); |
| | 1034 | de = dnode_first_de(d); |
| | 1035 | if (downd) { |
| | 1036 | while (de < de_end) { |
| | 1037 | if (de->down) if (de_down_pointer(de) == downd) goto f; |
| | 1038 | de = de_next_de(de); |
| | 1039 | } |
| | 1040 | hpfs_error(s, "pointer to dnode %08x not found in dnode %08x", downd, dno); |
| | 1041 | hpfs_brelse4(qbh); |
| | 1042 | kfree(name2); |
| | 1043 | return NULL; |
| | 1044 | } |
| | 1045 | next_de: |
| | 1046 | if (le32_to_cpu(de->fnode) == fno) { |
| | 1047 | kfree(name2); |
| | 1048 | return de; |
| | 1049 | } |
| | 1050 | c = hpfs_compare_names(s, name1, name1len, de->name, de->namelen, de->last); |
| | 1051 | if (c < 0 && de->down) { |
| | 1052 | dno = de_down_pointer(de); |
| | 1053 | hpfs_brelse4(qbh); |
| | 1054 | if (hpfs_sb(s)->sb_chk) |
| | 1055 | if (hpfs_stop_cycles(s, dno, &c1, &c2, "map_fnode_dirent #1")) { |
| | 1056 | kfree(name2); |
| | 1057 | return NULL; |
| | 1058 | } |
| | 1059 | goto go_down; |
| | 1060 | } |
| | 1061 | f: |
| | 1062 | if (le32_to_cpu(de->fnode) == fno) { |
| | 1063 | kfree(name2); |
| | 1064 | return de; |
| | 1065 | } |
| | 1066 | c = hpfs_compare_names(s, name2, name2len, de->name, de->namelen, de->last); |
| | 1067 | if (c < 0 && !de->last) goto not_found; |
| | 1068 | if ((de = de_next_de(de)) < de_end) goto next_de; |
| | 1069 | if (d->root_dnode) goto not_found; |
| | 1070 | downd = dno; |
| | 1071 | dno = le32_to_cpu(d->up); |
| | 1072 | hpfs_brelse4(qbh); |
| | 1073 | if (hpfs_sb(s)->sb_chk) |
| | 1074 | if (hpfs_stop_cycles(s, downd, &d1, &d2, "map_fnode_dirent #2")) { |
| | 1075 | kfree(name2); |
| | 1076 | return NULL; |
| | 1077 | } |
| | 1078 | goto go_up; |
| | 1079 | not_found: |
| | 1080 | hpfs_brelse4(qbh); |
| | 1081 | hpfs_error(s, "dirent for fnode %08x not found", fno); |
| | 1082 | kfree(name2); |
| | 1083 | return NULL; |
| | 1084 | } |
projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame_incremental