← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/nilfs2/btree.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/nilfs2/btree.c
714
714
                                nilfs_btree_get_nonroot_node(path, level),
715
715
                                path[level].bp_index, key);
716
716
                        if (!buffer_dirty(path[level].bp_bh))
717
 
                                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
717
                                mark_buffer_dirty(path[level].bp_bh);
718
718
                } while ((path[level].bp_index == 0) &&
719
719
                         (++level < nilfs_btree_height(btree) - 1));
720
720
        }
739
739
                nilfs_btree_node_insert(node, path[level].bp_index,
740
740
                                        *keyp, *ptrp, ncblk);
741
741
                if (!buffer_dirty(path[level].bp_bh))
742
 
                        nilfs_btnode_mark_dirty(path[level].bp_bh);
 
742
                        mark_buffer_dirty(path[level].bp_bh);
743
743
 
744
744
                if (path[level].bp_index == 0)
745
745
                        nilfs_btree_promote_key(btree, path, level + 1,
777
777
        nilfs_btree_node_move_left(left, node, n, ncblk, ncblk);
778
778
 
779
779
        if (!buffer_dirty(path[level].bp_bh))
780
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
780
                mark_buffer_dirty(path[level].bp_bh);
781
781
        if (!buffer_dirty(path[level].bp_sib_bh))
782
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
782
                mark_buffer_dirty(path[level].bp_sib_bh);
783
783
 
784
784
        nilfs_btree_promote_key(btree, path, level + 1,
785
785
                                nilfs_btree_node_get_key(node, 0));
823
823
        nilfs_btree_node_move_right(node, right, n, ncblk, ncblk);
824
824
 
825
825
        if (!buffer_dirty(path[level].bp_bh))
826
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
826
                mark_buffer_dirty(path[level].bp_bh);
827
827
        if (!buffer_dirty(path[level].bp_sib_bh))
828
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
828
                mark_buffer_dirty(path[level].bp_sib_bh);
829
829
 
830
830
        path[level + 1].bp_index++;
831
831
        nilfs_btree_promote_key(btree, path, level + 1,
870
870
        nilfs_btree_node_move_right(node, right, n, ncblk, ncblk);
871
871
 
872
872
        if (!buffer_dirty(path[level].bp_bh))
873
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
873
                mark_buffer_dirty(path[level].bp_bh);
874
874
        if (!buffer_dirty(path[level].bp_sib_bh))
875
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
875
                mark_buffer_dirty(path[level].bp_sib_bh);
876
876
 
877
877
        newkey = nilfs_btree_node_get_key(right, 0);
878
878
        newptr = path[level].bp_newreq.bpr_ptr;
919
919
        nilfs_btree_node_set_level(root, level + 1);
920
920
 
921
921
        if (!buffer_dirty(path[level].bp_sib_bh))
922
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
922
                mark_buffer_dirty(path[level].bp_sib_bh);
923
923
 
924
924
        path[level].bp_bh = path[level].bp_sib_bh;
925
925
        path[level].bp_sib_bh = NULL;
1174
1174
        if (ret < 0)
1175
1175
                goto out;
1176
1176
        nilfs_btree_commit_insert(btree, path, level, key, ptr);
1177
 
        nilfs_bmap_add_blocks(btree, stats.bs_nblocks);
 
1177
        nilfs_inode_add_blocks(btree->b_inode, stats.bs_nblocks);
1178
1178
 
1179
1179
 out:
1180
1180
        nilfs_btree_free_path(path);
1194
1194
                nilfs_btree_node_delete(node, path[level].bp_index,
1195
1195
                                        keyp, ptrp, ncblk);
1196
1196
                if (!buffer_dirty(path[level].bp_bh))
1197
 
                        nilfs_btnode_mark_dirty(path[level].bp_bh);
 
1197
                        mark_buffer_dirty(path[level].bp_bh);
1198
1198
                if (path[level].bp_index == 0)
1199
1199
                        nilfs_btree_promote_key(btree, path, level + 1,
1200
1200
                                nilfs_btree_node_get_key(node, 0));
1226
1226
        nilfs_btree_node_move_right(left, node, n, ncblk, ncblk);
1227
1227
 
1228
1228
        if (!buffer_dirty(path[level].bp_bh))
1229
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
1229
                mark_buffer_dirty(path[level].bp_bh);
1230
1230
        if (!buffer_dirty(path[level].bp_sib_bh))
1231
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
1231
                mark_buffer_dirty(path[level].bp_sib_bh);
1232
1232
 
1233
1233
        nilfs_btree_promote_key(btree, path, level + 1,
1234
1234
                                nilfs_btree_node_get_key(node, 0));
1258
1258
        nilfs_btree_node_move_left(node, right, n, ncblk, ncblk);
1259
1259
 
1260
1260
        if (!buffer_dirty(path[level].bp_bh))
1261
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
1261
                mark_buffer_dirty(path[level].bp_bh);
1262
1262
        if (!buffer_dirty(path[level].bp_sib_bh))
1263
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
1263
                mark_buffer_dirty(path[level].bp_sib_bh);
1264
1264
 
1265
1265
        path[level + 1].bp_index++;
1266
1266
        nilfs_btree_promote_key(btree, path, level + 1,
1289
1289
        nilfs_btree_node_move_left(left, node, n, ncblk, ncblk);
1290
1290
 
1291
1291
        if (!buffer_dirty(path[level].bp_sib_bh))
1292
 
                nilfs_btnode_mark_dirty(path[level].bp_sib_bh);
 
1292
                mark_buffer_dirty(path[level].bp_sib_bh);
1293
1293
 
1294
1294
        nilfs_btnode_delete(path[level].bp_bh);
1295
1295
        path[level].bp_bh = path[level].bp_sib_bh;
1315
1315
        nilfs_btree_node_move_left(node, right, n, ncblk, ncblk);
1316
1316
 
1317
1317
        if (!buffer_dirty(path[level].bp_bh))
1318
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
1318
                mark_buffer_dirty(path[level].bp_bh);
1319
1319
 
1320
1320
        nilfs_btnode_delete(path[level].bp_sib_bh);
1321
1321
        path[level].bp_sib_bh = NULL;
1346
1346
        path[level].bp_bh = NULL;
1347
1347
}
1348
1348
 
 
1349
static void nilfs_btree_nop(struct nilfs_bmap *btree,
 
1350
                            struct nilfs_btree_path *path,
 
1351
                            int level, __u64 *keyp, __u64 *ptrp)
 
1352
{
 
1353
}
1349
1354
 
1350
1355
static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
1351
1356
                                      struct nilfs_btree_path *path,
1356
1361
        struct buffer_head *bh;
1357
1362
        struct nilfs_btree_node *node, *parent, *sib;
1358
1363
        __u64 sibptr;
1359
 
        int pindex, level, ncmin, ncmax, ncblk, ret;
 
1364
        int pindex, dindex, level, ncmin, ncmax, ncblk, ret;
1360
1365
 
1361
1366
        ret = 0;
1362
1367
        stats->bs_nblocks = 0;
1363
1368
        ncmin = NILFS_BTREE_NODE_NCHILDREN_MIN(nilfs_btree_node_size(btree));
1364
1369
        ncblk = nilfs_btree_nchildren_per_block(btree);
1365
1370
 
1366
 
        for (level = NILFS_BTREE_LEVEL_NODE_MIN;
 
1371
        for (level = NILFS_BTREE_LEVEL_NODE_MIN, dindex = path[level].bp_index;
1367
1372
             level < nilfs_btree_height(btree) - 1;
1368
1373
             level++) {
1369
1374
                node = nilfs_btree_get_nonroot_node(path, level);
1370
1375
                path[level].bp_oldreq.bpr_ptr =
1371
 
                        nilfs_btree_node_get_ptr(node, path[level].bp_index,
1372
 
                                                 ncblk);
 
1376
                        nilfs_btree_node_get_ptr(node, dindex, ncblk);
1373
1377
                ret = nilfs_bmap_prepare_end_ptr(btree,
1374
1378
                                                 &path[level].bp_oldreq, dat);
1375
1379
                if (ret < 0)
1383
1387
 
1384
1388
                parent = nilfs_btree_get_node(btree, path, level + 1, &ncmax);
1385
1389
                pindex = path[level + 1].bp_index;
 
1390
                dindex = pindex;
1386
1391
 
1387
1392
                if (pindex > 0) {
1388
1393
                        /* left sibling */
1421
1426
                                path[level].bp_sib_bh = bh;
1422
1427
                                path[level].bp_op = nilfs_btree_concat_right;
1423
1428
                                stats->bs_nblocks++;
 
1429
                                /*
 
1430
                                 * When merging right sibling node
 
1431
                                 * into the current node, pointer to
 
1432
                                 * the right sibling node must be
 
1433
                                 * terminated instead.  The adjustment
 
1434
                                 * below is required for that.
 
1435
                                 */
 
1436
                                dindex = pindex + 1;
1424
1437
                                /* continue; */
1425
1438
                        }
1426
1439
                } else {
1431
1444
                            NILFS_BTREE_ROOT_NCHILDREN_MAX) {
1432
1445
                                path[level].bp_op = nilfs_btree_shrink;
1433
1446
                                stats->bs_nblocks += 2;
 
1447
                                level++;
 
1448
                                path[level].bp_op = nilfs_btree_nop;
 
1449
                                goto shrink_root_child;
1434
1450
                        } else {
1435
1451
                                path[level].bp_op = nilfs_btree_do_delete;
1436
1452
                                stats->bs_nblocks++;
 
1453
                                goto out;
1437
1454
                        }
1438
 
 
1439
 
                        goto out;
1440
 
 
1441
1455
                }
1442
1456
        }
1443
1457
 
 
1458
        /* child of the root node is deleted */
 
1459
        path[level].bp_op = nilfs_btree_do_delete;
 
1460
        stats->bs_nblocks++;
 
1461
 
 
1462
shrink_root_child:
1444
1463
        node = nilfs_btree_get_root(btree);
1445
1464
        path[level].bp_oldreq.bpr_ptr =
1446
 
                nilfs_btree_node_get_ptr(node, path[level].bp_index,
 
1465
                nilfs_btree_node_get_ptr(node, dindex,
1447
1466
                                         NILFS_BTREE_ROOT_NCHILDREN_MAX);
1448
1467
 
1449
1468
        ret = nilfs_bmap_prepare_end_ptr(btree, &path[level].bp_oldreq, dat);
1450
1469
        if (ret < 0)
1451
1470
                goto err_out_child_node;
1452
1471
 
1453
 
        /* child of the root node is deleted */
1454
 
        path[level].bp_op = nilfs_btree_do_delete;
1455
 
        stats->bs_nblocks++;
1456
 
 
1457
1472
        /* success */
1458
1473
 out:
1459
1474
        *levelp = level;
1511
1526
        if (ret < 0)
1512
1527
                goto out;
1513
1528
        nilfs_btree_commit_delete(btree, path, level, dat);
1514
 
        nilfs_bmap_sub_blocks(btree, stats.bs_nblocks);
 
1529
        nilfs_inode_sub_blocks(btree->b_inode, stats.bs_nblocks);
1515
1530
 
1516
1531
out:
1517
1532
        nilfs_btree_free_path(path);
1709
1724
                nilfs_btree_node_init(node, 0, 1, n, ncblk, keys, ptrs);
1710
1725
                nilfs_btree_node_insert(node, n, key, dreq->bpr_ptr, ncblk);
1711
1726
                if (!buffer_dirty(bh))
1712
 
                        nilfs_btnode_mark_dirty(bh);
 
1727
                        mark_buffer_dirty(bh);
1713
1728
                if (!nilfs_bmap_dirty(btree))
1714
1729
                        nilfs_bmap_set_dirty(btree);
1715
1730
 
1776
1791
                return ret;
1777
1792
        nilfs_btree_commit_convert_and_insert(btree, key, ptr, keys, ptrs, n,
1778
1793
                                              di, ni, bh);
1779
 
        nilfs_bmap_add_blocks(btree, stats.bs_nblocks);
 
1794
        nilfs_inode_add_blocks(btree->b_inode, stats.bs_nblocks);
1780
1795
        return 0;
1781
1796
}
1782
1797
 
1787
1802
{
1788
1803
        while ((++level < nilfs_btree_height(btree) - 1) &&
1789
1804
               !buffer_dirty(path[level].bp_bh))
1790
 
                nilfs_btnode_mark_dirty(path[level].bp_bh);
 
1805
                mark_buffer_dirty(path[level].bp_bh);
1791
1806
 
1792
1807
        return 0;
1793
1808
}
2229
2244
        }
2230
2245
 
2231
2246
        if (!buffer_dirty(bh))
2232
 
                nilfs_btnode_mark_dirty(bh);
 
2247
                mark_buffer_dirty(bh);
2233
2248
        brelse(bh);
2234
2249
        if (!nilfs_bmap_dirty(btree))
2235
2250
                nilfs_bmap_set_dirty(btree);