[block-ref-repair] rename rc's rc field to rc_table

src/block/manager.rs

@@ -156,7 +156,7 @@ impl BlockManager {
 
 		let metrics = BlockManagerMetrics::new(
 			config.compression_level,
-			rc.rc.clone(),
+			rc.rc_table.clone(),
 			resync.queue.clone(),
 			resync.errors.clone(),
 		);
@@ -387,7 +387,7 @@ impl BlockManager {
 
 	/// Get number of items in the refcount table
 	pub fn rc_len(&self) -> Result<usize, Error> {
-		Ok(self.rc.rc.len()?)
+		Ok(self.rc.rc_table.len()?)
 	}
 
 	/// Send command to start/stop/manager scrub worker

src/block/rc.rs

@@ -14,14 +14,14 @@ pub type CalculateRefcount =
 	Box<dyn Fn(&db::Transaction, &Hash) -> db::TxResult<usize, Error> + Send + Sync>;
 
 pub struct BlockRc {
-	pub rc: db::Tree,
+	pub rc_table: db::Tree,
 	pub(crate) recalc_rc: ArcSwapOption<Vec<CalculateRefcount>>,
 }
 
 impl BlockRc {
 	pub(crate) fn new(rc: db::Tree) -> Self {
 		Self {
-			rc,
+			rc_table: rc,
 			recalc_rc: ArcSwapOption::new(None),
 		}
 	}
@@ -33,9 +33,9 @@ impl BlockRc {
 		tx: &mut db::Transaction,
 		hash: &Hash,
 	) -> db::TxOpResult<bool> {
-		let old_rc = RcEntry::parse_opt(tx.get(&self.rc, hash)?);
+		let old_rc = RcEntry::parse_opt(tx.get(&self.rc_table, hash)?);
 		match old_rc.increment().serialize() {
-			Some(x) => tx.insert(&self.rc, hash, x)?,
+			Some(x) => tx.insert(&self.rc_table, hash, x)?,
 			None => unreachable!(),
 		};
 		Ok(old_rc.is_zero())
@@ -48,28 +48,28 @@ impl BlockRc {
 		tx: &mut db::Transaction,
 		hash: &Hash,
 	) -> db::TxOpResult<bool> {
-		let new_rc = RcEntry::parse_opt(tx.get(&self.rc, hash)?).decrement();
+		let new_rc = RcEntry::parse_opt(tx.get(&self.rc_table, hash)?).decrement();
 		match new_rc.serialize() {
-			Some(x) => tx.insert(&self.rc, hash, x)?,
+			Some(x) => tx.insert(&self.rc_table, hash, x)?,
-			None => tx.remove(&self.rc, hash)?,
+			None => tx.remove(&self.rc_table, hash)?,
 		};
 		Ok(matches!(new_rc, RcEntry::Deletable { .. }))
 	}
 
 	/// Read a block's reference count
 	pub(crate) fn get_block_rc(&self, hash: &Hash) -> Result<RcEntry, Error> {
-		Ok(RcEntry::parse_opt(self.rc.get(hash.as_ref())?))
+		Ok(RcEntry::parse_opt(self.rc_table.get(hash.as_ref())?))
 	}
 
 	/// Delete an entry in the RC table if it is deletable and the
 	/// deletion time has passed
 	pub(crate) fn clear_deleted_block_rc(&self, hash: &Hash) -> Result<(), Error> {
 		let now = now_msec();
-		self.rc.db().transaction(|tx| {
+		self.rc_table.db().transaction(|tx| {
-			let rcval = RcEntry::parse_opt(tx.get(&self.rc, hash)?);
+			let rcval = RcEntry::parse_opt(tx.get(&self.rc_table, hash)?);
 			match rcval {
 				RcEntry::Deletable { at_time } if now > at_time => {
-					tx.remove(&self.rc, hash)?;
+					tx.remove(&self.rc_table, hash)?;
 				}
 				_ => (),
 			};
@@ -84,14 +84,14 @@ impl BlockRc {
 		if let Some(recalc_fns) = self.recalc_rc.load().as_ref() {
 			trace!("Repair block RC for {:?}", hash);
 			let res = self
-				.rc
+				.rc_table
 				.db()
 				.transaction(|tx| {
 					let mut cnt = 0;
 					for f in recalc_fns.iter() {
 						cnt += f(&tx, hash)?;
 					}
-					let old_rc = RcEntry::parse_opt(tx.get(&self.rc, hash)?);
+					let old_rc = RcEntry::parse_opt(tx.get(&self.rc_table, hash)?);
 					trace!(
 						"Block RC for {:?}: stored={}, calculated={}",
 						hash,
@@ -112,7 +112,7 @@ impl BlockRc {
 								at_time: now_msec() + BLOCK_GC_DELAY.as_millis() as u64,
 							}
 						};
-						tx.insert(&self.rc, hash, new_rc.serialize().unwrap())?;
+						tx.insert(&self.rc_table, hash, new_rc.serialize().unwrap())?;
 						Ok((cnt, true))
 					} else {
 						Ok((cnt, false))

src/block/repair.rs

@@ -107,7 +107,7 @@ impl Worker for RepairWorker {
 				for entry in self
 					.manager
 					.rc
-					.rc
+					.rc_table
 					.range::<&[u8], _>((start_bound, Bound::Unbounded))?
 				{
 					let (hash, _) = entry?;

src/garage/repair/online.rs

@@ -337,7 +337,7 @@ impl Worker for BlockRcRepair {
 			let next1 = self
 				.block_manager
 				.rc
-				.rc
+				.rc_table
 				.range(self.cursor.as_slice()..)?
 				.next()
 				.transpose()?