LCOV - code coverage report
Current view: top level - lkbce/include/linux - thread_info.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 1 0.0 %
Date: 2017-01-25 Functions: 0 1 0.0 %

          Line data    Source code
       1             : /* thread_info.h: common low-level thread information accessors
       2             :  *
       3             :  * Copyright (C) 2002  David Howells (dhowells@redhat.com)
       4             :  * - Incorporating suggestions made by Linus Torvalds
       5             :  */
       6             : 
       7             : #ifndef _LINUX_THREAD_INFO_H
       8             : #define _LINUX_THREAD_INFO_H
       9             : 
      10             : #include <linux/types.h>
      11             : 
      12             : struct timespec;
      13             : struct compat_timespec;
      14             : 
      15             : /*
      16             :  * System call restart block.
      17             :  */
      18             : struct restart_block {
      19             :         long (*fn)(struct restart_block *);
      20             :         union {
      21             :                 struct {
      22             :                         unsigned long arg0, arg1, arg2, arg3;
      23             :                 };
      24             :                 /* For futex_wait and futex_wait_requeue_pi */
      25             :                 struct {
      26             :                         u32 *uaddr;
      27             :                         u32 val;
      28             :                         u32 flags;
      29             :                         u32 bitset;
      30             :                         u64 time;
      31             :                         u32 *uaddr2;
      32             :                 } futex;
      33             :                 /* For nanosleep */
      34             :                 struct {
      35             :                         clockid_t index;
      36             :                         struct timespec __user *rmtp;
      37             : #ifdef CONFIG_COMPAT
      38             :                         struct compat_timespec __user *compat_rmtp;
      39             : #endif
      40             :                         u64 expires;
      41             :                 } nanosleep;
      42             :                 /* For poll */
      43             :                 struct {
      44             :                         struct pollfd __user *ufds;
      45             :                         int nfds;
      46             :                         int has_timeout;
      47             :                         unsigned long tv_sec;
      48             :                         unsigned long tv_nsec;
      49             :                 } poll;
      50             :         };
      51             : };
      52             : 
      53             : extern long do_no_restart_syscall(struct restart_block *parm);
      54             : 
      55             : #include <linux/bitops.h>
      56             : #include <asm/thread_info.h>
      57             : 
      58             : #ifdef __KERNEL__
      59             : 
      60             : /*
      61             :  * flag set/clear/test wrappers
      62             :  * - pass TIF_xxxx constants to these functions
      63             :  */
      64             : 
      65             : static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
      66             : {
      67             :         set_bit(flag, (unsigned long *)&ti->flags);
      68             : }
      69             : 
      70             : static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
      71             : {
      72             :         clear_bit(flag, (unsigned long *)&ti->flags);
      73             : }
      74             : 
      75             : static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
      76             : {
      77             :         return test_and_set_bit(flag, (unsigned long *)&ti->flags);
      78             : }
      79             : 
      80             : static inline int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
      81             : {
      82             :         return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
      83             : }
      84             : 
      85             : static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
      86             : {
      87           0 :         return test_bit(flag, (unsigned long *)&ti->flags);
      88             : }
      89             : 
      90             : #define set_thread_flag(flag) \
      91             :         set_ti_thread_flag(current_thread_info(), flag)
      92             : #define clear_thread_flag(flag) \
      93             :         clear_ti_thread_flag(current_thread_info(), flag)
      94             : #define test_and_set_thread_flag(flag) \
      95             :         test_and_set_ti_thread_flag(current_thread_info(), flag)
      96             : #define test_and_clear_thread_flag(flag) \
      97             :         test_and_clear_ti_thread_flag(current_thread_info(), flag)
      98             : #define test_thread_flag(flag) \
      99             :         test_ti_thread_flag(current_thread_info(), flag)
     100             : 
     101             : #define set_need_resched()      set_thread_flag(TIF_NEED_RESCHED)
     102             : #define clear_need_resched()    clear_thread_flag(TIF_NEED_RESCHED)
     103             : 
     104             : #if defined TIF_RESTORE_SIGMASK && !defined HAVE_SET_RESTORE_SIGMASK
     105             : /*
     106             :  * An arch can define its own version of set_restore_sigmask() to get the
     107             :  * job done however works, with or without TIF_RESTORE_SIGMASK.
     108             :  */
     109             : #define HAVE_SET_RESTORE_SIGMASK        1
     110             : 
     111             : /**
     112             :  * set_restore_sigmask() - make sure saved_sigmask processing gets done
     113             :  *
     114             :  * This sets TIF_RESTORE_SIGMASK and ensures that the arch signal code
     115             :  * will run before returning to user mode, to process the flag.  For
     116             :  * all callers, TIF_SIGPENDING is already set or it's no harm to set
     117             :  * it.  TIF_RESTORE_SIGMASK need not be in the set of bits that the
     118             :  * arch code will notice on return to user mode, in case those bits
     119             :  * are scarce.  We set TIF_SIGPENDING here to ensure that the arch
     120             :  * signal code always gets run when TIF_RESTORE_SIGMASK is set.
     121             :  */
     122             : static inline void set_restore_sigmask(void)
     123             : {
     124             :         set_thread_flag(TIF_RESTORE_SIGMASK);
     125             :         set_thread_flag(TIF_SIGPENDING);
     126             : }
     127             : #endif  /* TIF_RESTORE_SIGMASK && !HAVE_SET_RESTORE_SIGMASK */
     128             : 
     129             : #endif  /* __KERNEL__ */
     130             : 
     131             : #endif /* _LINUX_THREAD_INFO_H */

Generated by: LCOV version 1.10