sysdeps/unix/sysv/linux/bits/sched.h

   1 /* Definitions of constants and data structure for POSIX 1003.1b-1993
   2    scheduling interface.
   3    Copyright (C) 1996-2015 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef __need_schedparam
  21
  22 #ifndef _SCHED_H
  23 # error "Never include <bits/sched.h> directly; use <sched.h> instead."
  24 #endif
  25
  26
  27 /* Scheduling algorithms.  */
  28 #define SCHED_OTHER             0
  29 #define SCHED_FIFO              1
  30 #define SCHED_RR                2
  31 #ifdef __USE_GNU
  32 # define SCHED_BATCH            3
  33 # define SCHED_IDLE             5
  34
  35 # define SCHED_RESET_ON_FORK    0x40000000
  36 #endif
  37
  38 #ifdef __USE_GNU
  39 /* Cloning flags.  */
  40 # define CSIGNAL       0x000000ff /* Signal mask to be sent at exit.  */
  41 # define CLONE_VM      0x00000100 /* Set if VM shared between processes.  */
  42 # define CLONE_FS      0x00000200 /* Set if fs info shared between processes.  */
  43 # define CLONE_FILES   0x00000400 /* Set if open files shared between processes.  */
  44 # define CLONE_SIGHAND 0x00000800 /* Set if signal handlers shared.  */
  45 # define CLONE_PTRACE  0x00002000 /* Set if tracing continues on the child.  */
  46 # define CLONE_VFORK   0x00004000 /* Set if the parent wants the child to
  47                                      wake it up on mm_release.  */
  48 # define CLONE_PARENT  0x00008000 /* Set if we want to have the same
  49                                      parent as the cloner.  */
  50 # define CLONE_THREAD  0x00010000 /* Set to add to same thread group.  */
  51 # define CLONE_NEWNS   0x00020000 /* Set to create new namespace.  */
  52 # define CLONE_SYSVSEM 0x00040000 /* Set to shared SVID SEM_UNDO semantics.  */
  53 # define CLONE_SETTLS  0x00080000 /* Set TLS info.  */
  54 # define CLONE_PARENT_SETTID 0x00100000 /* Store TID in userlevel buffer
  55                                            before MM copy.  */
  56 # define CLONE_CHILD_CLEARTID 0x00200000 /* Register exit futex and memory
  57                                             location to clear.  */
  58 # define CLONE_DETACHED 0x00400000 /* Create clone detached.  */
  59 # define CLONE_UNTRACED 0x00800000 /* Set if the tracing process can't
  60                                       force CLONE_PTRACE on this clone.  */
  61 # define CLONE_CHILD_SETTID 0x01000000 /* Store TID in userlevel buffer in
  62                                           the child.  */
  63 # define CLONE_NEWUTS   0x04000000      /* New utsname group.  */
  64 # define CLONE_NEWIPC   0x08000000      /* New ipcs.  */
  65 # define CLONE_NEWUSER  0x10000000      /* New user namespace.  */
  66 # define CLONE_NEWPID   0x20000000      /* New pid namespace.  */
  67 # define CLONE_NEWNET   0x40000000      /* New network namespace.  */
  68 # define CLONE_IO       0x80000000      /* Clone I/O context.  */
  69 #endif
  70
  71 /* The official definition.  */
  72 struct sched_param
  73   {
  74     int __sched_priority;
  75   };
  76
  77 __BEGIN_DECLS
  78
  79 #ifdef __USE_GNU
  80 /* Clone current process.  */
  81 extern int clone (int (*__fn) (void *__arg), void *__child_stack,
  82                   int __flags, void *__arg, ...) __THROW;
  83
  84 /* Unshare the specified resources.  */
  85 extern int unshare (int __flags) __THROW;
  86
  87 /* Get index of currently used CPU.  */
  88 extern int sched_getcpu (void) __THROW;
  89
  90 /* Switch process to namespace of type NSTYPE indicated by FD.  */
  91 extern int setns (int __fd, int __nstype) __THROW;
  92 #endif
  93
  94
  95 __END_DECLS
  96
  97 #endif  /* need schedparam */
  98
  99 #if !defined __defined_schedparam \
 100     && (defined __need_schedparam || defined _SCHED_H)
 101 # define __defined_schedparam   1
 102 /* Data structure to describe a process' schedulability.  */
 103 struct __sched_param
 104   {
 105     int __sched_priority;
 106   };
 107 # undef __need_schedparam
 108 #endif
 109
 110
 111 #if defined _SCHED_H && !defined __cpu_set_t_defined
 112 # define __cpu_set_t_defined
 113 /* Size definition for CPU sets.  */
 114 # define __CPU_SETSIZE  1024
 115 # define __NCPUBITS     (8 * sizeof (__cpu_mask))
 116
 117 /* Type for array elements in 'cpu_set_t'.  */
 118 typedef unsigned long int __cpu_mask;
 119
 120 /* Basic access functions.  */
 121 # define __CPUELT(cpu)  ((cpu) / __NCPUBITS)
 122 # define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
 123
 124 /* Data structure to describe CPU mask.  */
 125 typedef struct
 126 {
 127   __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
 128 } cpu_set_t;
 129
 130 /* Access functions for CPU masks.  */
 131 # if __GNUC_PREREQ (2, 91)
 132 #  define __CPU_ZERO_S(setsize, cpusetp) \
 133   do __builtin_memset (cpusetp, '\0', setsize); while (0)
 134 # else
 135 #  define __CPU_ZERO_S(setsize, cpusetp) \
 136   do {                                                                        \
 137     size_t __i;                                                               \
 138     size_t __imax = (setsize) / sizeof (__cpu_mask);                          \
 139     __cpu_mask *__bits = (cpusetp)->__bits;                                   \
 140     for (__i = 0; __i < __imax; ++__i)                                        \
 141       __bits[__i] = 0;                                                        \
 142   } while (0)
 143 # endif
 144 # define __CPU_SET_S(cpu, setsize, cpusetp) \
 145   (__extension__                                                              \
 146    ({ size_t __cpu = (cpu);                                                   \
 147       __cpu / 8 < (setsize)                                                   \
 148       ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]               \
 149          |= __CPUMASK (__cpu))                                                \
 150       : 0; }))
 151 # define __CPU_CLR_S(cpu, setsize, cpusetp) \
 152   (__extension__                                                              \
 153    ({ size_t __cpu = (cpu);                                                   \
 154       __cpu / 8 < (setsize)                                                   \
 155       ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]               \
 156          &= ~__CPUMASK (__cpu))                                               \
 157       : 0; }))
 158 # define __CPU_ISSET_S(cpu, setsize, cpusetp) \
 159   (__extension__                                                              \
 160    ({ size_t __cpu = (cpu);                                                   \
 161       __cpu / 8 < (setsize)                                                   \
 162       ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]        \
 163           & __CPUMASK (__cpu))) != 0                                          \
 164       : 0; }))
 165
 166 # define __CPU_COUNT_S(setsize, cpusetp) \
 167   __sched_cpucount (setsize, cpusetp)
 168
 169 # if __GNUC_PREREQ (2, 91)
 170 #  define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \
 171   (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
 172 # else
 173 #  define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \
 174   (__extension__                                                              \
 175    ({ const __cpu_mask *__arr1 = (cpusetp1)->__bits;                          \
 176       const __cpu_mask *__arr2 = (cpusetp2)->__bits;                          \
 177       size_t __imax = (setsize) / sizeof (__cpu_mask);                        \
 178       size_t __i;                                                             \
 179       for (__i = 0; __i < __imax; ++__i)                                      \
 180         if (__arr1[__i] != __arr2[__i])                                       \
 181           break;                                                              \
 182       __i == __imax; }))
 183 # endif
 184
 185 # define __CPU_OP_S(setsize, destset, srcset1, srcset2, op) \
 186   (__extension__                                                              \
 187    ({ cpu_set_t *__dest = (destset);                                          \
 188       const __cpu_mask *__arr1 = (srcset1)->__bits;                           \
 189       const __cpu_mask *__arr2 = (srcset2)->__bits;                           \
 190       size_t __imax = (setsize) / sizeof (__cpu_mask);                        \
 191       size_t __i;                                                             \
 192       for (__i = 0; __i < __imax; ++__i)                                      \
 193         ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i];    \
 194       __dest; }))
 195
 196 # define __CPU_ALLOC_SIZE(count) \
 197   ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
 198 # define __CPU_ALLOC(count) __sched_cpualloc (count)
 199 # define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
 200
 201 __BEGIN_DECLS
 202
 203 extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
 204   __THROW;
 205 extern cpu_set_t *__sched_cpualloc (size_t __count) __THROW __wur;
 206 extern void __sched_cpufree (cpu_set_t *__set) __THROW;
 207
 208 __END_DECLS
 209
 210 #endif