e7b40eeaea
drbd: fix build error against kernel v6.5.4 (boo#1215699) OBS-URL: https://build.opensuse.org/request/show/1113586 OBS-URL: https://build.opensuse.org/package/show/network:ha-clustering:Factory/drbd?expand=0&rev=146
1481 lines
63 KiB
Diff
1481 lines
63 KiB
Diff
From d6bbb1b1635b9912d77d1a26aba3f380a2ed986d Mon Sep 17 00:00:00 2001
|
|
From: Joel Colledge <joel.colledge@linbit.com>
|
|
Date: Mon, 11 Sep 2023 16:45:27 +0200
|
|
Subject: [PATCH 14/20] drbd: include source of state change in log
|
|
|
|
This is useful for understanding why a state change occurs. In
|
|
particular, whether it was triggered by userspace.
|
|
---
|
|
drbd/drbd_int.h | 10 ++--
|
|
drbd/drbd_main.c | 12 ++---
|
|
drbd/drbd_nl.c | 103 ++++++++++++++++++++------------------
|
|
drbd/drbd_receiver.c | 77 +++++++++++++++-------------
|
|
drbd/drbd_req.c | 6 +--
|
|
drbd/drbd_sender.c | 25 ++++++----
|
|
drbd/drbd_state.c | 116 ++++++++++++++++++++++++-------------------
|
|
drbd/drbd_state.h | 40 +++++++++++----
|
|
8 files changed, 224 insertions(+), 165 deletions(-)
|
|
|
|
diff --git a/drbd/drbd_int.h b/drbd/drbd_int.h
|
|
index f6e7c3ac2629..b705f26e71a4 100644
|
|
--- a/drbd/drbd_int.h
|
|
+++ b/drbd/drbd_int.h
|
|
@@ -1876,7 +1876,8 @@ extern void drbd_destroy_resource(struct kref *kref);
|
|
|
|
extern void drbd_destroy_device(struct kref *kref);
|
|
|
|
-extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts);
|
|
+extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts,
|
|
+ const char *tag);
|
|
extern struct drbd_connection *drbd_create_connection(struct drbd_resource *resource,
|
|
struct drbd_transport_class *tc);
|
|
extern void drbd_transport_shutdown(struct drbd_connection *connection, enum drbd_tr_free_op op);
|
|
@@ -1931,7 +1932,9 @@ extern void resync_after_online_grow(struct drbd_peer_device *);
|
|
extern void drbd_reconsider_queue_parameters(struct drbd_device *device,
|
|
struct drbd_backing_dev *bdev);
|
|
extern bool barrier_pending(struct drbd_resource *resource);
|
|
-extern enum drbd_state_rv drbd_set_role(struct drbd_resource *, enum drbd_role, bool, struct sk_buff *);
|
|
+extern enum drbd_state_rv
|
|
+drbd_set_role(struct drbd_resource *resource, enum drbd_role role, bool force, const char *tag,
|
|
+ struct sk_buff *reply_skb);
|
|
extern void conn_try_outdate_peer_async(struct drbd_connection *connection);
|
|
extern int drbd_maybe_khelper(struct drbd_device *, struct drbd_connection *, char *);
|
|
extern int drbd_create_peer_device_default_config(struct drbd_peer_device *peer_device);
|
|
@@ -1943,7 +1946,8 @@ extern int drbd_worker(struct drbd_thread *thi);
|
|
enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);
|
|
void drbd_resync_after_changed(struct drbd_device *device);
|
|
extern bool drbd_stable_sync_source_present(struct drbd_peer_device *, enum which_state);
|
|
-extern void drbd_start_resync(struct drbd_peer_device *, enum drbd_repl_state);
|
|
+extern void drbd_start_resync(struct drbd_peer_device *peer_device, enum drbd_repl_state side,
|
|
+ const char *tag);
|
|
extern void resume_next_sg(struct drbd_device *device);
|
|
extern void suspend_other_sg(struct drbd_device *device);
|
|
extern void drbd_resync_finished(struct drbd_peer_device *, enum drbd_disk_state);
|
|
diff --git a/drbd/drbd_main.c b/drbd/drbd_main.c
|
|
index 6bb618909aa0..4b0b967c2c97 100644
|
|
--- a/drbd/drbd_main.c
|
|
+++ b/drbd/drbd_main.c
|
|
@@ -2505,7 +2505,7 @@ static int try_to_promote(struct drbd_device *device, long timeout, bool ndelay)
|
|
unsigned long start = jiffies;
|
|
long t;
|
|
|
|
- rv = drbd_set_role(resource, R_PRIMARY, false, NULL);
|
|
+ rv = drbd_set_role(resource, R_PRIMARY, false, "auto-promote", NULL);
|
|
timeout -= jiffies - start;
|
|
|
|
if (ndelay || rv >= SS_SUCCESS || timeout <= 0) {
|
|
@@ -2854,7 +2854,7 @@ static void drbd_release(struct gendisk *gd, fmode_t mode)
|
|
open_rw_cnt == 0 &&
|
|
resource->role[NOW] == R_PRIMARY &&
|
|
!test_bit(EXPLICIT_PRIMARY, &resource->flags)) {
|
|
- rv = drbd_set_role(resource, R_SECONDARY, false, NULL);
|
|
+ rv = drbd_set_role(resource, R_SECONDARY, false, "auto-demote", NULL);
|
|
if (rv < SS_SUCCESS)
|
|
drbd_warn(resource, "Auto-demote failed: %s (%d)\n",
|
|
drbd_set_st_err_str(rv), rv);
|
|
@@ -2866,7 +2866,7 @@ static void drbd_release(struct gendisk *gd, fmode_t mode)
|
|
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE);
|
|
resource->fail_io[NEW] = false;
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "release");
|
|
}
|
|
|
|
/* if the open counts are 0, we free the whole list, otherwise we remove the specific pid */
|
|
@@ -3349,7 +3349,7 @@ static void wake_all_device_misc(struct drbd_resource *resource)
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
-int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts)
|
|
+int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts, const char *tag)
|
|
{
|
|
struct drbd_connection *connection;
|
|
cpumask_var_t new_cpu_mask;
|
|
@@ -3414,7 +3414,7 @@ int set_resource_options(struct drbd_resource *resource, struct res_opts *res_op
|
|
|
|
if (force_state_recalc) {
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE | CS_FORCE_RECALC);
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, tag);
|
|
}
|
|
|
|
if (wake_device_misc)
|
|
@@ -3491,7 +3491,7 @@ struct drbd_resource *drbd_create_resource(const char *name,
|
|
}
|
|
resource->pp_vacant = page_pool_count;
|
|
|
|
- if (set_resource_options(resource, res_opts))
|
|
+ if (set_resource_options(resource, res_opts, "create-resource"))
|
|
goto fail_free_pages;
|
|
|
|
list_add_tail_rcu(&resource->resources, &drbd_resources);
|
|
diff --git a/drbd/drbd_nl.c b/drbd/drbd_nl.c
|
|
index cb5cdb184824..b7e9e43312f9 100644
|
|
--- a/drbd/drbd_nl.c
|
|
+++ b/drbd/drbd_nl.c
|
|
@@ -768,7 +768,7 @@ static bool intentional_diskless(struct drbd_resource *resource)
|
|
return intentional_diskless;
|
|
}
|
|
|
|
-static bool conn_try_outdate_peer(struct drbd_connection *connection)
|
|
+static bool conn_try_outdate_peer(struct drbd_connection *connection, const char *tag)
|
|
{
|
|
struct drbd_resource *resource = connection->resource;
|
|
unsigned long last_reconnect_jif;
|
|
@@ -792,7 +792,7 @@ static bool conn_try_outdate_peer(struct drbd_connection *connection)
|
|
!(disk_state == D_DISKLESS && intentional_diskless(resource))) {
|
|
begin_state_change_locked(resource, CS_VERBOSE | CS_HARD);
|
|
__change_io_susp_fencing(connection, false);
|
|
- end_state_change_locked(resource);
|
|
+ end_state_change_locked(resource, tag);
|
|
read_unlock_irq(&resource->state_rwlock);
|
|
return false;
|
|
}
|
|
@@ -862,7 +862,7 @@ static bool conn_try_outdate_peer(struct drbd_connection *connection)
|
|
goto abort;
|
|
}
|
|
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, tag);
|
|
|
|
goto out;
|
|
abort:
|
|
@@ -875,7 +875,7 @@ static int _try_outdate_peer_async(void *data)
|
|
{
|
|
struct drbd_connection *connection = (struct drbd_connection *)data;
|
|
|
|
- conn_try_outdate_peer(connection);
|
|
+ conn_try_outdate_peer(connection, "outdate-async");
|
|
|
|
kref_debug_put(&connection->kref_debug, 4);
|
|
kref_put(&connection->kref, drbd_destroy_connection);
|
|
@@ -1014,7 +1014,8 @@ static bool wait_up_to_date(struct drbd_resource *resource)
|
|
}
|
|
|
|
enum drbd_state_rv
|
|
-drbd_set_role(struct drbd_resource *resource, enum drbd_role role, bool force, struct sk_buff *reply_skb)
|
|
+drbd_set_role(struct drbd_resource *resource, enum drbd_role role, bool force, const char *tag,
|
|
+ struct sk_buff *reply_skb)
|
|
{
|
|
struct drbd_device *device;
|
|
int vnr, try = 0;
|
|
@@ -1042,7 +1043,7 @@ retry:
|
|
err_str = NULL;
|
|
}
|
|
rv = stable_state_change(resource,
|
|
- change_role(resource, role, flags, &err_str));
|
|
+ change_role(resource, role, flags, tag, &err_str));
|
|
|
|
if (rv == SS_TIMEOUT || rv == SS_CONCURRENT_ST_CHG) {
|
|
long timeout = twopc_retry_timeout(resource, try);
|
|
@@ -1104,7 +1105,7 @@ retry:
|
|
if (device->disk_state[NOW] != D_CONSISTENT)
|
|
continue;
|
|
|
|
- if (conn_try_outdate_peer(connection))
|
|
+ if (conn_try_outdate_peer(connection, tag))
|
|
fenced_peers = true;
|
|
else
|
|
any_fencing_failed = true;
|
|
@@ -1140,7 +1141,7 @@ retry:
|
|
|
|
up(&resource->state_sem); /* Allow connect while fencing */
|
|
for_each_connection_ref(connection, im, resource) {
|
|
- bool outdated_peer = conn_try_outdate_peer(connection);
|
|
+ bool outdated_peer = conn_try_outdate_peer(connection, tag);
|
|
if (!outdated_peer && force) {
|
|
drbd_warn(connection, "Forced into split brain situation!\n");
|
|
flags |= CS_FP_LOCAL_UP_TO_DATE;
|
|
@@ -1331,7 +1332,9 @@ int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
|
|
new_role = info->genlhdr->cmd == DRBD_ADM_PRIMARY ? R_PRIMARY : R_SECONDARY;
|
|
rv = drbd_set_role(adm_ctx.resource,
|
|
new_role,
|
|
- parms.force, adm_ctx.reply_skb);
|
|
+ parms.force,
|
|
+ new_role == R_PRIMARY ? "primary" : "secondary",
|
|
+ adm_ctx.reply_skb);
|
|
|
|
if (new_role == R_PRIMARY) {
|
|
if (rv >= SS_SUCCESS)
|
|
@@ -3093,7 +3096,7 @@ int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
|
|
drbd_flush_workqueue(&resource->work);
|
|
|
|
rv = stable_state_change(resource,
|
|
- change_disk_state(device, D_ATTACHING, CS_VERBOSE | CS_SERIALIZE, NULL));
|
|
+ change_disk_state(device, D_ATTACHING, CS_VERBOSE | CS_SERIALIZE, "attach", NULL));
|
|
retcode = (enum drbd_ret_code)rv;
|
|
if (rv >= SS_SUCCESS)
|
|
update_resource_dagtag(resource, nbc);
|
|
@@ -3353,8 +3356,8 @@ int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
/* change_disk_state uses disk_state_from_md(device); in case D_NEGOTIATING not
|
|
necessary, and falls back to a local state change */
|
|
- rv = stable_state_change(resource,
|
|
- change_disk_state(device, D_NEGOTIATING, CS_VERBOSE | CS_SERIALIZE, NULL));
|
|
+ rv = stable_state_change(resource, change_disk_state(device,
|
|
+ D_NEGOTIATING, CS_VERBOSE | CS_SERIALIZE, "attach", NULL));
|
|
|
|
if (rv < SS_SUCCESS) {
|
|
if (rv == SS_CW_FAILED_BY_PEER)
|
|
@@ -3385,7 +3388,7 @@ int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
|
|
force_diskless_dec:
|
|
put_ldev(device);
|
|
force_diskless:
|
|
- change_disk_state(device, D_DISKLESS, CS_HARD, NULL);
|
|
+ change_disk_state(device, D_DISKLESS, CS_HARD, "attach", NULL);
|
|
fail:
|
|
mutex_unlock_cond(&resource->conf_update, &have_conf_update);
|
|
drbd_backing_dev_free(device, nbc);
|
|
@@ -3406,7 +3409,7 @@ static enum drbd_disk_state get_disk_state(struct drbd_device *device)
|
|
}
|
|
|
|
static int adm_detach(struct drbd_device *device, bool force, bool intentional_diskless,
|
|
- struct sk_buff *reply_skb)
|
|
+ const char *tag, struct sk_buff *reply_skb)
|
|
{
|
|
const char *err_str = NULL;
|
|
int ret, retcode;
|
|
@@ -3414,7 +3417,7 @@ static int adm_detach(struct drbd_device *device, bool force, bool intentional_d
|
|
device->device_conf.intentional_diskless = intentional_diskless;
|
|
if (force) {
|
|
set_bit(FORCE_DETACH, &device->flags);
|
|
- change_disk_state(device, D_DETACHING, CS_HARD, NULL);
|
|
+ change_disk_state(device, D_DETACHING, CS_HARD, tag, NULL);
|
|
retcode = SS_SUCCESS;
|
|
goto out;
|
|
}
|
|
@@ -3422,7 +3425,7 @@ static int adm_detach(struct drbd_device *device, bool force, bool intentional_d
|
|
drbd_suspend_io(device, READ_AND_WRITE); /* so no-one is stuck in drbd_al_begin_io */
|
|
retcode = stable_state_change(device->resource,
|
|
change_disk_state(device, D_DETACHING,
|
|
- CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE, &err_str));
|
|
+ CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE, tag, &err_str));
|
|
/* D_DETACHING will transition to DISKLESS. */
|
|
drbd_resume_io(device);
|
|
ret = wait_event_interruptible(device->misc_wait,
|
|
@@ -3473,7 +3476,7 @@ int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
mutex_lock(&adm_ctx.resource->adm_mutex);
|
|
retcode = (enum drbd_ret_code)adm_detach(adm_ctx.device, parms.force_detach,
|
|
- parms.intentional_diskless_detach, adm_ctx.reply_skb);
|
|
+ parms.intentional_diskless_detach, "detach", adm_ctx.reply_skb);
|
|
mutex_unlock(&adm_ctx.resource->adm_mutex);
|
|
|
|
out:
|
|
@@ -4385,7 +4388,7 @@ int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
|
|
drbd_md_mark_dirty(device);
|
|
}
|
|
|
|
- rv = change_cstate(connection, C_UNCONNECTED, CS_VERBOSE);
|
|
+ rv = change_cstate_tag(connection, C_UNCONNECTED, CS_VERBOSE, "connect", NULL);
|
|
drbd_adm_finish(&adm_ctx, info, rv);
|
|
return 0;
|
|
out:
|
|
@@ -4535,7 +4538,7 @@ int drbd_open_ro_count(struct drbd_resource *resource)
|
|
}
|
|
|
|
static enum drbd_state_rv conn_try_disconnect(struct drbd_connection *connection, bool force,
|
|
- struct sk_buff *reply_skb)
|
|
+ const char *tag, struct sk_buff *reply_skb)
|
|
{
|
|
struct drbd_resource *resource = connection->resource;
|
|
enum drbd_conn_state cstate;
|
|
@@ -4545,7 +4548,7 @@ static enum drbd_state_rv conn_try_disconnect(struct drbd_connection *connection
|
|
long t;
|
|
|
|
repeat:
|
|
- rv = change_cstate_es(connection, C_DISCONNECTING, flags, &err_str);
|
|
+ rv = change_cstate_tag(connection, C_DISCONNECTING, flags, tag, &err_str);
|
|
switch (rv) {
|
|
case SS_CW_FAILED_BY_PEER:
|
|
case SS_NEED_CONNECTION:
|
|
@@ -4571,7 +4574,7 @@ static enum drbd_state_rv conn_try_disconnect(struct drbd_connection *connection
|
|
break;
|
|
case SS_IS_DISKLESS:
|
|
case SS_LOWER_THAN_OUTDATED:
|
|
- rv = change_cstate(connection, C_DISCONNECTING, CS_HARD);
|
|
+ rv = change_cstate_tag(connection, C_DISCONNECTING, CS_HARD, tag, NULL);
|
|
break;
|
|
case SS_NO_QUORUM:
|
|
if (!(flags & CS_VERBOSE)) {
|
|
@@ -4597,7 +4600,7 @@ static enum drbd_state_rv conn_try_disconnect(struct drbd_connection *connection
|
|
|
|
/* this can only be called immediately after a successful
|
|
* peer_try_disconnect, within the same resource->adm_mutex */
|
|
-static void del_connection(struct drbd_connection *connection)
|
|
+static void del_connection(struct drbd_connection *connection, const char *tag)
|
|
{
|
|
struct drbd_resource *resource = connection->resource;
|
|
struct drbd_peer_device *peer_device;
|
|
@@ -4619,7 +4622,7 @@ static void del_connection(struct drbd_connection *connection)
|
|
* after drbd_receiver() returned. Typically, we should be
|
|
* C_STANDALONE already, now, and this becomes a no-op.
|
|
*/
|
|
- rv2 = change_cstate(connection, C_STANDALONE, CS_VERBOSE | CS_HARD);
|
|
+ rv2 = change_cstate_tag(connection, C_STANDALONE, CS_VERBOSE | CS_HARD, tag, NULL);
|
|
if (rv2 < SS_SUCCESS)
|
|
drbd_err(connection,
|
|
"unexpected rv2=%d in del_connection()\n",
|
|
@@ -4654,6 +4657,7 @@ static int adm_disconnect(struct sk_buff *skb, struct genl_info *info, bool dest
|
|
struct drbd_connection *connection;
|
|
enum drbd_state_rv rv;
|
|
enum drbd_ret_code retcode;
|
|
+ const char *tag = destroy ? "del-peer" : "disconnect";
|
|
|
|
retcode = drbd_adm_prepare(&adm_ctx, skb, info, DRBD_ADM_NEED_CONNECTION);
|
|
if (!adm_ctx.reply_skb)
|
|
@@ -4671,10 +4675,10 @@ static int adm_disconnect(struct sk_buff *skb, struct genl_info *info, bool dest
|
|
|
|
connection = adm_ctx.connection;
|
|
mutex_lock(&adm_ctx.resource->adm_mutex);
|
|
- rv = conn_try_disconnect(connection, parms.force_disconnect, adm_ctx.reply_skb);
|
|
+ rv = conn_try_disconnect(connection, parms.force_disconnect, tag, adm_ctx.reply_skb);
|
|
if (rv >= SS_SUCCESS && destroy) {
|
|
mutex_lock(&connection->resource->conf_update);
|
|
- del_connection(connection);
|
|
+ del_connection(connection, tag);
|
|
mutex_unlock(&connection->resource->conf_update);
|
|
}
|
|
if (rv < SS_SUCCESS)
|
|
@@ -4721,10 +4725,10 @@ void resync_after_online_grow(struct drbd_peer_device *peer_device)
|
|
|
|
if (!sync_source && connection->agreed_pro_version < 110) {
|
|
stable_change_repl_state(peer_device, L_WF_SYNC_UUID,
|
|
- CS_VERBOSE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_SERIALIZE, "online-grow");
|
|
return;
|
|
}
|
|
- drbd_start_resync(peer_device, sync_source ? L_SYNC_SOURCE : L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, sync_source ? L_SYNC_SOURCE : L_SYNC_TARGET, "online-grow");
|
|
}
|
|
|
|
sector_t drbd_local_max_size(struct drbd_device *device) __must_hold(local)
|
|
@@ -4956,7 +4960,7 @@ int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
|
|
goto fail;
|
|
}
|
|
|
|
- err = set_resource_options(adm_ctx.resource, &res_opts);
|
|
+ err = set_resource_options(adm_ctx.resource, &res_opts, "resource-options");
|
|
if (err) {
|
|
retcode = ERR_INVALID_REQUEST;
|
|
if (err == -ENOMEM)
|
|
@@ -4976,11 +4980,11 @@ static enum drbd_state_rv invalidate_resync(struct drbd_peer_device *peer_device
|
|
|
|
drbd_flush_workqueue(&peer_device->connection->sender_work);
|
|
|
|
- rv = change_repl_state(peer_device, L_STARTING_SYNC_T, CS_SERIALIZE);
|
|
+ rv = change_repl_state(peer_device, L_STARTING_SYNC_T, CS_SERIALIZE, "invalidate");
|
|
|
|
if (rv < SS_SUCCESS && rv != SS_NEED_CONNECTION)
|
|
rv = stable_change_repl_state(peer_device, L_STARTING_SYNC_T,
|
|
- CS_VERBOSE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_SERIALIZE, "invalidate");
|
|
|
|
wait_event_interruptible(resource->state_wait,
|
|
peer_device->repl_state[NOW] != L_STARTING_SYNC_T);
|
|
@@ -5005,7 +5009,7 @@ static enum drbd_state_rv invalidate_no_resync(struct drbd_device *device) __mus
|
|
}
|
|
}
|
|
__change_disk_state(device, D_INCONSISTENT);
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, "invalidate");
|
|
|
|
if (rv >= SS_SUCCESS) {
|
|
drbd_bitmap_io(device, &drbd_bmio_set_all_n_write,
|
|
@@ -5080,7 +5084,8 @@ int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
|
|
retcode = invalidate_resync(sync_from_peer_device);
|
|
} else {
|
|
retcode = change_repl_state(sync_from_peer_device, L_WF_BITMAP_T,
|
|
- CS_VERBOSE | CS_CLUSTER_WIDE | CS_WAIT_COMPLETE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_CLUSTER_WIDE | CS_WAIT_COMPLETE |
|
|
+ CS_SERIALIZE, "invalidate");
|
|
}
|
|
} else {
|
|
int retry = 3;
|
|
@@ -5103,7 +5108,8 @@ int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
|
|
}
|
|
retcode = change_repl_state(peer_device, L_WF_BITMAP_T,
|
|
CS_VERBOSE | CS_CLUSTER_WIDE |
|
|
- CS_WAIT_COMPLETE | CS_SERIALIZE);
|
|
+ CS_WAIT_COMPLETE | CS_SERIALIZE,
|
|
+ "invalidate");
|
|
}
|
|
if (retcode >= SS_SUCCESS)
|
|
goto out;
|
|
@@ -5140,13 +5146,15 @@ static int full_sync_from_peer(struct drbd_peer_device *peer_device)
|
|
struct drbd_resource *resource = device->resource;
|
|
int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
|
|
|
|
- retcode = stable_change_repl_state(peer_device, L_STARTING_SYNC_S, CS_SERIALIZE);
|
|
+ retcode = stable_change_repl_state(peer_device, L_STARTING_SYNC_S, CS_SERIALIZE,
|
|
+ "invalidate-remote");
|
|
if (retcode < SS_SUCCESS) {
|
|
if (retcode == SS_NEED_CONNECTION && resource->role[NOW] == R_PRIMARY) {
|
|
/* The peer will get a resync upon connect anyways.
|
|
* Just make that into a full resync. */
|
|
retcode = change_peer_disk_state(peer_device, D_INCONSISTENT,
|
|
- CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE,
|
|
+ "invalidate-remote");
|
|
if (retcode >= SS_SUCCESS) {
|
|
if (drbd_bitmap_io(device, &drbd_bmio_set_susp_al,
|
|
"set_n_write from invalidate_peer",
|
|
@@ -5155,7 +5163,7 @@ static int full_sync_from_peer(struct drbd_peer_device *peer_device)
|
|
}
|
|
} else {
|
|
retcode = stable_change_repl_state(peer_device, L_STARTING_SYNC_S,
|
|
- CS_VERBOSE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_SERIALIZE, "invalidate-remote");
|
|
}
|
|
}
|
|
|
|
@@ -5214,7 +5222,8 @@ int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
|
|
retcode = full_sync_from_peer(peer_device);
|
|
} else {
|
|
retcode = change_repl_state(peer_device, L_WF_BITMAP_S,
|
|
- CS_VERBOSE | CS_CLUSTER_WIDE | CS_WAIT_COMPLETE | CS_SERIALIZE);
|
|
+ CS_VERBOSE | CS_CLUSTER_WIDE | CS_WAIT_COMPLETE | CS_SERIALIZE,
|
|
+ "invalidate-remote");
|
|
}
|
|
drbd_resume_io(device);
|
|
|
|
@@ -5329,7 +5338,7 @@ int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
|
|
__change_io_susp_fencing(connection, false);
|
|
|
|
__change_io_susp_quorum(resource, false);
|
|
- retcode = end_state_change(resource, &irq_flags);
|
|
+ retcode = end_state_change(resource, &irq_flags, "resume-io");
|
|
drbd_resume_io(device);
|
|
mutex_unlock(&adm_ctx.resource->adm_mutex);
|
|
drbd_adm_finish(&adm_ctx, info, retcode);
|
|
@@ -5348,7 +5357,7 @@ int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
|
|
|
|
retcode = stable_state_change(adm_ctx.device->resource,
|
|
change_disk_state(adm_ctx.device, D_OUTDATED,
|
|
- CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE, NULL));
|
|
+ CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE, "outdate", NULL));
|
|
|
|
mutex_unlock(&adm_ctx.resource->adm_mutex);
|
|
drbd_adm_finish(&adm_ctx, info, retcode);
|
|
@@ -6010,7 +6019,7 @@ int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
|
|
drbd_suspend_io(device, READ_AND_WRITE);
|
|
wait_event(device->misc_wait, !atomic_read(&device->pending_bitmap_work.n));
|
|
rv = stable_change_repl_state(peer_device,
|
|
- L_VERIFY_S, CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE);
|
|
+ L_VERIFY_S, CS_VERBOSE | CS_WAIT_COMPLETE | CS_SERIALIZE, "verify");
|
|
drbd_resume_io(device);
|
|
|
|
mutex_unlock(&adm_ctx.resource->adm_mutex);
|
|
@@ -6082,7 +6091,7 @@ int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
|
|
unsigned long irq_flags;
|
|
begin_state_change(device->resource, &irq_flags, CS_VERBOSE);
|
|
__change_disk_state(device, D_UP_TO_DATE);
|
|
- end_state_change(device->resource, &irq_flags);
|
|
+ end_state_change(device->resource, &irq_flags, "new-c-uuid");
|
|
|
|
for_each_peer_device(peer_device, device) {
|
|
if (NODE_MASK(peer_device->node_id) & nodes) {
|
|
@@ -6122,7 +6131,7 @@ int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
|
|
if (NODE_MASK(peer_device->node_id) & diskful)
|
|
__change_peer_disk_state(peer_device, D_UP_TO_DATE);
|
|
}
|
|
- end_state_change(device->resource, &irq_flags);
|
|
+ end_state_change(device->resource, &irq_flags, "new-c-uuid");
|
|
}
|
|
|
|
drbd_md_sync_if_dirty(device);
|
|
@@ -6353,7 +6362,7 @@ static enum drbd_ret_code adm_del_minor(struct drbd_device *device)
|
|
|
|
for_each_peer_device_ref(peer_device, im, device)
|
|
stable_change_repl_state(peer_device, L_OFF,
|
|
- CS_VERBOSE | CS_WAIT_COMPLETE);
|
|
+ CS_VERBOSE | CS_WAIT_COMPLETE, "del-minor");
|
|
|
|
/* If drbd_ldev_destroy() is pending, wait for it to run before
|
|
* unregistering the device. */
|
|
@@ -6465,7 +6474,7 @@ int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
|
|
mutex_lock(&resource->adm_mutex);
|
|
set_bit(DOWN_IN_PROGRESS, &resource->flags);
|
|
/* demote */
|
|
- retcode = drbd_set_role(resource, R_SECONDARY, false, adm_ctx.reply_skb);
|
|
+ retcode = drbd_set_role(resource, R_SECONDARY, false, "down", adm_ctx.reply_skb);
|
|
if (retcode < SS_SUCCESS) {
|
|
opener_info(adm_ctx.resource, adm_ctx.reply_skb, retcode);
|
|
goto out;
|
|
@@ -6474,10 +6483,10 @@ int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
|
|
for_each_connection_ref(connection, im, resource) {
|
|
retcode = SS_SUCCESS;
|
|
if (connection->cstate[NOW] > C_STANDALONE)
|
|
- retcode = conn_try_disconnect(connection, 0, adm_ctx.reply_skb);
|
|
+ retcode = conn_try_disconnect(connection, 0, "down", adm_ctx.reply_skb);
|
|
if (retcode >= SS_SUCCESS) {
|
|
mutex_lock(&resource->conf_update);
|
|
- del_connection(connection);
|
|
+ del_connection(connection, "down");
|
|
mutex_unlock(&resource->conf_update);
|
|
} else {
|
|
kref_debug_put(&connection->kref_debug, 13);
|
|
@@ -6491,7 +6500,7 @@ int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
|
|
idr_for_each_entry(&resource->devices, device, i) {
|
|
kref_get(&device->kref);
|
|
rcu_read_unlock();
|
|
- retcode = adm_detach(device, 0, 0, adm_ctx.reply_skb);
|
|
+ retcode = adm_detach(device, 0, 0, "down", adm_ctx.reply_skb);
|
|
mutex_lock(&resource->conf_update);
|
|
ret = adm_del_minor(device);
|
|
mutex_unlock(&resource->conf_update);
|
|
diff --git a/drbd/drbd_receiver.c b/drbd/drbd_receiver.c
|
|
index 223353b1081c..0c3ab0fd486c 100644
|
|
--- a/drbd/drbd_receiver.c
|
|
+++ b/drbd/drbd_receiver.c
|
|
@@ -920,7 +920,7 @@ static void apply_local_state_change(struct drbd_connection *connection, enum ao
|
|
resource->role[NEW] = R_SECONDARY;
|
|
}
|
|
}
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "connect-failed");
|
|
}
|
|
|
|
static int connect_work(struct drbd_work *work, int cancel)
|
|
@@ -945,8 +945,9 @@ static int connect_work(struct drbd_work *work, int cancel)
|
|
rv = SS_CONCURRENT_ST_CHG;
|
|
break;
|
|
}
|
|
- rv = change_cstate(connection, C_CONNECTED, CS_SERIALIZE |
|
|
- CS_ALREADY_SERIALIZED | CS_VERBOSE | CS_DONT_RETRY);
|
|
+ rv = change_cstate_tag(connection, C_CONNECTED, CS_SERIALIZE |
|
|
+ CS_ALREADY_SERIALIZED | CS_VERBOSE | CS_DONT_RETRY,
|
|
+ "connected", NULL);
|
|
up(&resource->state_sem);
|
|
if (rv != SS_PRIMARY_READER)
|
|
break;
|
|
@@ -1011,7 +1012,8 @@ static bool conn_connect(struct drbd_connection *connection)
|
|
start:
|
|
have_mutex = false;
|
|
clear_bit(DISCONNECT_EXPECTED, &connection->flags);
|
|
- if (change_cstate(connection, C_CONNECTING, CS_VERBOSE) < SS_SUCCESS) {
|
|
+ if (change_cstate_tag(connection, C_CONNECTING, CS_VERBOSE, "connecting", NULL)
|
|
+ < SS_SUCCESS) {
|
|
/* We do not have a network config. */
|
|
return false;
|
|
}
|
|
@@ -3697,7 +3699,8 @@ static enum sync_strategy drbd_asb_recover_1p(struct drbd_peer_device *peer_devi
|
|
/* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
|
|
* we might be here in L_OFF which is transient.
|
|
* we do not need to wait for the after state change work either. */
|
|
- rv2 = change_role(resource, R_SECONDARY, CS_VERBOSE, NULL);
|
|
+ rv2 = change_role(resource, R_SECONDARY, CS_VERBOSE,
|
|
+ "after-sb-1pri", NULL);
|
|
if (rv2 != SS_SUCCESS) {
|
|
drbd_maybe_khelper(device, connection, "pri-lost-after-sb");
|
|
} else {
|
|
@@ -3750,7 +3753,8 @@ static enum sync_strategy drbd_asb_recover_2p(struct drbd_peer_device *peer_devi
|
|
/* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
|
|
* we might be here in L_OFF which is transient.
|
|
* we do not need to wait for the after state change work either. */
|
|
- rv2 = change_role(device->resource, R_SECONDARY, CS_VERBOSE, NULL);
|
|
+ rv2 = change_role(device->resource, R_SECONDARY, CS_VERBOSE,
|
|
+ "after-sb-2pri", NULL);
|
|
if (rv2 != SS_SUCCESS) {
|
|
drbd_maybe_khelper(device, connection, "pri-lost-after-sb");
|
|
} else {
|
|
@@ -5500,6 +5504,7 @@ static void drbd_resync(struct drbd_peer_device *peer_device,
|
|
enum sync_rule rule;
|
|
int peer_node_id;
|
|
enum drbd_state_rv rv;
|
|
+ const char *tag = reason == AFTER_UNSTABLE ? "after-unstable" : "diskless-primary";
|
|
|
|
strategy = drbd_handshake(peer_device, &rule, &peer_node_id, reason == DISKLESS_PRIMARY);
|
|
if (strategy == SPLIT_BRAIN_AUTO_RECOVER && reason == AFTER_UNSTABLE)
|
|
@@ -5529,11 +5534,11 @@ static void drbd_resync(struct drbd_peer_device *peer_device,
|
|
as well. */
|
|
drbd_info(peer_device, "Upgrading local disk to %s after unstable/weak (and no resync).\n",
|
|
drbd_disk_str(peer_disk_state));
|
|
- change_disk_state(peer_device->device, peer_disk_state, CS_VERBOSE, NULL);
|
|
+ change_disk_state(peer_device->device, peer_disk_state, CS_VERBOSE, tag, NULL);
|
|
return;
|
|
}
|
|
|
|
- rv = change_repl_state(peer_device, new_repl_state, CS_VERBOSE);
|
|
+ rv = change_repl_state(peer_device, new_repl_state, CS_VERBOSE, tag);
|
|
if ((rv == SS_NOTHING_TO_DO || rv == SS_RESYNC_RUNNING) &&
|
|
(new_repl_state == L_WF_BITMAP_S || new_repl_state == L_WF_BITMAP_T)) {
|
|
/* Those events might happen very quickly. In case we are still processing
|
|
@@ -5633,7 +5638,7 @@ static int __receive_uuids(struct drbd_peer_device *peer_device, u64 node_mask)
|
|
begin_state_change(device->resource, &irq_flags, CS_VERBOSE);
|
|
__change_disk_state(device, D_UP_TO_DATE);
|
|
__change_peer_disk_state(peer_device, D_UP_TO_DATE);
|
|
- end_state_change(device->resource, &irq_flags);
|
|
+ end_state_change(device->resource, &irq_flags, "skip-initial-sync");
|
|
updated_uuids = 1;
|
|
propagate_skip_initial_to_diskless(device);
|
|
}
|
|
@@ -5668,7 +5673,7 @@ static int __receive_uuids(struct drbd_peer_device *peer_device, u64 node_mask)
|
|
if (device->disk_state[NOW] == D_DISKLESS && uuid_match &&
|
|
peer_device->disk_state[NOW] == D_CONSISTENT) {
|
|
drbd_info(peer_device, "Peer is on same UUID now\n");
|
|
- change_peer_disk_state(peer_device, D_UP_TO_DATE, CS_VERBOSE);
|
|
+ change_peer_disk_state(peer_device, D_UP_TO_DATE, CS_VERBOSE, "receive-uuids");
|
|
}
|
|
|
|
if (updated_uuids)
|
|
@@ -5855,7 +5860,7 @@ static void check_resync_source(struct drbd_device *device, u64 weak_nodes)
|
|
return;
|
|
abort:
|
|
drbd_info(peer_device, "My sync source became a weak node, aborting resync!\n");
|
|
- change_repl_state(peer_device, L_ESTABLISHED, CS_VERBOSE);
|
|
+ change_repl_state(peer_device, L_ESTABLISHED, CS_VERBOSE, "abort-resync");
|
|
drbd_flush_workqueue(&device->resource->work);
|
|
|
|
wait_event_interruptible(device->misc_wait,
|
|
@@ -6091,7 +6096,7 @@ retry:
|
|
|
|
if (is_connect && connection->agreed_pro_version >= 117)
|
|
apply_connect(connection, (flags & CS_PREPARED) && !abort);
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, "remote");
|
|
out:
|
|
|
|
if ((rv == SS_NO_UP_TO_DATE_DISK && resource->role[NOW] != R_PRIMARY) ||
|
|
@@ -6144,7 +6149,7 @@ change_peer_device_state(struct drbd_peer_device *peer_device,
|
|
rv = __change_connection_state(connection, mask, val, flags);
|
|
if (rv < SS_SUCCESS)
|
|
goto fail;
|
|
- rv = end_state_change(connection->resource, &irq_flags);
|
|
+ rv = end_state_change(connection->resource, &irq_flags, "remote");
|
|
out:
|
|
return rv;
|
|
fail:
|
|
@@ -6375,7 +6380,7 @@ far_away_change(struct drbd_connection *connection,
|
|
}
|
|
|
|
/* even if no outdate happens, CS_FORCE_RECALC might be set here */
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, "far-away");
|
|
}
|
|
|
|
static void handle_neighbor_demotion(struct drbd_connection *connection,
|
|
@@ -6630,17 +6635,18 @@ cont:
|
|
/* peer is secondary */
|
|
resync = L_SYNC_SOURCE;
|
|
}
|
|
- drbd_start_resync(peer_device, resync);
|
|
+ drbd_start_resync(peer_device, resync, "resize");
|
|
} else {
|
|
if (tr->diskful_primary_nodes & NODE_MASK(peer_device->node_id))
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET,
|
|
+ "resize");
|
|
/* else no resync */
|
|
}
|
|
} else {
|
|
if (resource->twopc_parent_nodes & NODE_MASK(peer_device->node_id))
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "resize");
|
|
else if (nodes_to_reach & NODE_MASK(peer_device->node_id))
|
|
- drbd_start_resync(peer_device, L_SYNC_SOURCE);
|
|
+ drbd_start_resync(peer_device, L_SYNC_SOURCE, "resize");
|
|
/* else no resync */
|
|
}
|
|
}
|
|
@@ -7101,7 +7107,7 @@ void drbd_try_to_get_resynced(struct drbd_device *device)
|
|
peer_device = best_peer_device;
|
|
|
|
if (best_strategy == NO_SYNC) {
|
|
- change_disk_state(device, D_UP_TO_DATE, CS_VERBOSE, NULL);
|
|
+ change_disk_state(device, D_UP_TO_DATE, CS_VERBOSE, "get-resync", NULL);
|
|
} else if (peer_device) {
|
|
drbd_resync(peer_device, DISKLESS_PRIMARY);
|
|
drbd_send_uuids(peer_device, UUID_FLAG_RESYNC | UUID_FLAG_DISKLESS_PRIMARY, 0);
|
|
@@ -7225,7 +7231,7 @@ static void diskless_with_peers_different_current_uuids(struct drbd_peer_device
|
|
CS_VERBOSE | CS_HARD | CS_FS_IGN_OPENERS);
|
|
resource->role[NEW] = R_SECONDARY;
|
|
/* resource->fail_io[NEW] gets set via CS_FS_IGN_OPENERS */
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "peer-state");
|
|
}
|
|
set_bit(CONN_HANDSHAKE_RETRY, &connection->flags);
|
|
} else if (data_successor && resource->role[NOW] == R_SECONDARY) {
|
|
@@ -7278,7 +7284,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
|
|
if (peer_state.role == R_SECONDARY) {
|
|
begin_state_change(resource, &irq_flags, CS_HARD | CS_VERBOSE);
|
|
__change_peer_role(connection, R_SECONDARY);
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, "peer-state");
|
|
if (rv < SS_SUCCESS)
|
|
goto fail;
|
|
}
|
|
@@ -7374,7 +7380,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
|
|
/* Start resync after AHEAD/BEHIND */
|
|
if (connection->agreed_pro_version >= 110 &&
|
|
peer_state.conn == L_SYNC_SOURCE && old_peer_state.conn == L_BEHIND) {
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "resync-after-behind");
|
|
return 0;
|
|
}
|
|
|
|
@@ -7519,7 +7525,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
|
|
begin_state_change(resource, &irq_flags, CS_HARD);
|
|
__change_cstate(connection, C_PROTOCOL_ERROR);
|
|
__change_io_susp_user(resource, false);
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "abort-connect");
|
|
return -EIO;
|
|
}
|
|
|
|
@@ -7581,7 +7587,7 @@ static int receive_state(struct drbd_connection *connection, struct packet_info
|
|
if (repl_state[OLD] < L_ESTABLISHED && repl_state[NEW] >= L_ESTABLISHED)
|
|
resource->state_change_flags |= CS_HARD;
|
|
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, "peer-state");
|
|
new_repl_state = peer_device->repl_state[NOW];
|
|
|
|
if (rv < SS_SUCCESS)
|
|
@@ -7635,7 +7641,7 @@ static int receive_sync_uuid(struct drbd_connection *connection, struct packet_i
|
|
_drbd_uuid_set_bitmap(peer_device, 0UL);
|
|
|
|
drbd_print_uuids(peer_device, "updated sync uuid");
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "peer-sync-uuid");
|
|
|
|
put_ldev(device);
|
|
} else
|
|
@@ -7935,17 +7941,18 @@ static int receive_bitmap(struct drbd_connection *connection, struct packet_info
|
|
/* We have entered drbd_start_resync() since starting the bitmap exchange. */
|
|
drbd_warn(peer_device, "Received bitmap more than once; ignoring\n");
|
|
} else if (repl_state == L_WF_BITMAP_S) {
|
|
- drbd_start_resync(peer_device, L_SYNC_SOURCE);
|
|
+ drbd_start_resync(peer_device, L_SYNC_SOURCE, "receive-bitmap");
|
|
} else if (repl_state == L_WF_BITMAP_T) {
|
|
if (connection->agreed_pro_version < 110) {
|
|
enum drbd_state_rv rv;
|
|
|
|
/* Omit CS_WAIT_COMPLETE and CS_SERIALIZE with this state
|
|
* transition to avoid deadlocks. */
|
|
- rv = stable_change_repl_state(peer_device, L_WF_SYNC_UUID, CS_VERBOSE);
|
|
+ rv = stable_change_repl_state(peer_device, L_WF_SYNC_UUID, CS_VERBOSE,
|
|
+ "receive-bitmap");
|
|
D_ASSERT(device, rv == SS_SUCCESS);
|
|
} else {
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "receive-bitmap");
|
|
}
|
|
} else {
|
|
/* admin may have requested C_DISCONNECTING,
|
|
@@ -8139,7 +8146,7 @@ static int receive_peer_dagtag(struct drbd_connection *connection, struct packet
|
|
__change_repl_state(peer_device, new_repl_state);
|
|
set_bit(RECONCILIATION_RESYNC, &peer_device->flags);
|
|
}
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, "receive-peer-dagtag");
|
|
if (rv == SS_SUCCESS)
|
|
drbd_info(connection, "Reconciliation resync because \'%s\' disappeared. (o=%d)\n",
|
|
lost_peer->transport.net_conf->name, (int)dagtag_offset);
|
|
@@ -8248,7 +8255,8 @@ static int receive_current_uuid(struct drbd_connection *connection, struct packe
|
|
if (resource->remote_state_change)
|
|
set_bit(OUTDATE_ON_2PC_COMMIT, &device->flags);
|
|
else
|
|
- change_disk_state(device, D_OUTDATED, CS_VERBOSE, NULL);
|
|
+ change_disk_state(device, D_OUTDATED, CS_VERBOSE,
|
|
+ "receive-current-uuid", NULL);
|
|
}
|
|
put_ldev(device);
|
|
} else if (device->disk_state[NOW] == D_DISKLESS && resource->role[NOW] == R_PRIMARY) {
|
|
@@ -8328,7 +8336,7 @@ static int receive_rs_deallocated(struct drbd_connection *connection, struct pac
|
|
|
|
static int receive_disconnect(struct drbd_connection *connection, struct packet_info *pi)
|
|
{
|
|
- change_cstate(connection, C_DISCONNECTING, CS_HARD);
|
|
+ change_cstate_tag(connection, C_DISCONNECTING, CS_HARD, "receive-disconnect", NULL);
|
|
return 0;
|
|
}
|
|
|
|
@@ -8594,7 +8602,7 @@ static void conn_disconnect(struct drbd_connection *connection)
|
|
* Usually we should be in some network failure state already,
|
|
* but just in case we are not, we fix it up here.
|
|
*/
|
|
- change_cstate(connection, C_NETWORK_FAILURE, CS_HARD);
|
|
+ change_cstate_tag(connection, C_NETWORK_FAILURE, CS_HARD, "disconnected", NULL);
|
|
|
|
del_connect_timer(connection);
|
|
|
|
@@ -8707,10 +8715,11 @@ static void conn_disconnect(struct drbd_connection *connection)
|
|
/* drbd_receiver() has to be restarted after it returns */
|
|
drbd_thread_restart_nowait(&connection->receiver);
|
|
}
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "disconnected");
|
|
|
|
if (oc == C_DISCONNECTING)
|
|
- change_cstate(connection, C_STANDALONE, CS_VERBOSE | CS_HARD | CS_LOCAL_ONLY);
|
|
+ change_cstate_tag(connection, C_STANDALONE, CS_VERBOSE | CS_HARD | CS_LOCAL_ONLY,
|
|
+ "disconnected", NULL);
|
|
}
|
|
|
|
/*
|
|
diff --git a/drbd/drbd_req.c b/drbd/drbd_req.c
|
|
index af2ae66f51b5..41950e46ec27 100644
|
|
--- a/drbd/drbd_req.c
|
|
+++ b/drbd/drbd_req.c
|
|
@@ -2688,7 +2688,7 @@ void request_timer_fn(struct timer_list *t)
|
|
continue;
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE | CS_HARD);
|
|
__change_cstate(connection, C_TIMEOUT);
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "timeout");
|
|
kref_put(&connection->kref, drbd_destroy_connection);
|
|
}
|
|
|
|
@@ -2723,7 +2723,7 @@ void drbd_handle_io_error_(struct drbd_device *device,
|
|
if (device->disk_state[NOW] > D_INCONSISTENT) {
|
|
begin_state_change_locked(device->resource, CS_HARD);
|
|
__change_disk_state(device, D_INCONSISTENT);
|
|
- end_state_change_locked(device->resource);
|
|
+ end_state_change_locked(device->resource, "local-io-error");
|
|
}
|
|
break;
|
|
}
|
|
@@ -2740,7 +2740,7 @@ void drbd_handle_io_error_(struct drbd_device *device,
|
|
if (device->disk_state[NOW] > D_FAILED) {
|
|
begin_state_change_locked(device->resource, CS_HARD);
|
|
__change_disk_state(device, D_FAILED);
|
|
- end_state_change_locked(device->resource);
|
|
+ end_state_change_locked(device->resource, "local-io-error");
|
|
drbd_err(device,
|
|
"Local IO failed in %s. Detaching...\n", where);
|
|
}
|
|
diff --git a/drbd/drbd_sender.c b/drbd/drbd_sender.c
|
|
index 93a460dae190..0beeb5f3cb54 100644
|
|
--- a/drbd/drbd_sender.c
|
|
+++ b/drbd/drbd_sender.c
|
|
@@ -472,7 +472,7 @@ int w_resync_timer(struct drbd_work *w, int cancel)
|
|
unsigned long irq_flags;
|
|
begin_state_change(resource, &irq_flags, 0);
|
|
peer_device->resync_active[NEW] = false;
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "resync-inactive");
|
|
}
|
|
break;
|
|
}
|
|
@@ -1155,7 +1155,7 @@ static void resync_again(struct drbd_device *device, u64 source_m, u64 target_m)
|
|
peer_device->resync_again--;
|
|
begin_state_change_locked(device->resource, CS_VERBOSE);
|
|
__change_repl_state(peer_device, new_repl_state);
|
|
- end_state_change_locked(device->resource);
|
|
+ end_state_change_locked(device->resource, "resync-again");
|
|
}
|
|
}
|
|
}
|
|
@@ -1225,7 +1225,7 @@ found:
|
|
}
|
|
|
|
drbd_send_uuids(peer_device, 0, 0);
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "resync-from-primary");
|
|
}
|
|
|
|
static void queue_resync_finished(struct drbd_peer_device *peer_device, enum drbd_disk_state new_peer_disk_state)
|
|
@@ -1428,7 +1428,7 @@ void drbd_resync_finished(struct drbd_peer_device *peer_device,
|
|
}
|
|
|
|
out_unlock:
|
|
- end_state_change_locked(device->resource);
|
|
+ end_state_change_locked(device->resource, "resync-finished");
|
|
|
|
put_ldev(device);
|
|
|
|
@@ -1920,7 +1920,8 @@ static bool drbd_pause_after(struct drbd_device *device)
|
|
if (!__drbd_may_sync_now(other_peer_device))
|
|
__change_resync_susp_dependency(other_peer_device, true);
|
|
}
|
|
- if (end_state_change_locked(other_device->resource) != SS_NOTHING_TO_DO)
|
|
+ if (end_state_change_locked(other_device->resource, "resync-after") !=
|
|
+ SS_NOTHING_TO_DO)
|
|
changed = true;
|
|
}
|
|
rcu_read_unlock();
|
|
@@ -1957,7 +1958,8 @@ static bool drbd_resume_next(struct drbd_device *device)
|
|
__drbd_may_sync_now(other_peer_device))
|
|
__change_resync_susp_dependency(other_peer_device, false);
|
|
}
|
|
- if (end_state_change_locked(other_device->resource) != SS_NOTHING_TO_DO)
|
|
+ if (end_state_change_locked(other_device->resource, "resync-after") !=
|
|
+ SS_NOTHING_TO_DO)
|
|
changed = true;
|
|
}
|
|
rcu_read_unlock();
|
|
@@ -2125,7 +2127,7 @@ static void do_start_resync(struct drbd_peer_device *peer_device)
|
|
return;
|
|
}
|
|
|
|
- drbd_start_resync(peer_device, peer_device->start_resync_side);
|
|
+ drbd_start_resync(peer_device, peer_device->start_resync_side, "postponed-resync");
|
|
clear_bit(AHEAD_TO_SYNC_SOURCE, &peer_device->flags);
|
|
}
|
|
|
|
@@ -2149,7 +2151,7 @@ static void handle_congestion(struct drbd_peer_device *peer_device)
|
|
else if (on_congestion == OC_DISCONNECT)
|
|
__change_cstate(peer_device->connection, C_DISCONNECTING);
|
|
}
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "congestion");
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
@@ -2163,7 +2165,8 @@ static void handle_congestion(struct drbd_peer_device *peer_device)
|
|
* This function might bring you directly into one of the
|
|
* C_PAUSED_SYNC_* states.
|
|
*/
|
|
-void drbd_start_resync(struct drbd_peer_device *peer_device, enum drbd_repl_state side)
|
|
+void drbd_start_resync(struct drbd_peer_device *peer_device, enum drbd_repl_state side,
|
|
+ const char *tag)
|
|
{
|
|
struct drbd_device *device = peer_device->device;
|
|
struct drbd_connection *connection = peer_device->connection;
|
|
@@ -2258,7 +2261,7 @@ skip_helper:
|
|
init_resync_stable_bits(peer_device);
|
|
finished_resync_pdsk = peer_device->resync_finished_pdsk;
|
|
peer_device->resync_finished_pdsk = D_UNKNOWN;
|
|
- r = end_state_change_locked(device->resource);
|
|
+ r = end_state_change_locked(device->resource, tag);
|
|
repl_state = peer_device->repl_state[NOW];
|
|
|
|
if (repl_state < L_ESTABLISHED)
|
|
@@ -2339,7 +2342,7 @@ static void go_diskless(struct drbd_device *device)
|
|
}
|
|
|
|
drbd_md_sync_if_dirty(device);
|
|
- change_disk_state(device, D_DISKLESS, CS_HARD, NULL);
|
|
+ change_disk_state(device, D_DISKLESS, CS_HARD, "go-diskless", NULL);
|
|
}
|
|
|
|
static int do_md_sync(struct drbd_device *device)
|
|
diff --git a/drbd/drbd_state.c b/drbd/drbd_state.c
|
|
index 23eab7f867aa..22cd134be962 100644
|
|
--- a/drbd/drbd_state.c
|
|
+++ b/drbd/drbd_state.c
|
|
@@ -74,8 +74,8 @@ struct change_disk_state_context {
|
|
static bool lost_contact_to_peer_data(enum drbd_disk_state *peer_disk_state);
|
|
static bool peer_returns_diskless(struct drbd_peer_device *peer_device,
|
|
enum drbd_disk_state os, enum drbd_disk_state ns);
|
|
-static void print_state_change(struct drbd_resource *resource, const char *prefix);
|
|
-static void finish_state_change(struct drbd_resource *);
|
|
+static void print_state_change(struct drbd_resource *resource, const char *prefix, const char *tag);
|
|
+static void finish_state_change(struct drbd_resource *, const char *tag);
|
|
static int w_after_state_change(struct drbd_work *w, int unused);
|
|
static enum drbd_state_rv is_valid_soft_transition(struct drbd_resource *);
|
|
static enum drbd_state_rv is_valid_transition(struct drbd_resource *resource);
|
|
@@ -774,7 +774,7 @@ static void queue_after_state_change_work(struct drbd_resource *resource,
|
|
}
|
|
|
|
static enum drbd_state_rv ___end_state_change(struct drbd_resource *resource, struct completion *done,
|
|
- enum drbd_state_rv rv)
|
|
+ enum drbd_state_rv rv, const char *tag)
|
|
{
|
|
enum chg_state_flags flags = resource->state_change_flags;
|
|
struct drbd_connection *connection;
|
|
@@ -793,14 +793,14 @@ static enum drbd_state_rv ___end_state_change(struct drbd_resource *resource, st
|
|
if (flags & CS_VERBOSE) {
|
|
drbd_err(resource, "State change failed: %s (%d)\n",
|
|
drbd_set_st_err_str(rv), rv);
|
|
- print_state_change(resource, "Failed: ");
|
|
+ print_state_change(resource, "Failed: ", tag);
|
|
}
|
|
goto out;
|
|
}
|
|
if (flags & CS_PREPARE)
|
|
goto out;
|
|
|
|
- finish_state_change(resource);
|
|
+ finish_state_change(resource, tag);
|
|
update_members(resource);
|
|
|
|
/* Check whether we are establishing a connection before applying the change. */
|
|
@@ -939,9 +939,9 @@ void begin_state_change_locked(struct drbd_resource *resource, enum chg_state_fl
|
|
__begin_state_change(resource);
|
|
}
|
|
|
|
-enum drbd_state_rv end_state_change_locked(struct drbd_resource *resource)
|
|
+enum drbd_state_rv end_state_change_locked(struct drbd_resource *resource, const char *tag)
|
|
{
|
|
- return ___end_state_change(resource, NULL, SS_SUCCESS);
|
|
+ return ___end_state_change(resource, NULL, SS_SUCCESS, tag);
|
|
}
|
|
|
|
void begin_state_change(struct drbd_resource *resource, unsigned long *irq_flags, enum chg_state_flags flags)
|
|
@@ -952,7 +952,8 @@ void begin_state_change(struct drbd_resource *resource, unsigned long *irq_flags
|
|
|
|
static enum drbd_state_rv __end_state_change(struct drbd_resource *resource,
|
|
unsigned long *irq_flags,
|
|
- enum drbd_state_rv rv)
|
|
+ enum drbd_state_rv rv,
|
|
+ const char *tag)
|
|
{
|
|
enum chg_state_flags flags = resource->state_change_flags;
|
|
struct completion __done, *done = NULL;
|
|
@@ -961,26 +962,27 @@ static enum drbd_state_rv __end_state_change(struct drbd_resource *resource,
|
|
done = &__done;
|
|
init_completion(done);
|
|
}
|
|
- rv = ___end_state_change(resource, done, rv);
|
|
+ rv = ___end_state_change(resource, done, rv, tag);
|
|
__state_change_unlock(resource, irq_flags, rv >= SS_SUCCESS ? done : NULL);
|
|
return rv;
|
|
}
|
|
|
|
-enum drbd_state_rv end_state_change(struct drbd_resource *resource, unsigned long *irq_flags)
|
|
+enum drbd_state_rv end_state_change(struct drbd_resource *resource, unsigned long *irq_flags,
|
|
+ const char *tag)
|
|
{
|
|
- return __end_state_change(resource, irq_flags, SS_SUCCESS);
|
|
+ return __end_state_change(resource, irq_flags, SS_SUCCESS, tag);
|
|
}
|
|
|
|
void abort_state_change(struct drbd_resource *resource, unsigned long *irq_flags)
|
|
{
|
|
resource->state_change_flags &= ~CS_VERBOSE;
|
|
- __end_state_change(resource, irq_flags, SS_UNKNOWN_ERROR);
|
|
+ __end_state_change(resource, irq_flags, SS_UNKNOWN_ERROR, NULL);
|
|
}
|
|
|
|
void abort_state_change_locked(struct drbd_resource *resource)
|
|
{
|
|
resource->state_change_flags &= ~CS_VERBOSE;
|
|
- ___end_state_change(resource, NULL, SS_UNKNOWN_ERROR);
|
|
+ ___end_state_change(resource, NULL, SS_UNKNOWN_ERROR, NULL);
|
|
}
|
|
|
|
static void begin_remote_state_change(struct drbd_resource *resource, unsigned long *irq_flags)
|
|
@@ -1159,15 +1161,19 @@ static int scnprintf_io_suspend_flags(char *buffer, size_t size,
|
|
return b - buffer;
|
|
}
|
|
|
|
-static void print_state_change(struct drbd_resource *resource, const char *prefix)
|
|
+static void print_state_change(struct drbd_resource *resource, const char *prefix, const char *tag)
|
|
{
|
|
char buffer[150], *b, *end = buffer + sizeof(buffer);
|
|
+ char tag_buffer[30] = "";
|
|
struct drbd_connection *connection;
|
|
struct drbd_device *device;
|
|
enum drbd_role *role = resource->role;
|
|
bool *fail_io = resource->fail_io;
|
|
int vnr;
|
|
|
|
+ if (tag)
|
|
+ scnprintf(tag_buffer, 30, " [%s]", tag);
|
|
+
|
|
b = buffer;
|
|
if (role[OLD] != role[NEW])
|
|
b += scnprintf(b, end - b, "role( %s -> %s ) ",
|
|
@@ -1186,7 +1192,7 @@ static void print_state_change(struct drbd_resource *resource, const char *prefi
|
|
fail_io[NEW] ? "yes" : "no");
|
|
if (b != buffer) {
|
|
*(b-1) = 0;
|
|
- drbd_info(resource, "%s%s\n", prefix, buffer);
|
|
+ drbd_info(resource, "%s%s%s\n", prefix, buffer, tag_buffer);
|
|
}
|
|
|
|
for_each_connection(connection, resource) {
|
|
@@ -1205,7 +1211,7 @@ static void print_state_change(struct drbd_resource *resource, const char *prefi
|
|
|
|
if (b != buffer) {
|
|
*(b-1) = 0;
|
|
- drbd_info(connection, "%s%s\n", prefix, buffer);
|
|
+ drbd_info(connection, "%s%s%s\n", prefix, buffer, tag_buffer);
|
|
}
|
|
}
|
|
|
|
@@ -1225,7 +1231,7 @@ static void print_state_change(struct drbd_resource *resource, const char *prefi
|
|
have_quorum[NEW] ? "yes" : "no");
|
|
if (b != buffer) {
|
|
*(b-1) = 0;
|
|
- drbd_info(device, "%s%s\n", prefix, buffer);
|
|
+ drbd_info(device, "%s%s%s\n", prefix, buffer, tag_buffer);
|
|
}
|
|
|
|
for_each_peer_device(peer_device, device) {
|
|
@@ -1253,7 +1259,7 @@ static void print_state_change(struct drbd_resource *resource, const char *prefi
|
|
|
|
if (b != buffer) {
|
|
*(b-1) = 0;
|
|
- drbd_info(peer_device, "%s%s\n", prefix, buffer);
|
|
+ drbd_info(peer_device, "%s%s%s\n", prefix, buffer, tag_buffer);
|
|
}
|
|
}
|
|
}
|
|
@@ -2543,7 +2549,7 @@ static bool should_try_become_up_to_date(struct drbd_device *device, enum drbd_d
|
|
/**
|
|
* finish_state_change - carry out actions triggered by a state change
|
|
*/
|
|
-static void finish_state_change(struct drbd_resource *resource)
|
|
+static void finish_state_change(struct drbd_resource *resource, const char *tag)
|
|
{
|
|
enum drbd_role *role = resource->role;
|
|
struct drbd_device *device;
|
|
@@ -2557,7 +2563,7 @@ static void finish_state_change(struct drbd_resource *resource)
|
|
bool unfreeze_io = false;
|
|
int vnr;
|
|
|
|
- print_state_change(resource, "");
|
|
+ print_state_change(resource, "", tag);
|
|
|
|
resource_suspended[OLD] = resource_is_suspended(resource, OLD);
|
|
resource_suspended[NEW] = resource_is_suspended(resource, NEW);
|
|
@@ -3025,7 +3031,7 @@ static void abw_start_sync(struct drbd_device *device,
|
|
|
|
if (rv) {
|
|
drbd_err(device, "Writing the bitmap failed not starting resync.\n");
|
|
- stable_change_repl_state(peer_device, L_ESTABLISHED, CS_VERBOSE);
|
|
+ stable_change_repl_state(peer_device, L_ESTABLISHED, CS_VERBOSE, "start-sync");
|
|
return;
|
|
}
|
|
|
|
@@ -3039,12 +3045,13 @@ static void abw_start_sync(struct drbd_device *device,
|
|
rcu_read_unlock();
|
|
|
|
if (peer_device->connection->agreed_pro_version < 110)
|
|
- stable_change_repl_state(peer_device, L_WF_SYNC_UUID, CS_VERBOSE);
|
|
+ stable_change_repl_state(peer_device, L_WF_SYNC_UUID, CS_VERBOSE,
|
|
+ "start-sync");
|
|
else
|
|
- drbd_start_resync(peer_device, L_SYNC_TARGET);
|
|
+ drbd_start_resync(peer_device, L_SYNC_TARGET, "start-sync");
|
|
break;
|
|
case L_STARTING_SYNC_S:
|
|
- drbd_start_resync(peer_device, L_SYNC_SOURCE);
|
|
+ drbd_start_resync(peer_device, L_SYNC_SOURCE, "start-sync");
|
|
break;
|
|
default:
|
|
break;
|
|
@@ -3531,7 +3538,7 @@ static void check_may_resume_io_after_fencing(struct drbd_state_change *state_ch
|
|
rcu_read_unlock();
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE);
|
|
__change_io_susp_fencing(connection, false);
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "after-fencing");
|
|
}
|
|
/* case2: The connection was established again: */
|
|
if (all_peer_disks_connected) {
|
|
@@ -3543,7 +3550,7 @@ static void check_may_resume_io_after_fencing(struct drbd_state_change *state_ch
|
|
rcu_read_unlock();
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE);
|
|
__change_io_susp_fencing(connection, false);
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "after-fencing");
|
|
}
|
|
}
|
|
|
|
@@ -4191,7 +4198,7 @@ static int w_after_state_change(struct drbd_work *w, int unused)
|
|
|
|
begin_state_change(resource, &irq_flags, CS_VERBOSE);
|
|
resource->susp_uuid[NEW] = false;
|
|
- end_state_change(resource, &irq_flags);
|
|
+ end_state_change(resource, &irq_flags, "susp-uuid");
|
|
}
|
|
|
|
if (try_become_up_to_date)
|
|
@@ -4673,7 +4680,7 @@ static void twopc_phase2(struct drbd_resource *resource,
|
|
*/
|
|
static enum drbd_state_rv
|
|
change_cluster_wide_state(bool (*change)(struct change_context *, enum change_phase),
|
|
- struct change_context *context)
|
|
+ struct change_context *context, const char *tag)
|
|
{
|
|
struct drbd_resource *resource = context->resource;
|
|
unsigned long irq_flags;
|
|
@@ -4692,11 +4699,11 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
if (local_state_change(context->flags)) {
|
|
/* Not a cluster-wide state change. */
|
|
change(context, PH_LOCAL_COMMIT);
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, tag);
|
|
} else {
|
|
if (!change(context, PH_PREPARE)) {
|
|
/* Not a cluster-wide state change. */
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, tag);
|
|
}
|
|
rv = try_state_change(resource);
|
|
if (rv != SS_SUCCESS) {
|
|
@@ -4704,7 +4711,7 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
/* abort_state_change(resource, &irq_flags); */
|
|
if (rv == SS_NOTHING_TO_DO)
|
|
resource->state_change_flags &= ~CS_VERBOSE;
|
|
- return __end_state_change(resource, &irq_flags, rv);
|
|
+ return __end_state_change(resource, &irq_flags, rv, tag);
|
|
}
|
|
/* Really a cluster-wide state change. */
|
|
}
|
|
@@ -4720,12 +4727,12 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
}
|
|
if (rv >= SS_SUCCESS)
|
|
change(context, PH_84_COMMIT);
|
|
- return __end_state_change(resource, &irq_flags, rv);
|
|
+ return __end_state_change(resource, &irq_flags, rv, tag);
|
|
}
|
|
|
|
if (!expect(resource, context->flags & CS_SERIALIZE)) {
|
|
rv = SS_CW_FAILED_BY_PEER;
|
|
- return __end_state_change(resource, &irq_flags, rv);
|
|
+ return __end_state_change(resource, &irq_flags, rv, tag);
|
|
}
|
|
|
|
rcu_read_lock();
|
|
@@ -4740,7 +4747,7 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
|
|
retry:
|
|
if (current == resource->worker.task && resource->remote_state_change)
|
|
- return __end_state_change(resource, &irq_flags, SS_CONCURRENT_ST_CHG);
|
|
+ return __end_state_change(resource, &irq_flags, SS_CONCURRENT_ST_CHG, tag);
|
|
|
|
complete_remote_state_change(resource, &irq_flags);
|
|
start_time = jiffies;
|
|
@@ -4756,7 +4763,7 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
connection = drbd_get_connection_by_node_id(resource, context->target_node_id);
|
|
if (!connection) {
|
|
rv = SS_NEED_CONNECTION;
|
|
- return __end_state_change(resource, &irq_flags, rv);
|
|
+ return __end_state_change(resource, &irq_flags, rv, tag);
|
|
}
|
|
kref_debug_get(&connection->kref_debug, 8);
|
|
|
|
@@ -4768,7 +4775,7 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
|
|
kref_debug_put(&connection->kref_debug, 8);
|
|
kref_put(&connection->kref, drbd_destroy_connection);
|
|
- return __end_state_change(resource, &irq_flags, rv);
|
|
+ return __end_state_change(resource, &irq_flags, rv, tag);
|
|
}
|
|
target_connection = connection;
|
|
|
|
@@ -4959,7 +4966,7 @@ change_cluster_wide_state(bool (*change)(struct change_context *, enum change_ph
|
|
clear_bit(TWOPC_STATE_CHANGE_PENDING, &resource->flags);
|
|
if (rv >= SS_SUCCESS) {
|
|
change(context, PH_COMMIT);
|
|
- rv = end_state_change(resource, &irq_flags);
|
|
+ rv = end_state_change(resource, &irq_flags, tag);
|
|
if (rv < SS_SUCCESS)
|
|
drbd_err(resource, "FATAL: Local commit of already committed %u failed! \n",
|
|
request.tid);
|
|
@@ -5276,6 +5283,7 @@ static bool do_change_role(struct change_context *context, enum change_phase pha
|
|
enum drbd_state_rv change_role(struct drbd_resource *resource,
|
|
enum drbd_role role,
|
|
enum chg_state_flags flags,
|
|
+ const char *tag,
|
|
const char **err_str)
|
|
{
|
|
struct change_context role_context = {
|
|
@@ -5310,7 +5318,7 @@ enum drbd_state_rv change_role(struct drbd_resource *resource,
|
|
}
|
|
role_context.change_local_state_last = true;
|
|
}
|
|
- rv = change_cluster_wide_state(do_change_role, &role_context);
|
|
+ rv = change_cluster_wide_state(do_change_role, &role_context, tag);
|
|
out:
|
|
if (got_state_sem)
|
|
up(&resource->state_sem);
|
|
@@ -5330,7 +5338,7 @@ enum drbd_state_rv change_io_susp_user(struct drbd_resource *resource,
|
|
|
|
begin_state_change(resource, &irq_flags, flags);
|
|
__change_io_susp_user(resource, value);
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, value ? "suspend-io" : "resume-io");
|
|
}
|
|
|
|
void __change_io_susp_no_data(struct drbd_resource *resource, bool value)
|
|
@@ -5465,7 +5473,7 @@ enum drbd_state_rv twopc_after_lost_peer(struct drbd_resource *resource,
|
|
/* The other nodes get the request for an empty state change. I.e. they
|
|
will agree to this change request. At commit time we know where to
|
|
go from the D_CONSISTENT, since we got the primary mask. */
|
|
- return change_cluster_wide_state(do_twopc_after_lost_peer, &context);
|
|
+ return change_cluster_wide_state(do_twopc_after_lost_peer, &context, "lost-peer");
|
|
}
|
|
|
|
static bool do_change_disk_state(struct change_context *context, enum change_phase phase)
|
|
@@ -5496,6 +5504,7 @@ static bool do_change_disk_state(struct change_context *context, enum change_pha
|
|
enum drbd_state_rv change_disk_state(struct drbd_device *device,
|
|
enum drbd_disk_state disk_state,
|
|
enum chg_state_flags flags,
|
|
+ const char *tag,
|
|
const char **err_str)
|
|
{
|
|
struct change_disk_state_context disk_state_context = {
|
|
@@ -5513,7 +5522,7 @@ enum drbd_state_rv change_disk_state(struct drbd_device *device,
|
|
};
|
|
|
|
return change_cluster_wide_state(do_change_disk_state,
|
|
- &disk_state_context.context);
|
|
+ &disk_state_context.context, tag);
|
|
}
|
|
|
|
void __change_cstate(struct drbd_connection *connection, enum drbd_conn_state cstate)
|
|
@@ -5683,11 +5692,11 @@ static bool do_change_cstate(struct change_context *context, enum change_phase p
|
|
* peer disks depending on the fencing policy. This cannot easily be split
|
|
* into two state changes.
|
|
*/
|
|
-enum drbd_state_rv change_cstate_es(struct drbd_connection *connection,
|
|
+enum drbd_state_rv change_cstate_tag(struct drbd_connection *connection,
|
|
enum drbd_conn_state cstate,
|
|
enum chg_state_flags flags,
|
|
- const char **err_str
|
|
- )
|
|
+ const char *tag,
|
|
+ const char **err_str)
|
|
{
|
|
struct change_cstate_context cstate_context = {
|
|
.context = {
|
|
@@ -5717,7 +5726,7 @@ enum drbd_state_rv change_cstate_es(struct drbd_connection *connection,
|
|
if (!(flags & CS_HARD))
|
|
cstate_context.context.flags |= CS_SERIALIZE;
|
|
|
|
- return change_cluster_wide_state(do_change_cstate, &cstate_context.context);
|
|
+ return change_cluster_wide_state(do_change_cstate, &cstate_context.context, tag);
|
|
}
|
|
|
|
void __change_peer_role(struct drbd_connection *connection, enum drbd_role peer_role)
|
|
@@ -5759,7 +5768,8 @@ static bool do_change_repl_state(struct change_context *context, enum change_pha
|
|
|
|
enum drbd_state_rv change_repl_state(struct drbd_peer_device *peer_device,
|
|
enum drbd_repl_state new_repl_state,
|
|
- enum chg_state_flags flags)
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag)
|
|
{
|
|
struct change_repl_context repl_context = {
|
|
.context = {
|
|
@@ -5776,15 +5786,16 @@ enum drbd_state_rv change_repl_state(struct drbd_peer_device *peer_device,
|
|
if (new_repl_state == L_WF_BITMAP_S || new_repl_state == L_VERIFY_S)
|
|
repl_context.context.change_local_state_last = true;
|
|
|
|
- return change_cluster_wide_state(do_change_repl_state, &repl_context.context);
|
|
+ return change_cluster_wide_state(do_change_repl_state, &repl_context.context, tag);
|
|
}
|
|
|
|
enum drbd_state_rv stable_change_repl_state(struct drbd_peer_device *peer_device,
|
|
enum drbd_repl_state repl_state,
|
|
- enum chg_state_flags flags)
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag)
|
|
{
|
|
return stable_state_change(peer_device->device->resource,
|
|
- change_repl_state(peer_device, repl_state, flags));
|
|
+ change_repl_state(peer_device, repl_state, flags, tag));
|
|
}
|
|
|
|
void __change_peer_disk_state(struct drbd_peer_device *peer_device, enum drbd_disk_state disk_state)
|
|
@@ -5807,14 +5818,15 @@ void __downgrade_peer_disk_states(struct drbd_connection *connection, enum drbd_
|
|
|
|
enum drbd_state_rv change_peer_disk_state(struct drbd_peer_device *peer_device,
|
|
enum drbd_disk_state disk_state,
|
|
- enum chg_state_flags flags)
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag)
|
|
{
|
|
struct drbd_resource *resource = peer_device->device->resource;
|
|
unsigned long irq_flags;
|
|
|
|
begin_state_change(resource, &irq_flags, flags);
|
|
__change_peer_disk_state(peer_device, disk_state);
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, tag);
|
|
}
|
|
|
|
void __change_resync_susp_user(struct drbd_peer_device *peer_device,
|
|
@@ -5832,7 +5844,7 @@ enum drbd_state_rv change_resync_susp_user(struct drbd_peer_device *peer_device,
|
|
|
|
begin_state_change(resource, &irq_flags, flags);
|
|
__change_resync_susp_user(peer_device, value);
|
|
- return end_state_change(resource, &irq_flags);
|
|
+ return end_state_change(resource, &irq_flags, value ? "pause-sync" : "resume-sync");
|
|
}
|
|
|
|
void __change_resync_susp_peer(struct drbd_peer_device *peer_device,
|
|
diff --git a/drbd/drbd_state.h b/drbd/drbd_state.h
|
|
index 6942f85123dd..952dea156697 100644
|
|
--- a/drbd/drbd_state.h
|
|
+++ b/drbd/drbd_state.h
|
|
@@ -56,12 +56,13 @@ extern void state_change_lock(struct drbd_resource *, unsigned long *, enum chg_
|
|
extern void state_change_unlock(struct drbd_resource *, unsigned long *);
|
|
|
|
extern void begin_state_change(struct drbd_resource *, unsigned long *, enum chg_state_flags);
|
|
-extern enum drbd_state_rv end_state_change(struct drbd_resource *, unsigned long *);
|
|
+extern enum drbd_state_rv end_state_change(struct drbd_resource *resource, unsigned long *irq_flags,
|
|
+ const char *tag);
|
|
extern void abort_state_change(struct drbd_resource *, unsigned long *);
|
|
extern void abort_state_change_locked(struct drbd_resource *resource);
|
|
|
|
extern void begin_state_change_locked(struct drbd_resource *, enum chg_state_flags);
|
|
-extern enum drbd_state_rv end_state_change_locked(struct drbd_resource *);
|
|
+extern enum drbd_state_rv end_state_change_locked(struct drbd_resource *resource, const char *tag);
|
|
|
|
extern void clear_remote_state_change(struct drbd_resource *resource);
|
|
extern void __clear_remote_state_change(struct drbd_resource *resource);
|
|
@@ -89,7 +90,11 @@ extern enum drbd_state_rv nested_twopc_request(struct drbd_resource *res, struct
|
|
extern bool drbd_twopc_between_peer_and_me(struct drbd_connection *connection);
|
|
extern bool cluster_wide_reply_ready(struct drbd_resource *);
|
|
|
|
-extern enum drbd_state_rv change_role(struct drbd_resource *, enum drbd_role, enum chg_state_flags, const char **);
|
|
+extern enum drbd_state_rv change_role(struct drbd_resource *resource,
|
|
+ enum drbd_role role,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag,
|
|
+ const char **err_str);
|
|
|
|
extern void __change_io_susp_user(struct drbd_resource *, bool);
|
|
extern enum drbd_state_rv change_io_susp_user(struct drbd_resource *, bool, enum chg_state_flags);
|
|
@@ -99,27 +104,44 @@ extern void __change_io_susp_quorum(struct drbd_resource *, bool);
|
|
|
|
extern void __change_disk_state(struct drbd_device *, enum drbd_disk_state);
|
|
extern void __downgrade_disk_states(struct drbd_resource *, enum drbd_disk_state);
|
|
-extern enum drbd_state_rv change_disk_state(struct drbd_device *, enum drbd_disk_state, enum chg_state_flags, const char **);
|
|
+extern enum drbd_state_rv change_disk_state(struct drbd_device *device,
|
|
+ enum drbd_disk_state disk_state,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag,
|
|
+ const char **err_str);
|
|
|
|
extern void __change_cstate(struct drbd_connection *, enum drbd_conn_state);
|
|
-extern enum drbd_state_rv change_cstate_es(struct drbd_connection *, enum drbd_conn_state, enum chg_state_flags, const char **);
|
|
+extern enum drbd_state_rv change_cstate_tag(struct drbd_connection *connection,
|
|
+ enum drbd_conn_state cstate,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag,
|
|
+ const char **err_str);
|
|
static inline enum drbd_state_rv change_cstate(struct drbd_connection *connection,
|
|
enum drbd_conn_state cstate,
|
|
enum chg_state_flags flags)
|
|
{
|
|
- return change_cstate_es(connection, cstate, flags, NULL);
|
|
+ return change_cstate_tag(connection, cstate, flags, NULL, NULL);
|
|
}
|
|
|
|
extern void __change_peer_role(struct drbd_connection *, enum drbd_role);
|
|
|
|
extern void __change_repl_state(struct drbd_peer_device *, enum drbd_repl_state);
|
|
-extern enum drbd_state_rv change_repl_state(struct drbd_peer_device *, enum drbd_repl_state, enum chg_state_flags);
|
|
-extern enum drbd_state_rv stable_change_repl_state(struct drbd_peer_device *, enum drbd_repl_state, enum chg_state_flags);
|
|
+extern enum drbd_state_rv change_repl_state(struct drbd_peer_device *peer_device,
|
|
+ enum drbd_repl_state new_repl_state,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag);
|
|
+extern enum drbd_state_rv stable_change_repl_state(struct drbd_peer_device *peer_device,
|
|
+ enum drbd_repl_state repl_state,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag);
|
|
|
|
extern void __change_peer_disk_state(struct drbd_peer_device *, enum drbd_disk_state);
|
|
extern void __downgrade_peer_disk_states(struct drbd_connection *, enum drbd_disk_state);
|
|
extern void __outdate_myself(struct drbd_resource *resource);
|
|
-extern enum drbd_state_rv change_peer_disk_state(struct drbd_peer_device *, enum drbd_disk_state, enum chg_state_flags);
|
|
+extern enum drbd_state_rv change_peer_disk_state(struct drbd_peer_device *peer_device,
|
|
+ enum drbd_disk_state disk_state,
|
|
+ enum chg_state_flags flags,
|
|
+ const char *tag);
|
|
|
|
enum drbd_state_rv twopc_after_lost_peer(struct drbd_resource *resource, enum chg_state_flags);
|
|
|
|
--
|
|
2.35.3
|
|
|