Lines Matching full:path

184 ext4_ext_print_path(struct inode *ip, struct ext4_extent_path *path)
188 depth = path->ep_depth;
191 printf("ip=%ju, Path:\n", ip->i_number);
193 for (k = 0; k <= depth && error == 0; k++, path++) {
194 if (path->ep_index) {
195 error = ext4_ext_walk_index(ip, path->ep_index,
197 } else if (path->ep_ext) {
198 error = ext4_ext_walk_extent(ip, path->ep_ext);
495 ext4_ext_binsearch_index(struct ext4_extent_path *path, int blk)
500 eh = path->ep_header;
516 path->ep_index = l - 1;
520 ext4_ext_binsearch_ext(struct ext4_extent_path *path, int blk)
525 eh = path->ep_header;
544 path->ep_ext = l - 1;
548 ext4_ext_fill_path_bdata(struct ext4_extent_path *path,
552 KASSERT(path->ep_data == NULL,
555 path->ep_data = malloc(bp->b_bufsize, M_EXT2EXTENTS, M_WAITOK);
556 memcpy(path->ep_data, bp->b_data, bp->b_bufsize);
557 path->ep_blk = blk;
563 ext4_ext_fill_path_buf(struct ext4_extent_path *path, struct buf *bp)
566 KASSERT(path->ep_data != NULL,
569 memcpy(bp->b_data, path->ep_data, bp->b_bufsize);
573 ext4_ext_drop_refs(struct ext4_extent_path *path)
577 if (!path)
580 depth = path->ep_depth;
581 for (i = 0; i <= depth; i++, path++)
582 if (path->ep_data) {
583 free(path->ep_data, M_EXT2EXTENTS);
584 path->ep_data = NULL;
589 ext4_ext_path_free(struct ext4_extent_path *path)
592 if (!path)
595 ext4_ext_drop_refs(path);
596 free(path, M_EXT2EXTENTS);
604 struct ext4_extent_path *path;
621 path = *ppath;
622 if (path == NULL) {
623 path = malloc(EXT4_EXT_DEPTH_MAX *
626 *ppath = path;
630 path[0].ep_header = eh;
631 path[0].ep_data = NULL;
636 ext4_ext_binsearch_index(&path[ppos], block);
637 blk = ext4_ext_index_pblock(path[ppos].ep_index);
638 path[ppos].ep_depth = i;
639 path[ppos].ep_ext = NULL;
656 ext4_ext_fill_path_bdata(&path[ppos], bp, blk);
659 eh = ext4_ext_block_header(path[ppos].ep_data);
661 ext2_extent_blk_csum_verify(ip, path[ppos].ep_data)) {
666 path[ppos].ep_header = eh;
676 path[ppos].ep_depth = i;
677 path[ppos].ep_header = eh;
678 path[ppos].ep_ext = NULL;
679 path[ppos].ep_index = NULL;
680 ext4_ext_binsearch_ext(&path[ppos], block);
684 ext4_ext_drop_refs(path);
686 free(path, M_EXT2EXTENTS);
737 ext4_ext_blkpref(struct inode *ip, struct ext4_extent_path *path,
747 if (path) {
748 depth = path->ep_depth;
749 ex = path[depth].ep_ext;
761 if (path[depth].ep_data)
762 return (path[depth].ep_blk);
791 ext4_ext_next_leaf_block(struct inode *ip, struct ext4_extent_path *path)
793 int depth = path->ep_depth;
803 if (path[depth].ep_index !=
804 EXT_LAST_INDEX(path[depth].ep_header))
805 return (le32toh(path[depth].ep_index[1].ei_blk));
814 ext4_ext_dirty(struct inode *ip, struct ext4_extent_path *path)
823 if (!path)
826 if (path->ep_data) {
827 blk = path->ep_blk;
832 ext4_ext_fill_path_buf(path, bp);
844 ext4_ext_insert_index(struct inode *ip, struct ext4_extent_path *path,
850 if (lblk == le32toh(path->ep_index->ei_blk)) {
856 if (le16toh(path->ep_header->eh_ecount) >=
857 le16toh(path->ep_header->eh_max)) {
863 if (lblk > le32toh(path->ep_index->ei_blk)) {
865 idx = path->ep_index + 1;
868 idx = path->ep_index;
871 len = EXT_LAST_INDEX(path->ep_header) - idx + 1;
875 if (idx > EXT_MAX_INDEX(path->ep_header)) {
883 path->ep_header->eh_ecount =
884 htole16(le16toh(path->ep_header->eh_ecount) + 1);
886 return (ext4_ext_dirty(ip, path));
924 ext4_ext_split(struct inode *ip, struct ext4_extent_path *path,
945 if (path[depth].ep_ext > EXT_MAX_EXTENT(path[depth].ep_header)) {
951 if (path[depth].ep_ext != EXT_MAX_EXTENT(path[depth].ep_header))
952 border = le32toh(path[depth].ep_ext[1].e_blk);
980 if (le16toh(path[depth].ep_header->eh_ecount) !=
981 le16toh(path[depth].ep_header->eh_max)) {
990 path[depth].ep_ext++;
991 while (path[depth].ep_ext <= EXT_MAX_EXTENT(path[depth].ep_header)) {
992 path[depth].ep_ext++;
996 memmove(ex, path[depth].ep_ext - m,
1007 path[depth].ep_header->eh_ecount =
1008 htole16(le16toh(path[depth].ep_header->eh_ecount) - m);
1009 ext4_ext_dirty(ip, path + depth);
1037 path[i].ep_index++;
1038 while (path[i].ep_index <= EXT_MAX_INDEX(path[i].ep_header)) {
1039 path[i].ep_index++;
1043 memmove(++fidx, path[i].ep_index - m,
1054 path[i].ep_header->eh_ecount =
1055 htole16(le16toh(path[i].ep_header->eh_ecount) - m);
1056 ext4_ext_dirty(ip, path + i);
1062 error = ext4_ext_insert_index(ip, path + at, border, newblk);
1082 ext4_ext_grow_indepth(struct inode *ip, struct ext4_extent_path *path,
1093 curpath = path;
1130 curpath->ep_index->ei_blk = EXT_FIRST_EXTENT(path[0].ep_header)->e_blk;
1134 neh->eh_depth = htole16(path->ep_depth + 1);
1143 ext4_ext_create_new_leaf(struct inode *ip, struct ext4_extent_path *path,
1153 curpath = path + depth;
1164 error = ext4_ext_split(ip, path, newext, i);
1168 /* Refill path. */
1169 ext4_ext_drop_refs(path);
1170 error = ext4_ext_find_extent(ip, le32toh(newext->e_blk), &path);
1175 error = ext4_ext_grow_indepth(ip, path, newext);
1179 /* Refill path. */
1180 ext4_ext_drop_refs(path);
1181 error = ext4_ext_find_extent(ip, le32toh(newext->e_blk), &path);
1187 if (le16toh(path[depth].ep_header->eh_ecount) ==
1188 le16toh(path[depth].ep_header->eh_max))
1197 ext4_ext_correct_indexes(struct inode *ip, struct ext4_extent_path *path)
1205 eh = path[depth].ep_header;
1206 ex = path[depth].ep_ext;
1219 border = le32toh(path[depth].ep_ext->e_blk);
1220 path[k].ep_index->ei_blk = htole32(border);
1221 ext4_ext_dirty(ip, path + k);
1224 if (path[k+1].ep_index != EXT_FIRST_INDEX(path[k+1].ep_header))
1227 path[k].ep_index->ei_blk = htole32(border);
1228 ext4_ext_dirty(ip, path + k);
1235 ext4_ext_insert_extent(struct inode *ip, struct ext4_extent_path *path,
1244 ex = path[depth].ep_ext;
1247 if (htole16(newext->e_len) == 0 || path[depth].ep_header == NULL)
1253 eh = path[depth].ep_header;
1260 eh = path[depth].ep_header;
1266 next = ext4_ext_next_leaf_block(ip, path);
1270 ("ext4_ext_insert_extent: bad path"));
1276 if (npath->ep_depth != path->ep_depth) {
1283 path = npath;
1292 error = ext4_ext_create_new_leaf(ip, path, newext);
1297 eh = path[depth].ep_header;
1300 nearex = path[depth].ep_ext;
1303 path[depth].ep_ext = EXT_FIRST_EXTENT(eh);
1311 path[depth].ep_ext = nearex + 1;
1316 path[depth].ep_ext = nearex;
1320 nearex = path[depth].ep_ext;
1350 error = ext4_ext_correct_indexes(ip, path);
1354 ext4_ext_dirty(ip, path + depth);
1400 struct ext4_extent_path *path;
1411 path = NULL;
1425 error = ext4_ext_find_extent(ip, iblk, &path);
1431 if (path[depth].ep_ext == NULL && depth != 0) {
1436 if ((ex = path[depth].ep_ext)) {
1459 bpref = ext4_ext_blkpref(ip, path, iblk);
1469 error = ext4_ext_insert_extent(ip, path, &newex);
1494 if (path) {
1495 ext4_ext_drop_refs(path);
1496 free(path, M_EXT2EXTENTS);
1531 ext4_ext_rm_index(struct inode *ip, struct ext4_extent_path *path)
1536 path--;
1537 leaf = ext4_ext_index_pblock(path->ep_index);
1538 KASSERT(path->ep_header->eh_ecount != 0,
1540 path->ep_header->eh_ecount =
1541 htole16(le16toh(path->ep_header->eh_ecount) - 1);
1542 ext4_ext_dirty(ip, path);
1548 ext4_ext_rm_leaf(struct inode *ip, struct ext4_extent_path *path,
1560 if (!path[depth].ep_header) {
1561 if (path[depth].ep_data == NULL)
1563 path[depth].ep_header =
1564 (struct ext4_extent_header* )path[depth].ep_data;
1567 eh = path[depth].ep_header;
1581 path[depth].ep_ext = ex;
1616 ext4_ext_dirty(ip, path + depth);
1624 error = ext4_ext_correct_indexes(ip, path);
1631 path[depth].ep_data != NULL)
1632 error = ext4_ext_rm_index(ip, path + depth);
1674 ext4_ext_more_to_rm(struct ext4_extent_path *path)
1677 KASSERT(path->ep_index != NULL,
1678 ("ext4_ext_more_to_rm: bad index from path"));
1680 if (path->ep_index < EXT_FIRST_INDEX(path->ep_header))
1683 if (le16toh(path->ep_header->eh_ecount) == path->index_count)
1695 struct ext4_extent_path *path;
1706 path = malloc(sizeof(struct ext4_extent_path) * (depth + 1),
1708 path[0].ep_header = ehp;
1709 path[0].ep_depth = depth;
1714 error = ext4_ext_rm_leaf(ip, path, length);
1717 free(path[i].ep_data, M_EXT2EXTENTS);
1718 path[i].ep_data = NULL;
1724 if (!path[i].ep_header)
1725 path[i].ep_header =
1726 (struct ext4_extent_header *)path[i].ep_data;
1728 if (!path[i].ep_index) {
1730 path[i].ep_index = EXT_LAST_INDEX(path[i].ep_header);
1731 path[i].index_count =
1732 le16toh(path[i].ep_header->eh_ecount) + 1;
1735 path[i].ep_index--;
1738 if (ext4_ext_more_to_rm(path + i)) {
1739 memset(path + i + 1, 0, sizeof(*path));
1741 ext4_ext_index_pblock(path[i].ep_index),
1742 path[0].ep_depth - (i + 1), 0);
1748 ext4_ext_fill_path_bdata(&path[i+1], bp,
1749 ext4_ext_index_pblock(path[i].ep_index));
1751 path[i].index_count =
1752 le16toh(path[i].ep_header->eh_ecount);
1755 if (path[i].ep_header->eh_ecount == 0 && i > 0) {
1757 error = ext4_ext_rm_index(ip, path + i);
1759 free(path[i].ep_data, M_EXT2EXTENTS);
1760 path[i].ep_data = NULL;
1765 if (path->ep_header->eh_ecount == 0) {
1771 ext4_ext_dirty(ip, path);
1774 ext4_ext_drop_refs(path);
1775 free(path, M_EXT2EXTENTS);