5816 lines · 159.4 KB · C
RawDownload
	mutex_unlock(&wq_pool_mutex);	return busy;} /** * thaw_workqueues - thaw workqueues * * Thaw workqueues.  Normal queueing is restored and all collected * frozen works are transferred to their respective pool worklists. * * CONTEXT: * Grabs and releases wq_pool_mutex, wq->mutex and pool->lock's. */void thaw_workqueues(void){	struct workqueue_struct *wq;	struct pool_workqueue *pwq; 	mutex_lock(&wq_pool_mutex); 	if (!workqueue_freezing)		goto out_unlock; 	workqueue_freezing = false; 	/* restore max_active and repopulate worklist */	list_for_each_entry(wq, &workqueues, list) {		mutex_lock(&wq->mutex);		for_each_pwq(pwq, wq)			pwq_adjust_max_active(pwq);		mutex_unlock(&wq->mutex);	} out_unlock:	mutex_unlock(&wq_pool_mutex);}#endif /* CONFIG_FREEZER */ static int workqueue_apply_unbound_cpumask(void){	LIST_HEAD(ctxs);	int ret = 0;	struct workqueue_struct *wq;	struct apply_wqattrs_ctx *ctx, *n; 	lockdep_assert_held(&wq_pool_mutex); 	list_for_each_entry(wq, &workqueues, list) {		if (!(wq->flags & WQ_UNBOUND))			continue;		/* creating multiple pwqs breaks ordering guarantee */		if (wq->flags & __WQ_ORDERED)			continue; 		ctx = apply_wqattrs_prepare(wq, wq->unbound_attrs);		if (!ctx) {			ret = -ENOMEM;			break;		} 		list_add_tail(&ctx->list, &ctxs);	} 	list_for_each_entry_safe(ctx, n, &ctxs, list) {		if (!ret)			apply_wqattrs_commit(ctx);		apply_wqattrs_cleanup(ctx);	} 	return ret;} /** *  workqueue_set_unbound_cpumask - Set the low-level unbound cpumask *  @cpumask: the cpumask to set * *  The low-level workqueues cpumask is a global cpumask that limits *  the affinity of all unbound workqueues.  This function check the @cpumask *  and apply it to all unbound workqueues and updates all pwqs of them. * *  Retun:	0	- Success *  		-EINVAL	- Invalid @cpumask *  		-ENOMEM	- Failed to allocate memory for attrs or pwqs. */int workqueue_set_unbound_cpumask(cpumask_var_t cpumask){	int ret = -EINVAL;	cpumask_var_t saved_cpumask; 	if (!zalloc_cpumask_var(&saved_cpumask, GFP_KERNEL))		return -ENOMEM; 	/*	 * Not excluding isolated cpus on purpose.	 * If the user wishes to include them, we allow that.	 */	cpumask_and(cpumask, cpumask, cpu_possible_mask);	if (!cpumask_empty(cpumask)) {		apply_wqattrs_lock(); 		/* save the old wq_unbound_cpumask. */		cpumask_copy(saved_cpumask, wq_unbound_cpumask); 		/* update wq_unbound_cpumask at first and apply it to wqs. */		cpumask_copy(wq_unbound_cpumask, cpumask);		ret = workqueue_apply_unbound_cpumask(); 		/* restore the wq_unbound_cpumask when failed. */		if (ret < 0)			cpumask_copy(wq_unbound_cpumask, saved_cpumask); 		apply_wqattrs_unlock();	} 	free_cpumask_var(saved_cpumask);	return ret;} #ifdef CONFIG_SYSFS/* * Workqueues with WQ_SYSFS flag set is visible to userland via * /sys/bus/workqueue/devices/WQ_NAME.  All visible workqueues have the * following attributes. * *  per_cpu	RO bool	: whether the workqueue is per-cpu or unbound *  max_active	RW int	: maximum number of in-flight work items * * Unbound workqueues have the following extra attributes. * *  pool_ids	RO int	: the associated pool IDs for each node *  nice	RW int	: nice value of the workers *  cpumask	RW mask	: bitmask of allowed CPUs for the workers *  numa	RW bool	: whether enable NUMA affinity */struct wq_device {	struct workqueue_struct		*wq;	struct device			dev;}; static struct workqueue_struct *dev_to_wq(struct device *dev){	struct wq_device *wq_dev = container_of(dev, struct wq_device, dev); 	return wq_dev->wq;} static ssize_t per_cpu_show(struct device *dev, struct device_attribute *attr,			    char *buf){	struct workqueue_struct *wq = dev_to_wq(dev); 	return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)!(wq->flags & WQ_UNBOUND));}static DEVICE_ATTR_RO(per_cpu); static ssize_t max_active_show(struct device *dev,			       struct device_attribute *attr, char *buf){	struct workqueue_struct *wq = dev_to_wq(dev); 	return scnprintf(buf, PAGE_SIZE, "%d\n", wq->saved_max_active);} static ssize_t max_active_store(struct device *dev,				struct device_attribute *attr, const char *buf,				size_t count){	struct workqueue_struct *wq = dev_to_wq(dev);	int val; 	if (sscanf(buf, "%d", &val) != 1 || val <= 0)		return -EINVAL; 	workqueue_set_max_active(wq, val);	return count;}static DEVICE_ATTR_RW(max_active); static struct attribute *wq_sysfs_attrs[] = {	&dev_attr_per_cpu.attr,	&dev_attr_max_active.attr,	NULL,};ATTRIBUTE_GROUPS(wq_sysfs); static ssize_t wq_pool_ids_show(struct device *dev,				struct device_attribute *attr, char *buf){	struct workqueue_struct *wq = dev_to_wq(dev);	const char *delim = "";	int node, written = 0; 	rcu_read_lock_sched();	for_each_node(node) {		written += scnprintf(buf + written, PAGE_SIZE - written,				     "%s%d:%d", delim, node,				     unbound_pwq_by_node(wq, node)->pool->id);		delim = " ";	}	written += scnprintf(buf + written, PAGE_SIZE - written, "\n");	rcu_read_unlock_sched(); 	return written;} static ssize_t wq_nice_show(struct device *dev, struct device_attribute *attr,			    char *buf){	struct workqueue_struct *wq = dev_to_wq(dev);	int written; 	mutex_lock(&wq->mutex);	written = scnprintf(buf, PAGE_SIZE, "%d\n", wq->unbound_attrs->nice);	mutex_unlock(&wq->mutex); 	return written;} /* prepare workqueue_attrs for sysfs store operations */static struct workqueue_attrs *wq_sysfs_prep_attrs(struct workqueue_struct *wq){	struct workqueue_attrs *attrs; 	lockdep_assert_held(&wq_pool_mutex); 	attrs = alloc_workqueue_attrs(GFP_KERNEL);	if (!attrs)		return NULL; 	copy_workqueue_attrs(attrs, wq->unbound_attrs);	return attrs;} static ssize_t wq_nice_store(struct device *dev, struct device_attribute *attr,			     const char *buf, size_t count){	struct workqueue_struct *wq = dev_to_wq(dev);	struct workqueue_attrs *attrs;	int ret = -ENOMEM; 	apply_wqattrs_lock(); 	attrs = wq_sysfs_prep_attrs(wq);	if (!attrs)		goto out_unlock; 	if (sscanf(buf, "%d", &attrs->nice) == 1 &&	    attrs->nice >= MIN_NICE && attrs->nice <= MAX_NICE)		ret = apply_workqueue_attrs_locked(wq, attrs);	else		ret = -EINVAL; out_unlock:	apply_wqattrs_unlock();	free_workqueue_attrs(attrs);	return ret ?: count;} static ssize_t wq_cpumask_show(struct device *dev,			       struct device_attribute *attr, char *buf){	struct workqueue_struct *wq = dev_to_wq(dev);	int written; 	mutex_lock(&wq->mutex);	written = scnprintf(buf, PAGE_SIZE, "%*pb\n",			    cpumask_pr_args(wq->unbound_attrs->cpumask));	mutex_unlock(&wq->mutex);	return written;} static ssize_t wq_cpumask_store(struct device *dev,				struct device_attribute *attr,				const char *buf, size_t count){	struct workqueue_struct *wq = dev_to_wq(dev);	struct workqueue_attrs *attrs;	int ret = -ENOMEM; 	apply_wqattrs_lock(); 	attrs = wq_sysfs_prep_attrs(wq);	if (!attrs)		goto out_unlock; 	ret = cpumask_parse(buf, attrs->cpumask);	if (!ret)		ret = apply_workqueue_attrs_locked(wq, attrs); out_unlock:	apply_wqattrs_unlock();	free_workqueue_attrs(attrs);	return ret ?: count;} static ssize_t wq_numa_show(struct device *dev, struct device_attribute *attr,			    char *buf){	struct workqueue_struct *wq = dev_to_wq(dev);	int written; 	mutex_lock(&wq->mutex);	written = scnprintf(buf, PAGE_SIZE, "%d\n",			    !wq->unbound_attrs->no_numa);	mutex_unlock(&wq->mutex); 	return written;} static ssize_t wq_numa_store(struct device *dev, struct device_attribute *attr,			     const char *buf, size_t count){	struct workqueue_struct *wq = dev_to_wq(dev);	struct workqueue_attrs *attrs;	int v, ret = -ENOMEM; 	apply_wqattrs_lock(); 	attrs = wq_sysfs_prep_attrs(wq);	if (!attrs)		goto out_unlock; 	ret = -EINVAL;	if (sscanf(buf, "%d", &v) == 1) {		attrs->no_numa = !v;		ret = apply_workqueue_attrs_locked(wq, attrs);	} out_unlock:	apply_wqattrs_unlock();	free_workqueue_attrs(attrs);	return ret ?: count;} static struct device_attribute wq_sysfs_unbound_attrs[] = {	__ATTR(pool_ids, 0444, wq_pool_ids_show, NULL),	__ATTR(nice, 0644, wq_nice_show, wq_nice_store),	__ATTR(cpumask, 0644, wq_cpumask_show, wq_cpumask_store),	__ATTR(numa, 0644, wq_numa_show, wq_numa_store),	__ATTR_NULL,}; static struct bus_type wq_subsys = {	.name				= "workqueue",	.dev_groups			= wq_sysfs_groups,}; static ssize_t wq_unbound_cpumask_show(struct device *dev,		struct device_attribute *attr, char *buf){	int written; 	mutex_lock(&wq_pool_mutex);	written = scnprintf(buf, PAGE_SIZE, "%*pb\n",			    cpumask_pr_args(wq_unbound_cpumask));	mutex_unlock(&wq_pool_mutex); 	return written;} static ssize_t wq_unbound_cpumask_store(struct device *dev,		struct device_attribute *attr, const char *buf, size_t count){	cpumask_var_t cpumask;	int ret; 	if (!zalloc_cpumask_var(&cpumask, GFP_KERNEL))		return -ENOMEM; 	ret = cpumask_parse(buf, cpumask);	if (!ret)		ret = workqueue_set_unbound_cpumask(cpumask); 	free_cpumask_var(cpumask);	return ret ? ret : count;} static struct device_attribute wq_sysfs_cpumask_attr =	__ATTR(cpumask, 0644, wq_unbound_cpumask_show,	       wq_unbound_cpumask_store); static int __init wq_sysfs_init(void){	int err; 	err = subsys_virtual_register(&wq_subsys, NULL);	if (err)		return err; 	return device_create_file(wq_subsys.dev_root, &wq_sysfs_cpumask_attr);}core_initcall(wq_sysfs_init); static void wq_device_release(struct device *dev){	struct wq_device *wq_dev = container_of(dev, struct wq_device, dev); 	kfree(wq_dev);} /** * workqueue_sysfs_register - make a workqueue visible in sysfs * @wq: the workqueue to register * * Expose @wq in sysfs under /sys/bus/workqueue/devices. * alloc_workqueue*() automatically calls this function if WQ_SYSFS is set * which is the preferred method. * * Workqueue user should use this function directly iff it wants to apply * workqueue_attrs before making the workqueue visible in sysfs; otherwise, * apply_workqueue_attrs() may race against userland updating the * attributes. * * Return: 0 on success, -errno on failure. */int workqueue_sysfs_register(struct workqueue_struct *wq){	struct wq_device *wq_dev;	int ret; 	/*	 * Adjusting max_active or creating new pwqs by applying	 * attributes breaks ordering guarantee.  Disallow exposing ordered	 * workqueues.	 */	if (WARN_ON(wq->flags & __WQ_ORDERED_EXPLICIT))		return -EINVAL; 	wq->wq_dev = wq_dev = kzalloc(sizeof(*wq_dev), GFP_KERNEL);	if (!wq_dev)		return -ENOMEM; 	wq_dev->wq = wq;	wq_dev->dev.bus = &wq_subsys;	wq_dev->dev.release = wq_device_release;	dev_set_name(&wq_dev->dev, "%s", wq->name); 	/*	 * unbound_attrs are created separately.  Suppress uevent until	 * everything is ready.	 */	dev_set_uevent_suppress(&wq_dev->dev, true); 	ret = device_register(&wq_dev->dev);	if (ret) {		put_device(&wq_dev->dev);		wq->wq_dev = NULL;		return ret;	} 	if (wq->flags & WQ_UNBOUND) {		struct device_attribute *attr; 		for (attr = wq_sysfs_unbound_attrs; attr->attr.name; attr++) {			ret = device_create_file(&wq_dev->dev, attr);			if (ret) {				device_unregister(&wq_dev->dev);				wq->wq_dev = NULL;				return ret;			}		}	} 	dev_set_uevent_suppress(&wq_dev->dev, false);	kobject_uevent(&wq_dev->dev.kobj, KOBJ_ADD);	return 0;} /** * workqueue_sysfs_unregister - undo workqueue_sysfs_register() * @wq: the workqueue to unregister * * If @wq is registered to sysfs by workqueue_sysfs_register(), unregister. */static void workqueue_sysfs_unregister(struct workqueue_struct *wq){	struct wq_device *wq_dev = wq->wq_dev; 	if (!wq->wq_dev)		return; 	wq->wq_dev = NULL;	device_unregister(&wq_dev->dev);}#else	/* CONFIG_SYSFS */static void workqueue_sysfs_unregister(struct workqueue_struct *wq)	{ }#endif	/* CONFIG_SYSFS */ /* * Workqueue watchdog. * * Stall may be caused by various bugs - missing WQ_MEM_RECLAIM, illegal * flush dependency, a concurrency managed work item which stays RUNNING * indefinitely.  Workqueue stalls can be very difficult to debug as the * usual warning mechanisms don't trigger and internal workqueue state is * largely opaque. * * Workqueue watchdog monitors all worker pools periodically and dumps * state if some pools failed to make forward progress for a while where * forward progress is defined as the first item on ->worklist changing.

Lines 5001–5500 of 5816. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t