anchor.diff:          {NumPresent, NumRecovered}
             when NumRecovered =:= 0, NumPresent >= Blobk ->
               % No need for replication or blob update.
  -            noupdate;
  +            {noupdate, 0};
           {NumPresent, NumRecovered}
             when NumRecovered > 0, NumPresent + NumRecovered >= Blobk ->
               % No need for new replication; containing tags need updating to
               % recover lost blob replicas.
  -            {update, []};
  +            {{update, []}, 0};
           {0, 0}
             when Present =:= [], Recovered =:= [] ->
               % We have no good copies from which to generate new replicas;
               % we have no option but to live with the current information.
               lager:warning("GC: all replicas missing for ~p!!!", [BlobName]),
  -            noupdate;
  +            {noupdate, 0};
           {NumPresent, NumRecovered} ->
               % Extra replicas are needed; we generate one new replica at a
               % time, in a single-shot way. We use any available replicas as
  
positive.code:                        last_response_time = now()}};
  
  handle_cast({rr_blob, '$end_of_table'},
              #state{phase = rr_blobs, rr_pid = RR} = S) ->
      % We are done with sending replication requests; we now wait for
      % the replicator to terminate.
      lager:info("GC: done sending blob replication requests, entering rr_blobs_wait"),
      stop_replicator(RR),
      {noreply, S#state{phase = rr_blobs_wait}};
  handle_cast({rr_blob, Next}, #state{phase = rr_blobs} = S) ->
      rereplicate_blob(S, Next),
      {noreply, S};
  handle_cast({add_replicas, BlobName, NewUrls}, #state{phase = Phase} = S)
    when Phase =:= rr_blobs; Phase =:= rr_blobs_wait ->
      update_replicas(S, BlobName, NewUrls),
      {noreply, S};
  handle_cast({add_replicas, _BlobName, _NewUrls} = M, #state{phase = Phase} = S) ->
      lager:info("GC: ignoring late response ~p (~p)", [M, Phase]),
      {noreply, S};
  
  handle_cast({rr_tags, [T|Tags]}, #state{phase = rr_tags} = S) ->
      S1 = update_tag(S, T, ?MAX_TAG_OP_RETRIES),
      gen_server:cast(self(), {rr_tags, Tags}),
      {noreply, S1};
  handle_cast({rr_tags, []}, #state{phase = rr_tags, gc_peers = Peers,
                                    safe_blacklist = Blacklist} = S) ->
      % We are done with the RR phase, and hence with GC!
      lager:info("GC: tag update/replication done, done with GC!"),
      node_broadcast(Peers, end_rr),
      % Update ddfs_master with the safe_blacklist.
      ddfs_master:safe_gc_blacklist(Blacklist),
  
negative.code: -spec start_link(string(), ets:tab()) -> {ok, pid()} | {error, term()}.
  start_link(Root, DeletedAges) ->
      case gen_server:start_link(?MODULE, {Root, DeletedAges}, []) of
          {ok, Pid} -> {ok, Pid};
          E         -> E
      end.
  
  -spec gc_status(pid(), pid()) -> ok.
  