Lines Matching refs:es
188 struct extent_status *es;
189 es = rb_entry(node, struct extent_status, rb_node);
191 es->es_lblk, es->es_len,
192 ext4_es_pblock(es), ext4_es_status(es));
201 static inline ext4_lblk_t ext4_es_end(struct extent_status *es)
203 BUG_ON(es->es_lblk + es->es_len < es->es_lblk);
204 return es->es_lblk + es->es_len - 1;
215 struct extent_status *es = NULL;
218 es = rb_entry(node, struct extent_status, rb_node);
219 if (lblk < es->es_lblk)
221 else if (lblk > ext4_es_end(es))
224 return es;
227 if (es && lblk < es->es_lblk)
228 return es;
230 if (es && lblk > ext4_es_end(es)) {
231 node = rb_next(&es->rb_node);
248 * @es - extent found, if any
252 * is found, it's returned in @es. If not, and a matching extent is found
253 * beyond the block range, it's returned in @es. If no match is found, an
254 * extent is returned in @es whose es_lblk, es_len, and es_pblk components
258 int (*matching_fn)(struct extent_status *es),
260 struct extent_status *es)
266 WARN_ON(es == NULL);
272 es->es_lblk = es->es_len = es->es_pblk = 0;
298 es->es_lblk = es1->es_lblk;
299 es->es_len = es1->es_len;
300 es->es_pblk = es1->es_pblk;
309 int (*matching_fn)(struct extent_status *es),
311 struct extent_status *es)
319 __es_find_extent_range(inode, matching_fn, lblk, end, es);
322 trace_ext4_es_find_extent_range_exit(inode, es);
341 int (*matching_fn)(struct extent_status *es),
344 struct extent_status es;
346 __es_find_extent_range(inode, matching_fn, start, end, &es);
347 if (es.es_len == 0)
349 else if (es.es_lblk <= start &&
350 start < es.es_lblk + es.es_len)
352 else if (start <= es.es_lblk && es.es_lblk <= end)
361 int (*matching_fn)(struct extent_status *es),
391 int (*matching_fn)(struct extent_status *es),
407 int (*matching_fn)(struct extent_status *es),
469 static inline bool ext4_es_must_keep(struct extent_status *es)
472 if (ext4_es_is_delayed(es))
486 static void ext4_es_init_extent(struct inode *inode, struct extent_status *es,
489 es->es_lblk = lblk;
490 es->es_len = len;
491 es->es_pblk = pblk;
494 if (!ext4_es_must_keep(es)) {
505 static inline void __es_free_extent(struct extent_status *es)
507 kmem_cache_free(ext4_es_cachep, es);
510 static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
516 if (!ext4_es_must_keep(es)) {
524 __es_free_extent(es);
567 ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
573 node = rb_prev(&es->rb_node);
575 return es;
578 if (ext4_es_can_be_merged(es1, es)) {
579 es1->es_len += es->es_len;
580 if (ext4_es_is_referenced(es))
582 rb_erase(&es->rb_node, &tree->root);
583 ext4_es_free_extent(inode, es);
584 es = es1;
587 return es;
591 ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
597 node = rb_next(&es->rb_node);
599 return es;
602 if (ext4_es_can_be_merged(es, es1)) {
603 es->es_len += es1->es_len;
605 ext4_es_set_referenced(es);
610 return es;
617 struct extent_status *es)
626 path = ext4_find_extent(inode, es->es_lblk, NULL, EXT4_EX_NOCACHE);
640 es_status = ext4_es_is_unwritten(es) ? 1 : 0;
643 * Make sure ex and es are not overlap when we try to insert
646 if (!ext4_es_is_written(es) && !ext4_es_is_unwritten(es)) {
647 if (in_range(es->es_lblk, ee_block, ee_len)) {
655 es->es_lblk, es->es_len,
656 ext4_es_pblock(es), ext4_es_status(es));
662 * We don't check ee_block == es->es_lblk, etc. because es
665 if (es->es_lblk < ee_block ||
666 ext4_es_pblock(es) != ee_start + es->es_lblk - ee_block) {
671 ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
672 ext4_es_pblock(es), es_status ? 'u' : 'w');
681 ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
682 ext4_es_pblock(es), es_status ? 'u' : 'w');
689 if (!ext4_es_is_delayed(es) && !ext4_es_is_hole(es)) {
694 es->es_lblk, es->es_lblk, es->es_len,
695 ext4_es_pblock(es), ext4_es_status(es));
703 struct extent_status *es)
715 map.m_lblk = es->es_lblk;
716 map.m_len = es->es_len;
720 if (ext4_es_is_delayed(es) || ext4_es_is_hole(es)) {
728 inode->i_ino, es->es_lblk, es->es_len,
729 ext4_es_pblock(es), ext4_es_status(es));
731 } else if (ext4_es_is_written(es)) {
732 if (retval != es->es_len) {
735 inode->i_ino, retval, es->es_len);
738 if (map.m_pblk != ext4_es_pblock(es)) {
743 ext4_es_pblock(es));
754 if (ext4_es_is_written(es)) {
758 inode->i_ino, es->es_lblk, es->es_len,
759 ext4_es_pblock(es), ext4_es_status(es));
766 struct extent_status *es)
774 ext4_es_insert_extent_ext_check(inode, es);
776 ext4_es_insert_extent_ind_check(inode, es);
780 struct extent_status *es)
791 struct extent_status *es;
795 es = rb_entry(parent, struct extent_status, rb_node);
797 if (newes->es_lblk < es->es_lblk) {
798 if (ext4_es_can_be_merged(newes, es)) {
803 es->es_lblk = newes->es_lblk;
804 es->es_len += newes->es_len;
805 if (ext4_es_is_written(es) ||
806 ext4_es_is_unwritten(es))
807 ext4_es_store_pblock(es,
809 es = ext4_es_try_to_merge_left(inode, es);
813 } else if (newes->es_lblk > ext4_es_end(es)) {
814 if (ext4_es_can_be_merged(es, newes)) {
815 es->es_len += newes->es_len;
816 es = ext4_es_try_to_merge_right(inode, es);
827 es = prealloc;
829 es = __es_alloc_extent(false);
830 if (!es)
832 ext4_es_init_extent(inode, es, newes->es_lblk, newes->es_len,
835 rb_link_node(&es->rb_node, parent, p);
836 rb_insert_color(&es->rb_node, &tree->root);
839 tree->cache_es = es;
948 struct extent_status *es;
967 es = __es_tree_search(&EXT4_I(inode)->i_es_tree.root, lblk);
968 if (!es || es->es_lblk > end)
982 struct extent_status *es)
1000 es->es_lblk = es->es_len = es->es_pblk = 0;
1026 es->es_lblk = es1->es_lblk;
1027 es->es_len = es1->es_len;
1028 es->es_pblk = es1->es_pblk;
1047 trace_ext4_es_lookup_extent_exit(inode, es, found);
1067 * @es - pointer to first extent in range
1070 * Assumes es is not NULL
1073 struct extent_status *es, struct rsvd_count *rc)
1088 if (lblk > es->es_lblk) {
1089 rc->left_es = es;
1091 node = rb_prev(&es->rb_node);
1108 * @es - pointer to extent containing clusters to be counted
1115 struct extent_status *es, struct rsvd_count *rc)
1120 if (!ext4_es_is_delonly(es))
1132 i = (lblk < es->es_lblk) ? es->es_lblk : lblk;
1134 end = (end > ext4_es_end(es)) ? ext4_es_end(es) : end;
1247 struct extent_status *es;
1267 es = rc->left_es;
1268 while (es && ext4_es_end(es) >=
1270 if (ext4_es_is_delonly(es)) {
1275 node = rb_prev(&es->rb_node);
1278 es = rb_entry(node, struct extent_status, rb_node);
1282 es = right_es;
1285 es = node ? rb_entry(node, struct extent_status,
1288 while (es && es->es_lblk <=
1290 if (ext4_es_is_delonly(es)) {
1295 node = rb_next(&es->rb_node);
1298 es = rb_entry(node, struct extent_status,
1359 * @prealloc - pre-allocated es to avoid memory allocation failures
1372 struct extent_status *es;
1383 es = __es_tree_search(&tree->root, lblk);
1384 if (!es)
1386 if (es->es_lblk > end)
1392 init_rsvd(inode, lblk, es, &rc);
1394 orig_es.es_lblk = es->es_lblk;
1395 orig_es.es_len = es->es_len;
1396 orig_es.es_pblk = es->es_pblk;
1398 len1 = lblk > es->es_lblk ? lblk - es->es_lblk : 0;
1399 len2 = ext4_es_end(es) > end ? ext4_es_end(es) - end : 0;
1401 es->es_len = len1;
1420 es->es_lblk = orig_es.es_lblk;
1421 es->es_len = orig_es.es_len;
1425 es->es_lblk = end + 1;
1426 es->es_len = len2;
1427 if (ext4_es_is_written(es) ||
1428 ext4_es_is_unwritten(es)) {
1430 ext4_es_store_pblock(es, block);
1443 node = rb_next(&es->rb_node);
1445 es = rb_entry(node, struct extent_status, rb_node);
1447 es = NULL;
1450 while (es && ext4_es_end(es) <= end) {
1452 count_rsvd(inode, es->es_lblk, es->es_len, es, &rc);
1453 node = rb_next(&es->rb_node);
1454 rb_erase(&es->rb_node, &tree->root);
1455 ext4_es_free_extent(inode, es);
1457 es = NULL;
1460 es = rb_entry(node, struct extent_status, rb_node);
1463 if (es && es->es_lblk < end + 1) {
1464 ext4_lblk_t orig_len = es->es_len;
1466 len1 = ext4_es_end(es) - end;
1468 count_rsvd(inode, es->es_lblk, orig_len - len1,
1469 es, &rc);
1470 es->es_lblk = end + 1;
1471 es->es_len = len1;
1472 if (ext4_es_is_written(es) || ext4_es_is_unwritten(es)) {
1473 block = es->es_pblk + orig_len - len1;
1474 ext4_es_store_pblock(es, block);
1480 *reserved = get_rsvd(inode, end, es, &rc);
1501 struct extent_status *es = NULL;
1517 if (err && !es)
1518 es = __es_alloc_extent(true);
1525 err = __es_remove_extent(inode, lblk, end, &reserved, es);
1527 if (es) {
1528 if (!es->es_len)
1529 __es_free_extent(es);
1530 es = NULL;
1728 sbi->s_es_shrinker = shrinker_alloc(0, "ext4-es:%s", sbi->s_sb->s_id);
1774 struct extent_status *es;
1777 es = __es_tree_search(&tree->root, ei->i_es_shrink_lblk);
1778 if (!es)
1782 if (es->es_lblk > end) {
1788 node = rb_next(&es->rb_node);
1790 if (ext4_es_must_keep(es))
1792 if (ext4_es_is_referenced(es)) {
1793 ext4_es_clear_referenced(es);
1797 rb_erase(&es->rb_node, &tree->root);
1798 ext4_es_free_extent(inode, es);
1803 es = rb_entry(node, struct extent_status, rb_node);
1805 ei->i_es_shrink_lblk = es->es_lblk;
1843 struct extent_status *es;
1852 es = rb_entry(node, struct extent_status, rb_node);
1854 if (!ext4_es_must_keep(es)) {
1855 rb_erase(&es->rb_node, &tree->root);
1856 ext4_es_free_extent(inode, es);
2151 struct extent_status *es;
2161 es = __es_tree_search(&tree->root, start);
2163 while (es && (es->es_lblk <= end)) {
2164 if (ext4_es_is_delonly(es)) {
2165 if (es->es_lblk <= start)
2168 first_lclu = EXT4_B2C(sbi, es->es_lblk);
2170 if (ext4_es_end(es) >= end)
2173 last_lclu = EXT4_B2C(sbi, ext4_es_end(es));
2181 node = rb_next(&es->rb_node);
2184 es = rb_entry(node, struct extent_status, rb_node);