[Pkg-ceph-commits] [ceph] 04/04: bunch of backported post-0.79 patches
Dmitry Smirnov
onlyjob at moszumanska.debian.org
Sun Apr 20 01:56:46 UTC 2014
This is an automated email from the git hooks/post-receive script.
onlyjob pushed a commit to branch experimental
in repository ceph.
commit 9a8dc92 (experimental)
Author: Dmitry Smirnov <onlyjob at member.fsf.org>
Date: Sat Apr 19 23:11:08 2014
bunch of backported post-0.79 patches
---
debian/patches/8046.patch | 135 ++++++++++++++++++++++++++++++++++++++
debian/patches/8048.patch | 54 +++++++++++++++
debian/patches/8077.patch | 72 ++++++++++++++++++++
debian/patches/8081.patch | 27 ++++++++
debian/patches/8085.patch | 57 ++++++++++++++++
debian/patches/8086.patch | 45 +++++++++++++
debian/patches/8089.patch | 94 ++++++++++++++++++++++++++
debian/patches/8091.patch | 37 +++++++++++
debian/patches/_mds-fixtypo.patch | 23 +++++++
debian/patches/series | 9 +++
debian/patches/spelling.patch | 4 +-
11 files changed, 555 insertions(+), 2 deletions(-)
diff --git a/debian/patches/8046.patch b/debian/patches/8046.patch
new file mode 100644
index 0000000..f5e6af8
--- /dev/null
+++ b/debian/patches/8046.patch
@@ -0,0 +1,135 @@
+From a8f0953974511cd2883bd5d678ff47c4574064ea Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Wed, 9 Apr 2014 12:38:10 -0700
+Subject: [PATCH] osd/ReplicatedPG: adjust obc + snapset_obc locking strategy
+
+Prevoiusly we assumed that if we had snapset_obc set, !exists on the head
+and if we got the snapdir lock we were good to take the head lock too.
+This is no the case when:
+
+ - delete queued
+ - takes wr lock on both head and snapdir
+ - delete commits (but not yet applied)
+ - stat
+ - tries to take wr lock on head
+ - blocks, toggles w=1 state on *head only*
+ - copy-from
+ - tries to take wr lock on snapdir, succeeds
+ - tries to take wr lock on head, fails because w=1
+ - fails the assert(got)
+
+The problem is that the read and write paths are taking different locks
+and we are expecting them to operate in synchrony.
+
+Fix this by using the same ordering for reads as well as write: if the
+snapset_obc is defined, take the read lock on that too, just as we do with
+a write.
+
+Fixes: #8046
+Signed-off-by: Sage Weil <sage at inktank.com>
+Reviewed-by: Samuel Just <sam.just at inktank.com>
+---
+ src/osd/ReplicatedPG.h | 50 +++++++++++++++++++++++++++++++-------------------
+ 1 file changed, 31 insertions(+), 19 deletions(-)
+
+--- a/src/osd/ReplicatedPG.h
++++ b/src/osd/ReplicatedPG.h
+@@ -644,40 +644,47 @@
+ * @param ctx [in,out] ctx to get locks for
+ * @return true on success, false if we are queued
+ */
+ bool get_rw_locks(OpContext *ctx) {
+- if (ctx->op->may_write() || ctx->op->may_cache()) {
+- /* If snapset_obc, !obc->obs->exists and we need to
+- * get a write lock on the snapdir as well as the
+- * head. Fortunately, we are guarranteed to get a
+- * write lock on the head if !obc->obs->exists
+- */
+- if (ctx->snapset_obc) {
+- assert(!ctx->obc->obs.exists);
++ /* If snapset_obc, !obc->obs->exists and we will always take the
++ * snapdir lock *before* the head lock. Since all callers will do
++ * this (read or write) if we get the first we will be guaranteed
++ * to get the second.
++ */
++ if (ctx->snapset_obc) {
++ assert(!ctx->obc->obs.exists);
++ if (ctx->op->may_write() || ctx->op->may_cache()) {
+ if (ctx->snapset_obc->get_write(ctx->op)) {
+ ctx->release_snapset_obc = true;
+ ctx->lock_to_release = OpContext::W_LOCK;
+ } else {
+ return false;
+ }
+- // we are creating it and have the only ref
+- bool got = ctx->obc->get_write(ctx->op);
+- assert(got);
+- return true;
+ } else {
+- if (ctx->obc->get_write(ctx->op)) {
+- ctx->lock_to_release = OpContext::W_LOCK;
+- return true;
++ assert(ctx->op->may_read());
++ if (ctx->snapset_obc->get_read(ctx->op)) {
++ ctx->release_snapset_obc = true;
++ ctx->lock_to_release = OpContext::R_LOCK;
+ } else {
+ return false;
+ }
+ }
++ }
++ if (ctx->op->may_write() || ctx->op->may_cache()) {
++ if (ctx->obc->get_write(ctx->op)) {
++ ctx->lock_to_release = OpContext::W_LOCK;
++ return true;
++ } else {
++ assert(!ctx->snapset_obc);
++ return false;
++ }
+ } else {
+ assert(ctx->op->may_read());
+ if (ctx->obc->get_read(ctx->op)) {
+ ctx->lock_to_release = OpContext::R_LOCK;
+ return true;
+ } else {
++ assert(!ctx->snapset_obc);
+ return false;
+ }
+ }
+ }
+@@ -704,26 +711,31 @@
+ list<OpRequestRef> to_req;
+ bool requeue_recovery = false;
+ bool requeue_recovery_clone = false;
+ bool requeue_recovery_snapset = false;
+- if (ctx->snapset_obc && ctx->release_snapset_obc) {
+- ctx->snapset_obc->put_write(&to_req, &requeue_recovery_snapset);
+- ctx->release_snapset_obc = false;
+- }
+ switch (ctx->lock_to_release) {
+ case OpContext::W_LOCK:
++ if (ctx->snapset_obc && ctx->release_snapset_obc) {
++ ctx->snapset_obc->put_write(&to_req, &requeue_recovery_snapset);
++ ctx->release_snapset_obc = false;
++ }
+ ctx->obc->put_write(&to_req, &requeue_recovery);
+ if (ctx->clone_obc)
+ ctx->clone_obc->put_write(&to_req, &requeue_recovery_clone);
+ break;
+ case OpContext::R_LOCK:
++ if (ctx->snapset_obc && ctx->release_snapset_obc) {
++ ctx->snapset_obc->put_read(&to_req);
++ ctx->release_snapset_obc = false;
++ }
+ ctx->obc->put_read(&to_req);
+ break;
+ case OpContext::NONE:
+ break;
+ default:
+ assert(0);
+ };
++ assert(ctx->release_snapset_obc == false);
+ ctx->lock_to_release = OpContext::NONE;
+ if (requeue_recovery || requeue_recovery_clone || requeue_recovery_snapset)
+ osd->recovery_wq.queue(this);
+ requeue_ops(to_req);
diff --git a/debian/patches/8048.patch b/debian/patches/8048.patch
new file mode 100644
index 0000000..44903fe
--- /dev/null
+++ b/debian/patches/8048.patch
@@ -0,0 +1,54 @@
+From 3d0e80acd9e3e1c751c871742313173f14abbea6 Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Thu, 17 Apr 2014 13:11:54 -0700
+Subject: [PATCH] osd/ReplicatedPG: check clones for degraded
+
+We check whether the head is degraded, and we check whether a clone is
+unreadable, but in the case where we have a cache op on a degraded object,
+we don't check. That leads to an assert when the repop hits the replica
+and the object is in the peer's missing set.
+
+Fix this by adding a check on the clone when write_ordered is true. Note
+that checking write_ordered is better than whether it is a cache op because
+we want to preserve write ordering even for reads that are flagged by the
+client.
+
+Fixes: #8048
+Signed-off-by: Sage Weil <sage at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 22 +++++++++++++++++-----
+ 1 file changed, 17 insertions(+), 5 deletions(-)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -1255,13 +1255,25 @@
+ assert(!can_create); // only happens on a read
+ wait_for_unreadable_object(missing_oid, op);
+ return;
+ }
+- } else if (r == 0 && is_unreadable_object(obc->obs.oi.soid)) {
+- dout(10) << __func__ << ": clone " << obc->obs.oi.soid
+- << " is unreadable, waiting" << dendl;
+- wait_for_unreadable_object(obc->obs.oi.soid, op);
+- return;
++ } else if (r == 0) {
++ if (is_unreadable_object(obc->obs.oi.soid)) {
++ dout(10) << __func__ << ": clone " << obc->obs.oi.soid
++ << " is unreadable, waiting" << dendl;
++ wait_for_unreadable_object(obc->obs.oi.soid, op);
++ return;
++ }
++
++ // degraded object? (the check above was for head; this could be a clone)
++ if (write_ordered &&
++ obc->obs.oi.soid.snap != CEPH_NOSNAP &&
++ is_degraded_object(obc->obs.oi.soid)) {
++ dout(10) << __func__ << ": clone " << obc->obs.oi.soid
++ << " is degraded, waiting" << dendl;
++ wait_for_degraded_object(obc->obs.oi.soid, op);
++ return;
++ }
+ }
+
+ if (hit_set) {
+ hit_set->insert(oid);
diff --git a/debian/patches/8077.patch b/debian/patches/8077.patch
new file mode 100644
index 0000000..ac2d3db
--- /dev/null
+++ b/debian/patches/8077.patch
@@ -0,0 +1,72 @@
+From 78df66f52084bd5ba354bb41edce98e032e4811b Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Fri, 11 Apr 2014 13:14:58 -0700
+Subject: [PATCH] osd/ReplicatedPG: skip missing hit_sets when loading into
+ memory
+
+We weren't handling hit_sets that were missing.
+
+Two changes here:
+
+1- Load the hit_sets oldest to newest. That means that if we stop partway
+ through loading, and then add another to the end of the list, and then
+ try again to load some more, we will still catch them all.
+2- If the object is missing, stop. We'll try again the next time
+ agent_work() is called.
+
+Fixes: #8077
+Signed-off-by: Sage Weil <sage at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 29 +++++++++++++++++------------
+ 1 file changed, 17 insertions(+), 12 deletions(-)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -10742,11 +10742,10 @@
+ }
+
+ if (agent_state->hit_set_map.size() < info.hit_set.history.size()) {
+ dout(10) << __func__ << dendl;
+- for (list<pg_hit_set_info_t>::reverse_iterator p =
+- info.hit_set.history.rbegin();
+- p != info.hit_set.history.rend(); ++p) {
++ for (list<pg_hit_set_info_t>::iterator p = info.hit_set.history.begin();
++ p != info.hit_set.history.end(); ++p) {
+ if (agent_state->hit_set_map.count(p->begin.sec()) == 0) {
+ dout(10) << __func__ << " loading " << p->begin << "-"
+ << p->end << dendl;
+ if (!pool.info.is_replicated()) {
+@@ -10757,18 +10756,24 @@
+
+ // check if it's still in flight
+ if (hit_set_flushing.count(p->begin)) {
+ agent_state->add_hit_set(p->begin.sec(), hit_set_flushing[p->begin]);
+- } else {
+- bufferlist bl;
+- hobject_t oid = get_hit_set_archive_object(p->begin, p->end);
+- int r = osd->store->read(coll, oid, 0, 0, bl);
+- assert(r >= 0);
+- HitSetRef hs(new HitSet);
+- bufferlist::iterator pbl = bl.begin();
+- ::decode(*hs, pbl);
+- agent_state->add_hit_set(p->begin.sec(), hs);
++ continue;
+ }
++
++ hobject_t oid = get_hit_set_archive_object(p->begin, p->end);
++ if (is_unreadable_object(oid)) {
++ dout(10) << __func__ << " unreadable " << oid << ", waiting" << dendl;
++ break;
++ }
++
++ bufferlist bl;
++ int r = osd->store->read(coll, oid, 0, 0, bl);
++ assert(r >= 0);
++ HitSetRef hs(new HitSet);
++ bufferlist::iterator pbl = bl.begin();
++ ::decode(*hs, pbl);
++ agent_state->add_hit_set(p->begin.sec(), hs);
+ }
+ }
+ }
+ }
diff --git a/debian/patches/8081.patch b/debian/patches/8081.patch
new file mode 100644
index 0000000..c7e8025
--- /dev/null
+++ b/debian/patches/8081.patch
@@ -0,0 +1,27 @@
+From 809d0fab38d092dfa857e4237e5799c849de940e Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Fri, 11 Apr 2014 17:46:44 -0700
+Subject: [PATCH] osd/ReplicatedPG: handle missing hit_set on HITSET_GET rados
+ op
+
+Fixes: #8081
+Signed-off-by: Sage Weil <sage at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -963,8 +963,12 @@
+ // FIXME: EC not supported yet
+ result = -EOPNOTSUPP;
+ break;
+ }
++ if (is_unreadable_object(oid)) {
++ wait_for_unreadable_object(oid, op);
++ return;
++ }
+ result = osd->store->read(coll, oid, 0, 0, osd_op.outdata);
+ }
+ }
+ break;
diff --git a/debian/patches/8085.patch b/debian/patches/8085.patch
new file mode 100644
index 0000000..e80b340
--- /dev/null
+++ b/debian/patches/8085.patch
@@ -0,0 +1,57 @@
+From a72bcddfc81254793689612d5615ae572d8f51f7 Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Sat, 12 Apr 2014 22:23:26 -0700
+Subject: [PATCH] osd/ReplicatedPG: handle misdirected do_command
+
+We can get a query on a pg we still have but are no longer primary for. If
+that happens, do not reply. The client will resend to the correct OSD
+assuming it has the map. Send them the latest incremental so that we know
+they know there is something new. We don't know the exact epoch they have,
+unfortunately, because MCommand doesn't include it, but a newer inc is
+enough to make them request the right incrementals from a mon. Eventually
+they will figure it out and Objecter will resend the request to the
+correct target.
+
+It is possible we should include epoch in the MCommand message so that we
+can do this mapping "correctly" (as in, the same way MOSDOp does). That
+makes MCommand less general, though... a PG-specific command message might
+be the most precise thing. Another day...
+
+Fixes: #8085
+Signed-off-by: Sage Weil <sage at inktank.com>
+---
+ src/osd/OSD.cc | 21 +++++++++++++++++----
+ 1 file changed, 17 insertions(+), 4 deletions(-)
+
+--- a/src/osd/OSD.cc
++++ b/src/osd/OSD.cc
+@@ -4275,12 +4275,25 @@
+ if (osdmap->get_primary_shard(pgid, &pcand) &&
+ _have_pg(pcand)) {
+ PG *pg = _lookup_lock_pg(pcand);
+ assert(pg);
+- // simulate pg <pgid> cmd= for pg->do-command
+- if (prefix != "pg")
+- cmd_putval(cct, cmdmap, "cmd", prefix);
+- r = pg->do_command(cmdmap, ss, data, odata);
++ if (pg->is_primary()) {
++ // simulate pg <pgid> cmd= for pg->do-command
++ if (prefix != "pg")
++ cmd_putval(cct, cmdmap, "cmd", prefix);
++ r = pg->do_command(cmdmap, ss, data, odata);
++ } else {
++ ss << "not primary for pgid " << pgid;
++
++ // send them the latest diff to ensure they realize the mapping
++ // has changed.
++ send_incremental_map(osdmap->get_epoch() - 1, con);
++
++ // do not reply; they will get newer maps and realize they
++ // need to resend.
++ pg->unlock();
++ return;
++ }
+ pg->unlock();
+ } else {
+ ss << "i don't have pgid " << pgid;
+ r = -ENOENT;
diff --git a/debian/patches/8086.patch b/debian/patches/8086.patch
new file mode 100644
index 0000000..5f330f9
--- /dev/null
+++ b/debian/patches/8086.patch
@@ -0,0 +1,45 @@
+From 502cc6140667ada0bae3886885c99e3aaca7f5ed Mon Sep 17 00:00:00 2001
+From: Samuel Just <sam.just at inktank.com>
+Date: Mon, 14 Apr 2014 11:07:58 -0700
+Subject: [PATCH] ReplicatedPG::agent_work: skip hitset objects before getting
+ object context
+
+Otherwise, we might read the attr on a hitset object we are in the
+process of deleting.
+
+Fixes: #8086
+Signed-off-by: Samuel Just <sam.just at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -10670,8 +10670,13 @@
+ int started = 0;
+ for (vector<hobject_t>::iterator p = ls.begin();
+ p != ls.end();
+ ++p) {
++ if (p->nspace == cct->_conf->osd_hit_set_namespace) {
++ dout(20) << __func__ << " skip (hit set) " << *p << dendl;
++ osd->logger->inc(l_osd_agent_skip);
++ continue;
++ }
+ if (is_degraded_object(*p)) {
+ dout(20) << __func__ << " skip (degraded) " << *p << dendl;
+ osd->logger->inc(l_osd_agent_skip);
+ continue;
+@@ -10692,13 +10697,8 @@
+ dout(20) << __func__ << " skip (scrubbing) " << obc->obs.oi << dendl;
+ osd->logger->inc(l_osd_agent_skip);
+ continue;
+ }
+- if (obc->obs.oi.soid.nspace == cct->_conf->osd_hit_set_namespace) {
+- dout(20) << __func__ << " skip (hit set) " << obc->obs.oi << dendl;
+- osd->logger->inc(l_osd_agent_skip);
+- continue;
+- }
+ if (obc->is_blocked()) {
+ dout(20) << __func__ << " skip (blocked) " << obc->obs.oi << dendl;
+ osd->logger->inc(l_osd_agent_skip);
+ continue;
diff --git a/debian/patches/8089.patch b/debian/patches/8089.patch
new file mode 100644
index 0000000..0af5529
--- /dev/null
+++ b/debian/patches/8089.patch
@@ -0,0 +1,94 @@
+From 8905e3e2285c211e695d3d2747e6feda8ea5e55c Mon Sep 17 00:00:00 2001
+From: Sage Weil <sage at inktank.com>
+Date: Sun, 13 Apr 2014 21:31:35 -0700
+Subject: [PATCH] osd/ReplicatedPG: handle dup ops earlier in do_op
+
+Current the dup op checks happen in execute_ctx, long after we handle
+cache ops or get the obc and (potentially) return ENOENT. That means that
+object deletions and cache ops both aren't properly idempotent.
+
+This is easy to fix by moving the check earlier in do_op.
+
+Fixes: #8089
+Signed-off-by: Sage Weil <sage at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 57 +++++++++++++++++++++++++------------------------
+ 1 file changed, 29 insertions(+), 28 deletions(-)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -1236,8 +1236,37 @@
+ osd->reply_op_error(op, -EINVAL);
+ return;
+ }
+
++ // dup/replay?
++ if (op->may_write() || op->may_cache()) {
++ const pg_log_entry_t *entry = pg_log.get_log().get_request(m->get_reqid());
++ if (entry) {
++ const eversion_t& oldv = entry->version;
++ dout(3) << __func__ << " dup " << m->get_reqid()
++ << " was " << oldv << dendl;
++ if (already_complete(oldv)) {
++ osd->reply_op_error(op, 0, oldv, entry->user_version);
++ } else {
++ if (m->wants_ack()) {
++ if (already_ack(oldv)) {
++ MOSDOpReply *reply = new MOSDOpReply(m, 0, get_osdmap()->get_epoch(), 0, false);
++ reply->add_flags(CEPH_OSD_FLAG_ACK);
++ reply->set_reply_versions(oldv, entry->user_version);
++ osd->send_message_osd_client(reply, m->get_connection());
++ } else {
++ dout(10) << " waiting for " << oldv << " to ack" << dendl;
++ waiting_for_ack[oldv].push_back(op);
++ }
++ }
++ dout(10) << " waiting for " << oldv << " to commit" << dendl;
++ waiting_for_ondisk[oldv].push_back(op); // always queue ondisk waiters, so that we can requeue if needed
++ op->mark_delayed("waiting for ondisk");
++ }
++ return;
++ }
++ }
++
+ ObjectContextRef obc;
+ bool can_create = op->may_write() || op->may_cache();
+ hobject_t missing_oid;
+ hobject_t oid(m->get_oid(),
+@@ -1648,36 +1677,8 @@
+ delete ctx->op_t;
+ ctx->op_t = pgbackend->get_transaction();
+
+ if (op->may_write() || op->may_cache()) {
+- // dup/replay?
+- const pg_log_entry_t *entry = pg_log.get_log().get_request(ctx->reqid);
+- if (entry) {
+- const eversion_t& oldv = entry->version;
+- dout(3) << "do_op dup " << ctx->reqid << " was " << oldv << dendl;
+- if (already_complete(oldv)) {
+- reply_ctx(ctx, 0, oldv, entry->user_version);
+- } else {
+- close_op_ctx(ctx, -EBUSY);
+-
+- if (m->wants_ack()) {
+- if (already_ack(oldv)) {
+- MOSDOpReply *reply = new MOSDOpReply(m, 0, get_osdmap()->get_epoch(), 0, false);
+- reply->add_flags(CEPH_OSD_FLAG_ACK);
+- reply->set_reply_versions(oldv, entry->user_version);
+- osd->send_message_osd_client(reply, m->get_connection());
+- } else {
+- dout(10) << " waiting for " << oldv << " to ack" << dendl;
+- waiting_for_ack[oldv].push_back(op);
+- }
+- }
+- dout(10) << " waiting for " << oldv << " to commit" << dendl;
+- waiting_for_ondisk[oldv].push_back(op); // always queue ondisk waiters, so that we can requeue if needed
+- op->mark_delayed("waiting for ondisk");
+- }
+- return;
+- }
+-
+ op->mark_started();
+
+ // snap
+ if (pool.info.is_pool_snaps_mode()) {
diff --git a/debian/patches/8091.patch b/debian/patches/8091.patch
new file mode 100644
index 0000000..941e7ac
--- /dev/null
+++ b/debian/patches/8091.patch
@@ -0,0 +1,37 @@
+From 7e697b1bc2ffac086b6a24f97aba755401cd8c37 Mon Sep 17 00:00:00 2001
+From: Samuel Just <sam.just at inktank.com>
+Date: Tue, 15 Apr 2014 14:17:33 -0700
+Subject: [PATCH] ReplicatedPG::recover_replicas: do not recover clones while
+ snap obj is missing
+
+Otherwise, we cannot safely read the snapset for the clone.
+
+Fixes: #8091
+Signed-off-by: Samuel Just <sam.just at inktank.com>
+---
+ src/osd/ReplicatedPG.cc | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+--- a/src/osd/ReplicatedPG.cc
++++ b/src/osd/ReplicatedPG.cc
+@@ -9647,8 +9647,20 @@
+ dout(10) << __func__ << ": " << soid << " still unfound" << dendl;
+ continue;
+ }
+
++ if (soid.is_snap() && pg_log.get_missing().is_missing(soid.get_head())) {
++ dout(10) << __func__ << ": " << soid.get_head()
++ << " still missing on primary" << dendl;
++ continue;
++ }
++
++ if (soid.is_snap() && pg_log.get_missing().is_missing(soid.get_snapdir())) {
++ dout(10) << __func__ << ": " << soid.get_snapdir()
++ << " still missing on primary" << dendl;
++ continue;
++ }
++
+ if (pg_log.get_missing().is_missing(soid)) {
+ dout(10) << __func__ << ": " << soid << " still missing on primary" << dendl;
+ continue;
+ }
diff --git a/debian/patches/_mds-fixtypo.patch b/debian/patches/_mds-fixtypo.patch
new file mode 100644
index 0000000..84a4065
--- /dev/null
+++ b/debian/patches/_mds-fixtypo.patch
@@ -0,0 +1,23 @@
+From 4ccc845c0a5593a1809e53c13fc9bb0c7cfc46ae Mon Sep 17 00:00:00 2001
+From: "Yan, Zheng" <zheng.z.yan at intel.com>
+Date: Sat, 12 Apr 2014 14:10:55 +0800
+Subject: [PATCH] mds: fix typo in Server::do_rename_rollback()
+
+Signed-off-by: Yan, Zheng <zheng.z.yan at intel.com>
+---
+ src/mds/Server.cc | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/src/mds/Server.cc
++++ b/src/mds/Server.cc
+@@ -7123,9 +7123,9 @@
+ }
+
+ if (target && target->is_dir()) {
+ assert(destdn);
+- mdcache->project_subtree_rename(in, straydir, destdir);
++ mdcache->project_subtree_rename(target, straydir, destdir);
+ }
+
+ if (in && in->is_dir()) {
+ assert(srcdn);
diff --git a/debian/patches/series b/debian/patches/series
index cc8f0f4..288ccb2 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,6 +1,15 @@
5469.patch
8008.patch
+8046.patch
+8048.patch
+8077.patch
+8081.patch
+8085.patch
+8086.patch
+8089.patch
+8091.patch
_1606.patch
+_mds-fixtypo.patch
arch.patch
gcj.patch
modules.patch
diff --git a/debian/patches/spelling.patch b/debian/patches/spelling.patch
index d86af36..799572d 100644
--- a/debian/patches/spelling.patch
+++ b/debian/patches/spelling.patch
@@ -55,7 +55,7 @@ Description: spelling corrections
* also inform the Leader of accepted but uncommitted values.
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
-@@ -6451,9 +6451,9 @@
+@@ -6464,9 +6464,9 @@
it->second);
cluster_messenger->send_message(m, con.get());
} else {
@@ -66,7 +66,7 @@ Description: spelling corrections
it->second.begin();
i != it->second.end();
++i) {
-@@ -6490,9 +6490,9 @@
+@@ -6503,9 +6503,9 @@
MOSDPGQuery *m = new MOSDPGQuery(curmap->get_epoch(), pit->second);
cluster_messenger->send_message(m, con.get());
} else {
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ceph/ceph.git
More information about the Pkg-ceph-commits
mailing list