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