1 files changed, 1969 insertions, 1349 deletions

diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index c8dda4e8dfce..76bb3a684b86 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -29,159 +29,317 @@
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/slab.h>
-#include <linux/connector.h>
 #include <linux/blkpg.h>
 #include <linux/cpumask.h>
 #include "drbd_int.h"
 #include "drbd_req.h"
 #include "drbd_wrappers.h"
 #include <asm/unaligned.h>
-#include <linux/drbd_tag_magic.h>
 #include <linux/drbd_limits.h>
-#include <linux/compiler.h>
 #include <linux/kthread.h>
 
-static unsigned short *tl_add_blob(unsigned short *, enum drbd_tags, const void *, int);
-static unsigned short *tl_add_str(unsigned short *, enum drbd_tags, const char *);
-static unsigned short *tl_add_int(unsigned short *, enum drbd_tags, const void *);
-
-/* see get_sb_bdev and bd_claim */
+#include <net/genetlink.h>
+
+/* .doit */
+// int drbd_adm_create_resource(struct sk_buff *skb, struct genl_info *info);
+// int drbd_adm_delete_resource(struct sk_buff *skb, struct genl_info *info);
+
+int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info);
+
+int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_down(struct sk_buff *skb, struct genl_info *info);
+
+int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info);
+int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info);
+/* .dumpit */
+int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb);
+
+#include <linux/drbd_genl_api.h>
+#include "drbd_nla.h"
+#include <linux/genl_magic_func.h>
+
+/* used blkdev_get_by_path, to claim our meta data device(s) */
 static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";
 
-/* Generate the tag_list to struct functions */
-#define NL_PACKET(name, number, fields) \
-static int name ## _from_tags(struct drbd_conf *mdev, \
-        unsigned short *tags, struct name *arg) __attribute__ ((unused)); \
-static int name ## _from_tags(struct drbd_conf *mdev, \
-        unsigned short *tags, struct name *arg) \
-{ \
-        int tag; \
-        int dlen; \
-        \
-        while ((tag = get_unaligned(tags++)) != TT_END) {       \
-                dlen = get_unaligned(tags++);                   \
-                switch (tag_number(tag)) { \
-                fields \
-                default: \
-                        if (tag & T_MANDATORY) { \
-                                dev_err(DEV, "Unknown tag: %d\n", tag_number(tag)); \
-                                return 0; \
-                        } \
-                } \
-                tags = (unsigned short *)((char *)tags + dlen); \
-        } \
-        return 1; \
-}
-#define NL_INTEGER(pn, pr, member) \
-        case pn: /* D_ASSERT( tag_type(tag) == TT_INTEGER ); */ \
-                arg->member = get_unaligned((int *)(tags));     \
-                break;
-#define NL_INT64(pn, pr, member) \
-        case pn: /* D_ASSERT( tag_type(tag) == TT_INT64 ); */ \
-                arg->member = get_unaligned((u64 *)(tags));     \
+/* Configuration is strictly serialized, because generic netlink message
+ * processing is strictly serialized by the genl_lock().
+ * Which means we can use one static global drbd_config_context struct.
+ */
+static struct drbd_config_context {
+        /* assigned from drbd_genlmsghdr */
+        unsigned int minor;
+        /* assigned from request attributes, if present */
+        unsigned int volume;
+#define VOLUME_UNSPECIFIED              (-1U)
+        /* pointer into the request skb,
+         * limited lifetime! */
+        char *resource_name;
+        struct nlattr *my_addr;
+        struct nlattr *peer_addr;
+
+        /* reply buffer */
+        struct sk_buff *reply_skb;
+        /* pointer into reply buffer */
+        struct drbd_genlmsghdr *reply_dh;
+        /* resolved from attributes, if possible */
+        struct drbd_conf *mdev;
+        struct drbd_tconn *tconn;
+} adm_ctx;
+
+static void drbd_adm_send_reply(struct sk_buff *skb, struct genl_info *info)
+{
+        genlmsg_end(skb, genlmsg_data(nlmsg_data(nlmsg_hdr(skb))));
+        if (genlmsg_reply(skb, info))
+                printk(KERN_ERR "drbd: error sending genl reply\n");
+}
+
+/* Used on a fresh "drbd_adm_prepare"d reply_skb, this cannot fail: The only
+ * reason it could fail was no space in skb, and there are 4k available. */
+int drbd_msg_put_info(const char *info)
+{
+        struct sk_buff *skb = adm_ctx.reply_skb;
+        struct nlattr *nla;
+        int err = -EMSGSIZE;
+
+        if (!info || !info[0])
+                return 0;
+
+        nla = nla_nest_start(skb, DRBD_NLA_CFG_REPLY);
+        if (!nla)
+                return err;
+
+        err = nla_put_string(skb, T_info_text, info);
+        if (err) {
+                nla_nest_cancel(skb, nla);
+                return err;
+        } else
+                nla_nest_end(skb, nla);
+        return 0;
+}
+
+/* This would be a good candidate for a "pre_doit" hook,
+ * and per-family private info->pointers.
+ * But we need to stay compatible with older kernels.
+ * If it returns successfully, adm_ctx members are valid.
+ */
+#define DRBD_ADM_NEED_MINOR     1
+#define DRBD_ADM_NEED_RESOURCE  2
+#define DRBD_ADM_NEED_CONNECTION 4
+static int drbd_adm_prepare(struct sk_buff *skb, struct genl_info *info,
+                unsigned flags)
+{
+        struct drbd_genlmsghdr *d_in = info->userhdr;
+        const u8 cmd = info->genlhdr->cmd;
+        int err;
+
+        memset(&adm_ctx, 0, sizeof(adm_ctx));
+
+        /* genl_rcv_msg only checks for CAP_NET_ADMIN on "GENL_ADMIN_PERM" :( */
+        if (cmd != DRBD_ADM_GET_STATUS && !capable(CAP_NET_ADMIN))
+               return -EPERM;
+
+        adm_ctx.reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+        if (!adm_ctx.reply_skb) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        adm_ctx.reply_dh = genlmsg_put_reply(adm_ctx.reply_skb,
+                                        info, &drbd_genl_family, 0, cmd);
+        /* put of a few bytes into a fresh skb of >= 4k will always succeed.
+         * but anyways */
+        if (!adm_ctx.reply_dh) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        adm_ctx.reply_dh->minor = d_in->minor;
+        adm_ctx.reply_dh->ret_code = NO_ERROR;
+
+        adm_ctx.volume = VOLUME_UNSPECIFIED;
+        if (info->attrs[DRBD_NLA_CFG_CONTEXT]) {
+                struct nlattr *nla;
+                /* parse and validate only */
+                err = drbd_cfg_context_from_attrs(NULL, info);
+                if (err)
+                        goto fail;
+
+                /* It was present, and valid,
+                 * copy it over to the reply skb. */
+                err = nla_put_nohdr(adm_ctx.reply_skb,
+                                info->attrs[DRBD_NLA_CFG_CONTEXT]->nla_len,
+                                info->attrs[DRBD_NLA_CFG_CONTEXT]);
+                if (err)
+                        goto fail;
+
+                /* and assign stuff to the global adm_ctx */
+                nla = nested_attr_tb[__nla_type(T_ctx_volume)];
+                if (nla)
+                        adm_ctx.volume = nla_get_u32(nla);
+                nla = nested_attr_tb[__nla_type(T_ctx_resource_name)];
+                if (nla)
+                        adm_ctx.resource_name = nla_data(nla);
+                adm_ctx.my_addr = nested_attr_tb[__nla_type(T_ctx_my_addr)];
+                adm_ctx.peer_addr = nested_attr_tb[__nla_type(T_ctx_peer_addr)];
+                if ((adm_ctx.my_addr &&
+                     nla_len(adm_ctx.my_addr) > sizeof(adm_ctx.tconn->my_addr)) ||
+                    (adm_ctx.peer_addr &&
+                     nla_len(adm_ctx.peer_addr) > sizeof(adm_ctx.tconn->peer_addr))) {
+                        err = -EINVAL;
+                        goto fail;
+                }
+        }
+
+        adm_ctx.minor = d_in->minor;
+        adm_ctx.mdev = minor_to_mdev(d_in->minor);
+        adm_ctx.tconn = conn_get_by_name(adm_ctx.resource_name);
+
+        if (!adm_ctx.mdev && (flags & DRBD_ADM_NEED_MINOR)) {
+                drbd_msg_put_info("unknown minor");
+                return ERR_MINOR_INVALID;
+        }
+        if (!adm_ctx.tconn && (flags & DRBD_ADM_NEED_RESOURCE)) {
+                drbd_msg_put_info("unknown resource");
+                return ERR_INVALID_REQUEST;
+        }
+
+        if (flags & DRBD_ADM_NEED_CONNECTION) {
+                if (adm_ctx.tconn && !(flags & DRBD_ADM_NEED_RESOURCE)) {
+                        drbd_msg_put_info("no resource name expected");
+                        return ERR_INVALID_REQUEST;
+                }
+                if (adm_ctx.mdev) {
+                        drbd_msg_put_info("no minor number expected");
+                        return ERR_INVALID_REQUEST;
+                }
+                if (adm_ctx.my_addr && adm_ctx.peer_addr)
+                        adm_ctx.tconn = conn_get_by_addrs(nla_data(adm_ctx.my_addr),
+                                                          nla_len(adm_ctx.my_addr),
+                                                          nla_data(adm_ctx.peer_addr),
+                                                          nla_len(adm_ctx.peer_addr));
+                if (!adm_ctx.tconn) {
+                        drbd_msg_put_info("unknown connection");
+                        return ERR_INVALID_REQUEST;
+                }
+        }
+
+        /* some more paranoia, if the request was over-determined */
+        if (adm_ctx.mdev && adm_ctx.tconn &&
+            adm_ctx.mdev->tconn != adm_ctx.tconn) {
+                pr_warning("request: minor=%u, resource=%s; but that minor belongs to connection %s\n",
+                                adm_ctx.minor, adm_ctx.resource_name,
+                                adm_ctx.mdev->tconn->name);
+                drbd_msg_put_info("minor exists in different resource");
+                return ERR_INVALID_REQUEST;
+        }
+        if (adm_ctx.mdev &&
+            adm_ctx.volume != VOLUME_UNSPECIFIED &&
+            adm_ctx.volume != adm_ctx.mdev->vnr) {
+                pr_warning("request: minor=%u, volume=%u; but that minor is volume %u in %s\n",
+                                adm_ctx.minor, adm_ctx.volume,
+                                adm_ctx.mdev->vnr, adm_ctx.mdev->tconn->name);
+                drbd_msg_put_info("minor exists as different volume");
+                return ERR_INVALID_REQUEST;
+        }
+
+        return NO_ERROR;
+
+fail:
+        nlmsg_free(adm_ctx.reply_skb);
+        adm_ctx.reply_skb = NULL;
+        return err;
+}
+
+static int drbd_adm_finish(struct genl_info *info, int retcode)
+{
+        if (adm_ctx.tconn) {
+                kref_put(&adm_ctx.tconn->kref, &conn_destroy);
+                adm_ctx.tconn = NULL;
+        }
+
+        if (!adm_ctx.reply_skb)
+                return -ENOMEM;
+
+        adm_ctx.reply_dh->ret_code = retcode;
+        drbd_adm_send_reply(adm_ctx.reply_skb, info);
+        return 0;
+}
+
+static void setup_khelper_env(struct drbd_tconn *tconn, char **envp)
+{
+        char *afs;
+
+        /* FIXME: A future version will not allow this case. */
+        if (tconn->my_addr_len == 0 || tconn->peer_addr_len == 0)
+                return;
+
+        switch (((struct sockaddr *)&tconn->peer_addr)->sa_family) {
+        case AF_INET6:
+                afs = "ipv6";
+                snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI6",
+                         &((struct sockaddr_in6 *)&tconn->peer_addr)->sin6_addr);
                 break;
-#define NL_BIT(pn, pr, member) \
-        case pn: /* D_ASSERT( tag_type(tag) == TT_BIT ); */ \
-                arg->member = *(char *)(tags) ? 1 : 0; \
+        case AF_INET:
+                afs = "ipv4";
+                snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
+                         &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
                 break;
-#define NL_STRING(pn, pr, member, len) \
-        case pn: /* D_ASSERT( tag_type(tag) == TT_STRING ); */ \
-                if (dlen > len) { \
-                        dev_err(DEV, "arg too long: %s (%u wanted, max len: %u bytes)\n", \
-                                #member, dlen, (unsigned int)len); \
-                        return 0; \
-                } \
-                 arg->member ## _len = dlen; \
-                 memcpy(arg->member, tags, min_t(size_t, dlen, len)); \
-                 break;
-#include <linux/drbd_nl.h>
-
-/* Generate the struct to tag_list functions */
-#define NL_PACKET(name, number, fields) \
-static unsigned short* \
-name ## _to_tags(struct drbd_conf *mdev, \
-        struct name *arg, unsigned short *tags) __attribute__ ((unused)); \
-static unsigned short* \
-name ## _to_tags(struct drbd_conf *mdev, \
-        struct name *arg, unsigned short *tags) \
-{ \
-        fields \
-        return tags; \
-}
-
-#define NL_INTEGER(pn, pr, member) \
-        put_unaligned(pn | pr | TT_INTEGER, tags++);    \
-        put_unaligned(sizeof(int), tags++);             \
-        put_unaligned(arg->member, (int *)tags);        \
-        tags = (unsigned short *)((char *)tags+sizeof(int));
-#define NL_INT64(pn, pr, member) \
-        put_unaligned(pn | pr | TT_INT64, tags++);      \
-        put_unaligned(sizeof(u64), tags++);             \
-        put_unaligned(arg->member, (u64 *)tags);        \
-        tags = (unsigned short *)((char *)tags+sizeof(u64));
-#define NL_BIT(pn, pr, member) \
-        put_unaligned(pn | pr | TT_BIT, tags++);        \
-        put_unaligned(sizeof(char), tags++);            \
-        *(char *)tags = arg->member; \
-        tags = (unsigned short *)((char *)tags+sizeof(char));
-#define NL_STRING(pn, pr, member, len) \
-        put_unaligned(pn | pr | TT_STRING, tags++);     \
-        put_unaligned(arg->member ## _len, tags++);     \
-        memcpy(tags, arg->member, arg->member ## _len); \
-        tags = (unsigned short *)((char *)tags + arg->member ## _len);
-#include <linux/drbd_nl.h>
-
-void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name);
-void drbd_nl_send_reply(struct cn_msg *, int);
+        default:
+                afs = "ssocks";
+                snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
+                         &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
+        }
+        snprintf(envp[3], 20, "DRBD_PEER_AF=%s", afs);
+}
 
 int drbd_khelper(struct drbd_conf *mdev, char *cmd)
 {
         char *envp[] = { "HOME=/",
                         "TERM=linux",
                         "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
-                        NULL, /* Will be set to address family */
-                        NULL, /* Will be set to address */
+                         (char[20]) { }, /* address family */
+                         (char[60]) { }, /* address */
                         NULL };
-
-        char mb[12], af[20], ad[60], *afs;
+        char mb[12];
         char *argv[] = {usermode_helper, cmd, mb, NULL };
+        struct drbd_tconn *tconn = mdev->tconn;
+        struct sib_info sib;
         int ret;
 
-        if (current == mdev->worker.task)
-                drbd_set_flag(mdev, CALLBACK_PENDING);
+        if (current == tconn->worker.task)
+                set_bit(CALLBACK_PENDING, &tconn->flags);
 
         snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
-
-        if (get_net_conf(mdev)) {
-                switch (((struct sockaddr *)mdev->net_conf->peer_addr)->sa_family) {
-                case AF_INET6:
-                        afs = "ipv6";
-                        snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI6",
-                                 &((struct sockaddr_in6 *)mdev->net_conf->peer_addr)->sin6_addr);
-                        break;
-                case AF_INET:
-                        afs = "ipv4";
-                        snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4",
-                                 &((struct sockaddr_in *)mdev->net_conf->peer_addr)->sin_addr);
-                        break;
-                default:
-                        afs = "ssocks";
-                        snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4",
-                                 &((struct sockaddr_in *)mdev->net_conf->peer_addr)->sin_addr);
-                }
-                snprintf(af, 20, "DRBD_PEER_AF=%s", afs);
-                envp[3]=af;
-                envp[4]=ad;
-                put_net_conf(mdev);
-        }
+        setup_khelper_env(tconn, envp);
 
         /* The helper may take some time.
          * write out any unsynced meta data changes now */
         drbd_md_sync(mdev);
 
         dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
-
-        drbd_bcast_ev_helper(mdev, cmd);
+        sib.sib_reason = SIB_HELPER_PRE;
+        sib.helper_name = cmd;
+        drbd_bcast_event(mdev, &sib);
         ret = call_usermodehelper(usermode_helper, argv, envp, UMH_WAIT_PROC);
         if (ret)
                 dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
@@ -191,9 +349,46 @@ int drbd_khelper(struct drbd_conf *mdev, char *cmd)
                 dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
                                 usermode_helper, cmd, mb,
                                 (ret >> 8) & 0xff, ret);
+        sib.sib_reason = SIB_HELPER_POST;
+        sib.helper_exit_code = ret;
+        drbd_bcast_event(mdev, &sib);
+
+        if (current == tconn->worker.task)
+                clear_bit(CALLBACK_PENDING, &tconn->flags);
+
+        if (ret < 0) /* Ignore any ERRNOs we got. */
+                ret = 0;
+
+        return ret;
+}
+
+int conn_khelper(struct drbd_tconn *tconn, char *cmd)
+{
+        char *envp[] = { "HOME=/",
+                        "TERM=linux",
+                        "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
+                         (char[20]) { }, /* address family */
+                         (char[60]) { }, /* address */
+                        NULL };
+        char *argv[] = {usermode_helper, cmd, tconn->name, NULL };
+        int ret;
+
+        setup_khelper_env(tconn, envp);
+        conn_md_sync(tconn);
 
-        if (current == mdev->worker.task)
-                drbd_clear_flag(mdev, CALLBACK_PENDING);
+        conn_info(tconn, "helper command: %s %s %s\n", usermode_helper, cmd, tconn->name);
+        /* TODO: conn_bcast_event() ?? */
+
+        ret = call_usermodehelper(usermode_helper, argv, envp, UMH_WAIT_PROC);
+        if (ret)
+                conn_warn(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
+                          usermode_helper, cmd, tconn->name,
+                          (ret >> 8) & 0xff, ret);
+        else
+                conn_info(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
+                          usermode_helper, cmd, tconn->name,
+                          (ret >> 8) & 0xff, ret);
+        /* TODO: conn_bcast_event() ?? */
 
         if (ret < 0) /* Ignore any ERRNOs we got. */
                 ret = 0;
@@ -201,116 +396,129 @@ int drbd_khelper(struct drbd_conf *mdev, char *cmd)
         return ret;
 }
 
-enum drbd_disk_state drbd_try_outdate_peer(struct drbd_conf *mdev)
+static enum drbd_fencing_p highest_fencing_policy(struct drbd_tconn *tconn)
 {
+        enum drbd_fencing_p fp = FP_NOT_AVAIL;
+        struct drbd_conf *mdev;
+        int vnr;
+
+        rcu_read_lock();
+        idr_for_each_entry(&tconn->volumes, mdev, vnr) {
+                if (get_ldev_if_state(mdev, D_CONSISTENT)) {
+                        fp = max_t(enum drbd_fencing_p, fp,
+                                   rcu_dereference(mdev->ldev->disk_conf)->fencing);
+                        put_ldev(mdev);
+                }
+        }
+        rcu_read_unlock();
+
+        return fp;
+}
+
+bool conn_try_outdate_peer(struct drbd_tconn *tconn)
+{
+        union drbd_state mask = { };
+        union drbd_state val = { };
+        enum drbd_fencing_p fp;
         char *ex_to_string;
         int r;
-        enum drbd_disk_state nps;
-        enum drbd_fencing_p fp;
 
-        D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
+        if (tconn->cstate >= C_WF_REPORT_PARAMS) {
+                conn_err(tconn, "Expected cstate < C_WF_REPORT_PARAMS\n");
+                return false;
+        }
 
-        if (get_ldev_if_state(mdev, D_CONSISTENT)) {
-                fp = mdev->ldev->dc.fencing;
-                put_ldev(mdev);
-        } else {
-                dev_warn(DEV, "Not fencing peer, I'm not even Consistent myself.\n");
-                nps = mdev->state.pdsk;
+        fp = highest_fencing_policy(tconn);
+        switch (fp) {
+        case FP_NOT_AVAIL:
+                conn_warn(tconn, "Not fencing peer, I'm not even Consistent myself.\n");
                 goto out;
+        case FP_DONT_CARE:
+                return true;
+        default: ;
         }
 
-        r = drbd_khelper(mdev, "fence-peer");
+        r = conn_khelper(tconn, "fence-peer");
 
         switch ((r>>8) & 0xff) {
         case 3: /* peer is inconsistent */
                 ex_to_string = "peer is inconsistent or worse";
-                nps = D_INCONSISTENT;
+                mask.pdsk = D_MASK;
+                val.pdsk = D_INCONSISTENT;
                 break;
         case 4: /* peer got outdated, or was already outdated */
                 ex_to_string = "peer was fenced";
-                nps = D_OUTDATED;
+                mask.pdsk = D_MASK;
+                val.pdsk = D_OUTDATED;
                 break;
         case 5: /* peer was down */
-                if (mdev->state.disk == D_UP_TO_DATE) {
+                if (conn_highest_disk(tconn) == D_UP_TO_DATE) {
                         /* we will(have) create(d) a new UUID anyways... */
                         ex_to_string = "peer is unreachable, assumed to be dead";
-                        nps = D_OUTDATED;
+                        mask.pdsk = D_MASK;
+                        val.pdsk = D_OUTDATED;
                 } else {
                         ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
-                        nps = mdev->state.pdsk;
                 }
                 break;
         case 6: /* Peer is primary, voluntarily outdate myself.
                  * This is useful when an unconnected R_SECONDARY is asked to
                  * become R_PRIMARY, but finds the other peer being active. */
                 ex_to_string = "peer is active";
-                dev_warn(DEV, "Peer is primary, outdating myself.\n");
-                nps = D_UNKNOWN;
-                _drbd_request_state(mdev, NS(disk, D_OUTDATED), CS_WAIT_COMPLETE);
+                conn_warn(tconn, "Peer is primary, outdating myself.\n");
+                mask.disk = D_MASK;
+                val.disk = D_OUTDATED;
                 break;
         case 7:
                 if (fp != FP_STONITH)
-                        dev_err(DEV, "fence-peer() = 7 && fencing != Stonith !!!\n");
+                        conn_err(tconn, "fence-peer() = 7 && fencing != Stonith !!!\n");
                 ex_to_string = "peer was stonithed";
-                nps = D_OUTDATED;
+                mask.pdsk = D_MASK;
+                val.pdsk = D_OUTDATED;
                 break;
         default:
                 /* The script is broken ... */
-                nps = D_UNKNOWN;
-                dev_err(DEV, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
-                return nps;
+                conn_err(tconn, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
+                return false; /* Eventually leave IO frozen */
         }
 
-        dev_info(DEV, "fence-peer helper returned %d (%s)\n",
-                        (r>>8) & 0xff, ex_to_string);
+        conn_info(tconn, "fence-peer helper returned %d (%s)\n",
+                  (r>>8) & 0xff, ex_to_string);
 
-out:
-        if (mdev->state.susp_fen && nps >= D_UNKNOWN) {
-                /* The handler was not successful... unfreeze here, the
-                   state engine can not unfreeze... */
-                _drbd_request_state(mdev, NS(susp_fen, 0), CS_VERBOSE);
-        }
+ out:
 
-        return nps;
+        /* Not using
+           conn_request_state(tconn, mask, val, CS_VERBOSE);
+           here, because we might were able to re-establish the connection in the
+           meantime. */
+        spin_lock_irq(&tconn->req_lock);
+        if (tconn->cstate < C_WF_REPORT_PARAMS && !test_bit(STATE_SENT, &tconn->flags))
+                _conn_request_state(tconn, mask, val, CS_VERBOSE);
+        spin_unlock_irq(&tconn->req_lock);
+
+        return conn_highest_pdsk(tconn) <= D_OUTDATED;
 }
 
 static int _try_outdate_peer_async(void *data)
 {
-        struct drbd_conf *mdev = (struct drbd_conf *)data;
-        enum drbd_disk_state nps;
-        union drbd_state ns;
+        struct drbd_tconn *tconn = (struct drbd_tconn *)data;
 
-        nps = drbd_try_outdate_peer(mdev);
-
-        /* Not using
-           drbd_request_state(mdev, NS(pdsk, nps));
-           here, because we might were able to re-establish the connection
-           in the meantime. This can only partially be solved in the state's
-           engine is_valid_state() and is_valid_state_transition()
-           functions.
-
-           nps can be D_INCONSISTENT, D_OUTDATED or D_UNKNOWN.
-           pdsk == D_INCONSISTENT while conn >= C_CONNECTED is valid,
-           therefore we have to have the pre state change check here.
-        */
-        spin_lock_irq(&mdev->req_lock);
-        ns = mdev->state;
-        if (ns.conn < C_WF_REPORT_PARAMS && !drbd_test_flag(mdev, STATE_SENT)) {
-                ns.pdsk = nps;
-                _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
-        }
-        spin_unlock_irq(&mdev->req_lock);
+        conn_try_outdate_peer(tconn);
 
+        kref_put(&tconn->kref, &conn_destroy);
         return 0;
 }
 
-void drbd_try_outdate_peer_async(struct drbd_conf *mdev)
+void conn_try_outdate_peer_async(struct drbd_tconn *tconn)
 {
         struct task_struct *opa;
 
-        opa = kthread_run(_try_outdate_peer_async, mdev, "drbd%d_a_helper", mdev_to_minor(mdev));
-        if (IS_ERR(opa))
-                dev_err(DEV, "out of mem, failed to invoke fence-peer helper\n");
+        kref_get(&tconn->kref);
+        opa = kthread_run(_try_outdate_peer_async, tconn, "drbd_async_h");
+        if (IS_ERR(opa)) {
+                conn_err(tconn, "out of mem, failed to invoke fence-peer helper\n");
+                kref_put(&tconn->kref, &conn_destroy);
+        }
 }
 
 enum drbd_state_rv
@@ -318,15 +526,15 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
 {
         const int max_tries = 4;
         enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
+        struct net_conf *nc;
         int try = 0;
         int forced = 0;
         union drbd_state mask, val;
-        enum drbd_disk_state nps;
 
         if (new_role == R_PRIMARY)
-                request_ping(mdev); /* Detect a dead peer ASAP */
+                request_ping(mdev->tconn); /* Detect a dead peer ASAP */
 
-        mutex_lock(&mdev->state_mutex);
+        mutex_lock(mdev->state_mutex);
 
         mask.i = 0; mask.role = R_MASK;
         val.i  = 0; val.role  = new_role;
@@ -354,38 +562,34 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
                 if (rv == SS_NO_UP_TO_DATE_DISK &&
                     mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
                         D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
-                        nps = drbd_try_outdate_peer(mdev);
 
-                        if (nps == D_OUTDATED || nps == D_INCONSISTENT) {
+                        if (conn_try_outdate_peer(mdev->tconn)) {
                                 val.disk = D_UP_TO_DATE;
                                 mask.disk = D_MASK;
                         }
-
-                        val.pdsk = nps;
-                        mask.pdsk = D_MASK;
-
                         continue;
                 }
 
                 if (rv == SS_NOTHING_TO_DO)
-                        goto fail;
+                        goto out;
                 if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
-                        nps = drbd_try_outdate_peer(mdev);
-
-                        if (force && nps > D_OUTDATED) {
+                        if (!conn_try_outdate_peer(mdev->tconn) && force) {
                                 dev_warn(DEV, "Forced into split brain situation!\n");
-                                nps = D_OUTDATED;
-                        }
-
-                        mask.pdsk = D_MASK;
-                        val.pdsk  = nps;
+                                mask.pdsk = D_MASK;
+                                val.pdsk  = D_OUTDATED;
 
+                        }
                         continue;
                 }
                 if (rv == SS_TWO_PRIMARIES) {
                         /* Maybe the peer is detected as dead very soon...
                            retry at most once more in this case. */
-                        schedule_timeout_interruptible((mdev->net_conf->ping_timeo+1)*HZ/10);
+                        int timeo;
+                        rcu_read_lock();
+                        nc = rcu_dereference(mdev->tconn->net_conf);
+                        timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
+                        rcu_read_unlock();
+                        schedule_timeout_interruptible(timeo);
                         if (try < max_tries)
                                 try = max_tries - 1;
                         continue;
@@ -394,13 +598,13 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
                         rv = _drbd_request_state(mdev, mask, val,
                                                 CS_VERBOSE + CS_WAIT_COMPLETE);
                         if (rv < SS_SUCCESS)
-                                goto fail;
+                                goto out;
                 }
                 break;
         }
 
         if (rv < SS_SUCCESS)
-                goto fail;
+                goto out;
 
         if (forced)
                 dev_warn(DEV, "Forced to consider local data as UpToDate!\n");
@@ -408,6 +612,8 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
         /* Wait until nothing is on the fly :) */
         wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);
 
+        /* FIXME also wait for all pending P_BARRIER_ACK? */
+
         if (new_role == R_SECONDARY) {
                 set_disk_ro(mdev->vdisk, true);
                 if (get_ldev(mdev)) {
@@ -415,10 +621,12 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
                         put_ldev(mdev);
                 }
         } else {
-                if (get_net_conf(mdev)) {
-                        mdev->net_conf->want_lose = 0;
-                        put_net_conf(mdev);
-                }
+                mutex_lock(&mdev->tconn->conf_update);
+                nc = mdev->tconn->net_conf;
+                if (nc)
+                        nc->discard_my_data = 0; /* without copy; single bit op is atomic */
+                mutex_unlock(&mdev->tconn->conf_update);
+
                 set_disk_ro(mdev->vdisk, false);
                 if (get_ldev(mdev)) {
                         if (((mdev->state.conn < C_CONNECTED ||
@@ -444,67 +652,47 @@ drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
         drbd_md_sync(mdev);
 
         kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
- fail:
-        mutex_unlock(&mdev->state_mutex);
+out:
+        mutex_unlock(mdev->state_mutex);
         return rv;
 }
 
-static struct drbd_conf *ensure_mdev(int minor, int create)
+static const char *from_attrs_err_to_txt(int err)
 {
-        struct drbd_conf *mdev;
-
-        if (minor >= minor_count)
-                return NULL;
-
-        mdev = minor_to_mdev(minor);
-
-        if (!mdev && create) {
-                struct gendisk *disk = NULL;
-                mdev = drbd_new_device(minor);
-
-                spin_lock_irq(&drbd_pp_lock);
-                if (minor_table[minor] == NULL) {
-                        minor_table[minor] = mdev;
-                        disk = mdev->vdisk;
-                        mdev = NULL;
-                } /* else: we lost the race */
-                spin_unlock_irq(&drbd_pp_lock);
-
-                if (disk) /* we won the race above */
-                        /* in case we ever add a drbd_delete_device(),
-                         * don't forget the del_gendisk! */
-                        add_disk(disk);
-                else /* we lost the race above */
-                        drbd_free_mdev(mdev);
-
-                mdev = minor_to_mdev(minor);
-        }
-
-        return mdev;
+        return  err == -ENOMSG ? "required attribute missing" :
+                err == -EOPNOTSUPP ? "unknown mandatory attribute" :
+                err == -EEXIST ? "can not change invariant setting" :
+                "invalid attribute value";
 }
 
-static int drbd_nl_primary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                           struct drbd_nl_cfg_reply *reply)
+int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
 {
-        struct primary primary_args;
-
-        memset(&primary_args, 0, sizeof(struct primary));
-        if (!primary_from_tags(mdev, nlp->tag_list, &primary_args)) {
-                reply->ret_code = ERR_MANDATORY_TAG;
-                return 0;
-        }
-
-        reply->ret_code =
-                drbd_set_role(mdev, R_PRIMARY, primary_args.primary_force);
+        struct set_role_parms parms;
+        int err;
+        enum drbd_ret_code retcode;
 
-        return 0;
-}
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-static int drbd_nl_secondary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                             struct drbd_nl_cfg_reply *reply)
-{
-        reply->ret_code = drbd_set_role(mdev, R_SECONDARY, 0);
+        memset(&parms, 0, sizeof(parms));
+        if (info->attrs[DRBD_NLA_SET_ROLE_PARMS]) {
+                err = set_role_parms_from_attrs(&parms, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto out;
+                }
+        }
 
+        if (info->genlhdr->cmd == DRBD_ADM_PRIMARY)
+                retcode = drbd_set_role(adm_ctx.mdev, R_PRIMARY, parms.assume_uptodate);
+        else
+                retcode = drbd_set_role(adm_ctx.mdev, R_SECONDARY, 0);
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
@@ -514,7 +702,12 @@ static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
                                        struct drbd_backing_dev *bdev)
 {
         sector_t md_size_sect = 0;
-        switch (bdev->dc.meta_dev_idx) {
+        int meta_dev_idx;
+
+        rcu_read_lock();
+        meta_dev_idx = rcu_dereference(bdev->disk_conf)->meta_dev_idx;
+
+        switch (meta_dev_idx) {
         default:
                 /* v07 style fixed size indexed meta data */
                 bdev->md.md_size_sect = MD_RESERVED_SECT;
@@ -533,7 +726,7 @@ static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
         case DRBD_MD_INDEX_FLEX_INT:
                 bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
                 /* al size is still fixed */
-                bdev->md.al_offset = -MD_AL_MAX_SIZE;
+                bdev->md.al_offset = -MD_AL_SECTORS;
                 /* we need (slightly less than) ~ this much bitmap sectors: */
                 md_size_sect = drbd_get_capacity(bdev->backing_bdev);
                 md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
@@ -549,6 +742,7 @@ static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
                 bdev->md.bm_offset   = -md_size_sect + MD_AL_OFFSET;
                 break;
         }
+        rcu_read_unlock();
 }
 
 /* input size is expected to be in KB */
@@ -581,17 +775,23 @@ char *ppsize(char *buf, unsigned long long size)
  *  R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
  *  peer may not initiate a resize.
  */
+/* Note these are not to be confused with
+ * drbd_adm_suspend_io/drbd_adm_resume_io,
+ * which are (sub) state changes triggered by admin (drbdsetup),
+ * and can be long lived.
+ * This changes an mdev->flag, is triggered by drbd internals,
+ * and should be short-lived. */
 void drbd_suspend_io(struct drbd_conf *mdev)
 {
-        drbd_set_flag(mdev, SUSPEND_IO);
-        if (is_susp(mdev->state))
+        set_bit(SUSPEND_IO, &mdev->flags);
+        if (drbd_suspended(mdev))
                 return;
         wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
 }
 
 void drbd_resume_io(struct drbd_conf *mdev)
 {
-        drbd_clear_flag(mdev, SUSPEND_IO);
+        clear_bit(SUSPEND_IO, &mdev->flags);
         wake_up(&mdev->misc_wait);
 }
 
@@ -605,7 +805,7 @@ void drbd_resume_io(struct drbd_conf *mdev)
 enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *mdev, enum dds_flags flags) __must_hold(local)
 {
         sector_t prev_first_sect, prev_size; /* previous meta location */
-        sector_t la_size;
+        sector_t la_size, u_size;
         sector_t size;
         char ppb[10];
 
@@ -633,7 +833,10 @@ enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *mdev, enum dds
         /* TODO: should only be some assert here, not (re)init... */
         drbd_md_set_sector_offsets(mdev, mdev->ldev);
 
-        size = drbd_new_dev_size(mdev, mdev->ldev, flags & DDSF_FORCED);
+        rcu_read_lock();
+        u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
+        rcu_read_unlock();
+        size = drbd_new_dev_size(mdev, mdev->ldev, u_size, flags & DDSF_FORCED);
 
         if (drbd_get_capacity(mdev->this_bdev) != size ||
             drbd_bm_capacity(mdev) != size) {
@@ -696,12 +899,12 @@ out:
 }
 
 sector_t
-drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int assume_peer_has_space)
+drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev,
+                  sector_t u_size, int assume_peer_has_space)
 {
         sector_t p_size = mdev->p_size;   /* partner's disk size. */
         sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */
         sector_t m_size; /* my size */
-        sector_t u_size = bdev->dc.disk_size; /* size requested by user. */
         sector_t size = 0;
 
         m_size = drbd_get_max_capacity(bdev);
@@ -750,24 +953,21 @@ drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int ass
  * failed, and 0 on success. You should call drbd_md_sync() after you called
  * this function.
  */
-static int drbd_check_al_size(struct drbd_conf *mdev)
+static int drbd_check_al_size(struct drbd_conf *mdev, struct disk_conf *dc)
 {
         struct lru_cache *n, *t;
         struct lc_element *e;
         unsigned int in_use;
         int i;
 
-        ERR_IF(mdev->sync_conf.al_extents < 7)
-                mdev->sync_conf.al_extents = 127;
-
         if (mdev->act_log &&
-            mdev->act_log->nr_elements == mdev->sync_conf.al_extents)
+            mdev->act_log->nr_elements == dc->al_extents)
                 return 0;
 
         in_use = 0;
         t = mdev->act_log;
-        n = lc_create("act_log", drbd_al_ext_cache,
-                mdev->sync_conf.al_extents, sizeof(struct lc_element), 0);
+        n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
+                dc->al_extents, sizeof(struct lc_element), 0);
 
         if (n == NULL) {
                 dev_err(DEV, "Cannot allocate act_log lru!\n");
@@ -808,7 +1008,9 @@ static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_
                 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
 
                 max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
-                max_segments = mdev->ldev->dc.max_bio_bvecs;
+                rcu_read_lock();
+                max_segments = rcu_dereference(mdev->ldev->disk_conf)->max_bio_bvecs;
+                rcu_read_unlock();
                 put_ldev(mdev);
         }
 
@@ -852,12 +1054,14 @@ void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
            Because new from 8.3.8 onwards the peer can use multiple
            BIOs for a single peer_request */
         if (mdev->state.conn >= C_CONNECTED) {
-                if (mdev->agreed_pro_version < 94) {
-                        peer = min(mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
+                if (mdev->tconn->agreed_pro_version < 94)
+                        peer = min( mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
                         /* Correct old drbd (up to 8.3.7) if it believes it can do more than 32KiB */
-                } else if (mdev->agreed_pro_version == 94)
+                else if (mdev->tconn->agreed_pro_version == 94)
                         peer = DRBD_MAX_SIZE_H80_PACKET;
-                else /* drbd 8.3.8 onwards */
+                else if (mdev->tconn->agreed_pro_version < 100)
+                        peer = DRBD_MAX_BIO_SIZE_P95;  /* drbd 8.3.8 onwards, before 8.4.0 */
+                else
                         peer = DRBD_MAX_BIO_SIZE;
         }
 
@@ -872,36 +1076,27 @@ void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
         drbd_setup_queue_param(mdev, new);
 }
 
-/* serialize deconfig (worker exiting, doing cleanup)
- * and reconfig (drbdsetup disk, drbdsetup net)
- *
- * Wait for a potentially exiting worker, then restart it,
- * or start a new one.  Flush any pending work, there may still be an
- * after_state_change queued.
- */
-static void drbd_reconfig_start(struct drbd_conf *mdev)
+/* Starts the worker thread */
+static void conn_reconfig_start(struct drbd_tconn *tconn)
 {
-        wait_event(mdev->state_wait, !drbd_test_and_set_flag(mdev, CONFIG_PENDING));
-        wait_event(mdev->state_wait, !drbd_test_flag(mdev, DEVICE_DYING));
-        drbd_thread_start(&mdev->worker);
-        drbd_flush_workqueue(mdev);
+        drbd_thread_start(&tconn->worker);
+        conn_flush_workqueue(tconn);
 }
 
-/* if still unconfigured, stops worker again.
- * if configured now, clears CONFIG_PENDING.
- * wakes potential waiters */
-static void drbd_reconfig_done(struct drbd_conf *mdev)
+/* if still unconfigured, stops worker again. */
+static void conn_reconfig_done(struct drbd_tconn *tconn)
 {
-        spin_lock_irq(&mdev->req_lock);
-        if (mdev->state.disk == D_DISKLESS &&
-            mdev->state.conn == C_STANDALONE &&
-            mdev->state.role == R_SECONDARY) {
-                drbd_set_flag(mdev, DEVICE_DYING);
-                drbd_thread_stop_nowait(&mdev->worker);
-        } else
-                drbd_clear_flag(mdev, CONFIG_PENDING);
-        spin_unlock_irq(&mdev->req_lock);
-        wake_up(&mdev->state_wait);
+        bool stop_threads;
+        spin_lock_irq(&tconn->req_lock);
+        stop_threads = conn_all_vols_unconf(tconn) &&
+                tconn->cstate == C_STANDALONE;
+        spin_unlock_irq(&tconn->req_lock);
+        if (stop_threads) {
+                /* asender is implicitly stopped by receiver
+                 * in conn_disconnect() */
+                drbd_thread_stop(&tconn->receiver);
+                drbd_thread_stop(&tconn->worker);
+        }
 }
 
 /* Make sure IO is suspended before calling this function(). */
@@ -909,42 +1104,182 @@ static void drbd_suspend_al(struct drbd_conf *mdev)
 {
         int s = 0;
 
-        if (lc_try_lock(mdev->act_log)) {
-                drbd_al_shrink(mdev);
-                lc_unlock(mdev->act_log);
-        } else {
+        if (!lc_try_lock(mdev->act_log)) {
                 dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
                 return;
         }
 
-        spin_lock_irq(&mdev->req_lock);
+        drbd_al_shrink(mdev);
+        spin_lock_irq(&mdev->tconn->req_lock);
         if (mdev->state.conn < C_CONNECTED)
-                s = !drbd_test_and_set_flag(mdev, AL_SUSPENDED);
-
-        spin_unlock_irq(&mdev->req_lock);
+                s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
+        spin_unlock_irq(&mdev->tconn->req_lock);
+        lc_unlock(mdev->act_log);
 
         if (s)
                 dev_info(DEV, "Suspended AL updates\n");
 }
 
-/* does always return 0;
- * interesting return code is in reply->ret_code */
-static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                             struct drbd_nl_cfg_reply *reply)
+
+static bool should_set_defaults(struct genl_info *info)
+{
+        unsigned flags = ((struct drbd_genlmsghdr*)info->userhdr)->flags;
+        return 0 != (flags & DRBD_GENL_F_SET_DEFAULTS);
+}
+
+static void enforce_disk_conf_limits(struct disk_conf *dc)
+{
+        if (dc->al_extents < DRBD_AL_EXTENTS_MIN)
+                dc->al_extents = DRBD_AL_EXTENTS_MIN;
+        if (dc->al_extents > DRBD_AL_EXTENTS_MAX)
+                dc->al_extents = DRBD_AL_EXTENTS_MAX;
+
+        if (dc->c_plan_ahead > DRBD_C_PLAN_AHEAD_MAX)
+                dc->c_plan_ahead = DRBD_C_PLAN_AHEAD_MAX;
+}
+
+int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
 {
         enum drbd_ret_code retcode;
+        struct drbd_conf *mdev;
+        struct disk_conf *new_disk_conf, *old_disk_conf;
+        struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
+        int err, fifo_size;
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        mdev = adm_ctx.mdev;
+
+        /* we also need a disk
+         * to change the options on */
+        if (!get_ldev(mdev)) {
+                retcode = ERR_NO_DISK;
+                goto out;
+        }
+
+        new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
+        if (!new_disk_conf) {
+                retcode = ERR_NOMEM;
+                goto fail;
+        }
+
+        mutex_lock(&mdev->tconn->conf_update);
+        old_disk_conf = mdev->ldev->disk_conf;
+        *new_disk_conf = *old_disk_conf;
+        if (should_set_defaults(info))
+                set_disk_conf_defaults(new_disk_conf);
+
+        err = disk_conf_from_attrs_for_change(new_disk_conf, info);
+        if (err && err != -ENOMSG) {
+                retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
+        }
+
+        if (!expect(new_disk_conf->resync_rate >= 1))
+                new_disk_conf->resync_rate = 1;
+
+        enforce_disk_conf_limits(new_disk_conf);
+
+        fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
+        if (fifo_size != mdev->rs_plan_s->size) {
+                new_plan = fifo_alloc(fifo_size);
+                if (!new_plan) {
+                        dev_err(DEV, "kmalloc of fifo_buffer failed");
+                        retcode = ERR_NOMEM;
+                        goto fail_unlock;
+                }
+        }
+
+        drbd_suspend_io(mdev);
+        wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
+        drbd_al_shrink(mdev);
+        err = drbd_check_al_size(mdev, new_disk_conf);
+        lc_unlock(mdev->act_log);
+        wake_up(&mdev->al_wait);
+        drbd_resume_io(mdev);
+
+        if (err) {
+                retcode = ERR_NOMEM;
+                goto fail_unlock;
+        }
+
+        write_lock_irq(&global_state_lock);
+        retcode = drbd_resync_after_valid(mdev, new_disk_conf->resync_after);
+        if (retcode == NO_ERROR) {
+                rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
+                drbd_resync_after_changed(mdev);
+        }
+        write_unlock_irq(&global_state_lock);
+
+        if (retcode != NO_ERROR)
+                goto fail_unlock;
+
+        if (new_plan) {
+                old_plan = mdev->rs_plan_s;
+                rcu_assign_pointer(mdev->rs_plan_s, new_plan);
+        }
+
+        mutex_unlock(&mdev->tconn->conf_update);
+
+        if (new_disk_conf->al_updates)
+                mdev->ldev->md.flags &= ~MDF_AL_DISABLED;
+        else
+                mdev->ldev->md.flags |= MDF_AL_DISABLED;
+
+        drbd_bump_write_ordering(mdev->tconn, WO_bdev_flush);
+
+        drbd_md_sync(mdev);
+
+        if (mdev->state.conn >= C_CONNECTED)
+                drbd_send_sync_param(mdev);
+
+        synchronize_rcu();
+        kfree(old_disk_conf);
+        kfree(old_plan);
+        mod_timer(&mdev->request_timer, jiffies + HZ);
+        goto success;
+
+fail_unlock:
+        mutex_unlock(&mdev->tconn->conf_update);
+ fail:
+        kfree(new_disk_conf);
+        kfree(new_plan);
+success:
+        put_ldev(mdev);
+ out:
+        drbd_adm_finish(info, retcode);
+        return 0;
+}
+
+int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
+{
+        struct drbd_conf *mdev;
+        int err;
+        enum drbd_ret_code retcode;
         enum determine_dev_size dd;
         sector_t max_possible_sectors;
         sector_t min_md_device_sectors;
         struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
+        struct disk_conf *new_disk_conf = NULL;
         struct block_device *bdev;
         struct lru_cache *resync_lru = NULL;
+        struct fifo_buffer *new_plan = NULL;
         union drbd_state ns, os;
         enum drbd_state_rv rv;
-        int cp_discovered = 0;
-        int logical_block_size;
+        struct net_conf *nc;
 
-        drbd_reconfig_start(mdev);
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto finish;
+
+        mdev = adm_ctx.mdev;
+        conn_reconfig_start(mdev->tconn);
 
         /* if you want to reconfigure, please tear down first */
         if (mdev->state.disk > D_DISKLESS) {
@@ -958,52 +1293,66 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
 
         /* make sure there is no leftover from previous force-detach attempts */
-        drbd_clear_flag(mdev, FORCE_DETACH);
-        drbd_clear_flag(mdev, WAS_IO_ERROR);
-        drbd_clear_flag(mdev, WAS_READ_ERROR);
+        clear_bit(FORCE_DETACH, &mdev->flags);
+        clear_bit(WAS_IO_ERROR, &mdev->flags);
+        clear_bit(WAS_READ_ERROR, &mdev->flags);
 
         /* and no leftover from previously aborted resync or verify, either */
         mdev->rs_total = 0;
         mdev->rs_failed = 0;
         atomic_set(&mdev->rs_pending_cnt, 0);
 
-        /* allocation not in the IO path, cqueue thread context */
+        /* allocation not in the IO path, drbdsetup context */
         nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
         if (!nbc) {
                 retcode = ERR_NOMEM;
                 goto fail;
         }
-
-        nbc->dc.disk_size     = DRBD_DISK_SIZE_SECT_DEF;
-        nbc->dc.on_io_error   = DRBD_ON_IO_ERROR_DEF;
-        nbc->dc.fencing       = DRBD_FENCING_DEF;
-        nbc->dc.max_bio_bvecs = DRBD_MAX_BIO_BVECS_DEF;
-
         spin_lock_init(&nbc->md.uuid_lock);
 
-        if (!disk_conf_from_tags(mdev, nlp->tag_list, &nbc->dc)) {
+        new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
+        if (!new_disk_conf) {
+                retcode = ERR_NOMEM;
+                goto fail;
+        }
+        nbc->disk_conf = new_disk_conf;
+
+        set_disk_conf_defaults(new_disk_conf);
+        err = disk_conf_from_attrs(new_disk_conf, info);
+        if (err) {
                 retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
                 goto fail;
         }
 
-        if (nbc->dc.meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
+        enforce_disk_conf_limits(new_disk_conf);
+
+        new_plan = fifo_alloc((new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ);
+        if (!new_plan) {
+                retcode = ERR_NOMEM;
+                goto fail;
+        }
+
+        if (new_disk_conf->meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
                 retcode = ERR_MD_IDX_INVALID;
                 goto fail;
         }
 
-        if (get_net_conf(mdev)) {
-                int prot = mdev->net_conf->wire_protocol;
-                put_net_conf(mdev);
-                if (nbc->dc.fencing == FP_STONITH && prot == DRBD_PROT_A) {
+        rcu_read_lock();
+        nc = rcu_dereference(mdev->tconn->net_conf);
+        if (nc) {
+                if (new_disk_conf->fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
+                        rcu_read_unlock();
                         retcode = ERR_STONITH_AND_PROT_A;
                         goto fail;
                 }
         }
+        rcu_read_unlock();
 
-        bdev = blkdev_get_by_path(nbc->dc.backing_dev,
+        bdev = blkdev_get_by_path(new_disk_conf->backing_dev,
                                   FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
         if (IS_ERR(bdev)) {
-                dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev,
+                dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->backing_dev,
                         PTR_ERR(bdev));
                 retcode = ERR_OPEN_DISK;
                 goto fail;
@@ -1018,12 +1367,12 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
          * should check it for you already; but if you don't, or
          * someone fooled it, we need to double check here)
          */
-        bdev = blkdev_get_by_path(nbc->dc.meta_dev,
+        bdev = blkdev_get_by_path(new_disk_conf->meta_dev,
                                   FMODE_READ | FMODE_WRITE | FMODE_EXCL,
-                                  (nbc->dc.meta_dev_idx < 0) ?
+                                  (new_disk_conf->meta_dev_idx < 0) ?
                                   (void *)mdev : (void *)drbd_m_holder);
         if (IS_ERR(bdev)) {
-                dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev,
+                dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->meta_dev,
                         PTR_ERR(bdev));
                 retcode = ERR_OPEN_MD_DISK;
                 goto fail;
@@ -1031,14 +1380,14 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         nbc->md_bdev = bdev;
 
         if ((nbc->backing_bdev == nbc->md_bdev) !=
-            (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
-             nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
+            (new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
+             new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
                 retcode = ERR_MD_IDX_INVALID;
                 goto fail;
         }
 
         resync_lru = lc_create("resync", drbd_bm_ext_cache,
-                        61, sizeof(struct bm_extent),
+                        1, 61, sizeof(struct bm_extent),
                         offsetof(struct bm_extent, lce));
         if (!resync_lru) {
                 retcode = ERR_NOMEM;
@@ -1048,21 +1397,21 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
         drbd_md_set_sector_offsets(mdev, nbc);
 
-        if (drbd_get_max_capacity(nbc) < nbc->dc.disk_size) {
+        if (drbd_get_max_capacity(nbc) < new_disk_conf->disk_size) {
                 dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
                         (unsigned long long) drbd_get_max_capacity(nbc),
-                        (unsigned long long) nbc->dc.disk_size);
+                        (unsigned long long) new_disk_conf->disk_size);
                 retcode = ERR_DISK_TOO_SMALL;
                 goto fail;
         }
 
-        if (nbc->dc.meta_dev_idx < 0) {
+        if (new_disk_conf->meta_dev_idx < 0) {
                 max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
                 /* at least one MB, otherwise it does not make sense */
                 min_md_device_sectors = (2<<10);
         } else {
                 max_possible_sectors = DRBD_MAX_SECTORS;
-                min_md_device_sectors = MD_RESERVED_SECT * (nbc->dc.meta_dev_idx + 1);
+                min_md_device_sectors = MD_RESERVED_SECT * (new_disk_conf->meta_dev_idx + 1);
         }
 
         if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
@@ -1087,14 +1436,20 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                 dev_warn(DEV, "==> truncating very big lower level device "
                         "to currently maximum possible %llu sectors <==\n",
                         (unsigned long long) max_possible_sectors);
-                if (nbc->dc.meta_dev_idx >= 0)
+                if (new_disk_conf->meta_dev_idx >= 0)
                         dev_warn(DEV, "==>> using internal or flexible "
                                       "meta data may help <<==\n");
         }
 
         drbd_suspend_io(mdev);
         /* also wait for the last barrier ack. */
-        wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || is_susp(mdev->state));
+        /* FIXME see also https://daiquiri.linbit/cgi-bin/bugzilla/show_bug.cgi?id=171
+         * We need a way to either ignore barrier acks for barriers sent before a device
+         * was attached, or a way to wait for all pending barrier acks to come in.
+         * As barriers are counted per resource,
+         * we'd need to suspend io on all devices of a resource.
+         */
+        wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
         /* and for any other previously queued work */
         drbd_flush_workqueue(mdev);
 
@@ -1109,25 +1464,6 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
 
         drbd_md_set_sector_offsets(mdev, nbc);
 
-        /* allocate a second IO page if logical_block_size != 512 */
-        logical_block_size = bdev_logical_block_size(nbc->md_bdev);
-        if (logical_block_size == 0)
-                logical_block_size = MD_SECTOR_SIZE;
-
-        if (logical_block_size != MD_SECTOR_SIZE) {
-                if (!mdev->md_io_tmpp) {
-                        struct page *page = alloc_page(GFP_NOIO);
-                        if (!page)
-                                goto force_diskless_dec;
-
-                        dev_warn(DEV, "Meta data's bdev logical_block_size = %d != %d\n",
-                             logical_block_size, MD_SECTOR_SIZE);
-                        dev_warn(DEV, "Workaround engaged (has performance impact).\n");
-
-                        mdev->md_io_tmpp = page;
-                }
-        }
-
         if (!mdev->bitmap) {
                 if (drbd_bm_init(mdev)) {
                         retcode = ERR_NOMEM;
@@ -1149,30 +1485,25 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         }
 
         /* Since we are diskless, fix the activity log first... */
-        if (drbd_check_al_size(mdev)) {
+        if (drbd_check_al_size(mdev, new_disk_conf)) {
                 retcode = ERR_NOMEM;
                 goto force_diskless_dec;
         }
 
         /* Prevent shrinking of consistent devices ! */
         if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
-            drbd_new_dev_size(mdev, nbc, 0) < nbc->md.la_size_sect) {
+            drbd_new_dev_size(mdev, nbc, nbc->disk_conf->disk_size, 0) < nbc->md.la_size_sect) {
                 dev_warn(DEV, "refusing to truncate a consistent device\n");
                 retcode = ERR_DISK_TOO_SMALL;
                 goto force_diskless_dec;
         }
 
-        if (!drbd_al_read_log(mdev, nbc)) {
-                retcode = ERR_IO_MD_DISK;
-                goto force_diskless_dec;
-        }
-
         /* Reset the "barriers don't work" bits here, then force meta data to
          * be written, to ensure we determine if barriers are supported. */
-        if (nbc->dc.no_md_flush)
-                drbd_set_flag(mdev, MD_NO_FUA);
+        if (new_disk_conf->md_flushes)
+                clear_bit(MD_NO_FUA, &mdev->flags);
         else
-                drbd_clear_flag(mdev, MD_NO_FUA);
+                set_bit(MD_NO_FUA, &mdev->flags);
 
         /* Point of no return reached.
          * Devices and memory are no longer released by error cleanup below.
@@ -1181,22 +1512,22 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         D_ASSERT(mdev->ldev == NULL);
         mdev->ldev = nbc;
         mdev->resync = resync_lru;
+        mdev->rs_plan_s = new_plan;
         nbc = NULL;
         resync_lru = NULL;
+        new_disk_conf = NULL;
+        new_plan = NULL;
 
-        mdev->write_ordering = WO_bdev_flush;
-        drbd_bump_write_ordering(mdev, WO_bdev_flush);
+        drbd_bump_write_ordering(mdev->tconn, WO_bdev_flush);
 
         if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
-                drbd_set_flag(mdev, CRASHED_PRIMARY);
+                set_bit(CRASHED_PRIMARY, &mdev->flags);
         else
-                drbd_clear_flag(mdev, CRASHED_PRIMARY);
+                clear_bit(CRASHED_PRIMARY, &mdev->flags);
 
         if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
-            !(mdev->state.role == R_PRIMARY && mdev->state.susp_nod)) {
-                drbd_set_flag(mdev, CRASHED_PRIMARY);
-                cp_discovered = 1;
-        }
+            !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod))
+                set_bit(CRASHED_PRIMARY, &mdev->flags);
 
         mdev->send_cnt = 0;
         mdev->recv_cnt = 0;
@@ -1219,20 +1550,22 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
          * so we can automatically recover from a crash of a
          * degraded but active "cluster" after a certain timeout.
          */
-        drbd_clear_flag(mdev, USE_DEGR_WFC_T);
+        clear_bit(USE_DEGR_WFC_T, &mdev->flags);
         if (mdev->state.role != R_PRIMARY &&
              drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
             !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
-                drbd_set_flag(mdev, USE_DEGR_WFC_T);
+                set_bit(USE_DEGR_WFC_T, &mdev->flags);
 
         dd = drbd_determine_dev_size(mdev, 0);
         if (dd == dev_size_error) {
                 retcode = ERR_NOMEM_BITMAP;
                 goto force_diskless_dec;
         } else if (dd == grew)
-                drbd_set_flag(mdev, RESYNC_AFTER_NEG);
+                set_bit(RESYNC_AFTER_NEG, &mdev->flags);
 
-        if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
+        if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC) ||
+            (test_bit(CRASHED_PRIMARY, &mdev->flags) &&
+             drbd_md_test_flag(mdev->ldev, MDF_AL_DISABLED))) {
                 dev_info(DEV, "Assuming that all blocks are out of sync "
                      "(aka FullSync)\n");
                 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
@@ -1242,16 +1575,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                 }
         } else {
                 if (drbd_bitmap_io(mdev, &drbd_bm_read,
-                        "read from attaching", BM_LOCKED_MASK) < 0) {
-                        retcode = ERR_IO_MD_DISK;
-                        goto force_diskless_dec;
-                }
-        }
-
-        if (cp_discovered) {
-                drbd_al_apply_to_bm(mdev);
-                if (drbd_bitmap_io(mdev, &drbd_bm_write,
-                        "crashed primary apply AL", BM_LOCKED_MASK)) {
+                        "read from attaching", BM_LOCKED_MASK)) {
                         retcode = ERR_IO_MD_DISK;
                         goto force_diskless_dec;
                 }
@@ -1260,9 +1584,9 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
                 drbd_suspend_al(mdev); /* IO is still suspended here... */
 
-        spin_lock_irq(&mdev->req_lock);
-        os = mdev->state;
-        ns.i = os.i;
+        spin_lock_irq(&mdev->tconn->req_lock);
+        os = drbd_read_state(mdev);
+        ns = os;
         /* If MDF_CONSISTENT is not set go into inconsistent state,
            otherwise investigate MDF_WasUpToDate...
            If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
@@ -1280,8 +1604,9 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
                 ns.pdsk = D_OUTDATED;
 
-        if ( ns.disk == D_CONSISTENT &&
-            (ns.pdsk == D_OUTDATED || mdev->ldev->dc.fencing == FP_DONT_CARE))
+        rcu_read_lock();
+        if (ns.disk == D_CONSISTENT &&
+            (ns.pdsk == D_OUTDATED || rcu_dereference(mdev->ldev->disk_conf)->fencing == FP_DONT_CARE))
                 ns.disk = D_UP_TO_DATE;
 
         /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
@@ -1289,6 +1614,13 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
            this point, because drbd_request_state() modifies these
            flags. */
 
+        if (rcu_dereference(mdev->ldev->disk_conf)->al_updates)
+                mdev->ldev->md.flags &= ~MDF_AL_DISABLED;
+        else
+                mdev->ldev->md.flags |= MDF_AL_DISABLED;
+
+        rcu_read_unlock();
+
         /* In case we are C_CONNECTED postpone any decision on the new disk
            state after the negotiation phase. */
         if (mdev->state.conn == C_CONNECTED) {
@@ -1304,12 +1636,13 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         }
 
         rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
-        ns = mdev->state;
-        spin_unlock_irq(&mdev->req_lock);
+        spin_unlock_irq(&mdev->tconn->req_lock);
 
         if (rv < SS_SUCCESS)
                 goto force_diskless_dec;
 
+        mod_timer(&mdev->request_timer, jiffies + HZ);
+
         if (mdev->state.role == R_PRIMARY)
                 mdev->ldev->md.uuid[UI_CURRENT] |=  (u64)1;
         else
@@ -1320,16 +1653,17 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
 
         kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
         put_ldev(mdev);
-        reply->ret_code = retcode;
-        drbd_reconfig_done(mdev);
+        conn_reconfig_done(mdev->tconn);
+        drbd_adm_finish(info, retcode);
         return 0;
 
  force_diskless_dec:
         put_ldev(mdev);
  force_diskless:
-        drbd_force_state(mdev, NS(disk, D_FAILED));
+        drbd_force_state(mdev, NS(disk, D_DISKLESS));
         drbd_md_sync(mdev);
  fail:
+        conn_reconfig_done(mdev->tconn);
         if (nbc) {
                 if (nbc->backing_bdev)
                         blkdev_put(nbc->backing_bdev,
@@ -1339,34 +1673,24 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                                    FMODE_READ | FMODE_WRITE | FMODE_EXCL);
                 kfree(nbc);
         }
+        kfree(new_disk_conf);
         lc_destroy(resync_lru);
+        kfree(new_plan);
 
-        reply->ret_code = retcode;
-        drbd_reconfig_done(mdev);
+ finish:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-/* Detaching the disk is a process in multiple stages.  First we need to lock
- * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
- * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
- * internal references as well.
- * Only then we have finally detached. */
-static int drbd_nl_detach(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                          struct drbd_nl_cfg_reply *reply)
+static int adm_detach(struct drbd_conf *mdev, int force)
 {
-        enum drbd_ret_code retcode;
+        enum drbd_state_rv retcode;
         int ret;
-        struct detach dt = {};
 
-        if (!detach_from_tags(mdev, nlp->tag_list, &dt)) {
-                reply->ret_code = ERR_MANDATORY_TAG;
-                goto out;
-        }
-
-        if (dt.detach_force) {
-                drbd_set_flag(mdev, FORCE_DETACH);
+        if (force) {
+                set_bit(FORCE_DETACH, &mdev->flags);
                 drbd_force_state(mdev, NS(disk, D_FAILED));
-                reply->ret_code = SS_SUCCESS;
+                retcode = SS_SUCCESS;
                 goto out;
         }
 
@@ -1378,326 +1702,529 @@ static int drbd_nl_detach(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
         ret = wait_event_interruptible(mdev->misc_wait,
                         mdev->state.disk != D_FAILED);
         drbd_resume_io(mdev);
-
         if ((int)retcode == (int)SS_IS_DISKLESS)
                 retcode = SS_NOTHING_TO_DO;
         if (ret)
                 retcode = ERR_INTR;
-        reply->ret_code = retcode;
 out:
-        return 0;
+        return retcode;
 }
 
-static int drbd_nl_net_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                            struct drbd_nl_cfg_reply *reply)
+/* Detaching the disk is a process in multiple stages.  First we need to lock
+ * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
+ * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
+ * internal references as well.
+ * Only then we have finally detached. */
+int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
 {
-        int i, ns;
         enum drbd_ret_code retcode;
-        struct net_conf *new_conf = NULL;
-        struct crypto_hash *tfm = NULL;
-        struct crypto_hash *integrity_w_tfm = NULL;
-        struct crypto_hash *integrity_r_tfm = NULL;
-        struct hlist_head *new_tl_hash = NULL;
-        struct hlist_head *new_ee_hash = NULL;
-        struct drbd_conf *odev;
-        char hmac_name[CRYPTO_MAX_ALG_NAME];
-        void *int_dig_out = NULL;
-        void *int_dig_in = NULL;
-        void *int_dig_vv = NULL;
-        struct sockaddr *new_my_addr, *new_peer_addr, *taken_addr;
+        struct detach_parms parms = { };
+        int err;
 
-        drbd_reconfig_start(mdev);
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        if (mdev->state.conn > C_STANDALONE) {
-                retcode = ERR_NET_CONFIGURED;
-                goto fail;
+        if (info->attrs[DRBD_NLA_DETACH_PARMS]) {
+                err = detach_parms_from_attrs(&parms, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto out;
+                }
+        }
+
+        retcode = adm_detach(adm_ctx.mdev, parms.force_detach);
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
+}
+
+static bool conn_resync_running(struct drbd_tconn *tconn)
+{
+        struct drbd_conf *mdev;
+        bool rv = false;
+        int vnr;
+
+        rcu_read_lock();
+        idr_for_each_entry(&tconn->volumes, mdev, vnr) {
+                if (mdev->state.conn == C_SYNC_SOURCE ||
+                    mdev->state.conn == C_SYNC_TARGET ||
+                    mdev->state.conn == C_PAUSED_SYNC_S ||
+                    mdev->state.conn == C_PAUSED_SYNC_T) {
+                        rv = true;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+
+        return rv;
+}
+
+static bool conn_ov_running(struct drbd_tconn *tconn)
+{
+        struct drbd_conf *mdev;
+        bool rv = false;
+        int vnr;
+
+        rcu_read_lock();
+        idr_for_each_entry(&tconn->volumes, mdev, vnr) {
+                if (mdev->state.conn == C_VERIFY_S ||
+                    mdev->state.conn == C_VERIFY_T) {
+                        rv = true;
+                        break;
+                }
+        }
+        rcu_read_unlock();
+
+        return rv;
+}
+
+static enum drbd_ret_code
+_check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
+{
+        struct drbd_conf *mdev;
+        int i;
+
+        if (old_conf && tconn->cstate == C_WF_REPORT_PARAMS && tconn->agreed_pro_version < 100) {
+                if (new_conf->wire_protocol != old_conf->wire_protocol)
+                        return ERR_NEED_APV_100;
+
+                if (new_conf->two_primaries != old_conf->two_primaries)
+                        return ERR_NEED_APV_100;
+
+                if (strcmp(new_conf->integrity_alg, old_conf->integrity_alg))
+                        return ERR_NEED_APV_100;
+        }
+
+        if (!new_conf->two_primaries &&
+            conn_highest_role(tconn) == R_PRIMARY &&
+            conn_highest_peer(tconn) == R_PRIMARY)
+                return ERR_NEED_ALLOW_TWO_PRI;
+
+        if (new_conf->two_primaries &&
+            (new_conf->wire_protocol != DRBD_PROT_C))
+                return ERR_NOT_PROTO_C;
+
+        idr_for_each_entry(&tconn->volumes, mdev, i) {
+                if (get_ldev(mdev)) {
+                        enum drbd_fencing_p fp = rcu_dereference(mdev->ldev->disk_conf)->fencing;
+                        put_ldev(mdev);
+                        if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
+                                return ERR_STONITH_AND_PROT_A;
+                }
+                if (mdev->state.role == R_PRIMARY && new_conf->discard_my_data)
+                        return ERR_DISCARD_IMPOSSIBLE;
+        }
+
+        if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
+                return ERR_CONG_NOT_PROTO_A;
+
+        return NO_ERROR;
+}
+
+static enum drbd_ret_code
+check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
+{
+        static enum drbd_ret_code rv;
+        struct drbd_conf *mdev;
+        int i;
+
+        rcu_read_lock();
+        rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
+        rcu_read_unlock();
+
+        /* tconn->volumes protected by genl_lock() here */
+        idr_for_each_entry(&tconn->volumes, mdev, i) {
+                if (!mdev->bitmap) {
+                        if(drbd_bm_init(mdev))
+                                return ERR_NOMEM;
+                }
+        }
+
+        return rv;
+}
+
+struct crypto {
+        struct crypto_hash *verify_tfm;
+        struct crypto_hash *csums_tfm;
+        struct crypto_hash *cram_hmac_tfm;
+        struct crypto_hash *integrity_tfm;
+};
+
+static int
+alloc_hash(struct crypto_hash **tfm, char *tfm_name, int err_alg)
+{
+        if (!tfm_name[0])
+                return NO_ERROR;
+
+        *tfm = crypto_alloc_hash(tfm_name, 0, CRYPTO_ALG_ASYNC);
+        if (IS_ERR(*tfm)) {
+                *tfm = NULL;
+                return err_alg;
         }
 
-        /* allocation not in the IO path, cqueue thread context */
+        return NO_ERROR;
+}
+
+static enum drbd_ret_code
+alloc_crypto(struct crypto *crypto, struct net_conf *new_conf)
+{
+        char hmac_name[CRYPTO_MAX_ALG_NAME];
+        enum drbd_ret_code rv;
+
+        rv = alloc_hash(&crypto->csums_tfm, new_conf->csums_alg,
+                       ERR_CSUMS_ALG);
+        if (rv != NO_ERROR)
+                return rv;
+        rv = alloc_hash(&crypto->verify_tfm, new_conf->verify_alg,
+                       ERR_VERIFY_ALG);
+        if (rv != NO_ERROR)
+                return rv;
+        rv = alloc_hash(&crypto->integrity_tfm, new_conf->integrity_alg,
+                       ERR_INTEGRITY_ALG);
+        if (rv != NO_ERROR)
+                return rv;
+        if (new_conf->cram_hmac_alg[0] != 0) {
+                snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
+                         new_conf->cram_hmac_alg);
+
+                rv = alloc_hash(&crypto->cram_hmac_tfm, hmac_name,
+                               ERR_AUTH_ALG);
+        }
+
+        return rv;
+}
+
+static void free_crypto(struct crypto *crypto)
+{
+        crypto_free_hash(crypto->cram_hmac_tfm);
+        crypto_free_hash(crypto->integrity_tfm);
+        crypto_free_hash(crypto->csums_tfm);
+        crypto_free_hash(crypto->verify_tfm);
+}
+
+int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
+{
+        enum drbd_ret_code retcode;
+        struct drbd_tconn *tconn;
+        struct net_conf *old_conf, *new_conf = NULL;
+        int err;
+        int ovr; /* online verify running */
+        int rsr; /* re-sync running */
+        struct crypto crypto = { };
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        tconn = adm_ctx.tconn;
+
         new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
         if (!new_conf) {
                 retcode = ERR_NOMEM;
+                goto out;
+        }
+
+        conn_reconfig_start(tconn);
+
+        mutex_lock(&tconn->data.mutex);
+        mutex_lock(&tconn->conf_update);
+        old_conf = tconn->net_conf;
+
+        if (!old_conf) {
+                drbd_msg_put_info("net conf missing, try connect");
+                retcode = ERR_INVALID_REQUEST;
                 goto fail;
         }
 
-        new_conf->timeout          = DRBD_TIMEOUT_DEF;
-        new_conf->try_connect_int  = DRBD_CONNECT_INT_DEF;
-        new_conf->ping_int         = DRBD_PING_INT_DEF;
-        new_conf->max_epoch_size   = DRBD_MAX_EPOCH_SIZE_DEF;
-        new_conf->max_buffers      = DRBD_MAX_BUFFERS_DEF;
-        new_conf->unplug_watermark = DRBD_UNPLUG_WATERMARK_DEF;
-        new_conf->sndbuf_size      = DRBD_SNDBUF_SIZE_DEF;
-        new_conf->rcvbuf_size      = DRBD_RCVBUF_SIZE_DEF;
-        new_conf->ko_count         = DRBD_KO_COUNT_DEF;
-        new_conf->after_sb_0p      = DRBD_AFTER_SB_0P_DEF;
-        new_conf->after_sb_1p      = DRBD_AFTER_SB_1P_DEF;
-        new_conf->after_sb_2p      = DRBD_AFTER_SB_2P_DEF;
-        new_conf->want_lose        = 0;
-        new_conf->two_primaries    = 0;
-        new_conf->wire_protocol    = DRBD_PROT_C;
-        new_conf->ping_timeo       = DRBD_PING_TIMEO_DEF;
-        new_conf->rr_conflict      = DRBD_RR_CONFLICT_DEF;
-        new_conf->on_congestion    = DRBD_ON_CONGESTION_DEF;
-        new_conf->cong_extents     = DRBD_CONG_EXTENTS_DEF;
-
-        if (!net_conf_from_tags(mdev, nlp->tag_list, new_conf)) {
+        *new_conf = *old_conf;
+        if (should_set_defaults(info))
+                set_net_conf_defaults(new_conf);
+
+        err = net_conf_from_attrs_for_change(new_conf, info);
+        if (err && err != -ENOMSG) {
                 retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
                 goto fail;
         }
 
-        if (new_conf->two_primaries
-            && (new_conf->wire_protocol != DRBD_PROT_C)) {
-                retcode = ERR_NOT_PROTO_C;
+        retcode = check_net_options(tconn, new_conf);
+        if (retcode != NO_ERROR)
                 goto fail;
-        }
 
-        if (get_ldev(mdev)) {
-                enum drbd_fencing_p fp = mdev->ldev->dc.fencing;
-                put_ldev(mdev);
-                if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH) {
-                        retcode = ERR_STONITH_AND_PROT_A;
-                        goto fail;
-                }
+        /* re-sync running */
+        rsr = conn_resync_running(tconn);
+        if (rsr && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
+                retcode = ERR_CSUMS_RESYNC_RUNNING;
+                goto fail;
         }
 
-        if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A) {
-                retcode = ERR_CONG_NOT_PROTO_A;
+        /* online verify running */
+        ovr = conn_ov_running(tconn);
+        if (ovr && strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
+                retcode = ERR_VERIFY_RUNNING;
                 goto fail;
         }
 
-        if (mdev->state.role == R_PRIMARY && new_conf->want_lose) {
-                retcode = ERR_DISCARD;
+        retcode = alloc_crypto(&crypto, new_conf);
+        if (retcode != NO_ERROR)
                 goto fail;
-        }
 
-        retcode = NO_ERROR;
+        rcu_assign_pointer(tconn->net_conf, new_conf);
 
-        new_my_addr = (struct sockaddr *)&new_conf->my_addr;
-        new_peer_addr = (struct sockaddr *)&new_conf->peer_addr;
-        for (i = 0; i < minor_count; i++) {
-                odev = minor_to_mdev(i);
-                if (!odev || odev == mdev)
-                        continue;
-                if (get_net_conf(odev)) {
-                        taken_addr = (struct sockaddr *)&odev->net_conf->my_addr;
-                        if (new_conf->my_addr_len == odev->net_conf->my_addr_len &&
-                            !memcmp(new_my_addr, taken_addr, new_conf->my_addr_len))
-                                retcode = ERR_LOCAL_ADDR;
-
-                        taken_addr = (struct sockaddr *)&odev->net_conf->peer_addr;
-                        if (new_conf->peer_addr_len == odev->net_conf->peer_addr_len &&
-                            !memcmp(new_peer_addr, taken_addr, new_conf->peer_addr_len))
-                                retcode = ERR_PEER_ADDR;
-
-                        put_net_conf(odev);
-                        if (retcode != NO_ERROR)
-                                goto fail;
-                }
+        if (!rsr) {
+                crypto_free_hash(tconn->csums_tfm);
+                tconn->csums_tfm = crypto.csums_tfm;
+                crypto.csums_tfm = NULL;
+        }
+        if (!ovr) {
+                crypto_free_hash(tconn->verify_tfm);
+                tconn->verify_tfm = crypto.verify_tfm;
+                crypto.verify_tfm = NULL;
         }
 
-        if (new_conf->cram_hmac_alg[0] != 0) {
-                snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
-                        new_conf->cram_hmac_alg);
-                tfm = crypto_alloc_hash(hmac_name, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(tfm)) {
-                        tfm = NULL;
-                        retcode = ERR_AUTH_ALG;
-                        goto fail;
-                }
+        crypto_free_hash(tconn->integrity_tfm);
+        tconn->integrity_tfm = crypto.integrity_tfm;
+        if (tconn->cstate >= C_WF_REPORT_PARAMS && tconn->agreed_pro_version >= 100)
+                /* Do this without trying to take tconn->data.mutex again.  */
+                __drbd_send_protocol(tconn, P_PROTOCOL_UPDATE);
 
-                if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
-                        retcode = ERR_AUTH_ALG_ND;
-                        goto fail;
-                }
-        }
+        crypto_free_hash(tconn->cram_hmac_tfm);
+        tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
 
-        if (new_conf->integrity_alg[0]) {
-                integrity_w_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(integrity_w_tfm)) {
-                        integrity_w_tfm = NULL;
-                        retcode=ERR_INTEGRITY_ALG;
-                        goto fail;
-                }
+        mutex_unlock(&tconn->conf_update);
+        mutex_unlock(&tconn->data.mutex);
+        synchronize_rcu();
+        kfree(old_conf);
 
-                if (!drbd_crypto_is_hash(crypto_hash_tfm(integrity_w_tfm))) {
-                        retcode=ERR_INTEGRITY_ALG_ND;
-                        goto fail;
-                }
+        if (tconn->cstate >= C_WF_REPORT_PARAMS)
+                drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));
 
-                integrity_r_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(integrity_r_tfm)) {
-                        integrity_r_tfm = NULL;
-                        retcode=ERR_INTEGRITY_ALG;
-                        goto fail;
-                }
+        goto done;
+
+ fail:
+        mutex_unlock(&tconn->conf_update);
+        mutex_unlock(&tconn->data.mutex);
+        free_crypto(&crypto);
+        kfree(new_conf);
+ done:
+        conn_reconfig_done(tconn);
+ out:
+        drbd_adm_finish(info, retcode);
+        return 0;
+}
+
+int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
+{
+        struct drbd_conf *mdev;
+        struct net_conf *old_conf, *new_conf = NULL;
+        struct crypto crypto = { };
+        struct drbd_tconn *tconn;
+        enum drbd_ret_code retcode;
+        int i;
+        int err;
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
+
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+        if (!(adm_ctx.my_addr && adm_ctx.peer_addr)) {
+                drbd_msg_put_info("connection endpoint(s) missing");
+                retcode = ERR_INVALID_REQUEST;
+                goto out;
         }
 
-        ns = new_conf->max_epoch_size/8;
-        if (mdev->tl_hash_s != ns) {
-                new_tl_hash = kzalloc(ns*sizeof(void *), GFP_KERNEL);
-                if (!new_tl_hash) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
+        /* No need for _rcu here. All reconfiguration is
+         * strictly serialized on genl_lock(). We are protected against
+         * concurrent reconfiguration/addition/deletion */
+        list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
+                if (nla_len(adm_ctx.my_addr) == tconn->my_addr_len &&
+                    !memcmp(nla_data(adm_ctx.my_addr), &tconn->my_addr, tconn->my_addr_len)) {
+                        retcode = ERR_LOCAL_ADDR;
+                        goto out;
                 }
-        }
 
-        ns = new_conf->max_buffers/8;
-        if (new_conf->two_primaries && (mdev->ee_hash_s != ns)) {
-                new_ee_hash = kzalloc(ns*sizeof(void *), GFP_KERNEL);
-                if (!new_ee_hash) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
+                if (nla_len(adm_ctx.peer_addr) == tconn->peer_addr_len &&
+                    !memcmp(nla_data(adm_ctx.peer_addr), &tconn->peer_addr, tconn->peer_addr_len)) {
+                        retcode = ERR_PEER_ADDR;
+                        goto out;
                 }
         }
 
-        ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
+        tconn = adm_ctx.tconn;
+        conn_reconfig_start(tconn);
 
-        if (integrity_w_tfm) {
-                i = crypto_hash_digestsize(integrity_w_tfm);
-                int_dig_out = kmalloc(i, GFP_KERNEL);
-                if (!int_dig_out) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
-                }
-                int_dig_in = kmalloc(i, GFP_KERNEL);
-                if (!int_dig_in) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
-                }
-                int_dig_vv = kmalloc(i, GFP_KERNEL);
-                if (!int_dig_vv) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
-                }
+        if (tconn->cstate > C_STANDALONE) {
+                retcode = ERR_NET_CONFIGURED;
+                goto fail;
         }
 
-        if (!mdev->bitmap) {
-                if(drbd_bm_init(mdev)) {
-                        retcode = ERR_NOMEM;
-                        goto fail;
-                }
+        /* allocation not in the IO path, drbdsetup / netlink process context */
+        new_conf = kzalloc(sizeof(*new_conf), GFP_KERNEL);
+        if (!new_conf) {
+                retcode = ERR_NOMEM;
+                goto fail;
         }
 
-        drbd_flush_workqueue(mdev);
-        spin_lock_irq(&mdev->req_lock);
-        if (mdev->net_conf != NULL) {
-                retcode = ERR_NET_CONFIGURED;
-                spin_unlock_irq(&mdev->req_lock);
+        set_net_conf_defaults(new_conf);
+
+        err = net_conf_from_attrs(new_conf, info);
+        if (err && err != -ENOMSG) {
+                retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
                 goto fail;
         }
-        mdev->net_conf = new_conf;
 
-        mdev->send_cnt = 0;
-        mdev->recv_cnt = 0;
+        retcode = check_net_options(tconn, new_conf);
+        if (retcode != NO_ERROR)
+                goto fail;
 
-        if (new_tl_hash) {
-                kfree(mdev->tl_hash);
-                mdev->tl_hash_s = mdev->net_conf->max_epoch_size/8;
-                mdev->tl_hash = new_tl_hash;
-        }
+        retcode = alloc_crypto(&crypto, new_conf);
+        if (retcode != NO_ERROR)
+                goto fail;
 
-        if (new_ee_hash) {
-                kfree(mdev->ee_hash);
-                mdev->ee_hash_s = mdev->net_conf->max_buffers/8;
-                mdev->ee_hash = new_ee_hash;
+        ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
+
+        conn_flush_workqueue(tconn);
+
+        mutex_lock(&tconn->conf_update);
+        old_conf = tconn->net_conf;
+        if (old_conf) {
+                retcode = ERR_NET_CONFIGURED;
+                mutex_unlock(&tconn->conf_update);
+                goto fail;
         }
+        rcu_assign_pointer(tconn->net_conf, new_conf);
 
-        crypto_free_hash(mdev->cram_hmac_tfm);
-        mdev->cram_hmac_tfm = tfm;
+        conn_free_crypto(tconn);
+        tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
+        tconn->integrity_tfm = crypto.integrity_tfm;
+        tconn->csums_tfm = crypto.csums_tfm;
+        tconn->verify_tfm = crypto.verify_tfm;
 
-        crypto_free_hash(mdev->integrity_w_tfm);
-        mdev->integrity_w_tfm = integrity_w_tfm;
+        tconn->my_addr_len = nla_len(adm_ctx.my_addr);
+        memcpy(&tconn->my_addr, nla_data(adm_ctx.my_addr), tconn->my_addr_len);
+        tconn->peer_addr_len = nla_len(adm_ctx.peer_addr);
+        memcpy(&tconn->peer_addr, nla_data(adm_ctx.peer_addr), tconn->peer_addr_len);
 
-        crypto_free_hash(mdev->integrity_r_tfm);
-        mdev->integrity_r_tfm = integrity_r_tfm;
+        mutex_unlock(&tconn->conf_update);
 
-        kfree(mdev->int_dig_out);
-        kfree(mdev->int_dig_in);
-        kfree(mdev->int_dig_vv);
-        mdev->int_dig_out=int_dig_out;
-        mdev->int_dig_in=int_dig_in;
-        mdev->int_dig_vv=int_dig_vv;
-        retcode = _drbd_set_state(_NS(mdev, conn, C_UNCONNECTED), CS_VERBOSE, NULL);
-        spin_unlock_irq(&mdev->req_lock);
+        rcu_read_lock();
+        idr_for_each_entry(&tconn->volumes, mdev, i) {
+                mdev->send_cnt = 0;
+                mdev->recv_cnt = 0;
+        }
+        rcu_read_unlock();
 
-        kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
-        reply->ret_code = retcode;
-        drbd_reconfig_done(mdev);
+        retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
+
+        conn_reconfig_done(tconn);
+        drbd_adm_finish(info, retcode);
         return 0;
 
 fail:
-        kfree(int_dig_out);
-        kfree(int_dig_in);
-        kfree(int_dig_vv);
-        crypto_free_hash(tfm);
-        crypto_free_hash(integrity_w_tfm);
-        crypto_free_hash(integrity_r_tfm);
-        kfree(new_tl_hash);
-        kfree(new_ee_hash);
+        free_crypto(&crypto);
         kfree(new_conf);
 
-        reply->ret_code = retcode;
-        drbd_reconfig_done(mdev);
+        conn_reconfig_done(tconn);
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_disconnect(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                              struct drbd_nl_cfg_reply *reply)
+static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
 {
-        int retcode;
-        struct disconnect dc;
-
-        memset(&dc, 0, sizeof(struct disconnect));
-        if (!disconnect_from_tags(mdev, nlp->tag_list, &dc)) {
-                retcode = ERR_MANDATORY_TAG;
-                goto fail;
-        }
-
-        if (dc.force) {
-                spin_lock_irq(&mdev->req_lock);
-                if (mdev->state.conn >= C_WF_CONNECTION)
-                        _drbd_set_state(_NS(mdev, conn, C_DISCONNECTING), CS_HARD, NULL);
-                spin_unlock_irq(&mdev->req_lock);
-                goto done;
-        }
+        enum drbd_state_rv rv;
 
-        retcode = _drbd_request_state(mdev, NS(conn, C_DISCONNECTING), CS_ORDERED);
+        rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
+                        force ? CS_HARD : 0);
 
-        if (retcode == SS_NOTHING_TO_DO)
-                goto done;
-        else if (retcode == SS_ALREADY_STANDALONE)
-                goto done;
-        else if (retcode == SS_PRIMARY_NOP) {
-                /* Our statche checking code wants to see the peer outdated. */
-                retcode = drbd_request_state(mdev, NS2(conn, C_DISCONNECTING,
-                                                      pdsk, D_OUTDATED));
-        } else if (retcode == SS_CW_FAILED_BY_PEER) {
+        switch (rv) {
+        case SS_NOTHING_TO_DO:
+                break;
+        case SS_ALREADY_STANDALONE:
+                return SS_SUCCESS;
+        case SS_PRIMARY_NOP:
+                /* Our state checking code wants to see the peer outdated. */
+                rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
+                                                pdsk, D_OUTDATED), CS_VERBOSE);
+                break;
+        case SS_CW_FAILED_BY_PEER:
                 /* The peer probably wants to see us outdated. */
-                retcode = _drbd_request_state(mdev, NS2(conn, C_DISCONNECTING,
-                                                        disk, D_OUTDATED),
-                                              CS_ORDERED);
-                if (retcode == SS_IS_DISKLESS || retcode == SS_LOWER_THAN_OUTDATED) {
-                        drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
-                        retcode = SS_SUCCESS;
+                rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
+                                                        disk, D_OUTDATED), 0);
+                if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
+                        rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
+                                        CS_HARD);
                 }
+                break;
+        default:;
+                /* no special handling necessary */
+        }
+
+        if (rv >= SS_SUCCESS) {
+                enum drbd_state_rv rv2;
+                /* No one else can reconfigure the network while I am here.
+                 * The state handling only uses drbd_thread_stop_nowait(),
+                 * we want to really wait here until the receiver is no more.
+                 */
+                drbd_thread_stop(&adm_ctx.tconn->receiver);
+
+                /* Race breaker.  This additional state change request may be
+                 * necessary, if this was a forced disconnect during a receiver
+                 * restart.  We may have "killed" the receiver thread just
+                 * after drbdd_init() returned.  Typically, we should be
+                 * C_STANDALONE already, now, and this becomes a no-op.
+                 */
+                rv2 = conn_request_state(tconn, NS(conn, C_STANDALONE),
+                                CS_VERBOSE | CS_HARD);
+                if (rv2 < SS_SUCCESS)
+                        conn_err(tconn,
+                                "unexpected rv2=%d in conn_try_disconnect()\n",
+                                rv2);
         }
+        return rv;
+}
 
-        if (retcode < SS_SUCCESS)
-                goto fail;
+int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
+{
+        struct disconnect_parms parms;
+        struct drbd_tconn *tconn;
+        enum drbd_state_rv rv;
+        enum drbd_ret_code retcode;
+        int err;
 
-        if (wait_event_interruptible(mdev->state_wait,
-                                     mdev->state.conn != C_DISCONNECTING)) {
-                /* Do not test for mdev->state.conn == C_STANDALONE, since
-                   someone else might connect us in the mean time! */
-                retcode = ERR_INTR;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
                 goto fail;
+
+        tconn = adm_ctx.tconn;
+        memset(&parms, 0, sizeof(parms));
+        if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
+                err = disconnect_parms_from_attrs(&parms, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto fail;
+                }
         }
 
- done:
-        retcode = NO_ERROR;
+        rv = conn_try_disconnect(tconn, parms.force_disconnect);
+        if (rv < SS_SUCCESS)
+                retcode = rv;  /* FIXME: Type mismatch. */
+        else
+                retcode = NO_ERROR;
  fail:
-        drbd_md_sync(mdev);
-        reply->ret_code = retcode;
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
@@ -1709,7 +2236,7 @@ void resync_after_online_grow(struct drbd_conf *mdev)
         if (mdev->state.role != mdev->state.peer)
                 iass = (mdev->state.role == R_PRIMARY);
         else
-                iass = drbd_test_flag(mdev, DISCARD_CONCURRENT);
+                iass = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags);
 
         if (iass)
                 drbd_start_resync(mdev, C_SYNC_SOURCE);
@@ -1717,20 +2244,34 @@ void resync_after_online_grow(struct drbd_conf *mdev)
                 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
 }
 
-static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                          struct drbd_nl_cfg_reply *reply)
+int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
 {
-        struct resize rs;
-        int retcode = NO_ERROR;
+        struct disk_conf *old_disk_conf, *new_disk_conf = NULL;
+        struct resize_parms rs;
+        struct drbd_conf *mdev;
+        enum drbd_ret_code retcode;
         enum determine_dev_size dd;
         enum dds_flags ddsf;
+        sector_t u_size;
+        int err;
 
-        memset(&rs, 0, sizeof(struct resize));
-        if (!resize_from_tags(mdev, nlp->tag_list, &rs)) {
-                retcode = ERR_MANDATORY_TAG;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
                 goto fail;
+
+        memset(&rs, 0, sizeof(struct resize_parms));
+        if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
+                err = resize_parms_from_attrs(&rs, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto fail;
+                }
         }
 
+        mdev = adm_ctx.mdev;
         if (mdev->state.conn > C_CONNECTED) {
                 retcode = ERR_RESIZE_RESYNC;
                 goto fail;
@@ -1747,15 +2288,36 @@ static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
                 goto fail;
         }
 
-        if (rs.no_resync && mdev->agreed_pro_version < 93) {
+        if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
                 retcode = ERR_NEED_APV_93;
                 goto fail_ldev;
         }
 
+        rcu_read_lock();
+        u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
+        rcu_read_unlock();
+        if (u_size != (sector_t)rs.resize_size) {
+                new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
+                if (!new_disk_conf) {
+                        retcode = ERR_NOMEM;
+                        goto fail_ldev;
+                }
+        }
+
         if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
                 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
 
-        mdev->ldev->dc.disk_size = (sector_t)rs.resize_size;
+        if (new_disk_conf) {
+                mutex_lock(&mdev->tconn->conf_update);
+                old_disk_conf = mdev->ldev->disk_conf;
+                *new_disk_conf = *old_disk_conf;
+                new_disk_conf->disk_size = (sector_t)rs.resize_size;
+                rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
+                mutex_unlock(&mdev->tconn->conf_update);
+                synchronize_rcu();
+                kfree(old_disk_conf);
+        }
+
         ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
         dd = drbd_determine_dev_size(mdev, ddsf);
         drbd_md_sync(mdev);
@@ -1767,14 +2329,14 @@ static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
 
         if (mdev->state.conn == C_CONNECTED) {
                 if (dd == grew)
-                        drbd_set_flag(mdev, RESIZE_PENDING);
+                        set_bit(RESIZE_PENDING, &mdev->flags);
 
                 drbd_send_uuids(mdev);
                 drbd_send_sizes(mdev, 1, ddsf);
         }
 
  fail:
-        reply->ret_code = retcode;
+        drbd_adm_finish(info, retcode);
         return 0;
 
  fail_ldev:
@@ -1782,210 +2344,61 @@ static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
         goto fail;
 }
 
-static int drbd_nl_syncer_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                               struct drbd_nl_cfg_reply *reply)
+int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode = NO_ERROR;
+        enum drbd_ret_code retcode;
+        struct drbd_tconn *tconn;
+        struct res_opts res_opts;
         int err;
-        int ovr; /* online verify running */
-        int rsr; /* re-sync running */
-        struct crypto_hash *verify_tfm = NULL;
-        struct crypto_hash *csums_tfm = NULL;
-        struct syncer_conf sc;
-        cpumask_var_t new_cpu_mask;
-        int *rs_plan_s = NULL;
-        int fifo_size;
-
-        if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL)) {
-                retcode = ERR_NOMEM;
-                goto fail;
-        }
-
-        if (nlp->flags & DRBD_NL_SET_DEFAULTS) {
-                memset(&sc, 0, sizeof(struct syncer_conf));
-                sc.rate       = DRBD_RATE_DEF;
-                sc.after      = DRBD_AFTER_DEF;
-                sc.al_extents = DRBD_AL_EXTENTS_DEF;
-                sc.on_no_data  = DRBD_ON_NO_DATA_DEF;
-                sc.c_plan_ahead = DRBD_C_PLAN_AHEAD_DEF;
-                sc.c_delay_target = DRBD_C_DELAY_TARGET_DEF;
-                sc.c_fill_target = DRBD_C_FILL_TARGET_DEF;
-                sc.c_max_rate = DRBD_C_MAX_RATE_DEF;
-                sc.c_min_rate = DRBD_C_MIN_RATE_DEF;
-        } else
-                memcpy(&sc, &mdev->sync_conf, sizeof(struct syncer_conf));
 
-        if (!syncer_conf_from_tags(mdev, nlp->tag_list, &sc)) {
-                retcode = ERR_MANDATORY_TAG;
-                goto fail;
-        }
-
-        /* re-sync running */
-        rsr = ( mdev->state.conn == C_SYNC_SOURCE ||
-                mdev->state.conn == C_SYNC_TARGET ||
-                mdev->state.conn == C_PAUSED_SYNC_S ||
-                mdev->state.conn == C_PAUSED_SYNC_T );
-
-        if (rsr && strcmp(sc.csums_alg, mdev->sync_conf.csums_alg)) {
-                retcode = ERR_CSUMS_RESYNC_RUNNING;
-                goto fail;
-        }
-
-        if (!rsr && sc.csums_alg[0]) {
-                csums_tfm = crypto_alloc_hash(sc.csums_alg, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(csums_tfm)) {
-                        csums_tfm = NULL;
-                        retcode = ERR_CSUMS_ALG;
-                        goto fail;
-                }
-
-                if (!drbd_crypto_is_hash(crypto_hash_tfm(csums_tfm))) {
-                        retcode = ERR_CSUMS_ALG_ND;
-                        goto fail;
-                }
-        }
-
-        /* online verify running */
-        ovr = (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T);
-
-        if (ovr) {
-                if (strcmp(sc.verify_alg, mdev->sync_conf.verify_alg)) {
-                        retcode = ERR_VERIFY_RUNNING;
-                        goto fail;
-                }
-        }
-
-        if (!ovr && sc.verify_alg[0]) {
-                verify_tfm = crypto_alloc_hash(sc.verify_alg, 0, CRYPTO_ALG_ASYNC);
-                if (IS_ERR(verify_tfm)) {
-                        verify_tfm = NULL;
-                        retcode = ERR_VERIFY_ALG;
-                        goto fail;
-                }
-
-                if (!drbd_crypto_is_hash(crypto_hash_tfm(verify_tfm))) {
-                        retcode = ERR_VERIFY_ALG_ND;
-                        goto fail;
-                }
-        }
-
-        /* silently ignore cpu mask on UP kernel */
-        if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) {
-                err = bitmap_parse(sc.cpu_mask, 32,
-                                cpumask_bits(new_cpu_mask), nr_cpu_ids);
-                if (err) {
-                        dev_warn(DEV, "bitmap_parse() failed with %d\n", err);
-                        retcode = ERR_CPU_MASK_PARSE;
-                        goto fail;
-                }
-        }
-
-        ERR_IF (sc.rate < 1) sc.rate = 1;
-        ERR_IF (sc.al_extents < 7) sc.al_extents = 127; /* arbitrary minimum */
-#define AL_MAX ((MD_AL_MAX_SIZE-1) * AL_EXTENTS_PT)
-        if (sc.al_extents > AL_MAX) {
-                dev_err(DEV, "sc.al_extents > %d\n", AL_MAX);
-                sc.al_extents = AL_MAX;
-        }
-#undef AL_MAX
-
-        /* to avoid spurious errors when configuring minors before configuring
-         * the minors they depend on: if necessary, first create the minor we
-         * depend on */
-        if (sc.after >= 0)
-                ensure_mdev(sc.after, 1);
-
-        /* most sanity checks done, try to assign the new sync-after
-         * dependency.  need to hold the global lock in there,
-         * to avoid a race in the dependency loop check. */
-        retcode = drbd_alter_sa(mdev, sc.after);
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
+        if (!adm_ctx.reply_skb)
+                return retcode;
         if (retcode != NO_ERROR)
                 goto fail;
+        tconn = adm_ctx.tconn;
 
-        fifo_size = (sc.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
-        if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
-                rs_plan_s   = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
-                if (!rs_plan_s) {
-                        dev_err(DEV, "kmalloc of fifo_buffer failed");
-                        retcode = ERR_NOMEM;
-                        goto fail;
-                }
-        }
+        res_opts = tconn->res_opts;
+        if (should_set_defaults(info))
+                set_res_opts_defaults(&res_opts);
 
-        /* ok, assign the rest of it as well.
-         * lock against receive_SyncParam() */
-        spin_lock(&mdev->peer_seq_lock);
-        mdev->sync_conf = sc;
-
-        if (!rsr) {
-                crypto_free_hash(mdev->csums_tfm);
-                mdev->csums_tfm = csums_tfm;
-                csums_tfm = NULL;
-        }
-
-        if (!ovr) {
-                crypto_free_hash(mdev->verify_tfm);
-                mdev->verify_tfm = verify_tfm;
-                verify_tfm = NULL;
-        }
-
-        if (fifo_size != mdev->rs_plan_s.size) {
-                kfree(mdev->rs_plan_s.values);
-                mdev->rs_plan_s.values = rs_plan_s;
-                mdev->rs_plan_s.size   = fifo_size;
-                mdev->rs_planed = 0;
-                rs_plan_s = NULL;
+        err = res_opts_from_attrs(&res_opts, info);
+        if (err && err != -ENOMSG) {
+                retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
+                goto fail;
         }
 
-        spin_unlock(&mdev->peer_seq_lock);
-
-        if (get_ldev(mdev)) {
-                wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
-                drbd_al_shrink(mdev);
-                err = drbd_check_al_size(mdev);
-                lc_unlock(mdev->act_log);
-                wake_up(&mdev->al_wait);
-
-                put_ldev(mdev);
-                drbd_md_sync(mdev);
-
-                if (err) {
+        err = set_resource_options(tconn, &res_opts);
+        if (err) {
+                retcode = ERR_INVALID_REQUEST;
+                if (err == -ENOMEM)
                         retcode = ERR_NOMEM;
-                        goto fail;
-                }
-        }
-
-        if (mdev->state.conn >= C_CONNECTED)
-                drbd_send_sync_param(mdev, &sc);
-
-        if (!cpumask_equal(mdev->cpu_mask, new_cpu_mask)) {
-                cpumask_copy(mdev->cpu_mask, new_cpu_mask);
-                drbd_calc_cpu_mask(mdev);
-                mdev->receiver.reset_cpu_mask = 1;
-                mdev->asender.reset_cpu_mask = 1;
-                mdev->worker.reset_cpu_mask = 1;
         }
 
-        kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
 fail:
-        kfree(rs_plan_s);
-        free_cpumask_var(new_cpu_mask);
-        crypto_free_hash(csums_tfm);
-        crypto_free_hash(verify_tfm);
-        reply->ret_code = retcode;
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                              struct drbd_nl_cfg_reply *reply)
+int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode;
+        struct drbd_conf *mdev;
+        int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        mdev = adm_ctx.mdev;
 
         /* If there is still bitmap IO pending, probably because of a previous
          * resync just being finished, wait for it before requesting a new resync.
          * Also wait for it's after_state_ch(). */
         drbd_suspend_io(mdev);
-        wait_event(mdev->misc_wait, !drbd_test_flag(mdev, BITMAP_IO));
+        wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
         drbd_flush_workqueue(mdev);
 
         retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
@@ -1994,10 +2407,10 @@ static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
                 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
 
         while (retcode == SS_NEED_CONNECTION) {
-                spin_lock_irq(&mdev->req_lock);
+                spin_lock_irq(&mdev->tconn->req_lock);
                 if (mdev->state.conn < C_CONNECTED)
                         retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
-                spin_unlock_irq(&mdev->req_lock);
+                spin_unlock_irq(&mdev->tconn->req_lock);
 
                 if (retcode != SS_NEED_CONNECTION)
                         break;
@@ -2006,7 +2419,25 @@ static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
         }
         drbd_resume_io(mdev);
 
-        reply->ret_code = retcode;
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
+}
+
+static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
+                union drbd_state mask, union drbd_state val)
+{
+        enum drbd_ret_code retcode;
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        retcode = drbd_request_state(adm_ctx.mdev, mask, val);
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
@@ -2019,29 +2450,36 @@ static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
         return rv;
 }
 
-static int drbd_nl_invalidate_peer(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                                   struct drbd_nl_cfg_reply *reply)
+int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode;
+        int retcode; /* drbd_ret_code, drbd_state_rv */
+        struct drbd_conf *mdev;
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        mdev = adm_ctx.mdev;
 
         /* If there is still bitmap IO pending, probably because of a previous
          * resync just being finished, wait for it before requesting a new resync.
          * Also wait for it's after_state_ch(). */
         drbd_suspend_io(mdev);
-        wait_event(mdev->misc_wait, !drbd_test_flag(mdev, BITMAP_IO));
+        wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
         drbd_flush_workqueue(mdev);
 
         retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S), CS_ORDERED);
-
         if (retcode < SS_SUCCESS) {
                 if (retcode == SS_NEED_CONNECTION && mdev->state.role == R_PRIMARY) {
-                        /* The peer will get a resync upon connect anyways. Just make that
-                           into a full resync. */
+                        /* The peer will get a resync upon connect anyways.
+                         * Just make that into a full resync. */
                         retcode = drbd_request_state(mdev, NS(pdsk, D_INCONSISTENT));
                         if (retcode >= SS_SUCCESS) {
                                 if (drbd_bitmap_io(mdev, &drbd_bmio_set_susp_al,
-                                        "set_n_write from invalidate_peer",
-                                        BM_LOCKED_SET_ALLOWED))
+                                                   "set_n_write from invalidate_peer",
+                                                   BM_LOCKED_SET_ALLOWED))
                                         retcode = ERR_IO_MD_DISK;
                         }
                 } else
@@ -2049,30 +2487,41 @@ static int drbd_nl_invalidate_peer(struct drbd_conf *mdev, struct drbd_nl_cfg_re
         }
         drbd_resume_io(mdev);
 
-        reply->ret_code = retcode;
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_pause_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                              struct drbd_nl_cfg_reply *reply)
+int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode = NO_ERROR;
+        enum drbd_ret_code retcode;
 
-        if (drbd_request_state(mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
-                retcode = ERR_PAUSE_IS_SET;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        reply->ret_code = retcode;
+        if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
+                retcode = ERR_PAUSE_IS_SET;
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_resume_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                               struct drbd_nl_cfg_reply *reply)
+int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode = NO_ERROR;
-        union drbd_state s;
+        union drbd_dev_state s;
+        enum drbd_ret_code retcode;
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        if (drbd_request_state(mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
-                s = mdev->state;
+        if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
+                s = adm_ctx.mdev->state;
                 if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
                         retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
                                   s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
@@ -2081,178 +2530,482 @@ static int drbd_nl_resume_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *n
                 }
         }
 
-        reply->ret_code = retcode;
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_suspend_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                              struct drbd_nl_cfg_reply *reply)
+int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
 {
-        reply->ret_code = drbd_request_state(mdev, NS(susp, 1));
-
-        return 0;
+        return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
 }
 
-static int drbd_nl_resume_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                             struct drbd_nl_cfg_reply *reply)
+int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
 {
-        if (drbd_test_flag(mdev, NEW_CUR_UUID)) {
+        struct drbd_conf *mdev;
+        int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
+
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        mdev = adm_ctx.mdev;
+        if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
                 drbd_uuid_new_current(mdev);
-                drbd_clear_flag(mdev, NEW_CUR_UUID);
+                clear_bit(NEW_CUR_UUID, &mdev->flags);
         }
         drbd_suspend_io(mdev);
-        reply->ret_code = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
-        if (reply->ret_code == SS_SUCCESS) {
+        retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
+        if (retcode == SS_SUCCESS) {
                 if (mdev->state.conn < C_CONNECTED)
-                        tl_clear(mdev);
+                        tl_clear(mdev->tconn);
                 if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
-                        tl_restart(mdev, fail_frozen_disk_io);
+                        tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
         }
         drbd_resume_io(mdev);
 
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-static int drbd_nl_outdate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                           struct drbd_nl_cfg_reply *reply)
+int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
 {
-        reply->ret_code = drbd_request_state(mdev, NS(disk, D_OUTDATED));
-        return 0;
+        return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
 }
 
-static int drbd_nl_get_config(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                           struct drbd_nl_cfg_reply *reply)
+int nla_put_drbd_cfg_context(struct sk_buff *skb, struct drbd_tconn *tconn, unsigned vnr)
 {
-        unsigned short *tl;
+        struct nlattr *nla;
+        nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
+        if (!nla)
+                goto nla_put_failure;
+        if (vnr != VOLUME_UNSPECIFIED &&
+            nla_put_u32(skb, T_ctx_volume, vnr))
+                goto nla_put_failure;
+        if (nla_put_string(skb, T_ctx_resource_name, tconn->name))
+                goto nla_put_failure;
+        if (tconn->my_addr_len &&
+            nla_put(skb, T_ctx_my_addr, tconn->my_addr_len, &tconn->my_addr))
+                goto nla_put_failure;
+        if (tconn->peer_addr_len &&
+            nla_put(skb, T_ctx_peer_addr, tconn->peer_addr_len, &tconn->peer_addr))
+                goto nla_put_failure;
+        nla_nest_end(skb, nla);
+        return 0;
 
-        tl = reply->tag_list;
+nla_put_failure:
+        if (nla)
+                nla_nest_cancel(skb, nla);
+        return -EMSGSIZE;
+}
 
-        if (get_ldev(mdev)) {
-                tl = disk_conf_to_tags(mdev, &mdev->ldev->dc, tl);
-                put_ldev(mdev);
-        }
+int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
+                const struct sib_info *sib)
+{
+        struct state_info *si = NULL; /* for sizeof(si->member); */
+        struct net_conf *nc;
+        struct nlattr *nla;
+        int got_ldev;
+        int err = 0;
+        int exclude_sensitive;
+
+        /* If sib != NULL, this is drbd_bcast_event, which anyone can listen
+         * to.  So we better exclude_sensitive information.
+         *
+         * If sib == NULL, this is drbd_adm_get_status, executed synchronously
+         * in the context of the requesting user process. Exclude sensitive
+         * information, unless current has superuser.
+         *
+         * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
+         * relies on the current implementation of netlink_dump(), which
+         * executes the dump callback successively from netlink_recvmsg(),
+         * always in the context of the receiving process */
+        exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);
+
+        got_ldev = get_ldev(mdev);
+
+        /* We need to add connection name and volume number information still.
+         * Minor number is in drbd_genlmsghdr. */
+        if (nla_put_drbd_cfg_context(skb, mdev->tconn, mdev->vnr))
+                goto nla_put_failure;
+
+        if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
+                goto nla_put_failure;
+
+        rcu_read_lock();
+        if (got_ldev)
+                if (disk_conf_to_skb(skb, rcu_dereference(mdev->ldev->disk_conf), exclude_sensitive))
+                        goto nla_put_failure;
+
+        nc = rcu_dereference(mdev->tconn->net_conf);
+        if (nc)
+                err = net_conf_to_skb(skb, nc, exclude_sensitive);
+        rcu_read_unlock();
+        if (err)
+                goto nla_put_failure;
+
+        nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
+        if (!nla)
+                goto nla_put_failure;
+        if (nla_put_u32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY) ||
+            nla_put_u32(skb, T_current_state, mdev->state.i) ||
+            nla_put_u64(skb, T_ed_uuid, mdev->ed_uuid) ||
+            nla_put_u64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev)) ||
+            nla_put_u64(skb, T_send_cnt, mdev->send_cnt) ||
+            nla_put_u64(skb, T_recv_cnt, mdev->recv_cnt) ||
+            nla_put_u64(skb, T_read_cnt, mdev->read_cnt) ||
+            nla_put_u64(skb, T_writ_cnt, mdev->writ_cnt) ||
+            nla_put_u64(skb, T_al_writ_cnt, mdev->al_writ_cnt) ||
+            nla_put_u64(skb, T_bm_writ_cnt, mdev->bm_writ_cnt) ||
+            nla_put_u32(skb, T_ap_bio_cnt, atomic_read(&mdev->ap_bio_cnt)) ||
+            nla_put_u32(skb, T_ap_pending_cnt, atomic_read(&mdev->ap_pending_cnt)) ||
+            nla_put_u32(skb, T_rs_pending_cnt, atomic_read(&mdev->rs_pending_cnt)))
+                goto nla_put_failure;
+
+        if (got_ldev) {
+                int err;
 
-        if (get_net_conf(mdev)) {
-                tl = net_conf_to_tags(mdev, mdev->net_conf, tl);
-                put_net_conf(mdev);
+                spin_lock_irq(&mdev->ldev->md.uuid_lock);
+                err = nla_put(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
+                spin_unlock_irq(&mdev->ldev->md.uuid_lock);
+
+                if (err)
+                        goto nla_put_failure;
+
+                if (nla_put_u32(skb, T_disk_flags, mdev->ldev->md.flags) ||
+                    nla_put_u64(skb, T_bits_total, drbd_bm_bits(mdev)) ||
+                    nla_put_u64(skb, T_bits_oos, drbd_bm_total_weight(mdev)))
+                        goto nla_put_failure;
+                if (C_SYNC_SOURCE <= mdev->state.conn &&
+                    C_PAUSED_SYNC_T >= mdev->state.conn) {
+                        if (nla_put_u64(skb, T_bits_rs_total, mdev->rs_total) ||
+                            nla_put_u64(skb, T_bits_rs_failed, mdev->rs_failed))
+                                goto nla_put_failure;
+                }
         }
-        tl = syncer_conf_to_tags(mdev, &mdev->sync_conf, tl);
 
-        put_unaligned(TT_END, tl++); /* Close the tag list */
+        if (sib) {
+                switch(sib->sib_reason) {
+                case SIB_SYNC_PROGRESS:
+                case SIB_GET_STATUS_REPLY:
+                        break;
+                case SIB_STATE_CHANGE:
+                        if (nla_put_u32(skb, T_prev_state, sib->os.i) ||
+                            nla_put_u32(skb, T_new_state, sib->ns.i))
+                                goto nla_put_failure;
+                        break;
+                case SIB_HELPER_POST:
+                        if (nla_put_u32(skb, T_helper_exit_code,
+                                        sib->helper_exit_code))
+                                goto nla_put_failure;
+                        /* fall through */
+                case SIB_HELPER_PRE:
+                        if (nla_put_string(skb, T_helper, sib->helper_name))
+                                goto nla_put_failure;
+                        break;
+                }
+        }
+        nla_nest_end(skb, nla);
 
-        return (int)((char *)tl - (char *)reply->tag_list);
+        if (0)
+nla_put_failure:
+                err = -EMSGSIZE;
+        if (got_ldev)
+                put_ldev(mdev);
+        return err;
 }
 
-static int drbd_nl_get_state(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                             struct drbd_nl_cfg_reply *reply)
+int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
 {
-        unsigned short *tl = reply->tag_list;
-        union drbd_state s = mdev->state;
-        unsigned long rs_left;
-        unsigned int res;
+        enum drbd_ret_code retcode;
+        int err;
 
-        tl = get_state_to_tags(mdev, (struct get_state *)&s, tl);
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        /* no local ref, no bitmap, no syncer progress. */
-        if (s.conn >= C_SYNC_SOURCE && s.conn <= C_PAUSED_SYNC_T) {
-                if (get_ldev(mdev)) {
-                        drbd_get_syncer_progress(mdev, &rs_left, &res);
-                        tl = tl_add_int(tl, T_sync_progress, &res);
-                        put_ldev(mdev);
-                }
+        err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
+        if (err) {
+                nlmsg_free(adm_ctx.reply_skb);
+                return err;
         }
-        put_unaligned(TT_END, tl++); /* Close the tag list */
-
-        return (int)((char *)tl - (char *)reply->tag_list);
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-static int drbd_nl_get_uuids(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                             struct drbd_nl_cfg_reply *reply)
+int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
 {
-        unsigned short *tl;
-
-        tl = reply->tag_list;
+        struct drbd_conf *mdev;
+        struct drbd_genlmsghdr *dh;
+        struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
+        struct drbd_tconn *tconn = NULL;
+        struct drbd_tconn *tmp;
+        unsigned volume = cb->args[1];
+
+        /* Open coded, deferred, iteration:
+         * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
+         *      idr_for_each_entry(&tconn->volumes, mdev, i) {
+         *        ...
+         *      }
+         * }
+         * where tconn is cb->args[0];
+         * and i is cb->args[1];
+         *
+         * cb->args[2] indicates if we shall loop over all resources,
+         * or just dump all volumes of a single resource.
+         *
+         * This may miss entries inserted after this dump started,
+         * or entries deleted before they are reached.
+         *
+         * We need to make sure the mdev won't disappear while
+         * we are looking at it, and revalidate our iterators
+         * on each iteration.
+         */
 
-        if (get_ldev(mdev)) {
-                unsigned long flags;
-                spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
-                tl = tl_add_blob(tl, T_uuids, mdev->ldev->md.uuid, UI_SIZE*sizeof(u64));
-                tl = tl_add_int(tl, T_uuids_flags, &mdev->ldev->md.flags);
-                spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
-                put_ldev(mdev);
+        /* synchronize with conn_create()/conn_destroy() */
+        rcu_read_lock();
+        /* revalidate iterator position */
+        list_for_each_entry_rcu(tmp, &drbd_tconns, all_tconn) {
+                if (pos == NULL) {
+                        /* first iteration */
+                        pos = tmp;
+                        tconn = pos;
+                        break;
+                }
+                if (tmp == pos) {
+                        tconn = pos;
+                        break;
+                }
         }
-        put_unaligned(TT_END, tl++); /* Close the tag list */
+        if (tconn) {
+next_tconn:
+                mdev = idr_get_next(&tconn->volumes, &volume);
+                if (!mdev) {
+                        /* No more volumes to dump on this tconn.
+                         * Advance tconn iterator. */
+                        pos = list_entry_rcu(tconn->all_tconn.next,
+                                             struct drbd_tconn, all_tconn);
+                        /* Did we dump any volume on this tconn yet? */
+                        if (volume != 0) {
+                                /* If we reached the end of the list,
+                                 * or only a single resource dump was requested,
+                                 * we are done. */
+                                if (&pos->all_tconn == &drbd_tconns || cb->args[2])
+                                        goto out;
+                                volume = 0;
+                                tconn = pos;
+                                goto next_tconn;
+                        }
+                }
 
-        return (int)((char *)tl - (char *)reply->tag_list);
+                dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
+                                cb->nlh->nlmsg_seq, &drbd_genl_family,
+                                NLM_F_MULTI, DRBD_ADM_GET_STATUS);
+                if (!dh)
+                        goto out;
+
+                if (!mdev) {
+                        /* This is a tconn without a single volume.
+                         * Suprisingly enough, it may have a network
+                         * configuration. */
+                        struct net_conf *nc;
+                        dh->minor = -1U;
+                        dh->ret_code = NO_ERROR;
+                        if (nla_put_drbd_cfg_context(skb, tconn, VOLUME_UNSPECIFIED))
+                                goto cancel;
+                        nc = rcu_dereference(tconn->net_conf);
+                        if (nc && net_conf_to_skb(skb, nc, 1) != 0)
+                                goto cancel;
+                        goto done;
+                }
+
+                D_ASSERT(mdev->vnr == volume);
+                D_ASSERT(mdev->tconn == tconn);
+
+                dh->minor = mdev_to_minor(mdev);
+                dh->ret_code = NO_ERROR;
+
+                if (nla_put_status_info(skb, mdev, NULL)) {
+cancel:
+                        genlmsg_cancel(skb, dh);
+                        goto out;
+                }
+done:
+                genlmsg_end(skb, dh);
+        }
+
+out:
+        rcu_read_unlock();
+        /* where to start the next iteration */
+        cb->args[0] = (long)pos;
+        cb->args[1] = (pos == tconn) ? volume + 1 : 0;
+
+        /* No more tconns/volumes/minors found results in an empty skb.
+         * Which will terminate the dump. */
+        return skb->len;
 }
 
-/**
- * drbd_nl_get_timeout_flag() - Used by drbdsetup to find out which timeout value to use
- * @mdev:       DRBD device.
- * @nlp:        Netlink/connector packet from drbdsetup
- * @reply:      Reply packet for drbdsetup
+/*
+ * Request status of all resources, or of all volumes within a single resource.
+ *
+ * This is a dump, as the answer may not fit in a single reply skb otherwise.
+ * Which means we cannot use the family->attrbuf or other such members, because
+ * dump is NOT protected by the genl_lock().  During dump, we only have access
+ * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
+ *
+ * Once things are setup properly, we call into get_one_status().
  */
-static int drbd_nl_get_timeout_flag(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                                    struct drbd_nl_cfg_reply *reply)
+int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
 {
-        unsigned short *tl;
-        char rv;
+        const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
+        struct nlattr *nla;
+        const char *resource_name;
+        struct drbd_tconn *tconn;
+        int maxtype;
+
+        /* Is this a followup call? */
+        if (cb->args[0]) {
+                /* ... of a single resource dump,
+                 * and the resource iterator has been advanced already? */
+                if (cb->args[2] && cb->args[2] != cb->args[0])
+                        return 0; /* DONE. */
+                goto dump;
+        }
+
+        /* First call (from netlink_dump_start).  We need to figure out
+         * which resource(s) the user wants us to dump. */
+        nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
+                        nlmsg_attrlen(cb->nlh, hdrlen),
+                        DRBD_NLA_CFG_CONTEXT);
+
+        /* No explicit context given.  Dump all. */
+        if (!nla)
+                goto dump;
+        maxtype = ARRAY_SIZE(drbd_cfg_context_nl_policy) - 1;
+        nla = drbd_nla_find_nested(maxtype, nla, __nla_type(T_ctx_resource_name));
+        if (IS_ERR(nla))
+                return PTR_ERR(nla);
+        /* context given, but no name present? */
+        if (!nla)
+                return -EINVAL;
+        resource_name = nla_data(nla);
+        tconn = conn_get_by_name(resource_name);
+
+        if (!tconn)
+                return -ENODEV;
+
+        kref_put(&tconn->kref, &conn_destroy); /* get_one_status() (re)validates tconn by itself */
+
+        /* prime iterators, and set "filter" mode mark:
+         * only dump this tconn. */
+        cb->args[0] = (long)tconn;
+        /* cb->args[1] = 0; passed in this way. */
+        cb->args[2] = (long)tconn;
+
+dump:
+        return get_one_status(skb, cb);
+}
 
-        tl = reply->tag_list;
+int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
+{
+        enum drbd_ret_code retcode;
+        struct timeout_parms tp;
+        int err;
 
-        rv = mdev->state.pdsk == D_OUTDATED        ? UT_PEER_OUTDATED :
-          drbd_test_flag(mdev, USE_DEGR_WFC_T) ? UT_DEGRADED : UT_DEFAULT;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        tl = tl_add_blob(tl, T_use_degraded, &rv, sizeof(rv));
-        put_unaligned(TT_END, tl++); /* Close the tag list */
+        tp.timeout_type =
+                adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
+                test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
+                UT_DEFAULT;
 
-        return (int)((char *)tl - (char *)reply->tag_list);
+        err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
+        if (err) {
+                nlmsg_free(adm_ctx.reply_skb);
+                return err;
+        }
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-static int drbd_nl_start_ov(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                                    struct drbd_nl_cfg_reply *reply)
+int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
 {
-        /* default to resume from last known position, if possible */
-        struct start_ov args = {
-                .start_sector = mdev->ov_start_sector,
-                .stop_sector = ULLONG_MAX,
-        };
+        struct drbd_conf *mdev;
+        enum drbd_ret_code retcode;
+        struct start_ov_parms parms;
 
-        if (!start_ov_from_tags(mdev, nlp->tag_list, &args)) {
-                reply->ret_code = ERR_MANDATORY_TAG;
-                return 0;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
+
+        mdev = adm_ctx.mdev;
+
+        /* resume from last known position, if possible */
+        parms.ov_start_sector = mdev->ov_start_sector;
+        parms.ov_stop_sector = ULLONG_MAX;
+        if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
+                int err = start_ov_parms_from_attrs(&parms, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto out;
+                }
         }
+        /* w_make_ov_request expects position to be aligned */
+        mdev->ov_start_sector = parms.ov_start_sector & ~(BM_SECT_PER_BIT-1);
+        mdev->ov_stop_sector = parms.ov_stop_sector;
 
         /* If there is still bitmap IO pending, e.g. previous resync or verify
          * just being finished, wait for it before requesting a new resync. */
         drbd_suspend_io(mdev);
-        wait_event(mdev->misc_wait, !drbd_test_flag(mdev, BITMAP_IO));
-
-        /* w_make_ov_request expects start position to be aligned */
-        mdev->ov_start_sector = args.start_sector & ~(BM_SECT_PER_BIT-1);
-        mdev->ov_stop_sector = args.stop_sector;
-        reply->ret_code = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
+        wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
+        retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
         drbd_resume_io(mdev);
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
 
-static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
-                              struct drbd_nl_cfg_reply *reply)
+int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
 {
-        int retcode = NO_ERROR;
+        struct drbd_conf *mdev;
+        enum drbd_ret_code retcode;
         int skip_initial_sync = 0;
         int err;
+        struct new_c_uuid_parms args;
 
-        struct new_c_uuid args;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out_nolock;
 
-        memset(&args, 0, sizeof(struct new_c_uuid));
-        if (!new_c_uuid_from_tags(mdev, nlp->tag_list, &args)) {
-                reply->ret_code = ERR_MANDATORY_TAG;
-                return 0;
+        mdev = adm_ctx.mdev;
+        memset(&args, 0, sizeof(args));
+        if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
+                err = new_c_uuid_parms_from_attrs(&args, info);
+                if (err) {
+                        retcode = ERR_MANDATORY_TAG;
+                        drbd_msg_put_info(from_attrs_err_to_txt(err));
+                        goto out_nolock;
+                }
         }
 
-        mutex_lock(&mdev->state_mutex); /* Protects us against serialized state changes. */
+        mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
 
         if (!get_ldev(mdev)) {
                 retcode = ERR_NO_DISK;
@@ -2260,7 +3013,7 @@ static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
         }
 
         /* this is "skip initial sync", assume to be clean */
-        if (mdev->state.conn == C_CONNECTED && mdev->agreed_pro_version >= 90 &&
+        if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
             mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
                 dev_info(DEV, "Preparing to skip initial sync\n");
                 skip_initial_sync = 1;
@@ -2283,10 +3036,10 @@ static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
                         drbd_send_uuids_skip_initial_sync(mdev);
                         _drbd_uuid_set(mdev, UI_BITMAP, 0);
                         drbd_print_uuids(mdev, "cleared bitmap UUID");
-                        spin_lock_irq(&mdev->req_lock);
+                        spin_lock_irq(&mdev->tconn->req_lock);
                         _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
                                         CS_VERBOSE, NULL);
-                        spin_unlock_irq(&mdev->req_lock);
+                        spin_unlock_irq(&mdev->tconn->req_lock);
                 }
         }
 
@@ -2294,416 +3047,283 @@ static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nl
 out_dec:
         put_ldev(mdev);
 out:
-        mutex_unlock(&mdev->state_mutex);
-
-        reply->ret_code = retcode;
+        mutex_unlock(mdev->state_mutex);
+out_nolock:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-struct cn_handler_struct {
-        int (*function)(struct drbd_conf *,
-                         struct drbd_nl_cfg_req *,
-                         struct drbd_nl_cfg_reply *);
-        int reply_body_size;
-};
-
-static struct cn_handler_struct cnd_table[] = {
-        [ P_primary ]           = { &drbd_nl_primary,           0 },
-        [ P_secondary ]         = { &drbd_nl_secondary,         0 },
-        [ P_disk_conf ]         = { &drbd_nl_disk_conf,         0 },
-        [ P_detach ]            = { &drbd_nl_detach,            0 },
-        [ P_net_conf ]          = { &drbd_nl_net_conf,          0 },
-        [ P_disconnect ]        = { &drbd_nl_disconnect,        0 },
-        [ P_resize ]            = { &drbd_nl_resize,            0 },
-        [ P_syncer_conf ]       = { &drbd_nl_syncer_conf,       0 },
-        [ P_invalidate ]        = { &drbd_nl_invalidate,        0 },
-        [ P_invalidate_peer ]   = { &drbd_nl_invalidate_peer,   0 },
-        [ P_pause_sync ]        = { &drbd_nl_pause_sync,        0 },
-        [ P_resume_sync ]       = { &drbd_nl_resume_sync,       0 },
-        [ P_suspend_io ]        = { &drbd_nl_suspend_io,        0 },
-        [ P_resume_io ]         = { &drbd_nl_resume_io,         0 },
-        [ P_outdate ]           = { &drbd_nl_outdate,           0 },
-        [ P_get_config ]        = { &drbd_nl_get_config,
-                                    sizeof(struct syncer_conf_tag_len_struct) +
-                                    sizeof(struct disk_conf_tag_len_struct) +
-                                    sizeof(struct net_conf_tag_len_struct) },
-        [ P_get_state ]         = { &drbd_nl_get_state,
-                                    sizeof(struct get_state_tag_len_struct) +
-                                    sizeof(struct sync_progress_tag_len_struct) },
-        [ P_get_uuids ]         = { &drbd_nl_get_uuids,
-                                    sizeof(struct get_uuids_tag_len_struct) },
-        [ P_get_timeout_flag ]  = { &drbd_nl_get_timeout_flag,
-                                    sizeof(struct get_timeout_flag_tag_len_struct)},
-        [ P_start_ov ]          = { &drbd_nl_start_ov,          0 },
-        [ P_new_c_uuid ]        = { &drbd_nl_new_c_uuid,        0 },
-};
-
-static void drbd_connector_callback(struct cn_msg *req, struct netlink_skb_parms *nsp)
+static enum drbd_ret_code
+drbd_check_resource_name(const char *name)
 {
-        struct drbd_nl_cfg_req *nlp = (struct drbd_nl_cfg_req *)req->data;
-        struct cn_handler_struct *cm;
-        struct cn_msg *cn_reply;
-        struct drbd_nl_cfg_reply *reply;
-        struct drbd_conf *mdev;
-        int retcode, rr;
-        int reply_size = sizeof(struct cn_msg)
-                + sizeof(struct drbd_nl_cfg_reply)
-                + sizeof(short int);
-
-        if (!try_module_get(THIS_MODULE)) {
-                printk(KERN_ERR "drbd: try_module_get() failed!\n");
-                return;
-        }
-
-        if (!capable(CAP_SYS_ADMIN)) {
-                retcode = ERR_PERM;
-                goto fail;
+        if (!name || !name[0]) {
+                drbd_msg_put_info("resource name missing");
+                return ERR_MANDATORY_TAG;
         }
-
-        mdev = ensure_mdev(nlp->drbd_minor,
-                        (nlp->flags & DRBD_NL_CREATE_DEVICE));
-        if (!mdev) {
-                retcode = ERR_MINOR_INVALID;
-                goto fail;
+        /* if we want to use these in sysfs/configfs/debugfs some day,
+         * we must not allow slashes */
+        if (strchr(name, '/')) {
+                drbd_msg_put_info("invalid resource name");
+                return ERR_INVALID_REQUEST;
         }
+        return NO_ERROR;
+}
 
-        if (nlp->packet_type >= P_nl_after_last_packet ||
-            nlp->packet_type == P_return_code_only) {
-                retcode = ERR_PACKET_NR;
-                goto fail;
-        }
+int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info)
+{
+        enum drbd_ret_code retcode;
+        struct res_opts res_opts;
+        int err;
 
-        cm = cnd_table + nlp->packet_type;
+        retcode = drbd_adm_prepare(skb, info, 0);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        /* This may happen if packet number is 0: */
-        if (cm->function == NULL) {
-                retcode = ERR_PACKET_NR;
-                goto fail;
+        set_res_opts_defaults(&res_opts);
+        err = res_opts_from_attrs(&res_opts, info);
+        if (err && err != -ENOMSG) {
+                retcode = ERR_MANDATORY_TAG;
+                drbd_msg_put_info(from_attrs_err_to_txt(err));
+                goto out;
         }
 
-        reply_size += cm->reply_body_size;
+        retcode = drbd_check_resource_name(adm_ctx.resource_name);
+        if (retcode != NO_ERROR)
+                goto out;
 
-        /* allocation not in the IO path, cqueue thread context */
-        cn_reply = kzalloc(reply_size, GFP_KERNEL);
-        if (!cn_reply) {
-                retcode = ERR_NOMEM;
-                goto fail;
+        if (adm_ctx.tconn) {
+                if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
+                        retcode = ERR_INVALID_REQUEST;
+                        drbd_msg_put_info("resource exists");
+                }
+                /* else: still NO_ERROR */
+                goto out;
         }
-        reply = (struct drbd_nl_cfg_reply *) cn_reply->data;
-
-        reply->packet_type =
-                cm->reply_body_size ? nlp->packet_type : P_return_code_only;
-        reply->minor = nlp->drbd_minor;
-        reply->ret_code = NO_ERROR; /* Might by modified by cm->function. */
-        /* reply->tag_list; might be modified by cm->function. */
-
-        rr = cm->function(mdev, nlp, reply);
-
-        cn_reply->id = req->id;
-        cn_reply->seq = req->seq;
-        cn_reply->ack = req->ack  + 1;
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + rr;
-        cn_reply->flags = 0;
 
-        rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_KERNEL);
-        if (rr && rr != -ESRCH)
-                printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr);
-
-        kfree(cn_reply);
-        module_put(THIS_MODULE);
-        return;
- fail:
-        drbd_nl_send_reply(req, retcode);
-        module_put(THIS_MODULE);
+        if (!conn_create(adm_ctx.resource_name, &res_opts))
+                retcode = ERR_NOMEM;
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-static atomic_t drbd_nl_seq = ATOMIC_INIT(2); /* two. */
-
-static unsigned short *
-__tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data,
-        unsigned short len, int nul_terminated)
+int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
 {
-        unsigned short l = tag_descriptions[tag_number(tag)].max_len;
-        len = (len < l) ? len :  l;
-        put_unaligned(tag, tl++);
-        put_unaligned(len, tl++);
-        memcpy(tl, data, len);
-        tl = (unsigned short*)((char*)tl + len);
-        if (nul_terminated)
-                *((char*)tl - 1) = 0;
-        return tl;
-}
+        struct drbd_genlmsghdr *dh = info->userhdr;
+        enum drbd_ret_code retcode;
 
-static unsigned short *
-tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data, int len)
-{
-        return __tl_add_blob(tl, tag, data, len, 0);
-}
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-static unsigned short *
-tl_add_str(unsigned short *tl, enum drbd_tags tag, const char *str)
-{
-        return __tl_add_blob(tl, tag, str, strlen(str)+1, 0);
-}
+        if (dh->minor > MINORMASK) {
+                drbd_msg_put_info("requested minor out of range");
+                retcode = ERR_INVALID_REQUEST;
+                goto out;
+        }
+        if (adm_ctx.volume > DRBD_VOLUME_MAX) {
+                drbd_msg_put_info("requested volume id out of range");
+                retcode = ERR_INVALID_REQUEST;
+                goto out;
+        }
 
-static unsigned short *
-tl_add_int(unsigned short *tl, enum drbd_tags tag, const void *val)
-{
-        put_unaligned(tag, tl++);
-        switch(tag_type(tag)) {
-        case TT_INTEGER:
-                put_unaligned(sizeof(int), tl++);
-                put_unaligned(*(int *)val, (int *)tl);
-                tl = (unsigned short*)((char*)tl+sizeof(int));
-                break;
-        case TT_INT64:
-                put_unaligned(sizeof(u64), tl++);
-                put_unaligned(*(u64 *)val, (u64 *)tl);
-                tl = (unsigned short*)((char*)tl+sizeof(u64));
-                break;
-        default:
-                /* someone did something stupid. */
-                ;
+        /* drbd_adm_prepare made sure already
+         * that mdev->tconn and mdev->vnr match the request. */
+        if (adm_ctx.mdev) {
+                if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
+                        retcode = ERR_MINOR_EXISTS;
+                /* else: still NO_ERROR */
+                goto out;
         }
-        return tl;
+
+        retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-void drbd_bcast_state(struct drbd_conf *mdev, union drbd_state state)
+static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
 {
-        char buffer[sizeof(struct cn_msg)+
-                    sizeof(struct drbd_nl_cfg_reply)+
-                    sizeof(struct get_state_tag_len_struct)+
-                    sizeof(short int)];
-        struct cn_msg *cn_reply = (struct cn_msg *) buffer;
-        struct drbd_nl_cfg_reply *reply =
-                (struct drbd_nl_cfg_reply *)cn_reply->data;
-        unsigned short *tl = reply->tag_list;
-
-        /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */
-
-        tl = get_state_to_tags(mdev, (struct get_state *)&state, tl);
-
-        put_unaligned(TT_END, tl++); /* Close the tag list */
-
-        cn_reply->id.idx = CN_IDX_DRBD;
-        cn_reply->id.val = CN_VAL_DRBD;
-
-        cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
-        cn_reply->ack = 0; /* not used here. */
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
-                (int)((char *)tl - (char *)reply->tag_list);
-        cn_reply->flags = 0;
-
-        reply->packet_type = P_get_state;
-        reply->minor = mdev_to_minor(mdev);
-        reply->ret_code = NO_ERROR;
-
-        cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
+        if (mdev->state.disk == D_DISKLESS &&
+            /* no need to be mdev->state.conn == C_STANDALONE &&
+             * we may want to delete a minor from a live replication group.
+             */
+            mdev->state.role == R_SECONDARY) {
+                _drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS),
+                                    CS_VERBOSE + CS_WAIT_COMPLETE);
+                idr_remove(&mdev->tconn->volumes, mdev->vnr);
+                idr_remove(&minors, mdev_to_minor(mdev));
+                del_gendisk(mdev->vdisk);
+                synchronize_rcu();
+                kref_put(&mdev->kref, &drbd_minor_destroy);
+                return NO_ERROR;
+        } else
+                return ERR_MINOR_CONFIGURED;
 }
 
-void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name)
+int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
 {
-        char buffer[sizeof(struct cn_msg)+
-                    sizeof(struct drbd_nl_cfg_reply)+
-                    sizeof(struct call_helper_tag_len_struct)+
-                    sizeof(short int)];
-        struct cn_msg *cn_reply = (struct cn_msg *) buffer;
-        struct drbd_nl_cfg_reply *reply =
-                (struct drbd_nl_cfg_reply *)cn_reply->data;
-        unsigned short *tl = reply->tag_list;
-
-        /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */
-
-        tl = tl_add_str(tl, T_helper, helper_name);
-        put_unaligned(TT_END, tl++); /* Close the tag list */
-
-        cn_reply->id.idx = CN_IDX_DRBD;
-        cn_reply->id.val = CN_VAL_DRBD;
-
-        cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
-        cn_reply->ack = 0; /* not used here. */
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
-                (int)((char *)tl - (char *)reply->tag_list);
-        cn_reply->flags = 0;
+        enum drbd_ret_code retcode;
 
-        reply->packet_type = P_call_helper;
-        reply->minor = mdev_to_minor(mdev);
-        reply->ret_code = NO_ERROR;
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
+        retcode = adm_delete_minor(adm_ctx.mdev);
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-void drbd_bcast_ee(struct drbd_conf *mdev,
-                const char *reason, const int dgs,
-                const char* seen_hash, const char* calc_hash,
-                const struct drbd_epoch_entry* e)
+int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
 {
-        struct cn_msg *cn_reply;
-        struct drbd_nl_cfg_reply *reply;
-        unsigned short *tl;
-        struct page *page;
-        unsigned len;
+        int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
+        struct drbd_conf *mdev;
+        unsigned i;
 
-        if (!e)
-                return;
-        if (!reason || !reason[0])
-                return;
+        retcode = drbd_adm_prepare(skb, info, 0);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        /* apparently we have to memcpy twice, first to prepare the data for the
-         * struct cn_msg, then within cn_netlink_send from the cn_msg to the
-         * netlink skb. */
-        /* receiver thread context, which is not in the writeout path (of this node),
-         * but may be in the writeout path of the _other_ node.
-         * GFP_NOIO to avoid potential "distributed deadlock". */
-        cn_reply = kzalloc(
-                sizeof(struct cn_msg)+
-                sizeof(struct drbd_nl_cfg_reply)+
-                sizeof(struct dump_ee_tag_len_struct)+
-                sizeof(short int),
-                GFP_NOIO);
-
-        if (!cn_reply) {
-                dev_err(DEV, "could not kmalloc buffer for drbd_bcast_ee, sector %llu, size %u\n",
-                                (unsigned long long)e->sector, e->size);
-                return;
+        if (!adm_ctx.tconn) {
+                retcode = ERR_RES_NOT_KNOWN;
+                goto out;
         }
 
-        reply = (struct drbd_nl_cfg_reply*)cn_reply->data;
-        tl = reply->tag_list;
-
-        tl = tl_add_str(tl, T_dump_ee_reason, reason);
-        tl = tl_add_blob(tl, T_seen_digest, seen_hash, dgs);
-        tl = tl_add_blob(tl, T_calc_digest, calc_hash, dgs);
-        tl = tl_add_int(tl, T_ee_sector, &e->sector);
-        tl = tl_add_int(tl, T_ee_block_id, &e->block_id);
-
-        /* dump the first 32k */
-        len = min_t(unsigned, e->size, 32 << 10);
-        put_unaligned(T_ee_data, tl++);
-        put_unaligned(len, tl++);
-
-        page = e->pages;
-        page_chain_for_each(page) {
-                void *d = kmap_atomic(page);
-                unsigned l = min_t(unsigned, len, PAGE_SIZE);
-                memcpy(tl, d, l);
-                kunmap_atomic(d);
-                tl = (unsigned short*)((char*)tl + l);
-                len -= l;
-                if (len == 0)
-                        break;
+        /* demote */
+        idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
+                retcode = drbd_set_role(mdev, R_SECONDARY, 0);
+                if (retcode < SS_SUCCESS) {
+                        drbd_msg_put_info("failed to demote");
+                        goto out;
+                }
         }
-        put_unaligned(TT_END, tl++); /* Close the tag list */
-
-        cn_reply->id.idx = CN_IDX_DRBD;
-        cn_reply->id.val = CN_VAL_DRBD;
 
-        cn_reply->seq = atomic_add_return(1,&drbd_nl_seq);
-        cn_reply->ack = 0; // not used here.
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
-                (int)((char*)tl - (char*)reply->tag_list);
-        cn_reply->flags = 0;
-
-        reply->packet_type = P_dump_ee;
-        reply->minor = mdev_to_minor(mdev);
-        reply->ret_code = NO_ERROR;
-
-        cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
-        kfree(cn_reply);
-}
-
-void drbd_bcast_sync_progress(struct drbd_conf *mdev)
-{
-        char buffer[sizeof(struct cn_msg)+
-                    sizeof(struct drbd_nl_cfg_reply)+
-                    sizeof(struct sync_progress_tag_len_struct)+
-                    sizeof(short int)];
-        struct cn_msg *cn_reply = (struct cn_msg *) buffer;
-        struct drbd_nl_cfg_reply *reply =
-                (struct drbd_nl_cfg_reply *)cn_reply->data;
-        unsigned short *tl = reply->tag_list;
-        unsigned long rs_left;
-        unsigned int res;
+        retcode = conn_try_disconnect(adm_ctx.tconn, 0);
+        if (retcode < SS_SUCCESS) {
+                drbd_msg_put_info("failed to disconnect");
+                goto out;
+        }
 
-        /* no local ref, no bitmap, no syncer progress, no broadcast. */
-        if (!get_ldev(mdev))
-                return;
-        drbd_get_syncer_progress(mdev, &rs_left, &res);
-        put_ldev(mdev);
+        /* detach */
+        idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
+                retcode = adm_detach(mdev, 0);
+                if (retcode < SS_SUCCESS || retcode > NO_ERROR) {
+                        drbd_msg_put_info("failed to detach");
+                        goto out;
+                }
+        }
 
-        tl = tl_add_int(tl, T_sync_progress, &res);
-        put_unaligned(TT_END, tl++); /* Close the tag list */
+        /* If we reach this, all volumes (of this tconn) are Secondary,
+         * Disconnected, Diskless, aka Unconfigured. Make sure all threads have
+         * actually stopped, state handling only does drbd_thread_stop_nowait(). */
+        drbd_thread_stop(&adm_ctx.tconn->worker);
 
-        cn_reply->id.idx = CN_IDX_DRBD;
-        cn_reply->id.val = CN_VAL_DRBD;
+        /* Now, nothing can fail anymore */
 
-        cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
-        cn_reply->ack = 0; /* not used here. */
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
-                (int)((char *)tl - (char *)reply->tag_list);
-        cn_reply->flags = 0;
+        /* delete volumes */
+        idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
+                retcode = adm_delete_minor(mdev);
+                if (retcode != NO_ERROR) {
+                        /* "can not happen" */
+                        drbd_msg_put_info("failed to delete volume");
+                        goto out;
+                }
+        }
 
-        reply->packet_type = P_sync_progress;
-        reply->minor = mdev_to_minor(mdev);
-        reply->ret_code = NO_ERROR;
+        /* delete connection */
+        if (conn_lowest_minor(adm_ctx.tconn) < 0) {
+                list_del_rcu(&adm_ctx.tconn->all_tconn);
+                synchronize_rcu();
+                kref_put(&adm_ctx.tconn->kref, &conn_destroy);
 
-        cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
+                retcode = NO_ERROR;
+        } else {
+                /* "can not happen" */
+                retcode = ERR_RES_IN_USE;
+                drbd_msg_put_info("failed to delete connection");
+        }
+        goto out;
+out:
+        drbd_adm_finish(info, retcode);
+        return 0;
 }
 
-int __init drbd_nl_init(void)
+int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info)
 {
-        static struct cb_id cn_id_drbd;
-        int err, try=10;
+        enum drbd_ret_code retcode;
 
-        cn_id_drbd.val = CN_VAL_DRBD;
-        do {
-                cn_id_drbd.idx = cn_idx;
-                err = cn_add_callback(&cn_id_drbd, "cn_drbd", &drbd_connector_callback);
-                if (!err)
-                        break;
-                cn_idx = (cn_idx + CN_IDX_STEP);
-        } while (try--);
+        retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
+        if (!adm_ctx.reply_skb)
+                return retcode;
+        if (retcode != NO_ERROR)
+                goto out;
 
-        if (err) {
-                printk(KERN_ERR "drbd: cn_drbd failed to register\n");
-                return err;
+        if (conn_lowest_minor(adm_ctx.tconn) < 0) {
+                list_del_rcu(&adm_ctx.tconn->all_tconn);
+                synchronize_rcu();
+                kref_put(&adm_ctx.tconn->kref, &conn_destroy);
+
+                retcode = NO_ERROR;
+        } else {
+                retcode = ERR_RES_IN_USE;
         }
 
+        if (retcode == NO_ERROR)
+                drbd_thread_stop(&adm_ctx.tconn->worker);
+out:
+        drbd_adm_finish(info, retcode);
         return 0;
 }
 
-void drbd_nl_cleanup(void)
+void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
 {
-        static struct cb_id cn_id_drbd;
-
-        cn_id_drbd.idx = cn_idx;
-        cn_id_drbd.val = CN_VAL_DRBD;
-
-        cn_del_callback(&cn_id_drbd);
-}
-
-void drbd_nl_send_reply(struct cn_msg *req, int ret_code)
-{
-        char buffer[sizeof(struct cn_msg)+sizeof(struct drbd_nl_cfg_reply)];
-        struct cn_msg *cn_reply = (struct cn_msg *) buffer;
-        struct drbd_nl_cfg_reply *reply =
-                (struct drbd_nl_cfg_reply *)cn_reply->data;
-        int rr;
-
-        memset(buffer, 0, sizeof(buffer));
-        cn_reply->id = req->id;
+        static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
+        struct sk_buff *msg;
+        struct drbd_genlmsghdr *d_out;
+        unsigned seq;
+        int err = -ENOMEM;
+
+        if (sib->sib_reason == SIB_SYNC_PROGRESS &&
+            time_after(jiffies, mdev->rs_last_bcast + HZ))
+                mdev->rs_last_bcast = jiffies;
+        else
+                return;
 
-        cn_reply->seq = req->seq;
-        cn_reply->ack = req->ack  + 1;
-        cn_reply->len = sizeof(struct drbd_nl_cfg_reply);
-        cn_reply->flags = 0;
+        seq = atomic_inc_return(&drbd_genl_seq);
+        msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
+        if (!msg)
+                goto failed;
+
+        err = -EMSGSIZE;
+        d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
+        if (!d_out) /* cannot happen, but anyways. */
+                goto nla_put_failure;
+        d_out->minor = mdev_to_minor(mdev);
+        d_out->ret_code = NO_ERROR;
+
+        if (nla_put_status_info(msg, mdev, sib))
+                goto nla_put_failure;
+        genlmsg_end(msg, d_out);
+        err = drbd_genl_multicast_events(msg, 0);
+        /* msg has been consumed or freed in netlink_broadcast() */
+        if (err && err != -ESRCH)
+                goto failed;
 
-        reply->packet_type = P_return_code_only;
-        reply->minor = ((struct drbd_nl_cfg_req *)req->data)->drbd_minor;
-        reply->ret_code = ret_code;
+        return;
 
-        rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
-        if (rr && rr != -ESRCH)
-                printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr);
+nla_put_failure:
+        nlmsg_free(msg);
+failed:
+        dev_err(DEV, "Error %d while broadcasting event. "
+                        "Event seq:%u sib_reason:%u\n",
+                        err, seq, sib->sib_reason);
 }
-