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