Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

dm vdo: remove remaining ring references

Lists are the new rings, so update all remaining references to rings to
talk about lists.

Signed-off-by: Sweet Tea Dorminy <sweettea-kernel@dorminy.me>
Signed-off-by: Matthew Sakai <msakai@redhat.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>

authored by

Sweet Tea Dorminy and committed by
Mikulas Patocka
ff3f7115 51ba14fb

+22 -22
+1 -1
drivers/md/dm-vdo/block-map.c
··· 451 451 * select_lru_page() - Determine which page is least recently used. 452 452 * 453 453 * Picks the least recently used from among the non-busy entries at the front of each of the lru 454 - * ring. Since whenever we mark a page busy we also put it to the end of the ring it is unlikely 454 + * list. Since whenever we mark a page busy we also put it to the end of the list it is unlikely 455 455 * that the entries at the front are busy unless the queue is very short, but not impossible. 456 456 * 457 457 * Return: A pointer to the info structure for a relevant page, or NULL if no such page can be
+10 -10
drivers/md/dm-vdo/dedupe.c
··· 226 226 * A list containing the data VIOs sharing this lock, all having the same record name and 227 227 * data block contents, linked by their hash_lock_node fields. 228 228 */ 229 - struct list_head duplicate_ring; 229 + struct list_head duplicate_vios; 230 230 231 231 /* The number of data_vios sharing this lock instance */ 232 232 data_vio_count_t reference_count; ··· 343 343 { 344 344 memset(lock, 0, sizeof(*lock)); 345 345 INIT_LIST_HEAD(&lock->pool_node); 346 - INIT_LIST_HEAD(&lock->duplicate_ring); 346 + INIT_LIST_HEAD(&lock->duplicate_vios); 347 347 vdo_waitq_init(&lock->waiters); 348 348 list_add_tail(&lock->pool_node, &zone->lock_pool); 349 349 } ··· 441 441 VDO_ASSERT_LOG_ONLY(data_vio->hash_zone != NULL, 442 442 "must have a hash zone when holding a hash lock"); 443 443 VDO_ASSERT_LOG_ONLY(!list_empty(&data_vio->hash_lock_entry), 444 - "must be on a hash lock ring when holding a hash lock"); 444 + "must be on a hash lock list when holding a hash lock"); 445 445 VDO_ASSERT_LOG_ONLY(old_lock->reference_count > 0, 446 446 "hash lock reference must be counted"); 447 447 ··· 464 464 465 465 if (new_lock != NULL) { 466 466 /* 467 - * Keep all data_vios sharing the lock on a ring since they can complete in any 467 + * Keep all data_vios sharing the lock on a list since they can complete in any 468 468 * order and we'll always need a pointer to one to compare data. 469 469 */ 470 - list_move_tail(&data_vio->hash_lock_entry, &new_lock->duplicate_ring); 470 + list_move_tail(&data_vio->hash_lock_entry, &new_lock->duplicate_vios); 471 471 new_lock->reference_count += 1; 472 472 if (new_lock->max_references < new_lock->reference_count) 473 473 new_lock->max_references = new_lock->reference_count; ··· 1789 1789 struct hash_zone *zone; 1790 1790 bool collides; 1791 1791 1792 - if (list_empty(&lock->duplicate_ring)) 1792 + if (list_empty(&lock->duplicate_vios)) 1793 1793 return false; 1794 1794 1795 - lock_holder = list_first_entry(&lock->duplicate_ring, struct data_vio, 1795 + lock_holder = list_first_entry(&lock->duplicate_vios, struct data_vio, 1796 1796 hash_lock_entry); 1797 1797 zone = candidate->hash_zone; 1798 1798 collides = !blocks_equal(lock_holder->vio.data, candidate->vio.data); ··· 1815 1815 return result; 1816 1816 1817 1817 result = VDO_ASSERT(list_empty(&data_vio->hash_lock_entry), 1818 - "must not already be a member of a hash lock ring"); 1818 + "must not already be a member of a hash lock list"); 1819 1819 if (result != VDO_SUCCESS) 1820 1820 return result; 1821 1821 ··· 1942 1942 "returned hash lock must not be in use with state %s", 1943 1943 get_hash_lock_state_name(lock->state)); 1944 1944 VDO_ASSERT_LOG_ONLY(list_empty(&lock->pool_node), 1945 - "hash lock returned to zone must not be in a pool ring"); 1946 - VDO_ASSERT_LOG_ONLY(list_empty(&lock->duplicate_ring), 1945 + "hash lock returned to zone must not be in a pool list"); 1946 + VDO_ASSERT_LOG_ONLY(list_empty(&lock->duplicate_vios), 1947 1947 "hash lock returned to zone must not reference DataVIOs"); 1948 1948 1949 1949 return_hash_lock_to_pool(zone, lock);
+1 -1
drivers/md/dm-vdo/packer.h
··· 46 46 47 47 /* 48 48 * Each packer_bin holds an incomplete batch of data_vios that only partially fill a compressed 49 - * block. The bins are kept in a ring sorted by the amount of unused space so the first bin with 49 + * block. The bins are kept in a list sorted by the amount of unused space so the first bin with 50 50 * enough space to hold a newly-compressed data_vio can easily be found. When the bin fills up or 51 51 * is flushed, the first uncanceled data_vio in the bin is selected to be the agent for that bin. 52 52 * Upon entering the packer, each data_vio already has its compressed data in the first slot of the
+1 -1
drivers/md/dm-vdo/priority-table.c
··· 199 199 200 200 /* 201 201 * Remove the entry from the bucket list, remembering a pointer to another entry in the 202 - * ring. 202 + * list. 203 203 */ 204 204 next_entry = entry->next; 205 205 list_del_init(entry);
+3 -3
drivers/md/dm-vdo/recovery-journal.h
··· 43 43 * has a vio which is used to commit that block to disk. The vio's data is the on-disk 44 44 * representation of the journal block. In addition each in-memory block has a buffer which is used 45 45 * to accumulate entries while a partial commit of the block is in progress. In-memory blocks are 46 - * kept on two rings. Free blocks live on the 'free_tail_blocks' ring. When a block becomes active 47 - * (see below) it is moved to the 'active_tail_blocks' ring. When a block is fully committed, it is 48 - * moved back to the 'free_tail_blocks' ring. 46 + * kept on two lists. Free blocks live on the 'free_tail_blocks' list. When a block becomes active 47 + * (see below) it is moved to the 'active_tail_blocks' list. When a block is fully committed, it is 48 + * moved back to the 'free_tail_blocks' list. 49 49 * 50 50 * When entries are added to the journal, they are added to the active in-memory block, as 51 51 * indicated by the 'active_block' field. If the caller wishes to wait for the entry to be
+5 -5
drivers/md/dm-vdo/slab-depot.c
··· 139 139 } 140 140 141 141 /** 142 - * mark_slab_journal_dirty() - Put a slab journal on the dirty ring of its allocator in the correct 142 + * mark_slab_journal_dirty() - Put a slab journal on the dirty list of its allocator in the correct 143 143 * order. 144 144 * @journal: The journal to be marked dirty. 145 145 * @lock: The recovery journal lock held by the slab journal. ··· 821 821 822 822 /* 823 823 * Since we are about to commit the tail block, this journal no longer needs to be on the 824 - * ring of journals which the recovery journal might ask to commit. 824 + * list of journals which the recovery journal might ask to commit. 825 825 */ 826 826 mark_slab_journal_clean(journal); 827 827 ··· 1371 1371 static void prioritize_slab(struct vdo_slab *slab) 1372 1372 { 1373 1373 VDO_ASSERT_LOG_ONLY(list_empty(&slab->allocq_entry), 1374 - "a slab must not already be on a ring when prioritizing"); 1374 + "a slab must not already be on a list when prioritizing"); 1375 1375 slab->priority = calculate_slab_priority(slab); 1376 1376 vdo_priority_table_enqueue(slab->allocator->prioritized_slabs, 1377 1377 slab->priority, &slab->allocq_entry); ··· 2562 2562 int result; 2563 2563 2564 2564 VDO_ASSERT_LOG_ONLY(list_empty(&slab->allocq_entry), 2565 - "a requeued slab must not already be on a ring"); 2565 + "a requeued slab must not already be on a list"); 2566 2566 2567 2567 if (vdo_is_read_only(allocator->depot->vdo)) 2568 2568 return; ··· 3297 3297 * This is a min_heap callback function orders slab_status structures using the 'is_clean' field as 3298 3298 * the primary key and the 'emptiness' field as the secondary key. 3299 3299 * 3300 - * Slabs need to be pushed onto the rings in the same order they are to be popped off. Popping 3300 + * Slabs need to be pushed onto the lists in the same order they are to be popped off. Popping 3301 3301 * should always get the most empty first, so pushing should be from most empty to least empty. 3302 3302 * Thus, the ordering is reversed from the usual sense since min_heap returns smaller elements 3303 3303 * before larger ones.
+1 -1
drivers/md/dm-vdo/wait-queue.c
··· 34 34 waitq->last_waiter->next_waiter = waiter; 35 35 } 36 36 37 - /* In both cases, the waiter we added to the ring becomes the last waiter. */ 37 + /* In both cases, the waiter we added to the list becomes the last waiter. */ 38 38 waitq->last_waiter = waiter; 39 39 waitq->length += 1; 40 40 }