Lines Matching refs:depth
195 int depth = path->p_depth;
215 ex = path[depth].p_ext;
228 if (path[depth].p_bh)
229 return path[depth].p_bh->b_blocknr;
324 ext4_ext_max_entries(struct inode *inode, int depth)
328 if (depth == ext_depth(inode)) {
329 if (depth == 0)
334 if (depth == 0)
370 int depth)
381 if (depth == 0) {
389 if (depth != ext_depth(inode) &&
413 if (depth != ext_depth(inode) &&
436 int depth, ext4_fsblk_t pblk, ext4_lblk_t lblk)
445 if (unlikely(le16_to_cpu(eh->eh_depth) != depth)) {
453 max = ext4_ext_max_entries(inode, depth);
462 if (unlikely((eh->eh_entries == 0) && (depth > 0))) {
466 if (!ext4_valid_extent_entries(inode, eh, lblk, &pblk, depth)) {
470 if (unlikely(depth > 32)) {
475 if (ext_depth(inode) != depth &&
486 "entries %u, max %u(%u), depth %u(%u)",
491 max, le16_to_cpu(eh->eh_depth), depth);
495 #define ext4_ext_check(inode, eh, depth, pblk) \
496 __ext4_ext_check(__func__, __LINE__, (inode), (eh), (depth), (pblk), 0)
530 int depth, int flags)
564 depth, pblk, le32_to_cpu(idx->ei_block));
572 if (!(flags & EXT4_EX_NOCACHE) && depth == 0) {
583 #define read_extent_tree_block(inode, idx, depth, flags) \
585 (depth), (flags))
596 int i = 0, depth, ret = 0;
602 depth = ext_depth(inode);
605 if (!depth) {
610 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
618 ret = ext4_ext_check(inode, path[0].p_hdr, depth, 0);
627 if ((i == depth) ||
635 depth - i - 1,
679 int depth = ext_depth(inode);
687 eh = path[depth].p_hdr;
703 int depth = ext_depth(inode);
706 if (depth != level) {
719 ex = path[depth].p_ext;
720 while (ex <= EXT_MAX_EXTENT(path[depth].p_hdr)) {
739 int depth, i;
743 depth = path->p_depth;
744 for (i = 0; i <= depth; i++, path++) {
892 short int depth, i, ppos = 0;
900 depth = ext_depth(inode);
901 if (depth < 0 || depth > EXT4_MAX_EXTENT_DEPTH) {
902 EXT4_ERROR_INODE(inode, "inode has invalid extent depth: %d",
903 depth);
910 if (depth > path[0].p_maxdepth) {
916 /* account possible depth increase */
917 path = kcalloc(depth + 2, sizeof(struct ext4_ext_path),
921 path[0].p_maxdepth = depth + 1;
926 i = depth;
927 if (!(flags & EXT4_EX_NOCACHE) && depth == 0)
931 ext_debug(inode, "depth %d: num %d, max %d\n",
1049 * at depth @at:
1062 int depth = ext_depth(inode);
1081 if (unlikely(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr))) {
1085 if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
1086 border = path[depth].p_ext[1].ee_block;
1109 ablocks = kcalloc(depth, sizeof(ext4_fsblk_t), gfp_flags);
1114 ext_debug(inode, "allocate %d blocks for indexes/leaf\n", depth - at);
1115 for (a = 0; a < depth - at; a++) {
1148 /* move remainder of path[depth] to the new leaf */
1149 if (unlikely(path[depth].p_hdr->eh_entries !=
1150 path[depth].p_hdr->eh_max)) {
1152 path[depth].p_hdr->eh_entries,
1153 path[depth].p_hdr->eh_max);
1158 m = EXT_MAX_EXTENT(path[depth].p_hdr) - path[depth].p_ext++;
1159 ext4_ext_show_move(inode, path, newblock, depth);
1163 memmove(ex, path[depth].p_ext, sizeof(struct ext4_extent) * m);
1183 err = ext4_ext_get_access(handle, inode, path + depth);
1186 le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);
1187 err = ext4_ext_dirty(handle, inode, path + depth);
1194 k = depth - at - 1;
1203 /* current depth stored in i var */
1204 i = depth - 1;
1223 neh->eh_depth = cpu_to_le16(depth - i);
1293 for (i = 0; i < depth; i++) {
1396 * if no free index is found, then it requests in-depth growing.
1406 int depth, i, err = 0;
1409 i = depth = ext_depth(inode);
1412 curp = path + depth;
1434 /* tree is full, time to grow in depth */
1449 * only first (depth 0 -> 1) produces free space;
1452 depth = ext_depth(inode);
1453 if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
1476 int depth, ee_len;
1482 depth = path->p_depth;
1485 if (depth == 0 && path->p_ext == NULL)
1492 ex = path[depth].p_ext;
1495 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1501 while (--depth >= 0) {
1502 ix = path[depth].p_idx;
1503 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1505 "ix (%d) != EXT_FIRST_INDEX (%d) (depth %d)!",
1507 EXT_FIRST_INDEX(path[depth].p_hdr) != NULL ?
1508 le32_to_cpu(EXT_FIRST_INDEX(path[depth].p_hdr)->ei_block) : 0,
1509 depth);
1544 int depth; /* Note, NOT eh_depth; depth from top of tree */
1551 depth = path->p_depth;
1554 if (depth == 0 && path->p_ext == NULL)
1561 ex = path[depth].p_ext;
1564 if (unlikely(EXT_FIRST_EXTENT(path[depth].p_hdr) != ex)) {
1567 depth);
1570 while (--depth >= 0) {
1571 ix = path[depth].p_idx;
1572 if (unlikely(ix != EXT_FIRST_INDEX(path[depth].p_hdr))) {
1589 if (ex != EXT_LAST_EXTENT(path[depth].p_hdr)) {
1596 while (--depth >= 0) {
1597 ix = path[depth].p_idx;
1598 if (ix != EXT_LAST_INDEX(path[depth].p_hdr))
1610 while (++depth < path->p_depth) {
1612 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1620 bh = read_extent_tree_block(inode, ix, path->p_depth - depth, 0);
1645 int depth;
1648 depth = path->p_depth;
1650 if (depth == 0 && path->p_ext == NULL)
1653 while (depth >= 0) {
1654 struct ext4_ext_path *p = &path[depth];
1656 if (depth == path->p_depth) {
1665 depth--;
1677 int depth;
1680 depth = path->p_depth;
1683 if (depth == 0)
1687 depth--;
1689 while (depth >= 0) {
1690 if (path[depth].p_idx !=
1691 EXT_LAST_INDEX(path[depth].p_hdr))
1693 le32_to_cpu(path[depth].p_idx[1].ei_block);
1694 depth--;
1710 int depth = ext_depth(inode);
1715 eh = path[depth].p_hdr;
1716 ex = path[depth].p_ext;
1724 if (depth == 0) {
1737 k = depth - 1;
1738 border = path[depth].p_ext->ee_block;
1807 unsigned int depth, len;
1810 depth = ext_depth(inode);
1811 BUG_ON(path[depth].p_hdr == NULL);
1812 eh = path[depth].p_hdr;
1895 unsigned int depth;
1898 depth = ext_depth(inode);
1899 BUG_ON(path[depth].p_hdr == NULL);
1900 eh = path[depth].p_hdr;
1925 unsigned int depth, len1;
1930 depth = ext_depth(inode);
1931 if (!path[depth].p_ext)
1933 b2 = EXT4_LBLK_CMASK(sbi, le32_to_cpu(path[depth].p_ext->ee_block));
1977 int depth, len, err;
1987 depth = ext_depth(inode);
1988 ex = path[depth].p_ext;
1989 eh = path[depth].p_hdr;
1990 if (unlikely(path[depth].p_hdr == NULL)) {
1991 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2028 path + depth);
2036 eh = path[depth].p_hdr;
2054 path + depth);
2065 eh = path[depth].p_hdr;
2071 depth = ext_depth(inode);
2072 eh = path[depth].p_hdr;
2088 eh = npath[depth].p_hdr;
2109 depth = ext_depth(inode);
2110 eh = path[depth].p_hdr;
2113 nearex = path[depth].p_ext;
2115 err = ext4_ext_get_access(handle, inode, path + depth);
2165 path[depth].p_ext = nearex;
2252 int depth = ext_depth(inode);
2256 ex = path[depth].p_ext;
2306 struct ext4_ext_path *path, int depth)
2312 depth--;
2313 path = path + depth;
2339 while (--depth >= 0) {
2365 int depth = ext_depth(inode);
2369 if (le16_to_cpu(path[depth].p_hdr->eh_entries)
2370 < le16_to_cpu(path[depth].p_hdr->eh_max)) {
2401 int depth;
2407 depth = ext_depth(inode);
2410 index = depth * 2;
2412 index = depth * 3;
2601 int depth = ext_depth(inode), credits, revoke_credits;
2613 if (!path[depth].p_hdr)
2614 path[depth].p_hdr = ext_block_hdr(path[depth].p_bh);
2615 eh = path[depth].p_hdr;
2616 if (unlikely(path[depth].p_hdr == NULL)) {
2617 EXT4_ERROR_INODE(inode, "path[%d].p_hdr == NULL", depth);
2621 ex = path[depth].p_ext;
2640 path[depth].p_ext = ex;
2711 err = ext4_ext_get_access(handle, inode, path + depth);
2751 err = ext4_ext_dirty(handle, inode, path + depth);
2790 if (err == 0 && eh->eh_entries == 0 && path[depth].p_bh != NULL)
2791 err = ext4_ext_rm_idx(handle, inode, path, depth);
2822 int depth = ext_depth(inode);
2836 depth + 1,
2837 ext4_free_metadata_revoke_credits(inode->i_sb, depth));
2842 trace_ext4_ext_remove_space(inode, start, end, depth);
2863 depth = ext_depth(inode);
2865 ex = path[depth].p_ext;
2867 if (depth) {
2870 depth);
2934 * after i_size and walking into the tree depth-wise.
2936 depth = ext_depth(inode);
2938 int k = i = depth;
2943 path = kcalloc(depth + 1, sizeof(struct ext4_ext_path),
2949 path[0].p_maxdepth = path[0].p_depth = depth;
2953 if (ext4_ext_check(inode, path[0].p_hdr, depth, 0)) {
2961 if (i == depth) {
3000 depth - i - 1,
3010 if (WARN_ON(i + 1 > depth)) {
3036 trace_ext4_ext_remove_space_done(inode, start, end, depth, &partial,
3126 printk(KERN_ERR "EXT4-fs: extents: %lu min, %lu max, max depth %lu\n",
3194 unsigned int ee_len, depth;
3204 depth = ext_depth(inode);
3205 ex = path[depth].p_ext;
3216 err = ext4_ext_get_access(handle, inode, path + depth);
3248 err = ext4_ext_dirty(handle, inode, path + depth);
3340 unsigned int ee_len, depth;
3346 depth = ext_depth(inode);
3347 ex = path[depth].p_ext;
3374 depth = ext_depth(inode);
3375 ex = path[depth].p_ext;
3435 unsigned int ee_len, depth, map_len = map->m_len;
3449 depth = ext_depth(inode);
3450 eh = path[depth].p_hdr;
3451 ex = path[depth].p_ext;
3505 err = ext4_ext_get_access(handle, inode, path + depth);
3551 err = ext4_ext_get_access(handle, inode, path + depth);
3573 err = ext4_ext_dirty(handle, inode, path + depth);
3576 path[depth].p_ext = abut_ex;
3692 int split_flag = 0, depth;
3705 depth = ext_depth(inode);
3706 ex = path[depth].p_ext;
3732 int depth;
3735 depth = ext_depth(inode);
3736 ex = path[depth].p_ext;
3763 depth = ext_depth(inode);
3764 ex = path[depth].p_ext;
3767 err = ext4_ext_get_access(handle, inode, path + depth);
3795 int depth;
3805 depth = ext_depth(inode);
3806 ex = path[depth].p_ext;
3821 depth = ext_depth(inode);
3822 ex = path[depth].p_ext;
3830 err = ext4_ext_get_access(handle, inode, path + depth);
4099 int err = 0, depth, ret;
4116 depth = ext_depth(inode);
4123 if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
4125 "lblock: %lu, depth: %d pblock %lld",
4126 (unsigned long) map->m_lblk, depth,
4127 path[depth].p_block);
4132 ex = path[depth].p_ext;
4443 int depth = 0;
4463 depth = ext_depth(inode);
4468 * Recalculate credits when extent tree depth changes.
4470 if (depth != ext_depth(inode)) {
4472 depth = ext_depth(inode);
5029 * Shift the extents of a path structure lying between path[depth].p_ext
5030 * and EXT_LAST_EXTENT(path[depth].p_hdr), by @shift blocks. @SHIFT tells
5038 int depth, err = 0;
5042 depth = path->p_depth;
5044 while (depth >= 0) {
5045 if (depth == path->p_depth) {
5046 ex_start = path[depth].p_ext;
5050 ex_last = EXT_LAST_EXTENT(path[depth].p_hdr);
5053 if (ex_start == EXT_FIRST_EXTENT(path[depth].p_hdr)) {
5056 credits = depth + 2;
5068 err = ext4_ext_get_access(handle, inode, path + depth);
5078 EXT_FIRST_EXTENT(path[depth].p_hdr))
5092 err = ext4_ext_dirty(handle, inode, path + depth);
5096 if (--depth < 0 || !update)
5101 err = ext4_ext_get_access(handle, inode, path + depth);
5106 le32_add_cpu(&path[depth].p_idx->ei_block, -shift);
5108 le32_add_cpu(&path[depth].p_idx->ei_block, shift);
5109 err = ext4_ext_dirty(handle, inode, path + depth);
5114 if (path[depth].p_idx != EXT_FIRST_INDEX(path[depth].p_hdr))
5117 depth--;
5137 int ret = 0, depth;
5148 depth = path->p_depth;
5149 extent = path[depth].p_ext;
5165 depth = path->p_depth;
5166 extent = path[depth].p_ext;
5214 depth = path->p_depth;
5215 extent = path[depth].p_ext;
5224 if (extent < EXT_LAST_EXTENT(path[depth].p_hdr)) {
5225 path[depth].p_ext++;
5234 extent = EXT_LAST_EXTENT(path[depth].p_hdr);
5238 extent = EXT_FIRST_EXTENT(path[depth].p_hdr);
5244 extent = EXT_LAST_EXTENT(path[depth].p_hdr);
5248 if (extent == EXT_LAST_EXTENT(path[depth].p_hdr))
5254 path[depth].p_ext = extent;
5435 int ret = 0, depth, split_flag = 0;
5535 depth = ext_depth(inode);
5536 extent = path[depth].p_ext;
5811 int depth, mapped = 0, err = 0;
5832 depth = ext_depth(inode);
5839 if (unlikely(path[depth].p_ext == NULL && depth != 0)) {
5841 "bad extent address - lblock: %lu, depth: %d, pblock: %lld",
5843 depth, path[depth].p_block);
5848 extent = path[depth].p_ext;