md/dm-vdo/dedupe.c

12  * concurrently writing identical blocks, allowing them to deduplicate not only against advice but
47  * index query (UPDATING, triggered by stale advice, compression, and rollover), releasing the PBN
55  * Non-concurrent, finding valid advice looks like this (endpoints elided):
57  * Or with stale advice (endpoints elided):
245 	/* True if the UDS index should be updated with new advice */
248 	/* True if the advice has been verified to be a true duplicate */
610 	/* Ensure we don't attempt to update advice when cleaning up. */
647 		 * block, so it must have been a lock on advice we were verifying, not on a
791  *                    the duplicate that should be returned as advice in the future.
799 	VDO_ASSERT_LOG_ONLY(lock->verified, "new advice should have been verified");
800 	VDO_ASSERT_LOG_ONLY(lock->update_advice, "should only update advice if needed");
840 		 * it's time to update the advice.
943  * of the old lock in the lock map. The old lock remains active, but will not update advice.
959 	 * would be poor dedupe advice in the short term.
1087 	 * Only count the result of the initial verification of the advice as valid or stale, and
1109 		 * VERIFYING -> DEDUPING transition: The advice is for a true duplicate, so start
1118 		 * to be written or compressed, but first the advice PBN must be unlocked by the
1204 	VDO_ASSERT_LOG_ONLY(!lock->verified, "hash lock only verifies advice once");
1237 		 * LOCKING -> WRITING transition: The advice block is being modified or has no
1239 		 * update UDS later with the new advice.
1254 		 * it is a true duplicate or stale advice.
1349 		 * on trying to verify the advice and don't bother to try deduplicate against the
1355 		 * because of the chance of matching it, and because we don't record advice for it,
1360 		 * lucky advice. Giving up is a minuscule loss of potential dedupe.
1362 		 * 2b) If the advice is for a slot of a compressed block, it's about to get
1367 		 * 3a) If the lock is held by a data_vio with different data, the advice is already
1374 		 * update in the very rare case of advice for a free block that just happened to be
1377 		 * all stale advice cases almost certainly outweighs saving a UDS update and
1378 		 * trading a write for a read in a lucky case where advice would have been saved
1411  * start_locking() - Continue deduplication for a hash lock that has obtained valid advice of a
1414  * @agent: The data_vio bearing the dedupe advice.
1425 	 * accepting the advice, and don't explicitly change lock states (or use an agent-local
1555  * Begins the non-duplicate write path for a hash lock that had no advice, selecting a data_vio
1598  * Decode VDO duplicate advice from the old_metadata field of a UDS request.
1599  * Returns true if valid advice was found and decoded
1608 	struct zoned_pbn *advice = &data_vio->duplicate;
1617 		vdo_log_error("invalid UDS advice version code %u", version);
1621 	advice->state = encoding->data[offset++];
1622 	advice->pbn = get_unaligned_le64(&encoding->data[offset]);
1626 	/* Don't use advice that's clearly meaningless. */
1627 	if ((advice->state == VDO_MAPPING_STATE_UNMAPPED) || (advice->pbn == VDO_ZERO_BLOCK)) {
1628 		vdo_log_debug("Invalid advice from deduplication server: pbn %llu, state %u. Giving up on deduplication of logical block %llu",
1629 			      (unsigned long long) advice->pbn, advice->state,
1635 	result = vdo_get_physical_zone(vdo, advice->pbn, &advice->zone);
1636 	if ((result != VDO_SUCCESS) || (advice->zone == NULL)) {
1638 			      (unsigned long long) advice->pbn,
1678 		 * QUERYING -> LOCKING transition: Valid advice was obtained from UDS. Use the
1680 		 * that the advice can be used.
1690 		 * QUERYING -> WRITING transition: There was no advice or the advice wasn't valid,
2902  * appropriate) advice from the data_vio's new_mapped fields. The advice found in the index (or