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);
790 mutex_lock(&adm_ctx.resource->adm_mutex);
799 mutex_unlock(&adm_ctx.resource->adm_mutex);
1430 spin_lock_irq(&connection->resource->req_lock);
1433 spin_unlock_irq(&connection->resource->req_lock);
1453 spin_lock_irq(&device->resource->req_lock);
1456 spin_unlock_irq(&device->resource->req_lock);
1582 mutex_lock(&adm_ctx.resource->adm_mutex);
1597 mutex_lock(&device->resource->conf_update);
1654 mutex_unlock(&device->resource->conf_update);
1667 drbd_bump_write_ordering(device->resource, NULL, WO_BDEV_FLUSH);
1689 mutex_unlock(&device->resource->conf_update);
1696 mutex_unlock(&adm_ctx.resource->adm_mutex);
1810 mutex_lock(&adm_ctx.resource->adm_mutex);
1959 * As barriers are counted per resource,
1960 * we'd need to suspend io on all devices of a resource.
2043 drbd_bump_write_ordering(device->resource, device->ldev, WO_BDEV_FLUSH);
2052 !(device->state.role == R_PRIMARY && device->resource->susp_nod))
2110 spin_lock_irq(&device->resource->req_lock);
2162 spin_unlock_irq(&device->resource->req_lock);
2180 mutex_unlock(&adm_ctx.resource->adm_mutex);
2199 mutex_unlock(&adm_ctx.resource->adm_mutex);
2243 mutex_lock(&adm_ctx.resource->adm_mutex);
2245 mutex_unlock(&adm_ctx.resource->adm_mutex);
2437 mutex_lock(&adm_ctx.resource->adm_mutex);
2448 mutex_lock(&connection->resource->conf_update);
2512 mutex_unlock(&connection->resource->conf_update);
2528 mutex_unlock(&connection->resource->conf_update);
2535 mutex_unlock(&adm_ctx.resource->adm_mutex);
2570 struct drbd_resource *resource;
2591 for_each_resource(resource, &drbd_resources) {
2592 for_each_connection(connection, resource) {
2609 mutex_lock(&adm_ctx.resource->adm_mutex);
2610 connection = first_connection(adm_ctx.resource);
2646 mutex_lock(&adm_ctx.resource->conf_update);
2650 mutex_unlock(&adm_ctx.resource->conf_update);
2682 mutex_unlock(&adm_ctx.resource->conf_update);
2696 mutex_unlock(&adm_ctx.resource->adm_mutex);
2705 mutex_unlock(&adm_ctx.resource->adm_mutex);
2734 spin_lock_irq(&connection->resource->req_lock);
2736 spin_unlock_irq(&connection->resource->req_lock);
2803 mutex_lock(&adm_ctx.resource->adm_mutex);
2809 mutex_unlock(&adm_ctx.resource->adm_mutex);
2850 mutex_lock(&adm_ctx.resource->adm_mutex);
2922 mutex_lock(&device->resource->conf_update);
2927 mutex_unlock(&device->resource->conf_update);
2957 mutex_unlock(&adm_ctx.resource->adm_mutex);
2981 res_opts = adm_ctx.resource->res_opts;
2992 mutex_lock(&adm_ctx.resource->adm_mutex);
2993 err = set_resource_options(adm_ctx.resource, &res_opts);
2999 mutex_unlock(&adm_ctx.resource->adm_mutex);
3024 mutex_lock(&adm_ctx.resource->adm_mutex);
3047 mutex_unlock(&adm_ctx.resource->adm_mutex);
3066 mutex_lock(&adm_ctx.resource->adm_mutex);
3068 mutex_unlock(&adm_ctx.resource->adm_mutex);
3101 mutex_lock(&adm_ctx.resource->adm_mutex);
3127 mutex_unlock(&adm_ctx.resource->adm_mutex);
3145 mutex_lock(&adm_ctx.resource->adm_mutex);
3148 mutex_unlock(&adm_ctx.resource->adm_mutex);
3166 mutex_lock(&adm_ctx.resource->adm_mutex);
3176 mutex_unlock(&adm_ctx.resource->adm_mutex);
3199 mutex_lock(&adm_ctx.resource->adm_mutex);
3237 mutex_unlock(&adm_ctx.resource->adm_mutex);
3249 struct drbd_resource *resource,
3260 if (nla_put_string(skb, T_ctx_resource_name, resource->name))
3302 struct drbd_resource *resource;
3309 for_each_resource_rcu(resource, &drbd_resources)
3310 if (resource == (struct drbd_resource *)cb->args[0])
3312 err = 0; /* resource was probably deleted */
3315 resource = list_entry(&drbd_resources,
3319 list_for_each_entry_continue_rcu(resource, &drbd_resources, resources) {
3334 err = nla_put_drbd_cfg_context(skb, resource, NULL, NULL);
3337 err = res_opts_to_skb(skb, &resource->res_opts, !capable(CAP_SYS_ADMIN));
3340 resource_to_info(&resource_info, resource);
3344 resource_statistics.res_stat_write_ordering = resource->write_ordering;
3348 cb->args[0] = (long)resource;
3396 struct drbd_resource *resource =
3398 kref_put(&resource->kref, drbd_destroy_resource);
3413 struct drbd_resource *resource;
3421 resource = (struct drbd_resource *)cb->args[0];
3426 resource = drbd_find_resource(nla_data(resource_filter));
3427 if (!resource)
3429 cb->args[0] = (long)resource;
3435 idr_to_search = resource ? &resource->devices : &drbd_devices;
3459 err = nla_put_drbd_cfg_context(skb, device->resource, NULL, device);
3502 struct drbd_resource *resource = NULL, *next_resource;
3510 resource = (struct drbd_resource *)cb->args[0];
3515 resource = drbd_find_resource(nla_data(resource_filter));
3516 if (!resource)
3518 cb->args[0] = (long)resource;
3522 if (!resource) {
3525 resource = list_first_entry(&drbd_resources, struct drbd_resource, resources);
3526 kref_get(&resource->kref);
3527 cb->args[0] = (long)resource;
3533 mutex_lock(&resource->conf_update);
3536 for_each_connection_rcu(connection, resource)
3542 connection = list_entry(&resource->connections, struct drbd_connection, connections);
3545 list_for_each_entry_continue_rcu(connection, &resource->connections, connections) {
3555 if (next_resource == resource)
3558 /* resource was probably deleted */
3564 mutex_unlock(&resource->conf_update);
3565 kref_put(&resource->kref, drbd_destroy_resource);
3566 resource = next_resource;
3567 kref_get(&resource->kref);
3568 cb->args[0] = (long)resource;
3586 err = nla_put_drbd_cfg_context(skb, resource, connection, NULL);
3610 if (resource)
3611 mutex_unlock(&resource->conf_update);
3664 struct drbd_resource *resource;
3671 resource = (struct drbd_resource *)cb->args[0];
3676 resource = drbd_find_resource(nla_data(resource_filter));
3677 if (!resource)
3680 cb->args[0] = (long)resource;
3685 idr_to_search = resource ? &resource->devices : &drbd_devices;
3730 err = nla_put_drbd_cfg_context(skb, device->resource, peer_device->connection, device);
3754 * Return the connection of @resource if @resource has exactly one connection.
3756 static struct drbd_connection *the_only_connection(struct drbd_resource *resource)
3758 struct list_head *connections = &resource->connections;
3762 return list_first_entry(&resource->connections, struct drbd_connection, connections);
3768 struct drbd_resource *resource = device->resource;
3792 if (nla_put_drbd_cfg_context(skb, resource, the_only_connection(resource), device))
3795 if (res_opts_to_skb(skb, &device->resource->res_opts, exclude_sensitive))
3917 struct drbd_resource *resource = NULL;
3922 * for_each_resource_safe(resource, tmp, &drbd_resources) {
3923 * connection = "first connection of resource or undefined";
3924 * idr_for_each_entry(&resource->devices, device, i) {
3928 * where resource is cb->args[0];
3932 * or just dump all volumes of a single resource.
3949 resource = pos;
3953 resource = pos;
3957 if (resource) {
3959 device = idr_get_next(&resource->devices, &volume);
3961 /* No more volumes to dump on this resource.
3962 * Advance resource iterator. */
3963 pos = list_entry_rcu(resource->resources.next,
3965 /* Did we dump any volume of this resource yet? */
3968 * or only a single resource dump was requested,
3973 resource = pos;
3992 connection = the_only_connection(resource);
3993 if (nla_put_drbd_cfg_context(skb, resource, connection, NULL))
4006 D_ASSERT(device, device->resource == resource);
4024 cb->args[1] = (pos == resource) ? volume + 1 : 0;
4032 * Request status of all resources, or of all volumes within a single resource.
4046 struct drbd_resource *resource;
4051 /* ... of a single resource dump,
4052 * and the resource iterator has been advanced already? */
4059 * which resource(s) the user wants us to dump. */
4077 resource = drbd_find_resource(resource_name);
4078 if (!resource)
4081 kref_put(&resource->kref, drbd_destroy_resource); /* get_one_status() revalidates the resource */
4085 cb->args[0] = (long)resource;
4087 cb->args[2] = (long)resource;
4147 mutex_lock(&adm_ctx.resource->adm_mutex);
4160 mutex_unlock(&adm_ctx.resource->adm_mutex);
4193 mutex_lock(&adm_ctx.resource->adm_mutex);
4226 spin_lock_irq(&device->resource->req_lock);
4229 spin_unlock_irq(&device->resource->req_lock);
4238 mutex_unlock(&adm_ctx.resource->adm_mutex);
4249 drbd_msg_put_info(adm_ctx->reply_skb, "resource name missing");
4255 drbd_msg_put_info(adm_ctx->reply_skb, "invalid resource name");
4262 struct drbd_resource *resource)
4264 info->res_role = conn_highest_role(first_connection(resource));
4265 info->res_susp = resource->susp;
4266 info->res_susp_nod = resource->susp_nod;
4267 info->res_susp_fen = resource->susp_fen;
4296 if (adm_ctx.resource) {
4299 drbd_msg_put_info(adm_ctx.reply_skb, "resource exists");
4314 resource_to_info(&resource_info, connection->resource);
4315 notify_resource_state(NULL, 0, connection->resource,
4365 mutex_lock(&adm_ctx.resource->adm_mutex);
4397 mutex_unlock(&adm_ctx.resource->adm_mutex);
4413 first_connection(device->resource);
4451 mutex_lock(&adm_ctx.resource->adm_mutex);
4453 mutex_unlock(&adm_ctx.resource->adm_mutex);
4459 static int adm_del_resource(struct drbd_resource *resource)
4463 for_each_connection(connection, resource) {
4467 if (!idr_is_empty(&resource->devices))
4474 notify_resource_state(NULL, 0, resource, NULL, NOTIFY_DESTROY);
4478 list_del_rcu(&resource->resources);
4482 list_for_each_entry(connection, &resource->connections, connections)
4485 drbd_free_resource(resource);
4492 struct drbd_resource *resource;
4504 resource = adm_ctx.resource;
4505 mutex_lock(&resource->adm_mutex);
4507 for_each_connection(connection, resource) {
4526 idr_for_each_entry(&resource->devices, device, i) {
4535 idr_for_each_entry(&resource->devices, device, i) {
4544 retcode = adm_del_resource(resource);
4546 mutex_unlock(&resource->adm_mutex);
4555 struct drbd_resource *resource;
4563 resource = adm_ctx.resource;
4565 mutex_lock(&resource->adm_mutex);
4566 retcode = adm_del_resource(resource);
4567 mutex_unlock(&resource->adm_mutex);
4622 struct drbd_resource *resource,
4646 if (nla_put_drbd_cfg_context(skb, resource, NULL, NULL) ||
4651 resource_statistics.res_stat_write_ordering = resource->write_ordering;
4667 drbd_err(resource, "Error %d while broadcasting event. Event seq:%u\n",
4698 if (nla_put_drbd_cfg_context(skb, device->resource, NULL, device) ||
4748 if (nla_put_drbd_cfg_context(skb, connection->resource, connection, NULL) ||
4779 struct drbd_resource *resource = peer_device->device->resource;
4799 if (nla_put_drbd_cfg_context(skb, resource, peer_device->connection, peer_device->device) ||
4827 struct drbd_resource *resource = device ? device->resource : connection->resource;
4850 if (nla_put_drbd_cfg_context(skb, resource, connection, device) ||
4867 drbd_err(resource, "Error %d while broadcasting event. Event seq:%u\n",
4933 err = notify_resource_state_change(skb, seq, state_change->resource,
4974 struct drbd_resource *resource;
4993 for_each_resource(resource, &drbd_resources) {
4996 state_change = remember_old_state(resource, GFP_KERNEL);