cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

completion.h (4101B)

      1/* SPDX-License-Identifier: GPL-2.0 */
      2#ifndef __LINUX_COMPLETION_H
      3#define __LINUX_COMPLETION_H
      4
      5/*
      6 * (C) Copyright 2001 Linus Torvalds
      7 *
      8 * Atomic wait-for-completion handler data structures.
      9 * See kernel/sched/completion.c for details.
     10 */
     11
     12#include <linux/swait.h>
     13
     14/*
     15 * struct completion - structure used to maintain state for a "completion"
     16 *
     17 * This is the opaque structure used to maintain the state for a "completion".
     18 * Completions currently use a FIFO to queue threads that have to wait for
     19 * the "completion" event.
     20 *
     21 * See also:  complete(), wait_for_completion() (and friends _timeout,
     22 * _interruptible, _interruptible_timeout, and _killable), init_completion(),
     23 * reinit_completion(), and macros DECLARE_COMPLETION(),
     24 * DECLARE_COMPLETION_ONSTACK().
     25 */
     26struct completion {
     27	unsigned int done;
     28	struct swait_queue_head wait;
     29};
     30
     31#define init_completion_map(x, m) init_completion(x)
     32static inline void complete_acquire(struct completion *x) {}
     33static inline void complete_release(struct completion *x) {}
     34
     35#define COMPLETION_INITIALIZER(work) \
     36	{ 0, __SWAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
     37
     38#define COMPLETION_INITIALIZER_ONSTACK_MAP(work, map) \
     39	(*({ init_completion_map(&(work), &(map)); &(work); }))
     40
     41#define COMPLETION_INITIALIZER_ONSTACK(work) \
     42	(*({ init_completion(&work); &work; }))
     43
     44/**
     45 * DECLARE_COMPLETION - declare and initialize a completion structure
     46 * @work:  identifier for the completion structure
     47 *
     48 * This macro declares and initializes a completion structure. Generally used
     49 * for static declarations. You should use the _ONSTACK variant for automatic
     50 * variables.
     51 */
     52#define DECLARE_COMPLETION(work) \
     53	struct completion work = COMPLETION_INITIALIZER(work)
     54
     55/*
     56 * Lockdep needs to run a non-constant initializer for on-stack
     57 * completions - so we use the _ONSTACK() variant for those that
     58 * are on the kernel stack:
     59 */
     60/**
     61 * DECLARE_COMPLETION_ONSTACK - declare and initialize a completion structure
     62 * @work:  identifier for the completion structure
     63 *
     64 * This macro declares and initializes a completion structure on the kernel
     65 * stack.
     66 */
     67#ifdef CONFIG_LOCKDEP
     68# define DECLARE_COMPLETION_ONSTACK(work) \
     69	struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)
     70# define DECLARE_COMPLETION_ONSTACK_MAP(work, map) \
     71	struct completion work = COMPLETION_INITIALIZER_ONSTACK_MAP(work, map)
     72#else
     73# define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)
     74# define DECLARE_COMPLETION_ONSTACK_MAP(work, map) DECLARE_COMPLETION(work)
     75#endif
     76
     77/**
     78 * init_completion - Initialize a dynamically allocated completion
     79 * @x:  pointer to completion structure that is to be initialized
     80 *
     81 * This inline function will initialize a dynamically created completion
     82 * structure.
     83 */
     84static inline void init_completion(struct completion *x)
     85{
     86	x->done = 0;
     87	init_swait_queue_head(&x->wait);
     88}
     89
     90/**
     91 * reinit_completion - reinitialize a completion structure
     92 * @x:  pointer to completion structure that is to be reinitialized
     93 *
     94 * This inline function should be used to reinitialize a completion structure so it can
     95 * be reused. This is especially important after complete_all() is used.
     96 */
     97static inline void reinit_completion(struct completion *x)
     98{
     99	x->done = 0;
    100}
    101
    102extern void wait_for_completion(struct completion *);
    103extern void wait_for_completion_io(struct completion *);
    104extern int wait_for_completion_interruptible(struct completion *x);
    105extern int wait_for_completion_killable(struct completion *x);
    106extern unsigned long wait_for_completion_timeout(struct completion *x,
    107						   unsigned long timeout);
    108extern unsigned long wait_for_completion_io_timeout(struct completion *x,
    109						    unsigned long timeout);
    110extern long wait_for_completion_interruptible_timeout(
    111	struct completion *x, unsigned long timeout);
    112extern long wait_for_completion_killable_timeout(
    113	struct completion *x, unsigned long timeout);
    114extern bool try_wait_for_completion(struct completion *x);
    115extern bool completion_done(struct completion *x);
    116
    117extern void complete(struct completion *);
    118extern void complete_all(struct completion *);
    119
    120#endif