5816 lines · 159.4 KB · C
RawDownload
	}} static int wq_clamp_max_active(int max_active, unsigned int flags,			       const char *name){	int lim = flags & WQ_UNBOUND ? WQ_UNBOUND_MAX_ACTIVE : WQ_MAX_ACTIVE; 	if (max_active < 1 || max_active > lim)		pr_warn("workqueue: max_active %d requested for %s is out of range, clamping between %d and %d\n",			max_active, name, 1, lim); 	return clamp_val(max_active, 1, lim);} /* * Workqueues which may be used during memory reclaim should have a rescuer * to guarantee forward progress. */static int init_rescuer(struct workqueue_struct *wq){	struct worker *rescuer;	int ret; 	if (!(wq->flags & WQ_MEM_RECLAIM))		return 0; 	rescuer = alloc_worker(NUMA_NO_NODE);	if (!rescuer)		return -ENOMEM; 	rescuer->rescue_wq = wq;	rescuer->task = kthread_create(rescuer_thread, rescuer, "%s", wq->name);	ret = PTR_ERR_OR_ZERO(rescuer->task);	if (ret) {		kfree(rescuer);		return ret;	} 	wq->rescuer = rescuer;	kthread_bind_mask(rescuer->task, cpu_possible_mask);	wake_up_process(rescuer->task); 	return 0;} struct workqueue_struct *__alloc_workqueue_key(const char *fmt,					       unsigned int flags,					       int max_active,					       struct lock_class_key *key,					       const char *lock_name, ...){	size_t tbl_size = 0;	va_list args;	struct workqueue_struct *wq;	struct pool_workqueue *pwq; 	/*	 * Unbound && max_active == 1 used to imply ordered, which is no	 * longer the case on NUMA machines due to per-node pools.  While	 * alloc_ordered_workqueue() is the right way to create an ordered	 * workqueue, keep the previous behavior to avoid subtle breakages	 * on NUMA.	 */	if ((flags & WQ_UNBOUND) && max_active == 1)		flags |= __WQ_ORDERED; 	/* see the comment above the definition of WQ_POWER_EFFICIENT */	if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient)		flags |= WQ_UNBOUND; 	/* allocate wq and format name */	if (flags & WQ_UNBOUND)		tbl_size = nr_node_ids * sizeof(wq->numa_pwq_tbl[0]); 	wq = kzalloc(sizeof(*wq) + tbl_size, GFP_KERNEL);	if (!wq)		return NULL; 	if (flags & WQ_UNBOUND) {		wq->unbound_attrs = alloc_workqueue_attrs(GFP_KERNEL);		if (!wq->unbound_attrs)			goto err_free_wq;	} 	va_start(args, lock_name);	vsnprintf(wq->name, sizeof(wq->name), fmt, args);	va_end(args); 	max_active = max_active ?: WQ_DFL_ACTIVE;	max_active = wq_clamp_max_active(max_active, flags, wq->name); 	/* init wq */	wq->flags = flags;	wq->saved_max_active = max_active;	mutex_init(&wq->mutex);	atomic_set(&wq->nr_pwqs_to_flush, 0);	INIT_LIST_HEAD(&wq->pwqs);	INIT_LIST_HEAD(&wq->flusher_queue);	INIT_LIST_HEAD(&wq->flusher_overflow);	INIT_LIST_HEAD(&wq->maydays); 	lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);	INIT_LIST_HEAD(&wq->list); 	if (alloc_and_link_pwqs(wq) < 0)		goto err_free_wq; 	if (wq_online && init_rescuer(wq) < 0)		goto err_destroy; 	if ((wq->flags & WQ_SYSFS) && workqueue_sysfs_register(wq))		goto err_destroy; 	/*	 * wq_pool_mutex protects global freeze state and workqueues list.	 * Grab it, adjust max_active and add the new @wq to workqueues	 * list.	 */	mutex_lock(&wq_pool_mutex); 	mutex_lock(&wq->mutex);	for_each_pwq(pwq, wq)		pwq_adjust_max_active(pwq);	mutex_unlock(&wq->mutex); 	list_add_tail_rcu(&wq->list, &workqueues); 	mutex_unlock(&wq_pool_mutex); 	return wq; err_free_wq:	free_workqueue_attrs(wq->unbound_attrs);	kfree(wq);	return NULL;err_destroy:	destroy_workqueue(wq);	return NULL;}EXPORT_SYMBOL_GPL(__alloc_workqueue_key); /** * destroy_workqueue - safely terminate a workqueue * @wq: target workqueue * * Safely destroy a workqueue. All work currently pending will be done first. */void destroy_workqueue(struct workqueue_struct *wq){	struct pool_workqueue *pwq;	int node; 	/* drain it before proceeding with destruction */	drain_workqueue(wq); 	/* sanity checks */	mutex_lock(&wq->mutex);	for_each_pwq(pwq, wq) {		int i; 		for (i = 0; i < WORK_NR_COLORS; i++) {			if (WARN_ON(pwq->nr_in_flight[i])) {				mutex_unlock(&wq->mutex);				show_workqueue_state();				return;			}		} 		if (WARN_ON((pwq != wq->dfl_pwq) && (pwq->refcnt > 1)) ||		    WARN_ON(pwq->nr_active) ||		    WARN_ON(!list_empty(&pwq->delayed_works))) {			mutex_unlock(&wq->mutex);			show_workqueue_state();			return;		}	}	mutex_unlock(&wq->mutex); 	/*	 * wq list is used to freeze wq, remove from list after	 * flushing is complete in case freeze races us.	 */	mutex_lock(&wq_pool_mutex);	list_del_rcu(&wq->list);	mutex_unlock(&wq_pool_mutex); 	workqueue_sysfs_unregister(wq); 	if (wq->rescuer)		kthread_stop(wq->rescuer->task); 	if (!(wq->flags & WQ_UNBOUND)) {		/*		 * The base ref is never dropped on per-cpu pwqs.  Directly		 * schedule RCU free.		 */		call_rcu_sched(&wq->rcu, rcu_free_wq);	} else {		/*		 * We're the sole accessor of @wq at this point.  Directly		 * access numa_pwq_tbl[] and dfl_pwq to put the base refs.		 * @wq will be freed when the last pwq is released.		 */		for_each_node(node) {			pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]);			RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL);			put_pwq_unlocked(pwq);		} 		/*		 * Put dfl_pwq.  @wq may be freed any time after dfl_pwq is		 * put.  Don't access it afterwards.		 */		pwq = wq->dfl_pwq;		wq->dfl_pwq = NULL;		put_pwq_unlocked(pwq);	}}EXPORT_SYMBOL_GPL(destroy_workqueue); /** * workqueue_set_max_active - adjust max_active of a workqueue * @wq: target workqueue * @max_active: new max_active value. * * Set max_active of @wq to @max_active. * * CONTEXT: * Don't call from IRQ context. */void workqueue_set_max_active(struct workqueue_struct *wq, int max_active){	struct pool_workqueue *pwq; 	/* disallow meddling with max_active for ordered workqueues */	if (WARN_ON(wq->flags & __WQ_ORDERED_EXPLICIT))		return; 	max_active = wq_clamp_max_active(max_active, wq->flags, wq->name); 	mutex_lock(&wq->mutex); 	wq->flags &= ~__WQ_ORDERED;	wq->saved_max_active = max_active; 	for_each_pwq(pwq, wq)		pwq_adjust_max_active(pwq); 	mutex_unlock(&wq->mutex);}EXPORT_SYMBOL_GPL(workqueue_set_max_active); /** * current_work - retrieve %current task's work struct * * Determine if %current task is a workqueue worker and what it's working on. * Useful to find out the context that the %current task is running in. * * Return: work struct if %current task is a workqueue worker, %NULL otherwise. */struct work_struct *current_work(void){	struct worker *worker = current_wq_worker(); 	return worker ? worker->current_work : NULL;}EXPORT_SYMBOL(current_work); /** * current_is_workqueue_rescuer - is %current workqueue rescuer? * * Determine whether %current is a workqueue rescuer.  Can be used from * work functions to determine whether it's being run off the rescuer task. * * Return: %true if %current is a workqueue rescuer. %false otherwise. */bool current_is_workqueue_rescuer(void){	struct worker *worker = current_wq_worker(); 	return worker && worker->rescue_wq;} /** * workqueue_congested - test whether a workqueue is congested * @cpu: CPU in question * @wq: target workqueue * * Test whether @wq's cpu workqueue for @cpu is congested.  There is * no synchronization around this function and the test result is * unreliable and only useful as advisory hints or for debugging. * * If @cpu is WORK_CPU_UNBOUND, the test is performed on the local CPU. * Note that both per-cpu and unbound workqueues may be associated with * multiple pool_workqueues which have separate congested states.  A * workqueue being congested on one CPU doesn't mean the workqueue is also * contested on other CPUs / NUMA nodes. * * Return: * %true if congested, %false otherwise. */bool workqueue_congested(int cpu, struct workqueue_struct *wq){	struct pool_workqueue *pwq;	bool ret; 	rcu_read_lock_sched(); 	if (cpu == WORK_CPU_UNBOUND)		cpu = smp_processor_id(); 	if (!(wq->flags & WQ_UNBOUND))		pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);	else		pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu)); 	ret = !list_empty(&pwq->delayed_works);	rcu_read_unlock_sched(); 	return ret;}EXPORT_SYMBOL_GPL(workqueue_congested); /** * work_busy - test whether a work is currently pending or running * @work: the work to be tested * * Test whether @work is currently pending or running.  There is no * synchronization around this function and the test result is * unreliable and only useful as advisory hints or for debugging. * * Return: * OR'd bitmask of WORK_BUSY_* bits. */unsigned int work_busy(struct work_struct *work){	struct worker_pool *pool;	unsigned long flags;	unsigned int ret = 0; 	if (work_pending(work))		ret |= WORK_BUSY_PENDING; 	local_irq_save(flags);	pool = get_work_pool(work);	if (pool) {		spin_lock(&pool->lock);		if (find_worker_executing_work(pool, work))			ret |= WORK_BUSY_RUNNING;		spin_unlock(&pool->lock);	}	local_irq_restore(flags); 	return ret;}EXPORT_SYMBOL_GPL(work_busy); /** * set_worker_desc - set description for the current work item * @fmt: printf-style format string * @...: arguments for the format string * * This function can be called by a running work function to describe what * the work item is about.  If the worker task gets dumped, this * information will be printed out together to help debugging.  The * description can be at most WORKER_DESC_LEN including the trailing '\0'. */void set_worker_desc(const char *fmt, ...){	struct worker *worker = current_wq_worker();	va_list args; 	if (worker) {		va_start(args, fmt);		vsnprintf(worker->desc, sizeof(worker->desc), fmt, args);		va_end(args);	}}EXPORT_SYMBOL_GPL(set_worker_desc); /** * print_worker_info - print out worker information and description * @log_lvl: the log level to use when printing * @task: target task * * If @task is a worker and currently executing a work item, print out the * name of the workqueue being serviced and worker description set with * set_worker_desc() by the currently executing work item. * * This function can be safely called on any task as long as the * task_struct itself is accessible.  While safe, this function isn't * synchronized and may print out mixups or garbages of limited length. */void print_worker_info(const char *log_lvl, struct task_struct *task){	work_func_t *fn = NULL;	char name[WQ_NAME_LEN] = { };	char desc[WORKER_DESC_LEN] = { };	struct pool_workqueue *pwq = NULL;	struct workqueue_struct *wq = NULL;	struct worker *worker; 	if (!(task->flags & PF_WQ_WORKER))		return; 	/*	 * This function is called without any synchronization and @task	 * could be in any state.  Be careful with dereferences.	 */	worker = kthread_probe_data(task); 	/*	 * Carefully copy the associated workqueue's workfn, name and desc.	 * Keep the original last '\0' in case the original is garbage.	 */	probe_kernel_read(&fn, &worker->current_func, sizeof(fn));	probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));	probe_kernel_read(&wq, &pwq->wq, sizeof(wq));	probe_kernel_read(name, wq->name, sizeof(name) - 1);	probe_kernel_read(desc, worker->desc, sizeof(desc) - 1); 	if (fn || name[0] || desc[0]) {		printk("%sWorkqueue: %s %pf", log_lvl, name, fn);		if (strcmp(name, desc))			pr_cont(" (%s)", desc);		pr_cont("\n");	}} static void pr_cont_pool_info(struct worker_pool *pool){	pr_cont(" cpus=%*pbl", nr_cpumask_bits, pool->attrs->cpumask);	if (pool->node != NUMA_NO_NODE)		pr_cont(" node=%d", pool->node);	pr_cont(" flags=0x%x nice=%d", pool->flags, pool->attrs->nice);} static void pr_cont_work(bool comma, struct work_struct *work){	if (work->func == wq_barrier_func) {		struct wq_barrier *barr; 		barr = container_of(work, struct wq_barrier, work); 		pr_cont("%s BAR(%d)", comma ? "," : "",			task_pid_nr(barr->task));	} else {		pr_cont("%s %pf", comma ? "," : "", work->func);	}} static void show_pwq(struct pool_workqueue *pwq){	struct worker_pool *pool = pwq->pool;	struct work_struct *work;	struct worker *worker;	bool has_in_flight = false, has_pending = false;	int bkt; 	pr_info("  pwq %d:", pool->id);	pr_cont_pool_info(pool); 	pr_cont(" active=%d/%d%s\n", pwq->nr_active, pwq->max_active,		!list_empty(&pwq->mayday_node) ? " MAYDAY" : ""); 	hash_for_each(pool->busy_hash, bkt, worker, hentry) {		if (worker->current_pwq == pwq) {			has_in_flight = true;			break;		}	}	if (has_in_flight) {		bool comma = false; 		pr_info("    in-flight:");		hash_for_each(pool->busy_hash, bkt, worker, hentry) {			if (worker->current_pwq != pwq)				continue; 			pr_cont("%s %d%s:%pf", comma ? "," : "",				task_pid_nr(worker->task),				worker == pwq->wq->rescuer ? "(RESCUER)" : "",				worker->current_func);			list_for_each_entry(work, &worker->scheduled, entry)				pr_cont_work(false, work);			comma = true;		}		pr_cont("\n");	} 	list_for_each_entry(work, &pool->worklist, entry) {		if (get_work_pwq(work) == pwq) {			has_pending = true;			break;		}	}	if (has_pending) {		bool comma = false; 

Lines 4001–4500 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