drbd: Backport the "status" command
authorAndreas Gruenbacher <agruen@linbit.com>
Thu, 28 Aug 2014 11:31:14 +0000 (13:31 +0200)
committerJens Axboe <axboe@fb.com>
Wed, 25 Nov 2015 16:22:00 +0000 (09:22 -0700)
The status command originates the drbd9 code base. While for now we
keep the status information in /proc/drbd available, this commit
allows the user base to gracefully migrate their monitoring
infrastructure to the new status reporting interface.

In drbd9 no status information is exposed through /proc/drbd.

Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com>
Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
drivers/block/drbd/drbd_nl.c
include/linux/drbd_genl.h
include/linux/idr.h

index aa805cdde769486e03b9ae5f5aeb49ffaa50974f..1eb10e28ac192098452958181e4e3c1e1b574dc0 100644 (file)
@@ -76,6 +76,13 @@ 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);
+int drbd_adm_dump_resources(struct sk_buff *skb, struct netlink_callback *cb);
+int drbd_adm_dump_devices(struct sk_buff *skb, struct netlink_callback *cb);
+int drbd_adm_dump_devices_done(struct netlink_callback *cb);
+int drbd_adm_dump_connections(struct sk_buff *skb, struct netlink_callback *cb);
+int drbd_adm_dump_connections_done(struct netlink_callback *cb);
+int drbd_adm_dump_peer_devices(struct sk_buff *skb, struct netlink_callback *cb);
+int drbd_adm_dump_peer_devices_done(struct netlink_callback *cb);
 int drbd_adm_get_initial_state(struct sk_buff *skb, struct netlink_callback *cb);
 
 #include <linux/drbd_genl_api.h>
@@ -2964,6 +2971,486 @@ nla_put_failure:
        return -EMSGSIZE;
 }
 
+/*
+ * The generic netlink dump callbacks are called outside the genl_lock(), so
+ * they cannot use the simple attribute parsing code which uses global
+ * attribute tables.
+ */
+static struct nlattr *find_cfg_context_attr(const struct nlmsghdr *nlh, int attr)
+{
+       const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
+       const int maxtype = ARRAY_SIZE(drbd_cfg_context_nl_policy) - 1;
+       struct nlattr *nla;
+
+       nla = nla_find(nlmsg_attrdata(nlh, hdrlen), nlmsg_attrlen(nlh, hdrlen),
+                      DRBD_NLA_CFG_CONTEXT);
+       if (!nla)
+               return NULL;
+       return drbd_nla_find_nested(maxtype, nla, __nla_type(attr));
+}
+
+static void resource_to_info(struct resource_info *, struct drbd_resource *);
+
+int drbd_adm_dump_resources(struct sk_buff *skb, struct netlink_callback *cb)
+{
+       struct drbd_genlmsghdr *dh;
+       struct drbd_resource *resource;
+       struct resource_info resource_info;
+       struct resource_statistics resource_statistics;
+       int err;
+
+       rcu_read_lock();
+       if (cb->args[0]) {
+               for_each_resource_rcu(resource, &drbd_resources)
+                       if (resource == (struct drbd_resource *)cb->args[0])
+                               goto found_resource;
+               err = 0;  /* resource was probably deleted */
+               goto out;
+       }
+       resource = list_entry(&drbd_resources,
+                             struct drbd_resource, resources);
+
+found_resource:
+       list_for_each_entry_continue_rcu(resource, &drbd_resources, resources) {
+               goto put_result;
+       }
+       err = 0;
+       goto out;
+
+put_result:
+       dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
+                       cb->nlh->nlmsg_seq, &drbd_genl_family,
+                       NLM_F_MULTI, DRBD_ADM_GET_RESOURCES);
+       err = -ENOMEM;
+       if (!dh)
+               goto out;
+       dh->minor = -1U;
+       dh->ret_code = NO_ERROR;
+       err = nla_put_drbd_cfg_context(skb, resource, NULL, NULL);
+       if (err)
+               goto out;
+       err = res_opts_to_skb(skb, &resource->res_opts, !capable(CAP_SYS_ADMIN));
+       if (err)
+               goto out;
+       resource_to_info(&resource_info, resource);
+       err = resource_info_to_skb(skb, &resource_info, !capable(CAP_SYS_ADMIN));
+       if (err)
+               goto out;
+       resource_statistics.res_stat_write_ordering = resource->write_ordering;
+       err = resource_statistics_to_skb(skb, &resource_statistics, !capable(CAP_SYS_ADMIN));
+       if (err)
+               goto out;
+       cb->args[0] = (long)resource;
+       genlmsg_end(skb, dh);
+       err = 0;
+
+out:
+       rcu_read_unlock();
+       if (err)
+               return err;
+       return skb->len;
+}
+
+static void device_to_statistics(struct device_statistics *s,
+                                struct drbd_device *device)
+{
+       memset(s, 0, sizeof(*s));
+       s->dev_upper_blocked = !may_inc_ap_bio(device);
+       if (get_ldev(device)) {
+               struct drbd_md *md = &device->ldev->md;
+               u64 *history_uuids = (u64 *)s->history_uuids;
+               struct request_queue *q;
+               int n;
+
+               spin_lock_irq(&md->uuid_lock);
+               s->dev_current_uuid = md->uuid[UI_CURRENT];
+               BUILD_BUG_ON(sizeof(s->history_uuids) < UI_HISTORY_END - UI_HISTORY_START + 1);
+               for (n = 0; n < UI_HISTORY_END - UI_HISTORY_START + 1; n++)
+                       history_uuids[n] = md->uuid[UI_HISTORY_START + n];
+               for (; n < HISTORY_UUIDS; n++)
+                       history_uuids[n] = 0;
+               s->history_uuids_len = HISTORY_UUIDS;
+               spin_unlock_irq(&md->uuid_lock);
+
+               s->dev_disk_flags = md->flags;
+               q = bdev_get_queue(device->ldev->backing_bdev);
+               s->dev_lower_blocked =
+                       bdi_congested(&q->backing_dev_info,
+                                     (1 << WB_async_congested) |
+                                     (1 << WB_sync_congested));
+               put_ldev(device);
+       }
+       s->dev_size = drbd_get_capacity(device->this_bdev);
+       s->dev_read = device->read_cnt;
+       s->dev_write = device->writ_cnt;
+       s->dev_al_writes = device->al_writ_cnt;
+       s->dev_bm_writes = device->bm_writ_cnt;
+       s->dev_upper_pending = atomic_read(&device->ap_bio_cnt);
+       s->dev_lower_pending = atomic_read(&device->local_cnt);
+       s->dev_al_suspended = test_bit(AL_SUSPENDED, &device->flags);
+       s->dev_exposed_data_uuid = device->ed_uuid;
+}
+
+static int put_resource_in_arg0(struct netlink_callback *cb, int holder_nr)
+{
+       if (cb->args[0]) {
+               struct drbd_resource *resource =
+                       (struct drbd_resource *)cb->args[0];
+               kref_put(&resource->kref, drbd_destroy_resource);
+       }
+
+       return 0;
+}
+
+int drbd_adm_dump_devices_done(struct netlink_callback *cb) {
+       return put_resource_in_arg0(cb, 7);
+}
+
+static void device_to_info(struct device_info *, struct drbd_device *);
+
+int drbd_adm_dump_devices(struct sk_buff *skb, struct netlink_callback *cb)
+{
+       struct nlattr *resource_filter;
+       struct drbd_resource *resource;
+       struct drbd_device *uninitialized_var(device);
+       int minor, err, retcode;
+       struct drbd_genlmsghdr *dh;
+       struct device_info device_info;
+       struct device_statistics device_statistics;
+       struct idr *idr_to_search;
+
+       resource = (struct drbd_resource *)cb->args[0];
+       if (!cb->args[0] && !cb->args[1]) {
+               resource_filter = find_cfg_context_attr(cb->nlh, T_ctx_resource_name);
+               if (resource_filter) {
+                       retcode = ERR_RES_NOT_KNOWN;
+                       resource = drbd_find_resource(nla_data(resource_filter));
+                       if (!resource)
+                               goto put_result;
+                       cb->args[0] = (long)resource;
+               }
+       }
+
+       rcu_read_lock();
+       minor = cb->args[1];
+       idr_to_search = resource ? &resource->devices : &drbd_devices;
+       device = idr_get_next(idr_to_search, &minor);
+       if (!device) {
+               err = 0;
+               goto out;
+       }
+       idr_for_each_entry_continue(idr_to_search, device, minor) {
+               retcode = NO_ERROR;
+               goto put_result;  /* only one iteration */
+       }
+       err = 0;
+       goto out;  /* no more devices */
+
+put_result:
+       dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
+                       cb->nlh->nlmsg_seq, &drbd_genl_family,
+                       NLM_F_MULTI, DRBD_ADM_GET_DEVICES);
+       err = -ENOMEM;
+       if (!dh)
+               goto out;
+       dh->ret_code = retcode;
+       dh->minor = -1U;
+       if (retcode == NO_ERROR) {
+               dh->minor = device->minor;
+               err = nla_put_drbd_cfg_context(skb, device->resource, NULL, device);
+               if (err)
+                       goto out;
+               if (get_ldev(device)) {
+                       struct disk_conf *disk_conf =
+                               rcu_dereference(device->ldev->disk_conf);
+
+                       err = disk_conf_to_skb(skb, disk_conf, !capable(CAP_SYS_ADMIN));
+                       put_ldev(device);
+                       if (err)
+                               goto out;
+               }
+               device_to_info(&device_info, device);
+               err = device_info_to_skb(skb, &device_info, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+
+               device_to_statistics(&device_statistics, device);
+               err = device_statistics_to_skb(skb, &device_statistics, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+               cb->args[1] = minor + 1;
+       }
+       genlmsg_end(skb, dh);
+       err = 0;
+
+out:
+       rcu_read_unlock();
+       if (err)
+               return err;
+       return skb->len;
+}
+
+int drbd_adm_dump_connections_done(struct netlink_callback *cb)
+{
+       return put_resource_in_arg0(cb, 6);
+}
+
+enum { SINGLE_RESOURCE, ITERATE_RESOURCES };
+
+int drbd_adm_dump_connections(struct sk_buff *skb, struct netlink_callback *cb)
+{
+       struct nlattr *resource_filter;
+       struct drbd_resource *resource = NULL, *next_resource;
+       struct drbd_connection *uninitialized_var(connection);
+       int err = 0, retcode;
+       struct drbd_genlmsghdr *dh;
+       struct connection_info connection_info;
+       struct connection_statistics connection_statistics;
+
+       rcu_read_lock();
+       resource = (struct drbd_resource *)cb->args[0];
+       if (!cb->args[0]) {
+               resource_filter = find_cfg_context_attr(cb->nlh, T_ctx_resource_name);
+               if (resource_filter) {
+                       retcode = ERR_RES_NOT_KNOWN;
+                       resource = drbd_find_resource(nla_data(resource_filter));
+                       if (!resource)
+                               goto put_result;
+                       cb->args[0] = (long)resource;
+                       cb->args[1] = SINGLE_RESOURCE;
+               }
+       }
+       if (!resource) {
+               if (list_empty(&drbd_resources))
+                       goto out;
+               resource = list_first_entry(&drbd_resources, struct drbd_resource, resources);
+               kref_get(&resource->kref);
+               cb->args[0] = (long)resource;
+               cb->args[1] = ITERATE_RESOURCES;
+       }
+
+    next_resource:
+       rcu_read_unlock();
+       mutex_lock(&resource->conf_update);
+       rcu_read_lock();
+       if (cb->args[2]) {
+               for_each_connection_rcu(connection, resource)
+                       if (connection == (struct drbd_connection *)cb->args[2])
+                               goto found_connection;
+               /* connection was probably deleted */
+               goto no_more_connections;
+       }
+       connection = list_entry(&resource->connections, struct drbd_connection, connections);
+
+found_connection:
+       list_for_each_entry_continue_rcu(connection, &resource->connections, connections) {
+               if (!has_net_conf(connection))
+                       continue;
+               retcode = NO_ERROR;
+               goto put_result;  /* only one iteration */
+       }
+
+no_more_connections:
+       if (cb->args[1] == ITERATE_RESOURCES) {
+               for_each_resource_rcu(next_resource, &drbd_resources) {
+                       if (next_resource == resource)
+                               goto found_resource;
+               }
+               /* resource was probably deleted */
+       }
+       goto out;
+
+found_resource:
+       list_for_each_entry_continue_rcu(next_resource, &drbd_resources, resources) {
+               mutex_unlock(&resource->conf_update);
+               kref_put(&resource->kref, drbd_destroy_resource);
+               resource = next_resource;
+               kref_get(&resource->kref);
+               cb->args[0] = (long)resource;
+               cb->args[2] = 0;
+               goto next_resource;
+       }
+       goto out;  /* no more resources */
+
+put_result:
+       dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
+                       cb->nlh->nlmsg_seq, &drbd_genl_family,
+                       NLM_F_MULTI, DRBD_ADM_GET_CONNECTIONS);
+       err = -ENOMEM;
+       if (!dh)
+               goto out;
+       dh->ret_code = retcode;
+       dh->minor = -1U;
+       if (retcode == NO_ERROR) {
+               struct net_conf *net_conf;
+
+               err = nla_put_drbd_cfg_context(skb, resource, connection, NULL);
+               if (err)
+                       goto out;
+               net_conf = rcu_dereference(connection->net_conf);
+               if (net_conf) {
+                       err = net_conf_to_skb(skb, net_conf, !capable(CAP_SYS_ADMIN));
+                       if (err)
+                               goto out;
+               }
+               connection_to_info(&connection_info, connection);
+               err = connection_info_to_skb(skb, &connection_info, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+               connection_statistics.conn_congested = test_bit(NET_CONGESTED, &connection->flags);
+               err = connection_statistics_to_skb(skb, &connection_statistics, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+               cb->args[2] = (long)connection;
+       }
+       genlmsg_end(skb, dh);
+       err = 0;
+
+out:
+       rcu_read_unlock();
+       if (resource)
+               mutex_unlock(&resource->conf_update);
+       if (err)
+               return err;
+       return skb->len;
+}
+
+enum mdf_peer_flag {
+       MDF_PEER_CONNECTED =    1 << 0,
+       MDF_PEER_OUTDATED =     1 << 1,
+       MDF_PEER_FENCING =      1 << 2,
+       MDF_PEER_FULL_SYNC =    1 << 3,
+};
+
+static void peer_device_to_statistics(struct peer_device_statistics *s,
+                                     struct drbd_peer_device *peer_device)
+{
+       struct drbd_device *device = peer_device->device;
+
+       memset(s, 0, sizeof(*s));
+       s->peer_dev_received = device->recv_cnt;
+       s->peer_dev_sent = device->send_cnt;
+       s->peer_dev_pending = atomic_read(&device->ap_pending_cnt) +
+                             atomic_read(&device->rs_pending_cnt);
+       s->peer_dev_unacked = atomic_read(&device->unacked_cnt);
+       s->peer_dev_out_of_sync = drbd_bm_total_weight(device) << (BM_BLOCK_SHIFT - 9);
+       s->peer_dev_resync_failed = device->rs_failed << (BM_BLOCK_SHIFT - 9);
+       if (get_ldev(device)) {
+               struct drbd_md *md = &device->ldev->md;
+
+               spin_lock_irq(&md->uuid_lock);
+               s->peer_dev_bitmap_uuid = md->uuid[UI_BITMAP];
+               spin_unlock_irq(&md->uuid_lock);
+               s->peer_dev_flags =
+                       (drbd_md_test_flag(device->ldev, MDF_CONNECTED_IND) ?
+                               MDF_PEER_CONNECTED : 0) +
+                       (drbd_md_test_flag(device->ldev, MDF_CONSISTENT) &&
+                        !drbd_md_test_flag(device->ldev, MDF_WAS_UP_TO_DATE) ?
+                               MDF_PEER_OUTDATED : 0) +
+                       /* FIXME: MDF_PEER_FENCING? */
+                       (drbd_md_test_flag(device->ldev, MDF_FULL_SYNC) ?
+                               MDF_PEER_FULL_SYNC : 0);
+               put_ldev(device);
+       }
+}
+
+int drbd_adm_dump_peer_devices_done(struct netlink_callback *cb)
+{
+       return put_resource_in_arg0(cb, 9);
+}
+
+int drbd_adm_dump_peer_devices(struct sk_buff *skb, struct netlink_callback *cb)
+{
+       struct nlattr *resource_filter;
+       struct drbd_resource *resource;
+       struct drbd_device *uninitialized_var(device);
+       struct drbd_peer_device *peer_device = NULL;
+       int minor, err, retcode;
+       struct drbd_genlmsghdr *dh;
+       struct idr *idr_to_search;
+
+       resource = (struct drbd_resource *)cb->args[0];
+       if (!cb->args[0] && !cb->args[1]) {
+               resource_filter = find_cfg_context_attr(cb->nlh, T_ctx_resource_name);
+               if (resource_filter) {
+                       retcode = ERR_RES_NOT_KNOWN;
+                       resource = drbd_find_resource(nla_data(resource_filter));
+                       if (!resource)
+                               goto put_result;
+               }
+               cb->args[0] = (long)resource;
+       }
+
+       rcu_read_lock();
+       minor = cb->args[1];
+       idr_to_search = resource ? &resource->devices : &drbd_devices;
+       device = idr_find(idr_to_search, minor);
+       if (!device) {
+next_device:
+               minor++;
+               cb->args[2] = 0;
+               device = idr_get_next(idr_to_search, &minor);
+               if (!device) {
+                       err = 0;
+                       goto out;
+               }
+       }
+       if (cb->args[2]) {
+               for_each_peer_device(peer_device, device)
+                       if (peer_device == (struct drbd_peer_device *)cb->args[2])
+                               goto found_peer_device;
+               /* peer device was probably deleted */
+               goto next_device;
+       }
+       /* Make peer_device point to the list head (not the first entry). */
+       peer_device = list_entry(&device->peer_devices, struct drbd_peer_device, peer_devices);
+
+found_peer_device:
+       list_for_each_entry_continue_rcu(peer_device, &device->peer_devices, peer_devices) {
+               if (!has_net_conf(peer_device->connection))
+                       continue;
+               retcode = NO_ERROR;
+               goto put_result;  /* only one iteration */
+       }
+       goto next_device;
+
+put_result:
+       dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
+                       cb->nlh->nlmsg_seq, &drbd_genl_family,
+                       NLM_F_MULTI, DRBD_ADM_GET_PEER_DEVICES);
+       err = -ENOMEM;
+       if (!dh)
+               goto out;
+       dh->ret_code = retcode;
+       dh->minor = -1U;
+       if (retcode == NO_ERROR) {
+               struct peer_device_info peer_device_info;
+               struct peer_device_statistics peer_device_statistics;
+
+               dh->minor = minor;
+               err = nla_put_drbd_cfg_context(skb, device->resource, peer_device->connection, device);
+               if (err)
+                       goto out;
+               peer_device_to_info(&peer_device_info, peer_device);
+               err = peer_device_info_to_skb(skb, &peer_device_info, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+               peer_device_to_statistics(&peer_device_statistics, peer_device);
+               err = peer_device_statistics_to_skb(skb, &peer_device_statistics, !capable(CAP_SYS_ADMIN));
+               if (err)
+                       goto out;
+               cb->args[1] = minor;
+               cb->args[2] = (long)peer_device;
+       }
+       genlmsg_end(skb, dh);
+       err = 0;
+
+out:
+       rcu_read_unlock();
+       if (err)
+               return err;
+       return skb->len;
+}
 /*
  * Return the connection of @resource if @resource has exactly one connection.
  */
@@ -3818,85 +4305,6 @@ failed:
                        err, seq, sib->sib_reason);
 }
 
-static void device_to_statistics(struct device_statistics *s,
-                                struct drbd_device *device)
-{
-       memset(s, 0, sizeof(*s));
-       s->dev_upper_blocked = !may_inc_ap_bio(device);
-       if (get_ldev(device)) {
-               struct drbd_md *md = &device->ldev->md;
-               u64 *history_uuids = (u64 *)s->history_uuids;
-               struct request_queue *q;
-               int n;
-
-               spin_lock_irq(&md->uuid_lock);
-               s->dev_current_uuid = md->uuid[UI_CURRENT];
-               BUILD_BUG_ON(sizeof(s->history_uuids) < UI_HISTORY_END - UI_HISTORY_START + 1);
-               for (n = 0; n < UI_HISTORY_END - UI_HISTORY_START + 1; n++)
-                       history_uuids[n] = md->uuid[UI_HISTORY_START + n];
-               for (; n < HISTORY_UUIDS; n++)
-                       history_uuids[n] = 0;
-               s->history_uuids_len = HISTORY_UUIDS;
-               spin_unlock_irq(&md->uuid_lock);
-
-               s->dev_disk_flags = md->flags;
-               q = bdev_get_queue(device->ldev->backing_bdev);
-               s->dev_lower_blocked =
-                       bdi_congested(&q->backing_dev_info,
-                                     (1 << WB_async_congested) |
-                                     (1 << WB_sync_congested));
-               put_ldev(device);
-       }
-       s->dev_size = drbd_get_capacity(device->this_bdev);
-       s->dev_read = device->read_cnt;
-       s->dev_write = device->writ_cnt;
-       s->dev_al_writes = device->al_writ_cnt;
-       s->dev_bm_writes = device->bm_writ_cnt;
-       s->dev_upper_pending = atomic_read(&device->ap_bio_cnt);
-       s->dev_lower_pending = atomic_read(&device->local_cnt);
-       s->dev_al_suspended = test_bit(AL_SUSPENDED, &device->flags);
-       s->dev_exposed_data_uuid = device->ed_uuid;
-}
-
-enum mdf_peer_flag {
-       MDF_PEER_CONNECTED =    1 << 0,
-       MDF_PEER_OUTDATED =     1 << 1,
-       MDF_PEER_FENCING =      1 << 2,
-       MDF_PEER_FULL_SYNC =    1 << 3,
-};
-
-static void peer_device_to_statistics(struct peer_device_statistics *s,
-                                     struct drbd_peer_device *peer_device)
-{
-       struct drbd_device *device = peer_device->device;
-
-       memset(s, 0, sizeof(*s));
-       s->peer_dev_received = device->recv_cnt;
-       s->peer_dev_sent = device->send_cnt;
-       s->peer_dev_pending = atomic_read(&device->ap_pending_cnt) +
-                             atomic_read(&device->rs_pending_cnt);
-       s->peer_dev_unacked = atomic_read(&device->unacked_cnt);
-       s->peer_dev_out_of_sync = drbd_bm_total_weight(device) << (BM_BLOCK_SHIFT - 9);
-       s->peer_dev_resync_failed = device->rs_failed << (BM_BLOCK_SHIFT - 9);
-       if (get_ldev(device)) {
-               struct drbd_md *md = &device->ldev->md;
-
-               spin_lock_irq(&md->uuid_lock);
-               s->peer_dev_bitmap_uuid = md->uuid[UI_BITMAP];
-               spin_unlock_irq(&md->uuid_lock);
-               s->peer_dev_flags =
-                       (drbd_md_test_flag(device->ldev, MDF_CONNECTED_IND) ?
-                               MDF_PEER_CONNECTED : 0) +
-                       (drbd_md_test_flag(device->ldev, MDF_CONSISTENT) &&
-                        !drbd_md_test_flag(device->ldev, MDF_WAS_UP_TO_DATE) ?
-                               MDF_PEER_OUTDATED : 0) +
-                       /* FIXME: MDF_PEER_FENCING? */
-                       (drbd_md_test_flag(device->ldev, MDF_FULL_SYNC) ?
-                               MDF_PEER_FULL_SYNC : 0);
-               put_ldev(device);
-       }
-}
-
 static int nla_put_notification_header(struct sk_buff *msg,
                                       enum drbd_notification_type type)
 {
index 90304f8697ec8b9dde75cb5cc8eecd07cdbced62..2d0e5ad5de9d34227700acfee0e188eb6c752471 100644 (file)
@@ -453,6 +453,41 @@ GENL_op(DRBD_ADM_GET_TIMEOUT_TYPE, 26, GENL_doit(drbd_adm_get_timeout_type),
 GENL_op(DRBD_ADM_DOWN,         27, GENL_doit(drbd_adm_down),
        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_F_REQUIRED))
 
+GENL_op(DRBD_ADM_GET_RESOURCES, 30,
+        GENL_op_init(
+                .dumpit = drbd_adm_dump_resources,
+        ),
+        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_RESOURCE_INFO, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_RESOURCE_STATISTICS, DRBD_GENLA_F_MANDATORY))
+
+GENL_op(DRBD_ADM_GET_DEVICES, 31,
+        GENL_op_init(
+                .dumpit = drbd_adm_dump_devices,
+                .done = drbd_adm_dump_devices_done,
+        ),
+        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_DEVICE_INFO, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_DEVICE_STATISTICS, DRBD_GENLA_F_MANDATORY))
+
+GENL_op(DRBD_ADM_GET_CONNECTIONS, 32,
+        GENL_op_init(
+                .dumpit = drbd_adm_dump_connections,
+                .done = drbd_adm_dump_connections_done,
+        ),
+        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_CONNECTION_INFO, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_CONNECTION_STATISTICS, DRBD_GENLA_F_MANDATORY))
+
+GENL_op(DRBD_ADM_GET_PEER_DEVICES, 33,
+        GENL_op_init(
+                .dumpit = drbd_adm_dump_peer_devices,
+                .done = drbd_adm_dump_peer_devices_done,
+        ),
+        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_PEER_DEVICE_INFO, DRBD_GENLA_F_MANDATORY)
+        GENL_tla_expected(DRBD_NLA_PEER_DEVICE_STATISTICS, DRBD_GENLA_F_MANDATORY))
+
 GENL_notification(
        DRBD_RESOURCE_STATE, 34, events,
        GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_F_REQUIRED)
index 013fd9bc4cb6cefb102705a88a6911de546acd0a..083d61e9270632be41a7b707104af7003d3c23cb 100644 (file)
@@ -135,6 +135,20 @@ static inline void *idr_find(struct idr *idr, int id)
 #define idr_for_each_entry(idp, entry, id)                     \
        for (id = 0; ((entry) = idr_get_next(idp, &(id))) != NULL; ++id)
 
+/**
+ * idr_for_each_entry - continue iteration over an idr's elements of a given type
+ * @idp:     idr handle
+ * @entry:   the type * to use as cursor
+ * @id:      id entry's key
+ *
+ * Continue to iterate over list of given type, continuing after
+ * the current position.
+ */
+#define idr_for_each_entry_continue(idp, entry, id)                    \
+       for ((entry) = idr_get_next((idp), &(id));                      \
+            entry;                                                     \
+            ++id, (entry) = idr_get_next((idp), &(id)))
+
 /*
  * IDA - IDR based id allocator, use when translation from id to
  * pointer isn't necessary.