Lines Matching defs:resource

234 		adm_ctx->resource = drbd_find_resource(adm_ctx->resource_name);
241 if (!adm_ctx->resource && (flags & DRBD_ADM_NEED_RESOURCE)) {
242 drbd_msg_put_info(adm_ctx->reply_skb, "unknown resource");
249 if (adm_ctx->resource) {
250 drbd_msg_put_info(adm_ctx->reply_skb, "no resource name expected");
269 if (adm_ctx->device && adm_ctx->resource &&
270 adm_ctx->device->resource != adm_ctx->resource) {
271 pr_warn("request: minor=%u, resource=%s; but that minor belongs to resource %s\n",
272 adm_ctx->minor, adm_ctx->resource->name,
273 adm_ctx->device->resource->name);
274 drbd_msg_put_info(adm_ctx->reply_skb, "minor exists in different resource");
282 adm_ctx->device->vnr, adm_ctx->device->resource->name);
287 /* still, provide adm_ctx->resource always, if possible. */
288 if (!adm_ctx->resource) {
289 adm_ctx->resource = adm_ctx->device ? adm_ctx->device->resource
290 : adm_ctx->connection ? adm_ctx->connection->resource : NULL;
291 if (adm_ctx->resource)
292 kref_get(&adm_ctx->resource->kref);
314 if (adm_ctx->resource) {
315 kref_put(&adm_ctx->resource->kref, drbd_destroy_resource);
316 adm_ctx->resource = NULL;
414 char *resource_name = connection->resource->name;
464 static bool resource_is_supended(struct drbd_resource *resource)
466 return resource->susp || resource->susp_fen || resource->susp_nod;
471 struct drbd_resource * const resource = connection->resource;
479 spin_lock_irq(&resource->req_lock);
482 spin_unlock_irq(&resource->req_lock);
487 spin_unlock_irq(&resource->req_lock);
493 spin_lock_irq(&resource->req_lock);
502 if (!resource_is_supended(resource))
511 spin_unlock_irq(&resource->req_lock);
572 spin_lock_irq(&resource->req_lock);
581 spin_unlock_irq(&resource->req_lock);
632 for_each_connection(connection, device->resource)
724 mutex_lock(&device->resource->conf_update);
728 mutex_unlock(&device->resource->conf_update);
791 mutex_lock(&adm_ctx.resource->adm_mutex);
798 mutex_unlock(&adm_ctx.resource->adm_mutex);
1363 spin_lock_irq(&connection->resource->req_lock);
1366 spin_unlock_irq(&connection->resource->req_lock);
1386 spin_lock_irq(&device->resource->req_lock);
1389 spin_unlock_irq(&device->resource->req_lock);
1519 mutex_lock(&adm_ctx.resource->adm_mutex);
1534 mutex_lock(&device->resource->conf_update);
1591 mutex_unlock(&device->resource->conf_update);
1604 drbd_bump_write_ordering(device->resource, NULL, WO_BDEV_FLUSH);
1625 mutex_unlock(&device->resource->conf_update);
1632 mutex_unlock(&adm_ctx.resource->adm_mutex);
1749 mutex_lock(&adm_ctx.resource->adm_mutex);
1898 * As barriers are counted per resource,
1899 * we'd need to suspend io on all devices of a resource.
1982 drbd_bump_write_ordering(device->resource, device->ldev, WO_BDEV_FLUSH);
1991 !(device->state.role == R_PRIMARY && device->resource->susp_nod))
2051 spin_lock_irq(&device->resource->req_lock);
2103 spin_unlock_irq(&device->resource->req_lock);
2121 mutex_unlock(&adm_ctx.resource->adm_mutex);
2143 mutex_unlock(&adm_ctx.resource->adm_mutex);
2187 mutex_lock(&adm_ctx.resource->adm_mutex);
2189 mutex_unlock(&adm_ctx.resource->adm_mutex);
2381 mutex_lock(&adm_ctx.resource->adm_mutex);
2392 mutex_lock(&connection->resource->conf_update);
2456 mutex_unlock(&connection->resource->conf_update);
2471 mutex_unlock(&connection->resource->conf_update);
2478 mutex_unlock(&adm_ctx.resource->adm_mutex);
2513 struct drbd_resource *resource;
2535 for_each_resource(resource, &drbd_resources) {
2536 for_each_connection(connection, resource) {
2553 mutex_lock(&adm_ctx.resource->adm_mutex);
2554 connection = first_connection(adm_ctx.resource);
2590 mutex_lock(&adm_ctx.resource->conf_update);
2594 mutex_unlock(&adm_ctx.resource->conf_update);
2626 mutex_unlock(&adm_ctx.resource->conf_update);
2639 mutex_unlock(&adm_ctx.resource->adm_mutex);
2648 mutex_unlock(&adm_ctx.resource->adm_mutex);
2677 spin_lock_irq(&connection->resource->req_lock);
2679 spin_unlock_irq(&connection->resource->req_lock);
2746 mutex_lock(&adm_ctx.resource->adm_mutex);
2748 mutex_unlock(&adm_ctx.resource->adm_mutex);
2794 mutex_lock(&adm_ctx.resource->adm_mutex);
2866 mutex_lock(&device->resource->conf_update);
2871 mutex_unlock(&device->resource->conf_update);
2900 mutex_unlock(&adm_ctx.resource->adm_mutex);
2924 res_opts = adm_ctx.resource->res_opts;
2935 mutex_lock(&adm_ctx.resource->adm_mutex);
2936 err = set_resource_options(adm_ctx.resource, &res_opts);
2942 mutex_unlock(&adm_ctx.resource->adm_mutex);
2967 mutex_lock(&adm_ctx.resource->adm_mutex);
2990 mutex_unlock(&adm_ctx.resource->adm_mutex);
3009 mutex_lock(&adm_ctx.resource->adm_mutex);
3011 mutex_unlock(&adm_ctx.resource->adm_mutex);
3045 mutex_lock(&adm_ctx.resource->adm_mutex);
3071 mutex_unlock(&adm_ctx.resource->adm_mutex);
3089 mutex_lock(&adm_ctx.resource->adm_mutex);
3092 mutex_unlock(&adm_ctx.resource->adm_mutex);
3110 mutex_lock(&adm_ctx.resource->adm_mutex);
3120 mutex_unlock(&adm_ctx.resource->adm_mutex);
3143 mutex_lock(&adm_ctx.resource->adm_mutex);
3181 mutex_unlock(&adm_ctx.resource->adm_mutex);
3193 struct drbd_resource *resource,
3204 if (nla_put_string(skb, T_ctx_resource_name, resource->name))
3246 struct drbd_resource *resource;
3253 for_each_resource_rcu(resource, &drbd_resources)
3254 if (resource == (struct drbd_resource *)cb->args[0])
3256 err = 0; /* resource was probably deleted */
3259 resource = list_entry(&drbd_resources,
3263 list_for_each_entry_continue_rcu(resource, &drbd_resources, resources) {
3278 err = nla_put_drbd_cfg_context(skb, resource, NULL, NULL);
3281 err = res_opts_to_skb(skb, &resource->res_opts, !capable(CAP_SYS_ADMIN));
3284 resource_to_info(&resource_info, resource);
3288 resource_statistics.res_stat_write_ordering = resource->write_ordering;
3292 cb->args[0] = (long)resource;
3340 struct drbd_resource *resource =
3342 kref_put(&resource->kref, drbd_destroy_resource);
3357 struct drbd_resource *resource;
3365 resource = (struct drbd_resource *)cb->args[0];
3370 resource = drbd_find_resource(nla_data(resource_filter));
3371 if (!resource)
3373 cb->args[0] = (long)resource;
3379 idr_to_search = resource ? &resource->devices : &drbd_devices;
3403 err = nla_put_drbd_cfg_context(skb, device->resource, NULL, device);
3446 struct drbd_resource *resource = NULL, *next_resource;
3454 resource = (struct drbd_resource *)cb->args[0];
3459 resource = drbd_find_resource(nla_data(resource_filter));
3460 if (!resource)
3462 cb->args[0] = (long)resource;
3466 if (!resource) {
3469 resource = list_first_entry(&drbd_resources, struct drbd_resource, resources);
3470 kref_get(&resource->kref);
3471 cb->args[0] = (long)resource;
3477 mutex_lock(&resource->conf_update);
3480 for_each_connection_rcu(connection, resource)
3486 connection = list_entry(&resource->connections, struct drbd_connection, connections);
3489 list_for_each_entry_continue_rcu(connection, &resource->connections, connections) {
3499 if (next_resource == resource)
3502 /* resource was probably deleted */
3508 mutex_unlock(&resource->conf_update);
3509 kref_put(&resource->kref, drbd_destroy_resource);
3510 resource = next_resource;
3511 kref_get(&resource->kref);
3512 cb->args[0] = (long)resource;
3530 err = nla_put_drbd_cfg_context(skb, resource, connection, NULL);
3554 if (resource)
3555 mutex_unlock(&resource->conf_update);
3608 struct drbd_resource *resource;
3615 resource = (struct drbd_resource *)cb->args[0];
3620 resource = drbd_find_resource(nla_data(resource_filter));
3621 if (!resource)
3624 cb->args[0] = (long)resource;
3629 idr_to_search = resource ? &resource->devices : &drbd_devices;
3674 err = nla_put_drbd_cfg_context(skb, device->resource, peer_device->connection, device);
3698 * Return the connection of @resource if @resource has exactly one connection.
3700 static struct drbd_connection *the_only_connection(struct drbd_resource *resource)
3702 struct list_head *connections = &resource->connections;
3706 return list_first_entry(&resource->connections, struct drbd_connection, connections);
3712 struct drbd_resource *resource = device->resource;
3736 if (nla_put_drbd_cfg_context(skb, resource, the_only_connection(resource), device))
3739 if (res_opts_to_skb(skb, &device->resource->res_opts, exclude_sensitive))
3861 struct drbd_resource *resource = NULL;
3866 * for_each_resource_safe(resource, tmp, &drbd_resources) {
3867 * connection = "first connection of resource or undefined";
3868 * idr_for_each_entry(&resource->devices, device, i) {
3872 * where resource is cb->args[0];
3876 * or just dump all volumes of a single resource.
3893 resource = pos;
3897 resource = pos;
3901 if (resource) {
3903 device = idr_get_next(&resource->devices, &volume);
3905 /* No more volumes to dump on this resource.
3906 * Advance resource iterator. */
3907 pos = list_entry_rcu(resource->resources.next,
3909 /* Did we dump any volume of this resource yet? */
3912 * or only a single resource dump was requested,
3917 resource = pos;
3936 connection = the_only_connection(resource);
3937 if (nla_put_drbd_cfg_context(skb, resource, connection, NULL))
3950 D_ASSERT(device, device->resource == resource);
3968 cb->args[1] = (pos == resource) ? volume + 1 : 0;
3976 * Request status of all resources, or of all volumes within a single resource.
3990 struct drbd_resource *resource;
3995 /* ... of a single resource dump,
3996 * and the resource iterator has been advanced already? */
4003 * which resource(s) the user wants us to dump. */
4021 resource = drbd_find_resource(resource_name);
4022 if (!resource)
4025 kref_put(&resource->kref, drbd_destroy_resource); /* get_one_status() revalidates the resource */
4029 cb->args[0] = (long)resource;
4031 cb->args[2] = (long)resource;
4091 mutex_lock(&adm_ctx.resource->adm_mutex);
4104 mutex_unlock(&adm_ctx.resource->adm_mutex);
4137 mutex_lock(&adm_ctx.resource->adm_mutex);
4170 spin_lock_irq(&device->resource->req_lock);
4173 spin_unlock_irq(&device->resource->req_lock);
4182 mutex_unlock(&adm_ctx.resource->adm_mutex);
4193 drbd_msg_put_info(adm_ctx->reply_skb, "resource name missing");
4199 drbd_msg_put_info(adm_ctx->reply_skb, "invalid resource name");
4206 struct drbd_resource *resource)
4208 info->res_role = conn_highest_role(first_connection(resource));
4209 info->res_susp = resource->susp;
4210 info->res_susp_nod = resource->susp_nod;
4211 info->res_susp_fen = resource->susp_fen;
4240 if (adm_ctx.resource) {
4243 drbd_msg_put_info(adm_ctx.reply_skb, "resource exists");
4258 resource_to_info(&resource_info, connection->resource);
4259 notify_resource_state(NULL, 0, connection->resource,
4309 mutex_lock(&adm_ctx.resource->adm_mutex);
4341 mutex_unlock(&adm_ctx.resource->adm_mutex);
4357 first_connection(device->resource);
4395 mutex_lock(&adm_ctx.resource->adm_mutex);
4397 mutex_unlock(&adm_ctx.resource->adm_mutex);
4403 static int adm_del_resource(struct drbd_resource *resource)
4407 for_each_connection(connection, resource) {
4411 if (!idr_is_empty(&resource->devices))
4418 notify_resource_state(NULL, 0, resource, NULL, NOTIFY_DESTROY);
4422 list_del_rcu(&resource->resources);
4426 list_for_each_entry(connection, &resource->connections, connections)
4429 drbd_free_resource(resource);
4436 struct drbd_resource *resource;
4448 resource = adm_ctx.resource;
4449 mutex_lock(&resource->adm_mutex);
4451 for_each_connection(connection, resource) {
4470 idr_for_each_entry(&resource->devices, device, i) {
4479 idr_for_each_entry(&resource->devices, device, i) {
4488 retcode = adm_del_resource(resource);
4490 mutex_unlock(&resource->adm_mutex);
4499 struct drbd_resource *resource;
4507 resource = adm_ctx.resource;
4509 mutex_lock(&resource->adm_mutex);
4510 retcode = adm_del_resource(resource);
4511 mutex_unlock(&resource->adm_mutex);
4566 struct drbd_resource *resource,
4590 if (nla_put_drbd_cfg_context(skb, resource, NULL, NULL) ||
4595 resource_statistics.res_stat_write_ordering = resource->write_ordering;
4611 drbd_err(resource, "Error %d while broadcasting event. Event seq:%u\n",
4642 if (nla_put_drbd_cfg_context(skb, device->resource, NULL, device) ||
4692 if (nla_put_drbd_cfg_context(skb, connection->resource, connection, NULL) ||
4723 struct drbd_resource *resource = peer_device->device->resource;
4743 if (nla_put_drbd_cfg_context(skb, resource, peer_device->connection, peer_device->device) ||
4771 struct drbd_resource *resource = device ? device->resource : connection->resource;
4794 if (nla_put_drbd_cfg_context(skb, resource, connection, device) ||
4811 drbd_err(resource, "Error %d while broadcasting event. Event seq:%u\n",
4877 err = notify_resource_state_change(skb, seq, state_change->resource,
4918 struct drbd_resource *resource;
4937 for_each_resource(resource, &drbd_resources) {
4940 state_change = remember_old_state(resource, GFP_KERNEL);