include/uapi/linux/futex.h

   1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
   2 #ifndef _UAPI_LINUX_FUTEX_H
   3 #define _UAPI_LINUX_FUTEX_H
   4
   5 #include <linux/compiler.h>
   6 #include <linux/types.h>
   7
   8 /* Second argument to futex syscall */
   9
  10
  11 #define FUTEX_WAIT              0
  12 #define FUTEX_WAKE              1
  13 #define FUTEX_FD                2
  14 #define FUTEX_REQUEUE           3
  15 #define FUTEX_CMP_REQUEUE       4
  16 #define FUTEX_WAKE_OP           5
  17 #define FUTEX_LOCK_PI           6
  18 #define FUTEX_UNLOCK_PI         7
  19 #define FUTEX_TRYLOCK_PI        8
  20 #define FUTEX_WAIT_BITSET       9
  21 #define FUTEX_WAKE_BITSET       10
  22 #define FUTEX_WAIT_REQUEUE_PI   11
  23 #define FUTEX_CMP_REQUEUE_PI    12
  24 #define FUTEX_LOCK_PI2          13
  25
  26 #define FUTEX_PRIVATE_FLAG      128
  27 #define FUTEX_CLOCK_REALTIME    256
  28 #define FUTEX_CMD_MASK          ~(FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME)
  29
  30 #define FUTEX_WAIT_PRIVATE      (FUTEX_WAIT | FUTEX_PRIVATE_FLAG)
  31 #define FUTEX_WAKE_PRIVATE      (FUTEX_WAKE | FUTEX_PRIVATE_FLAG)
  32 #define FUTEX_REQUEUE_PRIVATE   (FUTEX_REQUEUE | FUTEX_PRIVATE_FLAG)
  33 #define FUTEX_CMP_REQUEUE_PRIVATE (FUTEX_CMP_REQUEUE | FUTEX_PRIVATE_FLAG)
  34 #define FUTEX_WAKE_OP_PRIVATE   (FUTEX_WAKE_OP | FUTEX_PRIVATE_FLAG)
  35 #define FUTEX_LOCK_PI_PRIVATE   (FUTEX_LOCK_PI | FUTEX_PRIVATE_FLAG)
  36 #define FUTEX_LOCK_PI2_PRIVATE  (FUTEX_LOCK_PI2 | FUTEX_PRIVATE_FLAG)
  37 #define FUTEX_UNLOCK_PI_PRIVATE (FUTEX_UNLOCK_PI | FUTEX_PRIVATE_FLAG)
  38 #define FUTEX_TRYLOCK_PI_PRIVATE (FUTEX_TRYLOCK_PI | FUTEX_PRIVATE_FLAG)
  39 #define FUTEX_WAIT_BITSET_PRIVATE       (FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG)
  40 #define FUTEX_WAKE_BITSET_PRIVATE       (FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG)
  41 #define FUTEX_WAIT_REQUEUE_PI_PRIVATE   (FUTEX_WAIT_REQUEUE_PI | \
  42                                          FUTEX_PRIVATE_FLAG)
  43 #define FUTEX_CMP_REQUEUE_PI_PRIVATE    (FUTEX_CMP_REQUEUE_PI | \
  44                                          FUTEX_PRIVATE_FLAG)
  45
  46 /*
  47  * Flags to specify the bit length of the futex word for futex2 syscalls.
  48  * Currently, only 32 is supported.
  49  */
  50 #define FUTEX_32                2
  51
  52 /*
  53  * Max numbers of elements in a futex_waitv array
  54  */
  55 #define FUTEX_WAITV_MAX         128
  56
  57 /**
  58  * struct futex_waitv - A waiter for vectorized wait
  59  * @val:        Expected value at uaddr
  60  * @uaddr:      User address to wait on
  61  * @flags:      Flags for this waiter
  62  * @__reserved: Reserved member to preserve data alignment. Should be 0.
  63  */
  64 struct futex_waitv {
  65         __u64 val;
  66         __u64 uaddr;
  67         __u32 flags;
  68         __u32 __reserved;
  69 };
  70
  71 /*
  72  * Support for robust futexes: the kernel cleans up held futexes at
  73  * thread exit time.
  74  */
  75
  76 /*
  77  * Per-lock list entry - embedded in user-space locks, somewhere close
  78  * to the futex field. (Note: user-space uses a double-linked list to
  79  * achieve O(1) list add and remove, but the kernel only needs to know
  80  * about the forward link)
  81  *
  82  * NOTE: this structure is part of the syscall ABI, and must not be
  83  * changed.
  84  */
  85 struct robust_list {
  86         struct robust_list __user *next;
  87 };
  88
  89 /*
  90  * Per-thread list head:
  91  *
  92  * NOTE: this structure is part of the syscall ABI, and must only be
  93  * changed if the change is first communicated with the glibc folks.
  94  * (When an incompatible change is done, we'll increase the structure
  95  *  size, which glibc will detect)
  96  */
  97 struct robust_list_head {
  98         /*
  99          * The head of the list. Points back to itself if empty:
 100          */
 101         struct robust_list list;
 102
 103         /*
 104          * This relative offset is set by user-space, it gives the kernel
 105          * the relative position of the futex field to examine. This way
 106          * we keep userspace flexible, to freely shape its data-structure,
 107          * without hardcoding any particular offset into the kernel:
 108          */
 109         long futex_offset;
 110
 111         /*
 112          * The death of the thread may race with userspace setting
 113          * up a lock's links. So to handle this race, userspace first
 114          * sets this field to the address of the to-be-taken lock,
 115          * then does the lock acquire, and then adds itself to the
 116          * list, and then clears this field. Hence the kernel will
 117          * always have full knowledge of all locks that the thread
 118          * _might_ have taken. We check the owner TID in any case,
 119          * so only truly owned locks will be handled.
 120          */
 121         struct robust_list __user *list_op_pending;
 122 };
 123
 124 /*
 125  * Are there any waiters for this robust futex:
 126  */
 127 #define FUTEX_WAITERS           0x80000000
 128
 129 /*
 130  * The kernel signals via this bit that a thread holding a futex
 131  * has exited without unlocking the futex. The kernel also does
 132  * a FUTEX_WAKE on such futexes, after setting the bit, to wake
 133  * up any possible waiters:
 134  */
 135 #define FUTEX_OWNER_DIED        0x40000000
 136
 137 /*
 138  * The rest of the robust-futex field is for the TID:
 139  */
 140 #define FUTEX_TID_MASK          0x3fffffff
 141
 142 /*
 143  * This limit protects against a deliberately circular list.
 144  * (Not worth introducing an rlimit for it)
 145  */
 146 #define ROBUST_LIST_LIMIT       2048
 147
 148 /*
 149  * bitset with all bits set for the FUTEX_xxx_BITSET OPs to request a
 150  * match of any bit.
 151  */
 152 #define FUTEX_BITSET_MATCH_ANY  0xffffffff
 153
 154
 155 #define FUTEX_OP_SET            0       /* *(int *)UADDR2 = OPARG; */
 156 #define FUTEX_OP_ADD            1       /* *(int *)UADDR2 += OPARG; */
 157 #define FUTEX_OP_OR             2       /* *(int *)UADDR2 |= OPARG; */
 158 #define FUTEX_OP_ANDN           3       /* *(int *)UADDR2 &= ~OPARG; */
 159 #define FUTEX_OP_XOR            4       /* *(int *)UADDR2 ^= OPARG; */
 160
 161 #define FUTEX_OP_OPARG_SHIFT    8       /* Use (1 << OPARG) instead of OPARG.  */
 162
 163 #define FUTEX_OP_CMP_EQ         0       /* if (oldval == CMPARG) wake */
 164 #define FUTEX_OP_CMP_NE         1       /* if (oldval != CMPARG) wake */
 165 #define FUTEX_OP_CMP_LT         2       /* if (oldval < CMPARG) wake */
 166 #define FUTEX_OP_CMP_LE         3       /* if (oldval <= CMPARG) wake */
 167 #define FUTEX_OP_CMP_GT         4       /* if (oldval > CMPARG) wake */
 168 #define FUTEX_OP_CMP_GE         5       /* if (oldval >= CMPARG) wake */
 169
 170 /* FUTEX_WAKE_OP will perform atomically
 171    int oldval = *(int *)UADDR2;
 172    *(int *)UADDR2 = oldval OP OPARG;
 173    if (oldval CMP CMPARG)
 174      wake UADDR2;  */
 175
 176 #define FUTEX_OP(op, oparg, cmp, cmparg) \
 177   (((op & 0xf) << 28) | ((cmp & 0xf) << 24)             \
 178    | ((oparg & 0xfff) << 12) | (cmparg & 0xfff))
 179
 180 #endif /* _UAPI_LINUX_FUTEX_H */