forked from torvalds/linux
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathxfs_ialloc_btree.c
2080 lines (2019 loc) · 60.3 KB
/
xfs_ialloc_btree.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_types.h"
#include "xfs_bit.h"
#include "xfs_log.h"
#include "xfs_inum.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir.h"
#include "xfs_dir2.h"
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_dir_sf.h"
#include "xfs_dir2_sf.h"
#include "xfs_attr_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_btree.h"
#include "xfs_ialloc.h"
#include "xfs_alloc.h"
#include "xfs_error.h"
STATIC void xfs_inobt_log_block(xfs_trans_t *, xfs_buf_t *, int);
STATIC void xfs_inobt_log_keys(xfs_btree_cur_t *, xfs_buf_t *, int, int);
STATIC void xfs_inobt_log_ptrs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
STATIC void xfs_inobt_log_recs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
STATIC int xfs_inobt_lshift(xfs_btree_cur_t *, int, int *);
STATIC int xfs_inobt_newroot(xfs_btree_cur_t *, int *);
STATIC int xfs_inobt_rshift(xfs_btree_cur_t *, int, int *);
STATIC int xfs_inobt_split(xfs_btree_cur_t *, int, xfs_agblock_t *,
xfs_inobt_key_t *, xfs_btree_cur_t **, int *);
STATIC int xfs_inobt_updkey(xfs_btree_cur_t *, xfs_inobt_key_t *, int);
/*
* Single level of the xfs_inobt_delete record deletion routine.
* Delete record pointed to by cur/level.
* Remove the record from its block then rebalance the tree.
* Return 0 for error, 1 for done, 2 to go on to the next level.
*/
STATIC int /* error */
xfs_inobt_delrec(
xfs_btree_cur_t *cur, /* btree cursor */
int level, /* level removing record from */
int *stat) /* fail/done/go-on */
{
xfs_buf_t *agbp; /* buffer for a.g. inode header */
xfs_mount_t *mp; /* mount structure */
xfs_agi_t *agi; /* allocation group inode header */
xfs_inobt_block_t *block; /* btree block record/key lives in */
xfs_agblock_t bno; /* btree block number */
xfs_buf_t *bp; /* buffer for block */
int error; /* error return value */
int i; /* loop index */
xfs_inobt_key_t key; /* kp points here if block is level 0 */
xfs_inobt_key_t *kp = NULL; /* pointer to btree keys */
xfs_agblock_t lbno; /* left block's block number */
xfs_buf_t *lbp; /* left block's buffer pointer */
xfs_inobt_block_t *left; /* left btree block */
xfs_inobt_key_t *lkp; /* left block key pointer */
xfs_inobt_ptr_t *lpp; /* left block address pointer */
int lrecs = 0; /* number of records in left block */
xfs_inobt_rec_t *lrp; /* left block record pointer */
xfs_inobt_ptr_t *pp = NULL; /* pointer to btree addresses */
int ptr; /* index in btree block for this rec */
xfs_agblock_t rbno; /* right block's block number */
xfs_buf_t *rbp; /* right block's buffer pointer */
xfs_inobt_block_t *right; /* right btree block */
xfs_inobt_key_t *rkp; /* right block key pointer */
xfs_inobt_rec_t *rp; /* pointer to btree records */
xfs_inobt_ptr_t *rpp; /* right block address pointer */
int rrecs = 0; /* number of records in right block */
int numrecs;
xfs_inobt_rec_t *rrp; /* right block record pointer */
xfs_btree_cur_t *tcur; /* temporary btree cursor */
mp = cur->bc_mp;
/*
* Get the index of the entry being deleted, check for nothing there.
*/
ptr = cur->bc_ptrs[level];
if (ptr == 0) {
*stat = 0;
return 0;
}
/*
* Get the buffer & block containing the record or key/ptr.
*/
bp = cur->bc_bufs[level];
block = XFS_BUF_TO_INOBT_BLOCK(bp);
#ifdef DEBUG
if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
return error;
#endif
/*
* Fail if we're off the end of the block.
*/
numrecs = be16_to_cpu(block->bb_numrecs);
if (ptr > numrecs) {
*stat = 0;
return 0;
}
/*
* It's a nonleaf. Excise the key and ptr being deleted, by
* sliding the entries past them down one.
* Log the changed areas of the block.
*/
if (level > 0) {
kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
#ifdef DEBUG
for (i = ptr; i < numrecs; i++) {
if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(pp[i]), level)))
return error;
}
#endif
if (ptr < numrecs) {
memmove(&kp[ptr - 1], &kp[ptr],
(numrecs - ptr) * sizeof(*kp));
memmove(&pp[ptr - 1], &pp[ptr],
(numrecs - ptr) * sizeof(*kp));
xfs_inobt_log_keys(cur, bp, ptr, numrecs - 1);
xfs_inobt_log_ptrs(cur, bp, ptr, numrecs - 1);
}
}
/*
* It's a leaf. Excise the record being deleted, by sliding the
* entries past it down one. Log the changed areas of the block.
*/
else {
rp = XFS_INOBT_REC_ADDR(block, 1, cur);
if (ptr < numrecs) {
memmove(&rp[ptr - 1], &rp[ptr],
(numrecs - ptr) * sizeof(*rp));
xfs_inobt_log_recs(cur, bp, ptr, numrecs - 1);
}
/*
* If it's the first record in the block, we'll need a key
* structure to pass up to the next level (updkey).
*/
if (ptr == 1) {
key.ir_startino = rp->ir_startino;
kp = &key;
}
}
/*
* Decrement and log the number of entries in the block.
*/
numrecs--;
block->bb_numrecs = cpu_to_be16(numrecs);
xfs_inobt_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
/*
* Is this the root level? If so, we're almost done.
*/
if (level == cur->bc_nlevels - 1) {
/*
* If this is the root level,
* and there's only one entry left,
* and it's NOT the leaf level,
* then we can get rid of this level.
*/
if (numrecs == 1 && level > 0) {
agbp = cur->bc_private.i.agbp;
agi = XFS_BUF_TO_AGI(agbp);
/*
* pp is still set to the first pointer in the block.
* Make it the new root of the btree.
*/
bno = be32_to_cpu(agi->agi_root);
agi->agi_root = *pp;
be32_add(&agi->agi_level, -1);
/*
* Free the block.
*/
if ((error = xfs_free_extent(cur->bc_tp,
XFS_AGB_TO_FSB(mp, cur->bc_private.i.agno, bno), 1)))
return error;
xfs_trans_binval(cur->bc_tp, bp);
xfs_ialloc_log_agi(cur->bc_tp, agbp,
XFS_AGI_ROOT | XFS_AGI_LEVEL);
/*
* Update the cursor so there's one fewer level.
*/
cur->bc_bufs[level] = NULL;
cur->bc_nlevels--;
} else if (level > 0 &&
(error = xfs_inobt_decrement(cur, level, &i)))
return error;
*stat = 1;
return 0;
}
/*
* If we deleted the leftmost entry in the block, update the
* key values above us in the tree.
*/
if (ptr == 1 && (error = xfs_inobt_updkey(cur, kp, level + 1)))
return error;
/*
* If the number of records remaining in the block is at least
* the minimum, we're done.
*/
if (numrecs >= XFS_INOBT_BLOCK_MINRECS(level, cur)) {
if (level > 0 &&
(error = xfs_inobt_decrement(cur, level, &i)))
return error;
*stat = 1;
return 0;
}
/*
* Otherwise, we have to move some records around to keep the
* tree balanced. Look at the left and right sibling blocks to
* see if we can re-balance by moving only one record.
*/
rbno = be32_to_cpu(block->bb_rightsib);
lbno = be32_to_cpu(block->bb_leftsib);
bno = NULLAGBLOCK;
ASSERT(rbno != NULLAGBLOCK || lbno != NULLAGBLOCK);
/*
* Duplicate the cursor so our btree manipulations here won't
* disrupt the next level up.
*/
if ((error = xfs_btree_dup_cursor(cur, &tcur)))
return error;
/*
* If there's a right sibling, see if it's ok to shift an entry
* out of it.
*/
if (rbno != NULLAGBLOCK) {
/*
* Move the temp cursor to the last entry in the next block.
* Actually any entry but the first would suffice.
*/
i = xfs_btree_lastrec(tcur, level);
XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
if ((error = xfs_inobt_increment(tcur, level, &i)))
goto error0;
XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
i = xfs_btree_lastrec(tcur, level);
XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
/*
* Grab a pointer to the block.
*/
rbp = tcur->bc_bufs[level];
right = XFS_BUF_TO_INOBT_BLOCK(rbp);
#ifdef DEBUG
if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
goto error0;
#endif
/*
* Grab the current block number, for future use.
*/
bno = be32_to_cpu(right->bb_leftsib);
/*
* If right block is full enough so that removing one entry
* won't make it too empty, and left-shifting an entry out
* of right to us works, we're done.
*/
if (be16_to_cpu(right->bb_numrecs) - 1 >=
XFS_INOBT_BLOCK_MINRECS(level, cur)) {
if ((error = xfs_inobt_lshift(tcur, level, &i)))
goto error0;
if (i) {
ASSERT(be16_to_cpu(block->bb_numrecs) >=
XFS_INOBT_BLOCK_MINRECS(level, cur));
xfs_btree_del_cursor(tcur,
XFS_BTREE_NOERROR);
if (level > 0 &&
(error = xfs_inobt_decrement(cur, level,
&i)))
return error;
*stat = 1;
return 0;
}
}
/*
* Otherwise, grab the number of records in right for
* future reference, and fix up the temp cursor to point
* to our block again (last record).
*/
rrecs = be16_to_cpu(right->bb_numrecs);
if (lbno != NULLAGBLOCK) {
xfs_btree_firstrec(tcur, level);
if ((error = xfs_inobt_decrement(tcur, level, &i)))
goto error0;
}
}
/*
* If there's a left sibling, see if it's ok to shift an entry
* out of it.
*/
if (lbno != NULLAGBLOCK) {
/*
* Move the temp cursor to the first entry in the
* previous block.
*/
xfs_btree_firstrec(tcur, level);
if ((error = xfs_inobt_decrement(tcur, level, &i)))
goto error0;
xfs_btree_firstrec(tcur, level);
/*
* Grab a pointer to the block.
*/
lbp = tcur->bc_bufs[level];
left = XFS_BUF_TO_INOBT_BLOCK(lbp);
#ifdef DEBUG
if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
goto error0;
#endif
/*
* Grab the current block number, for future use.
*/
bno = be32_to_cpu(left->bb_rightsib);
/*
* If left block is full enough so that removing one entry
* won't make it too empty, and right-shifting an entry out
* of left to us works, we're done.
*/
if (be16_to_cpu(left->bb_numrecs) - 1 >=
XFS_INOBT_BLOCK_MINRECS(level, cur)) {
if ((error = xfs_inobt_rshift(tcur, level, &i)))
goto error0;
if (i) {
ASSERT(be16_to_cpu(block->bb_numrecs) >=
XFS_INOBT_BLOCK_MINRECS(level, cur));
xfs_btree_del_cursor(tcur,
XFS_BTREE_NOERROR);
if (level == 0)
cur->bc_ptrs[0]++;
*stat = 1;
return 0;
}
}
/*
* Otherwise, grab the number of records in right for
* future reference.
*/
lrecs = be16_to_cpu(left->bb_numrecs);
}
/*
* Delete the temp cursor, we're done with it.
*/
xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
/*
* If here, we need to do a join to keep the tree balanced.
*/
ASSERT(bno != NULLAGBLOCK);
/*
* See if we can join with the left neighbor block.
*/
if (lbno != NULLAGBLOCK &&
lrecs + numrecs <= XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
/*
* Set "right" to be the starting block,
* "left" to be the left neighbor.
*/
rbno = bno;
right = block;
rrecs = be16_to_cpu(right->bb_numrecs);
rbp = bp;
if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
cur->bc_private.i.agno, lbno, 0, &lbp,
XFS_INO_BTREE_REF)))
return error;
left = XFS_BUF_TO_INOBT_BLOCK(lbp);
lrecs = be16_to_cpu(left->bb_numrecs);
if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
return error;
}
/*
* If that won't work, see if we can join with the right neighbor block.
*/
else if (rbno != NULLAGBLOCK &&
rrecs + numrecs <= XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
/*
* Set "left" to be the starting block,
* "right" to be the right neighbor.
*/
lbno = bno;
left = block;
lrecs = be16_to_cpu(left->bb_numrecs);
lbp = bp;
if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
cur->bc_private.i.agno, rbno, 0, &rbp,
XFS_INO_BTREE_REF)))
return error;
right = XFS_BUF_TO_INOBT_BLOCK(rbp);
rrecs = be16_to_cpu(right->bb_numrecs);
if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
return error;
}
/*
* Otherwise, we can't fix the imbalance.
* Just return. This is probably a logic error, but it's not fatal.
*/
else {
if (level > 0 && (error = xfs_inobt_decrement(cur, level, &i)))
return error;
*stat = 1;
return 0;
}
/*
* We're now going to join "left" and "right" by moving all the stuff
* in "right" to "left" and deleting "right".
*/
if (level > 0) {
/*
* It's a non-leaf. Move keys and pointers.
*/
lkp = XFS_INOBT_KEY_ADDR(left, lrecs + 1, cur);
lpp = XFS_INOBT_PTR_ADDR(left, lrecs + 1, cur);
rkp = XFS_INOBT_KEY_ADDR(right, 1, cur);
rpp = XFS_INOBT_PTR_ADDR(right, 1, cur);
#ifdef DEBUG
for (i = 0; i < rrecs; i++) {
if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(rpp[i]), level)))
return error;
}
#endif
memcpy(lkp, rkp, rrecs * sizeof(*lkp));
memcpy(lpp, rpp, rrecs * sizeof(*lpp));
xfs_inobt_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
xfs_inobt_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
} else {
/*
* It's a leaf. Move records.
*/
lrp = XFS_INOBT_REC_ADDR(left, lrecs + 1, cur);
rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
memcpy(lrp, rrp, rrecs * sizeof(*lrp));
xfs_inobt_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
}
/*
* If we joined with the left neighbor, set the buffer in the
* cursor to the left block, and fix up the index.
*/
if (bp != lbp) {
xfs_btree_setbuf(cur, level, lbp);
cur->bc_ptrs[level] += lrecs;
}
/*
* If we joined with the right neighbor and there's a level above
* us, increment the cursor at that level.
*/
else if (level + 1 < cur->bc_nlevels &&
(error = xfs_alloc_increment(cur, level + 1, &i)))
return error;
/*
* Fix up the number of records in the surviving block.
*/
lrecs += rrecs;
left->bb_numrecs = cpu_to_be16(lrecs);
/*
* Fix up the right block pointer in the surviving block, and log it.
*/
left->bb_rightsib = right->bb_rightsib;
xfs_inobt_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
/*
* If there is a right sibling now, make it point to the
* remaining block.
*/
if (be32_to_cpu(left->bb_rightsib) != NULLAGBLOCK) {
xfs_inobt_block_t *rrblock;
xfs_buf_t *rrbp;
if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
cur->bc_private.i.agno, be32_to_cpu(left->bb_rightsib), 0,
&rrbp, XFS_INO_BTREE_REF)))
return error;
rrblock = XFS_BUF_TO_INOBT_BLOCK(rrbp);
if ((error = xfs_btree_check_sblock(cur, rrblock, level, rrbp)))
return error;
rrblock->bb_leftsib = cpu_to_be32(lbno);
xfs_inobt_log_block(cur->bc_tp, rrbp, XFS_BB_LEFTSIB);
}
/*
* Free the deleting block.
*/
if ((error = xfs_free_extent(cur->bc_tp, XFS_AGB_TO_FSB(mp,
cur->bc_private.i.agno, rbno), 1)))
return error;
xfs_trans_binval(cur->bc_tp, rbp);
/*
* Readjust the ptr at this level if it's not a leaf, since it's
* still pointing at the deletion point, which makes the cursor
* inconsistent. If this makes the ptr 0, the caller fixes it up.
* We can't use decrement because it would change the next level up.
*/
if (level > 0)
cur->bc_ptrs[level]--;
/*
* Return value means the next level up has something to do.
*/
*stat = 2;
return 0;
error0:
xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
return error;
}
/*
* Insert one record/level. Return information to the caller
* allowing the next level up to proceed if necessary.
*/
STATIC int /* error */
xfs_inobt_insrec(
xfs_btree_cur_t *cur, /* btree cursor */
int level, /* level to insert record at */
xfs_agblock_t *bnop, /* i/o: block number inserted */
xfs_inobt_rec_t *recp, /* i/o: record data inserted */
xfs_btree_cur_t **curp, /* output: new cursor replacing cur */
int *stat) /* success/failure */
{
xfs_inobt_block_t *block; /* btree block record/key lives in */
xfs_buf_t *bp; /* buffer for block */
int error; /* error return value */
int i; /* loop index */
xfs_inobt_key_t key; /* key value being inserted */
xfs_inobt_key_t *kp=NULL; /* pointer to btree keys */
xfs_agblock_t nbno; /* block number of allocated block */
xfs_btree_cur_t *ncur; /* new cursor to be used at next lvl */
xfs_inobt_key_t nkey; /* new key value, from split */
xfs_inobt_rec_t nrec; /* new record value, for caller */
int numrecs;
int optr; /* old ptr value */
xfs_inobt_ptr_t *pp; /* pointer to btree addresses */
int ptr; /* index in btree block for this rec */
xfs_inobt_rec_t *rp=NULL; /* pointer to btree records */
/*
* GCC doesn't understand the (arguably complex) control flow in
* this function and complains about uninitialized structure fields
* without this.
*/
memset(&nrec, 0, sizeof(nrec));
/*
* If we made it to the root level, allocate a new root block
* and we're done.
*/
if (level >= cur->bc_nlevels) {
error = xfs_inobt_newroot(cur, &i);
*bnop = NULLAGBLOCK;
*stat = i;
return error;
}
/*
* Make a key out of the record data to be inserted, and save it.
*/
key.ir_startino = recp->ir_startino; /* INT_: direct copy */
optr = ptr = cur->bc_ptrs[level];
/*
* If we're off the left edge, return failure.
*/
if (ptr == 0) {
*stat = 0;
return 0;
}
/*
* Get pointers to the btree buffer and block.
*/
bp = cur->bc_bufs[level];
block = XFS_BUF_TO_INOBT_BLOCK(bp);
numrecs = be16_to_cpu(block->bb_numrecs);
#ifdef DEBUG
if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
return error;
/*
* Check that the new entry is being inserted in the right place.
*/
if (ptr <= numrecs) {
if (level == 0) {
rp = XFS_INOBT_REC_ADDR(block, ptr, cur);
xfs_btree_check_rec(cur->bc_btnum, recp, rp);
} else {
kp = XFS_INOBT_KEY_ADDR(block, ptr, cur);
xfs_btree_check_key(cur->bc_btnum, &key, kp);
}
}
#endif
nbno = NULLAGBLOCK;
ncur = (xfs_btree_cur_t *)0;
/*
* If the block is full, we can't insert the new entry until we
* make the block un-full.
*/
if (numrecs == XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
/*
* First, try shifting an entry to the right neighbor.
*/
if ((error = xfs_inobt_rshift(cur, level, &i)))
return error;
if (i) {
/* nothing */
}
/*
* Next, try shifting an entry to the left neighbor.
*/
else {
if ((error = xfs_inobt_lshift(cur, level, &i)))
return error;
if (i) {
optr = ptr = cur->bc_ptrs[level];
} else {
/*
* Next, try splitting the current block
* in half. If this works we have to
* re-set our variables because
* we could be in a different block now.
*/
if ((error = xfs_inobt_split(cur, level, &nbno,
&nkey, &ncur, &i)))
return error;
if (i) {
bp = cur->bc_bufs[level];
block = XFS_BUF_TO_INOBT_BLOCK(bp);
#ifdef DEBUG
if ((error = xfs_btree_check_sblock(cur,
block, level, bp)))
return error;
#endif
ptr = cur->bc_ptrs[level];
nrec.ir_startino = nkey.ir_startino; /* INT_: direct copy */
} else {
/*
* Otherwise the insert fails.
*/
*stat = 0;
return 0;
}
}
}
}
/*
* At this point we know there's room for our new entry in the block
* we're pointing at.
*/
numrecs = be16_to_cpu(block->bb_numrecs);
if (level > 0) {
/*
* It's a non-leaf entry. Make a hole for the new data
* in the key and ptr regions of the block.
*/
kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
#ifdef DEBUG
for (i = numrecs; i >= ptr; i--) {
if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(pp[i - 1]), level)))
return error;
}
#endif
memmove(&kp[ptr], &kp[ptr - 1],
(numrecs - ptr + 1) * sizeof(*kp));
memmove(&pp[ptr], &pp[ptr - 1],
(numrecs - ptr + 1) * sizeof(*pp));
/*
* Now stuff the new data in, bump numrecs and log the new data.
*/
#ifdef DEBUG
if ((error = xfs_btree_check_sptr(cur, *bnop, level)))
return error;
#endif
kp[ptr - 1] = key; /* INT_: struct copy */
pp[ptr - 1] = cpu_to_be32(*bnop);
numrecs++;
block->bb_numrecs = cpu_to_be16(numrecs);
xfs_inobt_log_keys(cur, bp, ptr, numrecs);
xfs_inobt_log_ptrs(cur, bp, ptr, numrecs);
} else {
/*
* It's a leaf entry. Make a hole for the new record.
*/
rp = XFS_INOBT_REC_ADDR(block, 1, cur);
memmove(&rp[ptr], &rp[ptr - 1],
(numrecs - ptr + 1) * sizeof(*rp));
/*
* Now stuff the new record in, bump numrecs
* and log the new data.
*/
rp[ptr - 1] = *recp; /* INT_: struct copy */
numrecs++;
block->bb_numrecs = cpu_to_be16(numrecs);
xfs_inobt_log_recs(cur, bp, ptr, numrecs);
}
/*
* Log the new number of records in the btree header.
*/
xfs_inobt_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
#ifdef DEBUG
/*
* Check that the key/record is in the right place, now.
*/
if (ptr < numrecs) {
if (level == 0)
xfs_btree_check_rec(cur->bc_btnum, rp + ptr - 1,
rp + ptr);
else
xfs_btree_check_key(cur->bc_btnum, kp + ptr - 1,
kp + ptr);
}
#endif
/*
* If we inserted at the start of a block, update the parents' keys.
*/
if (optr == 1 && (error = xfs_inobt_updkey(cur, &key, level + 1)))
return error;
/*
* Return the new block number, if any.
* If there is one, give back a record value and a cursor too.
*/
*bnop = nbno;
if (nbno != NULLAGBLOCK) {
*recp = nrec; /* INT_: struct copy */
*curp = ncur;
}
*stat = 1;
return 0;
}
/*
* Log header fields from a btree block.
*/
STATIC void
xfs_inobt_log_block(
xfs_trans_t *tp, /* transaction pointer */
xfs_buf_t *bp, /* buffer containing btree block */
int fields) /* mask of fields: XFS_BB_... */
{
int first; /* first byte offset logged */
int last; /* last byte offset logged */
static const short offsets[] = { /* table of offsets */
offsetof(xfs_inobt_block_t, bb_magic),
offsetof(xfs_inobt_block_t, bb_level),
offsetof(xfs_inobt_block_t, bb_numrecs),
offsetof(xfs_inobt_block_t, bb_leftsib),
offsetof(xfs_inobt_block_t, bb_rightsib),
sizeof(xfs_inobt_block_t)
};
xfs_btree_offsets(fields, offsets, XFS_BB_NUM_BITS, &first, &last);
xfs_trans_log_buf(tp, bp, first, last);
}
/*
* Log keys from a btree block (nonleaf).
*/
STATIC void
xfs_inobt_log_keys(
xfs_btree_cur_t *cur, /* btree cursor */
xfs_buf_t *bp, /* buffer containing btree block */
int kfirst, /* index of first key to log */
int klast) /* index of last key to log */
{
xfs_inobt_block_t *block; /* btree block to log from */
int first; /* first byte offset logged */
xfs_inobt_key_t *kp; /* key pointer in btree block */
int last; /* last byte offset logged */
block = XFS_BUF_TO_INOBT_BLOCK(bp);
kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
first = (int)((xfs_caddr_t)&kp[kfirst - 1] - (xfs_caddr_t)block);
last = (int)(((xfs_caddr_t)&kp[klast] - 1) - (xfs_caddr_t)block);
xfs_trans_log_buf(cur->bc_tp, bp, first, last);
}
/*
* Log block pointer fields from a btree block (nonleaf).
*/
STATIC void
xfs_inobt_log_ptrs(
xfs_btree_cur_t *cur, /* btree cursor */
xfs_buf_t *bp, /* buffer containing btree block */
int pfirst, /* index of first pointer to log */
int plast) /* index of last pointer to log */
{
xfs_inobt_block_t *block; /* btree block to log from */
int first; /* first byte offset logged */
int last; /* last byte offset logged */
xfs_inobt_ptr_t *pp; /* block-pointer pointer in btree blk */
block = XFS_BUF_TO_INOBT_BLOCK(bp);
pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
first = (int)((xfs_caddr_t)&pp[pfirst - 1] - (xfs_caddr_t)block);
last = (int)(((xfs_caddr_t)&pp[plast] - 1) - (xfs_caddr_t)block);
xfs_trans_log_buf(cur->bc_tp, bp, first, last);
}
/*
* Log records from a btree block (leaf).
*/
STATIC void
xfs_inobt_log_recs(
xfs_btree_cur_t *cur, /* btree cursor */
xfs_buf_t *bp, /* buffer containing btree block */
int rfirst, /* index of first record to log */
int rlast) /* index of last record to log */
{
xfs_inobt_block_t *block; /* btree block to log from */
int first; /* first byte offset logged */
int last; /* last byte offset logged */
xfs_inobt_rec_t *rp; /* record pointer for btree block */
block = XFS_BUF_TO_INOBT_BLOCK(bp);
rp = XFS_INOBT_REC_ADDR(block, 1, cur);
first = (int)((xfs_caddr_t)&rp[rfirst - 1] - (xfs_caddr_t)block);
last = (int)(((xfs_caddr_t)&rp[rlast] - 1) - (xfs_caddr_t)block);
xfs_trans_log_buf(cur->bc_tp, bp, first, last);
}
/*
* Lookup the record. The cursor is made to point to it, based on dir.
* Return 0 if can't find any such record, 1 for success.
*/
STATIC int /* error */
xfs_inobt_lookup(
xfs_btree_cur_t *cur, /* btree cursor */
xfs_lookup_t dir, /* <=, ==, or >= */
int *stat) /* success/failure */
{
xfs_agblock_t agbno; /* a.g. relative btree block number */
xfs_agnumber_t agno; /* allocation group number */
xfs_inobt_block_t *block=NULL; /* current btree block */
__int64_t diff; /* difference for the current key */
int error; /* error return value */
int keyno=0; /* current key number */
int level; /* level in the btree */
xfs_mount_t *mp; /* file system mount point */
/*
* Get the allocation group header, and the root block number.
*/
mp = cur->bc_mp;
{
xfs_agi_t *agi; /* a.g. inode header */
agi = XFS_BUF_TO_AGI(cur->bc_private.i.agbp);
agno = be32_to_cpu(agi->agi_seqno);
agbno = be32_to_cpu(agi->agi_root);
}
/*
* Iterate over each level in the btree, starting at the root.
* For each level above the leaves, find the key we need, based
* on the lookup record, then follow the corresponding block
* pointer down to the next level.
*/
for (level = cur->bc_nlevels - 1, diff = 1; level >= 0; level--) {
xfs_buf_t *bp; /* buffer pointer for btree block */
xfs_daddr_t d; /* disk address of btree block */
/*
* Get the disk address we're looking for.
*/
d = XFS_AGB_TO_DADDR(mp, agno, agbno);
/*
* If the old buffer at this level is for a different block,
* throw it away, otherwise just use it.
*/
bp = cur->bc_bufs[level];
if (bp && XFS_BUF_ADDR(bp) != d)
bp = (xfs_buf_t *)0;
if (!bp) {
/*
* Need to get a new buffer. Read it, then
* set it in the cursor, releasing the old one.
*/
if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
agno, agbno, 0, &bp, XFS_INO_BTREE_REF)))
return error;
xfs_btree_setbuf(cur, level, bp);
/*
* Point to the btree block, now that we have the buffer
*/
block = XFS_BUF_TO_INOBT_BLOCK(bp);
if ((error = xfs_btree_check_sblock(cur, block, level,
bp)))
return error;
} else
block = XFS_BUF_TO_INOBT_BLOCK(bp);
/*
* If we already had a key match at a higher level, we know
* we need to use the first entry in this block.
*/
if (diff == 0)
keyno = 1;
/*
* Otherwise we need to search this block. Do a binary search.
*/
else {
int high; /* high entry number */
xfs_inobt_key_t *kkbase=NULL;/* base of keys in block */
xfs_inobt_rec_t *krbase=NULL;/* base of records in block */
int low; /* low entry number */
/*
* Get a pointer to keys or records.
*/
if (level > 0)
kkbase = XFS_INOBT_KEY_ADDR(block, 1, cur);
else
krbase = XFS_INOBT_REC_ADDR(block, 1, cur);
/*
* Set low and high entry numbers, 1-based.
*/
low = 1;
if (!(high = be16_to_cpu(block->bb_numrecs))) {
/*
* If the block is empty, the tree must
* be an empty leaf.
*/
ASSERT(level == 0 && cur->bc_nlevels == 1);
cur->bc_ptrs[0] = dir != XFS_LOOKUP_LE;
*stat = 0;
return 0;
}
/*
* Binary search the block.
*/
while (low <= high) {
xfs_agino_t startino; /* key value */
/*
* keyno is average of low and high.
*/
keyno = (low + high) >> 1;
/*
* Get startino.
*/
if (level > 0) {
xfs_inobt_key_t *kkp;
kkp = kkbase + keyno - 1;
startino = INT_GET(kkp->ir_startino, ARCH_CONVERT);
} else {
xfs_inobt_rec_t *krp;
krp = krbase + keyno - 1;
startino = INT_GET(krp->ir_startino, ARCH_CONVERT);
}
/*
* Compute difference to get next direction.
*/
diff = (__int64_t)
startino - cur->bc_rec.i.ir_startino;
/*
* Less than, move right.
*/
if (diff < 0)
low = keyno + 1;
/*
* Greater than, move left.
*/
else if (diff > 0)
high = keyno - 1;
/*
* Equal, we're done.
*/
else
break;
}
}
/*
* If there are more levels, set up for the next level
* by getting the block number and filling in the cursor.
*/
if (level > 0) {
/*
* If we moved left, need the previous key number,
* unless there isn't one.
*/
if (diff > 0 && --keyno < 1)
keyno = 1;
agbno = be32_to_cpu(*XFS_INOBT_PTR_ADDR(block, keyno, cur));
#ifdef DEBUG
if ((error = xfs_btree_check_sptr(cur, agbno, level)))
return error;
#endif
cur->bc_ptrs[level] = keyno;