Merge tag 'for-5.17-rc5-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

+1 -1

fs/btrfs/ctree.h

··· 3291 3291 int __init btrfs_auto_defrag_init(void); 3292 3292 void __cold btrfs_auto_defrag_exit(void); 3293 3293 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 3294 - struct btrfs_inode *inode); 3294 + struct btrfs_inode *inode, u32 extent_thresh); 3295 3295 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info); 3296 3296 void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info); 3297 3297 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);

+2

fs/btrfs/extent_map.c

··· 261 261 em->mod_len = (em->mod_len + em->mod_start) - merge->mod_start; 262 262 em->mod_start = merge->mod_start; 263 263 em->generation = max(em->generation, merge->generation); 264 + set_bit(EXTENT_FLAG_MERGED, &em->flags); 264 265 265 266 rb_erase_cached(&merge->rb_node, &tree->map); 266 267 RB_CLEAR_NODE(&merge->rb_node); ··· 279 278 RB_CLEAR_NODE(&merge->rb_node); 280 279 em->mod_len = (merge->mod_start + merge->mod_len) - em->mod_start; 281 280 em->generation = max(em->generation, merge->generation); 281 + set_bit(EXTENT_FLAG_MERGED, &em->flags); 282 282 free_extent_map(merge); 283 283 } 284 284 }

+8

fs/btrfs/extent_map.h

··· 25 25 EXTENT_FLAG_FILLING, 26 26 /* filesystem extent mapping type */ 27 27 EXTENT_FLAG_FS_MAPPING, 28 + /* This em is merged from two or more physically adjacent ems */ 29 + EXTENT_FLAG_MERGED, 28 30 }; 29 31 30 32 struct extent_map { ··· 42 40 u64 ram_bytes; 43 41 u64 block_start; 44 42 u64 block_len; 43 + 44 + /* 45 + * Generation of the extent map, for merged em it's the highest 46 + * generation of all merged ems. 47 + * For non-merged extents, it's from btrfs_file_extent_item::generation. 48 + */ 45 49 u64 generation; 46 50 unsigned long flags; 47 51 /* Used for chunk mappings, flag EXTENT_FLAG_FS_MAPPING must be set */

+35 -62

fs/btrfs/file.c

··· 50 50 /* root objectid */ 51 51 u64 root; 52 52 53 - /* last offset we were able to defrag */ 54 - u64 last_offset; 55 - 56 - /* if we've wrapped around back to zero once already */ 57 - int cycled; 53 + /* 54 + * The extent size threshold for autodefrag. 55 + * 56 + * This value is different for compressed/non-compressed extents, 57 + * thus needs to be passed from higher layer. 58 + * (aka, inode_should_defrag()) 59 + */ 60 + u32 extent_thresh; 58 61 }; 59 62 60 63 static int __compare_inode_defrag(struct inode_defrag *defrag1, ··· 110 107 */ 111 108 if (defrag->transid < entry->transid) 112 109 entry->transid = defrag->transid; 113 - if (defrag->last_offset > entry->last_offset) 114 - entry->last_offset = defrag->last_offset; 110 + entry->extent_thresh = min(defrag->extent_thresh, 111 + entry->extent_thresh); 115 112 return -EEXIST; 116 113 } 117 114 } ··· 137 134 * enabled 138 135 */ 139 136 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 140 - struct btrfs_inode *inode) 137 + struct btrfs_inode *inode, u32 extent_thresh) 141 138 { 142 139 struct btrfs_root *root = inode->root; 143 140 struct btrfs_fs_info *fs_info = root->fs_info; ··· 163 160 defrag->ino = btrfs_ino(inode); 164 161 defrag->transid = transid; 165 162 defrag->root = root->root_key.objectid; 163 + defrag->extent_thresh = extent_thresh; 166 164 167 165 spin_lock(&fs_info->defrag_inodes_lock); 168 166 if (!test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags)) { ··· 180 176 } 181 177 spin_unlock(&fs_info->defrag_inodes_lock); 182 178 return 0; 183 - } 184 - 185 - /* 186 - * Requeue the defrag object. If there is a defrag object that points to 187 - * the same inode in the tree, we will merge them together (by 188 - * __btrfs_add_inode_defrag()) and free the one that we want to requeue. 189 - */ 190 - static void btrfs_requeue_inode_defrag(struct btrfs_inode *inode, 191 - struct inode_defrag *defrag) 192 - { 193 - struct btrfs_fs_info *fs_info = inode->root->fs_info; 194 - int ret; 195 - 196 - if (!__need_auto_defrag(fs_info)) 197 - goto out; 198 - 199 - /* 200 - * Here we don't check the IN_DEFRAG flag, because we need merge 201 - * them together. 202 - */ 203 - spin_lock(&fs_info->defrag_inodes_lock); 204 - ret = __btrfs_add_inode_defrag(inode, defrag); 205 - spin_unlock(&fs_info->defrag_inodes_lock); 206 - if (ret) 207 - goto out; 208 - return; 209 - out: 210 - kmem_cache_free(btrfs_inode_defrag_cachep, defrag); 211 179 } 212 180 213 181 /* ··· 254 278 struct btrfs_root *inode_root; 255 279 struct inode *inode; 256 280 struct btrfs_ioctl_defrag_range_args range; 257 - int num_defrag; 258 - int ret; 281 + int ret = 0; 282 + u64 cur = 0; 283 + 284 + again: 285 + if (test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state)) 286 + goto cleanup; 287 + if (!__need_auto_defrag(fs_info)) 288 + goto cleanup; 259 289 260 290 /* get the inode */ 261 291 inode_root = btrfs_get_fs_root(fs_info, defrag->root, true); ··· 277 295 goto cleanup; 278 296 } 279 297 298 + if (cur >= i_size_read(inode)) { 299 + iput(inode); 300 + goto cleanup; 301 + } 302 + 280 303 /* do a chunk of defrag */ 281 304 clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags); 282 305 memset(&range, 0, sizeof(range)); 283 306 range.len = (u64)-1; 284 - range.start = defrag->last_offset; 307 + range.start = cur; 308 + range.extent_thresh = defrag->extent_thresh; 285 309 286 310 sb_start_write(fs_info->sb); 287 - num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid, 311 + ret = btrfs_defrag_file(inode, NULL, &range, defrag->transid, 288 312 BTRFS_DEFRAG_BATCH); 289 313 sb_end_write(fs_info->sb); 290 - /* 291 - * if we filled the whole defrag batch, there 292 - * must be more work to do. Queue this defrag 293 - * again 294 - */ 295 - if (num_defrag == BTRFS_DEFRAG_BATCH) { 296 - defrag->last_offset = range.start; 297 - btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag); 298 - } else if (defrag->last_offset && !defrag->cycled) { 299 - /* 300 - * we didn't fill our defrag batch, but 301 - * we didn't start at zero. Make sure we loop 302 - * around to the start of the file. 303 - */ 304 - defrag->last_offset = 0; 305 - defrag->cycled = 1; 306 - btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag); 307 - } else { 308 - kmem_cache_free(btrfs_inode_defrag_cachep, defrag); 309 - } 310 - 311 314 iput(inode); 312 - return 0; 315 + 316 + if (ret < 0) 317 + goto cleanup; 318 + 319 + cur = max(cur + fs_info->sectorsize, range.start); 320 + goto again; 321 + 313 322 cleanup: 314 323 kmem_cache_free(btrfs_inode_defrag_cachep, defrag); 315 324 return ret;

+2 -2

fs/btrfs/inode.c

··· 560 560 } 561 561 562 562 static inline void inode_should_defrag(struct btrfs_inode *inode, 563 - u64 start, u64 end, u64 num_bytes, u64 small_write) 563 + u64 start, u64 end, u64 num_bytes, u32 small_write) 564 564 { 565 565 /* If this is a small write inside eof, kick off a defrag */ 566 566 if (num_bytes < small_write && 567 567 (start > 0 || end + 1 < inode->disk_i_size)) 568 - btrfs_add_inode_defrag(NULL, inode); 568 + btrfs_add_inode_defrag(NULL, inode, small_write); 569 569 } 570 570 571 571 /*

+237 -19

fs/btrfs/ioctl.c

··· 1012 1012 return ret; 1013 1013 } 1014 1014 1015 + /* 1016 + * Defrag specific helper to get an extent map. 1017 + * 1018 + * Differences between this and btrfs_get_extent() are: 1019 + * 1020 + * - No extent_map will be added to inode->extent_tree 1021 + * To reduce memory usage in the long run. 1022 + * 1023 + * - Extra optimization to skip file extents older than @newer_than 1024 + * By using btrfs_search_forward() we can skip entire file ranges that 1025 + * have extents created in past transactions, because btrfs_search_forward() 1026 + * will not visit leaves and nodes with a generation smaller than given 1027 + * minimal generation threshold (@newer_than). 1028 + * 1029 + * Return valid em if we find a file extent matching the requirement. 1030 + * Return NULL if we can not find a file extent matching the requirement. 1031 + * 1032 + * Return ERR_PTR() for error. 1033 + */ 1034 + static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, 1035 + u64 start, u64 newer_than) 1036 + { 1037 + struct btrfs_root *root = inode->root; 1038 + struct btrfs_file_extent_item *fi; 1039 + struct btrfs_path path = { 0 }; 1040 + struct extent_map *em; 1041 + struct btrfs_key key; 1042 + u64 ino = btrfs_ino(inode); 1043 + int ret; 1044 + 1045 + em = alloc_extent_map(); 1046 + if (!em) { 1047 + ret = -ENOMEM; 1048 + goto err; 1049 + } 1050 + 1051 + key.objectid = ino; 1052 + key.type = BTRFS_EXTENT_DATA_KEY; 1053 + key.offset = start; 1054 + 1055 + if (newer_than) { 1056 + ret = btrfs_search_forward(root, &key, &path, newer_than); 1057 + if (ret < 0) 1058 + goto err; 1059 + /* Can't find anything newer */ 1060 + if (ret > 0) 1061 + goto not_found; 1062 + } else { 1063 + ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0); 1064 + if (ret < 0) 1065 + goto err; 1066 + } 1067 + if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) { 1068 + /* 1069 + * If btrfs_search_slot() makes path to point beyond nritems, 1070 + * we should not have an empty leaf, as this inode must at 1071 + * least have its INODE_ITEM. 1072 + */ 1073 + ASSERT(btrfs_header_nritems(path.nodes[0])); 1074 + path.slots[0] = btrfs_header_nritems(path.nodes[0]) - 1; 1075 + } 1076 + btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]); 1077 + /* Perfect match, no need to go one slot back */ 1078 + if (key.objectid == ino && key.type == BTRFS_EXTENT_DATA_KEY && 1079 + key.offset == start) 1080 + goto iterate; 1081 + 1082 + /* We didn't find a perfect match, needs to go one slot back */ 1083 + if (path.slots[0] > 0) { 1084 + btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]); 1085 + if (key.objectid == ino && key.type == BTRFS_EXTENT_DATA_KEY) 1086 + path.slots[0]--; 1087 + } 1088 + 1089 + iterate: 1090 + /* Iterate through the path to find a file extent covering @start */ 1091 + while (true) { 1092 + u64 extent_end; 1093 + 1094 + if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) 1095 + goto next; 1096 + 1097 + btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]); 1098 + 1099 + /* 1100 + * We may go one slot back to INODE_REF/XATTR item, then 1101 + * need to go forward until we reach an EXTENT_DATA. 1102 + * But we should still has the correct ino as key.objectid. 1103 + */ 1104 + if (WARN_ON(key.objectid < ino) || key.type < BTRFS_EXTENT_DATA_KEY) 1105 + goto next; 1106 + 1107 + /* It's beyond our target range, definitely not extent found */ 1108 + if (key.objectid > ino || key.type > BTRFS_EXTENT_DATA_KEY) 1109 + goto not_found; 1110 + 1111 + /* 1112 + * | |<- File extent ->| 1113 + * \- start 1114 + * 1115 + * This means there is a hole between start and key.offset. 1116 + */ 1117 + if (key.offset > start) { 1118 + em->start = start; 1119 + em->orig_start = start; 1120 + em->block_start = EXTENT_MAP_HOLE; 1121 + em->len = key.offset - start; 1122 + break; 1123 + } 1124 + 1125 + fi = btrfs_item_ptr(path.nodes[0], path.slots[0], 1126 + struct btrfs_file_extent_item); 1127 + extent_end = btrfs_file_extent_end(&path); 1128 + 1129 + /* 1130 + * |<- file extent ->| | 1131 + * \- start 1132 + * 1133 + * We haven't reached start, search next slot. 1134 + */ 1135 + if (extent_end <= start) 1136 + goto next; 1137 + 1138 + /* Now this extent covers @start, convert it to em */ 1139 + btrfs_extent_item_to_extent_map(inode, &path, fi, false, em); 1140 + break; 1141 + next: 1142 + ret = btrfs_next_item(root, &path); 1143 + if (ret < 0) 1144 + goto err; 1145 + if (ret > 0) 1146 + goto not_found; 1147 + } 1148 + btrfs_release_path(&path); 1149 + return em; 1150 + 1151 + not_found: 1152 + btrfs_release_path(&path); 1153 + free_extent_map(em); 1154 + return NULL; 1155 + 1156 + err: 1157 + btrfs_release_path(&path); 1158 + free_extent_map(em); 1159 + return ERR_PTR(ret); 1160 + } 1161 + 1015 1162 static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start, 1016 - bool locked) 1163 + u64 newer_than, bool locked) 1017 1164 { 1018 1165 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree; 1019 1166 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; ··· 1175 1028 em = lookup_extent_mapping(em_tree, start, sectorsize); 1176 1029 read_unlock(&em_tree->lock); 1177 1030 1031 + /* 1032 + * We can get a merged extent, in that case, we need to re-search 1033 + * tree to get the original em for defrag. 1034 + * 1035 + * If @newer_than is 0 or em::generation < newer_than, we can trust 1036 + * this em, as either we don't care about the generation, or the 1037 + * merged extent map will be rejected anyway. 1038 + */ 1039 + if (em && test_bit(EXTENT_FLAG_MERGED, &em->flags) && 1040 + newer_than && em->generation >= newer_than) { 1041 + free_extent_map(em); 1042 + em = NULL; 1043 + } 1044 + 1178 1045 if (!em) { 1179 1046 struct extent_state *cached = NULL; 1180 1047 u64 end = start + sectorsize - 1; ··· 1196 1035 /* get the big lock and read metadata off disk */ 1197 1036 if (!locked) 1198 1037 lock_extent_bits(io_tree, start, end, &cached); 1199 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, sectorsize); 1038 + em = defrag_get_extent(BTRFS_I(inode), start, newer_than); 1200 1039 if (!locked) 1201 1040 unlock_extent_cached(io_tree, start, end, &cached); 1202 1041 ··· 1207 1046 return em; 1208 1047 } 1209 1048 1049 + static u32 get_extent_max_capacity(const struct extent_map *em) 1050 + { 1051 + if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) 1052 + return BTRFS_MAX_COMPRESSED; 1053 + return BTRFS_MAX_EXTENT_SIZE; 1054 + } 1055 + 1210 1056 static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em, 1211 1057 bool locked) 1212 1058 { 1213 1059 struct extent_map *next; 1214 - bool ret = true; 1060 + bool ret = false; 1215 1061 1216 1062 /* this is the last extent */ 1217 1063 if (em->start + em->len >= i_size_read(inode)) 1218 1064 return false; 1219 1065 1220 - next = defrag_lookup_extent(inode, em->start + em->len, locked); 1066 + /* 1067 + * We want to check if the next extent can be merged with the current 1068 + * one, which can be an extent created in a past generation, so we pass 1069 + * a minimum generation of 0 to defrag_lookup_extent(). 1070 + */ 1071 + next = defrag_lookup_extent(inode, em->start + em->len, 0, locked); 1072 + /* No more em or hole */ 1221 1073 if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE) 1222 - ret = false; 1223 - else if ((em->block_start + em->block_len == next->block_start) && 1224 - (em->block_len > SZ_128K && next->block_len > SZ_128K)) 1225 - ret = false; 1226 - 1074 + goto out; 1075 + if (test_bit(EXTENT_FLAG_PREALLOC, &next->flags)) 1076 + goto out; 1077 + /* 1078 + * If the next extent is at its max capacity, defragging current extent 1079 + * makes no sense, as the total number of extents won't change. 1080 + */ 1081 + if (next->len >= get_extent_max_capacity(em)) 1082 + goto out; 1083 + ret = true; 1084 + out: 1227 1085 free_extent_map(next); 1228 1086 return ret; 1229 1087 } ··· 1366 1186 static int defrag_collect_targets(struct btrfs_inode *inode, 1367 1187 u64 start, u64 len, u32 extent_thresh, 1368 1188 u64 newer_than, bool do_compress, 1369 - bool locked, struct list_head *target_list) 1189 + bool locked, struct list_head *target_list, 1190 + u64 *last_scanned_ret) 1370 1191 { 1192 + bool last_is_target = false; 1371 1193 u64 cur = start; 1372 1194 int ret = 0; 1373 1195 ··· 1379 1197 bool next_mergeable = true; 1380 1198 u64 range_len; 1381 1199 1382 - em = defrag_lookup_extent(&inode->vfs_inode, cur, locked); 1200 + last_is_target = false; 1201 + em = defrag_lookup_extent(&inode->vfs_inode, cur, 1202 + newer_than, locked); 1383 1203 if (!em) 1384 1204 break; 1385 1205 ··· 1438 1254 if (range_len >= extent_thresh) 1439 1255 goto next; 1440 1256 1257 + /* 1258 + * Skip extents already at its max capacity, this is mostly for 1259 + * compressed extents, which max cap is only 128K. 1260 + */ 1261 + if (em->len >= get_extent_max_capacity(em)) 1262 + goto next; 1263 + 1441 1264 next_mergeable = defrag_check_next_extent(&inode->vfs_inode, em, 1442 1265 locked); 1443 1266 if (!next_mergeable) { ··· 1463 1272 } 1464 1273 1465 1274 add: 1275 + last_is_target = true; 1466 1276 range_len = min(extent_map_end(em), start + len) - cur; 1467 1277 /* 1468 1278 * This one is a good target, check if it can be merged into ··· 1506 1314 list_del_init(&entry->list); 1507 1315 kfree(entry); 1508 1316 } 1317 + } 1318 + if (!ret && last_scanned_ret) { 1319 + /* 1320 + * If the last extent is not a target, the caller can skip to 1321 + * the end of that extent. 1322 + * Otherwise, we can only go the end of the specified range. 1323 + */ 1324 + if (!last_is_target) 1325 + *last_scanned_ret = max(cur, *last_scanned_ret); 1326 + else 1327 + *last_scanned_ret = max(start + len, *last_scanned_ret); 1509 1328 } 1510 1329 return ret; 1511 1330 } ··· 1576 1373 } 1577 1374 1578 1375 static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len, 1579 - u32 extent_thresh, u64 newer_than, bool do_compress) 1376 + u32 extent_thresh, u64 newer_than, bool do_compress, 1377 + u64 *last_scanned_ret) 1580 1378 { 1581 1379 struct extent_state *cached_state = NULL; 1582 1380 struct defrag_target_range *entry; ··· 1623 1419 */ 1624 1420 ret = defrag_collect_targets(inode, start, len, extent_thresh, 1625 1421 newer_than, do_compress, true, 1626 - &target_list); 1422 + &target_list, last_scanned_ret); 1627 1423 if (ret < 0) 1628 1424 goto unlock_extent; 1629 1425 ··· 1658 1454 u64 start, u32 len, u32 extent_thresh, 1659 1455 u64 newer_than, bool do_compress, 1660 1456 unsigned long *sectors_defragged, 1661 - unsigned long max_sectors) 1457 + unsigned long max_sectors, 1458 + u64 *last_scanned_ret) 1662 1459 { 1663 1460 const u32 sectorsize = inode->root->fs_info->sectorsize; 1664 1461 struct defrag_target_range *entry; ··· 1670 1465 BUILD_BUG_ON(!IS_ALIGNED(CLUSTER_SIZE, PAGE_SIZE)); 1671 1466 ret = defrag_collect_targets(inode, start, len, extent_thresh, 1672 1467 newer_than, do_compress, false, 1673 - &target_list); 1468 + &target_list, NULL); 1674 1469 if (ret < 0) 1675 1470 goto out; 1676 1471 ··· 1687 1482 range_len = min_t(u32, range_len, 1688 1483 (max_sectors - *sectors_defragged) * sectorsize); 1689 1484 1485 + /* 1486 + * If defrag_one_range() has updated last_scanned_ret, 1487 + * our range may already be invalid (e.g. hole punched). 1488 + * Skip if our range is before last_scanned_ret, as there is 1489 + * no need to defrag the range anymore. 1490 + */ 1491 + if (entry->start + range_len <= *last_scanned_ret) 1492 + continue; 1493 + 1690 1494 if (ra) 1691 1495 page_cache_sync_readahead(inode->vfs_inode.i_mapping, 1692 1496 ra, NULL, entry->start >> PAGE_SHIFT, ··· 1708 1494 * accounting. 1709 1495 */ 1710 1496 ret = defrag_one_range(inode, entry->start, range_len, 1711 - extent_thresh, newer_than, do_compress); 1497 + extent_thresh, newer_than, do_compress, 1498 + last_scanned_ret); 1712 1499 if (ret < 0) 1713 1500 break; 1714 1501 *sectors_defragged += range_len >> ··· 1720 1505 list_del_init(&entry->list); 1721 1506 kfree(entry); 1722 1507 } 1508 + if (ret >= 0) 1509 + *last_scanned_ret = max(*last_scanned_ret, start + len); 1723 1510 return ret; 1724 1511 } 1725 1512 ··· 1807 1590 1808 1591 while (cur < last_byte) { 1809 1592 const unsigned long prev_sectors_defragged = sectors_defragged; 1593 + u64 last_scanned = cur; 1810 1594 u64 cluster_end; 1811 1595 1812 1596 /* The cluster size 256K should always be page aligned */ ··· 1837 1619 BTRFS_I(inode)->defrag_compress = compress_type; 1838 1620 ret = defrag_one_cluster(BTRFS_I(inode), ra, cur, 1839 1621 cluster_end + 1 - cur, extent_thresh, 1840 - newer_than, do_compress, 1841 - &sectors_defragged, max_to_defrag); 1622 + newer_than, do_compress, &sectors_defragged, 1623 + max_to_defrag, &last_scanned); 1842 1624 1843 1625 if (sectors_defragged > prev_sectors_defragged) 1844 1626 balance_dirty_pages_ratelimited(inode->i_mapping); ··· 1846 1628 btrfs_inode_unlock(inode, 0); 1847 1629 if (ret < 0) 1848 1630 break; 1849 - cur = cluster_end + 1; 1631 + cur = max(cluster_end + 1, last_scanned); 1850 1632 if (ret > 0) { 1851 1633 ret = 0; 1852 1634 break;

+11

fs/btrfs/lzo.c

··· 380 380 kunmap(cur_page); 381 381 cur_in += LZO_LEN; 382 382 383 + if (seg_len > lzo1x_worst_compress(PAGE_SIZE)) { 384 + /* 385 + * seg_len shouldn't be larger than we have allocated 386 + * for workspace->cbuf 387 + */ 388 + btrfs_err(fs_info, "unexpectedly large lzo segment len %u", 389 + seg_len); 390 + ret = -EIO; 391 + goto out; 392 + } 393 + 383 394 /* Copy the compressed segment payload into workspace */ 384 395 copy_compressed_segment(cb, workspace->cbuf, seg_len, &cur_in); 385 396

Configure Feed

Configure Feed