/* * See cancel_delayed_work() */bool cancel_work(struct work_struct *work){	return __cancel_work(work, 0);}EXPORT_SYMBOL(cancel_work); /** * cancel_work_sync - cancel a work and wait for it to finish * @work: the work to cancel * * Cancel @work and wait for its execution to finish. This function can be used * even if the work re-queues itself or migrates to another workqueue. On return * from this function, @work is guaranteed to be not pending or executing on any * CPU as long as there aren't racing enqueues. * * cancel_work_sync(&delayed_work->work) must not be used for delayed_work's. * Use cancel_delayed_work_sync() instead. * * Must be called from a sleepable context if @work was last queued on a non-BH * workqueue. Can also be called from non-hardirq atomic contexts including BH * if @work was last queued on a BH workqueue. * * Returns %true if @work was pending, %false otherwise. */bool cancel_work_sync(struct work_struct *work){	return __cancel_work_sync(work, 0);}EXPORT_SYMBOL_GPL(cancel_work_sync); /** * cancel_delayed_work - cancel a delayed work * @dwork: delayed_work to cancel * * Kill off a pending delayed_work. * * Return: %true if @dwork was pending and canceled; %false if it wasn't * pending. * * Note: * The work callback function may still be running on return, unless * it returns %true and the work doesn't re-arm itself.  Explicitly flush or * use cancel_delayed_work_sync() to wait on it. * * This function is safe to call from any context including IRQ handler. */bool cancel_delayed_work(struct delayed_work *dwork){	return __cancel_work(&dwork->work, WORK_CANCEL_DELAYED);}EXPORT_SYMBOL(cancel_delayed_work); /** * cancel_delayed_work_sync - cancel a delayed work and wait for it to finish * @dwork: the delayed work cancel * * This is cancel_work_sync() for delayed works. * * Return: * %true if @dwork was pending, %false otherwise. */bool cancel_delayed_work_sync(struct delayed_work *dwork){	return __cancel_work_sync(&dwork->work, WORK_CANCEL_DELAYED);}EXPORT_SYMBOL(cancel_delayed_work_sync); /** * disable_work - Disable and cancel a work item * @work: work item to disable * * Disable @work by incrementing its disable count and cancel it if currently * pending. As long as the disable count is non-zero, any attempt to queue @work * will fail and return %false. The maximum supported disable depth is 2 to the * power of %WORK_OFFQ_DISABLE_BITS, currently 65536. * * Can be called from any context. Returns %true if @work was pending, %false * otherwise. */bool disable_work(struct work_struct *work){	return __cancel_work(work, WORK_CANCEL_DISABLE);}EXPORT_SYMBOL_GPL(disable_work); /** * disable_work_sync - Disable, cancel and drain a work item * @work: work item to disable * * Similar to disable_work() but also wait for @work to finish if currently * executing. * * Must be called from a sleepable context if @work was last queued on a non-BH * workqueue. Can also be called from non-hardirq atomic contexts including BH * if @work was last queued on a BH workqueue. * * Returns %true if @work was pending, %false otherwise. */bool disable_work_sync(struct work_struct *work){	return __cancel_work_sync(work, WORK_CANCEL_DISABLE);}EXPORT_SYMBOL_GPL(disable_work_sync); /** * enable_work - Enable a work item * @work: work item to enable * * Undo disable_work[_sync]() by decrementing @work's disable count. @work can * only be queued if its disable count is 0. * * Can be called from any context. Returns %true if the disable count reached 0. * Otherwise, %false. */bool enable_work(struct work_struct *work){	struct work_offq_data offqd;	unsigned long irq_flags; 	work_grab_pending(work, 0, &irq_flags); 	work_offqd_unpack(&offqd, *work_data_bits(work));	work_offqd_enable(&offqd);	set_work_pool_and_clear_pending(work, offqd.pool_id,					work_offqd_pack_flags(&offqd));	local_irq_restore(irq_flags); 	return !offqd.disable;}EXPORT_SYMBOL_GPL(enable_work); /** * disable_delayed_work - Disable and cancel a delayed work item * @dwork: delayed work item to disable * * disable_work() for delayed work items. */bool disable_delayed_work(struct delayed_work *dwork){	return __cancel_work(&dwork->work,			     WORK_CANCEL_DELAYED | WORK_CANCEL_DISABLE);}EXPORT_SYMBOL_GPL(disable_delayed_work); /** * disable_delayed_work_sync - Disable, cancel and drain a delayed work item * @dwork: delayed work item to disable * * disable_work_sync() for delayed work items. */bool disable_delayed_work_sync(struct delayed_work *dwork){	return __cancel_work_sync(&dwork->work,				  WORK_CANCEL_DELAYED | WORK_CANCEL_DISABLE);}EXPORT_SYMBOL_GPL(disable_delayed_work_sync); /** * enable_delayed_work - Enable a delayed work item * @dwork: delayed work item to enable * * enable_work() for delayed work items. */bool enable_delayed_work(struct delayed_work *dwork){	return enable_work(&dwork->work);}EXPORT_SYMBOL_GPL(enable_delayed_work); /** * schedule_on_each_cpu - execute a function synchronously on each online CPU * @func: the function to call * * schedule_on_each_cpu() executes @func on each online CPU using the * system workqueue and blocks until all CPUs have completed. * schedule_on_each_cpu() is very slow. * * Return: * 0 on success, -errno on failure. */int schedule_on_each_cpu(work_func_t func){	int cpu;	struct work_struct __percpu *works; 	works = alloc_percpu(struct work_struct);	if (!works)		return -ENOMEM; 	cpus_read_lock(); 	for_each_online_cpu(cpu) {		struct work_struct *work = per_cpu_ptr(works, cpu); 		INIT_WORK(work, func);		schedule_work_on(cpu, work);	} 	for_each_online_cpu(cpu)		flush_work(per_cpu_ptr(works, cpu)); 	cpus_read_unlock();	free_percpu(works);	return 0;} /** * execute_in_process_context - reliably execute the routine with user context * @fn:		the function to execute * @ew:		guaranteed storage for the execute work structure (must *		be available when the work executes) * * Executes the function immediately if process context is available, * otherwise schedules the function for delayed execution. * * Return:	0 - function was executed *		1 - function was scheduled for execution */int execute_in_process_context(work_func_t fn, struct execute_work *ew){	if (!in_interrupt()) {		fn(&ew->work);		return 0;	} 	INIT_WORK(&ew->work, fn);	schedule_work(&ew->work); 	return 1;}EXPORT_SYMBOL_GPL(execute_in_process_context); /** * free_workqueue_attrs - free a workqueue_attrs * @attrs: workqueue_attrs to free * * Undo alloc_workqueue_attrs(). */void free_workqueue_attrs(struct workqueue_attrs *attrs){	if (attrs) {		free_cpumask_var(attrs->cpumask);		free_cpumask_var(attrs->__pod_cpumask);		kfree(attrs);	}} /** * alloc_workqueue_attrs - allocate a workqueue_attrs * * Allocate a new workqueue_attrs, initialize with default settings and * return it. * * Return: The allocated new workqueue_attr on success. %NULL on failure. */struct workqueue_attrs *alloc_workqueue_attrs_noprof(void){	struct workqueue_attrs *attrs; 	attrs = kzalloc_obj(*attrs);	if (!attrs)		goto fail;	if (!alloc_cpumask_var(&attrs->cpumask, GFP_KERNEL))		goto fail;	if (!alloc_cpumask_var(&attrs->__pod_cpumask, GFP_KERNEL))		goto fail; 	cpumask_copy(attrs->cpumask, cpu_possible_mask);	attrs->affn_scope = WQ_AFFN_DFL;	return attrs;fail:	free_workqueue_attrs(attrs);	return NULL;} static void copy_workqueue_attrs(struct workqueue_attrs *to,				 const struct workqueue_attrs *from){	to->nice = from->nice;	cpumask_copy(to->cpumask, from->cpumask);	cpumask_copy(to->__pod_cpumask, from->__pod_cpumask);	to->affn_strict = from->affn_strict; 	/*	 * Unlike hash and equality test, copying shouldn't ignore wq-only	 * fields as copying is used for both pool and wq attrs. Instead,	 * get_unbound_pool() explicitly clears the fields.	 */	to->affn_scope = from->affn_scope;	to->ordered = from->ordered;} /* * Some attrs fields are workqueue-only. Clear them for worker_pool's. See the * comments in 'struct workqueue_attrs' definition. */static void wqattrs_clear_for_pool(struct workqueue_attrs *attrs){	attrs->affn_scope = WQ_AFFN_NR_TYPES;	attrs->ordered = false;	if (attrs->affn_strict)		cpumask_copy(attrs->cpumask, cpu_possible_mask);} /* hash value of the content of @attr */static u32 wqattrs_hash(const struct workqueue_attrs *attrs){	u32 hash = 0; 	hash = jhash_1word(attrs->nice, hash);	hash = jhash_1word(attrs->affn_strict, hash);	hash = jhash(cpumask_bits(attrs->__pod_cpumask),		     BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long), hash);	if (!attrs->affn_strict)		hash = jhash(cpumask_bits(attrs->cpumask),			     BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long), hash);	return hash;} /* content equality test */static bool wqattrs_equal(const struct workqueue_attrs *a,			  const struct workqueue_attrs *b){	if (a->nice != b->nice)		return false;	if (a->affn_strict != b->affn_strict)		return false;	if (!cpumask_equal(a->__pod_cpumask, b->__pod_cpumask))		return false;	if (!a->affn_strict && !cpumask_equal(a->cpumask, b->cpumask))		return false;	return true;} /* Update @attrs with actually available CPUs */static void wqattrs_actualize_cpumask(struct workqueue_attrs *attrs,				      const cpumask_t *unbound_cpumask){	/*	 * Calculate the effective CPU mask of @attrs given @unbound_cpumask. If	 * @attrs->cpumask doesn't overlap with @unbound_cpumask, we fallback to	 * @unbound_cpumask.	 */	cpumask_and(attrs->cpumask, attrs->cpumask, unbound_cpumask);	if (unlikely(cpumask_empty(attrs->cpumask)))		cpumask_copy(attrs->cpumask, unbound_cpumask);} /* find wq_pod_type to use for @attrs */static const struct wq_pod_type *wqattrs_pod_type(const struct workqueue_attrs *attrs){	enum wq_affn_scope scope;	struct wq_pod_type *pt; 	/* to synchronize access to wq_affn_dfl */	lockdep_assert_held(&wq_pool_mutex); 	if (attrs->affn_scope == WQ_AFFN_DFL)		scope = wq_affn_dfl;	else		scope = attrs->affn_scope; 	pt = &wq_pod_types[scope]; 	if (!WARN_ON_ONCE(attrs->affn_scope == WQ_AFFN_NR_TYPES) &&	    likely(pt->nr_pods))		return pt; 	/*	 * Before workqueue_init_topology(), only SYSTEM is available which is	 * initialized in workqueue_init_early().	 */	pt = &wq_pod_types[WQ_AFFN_SYSTEM];	BUG_ON(!pt->nr_pods);	return pt;} /** * init_worker_pool - initialize a newly zalloc'd worker_pool * @pool: worker_pool to initialize * * Initialize a newly zalloc'd @pool.  It also allocates @pool->attrs. * * Return: 0 on success, -errno on failure.  Even on failure, all fields * inside @pool proper are initialized and put_unbound_pool() can be called * on @pool safely to release it. */static int init_worker_pool(struct worker_pool *pool){	raw_spin_lock_init(&pool->lock);	pool->id = -1;	pool->cpu = -1;	pool->node = NUMA_NO_NODE;	pool->flags |= POOL_DISASSOCIATED;	pool->last_progress_ts = jiffies;	INIT_LIST_HEAD(&pool->worklist);	INIT_LIST_HEAD(&pool->idle_list);	hash_init(pool->busy_hash); 	timer_setup(&pool->idle_timer, idle_worker_timeout, TIMER_DEFERRABLE);	INIT_WORK(&pool->idle_cull_work, idle_cull_fn); 	timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0); 	INIT_LIST_HEAD(&pool->workers); 	ida_init(&pool->worker_ida);	INIT_HLIST_NODE(&pool->hash_node);	pool->refcnt = 1;#ifdef CONFIG_PREEMPT_RT	spin_lock_init(&pool->cb_lock);#endif 	/* shouldn't fail above this point */	pool->attrs = alloc_workqueue_attrs();	if (!pool->attrs)		return -ENOMEM; 	wqattrs_clear_for_pool(pool->attrs); 	return 0;} #ifdef CONFIG_LOCKDEPstatic void wq_init_lockdep(struct workqueue_struct *wq){	char *lock_name; 	lockdep_register_key(&wq->key);	lock_name = kasprintf(GFP_KERNEL, "%s%s", "(wq_completion)", wq->name);	if (!lock_name)		lock_name = wq->name; 	wq->lock_name = lock_name;	wq->lockdep_map = &wq->__lockdep_map;	lockdep_init_map(wq->lockdep_map, lock_name, &wq->key, 0);} static void wq_unregister_lockdep(struct workqueue_struct *wq){	if (wq->lockdep_map != &wq->__lockdep_map)		return; 	lockdep_unregister_key(&wq->key);} static void wq_free_lockdep(struct workqueue_struct *wq){	if (wq->lockdep_map != &wq->__lockdep_map)		return; 	if (wq->lock_name != wq->name)		kfree(wq->lock_name);}#elsestatic void wq_init_lockdep(struct workqueue_struct *wq){} static void wq_unregister_lockdep(struct workqueue_struct *wq){} static void wq_free_lockdep(struct workqueue_struct *wq){}#endif static void free_node_nr_active(struct wq_node_nr_active **nna_ar){	int node; 	for_each_node(node) {		kfree(nna_ar[node]);		nna_ar[node] = NULL;	} 	kfree(nna_ar[nr_node_ids]);	nna_ar[nr_node_ids] = NULL;} static void init_node_nr_active(struct wq_node_nr_active *nna){	nna->max = WQ_DFL_MIN_ACTIVE;	atomic_set(&nna->nr, 0);	raw_spin_lock_init(&nna->lock);	INIT_LIST_HEAD(&nna->pending_pwqs);} /* * Each node's nr_active counter will be accessed mostly from its own node and * should be allocated in the node. */static int alloc_node_nr_active(struct wq_node_nr_active **nna_ar){

Lines 4501–5000 of 8475. Previous lines Load more