/* * Copyright (C) 2008 The Android Open Source Project * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _SCHED_H_ #define _SCHED_H_ #include <sys/cdefs.h> #include <sys/time.h> #include <linux/sched.h> __BEGIN_DECLS /* This name is used by glibc, but not by the kernel. */ #define SCHED_OTHER SCHED_NORMAL struct sched_param { int __sched_priority; }; #define sched_priority __sched_priority extern int sched_setscheduler(pid_t, int, const struct sched_param*); extern int sched_getscheduler(pid_t); extern int sched_yield(void); extern int sched_get_priority_max(int); extern int sched_get_priority_min(int); extern int sched_setparam(pid_t, const struct sched_param*); extern int sched_getparam(pid_t, struct sched_param*); extern int sched_rr_get_interval(pid_t, struct timespec*); #ifdef _GNU_SOURCE extern int clone(int (*)(void*), void*, int, void*, ...); extern int unshare(int); extern int sched_getcpu(void); extern int setns(int, int); /* Our implementation supports up to 32 independent CPUs, which is also * the maximum supported by the kernel at the moment. GLibc uses 1024 by * default. * * If you want to use more than that, you should use CPU_ALLOC() / CPU_FREE() * and the CPU_XXX_S() macro variants. */ #define CPU_SETSIZE 32 #define __CPU_BITTYPE unsigned long int /* mandated by the kernel */ #define __CPU_BITSHIFT 5 /* should be log2(BITTYPE) */ #define __CPU_BITS (1 << __CPU_BITSHIFT) #define __CPU_ELT(x) ((x) >> __CPU_BITSHIFT) #define __CPU_MASK(x) ((__CPU_BITTYPE)1 << ((x) & (__CPU_BITS-1))) typedef struct { __CPU_BITTYPE __bits[ CPU_SETSIZE / __CPU_BITS ]; } cpu_set_t; extern int sched_setaffinity(pid_t pid, size_t setsize, const cpu_set_t* set); extern int sched_getaffinity(pid_t pid, size_t setsize, cpu_set_t* set); /* Provide optimized implementation for 32-bit cpu_set_t */ #if CPU_SETSIZE == __CPU_BITS # define CPU_ZERO(set_) \ do{ \ (set_)->__bits[0] = 0; \ }while(0) # define CPU_SET(cpu_,set_) \ do {\ size_t __cpu = (cpu_); \ if (__cpu < CPU_SETSIZE) \ (set_)->__bits[0] |= __CPU_MASK(__cpu); \ }while (0) # define CPU_CLR(cpu_,set_) \ do {\ size_t __cpu = (cpu_); \ if (__cpu < CPU_SETSIZE) \ (set_)->__bits[0] &= ~__CPU_MASK(__cpu); \ }while (0) # define CPU_ISSET(cpu_, set_) \ (__extension__({\ size_t __cpu = (cpu_); \ (cpu_ < CPU_SETSIZE) \ ? ((set_)->__bits[0] & __CPU_MASK(__cpu)) != 0 \ : 0; \ })) # define CPU_EQUAL(set1_, set2_) \ ((set1_)->__bits[0] == (set2_)->__bits[0]) # define __CPU_OP(dst_, set1_, set2_, op_) \ do { \ (dst_)->__bits[0] = (set1_)->__bits[0] op_ (set2_)->__bits[0]; \ } while (0) # define CPU_COUNT(set_) __builtin_popcountl((set_)->__bits[0]) #else /* CPU_SETSIZE != __CPU_BITS */ # define CPU_ZERO(set_) CPU_ZERO_S(sizeof(cpu_set_t), set_) # define CPU_SET(cpu_,set_) CPU_SET_S(cpu_,sizeof(cpu_set_t),set_) # define CPU_CLR(cpu_,set_) CPU_CLR_S(cpu_,sizeof(cpu_set_t),set_) # define CPU_ISSET(cpu_,set_) CPU_ISSET_S(cpu_,sizeof(cpu_set_t),set_) # define CPU_COUNT(set_) CPU_COUNT_S(sizeof(cpu_set_t),set_) # define CPU_EQUAL(set1_,set2_) CPU_EQUAL_S(sizeof(cpu_set_t),set1_,set2_) # define __CPU_OP(dst_,set1_,set2_,op_) __CPU_OP_S(sizeof(cpu_set_t),dst_,set1_,set2_,op_) #endif /* CPU_SETSIZE != __CPU_BITS */ #define CPU_AND(set1_,set2_) __CPU_OP(set1_,set2_,&) #define CPU_OR(set1_,set2_) __CPU_OP(set1_,set2_,|) #define CPU_XOR(set1_,set2_) __CPU_OP(set1_,set2_,^) /* Support for dynamically-allocated cpu_set_t */ #define CPU_ALLOC_SIZE(count) \ __CPU_ELT((count) + (__CPU_BITS-1))*sizeof(__CPU_BITTYPE) #define CPU_ALLOC(count) __sched_cpualloc((count)); #define CPU_FREE(set) __sched_cpufree((set)) extern cpu_set_t* __sched_cpualloc(size_t count); extern void __sched_cpufree(cpu_set_t* set); #define CPU_ZERO_S(setsize_,set_) \ do { \ size_t __nn = 0; \ size_t __nn_max = (setsize_)/sizeof(__CPU_BITTYPE); \ for (; __nn < __nn_max; __nn++) \ (set_)->__bits[__nn] = 0; \ } while (0) #define CPU_SET_S(cpu_,setsize_,set_) \ do { \ size_t __cpu = (cpu_); \ if (__cpu < 8*(setsize_)) \ (set_)->__bits[__CPU_ELT(__cpu)] |= __CPU_MASK(__cpu); \ } while (0) #define CPU_CLR_S(cpu_,setsize_,set_) \ do { \ size_t __cpu = (cpu_); \ if (__cpu < 8*(setsize_)) \ (set_)->__bits[__CPU_ELT(__cpu)] &= ~__CPU_MASK(__cpu); \ } while (0) #define CPU_ISSET_S(cpu_, setsize_, set_) \ (__extension__ ({ \ size_t __cpu = (cpu_); \ (__cpu < 8*(setsize_)) \ ? ((set_)->__bits[__CPU_ELT(__cpu)] & __CPU_MASK(__cpu)) != 0 \ : 0; \ })) #define CPU_EQUAL_S(setsize_, set1_, set2_) \ (__extension__ ({ \ __const __CPU_BITTYPE* __src1 = (set1_)->__bits; \ __const __CPU_BITTYPE* __src2 = (set2_)->__bits; \ size_t __nn = 0, __nn_max = (setsize_)/sizeof(__CPU_BITTYPE); \ for (; __nn < __nn_max; __nn++) { \ if (__src1[__nn] != __src2[__nn]) \ break; \ } \ __nn == __nn_max; \ })) #define __CPU_OP_S(setsize_, dstset_, srcset1_, srcset2_, op) \ do { \ cpu_set_t* __dst = (dstset); \ const __CPU_BITTYPE* __src1 = (srcset1)->__bits; \ const __CPU_BITTYPE* __src2 = (srcset2)->__bits; \ size_t __nn = 0, __nn_max = (setsize_)/sizeof(__CPU_BITTYPE); \ for (; __nn < __nn_max; __nn++) \ (__dst)->__bits[__nn] = __src1[__nn] op __src2[__nn]; \ } while (0) #define CPU_COUNT_S(setsize_, set_) \ __sched_cpucount((setsize_), (set_)) extern int __sched_cpucount(size_t setsize, cpu_set_t* set); #endif /* _GNU_SOURCE */ __END_DECLS #endif /* _SCHED_H_ */