Linux内核工作队列之任务执行

在前面介绍了工作队列，工作队列上面任务，以及工作队列创建的内核线程，现在讨论线程上面处理的

每一个任务，即函数worker_thread()。

[] process_one_work[] worker_thread[] kthread

之所以任务第一个跑的函数是kthread，是由于函数kthread_create_on_node()创建时，其设置的kthread函数。

/** * worker_thread - the worker thread function * @__worker: self * * The worker thread function.  All workers belong to a worker_pool - * either a per-cpu one or dynamic unbound one.  These workers process all * work items regardless of their specific target workqueue.  The only * exception is work items which belong to workqueues with a rescuer which * will be explained in rescuer_thread(). */static int worker_thread(void *__worker){ struct worker *worker = __worker; struct worker_pool *pool = worker->pool;
 /* tell the scheduler that this is a workqueue worker */ worker->task->flags |= PF_WQ_WORKER;woke_up: spin_lock_irq(&pool->lock);
 /* am I supposed to die? */ if (unlikely(worker->flags & WORKER_DIE)) {  spin_unlock_irq(&pool->lock);  WARN_ON_ONCE(!list_empty(&worker->entry));  worker->task->flags &= ~PF_WQ_WORKER;  return 0; }
 worker_leave_idle(worker);recheck: /* no more worker necessary? */ if (!need_more_worker(pool))  goto sleep;
 /* do we need to manage? */ if (unlikely(!may_start_working(pool)) && manage_workers(worker))  goto recheck;
 /*  * ->scheduled list can only be filled while a worker is  * preparing to process a work or actually processing it.  * Make sure nobody diddled with it while I was sleeping.  */ WARN_ON_ONCE(!list_empty(&worker->scheduled));
 /*  * Finish PREP stage.  We're guaranteed to have at least one idle  * worker or that someone else has already assumed the manager  * role.  This is where @worker starts participating in concurrency  * management if applicable and concurrency management is restored  * after being rebound.  See rebind_workers() for details.  */ worker_clr_flags(worker, WORKER_PREP | WORKER_REBOUND);
 do {  struct work_struct *work =   list_first_entry(&pool->worklist,      struct work_struct, entry);
  if (likely(!(*work_data_bits(work) & WORK_STRUCT_LINKED))) {   /* optimization path, not strictly necessary */   process_one_work(worker, work);   if (unlikely(!list_empty(&worker->scheduled)))    process_scheduled_works(worker);  } else {   move_linked_works(work, &worker->scheduled, NULL);   process_scheduled_works(worker);  } } while (keep_working(pool));
 worker_set_flags(worker, WORKER_PREP, false);sleep: if (unlikely(need_to_manage_workers(pool)) && manage_workers(worker))  goto recheck;
 /*  * pool->lock is held and there's no work to process and no need to  * manage, sleep.  Workers are woken up only while holding  * pool->lock or from local cpu, so setting the current state  * before releasing pool->lock is enough to prevent losing any  * event.  */ worker_enter_idle(worker); __set_current_state(TASK_INTERRUPTIBLE); spin_unlock_irq(&pool->lock); schedule(); goto woke_up;}
 
/** * process_one_work - process single work * @worker: self * @work: work to process * * Process @work.  This function contains all the logics necessary to * process a single work including synchronization against and * interaction with other workers on the same cpu, queueing and * flushing.  As long as context requirement is met, any worker can * call this function to process a work. * * CONTEXT: * spin_lock_irq(pool->lock) which is released and regrabbed. */static void process_one_work(struct worker *worker, struct work_struct *work)__releases(&pool->lock)__acquires(&pool->lock){ struct pool_workqueue *pwq = get_work_pwq(work); struct worker_pool *pool = worker->pool; bool cpu_intensive = pwq->wq->flags & WQ_CPU_INTENSIVE; int work_color; struct worker *collision;#ifdef CONFIG_LOCKDEP /*  * It is permissible to free the struct work_struct from  * inside the function that is called from it, this we need to  * take into account for lockdep too.  To avoid bogus "held  * lock freed" warnings as well as problems when looking into  * work->lockdep_map, make a copy and use that here.  */ struct lockdep_map lockdep_map;
 lockdep_copy_map(&lockdep_map, &work->lockdep_map);#endif /*  * Ensure we're on the correct CPU.  DISASSOCIATED test is  * necessary to avoid spurious warnings from rescuers servicing the  * unbound or a disassociated pool.  */ WARN_ON_ONCE(!(worker->flags & WORKER_UNBOUND) &&       !(pool->flags & POOL_DISASSOCIATED) &&       raw_smp_processor_id() != pool->cpu);
 /*  * A single work shouldn't be executed concurrently by  * multiple workers on a single cpu.  Check whether anyone is  * already processing the work.  If so, defer the work to the  * currently executing one.  */ collision = find_worker_executing_work(pool, work); if (unlikely(collision)) {  move_linked_works(work, &collision->scheduled, NULL);  return; }
 /* claim and dequeue */ debug_work_deactivate(work); hash_add(pool->busy_hash, &worker->hentry, (unsigned long)work); worker->current_work = work; worker->current_func = work->func; worker->current_pwq = pwq; work_color = get_work_color(work);
 list_del_init(&work->entry);
 /*  * CPU intensive works don't participate in concurrency  * management.  They're the scheduler's responsibility.  */ if (unlikely(cpu_intensive))  worker_set_flags(worker, WORKER_CPU_INTENSIVE, true);
 /*  * Unbound pool isn't concurrency managed and work items should be  * executed ASAP.  Wake up another worker if necessary.  */ if ((worker->flags & WORKER_UNBOUND) && need_more_worker(pool))  wake_up_worker(pool);
 /*  * Record the last pool and clear PENDING which should be the last  * update to @work.  Also, do this inside @pool->lock so that  * PENDING and queued state changes happen together while IRQ is  * disabled.  */ set_work_pool_and_clear_pending(work, pool->id);
 spin_unlock_irq(&pool->lock);
 lock_map_acquire_read(&pwq->wq->lockdep_map); lock_map_acquire(&lockdep_map); trace_workqueue_execute_start(work); worker->current_func(work); /*  * While we must be careful to not use "work" after this, the trace  * point will only record its address.  */ trace_workqueue_execute_end(work); lock_map_release(&lockdep_map); lock_map_release(&pwq->wq->lockdep_map);
 if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {  pr_err("BUG: workqueue leaked lock or atomic: %s/0x%08x/%d\n"         "     last function: %pf\n",         current->comm, preempt_count(), task_pid_nr(current),         worker->current_func);  debug_show_held_locks(current);  dump_stack(); }
 /*  * The following prevents a kworker from hogging CPU on !PREEMPT  * kernels, where a requeueing work item waiting for something to  * happen could deadlock with stop_machine as such work item could  * indefinitely requeue itself while all other CPUs are trapped in  * stop_machine.  */ cond_resched();
 spin_lock_irq(&pool->lock);
 /* clear cpu intensive status */ if (unlikely(cpu_intensive))  worker_clr_flags(worker, WORKER_CPU_INTENSIVE);
 /* we're done with it, release */ hash_del(&worker->hentry); worker->current_work = NULL; worker->current_func = NULL; worker->current_pwq = NULL; worker->desc_valid = false; pwq_dec_nr_in_flight(pwq, work_color);}