sched: add kernel doc for the completion, fix kernel-doc-nano-HOWTO.txt (65eb3dc6) · Commits · e / devices / android_kernel_xiaomi_markw

Documentation/kernel-doc-nano-HOWTO.txt

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -168,10 +168,10 @@ if ($#ARGV < 0) {
	mkdir $ARGV[0],0777;		mkdir $ARGV[0],0777;
	$state = 0;		$state = 0;
	while (<STDIN>) {		while (<STDIN>) {
	if (/^\.TH \"[^\"]\" 4 \"([^\"])\"/) {		if (/^\.TH \"[^\"]\" 9 \"([^\"])\"/) {
	if ($state == 1) { close OUT }		if ($state == 1) { close OUT }
	$state = 1;		$state = 1;
	$fn = "$ARGV[0]/$1.4";		$fn = "$ARGV[0]/$1.9";
	print STDERR "Creating $fn\n";		print STDERR "Creating $fn\n";
	open OUT, ">$fn" or die "can't open $fn: $!\n";		open OUT, ">$fn" or die "can't open $fn: $!\n";
	print OUT $_;		print OUT $_;

include/linux/completion.h

+41 −0

Original line number	Original line	Diff line number	Diff line
	@@ -10,6 +10,18 @@

	#include <linux/wait.h>		#include <linux/wait.h>

			/**
			* struct completion - structure used to maintain state for a "completion"
			*
			* This is the opaque structure used to maintain the state for a "completion".
			* Completions currently use a FIFO to queue threads that have to wait for
			* the "completion" event.
			*
			* See also: complete(), wait_for_completion() (and friends _timeout,
			* _interruptible, _interruptible_timeout, and _killable), init_completion(),
			* and macros DECLARE_COMPLETION(), DECLARE_COMPLETION_ONSTACK(), and
			* INIT_COMPLETION().
			*/
	struct completion {		struct completion {
	unsigned int done;		unsigned int done;
	wait_queue_head_t wait;		wait_queue_head_t wait;
	@@ -21,6 +33,14 @@ struct completion {
	#define COMPLETION_INITIALIZER_ONSTACK(work) \		#define COMPLETION_INITIALIZER_ONSTACK(work) \
	({ init_completion(&work); work; })		({ init_completion(&work); work; })

			/**
			* DECLARE_COMPLETION: - declare and initialize a completion structure
			* @work: identifier for the completion structure
			*
			* This macro declares and initializes a completion structure. Generally used
			* for static declarations. You should use the _ONSTACK variant for automatic
			* variables.
			*/
	#define DECLARE_COMPLETION(work) \		#define DECLARE_COMPLETION(work) \
	struct completion work = COMPLETION_INITIALIZER(work)		struct completion work = COMPLETION_INITIALIZER(work)

	@@ -29,6 +49,13 @@ struct completion {
	* completions - so we use the _ONSTACK() variant for those that		* completions - so we use the _ONSTACK() variant for those that
	* are on the kernel stack:		* are on the kernel stack:
	*/		*/
			/**
			* DECLARE_COMPLETION_ONSTACK: - declare and initialize a completion structure
			* @work: identifier for the completion structure
			*
			* This macro declares and initializes a completion structure on the kernel
			* stack.
			*/
	#ifdef CONFIG_LOCKDEP		#ifdef CONFIG_LOCKDEP
	# define DECLARE_COMPLETION_ONSTACK(work) \		# define DECLARE_COMPLETION_ONSTACK(work) \
	struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)		struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)
	@@ -36,6 +63,13 @@ struct completion {
	# define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)		# define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)
	#endif		#endif

			/**
			* init_completion: - Initialize a dynamically allocated completion
			* @x: completion structure that is to be initialized
			*
			* This inline function will initialize a dynamically created completion
			* structure.
			*/
	static inline void init_completion(struct completion *x)		static inline void init_completion(struct completion *x)
	{		{
	x->done = 0;		x->done = 0;
	@@ -55,6 +89,13 @@ extern bool completion_done(struct completion *x);
	extern void complete(struct completion *);		extern void complete(struct completion *);
	extern void complete_all(struct completion *);		extern void complete_all(struct completion *);

			/**
			* INIT_COMPLETION: - reinitialize a completion structure
			* @x: completion structure to be reinitialized
			*
			* This macro should be used to reinitialize a completion structure so it can
			* be reused. This is especially important after complete_all() is used.
			*/
	#define INIT_COMPLETION(x) ((x).done = 0)		#define INIT_COMPLETION(x) ((x).done = 0)

kernel/sched.c

+56 −0

Original line number	Original line	Diff line number	Diff line
	@@ -4565,6 +4565,15 @@ __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
	}		}
	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */		EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */

			/**
			* complete: - signals a single thread waiting on this completion
			* @x: holds the state of this particular completion
			*
			* This will wake up a single thread waiting on this completion. Threads will be
			* awakened in the same order in which they were queued.
			*
			* See also complete_all(), wait_for_completion() and related routines.
			*/
	void complete(struct completion *x)		void complete(struct completion *x)
	{		{
	unsigned long flags;		unsigned long flags;
	@@ -4576,6 +4585,12 @@ void complete(struct completion *x)
	}		}
	EXPORT_SYMBOL(complete);		EXPORT_SYMBOL(complete);

			/**
			* complete_all: - signals all threads waiting on this completion
			* @x: holds the state of this particular completion
			*
			* This will wake up all threads waiting on this particular completion event.
			*/
	void complete_all(struct completion *x)		void complete_all(struct completion *x)
	{		{
	unsigned long flags;		unsigned long flags;
	@@ -4624,12 +4639,31 @@ wait_for_common(struct completion *x, long timeout, int state)
	return timeout;		return timeout;
	}		}

			/**
			* wait_for_completion: - waits for completion of a task
			* @x: holds the state of this particular completion
			*
			* This waits to be signaled for completion of a specific task. It is NOT
			* interruptible and there is no timeout.
			*
			* See also similar routines (i.e. wait_for_completion_timeout()) with timeout
			* and interrupt capability. Also see complete().
			*/
	void __sched wait_for_completion(struct completion *x)		void __sched wait_for_completion(struct completion *x)
	{		{
	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);		wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
	}		}
	EXPORT_SYMBOL(wait_for_completion);		EXPORT_SYMBOL(wait_for_completion);

			/**
			* wait_for_completion_timeout: - waits for completion of a task (w/timeout)
			* @x: holds the state of this particular completion
			* @timeout: timeout value in jiffies
			*
			* This waits for either a completion of a specific task to be signaled or for a
			* specified timeout to expire. The timeout is in jiffies. It is not
			* interruptible.
			*/
	unsigned long __sched		unsigned long __sched
	wait_for_completion_timeout(struct completion *x, unsigned long timeout)		wait_for_completion_timeout(struct completion *x, unsigned long timeout)
	{		{
	@@ -4637,6 +4671,13 @@ wait_for_completion_timeout(struct completion *x, unsigned long timeout)
	}		}
	EXPORT_SYMBOL(wait_for_completion_timeout);		EXPORT_SYMBOL(wait_for_completion_timeout);

			/**
			* wait_for_completion_interruptible: - waits for completion of a task (w/intr)
			* @x: holds the state of this particular completion
			*
			* This waits for completion of a specific task to be signaled. It is
			* interruptible.
			*/
	int __sched wait_for_completion_interruptible(struct completion *x)		int __sched wait_for_completion_interruptible(struct completion *x)
	{		{
	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);		long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
	@@ -4646,6 +4687,14 @@ int __sched wait_for_completion_interruptible(struct completion *x)
	}		}
	EXPORT_SYMBOL(wait_for_completion_interruptible);		EXPORT_SYMBOL(wait_for_completion_interruptible);

			/**
			* wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
			* @x: holds the state of this particular completion
			* @timeout: timeout value in jiffies
			*
			* This waits for either a completion of a specific task to be signaled or for a
			* specified timeout to expire. It is interruptible. The timeout is in jiffies.
			*/
	unsigned long __sched		unsigned long __sched
	wait_for_completion_interruptible_timeout(struct completion *x,		wait_for_completion_interruptible_timeout(struct completion *x,
	unsigned long timeout)		unsigned long timeout)
	@@ -4654,6 +4703,13 @@ wait_for_completion_interruptible_timeout(struct completion *x,
	}		}
	EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);		EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);

			/**
			* wait_for_completion_killable: - waits for completion of a task (killable)
			* @x: holds the state of this particular completion
			*
			* This waits to be signaled for completion of a specific task. It can be
			* interrupted by a kill signal.
			*/
	int __sched wait_for_completion_killable(struct completion *x)		int __sched wait_for_completion_killable(struct completion *x)
	{		{
	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);		long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);