// time事件callback入口，会周期性的调用
void OSD::tick()
{
	......
    if (is_active()) { // osd 状态必须是active
		if (!scrub_random_backoff()) { // 以一定概率调度
			sched_scrub(); // 调度scrub
    }

    check_replay_queue();
	}
	......
}

void OSD::sched_scrub()
{
  bool load_is_low = scrub_should_schedule(); // 负载低，在规定时间限制内，会返回true

  pair<utime_t, spg_t> pos;
  if (service.first_scrub_stamp(&pos)) { // 获取一个需要做scrub的pg
    do {
      utime_t t = pos.first;
      spg_t pgid = pos.second;

      utime_t diff = now - t;
      if ((double)diff < cct->_conf->osd_scrub_min_interval) { // 没有超过下限，不做scrub
		break;
      }

      if ((double)diff < cct->_conf->osd_scrub_max_interval && !load_is_low) { // 超过下限，但是还未到上限，load_is_low不满足也不做scrub
		break;
      }

	  // 满足scrub条件
      PG *pg = _lookup_lock_pg(pgid); // 获取pg并且lock pg
      if (pg) {
		if (pg->get_pgbackend()->scrub_supported() && pg->is_active() && // pg也必须是active状态
	    (load_is_low || (double)diff >= cct->_conf->osd_scrub_max_interval ||
	     pg->scrubber.must_scrub)) {
		  if (pg->sched_scrub()) { // 调度pg 的scrub
			pg->unlock(); // 成功将pg送入scrub_wq后，释放锁，当disk_tp线程从队列获取pg，开始做scrub的时候，会继续拿锁
			break; // break说明一次只成功调度一个pg做，下一次time继续调度
	      }
		}
	    pg->unlock();
      }
    } while (service.next_scrub_stamp(pos, &pos)); // 排在前面的pg可能状态不是active，所以这里继续循环寻找下一个pg
  }
  ......
}

// OSD.h中定义的pg集合
set< pair<utime_t,spg_t> > last_scrub_pg;

// 从集合中取一个最久的pg
bool first_scrub_stamp(pair<utime_t, spg_t> *out) {
    Mutex::Locker l(sched_scrub_lock);
    if (last_scrub_pg.empty())
      return false;
    set< pair<utime_t, spg_t> >::iterator iter = last_scrub_pg.begin(); // 时间越小，排在越前面
    *out = *iter;
    return true;
}

bool PG::sched_scrub()
{
  // 注意条件，如果pg不是primary，直接返回了，说明只有primary pg才可以发起scrub
  if (!(is_primary() && is_active() && is_clean() && !is_scrubbing())) {
    return false;
  }

  ......

  bool ret = true;
  // 第一个if将pg本身加入peers，并且向副本发送scrub消息，让副本预留slot
  if (!scrubber.reserved) { // 第一次调用，reserve为false
    assert(scrubber.reserved_peers.empty()); // peers也为空集合
    if (osd->inc_scrubs_pending()) { // 为自己预留slot
      scrubber.reserved = true;
      scrubber.reserved_peers.insert(pg_whoami); // 将pg本身加入peers集合，一起计数
      scrub_reserve_replicas(); // 发送消息让副本也预留slot
    } else {
      ret = false;
    }
  }

  // 第二个if检查slot信息
  if (scrubber.reserved) {
    if (scrubber.reserve_failed) { // 还没收到副本的消息，或者副本预留成功，reserve_failed为false
      clear_scrub_reserved();
      scrub_unreserve_replicas();
      ret = false;
    } else if (scrubber.reserved_peers.size() == acting.size()) { // 判断是否所有副本都预留成功了
      if (time_for_deep) {
		state_set(PG_STATE_DEEP_SCRUB);
      }
      queue_scrub(); // 如果是，调度scrub
    } else {
      // 等待副本的消息
      dout(20) << "sched_scrub: reserved " << scrubber.reserved_peers << ", waiting for replicas" << dendl;
    }
  }

  ......
}

bool PG::queue_scrub()
{
  assert(_lock.is_locked());
  if (is_scrubbing()) { // 已经在做scrub，返回
    return false;
  }
  scrubber.must_scrub = false;
  state_set(PG_STATE_SCRUBBING);
  if (scrubber.must_deep_scrub) {
    state_set(PG_STATE_DEEP_SCRUB);
    scrubber.must_deep_scrub = false;
  }
  if (scrubber.must_repair) {
    state_set(PG_STATE_REPAIR);
    scrubber.must_repair = false;
  }
  osd->queue_for_scrub(this); // 放入队列
  return true;
}

bool queue_for_scrub(PG *pg)
{
  return scrub_wq.queue(pg); // 放入队列
}

void _process(
  PG *pg,
  ThreadPool::TPHandle &handle)
{
  pg->scrub(handle); // 还是让pg执行scrub
  pg->put("ScrubWQ");
}

void PG::scrub(ThreadPool::TPHandle &handle)
{
  lock();

  ......
  chunky_scrub(handle);

  unlock();
}