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