1 // SPDX-License-Identifier: GPL-2.0-only
21  * Protects list of resource pools maintained on per cgroup basis
22  * and rdma device list.
49  * resource pool object which represents per cgroup, per device
50  * resources. There are multiple instances of this object per cgroup,
55 	struct rdmacg_device	*device;  member
74 	return css_rdmacg(cg->css.parent);  in parent_rdmacg()
86 		if (rpool->resources[index].max != S32_MAX)  in set_resource_limit()
87 			rpool->num_max_cnt++;  in set_resource_limit()
89 		if (rpool->resources[index].max == S32_MAX)  in set_resource_limit()
90 			rpool->num_max_cnt--;  in set_resource_limit()
92 	rpool->resources[index].max = new_max;  in set_resource_limit()
107 	list_del(&rpool->cg_node);  in free_cg_rpool_locked()
108 	list_del(&rpool->dev_node);  in free_cg_rpool_locked()
114 		     struct rdmacg_device *device)  in find_cg_rpool_locked()  argument
121 	list_for_each_entry(pool, &cg->rpools, cg_node)  in find_cg_rpool_locked()
122 		if (pool->device == device)  in find_cg_rpool_locked()
129 get_cg_rpool_locked(struct rdma_cgroup *cg, struct rdmacg_device *device)  in get_cg_rpool_locked()  argument
133 	rpool = find_cg_rpool_locked(cg, device);  in get_cg_rpool_locked()
139 		return ERR_PTR(-ENOMEM);  in get_cg_rpool_locked()
141 	rpool->device = device;  in get_cg_rpool_locked()
144 	INIT_LIST_HEAD(&rpool->cg_node);  in get_cg_rpool_locked()
145 	INIT_LIST_HEAD(&rpool->dev_node);  in get_cg_rpool_locked()
146 	list_add_tail(&rpool->cg_node, &cg->rpools);  in get_cg_rpool_locked()
147 	list_add_tail(&rpool->dev_node, &device->rpools);  in get_cg_rpool_locked()
152  * uncharge_cg_locked - uncharge resource for rdma cgroup
154  * @device: pointer to rdmacg device
163 		   struct rdmacg_device *device,  in uncharge_cg_locked()  argument
168 	rpool = find_cg_rpool_locked(cg, device);  in uncharge_cg_locked()
176 		pr_warn("Invalid device %p or rdma cgroup %p\n", cg, device);  in uncharge_cg_locked()
180 	rpool->resources[index].usage--;  in uncharge_cg_locked()
186 	WARN_ON_ONCE(rpool->resources[index].usage < 0);  in uncharge_cg_locked()
187 	rpool->usage_sum--;  in uncharge_cg_locked()
188 	if (rpool->usage_sum == 0 &&  in uncharge_cg_locked()
189 	    rpool->num_max_cnt == RDMACG_RESOURCE_MAX) {  in uncharge_cg_locked()
199  * rdmacg_uncharge_hierarchy - hierarchically uncharge rdma resource count
200  * @device: pointer to rdmacg device
206 				     struct rdmacg_device *device,  in rdmacg_uncharge_hierarchy()  argument
215 		uncharge_cg_locked(p, device, index);  in rdmacg_uncharge_hierarchy()
219 	css_put(&cg->css);  in rdmacg_uncharge_hierarchy()
223  * rdmacg_uncharge - hierarchically uncharge rdma resource count
224  * @device: pointer to rdmacg device
228 		     struct rdmacg_device *device,  in rdmacg_uncharge()  argument
234 	rdmacg_uncharge_hierarchy(cg, device, NULL, index);  in rdmacg_uncharge()
239  * rdmacg_try_charge - hierarchically try to charge the rdma resource
241  * @device: pointer to rdmacg device
247  * Returns 0 if the charge succeded, otherwise -EAGAIN, -ENOMEM or -EINVAL.
251  * (a) per cgroup & (b) per device resource usage.
252  * Per cgroup resource usage ensures that tasks of cgroup doesn't cross
253  * the configured limits. Per device provides granular configuration
254  * in multi device usage. It allocates resource pool in the hierarchy
260 		      struct rdmacg_device *device,  in rdmacg_try_charge()  argument
269 		return -EINVAL;  in rdmacg_try_charge()
279 		rpool = get_cg_rpool_locked(p, device);  in rdmacg_try_charge()
284 			new = rpool->resources[index].usage + 1;  in rdmacg_try_charge()
285 			if (new > rpool->resources[index].max) {  in rdmacg_try_charge()
286 				ret = -EAGAIN;  in rdmacg_try_charge()
289 				rpool->resources[index].usage = new;  in rdmacg_try_charge()
290 				rpool->usage_sum++;  in rdmacg_try_charge()
301 	rdmacg_uncharge_hierarchy(cg, device, p, index);  in rdmacg_try_charge()
307  * rdmacg_register_device - register rdmacg device to rdma controller.
308  * @device: pointer to rdmacg device whose resources need to be accounted.
310  * If IB stack wish a device to participate in rdma cgroup resource
314 void rdmacg_register_device(struct rdmacg_device *device)  in rdmacg_register_device()  argument
316 	INIT_LIST_HEAD(&device->dev_node);  in rdmacg_register_device()
317 	INIT_LIST_HEAD(&device->rpools);  in rdmacg_register_device()
320 	list_add_tail(&device->dev_node, &rdmacg_devices);  in rdmacg_register_device()
326  * rdmacg_unregister_device - unregister rdmacg device from rdma controller.
327  * @device: pointer to rdmacg device which was previously registered with rdma
330  * IB stack must invoke this after all the resources of the IB device
334 void rdmacg_unregister_device(struct rdmacg_device *device)  in rdmacg_unregister_device()  argument
343 	list_del_init(&device->dev_node);  in rdmacg_unregister_device()
346 	 * Now that this device is off the cgroup list, its safe to free  in rdmacg_unregister_device()
349 	list_for_each_entry_safe(rpool, tmp, &device->rpools, dev_node)  in rdmacg_unregister_device()
365 		return -EINVAL;  in parse_resource()
379 			return -EINVAL;  in parse_resource()
386 	return -EINVAL;  in parse_resource()
393 	int err = -EINVAL;  in rdmacg_parse_limits()
414 	struct rdmacg_device *device;  in rdmacg_get_device_locked()  local
418 	list_for_each_entry(device, &rdmacg_devices, dev_node)  in rdmacg_get_device_locked()
419 		if (!strcmp(name, device->name))  in rdmacg_get_device_locked()
420 			return device;  in rdmacg_get_device_locked()
431 	struct rdmacg_device *device;  in rdmacg_resource_set_max()  local
437 	/* extract the device name first */  in rdmacg_resource_set_max()
440 		ret = -EINVAL;  in rdmacg_resource_set_max()
446 		ret = -ENOMEM;  in rdmacg_resource_set_max()
457 	device = rdmacg_get_device_locked(dev_name);  in rdmacg_resource_set_max()
458 	if (!device) {  in rdmacg_resource_set_max()
459 		ret = -ENODEV;  in rdmacg_resource_set_max()
463 	rpool = get_cg_rpool_locked(cg, device);  in rdmacg_resource_set_max()
473 	if (rpool->usage_sum == 0 &&  in rdmacg_resource_set_max()
474 	    rpool->num_max_cnt == RDMACG_RESOURCE_MAX) {  in rdmacg_resource_set_max()
499 	sf_type = seq_cft(sf)->private;  in print_rpool_values()
506 				value = rpool->resources[i].max;  in print_rpool_values()
511 				value = rpool->resources[i].usage;  in print_rpool_values()
526 	struct rdmacg_device *device;  in rdmacg_resource_read()  local
532 	list_for_each_entry(device, &rdmacg_devices, dev_node) {  in rdmacg_resource_read()
533 		seq_printf(sf, "%s ", device->name);  in rdmacg_resource_read()
535 		rpool = find_cg_rpool_locked(cg, device);  in rdmacg_resource_read()
569 		return ERR_PTR(-ENOMEM);  in rdmacg_css_alloc()
571 	INIT_LIST_HEAD(&cg->rpools);  in rdmacg_css_alloc()
572 	return &cg->css;  in rdmacg_css_alloc()
583  * rdmacg_css_offline - cgroup css_offline callback
598 	list_for_each_entry(rpool, &cg->rpools, cg_node)  in rdmacg_css_offline()