Lines Matching refs:es
190 struct extent_status *es;
191 es = rb_entry(node, struct extent_status, rb_node);
193 es->es_lblk, es->es_len,
194 ext4_es_pblock(es), ext4_es_status(es));
203 static inline ext4_lblk_t ext4_es_end(struct extent_status *es)
205 BUG_ON(es->es_lblk + es->es_len < es->es_lblk);
206 return es->es_lblk + es->es_len - 1;
217 struct extent_status *es = NULL;
220 es = rb_entry(node, struct extent_status, rb_node);
221 if (lblk < es->es_lblk)
223 else if (lblk > ext4_es_end(es))
226 return es;
229 if (es && lblk < es->es_lblk)
230 return es;
232 if (es && lblk > ext4_es_end(es)) {
233 node = rb_next(&es->rb_node);
250 * @es - extent found, if any
254 * is found, it's returned in @es. If not, and a matching extent is found
255 * beyond the block range, it's returned in @es. If no match is found, an
256 * extent is returned in @es whose es_lblk, es_len, and es_pblk components
260 int (*matching_fn)(struct extent_status *es),
262 struct extent_status *es)
268 WARN_ON(es == NULL);
274 es->es_lblk = es->es_len = es->es_pblk = 0;
300 es->es_lblk = es1->es_lblk;
301 es->es_len = es1->es_len;
302 es->es_pblk = es1->es_pblk;
311 int (*matching_fn)(struct extent_status *es),
313 struct extent_status *es)
315 es->es_lblk = es->es_len = es->es_pblk = 0;
323 __es_find_extent_range(inode, matching_fn, lblk, end, es);
326 trace_ext4_es_find_extent_range_exit(inode, es);
345 int (*matching_fn)(struct extent_status *es),
348 struct extent_status es;
350 __es_find_extent_range(inode, matching_fn, start, end, &es);
351 if (es.es_len == 0)
353 else if (es.es_lblk <= start &&
354 start < es.es_lblk + es.es_len)
356 else if (start <= es.es_lblk && es.es_lblk <= end)
365 int (*matching_fn)(struct extent_status *es),
395 int (*matching_fn)(struct extent_status *es),
411 int (*matching_fn)(struct extent_status *es),
473 static inline bool ext4_es_must_keep(struct extent_status *es)
476 if (ext4_es_is_delayed(es))
490 static void ext4_es_init_extent(struct inode *inode, struct extent_status *es,
493 es->es_lblk = lblk;
494 es->es_len = len;
495 es->es_pblk = pblk;
498 if (!ext4_es_must_keep(es)) {
509 static inline void __es_free_extent(struct extent_status *es)
511 kmem_cache_free(ext4_es_cachep, es);
514 static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
520 if (!ext4_es_must_keep(es)) {
528 __es_free_extent(es);
571 ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
577 node = rb_prev(&es->rb_node);
579 return es;
582 if (ext4_es_can_be_merged(es1, es)) {
583 es1->es_len += es->es_len;
584 if (ext4_es_is_referenced(es))
586 rb_erase(&es->rb_node, &tree->root);
587 ext4_es_free_extent(inode, es);
588 es = es1;
591 return es;
595 ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
601 node = rb_next(&es->rb_node);
603 return es;
606 if (ext4_es_can_be_merged(es, es1)) {
607 es->es_len += es1->es_len;
609 ext4_es_set_referenced(es);
614 return es;
621 struct extent_status *es)
630 path = ext4_find_extent(inode, es->es_lblk, NULL, EXT4_EX_NOCACHE);
644 es_status = ext4_es_is_unwritten(es) ? 1 : 0;
647 * Make sure ex and es are not overlap when we try to insert
650 if (!ext4_es_is_written(es) && !ext4_es_is_unwritten(es)) {
651 if (in_range(es->es_lblk, ee_block, ee_len)) {
659 es->es_lblk, es->es_len,
660 ext4_es_pblock(es), ext4_es_status(es));
666 * We don't check ee_block == es->es_lblk, etc. because es
669 if (es->es_lblk < ee_block ||
670 ext4_es_pblock(es) != ee_start + es->es_lblk - ee_block) {
675 ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
676 ext4_es_pblock(es), es_status ? 'u' : 'w');
685 ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
686 ext4_es_pblock(es), es_status ? 'u' : 'w');
693 if (!ext4_es_is_delayed(es) && !ext4_es_is_hole(es)) {
698 es->es_lblk, es->es_lblk, es->es_len,
699 ext4_es_pblock(es), ext4_es_status(es));
708 struct extent_status *es)
720 map.m_lblk = es->es_lblk;
721 map.m_len = es->es_len;
725 if (ext4_es_is_delayed(es) || ext4_es_is_hole(es)) {
733 inode->i_ino, es->es_lblk, es->es_len,
734 ext4_es_pblock(es), ext4_es_status(es));
736 } else if (ext4_es_is_written(es)) {
737 if (retval != es->es_len) {
740 inode->i_ino, retval, es->es_len);
743 if (map.m_pblk != ext4_es_pblock(es)) {
748 ext4_es_pblock(es));
759 if (ext4_es_is_written(es)) {
763 inode->i_ino, es->es_lblk, es->es_len,
764 ext4_es_pblock(es), ext4_es_status(es));
771 struct extent_status *es)
779 ext4_es_insert_extent_ext_check(inode, es);
781 ext4_es_insert_extent_ind_check(inode, es);
785 struct extent_status *es)
796 struct extent_status *es;
800 es = rb_entry(parent, struct extent_status, rb_node);
802 if (newes->es_lblk < es->es_lblk) {
803 if (ext4_es_can_be_merged(newes, es)) {
808 es->es_lblk = newes->es_lblk;
809 es->es_len += newes->es_len;
810 if (ext4_es_is_written(es) ||
811 ext4_es_is_unwritten(es))
812 ext4_es_store_pblock(es,
814 es = ext4_es_try_to_merge_left(inode, es);
818 } else if (newes->es_lblk > ext4_es_end(es)) {
819 if (ext4_es_can_be_merged(es, newes)) {
820 es->es_len += newes->es_len;
821 es = ext4_es_try_to_merge_right(inode, es);
832 es = prealloc;
834 es = __es_alloc_extent(false);
835 if (!es)
837 ext4_es_init_extent(inode, es, newes->es_lblk, newes->es_len,
840 rb_link_node(&es->rb_node, parent, p);
841 rb_insert_color(&es->rb_node, &tree->root);
844 tree->cache_es = es;
955 struct extent_status *es;
974 es = __es_tree_search(&EXT4_I(inode)->i_es_tree.root, lblk);
975 if (!es || es->es_lblk > end)
989 struct extent_status *es)
1007 es->es_lblk = es->es_len = es->es_pblk = 0;
1033 es->es_lblk = es1->es_lblk;
1034 es->es_len = es1->es_len;
1035 es->es_pblk = es1->es_pblk;
1054 trace_ext4_es_lookup_extent_exit(inode, es, found);
1074 * @es - pointer to first extent in range
1077 * Assumes es is not NULL
1080 struct extent_status *es, struct rsvd_count *rc)
1095 if (lblk > es->es_lblk) {
1096 rc->left_es = es;
1098 node = rb_prev(&es->rb_node);
1115 * @es - pointer to extent containing clusters to be counted
1122 struct extent_status *es, struct rsvd_count *rc)
1127 if (!ext4_es_is_delonly(es))
1139 i = (lblk < es->es_lblk) ? es->es_lblk : lblk;
1141 end = (end > ext4_es_end(es)) ? ext4_es_end(es) : end;
1254 struct extent_status *es;
1274 es = rc->left_es;
1275 while (es && ext4_es_end(es) >=
1277 if (ext4_es_is_delonly(es)) {
1282 node = rb_prev(&es->rb_node);
1285 es = rb_entry(node, struct extent_status, rb_node);
1289 es = right_es;
1292 es = node ? rb_entry(node, struct extent_status,
1295 while (es && es->es_lblk <=
1297 if (ext4_es_is_delonly(es)) {
1302 node = rb_next(&es->rb_node);
1305 es = rb_entry(node, struct extent_status,
1366 * @prealloc - pre-allocated es to avoid memory allocation failures
1379 struct extent_status *es;
1390 es = __es_tree_search(&tree->root, lblk);
1391 if (!es)
1393 if (es->es_lblk > end)
1399 init_rsvd(inode, lblk, es, &rc);
1401 orig_es.es_lblk = es->es_lblk;
1402 orig_es.es_len = es->es_len;
1403 orig_es.es_pblk = es->es_pblk;
1405 len1 = lblk > es->es_lblk ? lblk - es->es_lblk : 0;
1406 len2 = ext4_es_end(es) > end ? ext4_es_end(es) - end : 0;
1408 es->es_len = len1;
1427 es->es_lblk = orig_es.es_lblk;
1428 es->es_len = orig_es.es_len;
1432 es->es_lblk = end + 1;
1433 es->es_len = len2;
1434 if (ext4_es_is_written(es) ||
1435 ext4_es_is_unwritten(es)) {
1437 ext4_es_store_pblock(es, block);
1450 node = rb_next(&es->rb_node);
1452 es = rb_entry(node, struct extent_status, rb_node);
1454 es = NULL;
1457 while (es && ext4_es_end(es) <= end) {
1459 count_rsvd(inode, es->es_lblk, es->es_len, es, &rc);
1460 node = rb_next(&es->rb_node);
1461 rb_erase(&es->rb_node, &tree->root);
1462 ext4_es_free_extent(inode, es);
1464 es = NULL;
1467 es = rb_entry(node, struct extent_status, rb_node);
1470 if (es && es->es_lblk < end + 1) {
1471 ext4_lblk_t orig_len = es->es_len;
1473 len1 = ext4_es_end(es) - end;
1475 count_rsvd(inode, es->es_lblk, orig_len - len1,
1476 es, &rc);
1477 es->es_lblk = end + 1;
1478 es->es_len = len1;
1479 if (ext4_es_is_written(es) || ext4_es_is_unwritten(es)) {
1480 block = es->es_pblk + orig_len - len1;
1481 ext4_es_store_pblock(es, block);
1487 *reserved = get_rsvd(inode, end, es, &rc);
1508 struct extent_status *es = NULL;
1524 if (err && !es)
1525 es = __es_alloc_extent(true);
1532 err = __es_remove_extent(inode, lblk, end, &reserved, es);
1534 if (es) {
1535 if (!es->es_len)
1536 __es_free_extent(es);
1537 es = NULL;
1777 struct extent_status *es;
1780 es = __es_tree_search(&tree->root, ei->i_es_shrink_lblk);
1781 if (!es)
1785 if (es->es_lblk > end) {
1791 node = rb_next(&es->rb_node);
1793 if (ext4_es_must_keep(es))
1795 if (ext4_es_is_referenced(es)) {
1796 ext4_es_clear_referenced(es);
1800 rb_erase(&es->rb_node, &tree->root);
1801 ext4_es_free_extent(inode, es);
1806 es = rb_entry(node, struct extent_status, rb_node);
1808 ei->i_es_shrink_lblk = es->es_lblk;
1846 struct extent_status *es;
1855 es = rb_entry(node, struct extent_status, rb_node);
1857 if (!ext4_es_must_keep(es)) {
1858 rb_erase(&es->rb_node, &tree->root);
1859 ext4_es_free_extent(inode, es);
2158 struct extent_status *es;
2168 es = __es_tree_search(&tree->root, start);
2170 while (es && (es->es_lblk <= end)) {
2171 if (ext4_es_is_delonly(es)) {
2172 if (es->es_lblk <= start)
2175 first_lclu = EXT4_B2C(sbi, es->es_lblk);
2177 if (ext4_es_end(es) >= end)
2180 last_lclu = EXT4_B2C(sbi, ext4_es_end(es));
2188 node = rb_next(&es->rb_node);
2191 es = rb_entry(node, struct extent_status, rb_node);