dm vdo: remove internal ticket references

+4 -4

drivers/md/dm-vdo/block-map.c

··· 542 542 543 543 /* 544 544 * Increment the busy count once for each pending completion so that this page does not 545 - * stop being busy until all completions have been processed (VDO-83). 545 + * stop being busy until all completions have been processed. 546 546 */ 547 547 info->busy += num_pages; 548 548 ··· 1097 1097 struct vdo_page_cache *cache = ((struct page_info *) flush_completion->parent)->cache; 1098 1098 1099 1099 /* 1100 - * We need to cache these two values on the stack since in the error case below, it is 1101 - * possible for the last page info to cause the page cache to get freed. Hence once we 1102 - * launch the last page, it may be unsafe to dereference the cache [VDO-4724]. 1100 + * We need to cache these two values on the stack since it is possible for the last 1101 + * page info to cause the page cache to get freed. Hence once we launch the last page, 1102 + * it may be unsafe to dereference the cache. 1103 1103 */ 1104 1104 bool has_unflushed_pages = (cache->pages_to_flush > 0); 1105 1105 page_count_t pages_in_flush = cache->pages_in_flush;

+5 -4

drivers/md/dm-vdo/data-vio.c

··· 453 453 454 454 /* 455 455 * If the new request is a pure read request (not read-modify-write) and the lock_holder is 456 - * writing and has received an allocation (VDO-2683), service the read request immediately 457 - * by copying data from the lock_holder to avoid having to flush the write out of the 458 - * packer just to prevent the read from waiting indefinitely. If the lock_holder does not 459 - * yet have an allocation, prevent it from blocking in the packer and wait on it. 456 + * writing and has received an allocation, service the read request immediately by copying 457 + * data from the lock_holder to avoid having to flush the write out of the packer just to 458 + * prevent the read from waiting indefinitely. If the lock_holder does not yet have an 459 + * allocation, prevent it from blocking in the packer and wait on it. This is necessary in 460 + * order to prevent returning data that may not have actually been written. 460 461 */ 461 462 if (!data_vio->write && READ_ONCE(lock_holder->allocation_succeeded)) { 462 463 copy_to_bio(data_vio->user_bio, lock_holder->vio.data + data_vio->offset);

+5 -7

drivers/md/dm-vdo/dm-vdo-target.c

··· 945 945 * Sets the maximum discard size that will be passed into VDO. This value comes from a 946 946 * table line value passed in during dmsetup create. 947 947 * 948 - * The value 1024 is the largest usable value on HD systems. A 2048 sector discard on a 949 - * busy HD system takes 31 seconds. We should use a value no higher than 1024, which takes 950 - * 15 to 16 seconds on a busy HD system. 951 - * 952 - * But using large values results in 120 second blocked task warnings in /var/log/kern.log. 953 - * In order to avoid these warnings, we choose to use the smallest reasonable value. See 954 - * VDO-3062 and VDO-3087. 948 + * The value 1024 is the largest usable value on HD systems. A 2048 sector discard on a 949 + * busy HD system takes 31 seconds. We should use a value no higher than 1024, which takes 950 + * 15 to 16 seconds on a busy HD system. However, using large values results in 120 second 951 + * blocked task warnings in kernel logs. In order to avoid these warnings, we choose to 952 + * use the smallest reasonable value. 955 953 * 956 954 * The value is displayed in sysfs, and also used by dm-thin to determine whether to pass 957 955 * down discards. The block layer splits large discards on this boundary when this is set.

+4 -4

drivers/md/dm-vdo/memory-alloc.c

··· 235 235 if (p == NULL) { 236 236 /* 237 237 * It is possible for kmalloc to fail to allocate memory because there is 238 - * no page available (see VDO-3688). A short sleep may allow the page 239 - * reclaimer to free a page. 238 + * no page available. A short sleep may allow the page reclaimer to 239 + * free a page. 240 240 */ 241 241 fsleep(1000); 242 242 p = kmalloc(size, gfp_flags); ··· 251 251 UDS_SUCCESS) { 252 252 /* 253 253 * It is possible for __vmalloc to fail to allocate memory because there 254 - * are no pages available (see VDO-3661). A short sleep may allow the page 255 - * reclaimer to free enough pages for a small allocation. 254 + * are no pages available. A short sleep may allow the page reclaimer 255 + * to free enough pages for a small allocation. 256 256 * 257 257 * For larger allocations, the page_alloc code is racing against the page 258 258 * reclaimer. If the page reclaimer can stay ahead of page_alloc, the

+7 -9

drivers/md/dm-vdo/packer.c

··· 595 595 } 596 596 597 597 /* 598 - * The check of may_vio_block_in_packer() here will set the data_vio's compression state to 599 - * VIO_PACKING if the data_vio is allowed to be compressed (if it has already been 600 - * canceled, we'll fall out here). Once the data_vio is in the VIO_PACKING state, it must 601 - * be guaranteed to be put in a bin before any more requests can be processed by the packer 602 - * thread. Otherwise, a canceling data_vio could attempt to remove the canceled data_vio 603 - * from the packer and fail to rendezvous with it (VDO-2809). We must also make sure that 604 - * we will actually bin the data_vio and not give up on it as being larger than the space 605 - * used in the fullest bin. Hence we must call select_bin() before calling 606 - * may_vio_block_in_packer() (VDO-2826). 598 + * The advance_data_vio_compression_stage() check here verifies that the data_vio is 599 + * allowed to be compressed (if it has already been canceled, we'll fall out here). Once 600 + * the data_vio is in the DATA_VIO_PACKING state, it must be guaranteed to be put in a bin 601 + * before any more requests can be processed by the packer thread. Otherwise, a canceling 602 + * data_vio could attempt to remove the canceled data_vio from the packer and fail to 603 + * rendezvous with it. Thus, we must call select_bin() first to ensure that we will 604 + * actually add the data_vio to a bin before advancing to the DATA_VIO_PACKING stage. 607 605 */ 608 606 bin = select_bin(packer, data_vio); 609 607 if ((bin == NULL) ||

+1 -1

drivers/md/dm-vdo/packer.h

··· 58 58 * 59 59 * There is one special bin which is used to hold data_vios which have been canceled and removed 60 60 * from their bin by the packer. These data_vios need to wait for the canceller to rendezvous with 61 - * them (VDO-2809) and so they sit in this special bin. 61 + * them and so they sit in this special bin. 62 62 */ 63 63 struct packer_bin { 64 64 /* List links for packer.packer_bins */

+2 -2

drivers/md/dm-vdo/repair.c

··· 1504 1504 static noinline int compute_usages(struct repair_completion *repair) 1505 1505 { 1506 1506 /* 1507 - * VDO-5182: function is declared noinline to avoid what is likely a spurious valgrind 1508 - * error about this structure being uninitialized. 1507 + * This function is declared noinline to avoid a spurious valgrind error regarding the 1508 + * following structure being uninitialized. 1509 1509 */ 1510 1510 struct recovery_point recovery_point = { 1511 1511 .sequence_number = repair->tail,

+11 -5

drivers/md/dm-vdo/slab-depot.c

··· 334 334 335 335 /* 336 336 * Flush before writing to ensure that the slab journal tail blocks and reference updates 337 - * covered by this summary update are stable (VDO-2332). 337 + * covered by this summary update are stable. Otherwise, a subsequent recovery could 338 + * encounter a slab summary update that refers to a slab journal tail block that has not 339 + * actually been written. In such cases, the slab journal referenced will be treated as 340 + * empty, causing any data within the slab which predates the existing recovery journal 341 + * entries to be lost. 338 342 */ 339 343 pbn = (depot->summary_origin + 340 344 (VDO_SLAB_SUMMARY_BLOCKS_PER_ZONE * allocator->zone_number) + ··· 503 499 * journal block writes can be issued while previous slab summary updates have not yet been 504 500 * made. Even though those slab journal block writes will be ignored if the slab summary 505 501 * update is not persisted, they may still overwrite the to-be-reaped slab journal block 506 - * resulting in a loss of reference count updates (VDO-2912). 502 + * resulting in a loss of reference count updates. 507 503 */ 508 504 journal->flush_waiter.callback = flush_for_reaping; 509 505 acquire_vio_from_pool(journal->slab->allocator->vio_pool, ··· 774 770 775 771 /* 776 772 * This block won't be read in recovery until the slab summary is updated to refer to it. 777 - * The slab summary update does a flush which is sufficient to protect us from VDO-2331. 773 + * The slab summary update does a flush which is sufficient to protect us from corruption 774 + * due to out of order slab journal, reference block, or block map writes. 778 775 */ 779 776 vdo_submit_metadata_vio(uds_forget(vio), block_number, write_slab_journal_endio, 780 777 complete_write, REQ_OP_WRITE); ··· 1206 1201 1207 1202 /* 1208 1203 * Flush before writing to ensure that the recovery journal and slab journal entries which 1209 - * cover this reference update are stable (VDO-2331). 1204 + * cover this reference update are stable. This prevents data corruption that can be caused 1205 + * by out of order writes. 1210 1206 */ 1211 1207 WRITE_ONCE(block->slab->allocator->ref_counts_statistics.blocks_written, 1212 1208 block->slab->allocator->ref_counts_statistics.blocks_written + 1); ··· 1781 1775 (journal->slab->status == VDO_SLAB_REBUILDING)) { 1782 1776 /* 1783 1777 * Don't add entries while rebuilding or while a partial write is 1784 - * outstanding (VDO-2399). 1778 + * outstanding, as it could result in reference count corruption. 1785 1779 */ 1786 1780 break; 1787 1781 }

+1 -1

drivers/md/dm-vdo/sparse-cache.c

··· 191 191 * happens, sleep briefly to avoid keeping the CPU locked up in 192 192 * this loop. We could just call cond_resched, but then we'd 193 193 * still keep consuming CPU time slices and swamp other threads 194 - * trying to do computational work. [VDO-4980] 194 + * trying to do computational work. 195 195 */ 196 196 fsleep(1000); 197 197 }

+1 -1

drivers/md/dm-vdo/vdo.c

··· 544 544 int result; 545 545 struct vdo *vdo; 546 546 547 - /* VDO-3769 - Set a generic reason so we don't ever return garbage. */ 547 + /* Initialize with a generic failure reason to prevent returning garbage. */ 548 548 *reason = "Unspecified error"; 549 549 550 550 result = uds_allocate(1, struct vdo, __func__, &vdo);

-1

drivers/md/dm-vdo/vio.c

··· 123 123 struct vio *vio; 124 124 int result; 125 125 126 - /* If struct vio grows past 256 bytes, we'll lose benefits of VDOSTORY-176. */ 127 126 BUILD_BUG_ON(sizeof(struct vio) > 256); 128 127 129 128 /*

Configure Feed

Configure Feed