?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.28.1
[linux/fpc-iii.git] / fs / jfs / jfs_xtree.c
blobae3acafb447b2bad3c4346bb9194b6d549dcd694
1 /*
2 * Copyright (C) International Business Machines Corp., 2000-2005
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12 * the GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 /*
19 * jfs_xtree.c: extent allocation descriptor B+-tree manager
20 */
21
22 #include <linux/fs.h>
23 #include <linux/module.h>
24 #include <linux/quotaops.h>
25 #include <linux/seq_file.h>
26 #include "jfs_incore.h"
27 #include "jfs_filsys.h"
28 #include "jfs_metapage.h"
29 #include "jfs_dmap.h"
30 #include "jfs_dinode.h"
31 #include "jfs_superblock.h"
32 #include "jfs_debug.h"
33
34 /*
35 * xtree local flag
36 */
37 #define XT_INSERT 0x00000001
38
39 /*
40 * xtree key/entry comparison: extent offset
41 *
42 * return:
43 * -1: k < start of extent
44 * 0: start_of_extent <= k <= end_of_extent
45 * 1: k > end_of_extent
46 */
47 #define XT_CMP(CMP, K, X, OFFSET64)\
48 {\
49 OFFSET64 = offsetXAD(X);\
50 (CMP) = ((K) >= OFFSET64 + lengthXAD(X)) ? 1 :\
51 ((K) < OFFSET64) ? -1 : 0;\
52 }
53
54 /* write a xad entry */
55 #define XT_PUTENTRY(XAD, FLAG, OFF, LEN, ADDR)\
56 {\
57 (XAD)->flag = (FLAG);\
58 XADoffset((XAD), (OFF));\
59 XADlength((XAD), (LEN));\
60 XADaddress((XAD), (ADDR));\
61 }
62
63 #define XT_PAGE(IP, MP) BT_PAGE(IP, MP, xtpage_t, i_xtroot)
64
65 /* get page buffer for specified block address */
66 /* ToDo: Replace this ugly macro with a function */
67 #define XT_GETPAGE(IP, BN, MP, SIZE, P, RC)\
68 {\
69 BT_GETPAGE(IP, BN, MP, xtpage_t, SIZE, P, RC, i_xtroot)\
70 if (!(RC))\
71 {\
72 if ((le16_to_cpu((P)->header.nextindex) < XTENTRYSTART) ||\
73 (le16_to_cpu((P)->header.nextindex) > le16_to_cpu((P)->header.maxentry)) ||\
74 (le16_to_cpu((P)->header.maxentry) > (((BN)==0)?XTROOTMAXSLOT:PSIZE>>L2XTSLOTSIZE)))\
75 {\
76 jfs_error((IP)->i_sb, "XT_GETPAGE: xtree page corrupt");\
77 BT_PUTPAGE(MP);\
78 MP = NULL;\
79 RC = -EIO;\
80 }\
81 }\
82 }
83
84 /* for consistency */
85 #define XT_PUTPAGE(MP) BT_PUTPAGE(MP)
86
87 #define XT_GETSEARCH(IP, LEAF, BN, MP, P, INDEX) \
88 BT_GETSEARCH(IP, LEAF, BN, MP, xtpage_t, P, INDEX, i_xtroot)
89 /* xtree entry parameter descriptor */
90 struct xtsplit {
91 struct metapage *mp;
92 s16 index;
93 u8 flag;
94 s64 off;
95 s64 addr;
96 int len;
97 struct pxdlist *pxdlist;
98 };
99
100
101 /*
102 * statistics
103 */
104 #ifdef CONFIG_JFS_STATISTICS
105 static struct {
106 uint search;
107 uint fastSearch;
108 uint split;
109 } xtStat;
110 #endif
111
112
113 /*
114 * forward references
115 */
116 static int xtSearch(struct inode *ip, s64 xoff, s64 *next, int *cmpp,
117 struct btstack * btstack, int flag);
118
119 static int xtSplitUp(tid_t tid,
120 struct inode *ip,
121 struct xtsplit * split, struct btstack * btstack);
122
123 static int xtSplitPage(tid_t tid, struct inode *ip, struct xtsplit * split,
124 struct metapage ** rmpp, s64 * rbnp);
125
126 static int xtSplitRoot(tid_t tid, struct inode *ip,
127 struct xtsplit * split, struct metapage ** rmpp);
128
129 #ifdef _STILL_TO_PORT
130 static int xtDeleteUp(tid_t tid, struct inode *ip, struct metapage * fmp,
131 xtpage_t * fp, struct btstack * btstack);
132
133 static int xtSearchNode(struct inode *ip,
134 xad_t * xad,
135 int *cmpp, struct btstack * btstack, int flag);
136
137 static int xtRelink(tid_t tid, struct inode *ip, xtpage_t * fp);
138 #endif /* _STILL_TO_PORT */
139
140 /*
141 * xtLookup()
142 *
143 * function: map a single page into a physical extent;
144 */
145 int xtLookup(struct inode *ip, s64 lstart,
146 s64 llen, int *pflag, s64 * paddr, s32 * plen, int no_check)
147 {
148 int rc = 0;
149 struct btstack btstack;
150 int cmp;
151 s64 bn;
152 struct metapage *mp;
153 xtpage_t *p;
154 int index;
155 xad_t *xad;
156 s64 next, size, xoff, xend;
157 int xlen;
158 s64 xaddr;
159
160 *paddr = 0;
161 *plen = llen;
162
163 if (!no_check) {
164 /* is lookup offset beyond eof ? */
165 size = ((u64) ip->i_size + (JFS_SBI(ip->i_sb)->bsize - 1)) >>
166 JFS_SBI(ip->i_sb)->l2bsize;
167 if (lstart >= size) {
168 jfs_err("xtLookup: lstart (0x%lx) >= size (0x%lx)",
169 (ulong) lstart, (ulong) size);
170 return 0;
171 }
172 }
173
174 /*
175 * search for the xad entry covering the logical extent
176 */
177 //search:
178 if ((rc = xtSearch(ip, lstart, &next, &cmp, &btstack, 0))) {
179 jfs_err("xtLookup: xtSearch returned %d", rc);
180 return rc;
181 }
182
183 /*
184 * compute the physical extent covering logical extent
185 *
186 * N.B. search may have failed (e.g., hole in sparse file),
187 * and returned the index of the next entry.
188 */
189 /* retrieve search result */
190 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
191
192 /* is xad found covering start of logical extent ?
193 * lstart is a page start address,
194 * i.e., lstart cannot start in a hole;
195 */
196 if (cmp) {
197 if (next)
198 *plen = min(next - lstart, llen);
199 goto out;
200 }
201
202 /*
203 * lxd covered by xad
204 */
205 xad = &p->xad[index];
206 xoff = offsetXAD(xad);
207 xlen = lengthXAD(xad);
208 xend = xoff + xlen;
209 xaddr = addressXAD(xad);
210
211 /* initialize new pxd */
212 *pflag = xad->flag;
213 *paddr = xaddr + (lstart - xoff);
214 /* a page must be fully covered by an xad */
215 *plen = min(xend - lstart, llen);
216
217 out:
218 XT_PUTPAGE(mp);
219
220 return rc;
221 }
222
223
224 /*
225 * xtLookupList()
226 *
227 * function: map a single logical extent into a list of physical extent;
228 *
229 * parameter:
230 * struct inode *ip,
231 * struct lxdlist *lxdlist, lxd list (in)
232 * struct xadlist *xadlist, xad list (in/out)
233 * int flag)
234 *
235 * coverage of lxd by xad under assumption of
236 * . lxd's are ordered and disjoint.
237 * . xad's are ordered and disjoint.
238 *
239 * return:
240 * 0: success
241 *
242 * note: a page being written (even a single byte) is backed fully,
243 * except the last page which is only backed with blocks
244 * required to cover the last byte;
245 * the extent backing a page is fully contained within an xad;
246 */
247 int xtLookupList(struct inode *ip, struct lxdlist * lxdlist,
248 struct xadlist * xadlist, int flag)
249 {
250 int rc = 0;
251 struct btstack btstack;
252 int cmp;
253 s64 bn;
254 struct metapage *mp;
255 xtpage_t *p;
256 int index;
257 lxd_t *lxd;
258 xad_t *xad, *pxd;
259 s64 size, lstart, lend, xstart, xend, pstart;
260 s64 llen, xlen, plen;
261 s64 xaddr, paddr;
262 int nlxd, npxd, maxnpxd;
263
264 npxd = xadlist->nxad = 0;
265 maxnpxd = xadlist->maxnxad;
266 pxd = xadlist->xad;
267
268 nlxd = lxdlist->nlxd;
269 lxd = lxdlist->lxd;
270
271 lstart = offsetLXD(lxd);
272 llen = lengthLXD(lxd);
273 lend = lstart + llen;
274
275 size = (ip->i_size + (JFS_SBI(ip->i_sb)->bsize - 1)) >>
276 JFS_SBI(ip->i_sb)->l2bsize;
277
278 /*
279 * search for the xad entry covering the logical extent
280 */
281 search:
282 if (lstart >= size)
283 return 0;
284
285 if ((rc = xtSearch(ip, lstart, NULL, &cmp, &btstack, 0)))
286 return rc;
287
288 /*
289 * compute the physical extent covering logical extent
290 *
291 * N.B. search may have failed (e.g., hole in sparse file),
292 * and returned the index of the next entry.
293 */
294 //map:
295 /* retrieve search result */
296 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
297
298 /* is xad on the next sibling page ? */
299 if (index == le16_to_cpu(p->header.nextindex)) {
300 if (p->header.flag & BT_ROOT)
301 goto mapend;
302
303 if ((bn = le64_to_cpu(p->header.next)) == 0)
304 goto mapend;
305
306 XT_PUTPAGE(mp);
307
308 /* get next sibling page */
309 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
310 if (rc)
311 return rc;
312
313 index = XTENTRYSTART;
314 }
315
316 xad = &p->xad[index];
317
318 /*
319 * is lxd covered by xad ?
320 */
321 compare:
322 xstart = offsetXAD(xad);
323 xlen = lengthXAD(xad);
324 xend = xstart + xlen;
325 xaddr = addressXAD(xad);
326
327 compare1:
328 if (xstart < lstart)
329 goto compare2;
330
331 /* (lstart <= xstart) */
332
333 /* lxd is NOT covered by xad */
334 if (lend <= xstart) {
335 /*
336 * get next lxd
337 */
338 if (--nlxd == 0)
339 goto mapend;
340 lxd++;
341
342 lstart = offsetLXD(lxd);
343 llen = lengthLXD(lxd);
344 lend = lstart + llen;
345 if (lstart >= size)
346 goto mapend;
347
348 /* compare with the current xad */
349 goto compare1;
350 }
351 /* lxd is covered by xad */
352 else { /* (xstart < lend) */
353
354 /* initialize new pxd */
355 pstart = xstart;
356 plen = min(lend - xstart, xlen);
357 paddr = xaddr;
358
359 goto cover;
360 }
361
362 /* (xstart < lstart) */
363 compare2:
364 /* lxd is covered by xad */
365 if (lstart < xend) {
366 /* initialize new pxd */
367 pstart = lstart;
368 plen = min(xend - lstart, llen);
369 paddr = xaddr + (lstart - xstart);
370
371 goto cover;
372 }
373 /* lxd is NOT covered by xad */
374 else { /* (xend <= lstart) */
375
376 /*
377 * get next xad
378 *
379 * linear search next xad covering lxd on
380 * the current xad page, and then tree search
381 */
382 if (index == le16_to_cpu(p->header.nextindex) - 1) {
383 if (p->header.flag & BT_ROOT)
384 goto mapend;
385
386 XT_PUTPAGE(mp);
387 goto search;
388 } else {
389 index++;
390 xad++;
391
392 /* compare with new xad */
393 goto compare;
394 }
395 }
396
397 /*
398 * lxd is covered by xad and a new pxd has been initialized
399 * (lstart <= xstart < lend) or (xstart < lstart < xend)
400 */
401 cover:
402 /* finalize pxd corresponding to current xad */
403 XT_PUTENTRY(pxd, xad->flag, pstart, plen, paddr);
404
405 if (++npxd >= maxnpxd)
406 goto mapend;
407 pxd++;
408
409 /*
410 * lxd is fully covered by xad
411 */
412 if (lend <= xend) {
413 /*
414 * get next lxd
415 */
416 if (--nlxd == 0)
417 goto mapend;
418 lxd++;
419
420 lstart = offsetLXD(lxd);
421 llen = lengthLXD(lxd);
422 lend = lstart + llen;
423 if (lstart >= size)
424 goto mapend;
425
426 /*
427 * test for old xad covering new lxd
428 * (old xstart < new lstart)
429 */
430 goto compare2;
431 }
432 /*
433 * lxd is partially covered by xad
434 */
435 else { /* (xend < lend) */
436
437 /*
438 * get next xad
439 *
440 * linear search next xad covering lxd on
441 * the current xad page, and then next xad page search
442 */
443 if (index == le16_to_cpu(p->header.nextindex) - 1) {
444 if (p->header.flag & BT_ROOT)
445 goto mapend;
446
447 if ((bn = le64_to_cpu(p->header.next)) == 0)
448 goto mapend;
449
450 XT_PUTPAGE(mp);
451
452 /* get next sibling page */
453 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
454 if (rc)
455 return rc;
456
457 index = XTENTRYSTART;
458 xad = &p->xad[index];
459 } else {
460 index++;
461 xad++;
462 }
463
464 /*
465 * test for new xad covering old lxd
466 * (old lstart < new xstart)
467 */
468 goto compare;
469 }
470
471 mapend:
472 xadlist->nxad = npxd;
473
474 //out:
475 XT_PUTPAGE(mp);
476
477 return rc;
478 }
479
480
481 /*
482 * xtSearch()
483 *
484 * function: search for the xad entry covering specified offset.
485 *
486 * parameters:
487 * ip - file object;
488 * xoff - extent offset;
489 * nextp - address of next extent (if any) for search miss
490 * cmpp - comparison result:
491 * btstack - traverse stack;
492 * flag - search process flag (XT_INSERT);
493 *
494 * returns:
495 * btstack contains (bn, index) of search path traversed to the entry.
496 * *cmpp is set to result of comparison with the entry returned.
497 * the page containing the entry is pinned at exit.
498 */
499 static int xtSearch(struct inode *ip, s64 xoff, s64 *nextp,
500 int *cmpp, struct btstack * btstack, int flag)
501 {
502 struct jfs_inode_info *jfs_ip = JFS_IP(ip);
503 int rc = 0;
504 int cmp = 1; /* init for empty page */
505 s64 bn; /* block number */
506 struct metapage *mp; /* page buffer */
507 xtpage_t *p; /* page */
508 xad_t *xad;
509 int base, index, lim, btindex;
510 struct btframe *btsp;
511 int nsplit = 0; /* number of pages to split */
512 s64 t64;
513 s64 next = 0;
514
515 INCREMENT(xtStat.search);
516
517 BT_CLR(btstack);
518
519 btstack->nsplit = 0;
520
521 /*
522 * search down tree from root:
523 *
524 * between two consecutive entries of <Ki, Pi> and <Kj, Pj> of
525 * internal page, child page Pi contains entry with k, Ki <= K < Kj.
526 *
527 * if entry with search key K is not found
528 * internal page search find the entry with largest key Ki
529 * less than K which point to the child page to search;
530 * leaf page search find the entry with smallest key Kj
531 * greater than K so that the returned index is the position of
532 * the entry to be shifted right for insertion of new entry.
533 * for empty tree, search key is greater than any key of the tree.
534 *
535 * by convention, root bn = 0.
536 */
537 for (bn = 0;;) {
538 /* get/pin the page to search */
539 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
540 if (rc)
541 return rc;
542
543 /* try sequential access heuristics with the previous
544 * access entry in target leaf page:
545 * once search narrowed down into the target leaf,
546 * key must either match an entry in the leaf or
547 * key entry does not exist in the tree;
548 */
549 //fastSearch:
550 if ((jfs_ip->btorder & BT_SEQUENTIAL) &&
551 (p->header.flag & BT_LEAF) &&
552 (index = jfs_ip->btindex) <
553 le16_to_cpu(p->header.nextindex)) {
554 xad = &p->xad[index];
555 t64 = offsetXAD(xad);
556 if (xoff < t64 + lengthXAD(xad)) {
557 if (xoff >= t64) {
558 *cmpp = 0;
559 goto out;
560 }
561
562 /* stop sequential access heuristics */
563 goto binarySearch;
564 } else { /* (t64 + lengthXAD(xad)) <= xoff */
565
566 /* try next sequential entry */
567 index++;
568 if (index <
569 le16_to_cpu(p->header.nextindex)) {
570 xad++;
571 t64 = offsetXAD(xad);
572 if (xoff < t64 + lengthXAD(xad)) {
573 if (xoff >= t64) {
574 *cmpp = 0;
575 goto out;
576 }
577
578 /* miss: key falls between
579 * previous and this entry
580 */
581 *cmpp = 1;
582 next = t64;
583 goto out;
584 }
585
586 /* (xoff >= t64 + lengthXAD(xad));
587 * matching entry may be further out:
588 * stop heuristic search
589 */
590 /* stop sequential access heuristics */
591 goto binarySearch;
592 }
593
594 /* (index == p->header.nextindex);
595 * miss: key entry does not exist in
596 * the target leaf/tree
597 */
598 *cmpp = 1;
599 goto out;
600 }
601
602 /*
603 * if hit, return index of the entry found, and
604 * if miss, where new entry with search key is
605 * to be inserted;
606 */
607 out:
608 /* compute number of pages to split */
609 if (flag & XT_INSERT) {
610 if (p->header.nextindex == /* little-endian */
611 p->header.maxentry)
612 nsplit++;
613 else
614 nsplit = 0;
615 btstack->nsplit = nsplit;
616 }
617
618 /* save search result */
619 btsp = btstack->top;
620 btsp->bn = bn;
621 btsp->index = index;
622 btsp->mp = mp;
623
624 /* update sequential access heuristics */
625 jfs_ip->btindex = index;
626
627 if (nextp)
628 *nextp = next;
629
630 INCREMENT(xtStat.fastSearch);
631 return 0;
632 }
633
634 /* well, ... full search now */
635 binarySearch:
636 lim = le16_to_cpu(p->header.nextindex) - XTENTRYSTART;
637
638 /*
639 * binary search with search key K on the current page
640 */
641 for (base = XTENTRYSTART; lim; lim >>= 1) {
642 index = base + (lim >> 1);
643
644 XT_CMP(cmp, xoff, &p->xad[index], t64);
645 if (cmp == 0) {
646 /*
647 * search hit
648 */
649 /* search hit - leaf page:
650 * return the entry found
651 */
652 if (p->header.flag & BT_LEAF) {
653 *cmpp = cmp;
654
655 /* compute number of pages to split */
656 if (flag & XT_INSERT) {
657 if (p->header.nextindex ==
658 p->header.maxentry)
659 nsplit++;
660 else
661 nsplit = 0;
662 btstack->nsplit = nsplit;
663 }
664
665 /* save search result */
666 btsp = btstack->top;
667 btsp->bn = bn;
668 btsp->index = index;
669 btsp->mp = mp;
670
671 /* init sequential access heuristics */
672 btindex = jfs_ip->btindex;
673 if (index == btindex ||
674 index == btindex + 1)
675 jfs_ip->btorder = BT_SEQUENTIAL;
676 else
677 jfs_ip->btorder = BT_RANDOM;
678 jfs_ip->btindex = index;
679
680 return 0;
681 }
682 /* search hit - internal page:
683 * descend/search its child page
684 */
685 if (index < le16_to_cpu(p->header.nextindex)-1)
686 next = offsetXAD(&p->xad[index + 1]);
687 goto next;
688 }
689
690 if (cmp > 0) {
691 base = index + 1;
692 --lim;
693 }
694 }
695
696 /*
697 * search miss
698 *
699 * base is the smallest index with key (Kj) greater than
700 * search key (K) and may be zero or maxentry index.
701 */
702 if (base < le16_to_cpu(p->header.nextindex))
703 next = offsetXAD(&p->xad[base]);
704 /*
705 * search miss - leaf page:
706 *
707 * return location of entry (base) where new entry with
708 * search key K is to be inserted.
709 */
710 if (p->header.flag & BT_LEAF) {
711 *cmpp = cmp;
712
713 /* compute number of pages to split */
714 if (flag & XT_INSERT) {
715 if (p->header.nextindex ==
716 p->header.maxentry)
717 nsplit++;
718 else
719 nsplit = 0;
720 btstack->nsplit = nsplit;
721 }
722
723 /* save search result */
724 btsp = btstack->top;
725 btsp->bn = bn;
726 btsp->index = base;
727 btsp->mp = mp;
728
729 /* init sequential access heuristics */
730 btindex = jfs_ip->btindex;
731 if (base == btindex || base == btindex + 1)
732 jfs_ip->btorder = BT_SEQUENTIAL;
733 else
734 jfs_ip->btorder = BT_RANDOM;
735 jfs_ip->btindex = base;
736
737 if (nextp)
738 *nextp = next;
739
740 return 0;
741 }
742
743 /*
744 * search miss - non-leaf page:
745 *
746 * if base is non-zero, decrement base by one to get the parent
747 * entry of the child page to search.
748 */
749 index = base ? base - 1 : base;
750
751 /*
752 * go down to child page
753 */
754 next:
755 /* update number of pages to split */
756 if (p->header.nextindex == p->header.maxentry)
757 nsplit++;
758 else
759 nsplit = 0;
760
761 /* push (bn, index) of the parent page/entry */
762 if (BT_STACK_FULL(btstack)) {
763 jfs_error(ip->i_sb, "stack overrun in xtSearch!");
764 XT_PUTPAGE(mp);
765 return -EIO;
766 }
767 BT_PUSH(btstack, bn, index);
768
769 /* get the child page block number */
770 bn = addressXAD(&p->xad[index]);
771
772 /* unpin the parent page */
773 XT_PUTPAGE(mp);
774 }
775 }
776
777 /*
778 * xtInsert()
779 *
780 * function:
781 *
782 * parameter:
783 * tid - transaction id;
784 * ip - file object;
785 * xflag - extent flag (XAD_NOTRECORDED):
786 * xoff - extent offset;
787 * xlen - extent length;
788 * xaddrp - extent address pointer (in/out):
789 * if (*xaddrp)
790 * caller allocated data extent at *xaddrp;
791 * else
792 * allocate data extent and return its xaddr;
793 * flag -
794 *
795 * return:
796 */
797 int xtInsert(tid_t tid, /* transaction id */
798 struct inode *ip, int xflag, s64 xoff, s32 xlen, s64 * xaddrp,
799 int flag)
800 {
801 int rc = 0;
802 s64 xaddr, hint;
803 struct metapage *mp; /* meta-page buffer */
804 xtpage_t *p; /* base B+-tree index page */
805 s64 bn;
806 int index, nextindex;
807 struct btstack btstack; /* traverse stack */
808 struct xtsplit split; /* split information */
809 xad_t *xad;
810 int cmp;
811 s64 next;
812 struct tlock *tlck;
813 struct xtlock *xtlck;
814
815 jfs_info("xtInsert: nxoff:0x%lx nxlen:0x%x", (ulong) xoff, xlen);
816
817 /*
818 * search for the entry location at which to insert:
819 *
820 * xtFastSearch() and xtSearch() both returns (leaf page
821 * pinned, index at which to insert).
822 * n.b. xtSearch() may return index of maxentry of
823 * the full page.
824 */
825 if ((rc = xtSearch(ip, xoff, &next, &cmp, &btstack, XT_INSERT)))
826 return rc;
827
828 /* retrieve search result */
829 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
830
831 /* This test must follow XT_GETSEARCH since mp must be valid if
832 * we branch to out: */
833 if ((cmp == 0) || (next && (xlen > next - xoff))) {
834 rc = -EEXIST;
835 goto out;
836 }
837
838 /*
839 * allocate data extent requested
840 *
841 * allocation hint: last xad
842 */
843 if ((xaddr = *xaddrp) == 0) {
844 if (index > XTENTRYSTART) {
845 xad = &p->xad[index - 1];
846 hint = addressXAD(xad) + lengthXAD(xad) - 1;
847 } else
848 hint = 0;
849 if ((rc = DQUOT_ALLOC_BLOCK(ip, xlen)))
850 goto out;
851 if ((rc = dbAlloc(ip, hint, (s64) xlen, &xaddr))) {
852 DQUOT_FREE_BLOCK(ip, xlen);
853 goto out;
854 }
855 }
856
857 /*
858 * insert entry for new extent
859 */
860 xflag |= XAD_NEW;
861
862 /*
863 * if the leaf page is full, split the page and
864 * propagate up the router entry for the new page from split
865 *
866 * The xtSplitUp() will insert the entry and unpin the leaf page.
867 */
868 nextindex = le16_to_cpu(p->header.nextindex);
869 if (nextindex == le16_to_cpu(p->header.maxentry)) {
870 split.mp = mp;
871 split.index = index;
872 split.flag = xflag;
873 split.off = xoff;
874 split.len = xlen;
875 split.addr = xaddr;
876 split.pxdlist = NULL;
877 if ((rc = xtSplitUp(tid, ip, &split, &btstack))) {
878 /* undo data extent allocation */
879 if (*xaddrp == 0) {
880 dbFree(ip, xaddr, (s64) xlen);
881 DQUOT_FREE_BLOCK(ip, xlen);
882 }
883 return rc;
884 }
885
886 *xaddrp = xaddr;
887 return 0;
888 }
889
890 /*
891 * insert the new entry into the leaf page
892 */
893 /*
894 * acquire a transaction lock on the leaf page;
895 *
896 * action: xad insertion/extension;
897 */
898 BT_MARK_DIRTY(mp, ip);
899
900 /* if insert into middle, shift right remaining entries. */
901 if (index < nextindex)
902 memmove(&p->xad[index + 1], &p->xad[index],
903 (nextindex - index) * sizeof(xad_t));
904
905 /* insert the new entry: mark the entry NEW */
906 xad = &p->xad[index];
907 XT_PUTENTRY(xad, xflag, xoff, xlen, xaddr);
908
909 /* advance next available entry index */
910 le16_add_cpu(&p->header.nextindex, 1);
911
912 /* Don't log it if there are no links to the file */
913 if (!test_cflag(COMMIT_Nolink, ip)) {
914 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
915 xtlck = (struct xtlock *) & tlck->lock;
916 xtlck->lwm.offset =
917 (xtlck->lwm.offset) ? min(index,
918 (int)xtlck->lwm.offset) : index;
919 xtlck->lwm.length =
920 le16_to_cpu(p->header.nextindex) - xtlck->lwm.offset;
921 }
922
923 *xaddrp = xaddr;
924
925 out:
926 /* unpin the leaf page */
927 XT_PUTPAGE(mp);
928
929 return rc;
930 }
931
932
933 /*
934 * xtSplitUp()
935 *
936 * function:
937 * split full pages as propagating insertion up the tree
938 *
939 * parameter:
940 * tid - transaction id;
941 * ip - file object;
942 * split - entry parameter descriptor;
943 * btstack - traverse stack from xtSearch()
944 *
945 * return:
946 */
947 static int
948 xtSplitUp(tid_t tid,
949 struct inode *ip, struct xtsplit * split, struct btstack * btstack)
950 {
951 int rc = 0;
952 struct metapage *smp;
953 xtpage_t *sp; /* split page */
954 struct metapage *rmp;
955 s64 rbn; /* new right page block number */
956 struct metapage *rcmp;
957 xtpage_t *rcp; /* right child page */
958 s64 rcbn; /* right child page block number */
959 int skip; /* index of entry of insertion */
960 int nextindex; /* next available entry index of p */
961 struct btframe *parent; /* parent page entry on traverse stack */
962 xad_t *xad;
963 s64 xaddr;
964 int xlen;
965 int nsplit; /* number of pages split */
966 struct pxdlist pxdlist;
967 pxd_t *pxd;
968 struct tlock *tlck;
969 struct xtlock *xtlck;
970
971 smp = split->mp;
972 sp = XT_PAGE(ip, smp);
973
974 /* is inode xtree root extension/inline EA area free ? */
975 if ((sp->header.flag & BT_ROOT) && (!S_ISDIR(ip->i_mode)) &&
976 (le16_to_cpu(sp->header.maxentry) < XTROOTMAXSLOT) &&
977 (JFS_IP(ip)->mode2 & INLINEEA)) {
978 sp->header.maxentry = cpu_to_le16(XTROOTMAXSLOT);
979 JFS_IP(ip)->mode2 &= ~INLINEEA;
980
981 BT_MARK_DIRTY(smp, ip);
982 /*
983 * acquire a transaction lock on the leaf page;
984 *
985 * action: xad insertion/extension;
986 */
987
988 /* if insert into middle, shift right remaining entries. */
989 skip = split->index;
990 nextindex = le16_to_cpu(sp->header.nextindex);
991 if (skip < nextindex)
992 memmove(&sp->xad[skip + 1], &sp->xad[skip],
993 (nextindex - skip) * sizeof(xad_t));
994
995 /* insert the new entry: mark the entry NEW */
996 xad = &sp->xad[skip];
997 XT_PUTENTRY(xad, split->flag, split->off, split->len,
998 split->addr);
999
1000 /* advance next available entry index */
1001 le16_add_cpu(&sp->header.nextindex, 1);
1002
1003 /* Don't log it if there are no links to the file */
1004 if (!test_cflag(COMMIT_Nolink, ip)) {
1005 tlck = txLock(tid, ip, smp, tlckXTREE | tlckGROW);
1006 xtlck = (struct xtlock *) & tlck->lock;
1007 xtlck->lwm.offset = (xtlck->lwm.offset) ?
1008 min(skip, (int)xtlck->lwm.offset) : skip;
1009 xtlck->lwm.length =
1010 le16_to_cpu(sp->header.nextindex) -
1011 xtlck->lwm.offset;
1012 }
1013
1014 return 0;
1015 }
1016
1017 /*
1018 * allocate new index blocks to cover index page split(s)
1019 *
1020 * allocation hint: ?
1021 */
1022 if (split->pxdlist == NULL) {
1023 nsplit = btstack->nsplit;
1024 split->pxdlist = &pxdlist;
1025 pxdlist.maxnpxd = pxdlist.npxd = 0;
1026 pxd = &pxdlist.pxd[0];
1027 xlen = JFS_SBI(ip->i_sb)->nbperpage;
1028 for (; nsplit > 0; nsplit--, pxd++) {
1029 if ((rc = dbAlloc(ip, (s64) 0, (s64) xlen, &xaddr))
1030 == 0) {
1031 PXDaddress(pxd, xaddr);
1032 PXDlength(pxd, xlen);
1033
1034 pxdlist.maxnpxd++;
1035
1036 continue;
1037 }
1038
1039 /* undo allocation */
1040
1041 XT_PUTPAGE(smp);
1042 return rc;
1043 }
1044 }
1045
1046 /*
1047 * Split leaf page <sp> into <sp> and a new right page <rp>.
1048 *
1049 * The split routines insert the new entry into the leaf page,
1050 * and acquire txLock as appropriate.
1051 * return <rp> pinned and its block number <rpbn>.
1052 */
1053 rc = (sp->header.flag & BT_ROOT) ?
1054 xtSplitRoot(tid, ip, split, &rmp) :
1055 xtSplitPage(tid, ip, split, &rmp, &rbn);
1056
1057 XT_PUTPAGE(smp);
1058
1059 if (rc)
1060 return -EIO;
1061 /*
1062 * propagate up the router entry for the leaf page just split
1063 *
1064 * insert a router entry for the new page into the parent page,
1065 * propagate the insert/split up the tree by walking back the stack
1066 * of (bn of parent page, index of child page entry in parent page)
1067 * that were traversed during the search for the page that split.
1068 *
1069 * the propagation of insert/split up the tree stops if the root
1070 * splits or the page inserted into doesn't have to split to hold
1071 * the new entry.
1072 *
1073 * the parent entry for the split page remains the same, and
1074 * a new entry is inserted at its right with the first key and
1075 * block number of the new right page.
1076 *
1077 * There are a maximum of 3 pages pinned at any time:
1078 * right child, left parent and right parent (when the parent splits)
1079 * to keep the child page pinned while working on the parent.
1080 * make sure that all pins are released at exit.
1081 */
1082 while ((parent = BT_POP(btstack)) != NULL) {
1083 /* parent page specified by stack frame <parent> */
1084
1085 /* keep current child pages <rcp> pinned */
1086 rcmp = rmp;
1087 rcbn = rbn;
1088 rcp = XT_PAGE(ip, rcmp);
1089
1090 /*
1091 * insert router entry in parent for new right child page <rp>
1092 */
1093 /* get/pin the parent page <sp> */
1094 XT_GETPAGE(ip, parent->bn, smp, PSIZE, sp, rc);
1095 if (rc) {
1096 XT_PUTPAGE(rcmp);
1097 return rc;
1098 }
1099
1100 /*
1101 * The new key entry goes ONE AFTER the index of parent entry,
1102 * because the split was to the right.
1103 */
1104 skip = parent->index + 1;
1105
1106 /*
1107 * split or shift right remaining entries of the parent page
1108 */
1109 nextindex = le16_to_cpu(sp->header.nextindex);
1110 /*
1111 * parent page is full - split the parent page
1112 */
1113 if (nextindex == le16_to_cpu(sp->header.maxentry)) {
1114 /* init for parent page split */
1115 split->mp = smp;
1116 split->index = skip; /* index at insert */
1117 split->flag = XAD_NEW;
1118 split->off = offsetXAD(&rcp->xad[XTENTRYSTART]);
1119 split->len = JFS_SBI(ip->i_sb)->nbperpage;
1120 split->addr = rcbn;
1121
1122 /* unpin previous right child page */
1123 XT_PUTPAGE(rcmp);
1124
1125 /* The split routines insert the new entry,
1126 * and acquire txLock as appropriate.
1127 * return <rp> pinned and its block number <rpbn>.
1128 */
1129 rc = (sp->header.flag & BT_ROOT) ?
1130 xtSplitRoot(tid, ip, split, &rmp) :
1131 xtSplitPage(tid, ip, split, &rmp, &rbn);
1132 if (rc) {
1133 XT_PUTPAGE(smp);
1134 return rc;
1135 }
1136
1137 XT_PUTPAGE(smp);
1138 /* keep new child page <rp> pinned */
1139 }
1140 /*
1141 * parent page is not full - insert in parent page
1142 */
1143 else {
1144 /*
1145 * insert router entry in parent for the right child
1146 * page from the first entry of the right child page:
1147 */
1148 /*
1149 * acquire a transaction lock on the parent page;
1150 *
1151 * action: router xad insertion;
1152 */
1153 BT_MARK_DIRTY(smp, ip);
1154
1155 /*
1156 * if insert into middle, shift right remaining entries
1157 */
1158 if (skip < nextindex)
1159 memmove(&sp->xad[skip + 1], &sp->xad[skip],
1160 (nextindex -
1161 skip) << L2XTSLOTSIZE);
1162
1163 /* insert the router entry */
1164 xad = &sp->xad[skip];
1165 XT_PUTENTRY(xad, XAD_NEW,
1166 offsetXAD(&rcp->xad[XTENTRYSTART]),
1167 JFS_SBI(ip->i_sb)->nbperpage, rcbn);
1168
1169 /* advance next available entry index. */
1170 le16_add_cpu(&sp->header.nextindex, 1);
1171
1172 /* Don't log it if there are no links to the file */
1173 if (!test_cflag(COMMIT_Nolink, ip)) {
1174 tlck = txLock(tid, ip, smp,
1175 tlckXTREE | tlckGROW);
1176 xtlck = (struct xtlock *) & tlck->lock;
1177 xtlck->lwm.offset = (xtlck->lwm.offset) ?
1178 min(skip, (int)xtlck->lwm.offset) : skip;
1179 xtlck->lwm.length =
1180 le16_to_cpu(sp->header.nextindex) -
1181 xtlck->lwm.offset;
1182 }
1183
1184 /* unpin parent page */
1185 XT_PUTPAGE(smp);
1186
1187 /* exit propagate up */
1188 break;
1189 }
1190 }
1191
1192 /* unpin current right page */
1193 XT_PUTPAGE(rmp);
1194
1195 return 0;
1196 }
1197
1198
1199 /*
1200 * xtSplitPage()
1201 *
1202 * function:
1203 * split a full non-root page into
1204 * original/split/left page and new right page
1205 * i.e., the original/split page remains as left page.
1206 *
1207 * parameter:
1208 * int tid,
1209 * struct inode *ip,
1210 * struct xtsplit *split,
1211 * struct metapage **rmpp,
1212 * u64 *rbnp,
1213 *
1214 * return:
1215 * Pointer to page in which to insert or NULL on error.
1216 */
1217 static int
1218 xtSplitPage(tid_t tid, struct inode *ip,
1219 struct xtsplit * split, struct metapage ** rmpp, s64 * rbnp)
1220 {
1221 int rc = 0;
1222 struct metapage *smp;
1223 xtpage_t *sp;
1224 struct metapage *rmp;
1225 xtpage_t *rp; /* new right page allocated */
1226 s64 rbn; /* new right page block number */
1227 struct metapage *mp;
1228 xtpage_t *p;
1229 s64 nextbn;
1230 int skip, maxentry, middle, righthalf, n;
1231 xad_t *xad;
1232 struct pxdlist *pxdlist;
1233 pxd_t *pxd;
1234 struct tlock *tlck;
1235 struct xtlock *sxtlck = NULL, *rxtlck = NULL;
1236 int quota_allocation = 0;
1237
1238 smp = split->mp;
1239 sp = XT_PAGE(ip, smp);
1240
1241 INCREMENT(xtStat.split);
1242
1243 pxdlist = split->pxdlist;
1244 pxd = &pxdlist->pxd[pxdlist->npxd];
1245 pxdlist->npxd++;
1246 rbn = addressPXD(pxd);
1247
1248 /* Allocate blocks to quota. */
1249 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
1250 rc = -EDQUOT;
1251 goto clean_up;
1252 }
1253
1254 quota_allocation += lengthPXD(pxd);
1255
1256 /*
1257 * allocate the new right page for the split
1258 */
1259 rmp = get_metapage(ip, rbn, PSIZE, 1);
1260 if (rmp == NULL) {
1261 rc = -EIO;
1262 goto clean_up;
1263 }
1264
1265 jfs_info("xtSplitPage: ip:0x%p smp:0x%p rmp:0x%p", ip, smp, rmp);
1266
1267 BT_MARK_DIRTY(rmp, ip);
1268 /*
1269 * action: new page;
1270 */
1271
1272 rp = (xtpage_t *) rmp->data;
1273 rp->header.self = *pxd;
1274 rp->header.flag = sp->header.flag & BT_TYPE;
1275 rp->header.maxentry = sp->header.maxentry; /* little-endian */
1276 rp->header.nextindex = cpu_to_le16(XTENTRYSTART);
1277
1278 BT_MARK_DIRTY(smp, ip);
1279 /* Don't log it if there are no links to the file */
1280 if (!test_cflag(COMMIT_Nolink, ip)) {
1281 /*
1282 * acquire a transaction lock on the new right page;
1283 */
1284 tlck = txLock(tid, ip, rmp, tlckXTREE | tlckNEW);
1285 rxtlck = (struct xtlock *) & tlck->lock;
1286 rxtlck->lwm.offset = XTENTRYSTART;
1287 /*
1288 * acquire a transaction lock on the split page
1289 */
1290 tlck = txLock(tid, ip, smp, tlckXTREE | tlckGROW);
1291 sxtlck = (struct xtlock *) & tlck->lock;
1292 }
1293
1294 /*
1295 * initialize/update sibling pointers of <sp> and <rp>
1296 */
1297 nextbn = le64_to_cpu(sp->header.next);
1298 rp->header.next = cpu_to_le64(nextbn);
1299 rp->header.prev = cpu_to_le64(addressPXD(&sp->header.self));
1300 sp->header.next = cpu_to_le64(rbn);
1301
1302 skip = split->index;
1303
1304 /*
1305 * sequential append at tail (after last entry of last page)
1306 *
1307 * if splitting the last page on a level because of appending
1308 * a entry to it (skip is maxentry), it's likely that the access is
1309 * sequential. adding an empty page on the side of the level is less
1310 * work and can push the fill factor much higher than normal.
1311 * if we're wrong it's no big deal - we will do the split the right
1312 * way next time.
1313 * (it may look like it's equally easy to do a similar hack for
1314 * reverse sorted data, that is, split the tree left, but it's not.
1315 * Be my guest.)
1316 */
1317 if (nextbn == 0 && skip == le16_to_cpu(sp->header.maxentry)) {
1318 /*
1319 * acquire a transaction lock on the new/right page;
1320 *
1321 * action: xad insertion;
1322 */
1323 /* insert entry at the first entry of the new right page */
1324 xad = &rp->xad[XTENTRYSTART];
1325 XT_PUTENTRY(xad, split->flag, split->off, split->len,
1326 split->addr);
1327
1328 rp->header.nextindex = cpu_to_le16(XTENTRYSTART + 1);
1329
1330 if (!test_cflag(COMMIT_Nolink, ip)) {
1331 /* rxtlck->lwm.offset = XTENTRYSTART; */
1332 rxtlck->lwm.length = 1;
1333 }
1334
1335 *rmpp = rmp;
1336 *rbnp = rbn;
1337
1338 jfs_info("xtSplitPage: sp:0x%p rp:0x%p", sp, rp);
1339 return 0;
1340 }
1341
1342 /*
1343 * non-sequential insert (at possibly middle page)
1344 */
1345
1346 /*
1347 * update previous pointer of old next/right page of <sp>
1348 */
1349 if (nextbn != 0) {
1350 XT_GETPAGE(ip, nextbn, mp, PSIZE, p, rc);
1351 if (rc) {
1352 XT_PUTPAGE(rmp);
1353 goto clean_up;
1354 }
1355
1356 BT_MARK_DIRTY(mp, ip);
1357 /*
1358 * acquire a transaction lock on the next page;
1359 *
1360 * action:sibling pointer update;
1361 */
1362 if (!test_cflag(COMMIT_Nolink, ip))
1363 tlck = txLock(tid, ip, mp, tlckXTREE | tlckRELINK);
1364
1365 p->header.prev = cpu_to_le64(rbn);
1366
1367 /* sibling page may have been updated previously, or
1368 * it may be updated later;
1369 */
1370
1371 XT_PUTPAGE(mp);
1372 }
1373
1374 /*
1375 * split the data between the split and new/right pages
1376 */
1377 maxentry = le16_to_cpu(sp->header.maxentry);
1378 middle = maxentry >> 1;
1379 righthalf = maxentry - middle;
1380
1381 /*
1382 * skip index in old split/left page - insert into left page:
1383 */
1384 if (skip <= middle) {
1385 /* move right half of split page to the new right page */
1386 memmove(&rp->xad[XTENTRYSTART], &sp->xad[middle],
1387 righthalf << L2XTSLOTSIZE);
1388
1389 /* shift right tail of left half to make room for new entry */
1390 if (skip < middle)
1391 memmove(&sp->xad[skip + 1], &sp->xad[skip],
1392 (middle - skip) << L2XTSLOTSIZE);
1393
1394 /* insert new entry */
1395 xad = &sp->xad[skip];
1396 XT_PUTENTRY(xad, split->flag, split->off, split->len,
1397 split->addr);
1398
1399 /* update page header */
1400 sp->header.nextindex = cpu_to_le16(middle + 1);
1401 if (!test_cflag(COMMIT_Nolink, ip)) {
1402 sxtlck->lwm.offset = (sxtlck->lwm.offset) ?
1403 min(skip, (int)sxtlck->lwm.offset) : skip;
1404 }
1405
1406 rp->header.nextindex =
1407 cpu_to_le16(XTENTRYSTART + righthalf);
1408 }
1409 /*
1410 * skip index in new right page - insert into right page:
1411 */
1412 else {
1413 /* move left head of right half to right page */
1414 n = skip - middle;
1415 memmove(&rp->xad[XTENTRYSTART], &sp->xad[middle],
1416 n << L2XTSLOTSIZE);
1417
1418 /* insert new entry */
1419 n += XTENTRYSTART;
1420 xad = &rp->xad[n];
1421 XT_PUTENTRY(xad, split->flag, split->off, split->len,
1422 split->addr);
1423
1424 /* move right tail of right half to right page */
1425 if (skip < maxentry)
1426 memmove(&rp->xad[n + 1], &sp->xad[skip],
1427 (maxentry - skip) << L2XTSLOTSIZE);
1428
1429 /* update page header */
1430 sp->header.nextindex = cpu_to_le16(middle);
1431 if (!test_cflag(COMMIT_Nolink, ip)) {
1432 sxtlck->lwm.offset = (sxtlck->lwm.offset) ?
1433 min(middle, (int)sxtlck->lwm.offset) : middle;
1434 }
1435
1436 rp->header.nextindex = cpu_to_le16(XTENTRYSTART +
1437 righthalf + 1);
1438 }
1439
1440 if (!test_cflag(COMMIT_Nolink, ip)) {
1441 sxtlck->lwm.length = le16_to_cpu(sp->header.nextindex) -
1442 sxtlck->lwm.offset;
1443
1444 /* rxtlck->lwm.offset = XTENTRYSTART; */
1445 rxtlck->lwm.length = le16_to_cpu(rp->header.nextindex) -
1446 XTENTRYSTART;
1447 }
1448
1449 *rmpp = rmp;
1450 *rbnp = rbn;
1451
1452 jfs_info("xtSplitPage: sp:0x%p rp:0x%p", sp, rp);
1453 return rc;
1454
1455 clean_up:
1456
1457 /* Rollback quota allocation. */
1458 if (quota_allocation)
1459 DQUOT_FREE_BLOCK(ip, quota_allocation);
1460
1461 return (rc);
1462 }
1463
1464
1465 /*
1466 * xtSplitRoot()
1467 *
1468 * function:
1469 * split the full root page into original/root/split page and new
1470 * right page
1471 * i.e., root remains fixed in tree anchor (inode) and the root is
1472 * copied to a single new right child page since root page <<
1473 * non-root page, and the split root page contains a single entry
1474 * for the new right child page.
1475 *
1476 * parameter:
1477 * int tid,
1478 * struct inode *ip,
1479 * struct xtsplit *split,
1480 * struct metapage **rmpp)
1481 *
1482 * return:
1483 * Pointer to page in which to insert or NULL on error.
1484 */
1485 static int
1486 xtSplitRoot(tid_t tid,
1487 struct inode *ip, struct xtsplit * split, struct metapage ** rmpp)
1488 {
1489 xtpage_t *sp;
1490 struct metapage *rmp;
1491 xtpage_t *rp;
1492 s64 rbn;
1493 int skip, nextindex;
1494 xad_t *xad;
1495 pxd_t *pxd;
1496 struct pxdlist *pxdlist;
1497 struct tlock *tlck;
1498 struct xtlock *xtlck;
1499
1500 sp = &JFS_IP(ip)->i_xtroot;
1501
1502 INCREMENT(xtStat.split);
1503
1504 /*
1505 * allocate a single (right) child page
1506 */
1507 pxdlist = split->pxdlist;
1508 pxd = &pxdlist->pxd[pxdlist->npxd];
1509 pxdlist->npxd++;
1510 rbn = addressPXD(pxd);
1511 rmp = get_metapage(ip, rbn, PSIZE, 1);
1512 if (rmp == NULL)
1513 return -EIO;
1514
1515 /* Allocate blocks to quota. */
1516 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) {
1517 release_metapage(rmp);
1518 return -EDQUOT;
1519 }
1520
1521 jfs_info("xtSplitRoot: ip:0x%p rmp:0x%p", ip, rmp);
1522
1523 /*
1524 * acquire a transaction lock on the new right page;
1525 *
1526 * action: new page;
1527 */
1528 BT_MARK_DIRTY(rmp, ip);
1529
1530 rp = (xtpage_t *) rmp->data;
1531 rp->header.flag =
1532 (sp->header.flag & BT_LEAF) ? BT_LEAF : BT_INTERNAL;
1533 rp->header.self = *pxd;
1534 rp->header.nextindex = cpu_to_le16(XTENTRYSTART);
1535 rp->header.maxentry = cpu_to_le16(PSIZE >> L2XTSLOTSIZE);
1536
1537 /* initialize sibling pointers */
1538 rp->header.next = 0;
1539 rp->header.prev = 0;
1540
1541 /*
1542 * copy the in-line root page into new right page extent
1543 */
1544 nextindex = le16_to_cpu(sp->header.maxentry);
1545 memmove(&rp->xad[XTENTRYSTART], &sp->xad[XTENTRYSTART],
1546 (nextindex - XTENTRYSTART) << L2XTSLOTSIZE);
1547
1548 /*
1549 * insert the new entry into the new right/child page
1550 * (skip index in the new right page will not change)
1551 */
1552 skip = split->index;
1553 /* if insert into middle, shift right remaining entries */
1554 if (skip != nextindex)
1555 memmove(&rp->xad[skip + 1], &rp->xad[skip],
1556 (nextindex - skip) * sizeof(xad_t));
1557
1558 xad = &rp->xad[skip];
1559 XT_PUTENTRY(xad, split->flag, split->off, split->len, split->addr);
1560
1561 /* update page header */
1562 rp->header.nextindex = cpu_to_le16(nextindex + 1);
1563
1564 if (!test_cflag(COMMIT_Nolink, ip)) {
1565 tlck = txLock(tid, ip, rmp, tlckXTREE | tlckNEW);
1566 xtlck = (struct xtlock *) & tlck->lock;
1567 xtlck->lwm.offset = XTENTRYSTART;
1568 xtlck->lwm.length = le16_to_cpu(rp->header.nextindex) -
1569 XTENTRYSTART;
1570 }
1571
1572 /*
1573 * reset the root
1574 *
1575 * init root with the single entry for the new right page
1576 * set the 1st entry offset to 0, which force the left-most key
1577 * at any level of the tree to be less than any search key.
1578 */
1579 /*
1580 * acquire a transaction lock on the root page (in-memory inode);
1581 *
1582 * action: root split;
1583 */
1584 BT_MARK_DIRTY(split->mp, ip);
1585
1586 xad = &sp->xad[XTENTRYSTART];
1587 XT_PUTENTRY(xad, XAD_NEW, 0, JFS_SBI(ip->i_sb)->nbperpage, rbn);
1588
1589 /* update page header of root */
1590 sp->header.flag &= ~BT_LEAF;
1591 sp->header.flag |= BT_INTERNAL;
1592
1593 sp->header.nextindex = cpu_to_le16(XTENTRYSTART + 1);
1594
1595 if (!test_cflag(COMMIT_Nolink, ip)) {
1596 tlck = txLock(tid, ip, split->mp, tlckXTREE | tlckGROW);
1597 xtlck = (struct xtlock *) & tlck->lock;
1598 xtlck->lwm.offset = XTENTRYSTART;
1599 xtlck->lwm.length = 1;
1600 }
1601
1602 *rmpp = rmp;
1603
1604 jfs_info("xtSplitRoot: sp:0x%p rp:0x%p", sp, rp);
1605 return 0;
1606 }
1607
1608
1609 /*
1610 * xtExtend()
1611 *
1612 * function: extend in-place;
1613 *
1614 * note: existing extent may or may not have been committed.
1615 * caller is responsible for pager buffer cache update, and
1616 * working block allocation map update;
1617 * update pmap: alloc whole extended extent;
1618 */
1619 int xtExtend(tid_t tid, /* transaction id */
1620 struct inode *ip, s64 xoff, /* delta extent offset */
1621 s32 xlen, /* delta extent length */
1622 int flag)
1623 {
1624 int rc = 0;
1625 int cmp;
1626 struct metapage *mp; /* meta-page buffer */
1627 xtpage_t *p; /* base B+-tree index page */
1628 s64 bn;
1629 int index, nextindex, len;
1630 struct btstack btstack; /* traverse stack */
1631 struct xtsplit split; /* split information */
1632 xad_t *xad;
1633 s64 xaddr;
1634 struct tlock *tlck;
1635 struct xtlock *xtlck = NULL;
1636
1637 jfs_info("xtExtend: nxoff:0x%lx nxlen:0x%x", (ulong) xoff, xlen);
1638
1639 /* there must exist extent to be extended */
1640 if ((rc = xtSearch(ip, xoff - 1, NULL, &cmp, &btstack, XT_INSERT)))
1641 return rc;
1642
1643 /* retrieve search result */
1644 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
1645
1646 if (cmp != 0) {
1647 XT_PUTPAGE(mp);
1648 jfs_error(ip->i_sb, "xtExtend: xtSearch did not find extent");
1649 return -EIO;
1650 }
1651
1652 /* extension must be contiguous */
1653 xad = &p->xad[index];
1654 if ((offsetXAD(xad) + lengthXAD(xad)) != xoff) {
1655 XT_PUTPAGE(mp);
1656 jfs_error(ip->i_sb, "xtExtend: extension is not contiguous");
1657 return -EIO;
1658 }
1659
1660 /*
1661 * acquire a transaction lock on the leaf page;
1662 *
1663 * action: xad insertion/extension;
1664 */
1665 BT_MARK_DIRTY(mp, ip);
1666 if (!test_cflag(COMMIT_Nolink, ip)) {
1667 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
1668 xtlck = (struct xtlock *) & tlck->lock;
1669 }
1670
1671 /* extend will overflow extent ? */
1672 xlen = lengthXAD(xad) + xlen;
1673 if ((len = xlen - MAXXLEN) <= 0)
1674 goto extendOld;
1675
1676 /*
1677 * extent overflow: insert entry for new extent
1678 */
1679 //insertNew:
1680 xoff = offsetXAD(xad) + MAXXLEN;
1681 xaddr = addressXAD(xad) + MAXXLEN;
1682 nextindex = le16_to_cpu(p->header.nextindex);
1683
1684 /*
1685 * if the leaf page is full, insert the new entry and
1686 * propagate up the router entry for the new page from split
1687 *
1688 * The xtSplitUp() will insert the entry and unpin the leaf page.
1689 */
1690 if (nextindex == le16_to_cpu(p->header.maxentry)) {
1691 /* xtSpliUp() unpins leaf pages */
1692 split.mp = mp;
1693 split.index = index + 1;
1694 split.flag = XAD_NEW;
1695 split.off = xoff; /* split offset */
1696 split.len = len;
1697 split.addr = xaddr;
1698 split.pxdlist = NULL;
1699 if ((rc = xtSplitUp(tid, ip, &split, &btstack)))
1700 return rc;
1701
1702 /* get back old page */
1703 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
1704 if (rc)
1705 return rc;
1706 /*
1707 * if leaf root has been split, original root has been
1708 * copied to new child page, i.e., original entry now
1709 * resides on the new child page;
1710 */
1711 if (p->header.flag & BT_INTERNAL) {
1712 ASSERT(p->header.nextindex ==
1713 cpu_to_le16(XTENTRYSTART + 1));
1714 xad = &p->xad[XTENTRYSTART];
1715 bn = addressXAD(xad);
1716 XT_PUTPAGE(mp);
1717
1718 /* get new child page */
1719 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
1720 if (rc)
1721 return rc;
1722
1723 BT_MARK_DIRTY(mp, ip);
1724 if (!test_cflag(COMMIT_Nolink, ip)) {
1725 tlck = txLock(tid, ip, mp, tlckXTREE|tlckGROW);
1726 xtlck = (struct xtlock *) & tlck->lock;
1727 }
1728 }
1729 }
1730 /*
1731 * insert the new entry into the leaf page
1732 */
1733 else {
1734 /* insert the new entry: mark the entry NEW */
1735 xad = &p->xad[index + 1];
1736 XT_PUTENTRY(xad, XAD_NEW, xoff, len, xaddr);
1737
1738 /* advance next available entry index */
1739 le16_add_cpu(&p->header.nextindex, 1);
1740 }
1741
1742 /* get back old entry */
1743 xad = &p->xad[index];
1744 xlen = MAXXLEN;
1745
1746 /*
1747 * extend old extent
1748 */
1749 extendOld:
1750 XADlength(xad, xlen);
1751 if (!(xad->flag & XAD_NEW))
1752 xad->flag |= XAD_EXTENDED;
1753
1754 if (!test_cflag(COMMIT_Nolink, ip)) {
1755 xtlck->lwm.offset =
1756 (xtlck->lwm.offset) ? min(index,
1757 (int)xtlck->lwm.offset) : index;
1758 xtlck->lwm.length =
1759 le16_to_cpu(p->header.nextindex) - xtlck->lwm.offset;
1760 }
1761
1762 /* unpin the leaf page */
1763 XT_PUTPAGE(mp);
1764
1765 return rc;
1766 }
1767
1768 #ifdef _NOTYET
1769 /*
1770 * xtTailgate()
1771 *
1772 * function: split existing 'tail' extent
1773 * (split offset >= start offset of tail extent), and
1774 * relocate and extend the split tail half;
1775 *
1776 * note: existing extent may or may not have been committed.
1777 * caller is responsible for pager buffer cache update, and
1778 * working block allocation map update;
1779 * update pmap: free old split tail extent, alloc new extent;
1780 */
1781 int xtTailgate(tid_t tid, /* transaction id */
1782 struct inode *ip, s64 xoff, /* split/new extent offset */
1783 s32 xlen, /* new extent length */
1784 s64 xaddr, /* new extent address */
1785 int flag)
1786 {
1787 int rc = 0;
1788 int cmp;
1789 struct metapage *mp; /* meta-page buffer */
1790 xtpage_t *p; /* base B+-tree index page */
1791 s64 bn;
1792 int index, nextindex, llen, rlen;
1793 struct btstack btstack; /* traverse stack */
1794 struct xtsplit split; /* split information */
1795 xad_t *xad;
1796 struct tlock *tlck;
1797 struct xtlock *xtlck = 0;
1798 struct tlock *mtlck;
1799 struct maplock *pxdlock;
1800
1801 /*
1802 printf("xtTailgate: nxoff:0x%lx nxlen:0x%x nxaddr:0x%lx\n",
1803 (ulong)xoff, xlen, (ulong)xaddr);
1804 */
1805
1806 /* there must exist extent to be tailgated */
1807 if ((rc = xtSearch(ip, xoff, NULL, &cmp, &btstack, XT_INSERT)))
1808 return rc;
1809
1810 /* retrieve search result */
1811 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
1812
1813 if (cmp != 0) {
1814 XT_PUTPAGE(mp);
1815 jfs_error(ip->i_sb, "xtTailgate: couldn't find extent");
1816 return -EIO;
1817 }
1818
1819 /* entry found must be last entry */
1820 nextindex = le16_to_cpu(p->header.nextindex);
1821 if (index != nextindex - 1) {
1822 XT_PUTPAGE(mp);
1823 jfs_error(ip->i_sb,
1824 "xtTailgate: the entry found is not the last entry");
1825 return -EIO;
1826 }
1827
1828 BT_MARK_DIRTY(mp, ip);
1829 /*
1830 * acquire tlock of the leaf page containing original entry
1831 */
1832 if (!test_cflag(COMMIT_Nolink, ip)) {
1833 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
1834 xtlck = (struct xtlock *) & tlck->lock;
1835 }
1836
1837 /* completely replace extent ? */
1838 xad = &p->xad[index];
1839 /*
1840 printf("xtTailgate: xoff:0x%lx xlen:0x%x xaddr:0x%lx\n",
1841 (ulong)offsetXAD(xad), lengthXAD(xad), (ulong)addressXAD(xad));
1842 */
1843 if ((llen = xoff - offsetXAD(xad)) == 0)
1844 goto updateOld;
1845
1846 /*
1847 * partially replace extent: insert entry for new extent
1848 */
1849 //insertNew:
1850 /*
1851 * if the leaf page is full, insert the new entry and
1852 * propagate up the router entry for the new page from split
1853 *
1854 * The xtSplitUp() will insert the entry and unpin the leaf page.
1855 */
1856 if (nextindex == le16_to_cpu(p->header.maxentry)) {
1857 /* xtSpliUp() unpins leaf pages */
1858 split.mp = mp;
1859 split.index = index + 1;
1860 split.flag = XAD_NEW;
1861 split.off = xoff; /* split offset */
1862 split.len = xlen;
1863 split.addr = xaddr;
1864 split.pxdlist = NULL;
1865 if ((rc = xtSplitUp(tid, ip, &split, &btstack)))
1866 return rc;
1867
1868 /* get back old page */
1869 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
1870 if (rc)
1871 return rc;
1872 /*
1873 * if leaf root has been split, original root has been
1874 * copied to new child page, i.e., original entry now
1875 * resides on the new child page;
1876 */
1877 if (p->header.flag & BT_INTERNAL) {
1878 ASSERT(p->header.nextindex ==
1879 cpu_to_le16(XTENTRYSTART + 1));
1880 xad = &p->xad[XTENTRYSTART];
1881 bn = addressXAD(xad);
1882 XT_PUTPAGE(mp);
1883
1884 /* get new child page */
1885 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
1886 if (rc)
1887 return rc;
1888
1889 BT_MARK_DIRTY(mp, ip);
1890 if (!test_cflag(COMMIT_Nolink, ip)) {
1891 tlck = txLock(tid, ip, mp, tlckXTREE|tlckGROW);
1892 xtlck = (struct xtlock *) & tlck->lock;
1893 }
1894 }
1895 }
1896 /*
1897 * insert the new entry into the leaf page
1898 */
1899 else {
1900 /* insert the new entry: mark the entry NEW */
1901 xad = &p->xad[index + 1];
1902 XT_PUTENTRY(xad, XAD_NEW, xoff, xlen, xaddr);
1903
1904 /* advance next available entry index */
1905 le16_add_cpu(&p->header.nextindex, 1);
1906 }
1907
1908 /* get back old XAD */
1909 xad = &p->xad[index];
1910
1911 /*
1912 * truncate/relocate old extent at split offset
1913 */
1914 updateOld:
1915 /* update dmap for old/committed/truncated extent */
1916 rlen = lengthXAD(xad) - llen;
1917 if (!(xad->flag & XAD_NEW)) {
1918 /* free from PWMAP at commit */
1919 if (!test_cflag(COMMIT_Nolink, ip)) {
1920 mtlck = txMaplock(tid, ip, tlckMAP);
1921 pxdlock = (struct maplock *) & mtlck->lock;
1922 pxdlock->flag = mlckFREEPXD;
1923 PXDaddress(&pxdlock->pxd, addressXAD(xad) + llen);
1924 PXDlength(&pxdlock->pxd, rlen);
1925 pxdlock->index = 1;
1926 }
1927 } else
1928 /* free from WMAP */
1929 dbFree(ip, addressXAD(xad) + llen, (s64) rlen);
1930
1931 if (llen)
1932 /* truncate */
1933 XADlength(xad, llen);
1934 else
1935 /* replace */
1936 XT_PUTENTRY(xad, XAD_NEW, xoff, xlen, xaddr);
1937
1938 if (!test_cflag(COMMIT_Nolink, ip)) {
1939 xtlck->lwm.offset = (xtlck->lwm.offset) ?
1940 min(index, (int)xtlck->lwm.offset) : index;
1941 xtlck->lwm.length = le16_to_cpu(p->header.nextindex) -
1942 xtlck->lwm.offset;
1943 }
1944
1945 /* unpin the leaf page */
1946 XT_PUTPAGE(mp);
1947
1948 return rc;
1949 }
1950 #endif /* _NOTYET */
1951
1952 /*
1953 * xtUpdate()
1954 *
1955 * function: update XAD;
1956 *
1957 * update extent for allocated_but_not_recorded or
1958 * compressed extent;
1959 *
1960 * parameter:
1961 * nxad - new XAD;
1962 * logical extent of the specified XAD must be completely
1963 * contained by an existing XAD;
1964 */
1965 int xtUpdate(tid_t tid, struct inode *ip, xad_t * nxad)
1966 { /* new XAD */
1967 int rc = 0;
1968 int cmp;
1969 struct metapage *mp; /* meta-page buffer */
1970 xtpage_t *p; /* base B+-tree index page */
1971 s64 bn;
1972 int index0, index, newindex, nextindex;
1973 struct btstack btstack; /* traverse stack */
1974 struct xtsplit split; /* split information */
1975 xad_t *xad, *lxad, *rxad;
1976 int xflag;
1977 s64 nxoff, xoff;
1978 int nxlen, xlen, lxlen, rxlen;
1979 s64 nxaddr, xaddr;
1980 struct tlock *tlck;
1981 struct xtlock *xtlck = NULL;
1982 int newpage = 0;
1983
1984 /* there must exist extent to be tailgated */
1985 nxoff = offsetXAD(nxad);
1986 nxlen = lengthXAD(nxad);
1987 nxaddr = addressXAD(nxad);
1988
1989 if ((rc = xtSearch(ip, nxoff, NULL, &cmp, &btstack, XT_INSERT)))
1990 return rc;
1991
1992 /* retrieve search result */
1993 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index0);
1994
1995 if (cmp != 0) {
1996 XT_PUTPAGE(mp);
1997 jfs_error(ip->i_sb, "xtUpdate: Could not find extent");
1998 return -EIO;
1999 }
2000
2001 BT_MARK_DIRTY(mp, ip);
2002 /*
2003 * acquire tlock of the leaf page containing original entry
2004 */
2005 if (!test_cflag(COMMIT_Nolink, ip)) {
2006 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
2007 xtlck = (struct xtlock *) & tlck->lock;
2008 }
2009
2010 xad = &p->xad[index0];
2011 xflag = xad->flag;
2012 xoff = offsetXAD(xad);
2013 xlen = lengthXAD(xad);
2014 xaddr = addressXAD(xad);
2015
2016 /* nXAD must be completely contained within XAD */
2017 if ((xoff > nxoff) ||
2018 (nxoff + nxlen > xoff + xlen)) {
2019 XT_PUTPAGE(mp);
2020 jfs_error(ip->i_sb,
2021 "xtUpdate: nXAD in not completely contained within XAD");
2022 return -EIO;
2023 }
2024
2025 index = index0;
2026 newindex = index + 1;
2027 nextindex = le16_to_cpu(p->header.nextindex);
2028
2029 #ifdef _JFS_WIP_NOCOALESCE
2030 if (xoff < nxoff)
2031 goto updateRight;
2032
2033 /*
2034 * replace XAD with nXAD
2035 */
2036 replace: /* (nxoff == xoff) */
2037 if (nxlen == xlen) {
2038 /* replace XAD with nXAD:recorded */
2039 *xad = *nxad;
2040 xad->flag = xflag & ~XAD_NOTRECORDED;
2041
2042 goto out;
2043 } else /* (nxlen < xlen) */
2044 goto updateLeft;
2045 #endif /* _JFS_WIP_NOCOALESCE */
2046
2047 /* #ifdef _JFS_WIP_COALESCE */
2048 if (xoff < nxoff)
2049 goto coalesceRight;
2050
2051 /*
2052 * coalesce with left XAD
2053 */
2054 //coalesceLeft: /* (xoff == nxoff) */
2055 /* is XAD first entry of page ? */
2056 if (index == XTENTRYSTART)
2057 goto replace;
2058
2059 /* is nXAD logically and physically contiguous with lXAD ? */
2060 lxad = &p->xad[index - 1];
2061 lxlen = lengthXAD(lxad);
2062 if (!(lxad->flag & XAD_NOTRECORDED) &&
2063 (nxoff == offsetXAD(lxad) + lxlen) &&
2064 (nxaddr == addressXAD(lxad) + lxlen) &&
2065 (lxlen + nxlen < MAXXLEN)) {
2066 /* extend right lXAD */
2067 index0 = index - 1;
2068 XADlength(lxad, lxlen + nxlen);
2069
2070 /* If we just merged two extents together, need to make sure the
2071 * right extent gets logged. If the left one is marked XAD_NEW,
2072 * then we know it will be logged. Otherwise, mark as
2073 * XAD_EXTENDED
2074 */
2075 if (!(lxad->flag & XAD_NEW))
2076 lxad->flag |= XAD_EXTENDED;
2077
2078 if (xlen > nxlen) {
2079 /* truncate XAD */
2080 XADoffset(xad, xoff + nxlen);
2081 XADlength(xad, xlen - nxlen);
2082 XADaddress(xad, xaddr + nxlen);
2083 goto out;
2084 } else { /* (xlen == nxlen) */
2085
2086 /* remove XAD */
2087 if (index < nextindex - 1)
2088 memmove(&p->xad[index], &p->xad[index + 1],
2089 (nextindex - index -
2090 1) << L2XTSLOTSIZE);
2091
2092 p->header.nextindex =
2093 cpu_to_le16(le16_to_cpu(p->header.nextindex) -
2094 1);
2095
2096 index = index0;
2097 newindex = index + 1;
2098 nextindex = le16_to_cpu(p->header.nextindex);
2099 xoff = nxoff = offsetXAD(lxad);
2100 xlen = nxlen = lxlen + nxlen;
2101 xaddr = nxaddr = addressXAD(lxad);
2102 goto coalesceRight;
2103 }
2104 }
2105
2106 /*
2107 * replace XAD with nXAD
2108 */
2109 replace: /* (nxoff == xoff) */
2110 if (nxlen == xlen) {
2111 /* replace XAD with nXAD:recorded */
2112 *xad = *nxad;
2113 xad->flag = xflag & ~XAD_NOTRECORDED;
2114
2115 goto coalesceRight;
2116 } else /* (nxlen < xlen) */
2117 goto updateLeft;
2118
2119 /*
2120 * coalesce with right XAD
2121 */
2122 coalesceRight: /* (xoff <= nxoff) */
2123 /* is XAD last entry of page ? */
2124 if (newindex == nextindex) {
2125 if (xoff == nxoff)
2126 goto out;
2127 goto updateRight;
2128 }
2129
2130 /* is nXAD logically and physically contiguous with rXAD ? */
2131 rxad = &p->xad[index + 1];
2132 rxlen = lengthXAD(rxad);
2133 if (!(rxad->flag & XAD_NOTRECORDED) &&
2134 (nxoff + nxlen == offsetXAD(rxad)) &&
2135 (nxaddr + nxlen == addressXAD(rxad)) &&
2136 (rxlen + nxlen < MAXXLEN)) {
2137 /* extend left rXAD */
2138 XADoffset(rxad, nxoff);
2139 XADlength(rxad, rxlen + nxlen);
2140 XADaddress(rxad, nxaddr);
2141
2142 /* If we just merged two extents together, need to make sure
2143 * the left extent gets logged. If the right one is marked
2144 * XAD_NEW, then we know it will be logged. Otherwise, mark as
2145 * XAD_EXTENDED
2146 */
2147 if (!(rxad->flag & XAD_NEW))
2148 rxad->flag |= XAD_EXTENDED;
2149
2150 if (xlen > nxlen)
2151 /* truncate XAD */
2152 XADlength(xad, xlen - nxlen);
2153 else { /* (xlen == nxlen) */
2154
2155 /* remove XAD */
2156 memmove(&p->xad[index], &p->xad[index + 1],
2157 (nextindex - index - 1) << L2XTSLOTSIZE);
2158
2159 p->header.nextindex =
2160 cpu_to_le16(le16_to_cpu(p->header.nextindex) -
2161 1);
2162 }
2163
2164 goto out;
2165 } else if (xoff == nxoff)
2166 goto out;
2167
2168 if (xoff >= nxoff) {
2169 XT_PUTPAGE(mp);
2170 jfs_error(ip->i_sb, "xtUpdate: xoff >= nxoff");
2171 return -EIO;
2172 }
2173 /* #endif _JFS_WIP_COALESCE */
2174
2175 /*
2176 * split XAD into (lXAD, nXAD):
2177 *
2178 * |---nXAD--->
2179 * --|----------XAD----------|--
2180 * |-lXAD-|
2181 */
2182 updateRight: /* (xoff < nxoff) */
2183 /* truncate old XAD as lXAD:not_recorded */
2184 xad = &p->xad[index];
2185 XADlength(xad, nxoff - xoff);
2186
2187 /* insert nXAD:recorded */
2188 if (nextindex == le16_to_cpu(p->header.maxentry)) {
2189
2190 /* xtSpliUp() unpins leaf pages */
2191 split.mp = mp;
2192 split.index = newindex;
2193 split.flag = xflag & ~XAD_NOTRECORDED;
2194 split.off = nxoff;
2195 split.len = nxlen;
2196 split.addr = nxaddr;
2197 split.pxdlist = NULL;
2198 if ((rc = xtSplitUp(tid, ip, &split, &btstack)))
2199 return rc;
2200
2201 /* get back old page */
2202 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
2203 if (rc)
2204 return rc;
2205 /*
2206 * if leaf root has been split, original root has been
2207 * copied to new child page, i.e., original entry now
2208 * resides on the new child page;
2209 */
2210 if (p->header.flag & BT_INTERNAL) {
2211 ASSERT(p->header.nextindex ==
2212 cpu_to_le16(XTENTRYSTART + 1));
2213 xad = &p->xad[XTENTRYSTART];
2214 bn = addressXAD(xad);
2215 XT_PUTPAGE(mp);
2216
2217 /* get new child page */
2218 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
2219 if (rc)
2220 return rc;
2221
2222 BT_MARK_DIRTY(mp, ip);
2223 if (!test_cflag(COMMIT_Nolink, ip)) {
2224 tlck = txLock(tid, ip, mp, tlckXTREE|tlckGROW);
2225 xtlck = (struct xtlock *) & tlck->lock;
2226 }
2227 } else {
2228 /* is nXAD on new page ? */
2229 if (newindex >
2230 (le16_to_cpu(p->header.maxentry) >> 1)) {
2231 newindex =
2232 newindex -
2233 le16_to_cpu(p->header.nextindex) +
2234 XTENTRYSTART;
2235 newpage = 1;
2236 }
2237 }
2238 } else {
2239 /* if insert into middle, shift right remaining entries */
2240 if (newindex < nextindex)
2241 memmove(&p->xad[newindex + 1], &p->xad[newindex],
2242 (nextindex - newindex) << L2XTSLOTSIZE);
2243
2244 /* insert the entry */
2245 xad = &p->xad[newindex];
2246 *xad = *nxad;
2247 xad->flag = xflag & ~XAD_NOTRECORDED;
2248
2249 /* advance next available entry index. */
2250 p->header.nextindex =
2251 cpu_to_le16(le16_to_cpu(p->header.nextindex) + 1);
2252 }
2253
2254 /*
2255 * does nXAD force 3-way split ?
2256 *
2257 * |---nXAD--->|
2258 * --|----------XAD-------------|--
2259 * |-lXAD-| |-rXAD -|
2260 */
2261 if (nxoff + nxlen == xoff + xlen)
2262 goto out;
2263
2264 /* reorient nXAD as XAD for further split XAD into (nXAD, rXAD) */
2265 if (newpage) {
2266 /* close out old page */
2267 if (!test_cflag(COMMIT_Nolink, ip)) {
2268 xtlck->lwm.offset = (xtlck->lwm.offset) ?
2269 min(index0, (int)xtlck->lwm.offset) : index0;
2270 xtlck->lwm.length =
2271 le16_to_cpu(p->header.nextindex) -
2272 xtlck->lwm.offset;
2273 }
2274
2275 bn = le64_to_cpu(p->header.next);
2276 XT_PUTPAGE(mp);
2277
2278 /* get new right page */
2279 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
2280 if (rc)
2281 return rc;
2282
2283 BT_MARK_DIRTY(mp, ip);
2284 if (!test_cflag(COMMIT_Nolink, ip)) {
2285 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
2286 xtlck = (struct xtlock *) & tlck->lock;
2287 }
2288
2289 index0 = index = newindex;
2290 } else
2291 index++;
2292
2293 newindex = index + 1;
2294 nextindex = le16_to_cpu(p->header.nextindex);
2295 xlen = xlen - (nxoff - xoff);
2296 xoff = nxoff;
2297 xaddr = nxaddr;
2298
2299 /* recompute split pages */
2300 if (nextindex == le16_to_cpu(p->header.maxentry)) {
2301 XT_PUTPAGE(mp);
2302
2303 if ((rc = xtSearch(ip, nxoff, NULL, &cmp, &btstack, XT_INSERT)))
2304 return rc;
2305
2306 /* retrieve search result */
2307 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index0);
2308
2309 if (cmp != 0) {
2310 XT_PUTPAGE(mp);
2311 jfs_error(ip->i_sb, "xtUpdate: xtSearch failed");
2312 return -EIO;
2313 }
2314
2315 if (index0 != index) {
2316 XT_PUTPAGE(mp);
2317 jfs_error(ip->i_sb,
2318 "xtUpdate: unexpected value of index");
2319 return -EIO;
2320 }
2321 }
2322
2323 /*
2324 * split XAD into (nXAD, rXAD)
2325 *
2326 * ---nXAD---|
2327 * --|----------XAD----------|--
2328 * |-rXAD-|
2329 */
2330 updateLeft: /* (nxoff == xoff) && (nxlen < xlen) */
2331 /* update old XAD with nXAD:recorded */
2332 xad = &p->xad[index];
2333 *xad = *nxad;
2334 xad->flag = xflag & ~XAD_NOTRECORDED;
2335
2336 /* insert rXAD:not_recorded */
2337 xoff = xoff + nxlen;
2338 xlen = xlen - nxlen;
2339 xaddr = xaddr + nxlen;
2340 if (nextindex == le16_to_cpu(p->header.maxentry)) {
2341 /*
2342 printf("xtUpdate.updateLeft.split p:0x%p\n", p);
2343 */
2344 /* xtSpliUp() unpins leaf pages */
2345 split.mp = mp;
2346 split.index = newindex;
2347 split.flag = xflag;
2348 split.off = xoff;
2349 split.len = xlen;
2350 split.addr = xaddr;
2351 split.pxdlist = NULL;
2352 if ((rc = xtSplitUp(tid, ip, &split, &btstack)))
2353 return rc;
2354
2355 /* get back old page */
2356 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
2357 if (rc)
2358 return rc;
2359
2360 /*
2361 * if leaf root has been split, original root has been
2362 * copied to new child page, i.e., original entry now
2363 * resides on the new child page;
2364 */
2365 if (p->header.flag & BT_INTERNAL) {
2366 ASSERT(p->header.nextindex ==
2367 cpu_to_le16(XTENTRYSTART + 1));
2368 xad = &p->xad[XTENTRYSTART];
2369 bn = addressXAD(xad);
2370 XT_PUTPAGE(mp);
2371
2372 /* get new child page */
2373 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
2374 if (rc)
2375 return rc;
2376
2377 BT_MARK_DIRTY(mp, ip);
2378 if (!test_cflag(COMMIT_Nolink, ip)) {
2379 tlck = txLock(tid, ip, mp, tlckXTREE|tlckGROW);
2380 xtlck = (struct xtlock *) & tlck->lock;
2381 }
2382 }
2383 } else {
2384 /* if insert into middle, shift right remaining entries */
2385 if (newindex < nextindex)
2386 memmove(&p->xad[newindex + 1], &p->xad[newindex],
2387 (nextindex - newindex) << L2XTSLOTSIZE);
2388
2389 /* insert the entry */
2390 xad = &p->xad[newindex];
2391 XT_PUTENTRY(xad, xflag, xoff, xlen, xaddr);
2392
2393 /* advance next available entry index. */
2394 p->header.nextindex =
2395 cpu_to_le16(le16_to_cpu(p->header.nextindex) + 1);
2396 }
2397
2398 out:
2399 if (!test_cflag(COMMIT_Nolink, ip)) {
2400 xtlck->lwm.offset = (xtlck->lwm.offset) ?
2401 min(index0, (int)xtlck->lwm.offset) : index0;
2402 xtlck->lwm.length = le16_to_cpu(p->header.nextindex) -
2403 xtlck->lwm.offset;
2404 }
2405
2406 /* unpin the leaf page */
2407 XT_PUTPAGE(mp);
2408
2409 return rc;
2410 }
2411
2412
2413 /*
2414 * xtAppend()
2415 *
2416 * function: grow in append mode from contiguous region specified ;
2417 *
2418 * parameter:
2419 * tid - transaction id;
2420 * ip - file object;
2421 * xflag - extent flag:
2422 * xoff - extent offset;
2423 * maxblocks - max extent length;
2424 * xlen - extent length (in/out);
2425 * xaddrp - extent address pointer (in/out):
2426 * flag -
2427 *
2428 * return:
2429 */
2430 int xtAppend(tid_t tid, /* transaction id */
2431 struct inode *ip, int xflag, s64 xoff, s32 maxblocks,
2432 s32 * xlenp, /* (in/out) */
2433 s64 * xaddrp, /* (in/out) */
2434 int flag)
2435 {
2436 int rc = 0;
2437 struct metapage *mp; /* meta-page buffer */
2438 xtpage_t *p; /* base B+-tree index page */
2439 s64 bn, xaddr;
2440 int index, nextindex;
2441 struct btstack btstack; /* traverse stack */
2442 struct xtsplit split; /* split information */
2443 xad_t *xad;
2444 int cmp;
2445 struct tlock *tlck;
2446 struct xtlock *xtlck;
2447 int nsplit, nblocks, xlen;
2448 struct pxdlist pxdlist;
2449 pxd_t *pxd;
2450 s64 next;
2451
2452 xaddr = *xaddrp;
2453 xlen = *xlenp;
2454 jfs_info("xtAppend: xoff:0x%lx maxblocks:%d xlen:%d xaddr:0x%lx",
2455 (ulong) xoff, maxblocks, xlen, (ulong) xaddr);
2456
2457 /*
2458 * search for the entry location at which to insert:
2459 *
2460 * xtFastSearch() and xtSearch() both returns (leaf page
2461 * pinned, index at which to insert).
2462 * n.b. xtSearch() may return index of maxentry of
2463 * the full page.
2464 */
2465 if ((rc = xtSearch(ip, xoff, &next, &cmp, &btstack, XT_INSERT)))
2466 return rc;
2467
2468 /* retrieve search result */
2469 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
2470
2471 if (cmp == 0) {
2472 rc = -EEXIST;
2473 goto out;
2474 }
2475
2476 if (next)
2477 xlen = min(xlen, (int)(next - xoff));
2478 //insert:
2479 /*
2480 * insert entry for new extent
2481 */
2482 xflag |= XAD_NEW;
2483
2484 /*
2485 * if the leaf page is full, split the page and
2486 * propagate up the router entry for the new page from split
2487 *
2488 * The xtSplitUp() will insert the entry and unpin the leaf page.
2489 */
2490 nextindex = le16_to_cpu(p->header.nextindex);
2491 if (nextindex < le16_to_cpu(p->header.maxentry))
2492 goto insertLeaf;
2493
2494 /*
2495 * allocate new index blocks to cover index page split(s)
2496 */
2497 nsplit = btstack.nsplit;
2498 split.pxdlist = &pxdlist;
2499 pxdlist.maxnpxd = pxdlist.npxd = 0;
2500 pxd = &pxdlist.pxd[0];
2501 nblocks = JFS_SBI(ip->i_sb)->nbperpage;
2502 for (; nsplit > 0; nsplit--, pxd++, xaddr += nblocks, maxblocks -= nblocks) {
2503 if ((rc = dbAllocBottomUp(ip, xaddr, (s64) nblocks)) == 0) {
2504 PXDaddress(pxd, xaddr);
2505 PXDlength(pxd, nblocks);
2506
2507 pxdlist.maxnpxd++;
2508
2509 continue;
2510 }
2511
2512 /* undo allocation */
2513
2514 goto out;
2515 }
2516
2517 xlen = min(xlen, maxblocks);
2518
2519 /*
2520 * allocate data extent requested
2521 */
2522 if ((rc = dbAllocBottomUp(ip, xaddr, (s64) xlen)))
2523 goto out;
2524
2525 split.mp = mp;
2526 split.index = index;
2527 split.flag = xflag;
2528 split.off = xoff;
2529 split.len = xlen;
2530 split.addr = xaddr;
2531 if ((rc = xtSplitUp(tid, ip, &split, &btstack))) {
2532 /* undo data extent allocation */
2533 dbFree(ip, *xaddrp, (s64) * xlenp);
2534
2535 return rc;
2536 }
2537
2538 *xaddrp = xaddr;
2539 *xlenp = xlen;
2540 return 0;
2541
2542 /*
2543 * insert the new entry into the leaf page
2544 */
2545 insertLeaf:
2546 /*
2547 * allocate data extent requested
2548 */
2549 if ((rc = dbAllocBottomUp(ip, xaddr, (s64) xlen)))
2550 goto out;
2551
2552 BT_MARK_DIRTY(mp, ip);
2553 /*
2554 * acquire a transaction lock on the leaf page;
2555 *
2556 * action: xad insertion/extension;
2557 */
2558 tlck = txLock(tid, ip, mp, tlckXTREE | tlckGROW);
2559 xtlck = (struct xtlock *) & tlck->lock;
2560
2561 /* insert the new entry: mark the entry NEW */
2562 xad = &p->xad[index];
2563 XT_PUTENTRY(xad, xflag, xoff, xlen, xaddr);
2564
2565 /* advance next available entry index */
2566 le16_add_cpu(&p->header.nextindex, 1);
2567
2568 xtlck->lwm.offset =
2569 (xtlck->lwm.offset) ? min(index,(int) xtlck->lwm.offset) : index;
2570 xtlck->lwm.length = le16_to_cpu(p->header.nextindex) -
2571 xtlck->lwm.offset;
2572
2573 *xaddrp = xaddr;
2574 *xlenp = xlen;
2575
2576 out:
2577 /* unpin the leaf page */
2578 XT_PUTPAGE(mp);
2579
2580 return rc;
2581 }
2582 #ifdef _STILL_TO_PORT
2583
2584 /* - TBD for defragmentaion/reorganization -
2585 *
2586 * xtDelete()
2587 *
2588 * function:
2589 * delete the entry with the specified key.
2590 *
2591 * N.B.: whole extent of the entry is assumed to be deleted.
2592 *
2593 * parameter:
2594 *
2595 * return:
2596 * ENOENT: if the entry is not found.
2597 *
2598 * exception:
2599 */
2600 int xtDelete(tid_t tid, struct inode *ip, s64 xoff, s32 xlen, int flag)
2601 {
2602 int rc = 0;
2603 struct btstack btstack;
2604 int cmp;
2605 s64 bn;
2606 struct metapage *mp;
2607 xtpage_t *p;
2608 int index, nextindex;
2609 struct tlock *tlck;
2610 struct xtlock *xtlck;
2611
2612 /*
2613 * find the matching entry; xtSearch() pins the page
2614 */
2615 if ((rc = xtSearch(ip, xoff, NULL, &cmp, &btstack, 0)))
2616 return rc;
2617
2618 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
2619 if (cmp) {
2620 /* unpin the leaf page */
2621 XT_PUTPAGE(mp);
2622 return -ENOENT;
2623 }
2624
2625 /*
2626 * delete the entry from the leaf page
2627 */
2628 nextindex = le16_to_cpu(p->header.nextindex);
2629 le16_add_cpu(&p->header.nextindex, -1);
2630
2631 /*
2632 * if the leaf page bocome empty, free the page
2633 */
2634 if (p->header.nextindex == cpu_to_le16(XTENTRYSTART))
2635 return (xtDeleteUp(tid, ip, mp, p, &btstack));
2636
2637 BT_MARK_DIRTY(mp, ip);
2638 /*
2639 * acquire a transaction lock on the leaf page;
2640 *
2641 * action:xad deletion;
2642 */
2643 tlck = txLock(tid, ip, mp, tlckXTREE);
2644 xtlck = (struct xtlock *) & tlck->lock;
2645 xtlck->lwm.offset =
2646 (xtlck->lwm.offset) ? min(index, xtlck->lwm.offset) : index;
2647
2648 /* if delete from middle, shift left/compact the remaining entries */
2649 if (index < nextindex - 1)
2650 memmove(&p->xad[index], &p->xad[index + 1],
2651 (nextindex - index - 1) * sizeof(xad_t));
2652
2653 XT_PUTPAGE(mp);
2654
2655 return 0;
2656 }
2657
2658
2659 /* - TBD for defragmentaion/reorganization -
2660 *
2661 * xtDeleteUp()
2662 *
2663 * function:
2664 * free empty pages as propagating deletion up the tree
2665 *
2666 * parameter:
2667 *
2668 * return:
2669 */
2670 static int
2671 xtDeleteUp(tid_t tid, struct inode *ip,
2672 struct metapage * fmp, xtpage_t * fp, struct btstack * btstack)
2673 {
2674 int rc = 0;
2675 struct metapage *mp;
2676 xtpage_t *p;
2677 int index, nextindex;
2678 s64 xaddr;
2679 int xlen;
2680 struct btframe *parent;
2681 struct tlock *tlck;
2682 struct xtlock *xtlck;
2683
2684 /*
2685 * keep root leaf page which has become empty
2686 */
2687 if (fp->header.flag & BT_ROOT) {
2688 /* keep the root page */
2689 fp->header.flag &= ~BT_INTERNAL;
2690 fp->header.flag |= BT_LEAF;
2691 fp->header.nextindex = cpu_to_le16(XTENTRYSTART);
2692
2693 /* XT_PUTPAGE(fmp); */
2694
2695 return 0;
2696 }
2697
2698 /*
2699 * free non-root leaf page
2700 */
2701 if ((rc = xtRelink(tid, ip, fp))) {
2702 XT_PUTPAGE(fmp);
2703 return rc;
2704 }
2705
2706 xaddr = addressPXD(&fp->header.self);
2707 xlen = lengthPXD(&fp->header.self);
2708 /* free the page extent */
2709 dbFree(ip, xaddr, (s64) xlen);
2710
2711 /* free the buffer page */
2712 discard_metapage(fmp);
2713
2714 /*
2715 * propagate page deletion up the index tree
2716 *
2717 * If the delete from the parent page makes it empty,
2718 * continue all the way up the tree.
2719 * stop if the root page is reached (which is never deleted) or
2720 * if the entry deletion does not empty the page.
2721 */
2722 while ((parent = BT_POP(btstack)) != NULL) {
2723 /* get/pin the parent page <sp> */
2724 XT_GETPAGE(ip, parent->bn, mp, PSIZE, p, rc);
2725 if (rc)
2726 return rc;
2727
2728 index = parent->index;
2729
2730 /* delete the entry for the freed child page from parent.
2731 */
2732 nextindex = le16_to_cpu(p->header.nextindex);
2733
2734 /*
2735 * the parent has the single entry being deleted:
2736 * free the parent page which has become empty.
2737 */
2738 if (nextindex == 1) {
2739 if (p->header.flag & BT_ROOT) {
2740 /* keep the root page */
2741 p->header.flag &= ~BT_INTERNAL;
2742 p->header.flag |= BT_LEAF;
2743 p->header.nextindex =
2744 cpu_to_le16(XTENTRYSTART);
2745
2746 /* XT_PUTPAGE(mp); */
2747
2748 break;
2749 } else {
2750 /* free the parent page */
2751 if ((rc = xtRelink(tid, ip, p)))
2752 return rc;
2753
2754 xaddr = addressPXD(&p->header.self);
2755 /* free the page extent */
2756 dbFree(ip, xaddr,
2757 (s64) JFS_SBI(ip->i_sb)->nbperpage);
2758
2759 /* unpin/free the buffer page */
2760 discard_metapage(mp);
2761
2762 /* propagate up */
2763 continue;
2764 }
2765 }
2766 /*
2767 * the parent has other entries remaining:
2768 * delete the router entry from the parent page.
2769 */
2770 else {
2771 BT_MARK_DIRTY(mp, ip);
2772 /*
2773 * acquire a transaction lock on the leaf page;
2774 *
2775 * action:xad deletion;
2776 */
2777 tlck = txLock(tid, ip, mp, tlckXTREE);
2778 xtlck = (struct xtlock *) & tlck->lock;
2779 xtlck->lwm.offset =
2780 (xtlck->lwm.offset) ? min(index,
2781 xtlck->lwm.
2782 offset) : index;
2783
2784 /* if delete from middle,
2785 * shift left/compact the remaining entries in the page
2786 */
2787 if (index < nextindex - 1)
2788 memmove(&p->xad[index], &p->xad[index + 1],
2789 (nextindex - index -
2790 1) << L2XTSLOTSIZE);
2791
2792 le16_add_cpu(&p->header.nextindex, -1);
2793 jfs_info("xtDeleteUp(entry): 0x%lx[%d]",
2794 (ulong) parent->bn, index);
2795 }
2796
2797 /* unpin the parent page */
2798 XT_PUTPAGE(mp);
2799
2800 /* exit propagation up */
2801 break;
2802 }
2803
2804 return 0;
2805 }
2806
2807
2808 /*
2809 * NAME: xtRelocate()
2810 *
2811 * FUNCTION: relocate xtpage or data extent of regular file;
2812 * This function is mainly used by defragfs utility.
2813 *
2814 * NOTE: This routine does not have the logic to handle
2815 * uncommitted allocated extent. The caller should call
2816 * txCommit() to commit all the allocation before call
2817 * this routine.
2818 */
2819 int
2820 xtRelocate(tid_t tid, struct inode * ip, xad_t * oxad, /* old XAD */
2821 s64 nxaddr, /* new xaddr */
2822 int xtype)
2823 { /* extent type: XTPAGE or DATAEXT */
2824 int rc = 0;
2825 struct tblock *tblk;
2826 struct tlock *tlck;
2827 struct xtlock *xtlck;
2828 struct metapage *mp, *pmp, *lmp, *rmp; /* meta-page buffer */
2829 xtpage_t *p, *pp, *rp, *lp; /* base B+-tree index page */
2830 xad_t *xad;
2831 pxd_t *pxd;
2832 s64 xoff, xsize;
2833 int xlen;
2834 s64 oxaddr, sxaddr, dxaddr, nextbn, prevbn;
2835 cbuf_t *cp;
2836 s64 offset, nbytes, nbrd, pno;
2837 int nb, npages, nblks;
2838 s64 bn;
2839 int cmp;
2840 int index;
2841 struct pxd_lock *pxdlock;
2842 struct btstack btstack; /* traverse stack */
2843
2844 xtype = xtype & EXTENT_TYPE;
2845
2846 xoff = offsetXAD(oxad);
2847 oxaddr = addressXAD(oxad);
2848 xlen = lengthXAD(oxad);
2849
2850 /* validate extent offset */
2851 offset = xoff << JFS_SBI(ip->i_sb)->l2bsize;
2852 if (offset >= ip->i_size)
2853 return -ESTALE; /* stale extent */
2854
2855 jfs_info("xtRelocate: xtype:%d xoff:0x%lx xlen:0x%x xaddr:0x%lx:0x%lx",
2856 xtype, (ulong) xoff, xlen, (ulong) oxaddr, (ulong) nxaddr);
2857
2858 /*
2859 * 1. get and validate the parent xtpage/xad entry
2860 * covering the source extent to be relocated;
2861 */
2862 if (xtype == DATAEXT) {
2863 /* search in leaf entry */
2864 rc = xtSearch(ip, xoff, NULL, &cmp, &btstack, 0);
2865 if (rc)
2866 return rc;
2867
2868 /* retrieve search result */
2869 XT_GETSEARCH(ip, btstack.top, bn, pmp, pp, index);
2870
2871 if (cmp) {
2872 XT_PUTPAGE(pmp);
2873 return -ESTALE;
2874 }
2875
2876 /* validate for exact match with a single entry */
2877 xad = &pp->xad[index];
2878 if (addressXAD(xad) != oxaddr || lengthXAD(xad) != xlen) {
2879 XT_PUTPAGE(pmp);
2880 return -ESTALE;
2881 }
2882 } else { /* (xtype == XTPAGE) */
2883
2884 /* search in internal entry */
2885 rc = xtSearchNode(ip, oxad, &cmp, &btstack, 0);
2886 if (rc)
2887 return rc;
2888
2889 /* retrieve search result */
2890 XT_GETSEARCH(ip, btstack.top, bn, pmp, pp, index);
2891
2892 if (cmp) {
2893 XT_PUTPAGE(pmp);
2894 return -ESTALE;
2895 }
2896
2897 /* xtSearchNode() validated for exact match with a single entry
2898 */
2899 xad = &pp->xad[index];
2900 }
2901 jfs_info("xtRelocate: parent xad entry validated.");
2902
2903 /*
2904 * 2. relocate the extent
2905 */
2906 if (xtype == DATAEXT) {
2907 /* if the extent is allocated-but-not-recorded
2908 * there is no real data to be moved in this extent,
2909 */
2910 if (xad->flag & XAD_NOTRECORDED)
2911 goto out;
2912 else
2913 /* release xtpage for cmRead()/xtLookup() */
2914 XT_PUTPAGE(pmp);
2915
2916 /*
2917 * cmRelocate()
2918 *
2919 * copy target data pages to be relocated;
2920 *
2921 * data extent must start at page boundary and
2922 * multiple of page size (except the last data extent);
2923 * read in each page of the source data extent into cbuf,
2924 * update the cbuf extent descriptor of the page to be
2925 * homeward bound to new dst data extent
2926 * copy the data from the old extent to new extent.
2927 * copy is essential for compressed files to avoid problems
2928 * that can arise if there was a change in compression
2929 * algorithms.
2930 * it is a good strategy because it may disrupt cache
2931 * policy to keep the pages in memory afterwards.
2932 */
2933 offset = xoff << JFS_SBI(ip->i_sb)->l2bsize;
2934 assert((offset & CM_OFFSET) == 0);
2935 nbytes = xlen << JFS_SBI(ip->i_sb)->l2bsize;
2936 pno = offset >> CM_L2BSIZE;
2937 npages = (nbytes + (CM_BSIZE - 1)) >> CM_L2BSIZE;
2938 /*
2939 npages = ((offset + nbytes - 1) >> CM_L2BSIZE) -
2940 (offset >> CM_L2BSIZE) + 1;
2941 */
2942 sxaddr = oxaddr;
2943 dxaddr = nxaddr;
2944
2945 /* process the request one cache buffer at a time */
2946 for (nbrd = 0; nbrd < nbytes; nbrd += nb,
2947 offset += nb, pno++, npages--) {
2948 /* compute page size */
2949 nb = min(nbytes - nbrd, CM_BSIZE);
2950
2951 /* get the cache buffer of the page */
2952 if (rc = cmRead(ip, offset, npages, &cp))
2953 break;
2954
2955 assert(addressPXD(&cp->cm_pxd) == sxaddr);
2956 assert(!cp->cm_modified);
2957
2958 /* bind buffer with the new extent address */
2959 nblks = nb >> JFS_IP(ip->i_sb)->l2bsize;
2960 cmSetXD(ip, cp, pno, dxaddr, nblks);
2961
2962 /* release the cbuf, mark it as modified */
2963 cmPut(cp, true);
2964
2965 dxaddr += nblks;
2966 sxaddr += nblks;
2967 }
2968
2969 /* get back parent page */
2970 if ((rc = xtSearch(ip, xoff, NULL, &cmp, &btstack, 0)))
2971 return rc;
2972
2973 XT_GETSEARCH(ip, btstack.top, bn, pmp, pp, index);
2974 jfs_info("xtRelocate: target data extent relocated.");
2975 } else { /* (xtype == XTPAGE) */
2976
2977 /*
2978 * read in the target xtpage from the source extent;
2979 */
2980 XT_GETPAGE(ip, oxaddr, mp, PSIZE, p, rc);
2981 if (rc) {
2982 XT_PUTPAGE(pmp);
2983 return rc;
2984 }
2985
2986 /*
2987 * read in sibling pages if any to update sibling pointers;
2988 */
2989 rmp = NULL;
2990 if (p->header.next) {
2991 nextbn = le64_to_cpu(p->header.next);
2992 XT_GETPAGE(ip, nextbn, rmp, PSIZE, rp, rc);
2993 if (rc) {
2994 XT_PUTPAGE(pmp);
2995 XT_PUTPAGE(mp);
2996 return (rc);
2997 }
2998 }
2999
3000 lmp = NULL;
3001 if (p->header.prev) {
3002 prevbn = le64_to_cpu(p->header.prev);
3003 XT_GETPAGE(ip, prevbn, lmp, PSIZE, lp, rc);
3004 if (rc) {
3005 XT_PUTPAGE(pmp);
3006 XT_PUTPAGE(mp);
3007 if (rmp)
3008 XT_PUTPAGE(rmp);
3009 return (rc);
3010 }
3011 }
3012
3013 /* at this point, all xtpages to be updated are in memory */
3014
3015 /*
3016 * update sibling pointers of sibling xtpages if any;
3017 */
3018 if (lmp) {
3019 BT_MARK_DIRTY(lmp, ip);
3020 tlck = txLock(tid, ip, lmp, tlckXTREE | tlckRELINK);
3021 lp->header.next = cpu_to_le64(nxaddr);
3022 XT_PUTPAGE(lmp);
3023 }
3024
3025 if (rmp) {
3026 BT_MARK_DIRTY(rmp, ip);
3027 tlck = txLock(tid, ip, rmp, tlckXTREE | tlckRELINK);
3028 rp->header.prev = cpu_to_le64(nxaddr);
3029 XT_PUTPAGE(rmp);
3030 }
3031
3032 /*
3033 * update the target xtpage to be relocated
3034 *
3035 * update the self address of the target page
3036 * and write to destination extent;
3037 * redo image covers the whole xtpage since it is new page
3038 * to the destination extent;
3039 * update of bmap for the free of source extent
3040 * of the target xtpage itself:
3041 * update of bmap for the allocation of destination extent
3042 * of the target xtpage itself:
3043 * update of bmap for the extents covered by xad entries in
3044 * the target xtpage is not necessary since they are not
3045 * updated;
3046 * if not committed before this relocation,
3047 * target page may contain XAD_NEW entries which must
3048 * be scanned for bmap update (logredo() always
3049 * scan xtpage REDOPAGE image for bmap update);
3050 * if committed before this relocation (tlckRELOCATE),
3051 * scan may be skipped by commit() and logredo();
3052 */
3053 BT_MARK_DIRTY(mp, ip);
3054 /* tlckNEW init xtlck->lwm.offset = XTENTRYSTART; */
3055 tlck = txLock(tid, ip, mp, tlckXTREE | tlckNEW);
3056 xtlck = (struct xtlock *) & tlck->lock;
3057
3058 /* update the self address in the xtpage header */
3059 pxd = &p->header.self;
3060 PXDaddress(pxd, nxaddr);
3061
3062 /* linelock for the after image of the whole page */
3063 xtlck->lwm.length =
3064 le16_to_cpu(p->header.nextindex) - xtlck->lwm.offset;
3065
3066 /* update the buffer extent descriptor of target xtpage */
3067 xsize = xlen << JFS_SBI(ip->i_sb)->l2bsize;
3068 bmSetXD(mp, nxaddr, xsize);
3069
3070 /* unpin the target page to new homeward bound */
3071 XT_PUTPAGE(mp);
3072 jfs_info("xtRelocate: target xtpage relocated.");
3073 }
3074
3075 /*
3076 * 3. acquire maplock for the source extent to be freed;
3077 *
3078 * acquire a maplock saving the src relocated extent address;
3079 * to free of the extent at commit time;
3080 */
3081 out:
3082 /* if DATAEXT relocation, write a LOG_UPDATEMAP record for
3083 * free PXD of the source data extent (logredo() will update
3084 * bmap for free of source data extent), and update bmap for
3085 * free of the source data extent;
3086 */
3087 if (xtype == DATAEXT)
3088 tlck = txMaplock(tid, ip, tlckMAP);
3089 /* if XTPAGE relocation, write a LOG_NOREDOPAGE record
3090 * for the source xtpage (logredo() will init NoRedoPage
3091 * filter and will also update bmap for free of the source
3092 * xtpage), and update bmap for free of the source xtpage;
3093 * N.B. We use tlckMAP instead of tlkcXTREE because there
3094 * is no buffer associated with this lock since the buffer
3095 * has been redirected to the target location.
3096 */
3097 else /* (xtype == XTPAGE) */
3098 tlck = txMaplock(tid, ip, tlckMAP | tlckRELOCATE);
3099
3100 pxdlock = (struct pxd_lock *) & tlck->lock;
3101 pxdlock->flag = mlckFREEPXD;
3102 PXDaddress(&pxdlock->pxd, oxaddr);
3103 PXDlength(&pxdlock->pxd, xlen);
3104 pxdlock->index = 1;
3105
3106 /*
3107 * 4. update the parent xad entry for relocation;
3108 *
3109 * acquire tlck for the parent entry with XAD_NEW as entry
3110 * update which will write LOG_REDOPAGE and update bmap for
3111 * allocation of XAD_NEW destination extent;
3112 */
3113 jfs_info("xtRelocate: update parent xad entry.");
3114 BT_MARK_DIRTY(pmp, ip);
3115 tlck = txLock(tid, ip, pmp, tlckXTREE | tlckGROW);
3116 xtlck = (struct xtlock *) & tlck->lock;
3117
3118 /* update the XAD with the new destination extent; */
3119 xad = &pp->xad[index];
3120 xad->flag |= XAD_NEW;
3121 XADaddress(xad, nxaddr);
3122
3123 xtlck->lwm.offset = min(index, xtlck->lwm.offset);
3124 xtlck->lwm.length = le16_to_cpu(pp->header.nextindex) -
3125 xtlck->lwm.offset;
3126
3127 /* unpin the parent xtpage */
3128 XT_PUTPAGE(pmp);
3129
3130 return rc;
3131 }
3132
3133
3134 /*
3135 * xtSearchNode()
3136 *
3137 * function: search for the internal xad entry covering specified extent.
3138 * This function is mainly used by defragfs utility.
3139 *
3140 * parameters:
3141 * ip - file object;
3142 * xad - extent to find;
3143 * cmpp - comparison result:
3144 * btstack - traverse stack;
3145 * flag - search process flag;
3146 *
3147 * returns:
3148 * btstack contains (bn, index) of search path traversed to the entry.
3149 * *cmpp is set to result of comparison with the entry returned.
3150 * the page containing the entry is pinned at exit.
3151 */
3152 static int xtSearchNode(struct inode *ip, xad_t * xad, /* required XAD entry */
3153 int *cmpp, struct btstack * btstack, int flag)
3154 {
3155 int rc = 0;
3156 s64 xoff, xaddr;
3157 int xlen;
3158 int cmp = 1; /* init for empty page */
3159 s64 bn; /* block number */
3160 struct metapage *mp; /* meta-page buffer */
3161 xtpage_t *p; /* page */
3162 int base, index, lim;
3163 struct btframe *btsp;
3164 s64 t64;
3165
3166 BT_CLR(btstack);
3167
3168 xoff = offsetXAD(xad);
3169 xlen = lengthXAD(xad);
3170 xaddr = addressXAD(xad);
3171
3172 /*
3173 * search down tree from root:
3174 *
3175 * between two consecutive entries of <Ki, Pi> and <Kj, Pj> of
3176 * internal page, child page Pi contains entry with k, Ki <= K < Kj.
3177 *
3178 * if entry with search key K is not found
3179 * internal page search find the entry with largest key Ki
3180 * less than K which point to the child page to search;
3181 * leaf page search find the entry with smallest key Kj
3182 * greater than K so that the returned index is the position of
3183 * the entry to be shifted right for insertion of new entry.
3184 * for empty tree, search key is greater than any key of the tree.
3185 *
3186 * by convention, root bn = 0.
3187 */
3188 for (bn = 0;;) {
3189 /* get/pin the page to search */
3190 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
3191 if (rc)
3192 return rc;
3193 if (p->header.flag & BT_LEAF) {
3194 XT_PUTPAGE(mp);
3195 return -ESTALE;
3196 }
3197
3198 lim = le16_to_cpu(p->header.nextindex) - XTENTRYSTART;
3199
3200 /*
3201 * binary search with search key K on the current page
3202 */
3203 for (base = XTENTRYSTART; lim; lim >>= 1) {
3204 index = base + (lim >> 1);
3205
3206 XT_CMP(cmp, xoff, &p->xad[index], t64);
3207 if (cmp == 0) {
3208 /*
3209 * search hit
3210 *
3211 * verify for exact match;
3212 */
3213 if (xaddr == addressXAD(&p->xad[index]) &&
3214 xoff == offsetXAD(&p->xad[index])) {
3215 *cmpp = cmp;
3216
3217 /* save search result */
3218 btsp = btstack->top;
3219 btsp->bn = bn;
3220 btsp->index = index;
3221 btsp->mp = mp;
3222
3223 return 0;
3224 }
3225
3226 /* descend/search its child page */
3227 goto next;
3228 }
3229
3230 if (cmp > 0) {
3231 base = index + 1;
3232 --lim;
3233 }
3234 }
3235
3236 /*
3237 * search miss - non-leaf page:
3238 *
3239 * base is the smallest index with key (Kj) greater than
3240 * search key (K) and may be zero or maxentry index.
3241 * if base is non-zero, decrement base by one to get the parent
3242 * entry of the child page to search.
3243 */
3244 index = base ? base - 1 : base;
3245
3246 /*
3247 * go down to child page
3248 */
3249 next:
3250 /* get the child page block number */
3251 bn = addressXAD(&p->xad[index]);
3252
3253 /* unpin the parent page */
3254 XT_PUTPAGE(mp);
3255 }
3256 }
3257
3258
3259 /*
3260 * xtRelink()
3261 *
3262 * function:
3263 * link around a freed page.
3264 *
3265 * Parameter:
3266 * int tid,
3267 * struct inode *ip,
3268 * xtpage_t *p)
3269 *
3270 * returns:
3271 */
3272 static int xtRelink(tid_t tid, struct inode *ip, xtpage_t * p)
3273 {
3274 int rc = 0;
3275 struct metapage *mp;
3276 s64 nextbn, prevbn;
3277 struct tlock *tlck;
3278
3279 nextbn = le64_to_cpu(p->header.next);
3280 prevbn = le64_to_cpu(p->header.prev);
3281
3282 /* update prev pointer of the next page */
3283 if (nextbn != 0) {
3284 XT_GETPAGE(ip, nextbn, mp, PSIZE, p, rc);
3285 if (rc)
3286 return rc;
3287
3288 /*
3289 * acquire a transaction lock on the page;
3290 *
3291 * action: update prev pointer;
3292 */
3293 BT_MARK_DIRTY(mp, ip);
3294 tlck = txLock(tid, ip, mp, tlckXTREE | tlckRELINK);
3295
3296 /* the page may already have been tlock'd */
3297
3298 p->header.prev = cpu_to_le64(prevbn);
3299
3300 XT_PUTPAGE(mp);
3301 }
3302
3303 /* update next pointer of the previous page */
3304 if (prevbn != 0) {
3305 XT_GETPAGE(ip, prevbn, mp, PSIZE, p, rc);
3306 if (rc)
3307 return rc;
3308
3309 /*
3310 * acquire a transaction lock on the page;
3311 *
3312 * action: update next pointer;
3313 */
3314 BT_MARK_DIRTY(mp, ip);
3315 tlck = txLock(tid, ip, mp, tlckXTREE | tlckRELINK);
3316
3317 /* the page may already have been tlock'd */
3318
3319 p->header.next = le64_to_cpu(nextbn);
3320
3321 XT_PUTPAGE(mp);
3322 }
3323
3324 return 0;
3325 }
3326 #endif /* _STILL_TO_PORT */
3327
3328
3329 /*
3330 * xtInitRoot()
3331 *
3332 * initialize file root (inline in inode)
3333 */
3334 void xtInitRoot(tid_t tid, struct inode *ip)
3335 {
3336 xtpage_t *p;
3337
3338 /*
3339 * acquire a transaction lock on the root
3340 *
3341 * action:
3342 */
3343 txLock(tid, ip, (struct metapage *) &JFS_IP(ip)->bxflag,
3344 tlckXTREE | tlckNEW);
3345 p = &JFS_IP(ip)->i_xtroot;
3346
3347 p->header.flag = DXD_INDEX | BT_ROOT | BT_LEAF;
3348 p->header.nextindex = cpu_to_le16(XTENTRYSTART);
3349
3350 if (S_ISDIR(ip->i_mode))
3351 p->header.maxentry = cpu_to_le16(XTROOTINITSLOT_DIR);
3352 else {
3353 p->header.maxentry = cpu_to_le16(XTROOTINITSLOT);
3354 ip->i_size = 0;
3355 }
3356
3357
3358 return;
3359 }
3360
3361
3362 /*
3363 * We can run into a deadlock truncating a file with a large number of
3364 * xtree pages (large fragmented file). A robust fix would entail a
3365 * reservation system where we would reserve a number of metadata pages
3366 * and tlocks which we would be guaranteed without a deadlock. Without
3367 * this, a partial fix is to limit number of metadata pages we will lock
3368 * in a single transaction. Currently we will truncate the file so that
3369 * no more than 50 leaf pages will be locked. The caller of xtTruncate
3370 * will be responsible for ensuring that the current transaction gets
3371 * committed, and that subsequent transactions are created to truncate
3372 * the file further if needed.
3373 */
3374 #define MAX_TRUNCATE_LEAVES 50
3375
3376 /*
3377 * xtTruncate()
3378 *
3379 * function:
3380 * traverse for truncation logging backward bottom up;
3381 * terminate at the last extent entry at the current subtree
3382 * root page covering new down size.
3383 * truncation may occur within the last extent entry.
3384 *
3385 * parameter:
3386 * int tid,
3387 * struct inode *ip,
3388 * s64 newsize,
3389 * int type) {PWMAP, PMAP, WMAP; DELETE, TRUNCATE}
3390 *
3391 * return:
3392 *
3393 * note:
3394 * PWMAP:
3395 * 1. truncate (non-COMMIT_NOLINK file)
3396 * by jfs_truncate() or jfs_open(O_TRUNC):
3397 * xtree is updated;
3398 * 2. truncate index table of directory when last entry removed
3399 * map update via tlock at commit time;
3400 * PMAP:
3401 * Call xtTruncate_pmap instead
3402 * WMAP:
3403 * 1. remove (free zero link count) on last reference release
3404 * (pmap has been freed at commit zero link count);
3405 * 2. truncate (COMMIT_NOLINK file, i.e., tmp file):
3406 * xtree is updated;
3407 * map update directly at truncation time;
3408 *
3409 * if (DELETE)
3410 * no LOG_NOREDOPAGE is required (NOREDOFILE is sufficient);
3411 * else if (TRUNCATE)
3412 * must write LOG_NOREDOPAGE for deleted index page;
3413 *
3414 * pages may already have been tlocked by anonymous transactions
3415 * during file growth (i.e., write) before truncation;
3416 *
3417 * except last truncated entry, deleted entries remains as is
3418 * in the page (nextindex is updated) for other use
3419 * (e.g., log/update allocation map): this avoid copying the page
3420 * info but delay free of pages;
3421 *
3422 */
3423 s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
3424 {
3425 int rc = 0;
3426 s64 teof;
3427 struct metapage *mp;
3428 xtpage_t *p;
3429 s64 bn;
3430 int index, nextindex;
3431 xad_t *xad;
3432 s64 xoff, xaddr;
3433 int xlen, len, freexlen;
3434 struct btstack btstack;
3435 struct btframe *parent;
3436 struct tblock *tblk = NULL;
3437 struct tlock *tlck = NULL;
3438 struct xtlock *xtlck = NULL;
3439 struct xdlistlock xadlock; /* maplock for COMMIT_WMAP */
3440 struct pxd_lock *pxdlock; /* maplock for COMMIT_WMAP */
3441 s64 nfreed;
3442 int freed, log;
3443 int locked_leaves = 0;
3444
3445 /* save object truncation type */
3446 if (tid) {
3447 tblk = tid_to_tblock(tid);
3448 tblk->xflag |= flag;
3449 }
3450
3451 nfreed = 0;
3452
3453 flag &= COMMIT_MAP;
3454 assert(flag != COMMIT_PMAP);
3455
3456 if (flag == COMMIT_PWMAP)
3457 log = 1;
3458 else {
3459 log = 0;
3460 xadlock.flag = mlckFREEXADLIST;
3461 xadlock.index = 1;
3462 }
3463
3464 /*
3465 * if the newsize is not an integral number of pages,
3466 * the file between newsize and next page boundary will
3467 * be cleared.
3468 * if truncating into a file hole, it will cause
3469 * a full block to be allocated for the logical block.
3470 */
3471
3472 /*
3473 * release page blocks of truncated region <teof, eof>
3474 *
3475 * free the data blocks from the leaf index blocks.
3476 * delete the parent index entries corresponding to
3477 * the freed child data/index blocks.
3478 * free the index blocks themselves which aren't needed
3479 * in new sized file.
3480 *
3481 * index blocks are updated only if the blocks are to be
3482 * retained in the new sized file.
3483 * if type is PMAP, the data and index pages are NOT
3484 * freed, and the data and index blocks are NOT freed
3485 * from working map.
3486 * (this will allow continued access of data/index of
3487 * temporary file (zerolink count file truncated to zero-length)).
3488 */
3489 teof = (newsize + (JFS_SBI(ip->i_sb)->bsize - 1)) >>
3490 JFS_SBI(ip->i_sb)->l2bsize;
3491
3492 /* clear stack */
3493 BT_CLR(&btstack);
3494
3495 /*
3496 * start with root
3497 *
3498 * root resides in the inode
3499 */
3500 bn = 0;
3501
3502 /*
3503 * first access of each page:
3504 */
3505 getPage:
3506 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
3507 if (rc)
3508 return rc;
3509
3510 /* process entries backward from last index */
3511 index = le16_to_cpu(p->header.nextindex) - 1;
3512
3513
3514 /* Since this is the rightmost page at this level, and we may have
3515 * already freed a page that was formerly to the right, let's make
3516 * sure that the next pointer is zero.
3517 */
3518 if (p->header.next) {
3519 if (log)
3520 /*
3521 * Make sure this change to the header is logged.
3522 * If we really truncate this leaf, the flag
3523 * will be changed to tlckTRUNCATE
3524 */
3525 tlck = txLock(tid, ip, mp, tlckXTREE|tlckGROW);
3526 BT_MARK_DIRTY(mp, ip);
3527 p->header.next = 0;
3528 }
3529
3530 if (p->header.flag & BT_INTERNAL)
3531 goto getChild;
3532
3533 /*
3534 * leaf page
3535 */
3536 freed = 0;
3537
3538 /* does region covered by leaf page precede Teof ? */
3539 xad = &p->xad[index];
3540 xoff = offsetXAD(xad);
3541 xlen = lengthXAD(xad);
3542 if (teof >= xoff + xlen) {
3543 XT_PUTPAGE(mp);
3544 goto getParent;
3545 }
3546
3547 /* (re)acquire tlock of the leaf page */
3548 if (log) {
3549 if (++locked_leaves > MAX_TRUNCATE_LEAVES) {
3550 /*
3551 * We need to limit the size of the transaction
3552 * to avoid exhausting pagecache & tlocks
3553 */
3554 XT_PUTPAGE(mp);
3555 newsize = (xoff + xlen) << JFS_SBI(ip->i_sb)->l2bsize;
3556 goto getParent;
3557 }
3558 tlck = txLock(tid, ip, mp, tlckXTREE);
3559 tlck->type = tlckXTREE | tlckTRUNCATE;
3560 xtlck = (struct xtlock *) & tlck->lock;
3561 xtlck->hwm.offset = le16_to_cpu(p->header.nextindex) - 1;
3562 }
3563 BT_MARK_DIRTY(mp, ip);
3564
3565 /*
3566 * scan backward leaf page entries
3567 */
3568 for (; index >= XTENTRYSTART; index--) {
3569 xad = &p->xad[index];
3570 xoff = offsetXAD(xad);
3571 xlen = lengthXAD(xad);
3572 xaddr = addressXAD(xad);
3573
3574 /*
3575 * The "data" for a directory is indexed by the block
3576 * device's address space. This metadata must be invalidated
3577 * here
3578 */
3579 if (S_ISDIR(ip->i_mode) && (teof == 0))
3580 invalidate_xad_metapages(ip, *xad);
3581 /*
3582 * entry beyond eof: continue scan of current page
3583 * xad
3584 * ---|---=======------->
3585 * eof
3586 */
3587 if (teof < xoff) {
3588 nfreed += xlen;
3589 continue;
3590 }
3591
3592 /*
3593 * (xoff <= teof): last entry to be deleted from page;
3594 * If other entries remain in page: keep and update the page.
3595 */
3596
3597 /*
3598 * eof == entry_start: delete the entry
3599 * xad
3600 * -------|=======------->
3601 * eof
3602 *
3603 */
3604 if (teof == xoff) {
3605 nfreed += xlen;
3606
3607 if (index == XTENTRYSTART)
3608 break;
3609
3610 nextindex = index;
3611 }
3612 /*
3613 * eof within the entry: truncate the entry.
3614 * xad
3615 * -------===|===------->
3616 * eof
3617 */
3618 else if (teof < xoff + xlen) {
3619 /* update truncated entry */
3620 len = teof - xoff;
3621 freexlen = xlen - len;
3622 XADlength(xad, len);
3623
3624 /* save pxd of truncated extent in tlck */
3625 xaddr += len;
3626 if (log) { /* COMMIT_PWMAP */
3627 xtlck->lwm.offset = (xtlck->lwm.offset) ?
3628 min(index, (int)xtlck->lwm.offset) : index;
3629 xtlck->lwm.length = index + 1 -
3630 xtlck->lwm.offset;
3631 xtlck->twm.offset = index;
3632 pxdlock = (struct pxd_lock *) & xtlck->pxdlock;
3633 pxdlock->flag = mlckFREEPXD;
3634 PXDaddress(&pxdlock->pxd, xaddr);
3635 PXDlength(&pxdlock->pxd, freexlen);
3636 }
3637 /* free truncated extent */
3638 else { /* COMMIT_WMAP */
3639
3640 pxdlock = (struct pxd_lock *) & xadlock;
3641 pxdlock->flag = mlckFREEPXD;
3642 PXDaddress(&pxdlock->pxd, xaddr);
3643 PXDlength(&pxdlock->pxd, freexlen);
3644 txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
3645
3646 /* reset map lock */
3647 xadlock.flag = mlckFREEXADLIST;
3648 }
3649
3650 /* current entry is new last entry; */
3651 nextindex = index + 1;
3652
3653 nfreed += freexlen;
3654 }
3655 /*
3656 * eof beyond the entry:
3657 * xad
3658 * -------=======---|--->
3659 * eof
3660 */
3661 else { /* (xoff + xlen < teof) */
3662
3663 nextindex = index + 1;
3664 }
3665
3666 if (nextindex < le16_to_cpu(p->header.nextindex)) {
3667 if (!log) { /* COMMIT_WAMP */
3668 xadlock.xdlist = &p->xad[nextindex];
3669 xadlock.count =
3670 le16_to_cpu(p->header.nextindex) -
3671 nextindex;
3672 txFreeMap(ip, (struct maplock *) & xadlock,
3673 NULL, COMMIT_WMAP);
3674 }
3675 p->header.nextindex = cpu_to_le16(nextindex);
3676 }
3677
3678 XT_PUTPAGE(mp);
3679
3680 /* assert(freed == 0); */
3681 goto getParent;
3682 } /* end scan of leaf page entries */
3683
3684 freed = 1;
3685
3686 /*
3687 * leaf page become empty: free the page if type != PMAP
3688 */
3689 if (log) { /* COMMIT_PWMAP */
3690 /* txCommit() with tlckFREE:
3691 * free data extents covered by leaf [XTENTRYSTART:hwm);
3692 * invalidate leaf if COMMIT_PWMAP;
3693 * if (TRUNCATE), will write LOG_NOREDOPAGE;
3694 */
3695 tlck->type = tlckXTREE | tlckFREE;
3696 } else { /* COMMIT_WAMP */
3697
3698 /* free data extents covered by leaf */
3699 xadlock.xdlist = &p->xad[XTENTRYSTART];
3700 xadlock.count =
3701 le16_to_cpu(p->header.nextindex) - XTENTRYSTART;
3702 txFreeMap(ip, (struct maplock *) & xadlock, NULL, COMMIT_WMAP);
3703 }
3704
3705 if (p->header.flag & BT_ROOT) {
3706 p->header.flag &= ~BT_INTERNAL;
3707 p->header.flag |= BT_LEAF;
3708 p->header.nextindex = cpu_to_le16(XTENTRYSTART);
3709
3710 XT_PUTPAGE(mp); /* debug */
3711 goto out;
3712 } else {
3713 if (log) { /* COMMIT_PWMAP */
3714 /* page will be invalidated at tx completion
3715 */
3716 XT_PUTPAGE(mp);
3717 } else { /* COMMIT_WMAP */
3718
3719 if (mp->lid)
3720 lid_to_tlock(mp->lid)->flag |= tlckFREELOCK;
3721
3722 /* invalidate empty leaf page */
3723 discard_metapage(mp);
3724 }
3725 }
3726
3727 /*
3728 * the leaf page become empty: delete the parent entry
3729 * for the leaf page if the parent page is to be kept
3730 * in the new sized file.
3731 */
3732
3733 /*
3734 * go back up to the parent page
3735 */
3736 getParent:
3737 /* pop/restore parent entry for the current child page */
3738 if ((parent = BT_POP(&btstack)) == NULL)
3739 /* current page must have been root */
3740 goto out;
3741
3742 /* get back the parent page */
3743 bn = parent->bn;
3744 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
3745 if (rc)
3746 return rc;
3747
3748 index = parent->index;
3749
3750 /*
3751 * child page was not empty:
3752 */
3753 if (freed == 0) {
3754 /* has any entry deleted from parent ? */
3755 if (index < le16_to_cpu(p->header.nextindex) - 1) {
3756 /* (re)acquire tlock on the parent page */
3757 if (log) { /* COMMIT_PWMAP */
3758 /* txCommit() with tlckTRUNCATE:
3759 * free child extents covered by parent [);
3760 */
3761 tlck = txLock(tid, ip, mp, tlckXTREE);
3762 xtlck = (struct xtlock *) & tlck->lock;
3763 if (!(tlck->type & tlckTRUNCATE)) {
3764 xtlck->hwm.offset =
3765 le16_to_cpu(p->header.
3766 nextindex) - 1;
3767 tlck->type =
3768 tlckXTREE | tlckTRUNCATE;
3769 }
3770 } else { /* COMMIT_WMAP */
3771
3772 /* free child extents covered by parent */
3773 xadlock.xdlist = &p->xad[index + 1];
3774 xadlock.count =
3775 le16_to_cpu(p->header.nextindex) -
3776 index - 1;
3777 txFreeMap(ip, (struct maplock *) & xadlock,
3778 NULL, COMMIT_WMAP);
3779 }
3780 BT_MARK_DIRTY(mp, ip);
3781
3782 p->header.nextindex = cpu_to_le16(index + 1);
3783 }
3784 XT_PUTPAGE(mp);
3785 goto getParent;
3786 }
3787
3788 /*
3789 * child page was empty:
3790 */
3791 nfreed += lengthXAD(&p->xad[index]);
3792
3793 /*
3794 * During working map update, child page's tlock must be handled
3795 * before parent's. This is because the parent's tlock will cause
3796 * the child's disk space to be marked available in the wmap, so
3797 * it's important that the child page be released by that time.
3798 *
3799 * ToDo: tlocks should be on doubly-linked list, so we can
3800 * quickly remove it and add it to the end.
3801 */
3802
3803 /*
3804 * Move parent page's tlock to the end of the tid's tlock list
3805 */
3806 if (log && mp->lid && (tblk->last != mp->lid) &&
3807 lid_to_tlock(mp->lid)->tid) {
3808 lid_t lid = mp->lid;
3809 struct tlock *prev;
3810
3811 tlck = lid_to_tlock(lid);
3812
3813 if (tblk->next == lid)
3814 tblk->next = tlck->next;
3815 else {
3816 for (prev = lid_to_tlock(tblk->next);
3817 prev->next != lid;
3818 prev = lid_to_tlock(prev->next)) {
3819 assert(prev->next);
3820 }
3821 prev->next = tlck->next;
3822 }
3823 lid_to_tlock(tblk->last)->next = lid;
3824 tlck->next = 0;
3825 tblk->last = lid;
3826 }
3827
3828 /*
3829 * parent page become empty: free the page
3830 */
3831 if (index == XTENTRYSTART) {
3832 if (log) { /* COMMIT_PWMAP */
3833 /* txCommit() with tlckFREE:
3834 * free child extents covered by parent;
3835 * invalidate parent if COMMIT_PWMAP;
3836 */
3837 tlck = txLock(tid, ip, mp, tlckXTREE);
3838 xtlck = (struct xtlock *) & tlck->lock;
3839 xtlck->hwm.offset =
3840 le16_to_cpu(p->header.nextindex) - 1;
3841 tlck->type = tlckXTREE | tlckFREE;
3842 } else { /* COMMIT_WMAP */
3843
3844 /* free child extents covered by parent */
3845 xadlock.xdlist = &p->xad[XTENTRYSTART];
3846 xadlock.count =
3847 le16_to_cpu(p->header.nextindex) -
3848 XTENTRYSTART;
3849 txFreeMap(ip, (struct maplock *) & xadlock, NULL,
3850 COMMIT_WMAP);
3851 }
3852 BT_MARK_DIRTY(mp, ip);
3853
3854 if (p->header.flag & BT_ROOT) {
3855 p->header.flag &= ~BT_INTERNAL;
3856 p->header.flag |= BT_LEAF;
3857 p->header.nextindex = cpu_to_le16(XTENTRYSTART);
3858 if (le16_to_cpu(p->header.maxentry) == XTROOTMAXSLOT) {
3859 /*
3860 * Shrink root down to allow inline
3861 * EA (otherwise fsck complains)
3862 */
3863 p->header.maxentry =
3864 cpu_to_le16(XTROOTINITSLOT);
3865 JFS_IP(ip)->mode2 |= INLINEEA;
3866 }
3867
3868 XT_PUTPAGE(mp); /* debug */
3869 goto out;
3870 } else {
3871 if (log) { /* COMMIT_PWMAP */
3872 /* page will be invalidated at tx completion
3873 */
3874 XT_PUTPAGE(mp);
3875 } else { /* COMMIT_WMAP */
3876
3877 if (mp->lid)
3878 lid_to_tlock(mp->lid)->flag |=
3879 tlckFREELOCK;
3880
3881 /* invalidate parent page */
3882 discard_metapage(mp);
3883 }
3884
3885 /* parent has become empty and freed:
3886 * go back up to its parent page
3887 */
3888 /* freed = 1; */
3889 goto getParent;
3890 }
3891 }
3892 /*
3893 * parent page still has entries for front region;
3894 */
3895 else {
3896 /* try truncate region covered by preceding entry
3897 * (process backward)
3898 */
3899 index--;
3900
3901 /* go back down to the child page corresponding
3902 * to the entry
3903 */
3904 goto getChild;
3905 }
3906
3907 /*
3908 * internal page: go down to child page of current entry
3909 */
3910 getChild:
3911 /* save current parent entry for the child page */
3912 if (BT_STACK_FULL(&btstack)) {
3913 jfs_error(ip->i_sb, "stack overrun in xtTruncate!");
3914 XT_PUTPAGE(mp);
3915 return -EIO;
3916 }
3917 BT_PUSH(&btstack, bn, index);
3918
3919 /* get child page */
3920 xad = &p->xad[index];
3921 bn = addressXAD(xad);
3922
3923 /*
3924 * first access of each internal entry:
3925 */
3926 /* release parent page */
3927 XT_PUTPAGE(mp);
3928
3929 /* process the child page */
3930 goto getPage;
3931
3932 out:
3933 /*
3934 * update file resource stat
3935 */
3936 /* set size
3937 */
3938 if (S_ISDIR(ip->i_mode) && !newsize)
3939 ip->i_size = 1; /* fsck hates zero-length directories */
3940 else
3941 ip->i_size = newsize;
3942
3943 /* update quota allocation to reflect freed blocks */
3944 DQUOT_FREE_BLOCK(ip, nfreed);
3945
3946 /*
3947 * free tlock of invalidated pages
3948 */
3949 if (flag == COMMIT_WMAP)
3950 txFreelock(ip);
3951
3952 return newsize;
3953 }
3954
3955
3956 /*
3957 * xtTruncate_pmap()
3958 *
3959 * function:
3960 * Perform truncate to zero length for deleted file, leaving the
3961 * the xtree and working map untouched. This allows the file to
3962 * be accessed via open file handles, while the delete of the file
3963 * is committed to disk.
3964 *
3965 * parameter:
3966 * tid_t tid,
3967 * struct inode *ip,
3968 * s64 committed_size)
3969 *
3970 * return: new committed size
3971 *
3972 * note:
3973 *
3974 * To avoid deadlock by holding too many transaction locks, the
3975 * truncation may be broken up into multiple transactions.
3976 * The committed_size keeps track of part of the file has been
3977 * freed from the pmaps.
3978 */
3979 s64 xtTruncate_pmap(tid_t tid, struct inode *ip, s64 committed_size)
3980 {
3981 s64 bn;
3982 struct btstack btstack;
3983 int cmp;
3984 int index;
3985 int locked_leaves = 0;
3986 struct metapage *mp;
3987 xtpage_t *p;
3988 struct btframe *parent;
3989 int rc;
3990 struct tblock *tblk;
3991 struct tlock *tlck = NULL;
3992 xad_t *xad;
3993 int xlen;
3994 s64 xoff;
3995 struct xtlock *xtlck = NULL;
3996
3997 /* save object truncation type */
3998 tblk = tid_to_tblock(tid);
3999 tblk->xflag |= COMMIT_PMAP;
4000
4001 /* clear stack */
4002 BT_CLR(&btstack);
4003
4004 if (committed_size) {
4005 xoff = (committed_size >> JFS_SBI(ip->i_sb)->l2bsize) - 1;
4006 rc = xtSearch(ip, xoff, NULL, &cmp, &btstack, 0);
4007 if (rc)
4008 return rc;
4009
4010 XT_GETSEARCH(ip, btstack.top, bn, mp, p, index);
4011
4012 if (cmp != 0) {
4013 XT_PUTPAGE(mp);
4014 jfs_error(ip->i_sb,
4015 "xtTruncate_pmap: did not find extent");
4016 return -EIO;
4017 }
4018 } else {
4019 /*
4020 * start with root
4021 *
4022 * root resides in the inode
4023 */
4024 bn = 0;
4025
4026 /*
4027 * first access of each page:
4028 */
4029 getPage:
4030 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
4031 if (rc)
4032 return rc;
4033
4034 /* process entries backward from last index */
4035 index = le16_to_cpu(p->header.nextindex) - 1;
4036
4037 if (p->header.flag & BT_INTERNAL)
4038 goto getChild;
4039 }
4040
4041 /*
4042 * leaf page
4043 */
4044
4045 if (++locked_leaves > MAX_TRUNCATE_LEAVES) {
4046 /*
4047 * We need to limit the size of the transaction
4048 * to avoid exhausting pagecache & tlocks
4049 */
4050 xad = &p->xad[index];
4051 xoff = offsetXAD(xad);
4052 xlen = lengthXAD(xad);
4053 XT_PUTPAGE(mp);
4054 return (xoff + xlen) << JFS_SBI(ip->i_sb)->l2bsize;
4055 }
4056 tlck = txLock(tid, ip, mp, tlckXTREE);
4057 tlck->type = tlckXTREE | tlckFREE;
4058 xtlck = (struct xtlock *) & tlck->lock;
4059 xtlck->hwm.offset = index;
4060
4061
4062 XT_PUTPAGE(mp);
4063
4064 /*
4065 * go back up to the parent page
4066 */
4067 getParent:
4068 /* pop/restore parent entry for the current child page */
4069 if ((parent = BT_POP(&btstack)) == NULL)
4070 /* current page must have been root */
4071 goto out;
4072
4073 /* get back the parent page */
4074 bn = parent->bn;
4075 XT_GETPAGE(ip, bn, mp, PSIZE, p, rc);
4076 if (rc)
4077 return rc;
4078
4079 index = parent->index;
4080
4081 /*
4082 * parent page become empty: free the page
4083 */
4084 if (index == XTENTRYSTART) {
4085 /* txCommit() with tlckFREE:
4086 * free child extents covered by parent;
4087 * invalidate parent if COMMIT_PWMAP;
4088 */
4089 tlck = txLock(tid, ip, mp, tlckXTREE);
4090 xtlck = (struct xtlock *) & tlck->lock;
4091 xtlck->hwm.offset = le16_to_cpu(p->header.nextindex) - 1;
4092 tlck->type = tlckXTREE | tlckFREE;
4093
4094 XT_PUTPAGE(mp);
4095
4096 if (p->header.flag & BT_ROOT) {
4097
4098 goto out;
4099 } else {
4100 goto getParent;
4101 }
4102 }
4103 /*
4104 * parent page still has entries for front region;
4105 */
4106 else
4107 index--;
4108 /*
4109 * internal page: go down to child page of current entry
4110 */
4111 getChild:
4112 /* save current parent entry for the child page */
4113 if (BT_STACK_FULL(&btstack)) {
4114 jfs_error(ip->i_sb, "stack overrun in xtTruncate_pmap!");
4115 XT_PUTPAGE(mp);
4116 return -EIO;
4117 }
4118 BT_PUSH(&btstack, bn, index);
4119
4120 /* get child page */
4121 xad = &p->xad[index];
4122 bn = addressXAD(xad);
4123
4124 /*
4125 * first access of each internal entry:
4126 */
4127 /* release parent page */
4128 XT_PUTPAGE(mp);
4129
4130 /* process the child page */
4131 goto getPage;
4132
4133 out:
4134
4135 return 0;
4136 }
4137
4138 #ifdef CONFIG_JFS_STATISTICS
4139 static int jfs_xtstat_proc_show(struct seq_file *m, void *v)
4140 {
4141 seq_printf(m,
4142 "JFS Xtree statistics\n"
4143 "====================\n"
4144 "searches = %d\n"
4145 "fast searches = %d\n"
4146 "splits = %d\n",
4147 xtStat.search,
4148 xtStat.fastSearch,
4149 xtStat.split);
4150 return 0;
4151 }
4152
4153 static int jfs_xtstat_proc_open(struct inode *inode, struct file *file)
4154 {
4155 return single_open(file, jfs_xtstat_proc_show, NULL);
4156 }
4157
4158 const struct file_operations jfs_xtstat_proc_fops = {
4159 .owner = THIS_MODULE,
4160 .open = jfs_xtstat_proc_open,
4161 .read = seq_read,
4162 .llseek = seq_lseek,
4163 .release = single_release,
4164 };
4165 #endif
Linux with added FPC-III support