~ubuntu-branches/ubuntu/trusty/ceph/trusty-proposed

« back to all changes in this revision

Viewing changes to src/osd/ReplicatedPG.cc

• browse files at revision 62
• compare with another revision
• download diff
• download tarball
• view history from revision 62

Show diffs side-by-side

added

removed

src/osd/ReplicatedPG.cc

595

595

  if (command == "query") {

596

596

    f->open_object_section("pg");

597

597

    f->dump_string("state", pg_state_string(get_state()));

 

598

    f->dump_stream("snap_trimq") << snap_trimq;

598

599

    f->dump_unsigned("epoch", get_osdmap()->get_epoch());

599

600

    f->open_array_section("up");

600

601

    for (vector<int>::iterator p = up.begin(); p != up.end(); ++p)

2072

2073

      }

2073

2074

      peer_backfill_info[from] = bi;

2074

2075

 

2075

 

      assert(waiting_on_backfill.find(from) != waiting_on_backfill.end());

2076

 

      waiting_on_backfill.erase(from);

 

2076

      if (waiting_on_backfill.find(from) != waiting_on_backfill.end()) {

 

2077

        waiting_on_backfill.erase(from);

2077

2078

 

2078

 

      if (waiting_on_backfill.empty()) {

2079

 

        assert(peer_backfill_info.size() == backfill_targets.size());

2080

 

        finish_recovery_op(hobject_t::get_max());

 

2079

        if (waiting_on_backfill.empty()) {

 

2080

          assert(peer_backfill_info.size() == backfill_targets.size());

 

2081

          finish_recovery_op(hobject_t::get_max());

 

2082

        }

 

2083

      } else {

 

2084

        // we canceled backfill for a while due to a too full, and this

 

2085

        // is an extra response from a non-too-full peer

2081

2086

      }

2082

2087

    }

2083

2088

    break;

2560

2565

    // replica collection trimming

2561

2566

    snap_trimmer_machine.process_event(SnapTrim());

2562

2567

  }

2563

 

  if (snap_trimmer_machine.requeue) {

2564

 

    dout(10) << "snap_trimmer requeue" << dendl;

2565

 

    queue_snap_trim();

2566

 

  }

2567

2568

  unlock();

2568

2569

  return;

2569

2570

}

3353

3354

            break;

3354

3355

        }

3355

3356

        result = _delete_oid(ctx, true);

 

3357

        if (result >= 0) {

 

3358

          // mark that this is a cache eviction to avoid triggering normal

 

3359

          // make_writeable() clone or snapdir object creation in finish_ctx()

 

3360

          ctx->cache_evict = true;

 

3361

        }

3356

3362

        osd->logger->inc(l_osd_tier_evict);

3357

3363

      }

3358

3364

      break;

3645

3651

    case CEPH_OSD_OP_SETALLOCHINT:

3646

3652

      ++ctx->num_write;

3647

3653

      {

 

3654

        if (!(get_min_peer_features() & CEPH_FEATURE_OSD_SET_ALLOC_HINT)) { 

 

3655

          result = -EOPNOTSUPP;

 

3656

          break;

 

3657

        }

3648

3658

        if (!obs.exists) {

3649

3659

          ctx->mod_desc.create();

3650

3660

          t->touch(soid);

4836

4846

  

4837

4847

  if ((ctx->obs->exists && !ctx->obs->oi.is_whiteout()) && // head exist(ed)

4838

4848

      snapc.snaps.size() &&                 // there are snaps

 

4849

      !ctx->cache_evict &&

4839

4850

      snapc.snaps[0] > ctx->new_snapset.seq) {  // existing object is old

4840

4851

    // clone

4841

4852

    hobject_t coid = soid;

5156

5167

          ctx->snapset_obc->obs.exists = false;

5157

5168

        }

5158

5169

      }

5159

 

    } else if (ctx->new_snapset.clones.size()) {

 

5170

    } else if (ctx->new_snapset.clones.size() &&

 

5171

               !ctx->cache_evict) {

5160

5172

      // save snapset on _snap

5161

5173

      hobject_t snapoid(soid.oid, soid.get_key(), CEPH_SNAPDIR, soid.hash,

5162

5174

                        info.pgid.pool(), soid.get_namespace());

6968

6980

    if (get_osdmap()->is_blacklisted(ea)) {

6969

6981

      dout(10) << "watch: Found blacklisted watcher for " << ea << dendl;

6970

6982

      assert(j->second->get_pg() == this);

 

6983

      j->second->unregister_cb();

6971

6984

      handle_watch_timeout(j->second);

6972

6985

    }

6973

6986

  }

9334

9347

  // adjust info to backfill

9335

9348

  info.last_backfill = hobject_t();

9336

9349

  dirty_info = true;

 

9350

 

 

9351

 

 

9352

  // clear log

 

9353

  PGLogEntryHandler rollbacker;

 

9354

  pg_log.clear_can_rollback_to(&rollbacker);

 

9355

  rollbacker.apply(this, t);

 

9356

 

9337

9357

  write_if_dirty(*t);

9338

9358

 

9339

9359

  on_shutdown();

10952

10972

      pg_log_entry_t::MODIFY,

10953

10973

      oid,

10954

10974

      ctx->at_version,

10955

 

      ctx->obs->oi.version,

 

10975

      eversion_t(),

10956

10976

      0,

10957

10977

      osd_reqid_t(),

10958

10978

      ctx->mtime)

11974

11994

  : my_base(ctx), 

11975

11995

    NamedState(context< SnapTrimmer >().pg->cct, "NotTrimming")

11976

11996

{

11977

 

  context< SnapTrimmer >().requeue = false;

11978

11997

  context< SnapTrimmer >().log_enter(state_name);

11979

11998

}

11980

11999

 

11981

12000

void ReplicatedPG::NotTrimming::exit()

11982

12001

{

11983

 

  context< SnapTrimmer >().requeue = true;

11984

12002

  context< SnapTrimmer >().log_exit(state_name, enter_time);

11985

12003

}

11986

12004

 

12040

12058

 

12041

12059

  dout(10) << "TrimmingObjects: trimming snap " << snap_to_trim << dendl;

12042

12060

 

12043

 

  // Get next

12044

 

  hobject_t old_pos = pos;

12045

 

  int r = pg->snap_mapper.get_next_object_to_trim(snap_to_trim, &pos);

12046

 

  if (r != 0 && r != -ENOENT) {

12047

 

    derr << __func__ << ": get_next returned " << cpp_strerror(r) << dendl;

12048

 

    assert(0);

12049

 

  } else if (r == -ENOENT) {

12050

 

    // Done!

12051

 

    dout(10) << "TrimmingObjects: got ENOENT" << dendl;

12052

 

    post_event(SnapTrim());

12053

 

    return transit< WaitingOnReplicas >();

12054

 

  }

12055

 

 

12056

 

  dout(10) << "TrimmingObjects react trimming " << pos << dendl;

12057

 

  RepGather *repop = pg->trim_object(pos);

12058

 

  if (!repop) {

12059

 

    dout(10) << __func__ << " could not get write lock on obj "

12060

 

             << pos << dendl;

12061

 

    pos = old_pos;

12062

 

    return discard_event();

12063

 

  }

12064

 

  assert(repop);

12065

 

  repop->queue_snap_trimmer = true;

12066

 

 

12067

 

  repops.insert(repop->get());

12068

 

  pg->simple_repop_submit(repop);

 

12061

  for (set<RepGather *>::iterator i = repops.begin();

 

12062

       i != repops.end(); 

 

12063

       ) {

 

12064

    if ((*i)->all_applied && (*i)->all_committed) {

 

12065

      (*i)->put();

 

12066

      repops.erase(i++);

 

12067

    } else {

 

12068

      ++i;

 

12069

    }

 

12070

  }

 

12071

 

 

12072

  while (repops.size() < g_conf->osd_pg_max_concurrent_snap_trims) {

 

12073

    // Get next

 

12074

    hobject_t old_pos = pos;

 

12075

    int r = pg->snap_mapper.get_next_object_to_trim(snap_to_trim, &pos);

 

12076

    if (r != 0 && r != -ENOENT) {

 

12077

      derr << __func__ << ": get_next returned " << cpp_strerror(r) << dendl;

 

12078

      assert(0);

 

12079

    } else if (r == -ENOENT) {

 

12080

      // Done!

 

12081

      dout(10) << "TrimmingObjects: got ENOENT" << dendl;

 

12082

      post_event(SnapTrim());

 

12083

      return transit< WaitingOnReplicas >();

 

12084

    }

 

12085

 

 

12086

    dout(10) << "TrimmingObjects react trimming " << pos << dendl;

 

12087

    RepGather *repop = pg->trim_object(pos);

 

12088

    if (!repop) {

 

12089

      dout(10) << __func__ << " could not get write lock on obj "

 

12090

               << pos << dendl;

 

12091

      pos = old_pos;

 

12092

      return discard_event();

 

12093

    }

 

12094

    assert(repop);

 

12095

    repop->queue_snap_trimmer = true;

 

12096

 

 

12097

    repops.insert(repop->get());

 

12098

    pg->simple_repop_submit(repop);

 

12099

  }

12069

12100

  return discard_event();

12070

12101

}

12071

12102

/* WaitingOnReplicasObjects */

12074

12105

    NamedState(context< SnapTrimmer >().pg->cct, "Trimming/WaitingOnReplicas")

12075

12106

{

12076

12107

  context< SnapTrimmer >().log_enter(state_name);

12077

 

  context< SnapTrimmer >().requeue = false;

12078

12108

}

12079

12109

 

12080

12110

void ReplicatedPG::WaitingOnReplicas::exit()

12099

12129

  for (set<RepGather *>::iterator i = repops.begin();

12100

12130

       i != repops.end();

12101

12131

       repops.erase(i++)) {

12102

 

    if (!(*i)->all_applied) {

 

12132

    if (!(*i)->all_applied || !(*i)->all_committed) {

12103

12133

      return discard_event();

12104

12134

    } else {

12105

12135

      (*i)->put();

12124

12154

  context<SnapTrimmer>().need_share_pg_info = true;

12125

12155

 

12126

12156

  // Back to the start

12127

 

  post_event(SnapTrim());

 

12157

  pg->queue_snap_trim();

12128

12158

  return transit< NotTrimming >();

12129

12159

}

12130

12160

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1