1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2017 Oracle. All Rights Reserved. 4 * 5 * Author: Darrick J. Wong <darrick.wong@oracle.com> 6 */ 7 #include "ext4.h" 8 #include <linux/fsmap.h> 9 #include "fsmap.h" 10 #include "mballoc.h" 11 #include <linux/sort.h> 12 #include <linux/list_sort.h> 13 #include <trace/events/ext4.h> 14 15 /* Convert an ext4_fsmap to an fsmap. */ 16 void ext4_fsmap_from_internal(struct super_block *sb, struct fsmap *dest, 17 struct ext4_fsmap *src) 18 { 19 dest->fmr_device = src->fmr_device; 20 dest->fmr_flags = src->fmr_flags; 21 dest->fmr_physical = src->fmr_physical << sb->s_blocksize_bits; 22 dest->fmr_owner = src->fmr_owner; 23 dest->fmr_offset = 0; 24 dest->fmr_length = src->fmr_length << sb->s_blocksize_bits; 25 dest->fmr_reserved[0] = 0; 26 dest->fmr_reserved[1] = 0; 27 dest->fmr_reserved[2] = 0; 28 } 29 30 /* Convert an fsmap to an ext4_fsmap. */ 31 void ext4_fsmap_to_internal(struct super_block *sb, struct ext4_fsmap *dest, 32 struct fsmap *src) 33 { 34 dest->fmr_device = src->fmr_device; 35 dest->fmr_flags = src->fmr_flags; 36 dest->fmr_physical = src->fmr_physical >> sb->s_blocksize_bits; 37 dest->fmr_owner = src->fmr_owner; 38 dest->fmr_length = src->fmr_length >> sb->s_blocksize_bits; 39 } 40 41 /* getfsmap query state */ 42 struct ext4_getfsmap_info { 43 struct ext4_fsmap_head *gfi_head; 44 ext4_fsmap_format_t gfi_formatter; /* formatting fn */ 45 void *gfi_format_arg;/* format buffer */ 46 ext4_fsblk_t gfi_next_fsblk; /* next fsblock we expect */ 47 u32 gfi_dev; /* device id */ 48 ext4_group_t gfi_agno; /* bg number, if applicable */ 49 struct ext4_fsmap gfi_low; /* low rmap key */ 50 struct ext4_fsmap gfi_high; /* high rmap key */ 51 struct ext4_fsmap gfi_lastfree; /* free ext at end of last bg */ 52 struct list_head gfi_meta_list; /* fixed metadata list */ 53 bool gfi_last; /* last extent? */ 54 }; 55 56 /* Associate a device with a getfsmap handler. */ 57 struct ext4_getfsmap_dev { 58 int (*gfd_fn)(struct super_block *sb, 59 struct ext4_fsmap *keys, 60 struct ext4_getfsmap_info *info); 61 u32 gfd_dev; 62 }; 63 64 /* Compare two getfsmap device handlers. */ 65 static int ext4_getfsmap_dev_compare(const void *p1, const void *p2) 66 { 67 const struct ext4_getfsmap_dev *d1 = p1; 68 const struct ext4_getfsmap_dev *d2 = p2; 69 70 return d1->gfd_dev - d2->gfd_dev; 71 } 72 73 /* Compare a record against our starting point */ 74 static bool ext4_getfsmap_rec_before_low_key(struct ext4_getfsmap_info *info, 75 struct ext4_fsmap *rec) 76 { 77 return rec->fmr_physical < info->gfi_low.fmr_physical; 78 } 79 80 /* 81 * Format a reverse mapping for getfsmap, having translated rm_startblock 82 * into the appropriate daddr units. 83 */ 84 static int ext4_getfsmap_helper(struct super_block *sb, 85 struct ext4_getfsmap_info *info, 86 struct ext4_fsmap *rec) 87 { 88 struct ext4_fsmap fmr; 89 struct ext4_sb_info *sbi = EXT4_SB(sb); 90 ext4_fsblk_t rec_fsblk = rec->fmr_physical; 91 ext4_group_t agno; 92 ext4_grpblk_t cno; 93 int error; 94 95 if (fatal_signal_pending(current)) 96 return -EINTR; 97 98 /* 99 * Filter out records that start before our startpoint, if the 100 * caller requested that. 101 */ 102 if (ext4_getfsmap_rec_before_low_key(info, rec)) { 103 rec_fsblk += rec->fmr_length; 104 if (info->gfi_next_fsblk < rec_fsblk) 105 info->gfi_next_fsblk = rec_fsblk; 106 return EXT4_QUERY_RANGE_CONTINUE; 107 } 108 109 /* Are we just counting mappings? */ 110 if (info->gfi_head->fmh_count == 0) { 111 if (info->gfi_head->fmh_entries == UINT_MAX) 112 return EXT4_QUERY_RANGE_ABORT; 113 114 if (rec_fsblk > info->gfi_next_fsblk) 115 info->gfi_head->fmh_entries++; 116 117 if (info->gfi_last) 118 return EXT4_QUERY_RANGE_CONTINUE; 119 120 info->gfi_head->fmh_entries++; 121 122 rec_fsblk += rec->fmr_length; 123 if (info->gfi_next_fsblk < rec_fsblk) 124 info->gfi_next_fsblk = rec_fsblk; 125 return EXT4_QUERY_RANGE_CONTINUE; 126 } 127 128 /* 129 * If the record starts past the last physical block we saw, 130 * then we've found a gap. Report the gap as being owned by 131 * whatever the caller specified is the missing owner. 132 */ 133 if (rec_fsblk > info->gfi_next_fsblk) { 134 if (info->gfi_head->fmh_entries >= info->gfi_head->fmh_count) 135 return EXT4_QUERY_RANGE_ABORT; 136 137 ext4_get_group_no_and_offset(sb, info->gfi_next_fsblk, 138 &agno, &cno); 139 trace_ext4_fsmap_mapping(sb, info->gfi_dev, agno, 140 EXT4_C2B(sbi, cno), 141 rec_fsblk - info->gfi_next_fsblk, 142 EXT4_FMR_OWN_UNKNOWN); 143 144 fmr.fmr_device = info->gfi_dev; 145 fmr.fmr_physical = info->gfi_next_fsblk; 146 fmr.fmr_owner = EXT4_FMR_OWN_UNKNOWN; 147 fmr.fmr_length = rec_fsblk - info->gfi_next_fsblk; 148 fmr.fmr_flags = FMR_OF_SPECIAL_OWNER; 149 error = info->gfi_formatter(&fmr, info->gfi_format_arg); 150 if (error) 151 return error; 152 info->gfi_head->fmh_entries++; 153 } 154 155 if (info->gfi_last) 156 goto out; 157 158 /* Fill out the extent we found */ 159 if (info->gfi_head->fmh_entries >= info->gfi_head->fmh_count) 160 return EXT4_QUERY_RANGE_ABORT; 161 162 ext4_get_group_no_and_offset(sb, rec_fsblk, &agno, &cno); 163 trace_ext4_fsmap_mapping(sb, info->gfi_dev, agno, EXT4_C2B(sbi, cno), 164 rec->fmr_length, rec->fmr_owner); 165 166 fmr.fmr_device = info->gfi_dev; 167 fmr.fmr_physical = rec_fsblk; 168 fmr.fmr_owner = rec->fmr_owner; 169 fmr.fmr_flags = FMR_OF_SPECIAL_OWNER; 170 fmr.fmr_length = rec->fmr_length; 171 error = info->gfi_formatter(&fmr, info->gfi_format_arg); 172 if (error) 173 return error; 174 info->gfi_head->fmh_entries++; 175 176 out: 177 rec_fsblk += rec->fmr_length; 178 if (info->gfi_next_fsblk < rec_fsblk) 179 info->gfi_next_fsblk = rec_fsblk; 180 return EXT4_QUERY_RANGE_CONTINUE; 181 } 182 183 static inline ext4_fsblk_t ext4_fsmap_next_pblk(struct ext4_fsmap *fmr) 184 { 185 return fmr->fmr_physical + fmr->fmr_length; 186 } 187 188 static int ext4_getfsmap_meta_helper(struct super_block *sb, 189 ext4_group_t agno, ext4_grpblk_t start, 190 ext4_grpblk_t len, void *priv) 191 { 192 struct ext4_getfsmap_info *info = priv; 193 struct ext4_fsmap *p; 194 struct ext4_fsmap *tmp; 195 struct ext4_sb_info *sbi = EXT4_SB(sb); 196 ext4_fsblk_t fsb, fs_start, fs_end; 197 int error; 198 199 fs_start = fsb = (EXT4_C2B(sbi, start) + 200 ext4_group_first_block_no(sb, agno)); 201 fs_end = fs_start + EXT4_C2B(sbi, len); 202 203 /* Return relevant extents from the meta_list */ 204 list_for_each_entry_safe(p, tmp, &info->gfi_meta_list, fmr_list) { 205 if (p->fmr_physical < info->gfi_next_fsblk) { 206 list_del(&p->fmr_list); 207 kfree(p); 208 continue; 209 } 210 if (p->fmr_physical <= fs_start || 211 p->fmr_physical + p->fmr_length <= fs_end) { 212 /* Emit the retained free extent record if present */ 213 if (info->gfi_lastfree.fmr_owner) { 214 error = ext4_getfsmap_helper(sb, info, 215 &info->gfi_lastfree); 216 if (error) 217 return error; 218 info->gfi_lastfree.fmr_owner = 0; 219 } 220 error = ext4_getfsmap_helper(sb, info, p); 221 if (error) 222 return error; 223 fsb = p->fmr_physical + p->fmr_length; 224 if (info->gfi_next_fsblk < fsb) 225 info->gfi_next_fsblk = fsb; 226 list_del(&p->fmr_list); 227 kfree(p); 228 continue; 229 } 230 } 231 if (info->gfi_next_fsblk < fsb) 232 info->gfi_next_fsblk = fsb; 233 234 return 0; 235 } 236 237 238 /* Transform a blockgroup's free record into a fsmap */ 239 static int ext4_getfsmap_datadev_helper(struct super_block *sb, 240 ext4_group_t agno, ext4_grpblk_t start, 241 ext4_grpblk_t len, void *priv) 242 { 243 struct ext4_fsmap irec; 244 struct ext4_getfsmap_info *info = priv; 245 struct ext4_fsmap *p; 246 struct ext4_fsmap *tmp; 247 struct ext4_sb_info *sbi = EXT4_SB(sb); 248 ext4_fsblk_t fsb; 249 ext4_fsblk_t fslen; 250 int error; 251 252 fsb = (EXT4_C2B(sbi, start) + ext4_group_first_block_no(sb, agno)); 253 fslen = EXT4_C2B(sbi, len); 254 255 /* If the retained free extent record is set... */ 256 if (info->gfi_lastfree.fmr_owner) { 257 /* ...and abuts this one, lengthen it and return. */ 258 if (ext4_fsmap_next_pblk(&info->gfi_lastfree) == fsb) { 259 info->gfi_lastfree.fmr_length += fslen; 260 return 0; 261 } 262 263 /* 264 * There's a gap between the two free extents; emit the 265 * retained extent prior to merging the meta_list. 266 */ 267 error = ext4_getfsmap_helper(sb, info, &info->gfi_lastfree); 268 if (error) 269 return error; 270 info->gfi_lastfree.fmr_owner = 0; 271 } 272 273 /* Merge in any relevant extents from the meta_list */ 274 list_for_each_entry_safe(p, tmp, &info->gfi_meta_list, fmr_list) { 275 if (p->fmr_physical + p->fmr_length <= info->gfi_next_fsblk) { 276 list_del(&p->fmr_list); 277 kfree(p); 278 } else if (p->fmr_physical < fsb) { 279 error = ext4_getfsmap_helper(sb, info, p); 280 if (error) 281 return error; 282 283 list_del(&p->fmr_list); 284 kfree(p); 285 } 286 } 287 288 irec.fmr_device = 0; 289 irec.fmr_physical = fsb; 290 irec.fmr_length = fslen; 291 irec.fmr_owner = EXT4_FMR_OWN_FREE; 292 irec.fmr_flags = 0; 293 294 /* If this is a free extent at the end of a bg, buffer it. */ 295 if (ext4_fsmap_next_pblk(&irec) == 296 ext4_group_first_block_no(sb, agno + 1)) { 297 info->gfi_lastfree = irec; 298 return 0; 299 } 300 301 /* Otherwise, emit it */ 302 return ext4_getfsmap_helper(sb, info, &irec); 303 } 304 305 /* Execute a getfsmap query against the log device. */ 306 static int ext4_getfsmap_logdev(struct super_block *sb, struct ext4_fsmap *keys, 307 struct ext4_getfsmap_info *info) 308 { 309 journal_t *journal = EXT4_SB(sb)->s_journal; 310 struct ext4_fsmap irec; 311 312 /* Set up search keys */ 313 info->gfi_low = keys[0]; 314 info->gfi_low.fmr_length = 0; 315 316 memset(&info->gfi_high, 0xFF, sizeof(info->gfi_high)); 317 318 trace_ext4_fsmap_low_key(sb, info->gfi_dev, 0, 319 info->gfi_low.fmr_physical, 320 info->gfi_low.fmr_length, 321 info->gfi_low.fmr_owner); 322 323 trace_ext4_fsmap_high_key(sb, info->gfi_dev, 0, 324 info->gfi_high.fmr_physical, 325 info->gfi_high.fmr_length, 326 info->gfi_high.fmr_owner); 327 328 if (keys[0].fmr_physical > 0) 329 return 0; 330 331 /* Fabricate an rmap entry for the external log device. */ 332 irec.fmr_physical = journal->j_blk_offset; 333 irec.fmr_length = journal->j_total_len; 334 irec.fmr_owner = EXT4_FMR_OWN_LOG; 335 irec.fmr_flags = 0; 336 337 return ext4_getfsmap_helper(sb, info, &irec); 338 } 339 340 /* Helper to fill out an ext4_fsmap. */ 341 static inline int ext4_getfsmap_fill(struct list_head *meta_list, 342 ext4_fsblk_t fsb, ext4_fsblk_t len, 343 uint64_t owner) 344 { 345 struct ext4_fsmap *fsm; 346 347 fsm = kmalloc(sizeof(*fsm), GFP_NOFS); 348 if (!fsm) 349 return -ENOMEM; 350 fsm->fmr_device = 0; 351 fsm->fmr_flags = 0; 352 fsm->fmr_physical = fsb; 353 fsm->fmr_owner = owner; 354 fsm->fmr_length = len; 355 list_add_tail(&fsm->fmr_list, meta_list); 356 357 return 0; 358 } 359 360 /* 361 * This function returns the number of file system metadata blocks at 362 * the beginning of a block group, including the reserved gdt blocks. 363 */ 364 static unsigned int ext4_getfsmap_find_sb(struct super_block *sb, 365 ext4_group_t agno, 366 struct list_head *meta_list) 367 { 368 struct ext4_sb_info *sbi = EXT4_SB(sb); 369 ext4_fsblk_t fsb = ext4_group_first_block_no(sb, agno); 370 ext4_fsblk_t len; 371 unsigned long first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg); 372 unsigned long metagroup = agno / EXT4_DESC_PER_BLOCK(sb); 373 int error; 374 375 /* Record the superblock. */ 376 if (ext4_bg_has_super(sb, agno)) { 377 error = ext4_getfsmap_fill(meta_list, fsb, 1, EXT4_FMR_OWN_FS); 378 if (error) 379 return error; 380 fsb++; 381 } 382 383 /* Record the group descriptors. */ 384 len = ext4_bg_num_gdb(sb, agno); 385 if (!len) 386 return 0; 387 error = ext4_getfsmap_fill(meta_list, fsb, len, 388 EXT4_FMR_OWN_GDT); 389 if (error) 390 return error; 391 fsb += len; 392 393 /* Reserved GDT blocks */ 394 if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg) { 395 len = le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks); 396 397 /* 398 * mkfs.ext4 can set s_reserved_gdt_blocks as 0 in some cases, 399 * check for that. 400 */ 401 if (!len) 402 return 0; 403 404 error = ext4_getfsmap_fill(meta_list, fsb, len, 405 EXT4_FMR_OWN_RESV_GDT); 406 if (error) 407 return error; 408 } 409 410 return 0; 411 } 412 413 /* Compare two fsmap items. */ 414 static int ext4_getfsmap_compare(void *priv, 415 const struct list_head *a, 416 const struct list_head *b) 417 { 418 struct ext4_fsmap *fa; 419 struct ext4_fsmap *fb; 420 421 fa = container_of(a, struct ext4_fsmap, fmr_list); 422 fb = container_of(b, struct ext4_fsmap, fmr_list); 423 if (fa->fmr_physical < fb->fmr_physical) 424 return -1; 425 else if (fa->fmr_physical > fb->fmr_physical) 426 return 1; 427 return 0; 428 } 429 430 /* Merge adjacent extents of fixed metadata. */ 431 static void ext4_getfsmap_merge_fixed_metadata(struct list_head *meta_list) 432 { 433 struct ext4_fsmap *p; 434 struct ext4_fsmap *prev = NULL; 435 struct ext4_fsmap *tmp; 436 437 list_for_each_entry_safe(p, tmp, meta_list, fmr_list) { 438 if (!prev) { 439 prev = p; 440 continue; 441 } 442 443 if (prev->fmr_owner == p->fmr_owner && 444 prev->fmr_physical + prev->fmr_length == p->fmr_physical) { 445 prev->fmr_length += p->fmr_length; 446 list_del(&p->fmr_list); 447 kfree(p); 448 } else 449 prev = p; 450 } 451 } 452 453 /* Free a list of fixed metadata. */ 454 static void ext4_getfsmap_free_fixed_metadata(struct list_head *meta_list) 455 { 456 struct ext4_fsmap *p; 457 struct ext4_fsmap *tmp; 458 459 list_for_each_entry_safe(p, tmp, meta_list, fmr_list) { 460 list_del(&p->fmr_list); 461 kfree(p); 462 } 463 } 464 465 /* Find all the fixed metadata in the filesystem. */ 466 static int ext4_getfsmap_find_fixed_metadata(struct super_block *sb, 467 struct list_head *meta_list) 468 { 469 struct ext4_group_desc *gdp; 470 ext4_group_t agno; 471 int error; 472 473 INIT_LIST_HEAD(meta_list); 474 475 /* Collect everything. */ 476 for (agno = 0; agno < EXT4_SB(sb)->s_groups_count; agno++) { 477 gdp = ext4_get_group_desc(sb, agno, NULL); 478 if (!gdp) { 479 error = -EFSCORRUPTED; 480 goto err; 481 } 482 483 /* Superblock & GDT */ 484 error = ext4_getfsmap_find_sb(sb, agno, meta_list); 485 if (error) 486 goto err; 487 488 /* Block bitmap */ 489 error = ext4_getfsmap_fill(meta_list, 490 ext4_block_bitmap(sb, gdp), 1, 491 EXT4_FMR_OWN_BLKBM); 492 if (error) 493 goto err; 494 495 /* Inode bitmap */ 496 error = ext4_getfsmap_fill(meta_list, 497 ext4_inode_bitmap(sb, gdp), 1, 498 EXT4_FMR_OWN_INOBM); 499 if (error) 500 goto err; 501 502 /* Inodes */ 503 error = ext4_getfsmap_fill(meta_list, 504 ext4_inode_table(sb, gdp), 505 EXT4_SB(sb)->s_itb_per_group, 506 EXT4_FMR_OWN_INODES); 507 if (error) 508 goto err; 509 } 510 511 /* Sort the list */ 512 list_sort(NULL, meta_list, ext4_getfsmap_compare); 513 514 /* Merge adjacent extents */ 515 ext4_getfsmap_merge_fixed_metadata(meta_list); 516 517 return 0; 518 err: 519 ext4_getfsmap_free_fixed_metadata(meta_list); 520 return error; 521 } 522 523 /* Execute a getfsmap query against the buddy bitmaps */ 524 static int ext4_getfsmap_datadev(struct super_block *sb, 525 struct ext4_fsmap *keys, 526 struct ext4_getfsmap_info *info) 527 { 528 struct ext4_sb_info *sbi = EXT4_SB(sb); 529 ext4_fsblk_t start_fsb; 530 ext4_fsblk_t end_fsb; 531 ext4_fsblk_t bofs; 532 ext4_fsblk_t eofs; 533 ext4_group_t start_ag; 534 ext4_group_t end_ag; 535 ext4_grpblk_t first_cluster; 536 ext4_grpblk_t last_cluster; 537 struct ext4_fsmap irec; 538 int error = 0; 539 540 bofs = le32_to_cpu(sbi->s_es->s_first_data_block); 541 eofs = ext4_blocks_count(sbi->s_es); 542 if (keys[0].fmr_physical >= eofs) 543 return 0; 544 else if (keys[0].fmr_physical < bofs) 545 keys[0].fmr_physical = bofs; 546 if (keys[1].fmr_physical >= eofs) 547 keys[1].fmr_physical = eofs - 1; 548 if (keys[1].fmr_physical < keys[0].fmr_physical) 549 return 0; 550 start_fsb = keys[0].fmr_physical; 551 end_fsb = keys[1].fmr_physical; 552 553 /* Determine first and last group to examine based on start and end */ 554 ext4_get_group_no_and_offset(sb, start_fsb, &start_ag, &first_cluster); 555 ext4_get_group_no_and_offset(sb, end_fsb, &end_ag, &last_cluster); 556 557 /* 558 * Convert the fsmap low/high keys to bg based keys. Initialize 559 * low to the fsmap low key and max out the high key to the end 560 * of the bg. 561 */ 562 info->gfi_low = keys[0]; 563 info->gfi_low.fmr_physical = EXT4_C2B(sbi, first_cluster); 564 info->gfi_low.fmr_length = 0; 565 566 memset(&info->gfi_high, 0xFF, sizeof(info->gfi_high)); 567 568 /* Assemble a list of all the fixed-location metadata. */ 569 error = ext4_getfsmap_find_fixed_metadata(sb, &info->gfi_meta_list); 570 if (error) 571 goto err; 572 573 /* Query each bg */ 574 for (info->gfi_agno = start_ag; 575 info->gfi_agno <= end_ag; 576 info->gfi_agno++) { 577 /* 578 * Set the bg high key from the fsmap high key if this 579 * is the last bg that we're querying. 580 */ 581 if (info->gfi_agno == end_ag) { 582 info->gfi_high = keys[1]; 583 info->gfi_high.fmr_physical = EXT4_C2B(sbi, 584 last_cluster); 585 info->gfi_high.fmr_length = 0; 586 } 587 588 trace_ext4_fsmap_low_key(sb, info->gfi_dev, info->gfi_agno, 589 info->gfi_low.fmr_physical, 590 info->gfi_low.fmr_length, 591 info->gfi_low.fmr_owner); 592 593 trace_ext4_fsmap_high_key(sb, info->gfi_dev, info->gfi_agno, 594 info->gfi_high.fmr_physical, 595 info->gfi_high.fmr_length, 596 info->gfi_high.fmr_owner); 597 598 error = ext4_mballoc_query_range(sb, info->gfi_agno, 599 EXT4_B2C(sbi, info->gfi_low.fmr_physical), 600 EXT4_B2C(sbi, info->gfi_high.fmr_physical), 601 ext4_getfsmap_meta_helper, 602 ext4_getfsmap_datadev_helper, info); 603 if (error) 604 goto err; 605 606 /* 607 * Set the bg low key to the start of the bg prior to 608 * moving on to the next bg. 609 */ 610 if (info->gfi_agno == start_ag) 611 memset(&info->gfi_low, 0, sizeof(info->gfi_low)); 612 } 613 614 /* Do we have a retained free extent? */ 615 if (info->gfi_lastfree.fmr_owner) { 616 error = ext4_getfsmap_helper(sb, info, &info->gfi_lastfree); 617 if (error) 618 goto err; 619 } 620 621 /* 622 * The dummy record below will cause ext4_getfsmap_helper() to report 623 * any allocated blocks at the end of the range. 624 */ 625 irec.fmr_device = 0; 626 irec.fmr_physical = end_fsb + 1; 627 irec.fmr_length = 0; 628 irec.fmr_owner = EXT4_FMR_OWN_FREE; 629 irec.fmr_flags = 0; 630 631 info->gfi_last = true; 632 error = ext4_getfsmap_helper(sb, info, &irec); 633 if (error) 634 goto err; 635 636 err: 637 ext4_getfsmap_free_fixed_metadata(&info->gfi_meta_list); 638 return error; 639 } 640 641 /* Do we recognize the device? */ 642 static bool ext4_getfsmap_is_valid_device(struct super_block *sb, 643 struct ext4_fsmap *fm) 644 { 645 if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX || 646 fm->fmr_device == new_encode_dev(sb->s_bdev->bd_dev)) 647 return true; 648 if (EXT4_SB(sb)->s_journal_bdev_file && 649 fm->fmr_device == 650 new_encode_dev(file_bdev(EXT4_SB(sb)->s_journal_bdev_file)->bd_dev)) 651 return true; 652 return false; 653 } 654 655 /* Ensure that the low key is less than the high key. */ 656 static bool ext4_getfsmap_check_keys(struct ext4_fsmap *low_key, 657 struct ext4_fsmap *high_key) 658 { 659 if (low_key->fmr_device > high_key->fmr_device) 660 return false; 661 if (low_key->fmr_device < high_key->fmr_device) 662 return true; 663 664 if (low_key->fmr_physical > high_key->fmr_physical) 665 return false; 666 if (low_key->fmr_physical < high_key->fmr_physical) 667 return true; 668 669 if (low_key->fmr_owner > high_key->fmr_owner) 670 return false; 671 if (low_key->fmr_owner < high_key->fmr_owner) 672 return true; 673 674 return false; 675 } 676 677 #define EXT4_GETFSMAP_DEVS 2 678 /* 679 * Get filesystem's extents as described in head, and format for 680 * output. Calls formatter to fill the user's buffer until all 681 * extents are mapped, until the passed-in head->fmh_count slots have 682 * been filled, or until the formatter short-circuits the loop, if it 683 * is tracking filled-in extents on its own. 684 * 685 * Key to Confusion 686 * ---------------- 687 * There are multiple levels of keys and counters at work here: 688 * _fsmap_head.fmh_keys -- low and high fsmap keys passed in; 689 * these reflect fs-wide block addrs. 690 * dkeys -- fmh_keys used to query each device; 691 * these are fmh_keys but w/ the low key 692 * bumped up by fmr_length. 693 * _getfsmap_info.gfi_next_fsblk-- next fs block we expect to see; this 694 * is how we detect gaps in the fsmap 695 * records and report them. 696 * _getfsmap_info.gfi_low/high -- per-bg low/high keys computed from 697 * dkeys; used to query the free space. 698 */ 699 int ext4_getfsmap(struct super_block *sb, struct ext4_fsmap_head *head, 700 ext4_fsmap_format_t formatter, void *arg) 701 { 702 struct ext4_fsmap dkeys[2]; /* per-dev keys */ 703 struct ext4_getfsmap_dev handlers[EXT4_GETFSMAP_DEVS]; 704 struct ext4_getfsmap_info info = { NULL }; 705 int i; 706 int error = 0; 707 708 if (head->fmh_iflags & ~FMH_IF_VALID) 709 return -EINVAL; 710 if (!ext4_getfsmap_is_valid_device(sb, &head->fmh_keys[0]) || 711 !ext4_getfsmap_is_valid_device(sb, &head->fmh_keys[1])) 712 return -EINVAL; 713 714 head->fmh_entries = 0; 715 716 /* Set up our device handlers. */ 717 memset(handlers, 0, sizeof(handlers)); 718 handlers[0].gfd_dev = new_encode_dev(sb->s_bdev->bd_dev); 719 handlers[0].gfd_fn = ext4_getfsmap_datadev; 720 if (EXT4_SB(sb)->s_journal_bdev_file) { 721 handlers[1].gfd_dev = new_encode_dev( 722 file_bdev(EXT4_SB(sb)->s_journal_bdev_file)->bd_dev); 723 handlers[1].gfd_fn = ext4_getfsmap_logdev; 724 } 725 726 sort(handlers, EXT4_GETFSMAP_DEVS, sizeof(struct ext4_getfsmap_dev), 727 ext4_getfsmap_dev_compare, NULL); 728 729 /* 730 * To continue where we left off, we allow userspace to use the 731 * last mapping from a previous call as the low key of the next. 732 * This is identified by a non-zero length in the low key. We 733 * have to increment the low key in this scenario to ensure we 734 * don't return the same mapping again, and instead return the 735 * very next mapping. 736 * 737 * Bump the physical offset as there can be no other mapping for 738 * the same physical block range. 739 */ 740 dkeys[0] = head->fmh_keys[0]; 741 dkeys[0].fmr_physical += dkeys[0].fmr_length; 742 dkeys[0].fmr_owner = 0; 743 dkeys[0].fmr_length = 0; 744 memset(&dkeys[1], 0xFF, sizeof(struct ext4_fsmap)); 745 746 if (!ext4_getfsmap_check_keys(dkeys, &head->fmh_keys[1])) 747 return -EINVAL; 748 749 info.gfi_next_fsblk = head->fmh_keys[0].fmr_physical + 750 head->fmh_keys[0].fmr_length; 751 info.gfi_formatter = formatter; 752 info.gfi_format_arg = arg; 753 info.gfi_head = head; 754 755 /* For each device we support... */ 756 for (i = 0; i < EXT4_GETFSMAP_DEVS; i++) { 757 /* Is this device within the range the user asked for? */ 758 if (!handlers[i].gfd_fn) 759 continue; 760 if (head->fmh_keys[0].fmr_device > handlers[i].gfd_dev) 761 continue; 762 if (head->fmh_keys[1].fmr_device < handlers[i].gfd_dev) 763 break; 764 765 /* 766 * If this device number matches the high key, we have 767 * to pass the high key to the handler to limit the 768 * query results. If the device number exceeds the 769 * low key, zero out the low key so that we get 770 * everything from the beginning. 771 */ 772 if (handlers[i].gfd_dev == head->fmh_keys[1].fmr_device) 773 dkeys[1] = head->fmh_keys[1]; 774 if (handlers[i].gfd_dev > head->fmh_keys[0].fmr_device) 775 memset(&dkeys[0], 0, sizeof(struct ext4_fsmap)); 776 777 info.gfi_dev = handlers[i].gfd_dev; 778 info.gfi_last = false; 779 info.gfi_agno = -1; 780 error = handlers[i].gfd_fn(sb, dkeys, &info); 781 if (error) 782 break; 783 info.gfi_next_fsblk = 0; 784 } 785 786 head->fmh_oflags = FMH_OF_DEV_T; 787 return error; 788 } 789