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

          Line data    Source code
       1             : #ifndef _LINUX_SEM_H
       2             : #define _LINUX_SEM_H
       3             : 
       4             : #include <linux/ipc.h>
       5             : 
       6             : /* semop flags */
       7             : #define SEM_UNDO        0x1000  /* undo the operation on exit */
       8             : 
       9             : /* semctl Command Definitions. */
      10             : #define GETPID  11       /* get sempid */
      11             : #define GETVAL  12       /* get semval */
      12             : #define GETALL  13       /* get all semval's */
      13             : #define GETNCNT 14       /* get semncnt */
      14             : #define GETZCNT 15       /* get semzcnt */
      15             : #define SETVAL  16       /* set semval */
      16             : #define SETALL  17       /* set all semval's */
      17             : 
      18             : /* ipcs ctl cmds */
      19             : #define SEM_STAT 18
      20             : #define SEM_INFO 19
      21             : 
      22             : /* Obsolete, used only for backwards compatibility and libc5 compiles */
      23             : struct semid_ds {
      24             :         struct ipc_perm sem_perm;               /* permissions .. see ipc.h */
      25             :         __kernel_time_t sem_otime;              /* last semop time */
      26             :         __kernel_time_t sem_ctime;              /* last change time */
      27             :         struct sem      *sem_base;              /* ptr to first semaphore in array */
      28             :         struct sem_queue *sem_pending;          /* pending operations to be processed */
      29             :         struct sem_queue **sem_pending_last;    /* last pending operation */
      30             :         struct sem_undo *undo;                  /* undo requests on this array */
      31             :         unsigned short  sem_nsems;              /* no. of semaphores in array */
      32             : };
      33             : 
      34             : /* Include the definition of semid64_ds */
      35             : #include <asm/sembuf.h>
      36             : 
      37             : /* semop system calls takes an array of these. */
      38             : struct sembuf {
      39             :         unsigned short  sem_num;        /* semaphore index in array */
      40             :         short           sem_op;         /* semaphore operation */
      41             :         short           sem_flg;        /* operation flags */
      42             : };
      43             : 
      44             : /* arg for semctl system calls. */
      45             : union semun {
      46             :         int val;                        /* value for SETVAL */
      47             :         struct semid_ds __user *buf;    /* buffer for IPC_STAT & IPC_SET */
      48             :         unsigned short __user *array;   /* array for GETALL & SETALL */
      49             :         struct seminfo __user *__buf;   /* buffer for IPC_INFO */
      50             :         void __user *__pad;
      51             : };
      52             : 
      53             : struct  seminfo {
      54             :         int semmap;
      55             :         int semmni;
      56             :         int semmns;
      57             :         int semmnu;
      58             :         int semmsl;
      59             :         int semopm;
      60             :         int semume;
      61             :         int semusz;
      62             :         int semvmx;
      63             :         int semaem;
      64             : };
      65             : 
      66             : #define SEMMNI  128             /* <= IPCMNI  max # of semaphore identifiers */
      67             : #define SEMMSL  250             /* <= 8 000 max num of semaphores per id */
      68             : #define SEMMNS  (SEMMNI*SEMMSL) /* <= INT_MAX max # of semaphores in system */
      69             : #define SEMOPM  32              /* <= 1 000 max num of ops per semop call */
      70             : #define SEMVMX  32767           /* <= 32767 semaphore maximum value */
      71             : #define SEMAEM  SEMVMX          /* adjust on exit max value */
      72             : 
      73             : /* unused */
      74             : #define SEMUME  SEMOPM          /* max num of undo entries per process */
      75             : #define SEMMNU  SEMMNS          /* num of undo structures system wide */
      76             : #define SEMMAP  SEMMNS          /* # of entries in semaphore map */
      77             : #define SEMUSZ  20              /* sizeof struct sem_undo */
      78             : 
      79             : #ifdef __KERNEL__
      80             : #include <asm/atomic.h>
      81             : #include <linux/rcupdate.h>
      82             : 
      83             : struct task_struct;
      84             : 
      85             : /* One semaphore structure for each semaphore in the system. */
      86             : struct sem {
      87             :         int     semval;         /* current value */
      88             :         int     sempid;         /* pid of last operation */
      89             :         struct list_head sem_pending; /* pending single-sop operations */
      90             : };
      91             : 
      92             : /* One sem_array data structure for each set of semaphores in the system. */
      93             : struct sem_array {
      94             :         struct kern_ipc_perm    sem_perm;       /* permissions .. see ipc.h */
      95             :         time_t                  sem_otime;      /* last semop time */
      96             :         time_t                  sem_ctime;      /* last change time */
      97             :         struct sem              *sem_base;      /* ptr to first semaphore in array */
      98             :         struct list_head        sem_pending;    /* pending operations to be processed */
      99             :         struct list_head        list_id;        /* undo requests on this array */
     100             :         int                     sem_nsems;      /* no. of semaphores in array */
     101             :         int                     complex_count;  /* pending complex operations */
     102             : };
     103             : 
     104             : /* One queue for each sleeping process in the system. */
     105             : struct sem_queue {
     106             :         struct list_head        simple_list; /* queue of pending operations */
     107             :         struct list_head        list;    /* queue of pending operations */
     108             :         struct task_struct      *sleeper; /* this process */
     109             :         struct sem_undo         *undo;   /* undo structure */
     110             :         int                     pid;     /* process id of requesting process */
     111             :         int                     status;  /* completion status of operation */
     112             :         struct sembuf           *sops;   /* array of pending operations */
     113             :         int                     nsops;   /* number of operations */
     114             :         int                     alter;   /* does the operation alter the array? */
     115             : };
     116           1 : 
     117             : /* Each task has a list of undo requests. They are executed automatically
     118             :  * when the process exits.
     119             :  */
     120             : struct sem_undo {
     121             :         struct list_head        list_proc;      /* per-process list: all undos from one process. */
     122             :                                                 /* rcu protected */
     123             :         struct rcu_head         rcu;            /* rcu struct for sem_undo() */
     124             :         struct sem_undo_list    *ulp;           /* sem_undo_list for the process */
     125             :         struct list_head        list_id;        /* per semaphore array list: all undos for one array */
     126             :         int                     semid;          /* semaphore set identifier */
     127             :         short *                 semadj;         /* array of adjustments, one per semaphore */
     128             : };
     129           1 : 
     130             : /* sem_undo_list controls shared access to the list of sem_undo structures
     131             :  * that may be shared among all a CLONE_SYSVSEM task group.
     132             :  */ 
     133             : struct sem_undo_list {
     134             :         atomic_t                refcnt;
     135             :         spinlock_t              lock;
     136             :         struct list_head        list_proc;
     137             : };
     138           1 : 
     139             : struct sysv_sem {
     140             :         struct sem_undo_list *undo_list;
     141             : };
     142             : 
     143             : #ifdef CONFIG_SYSVIPC
     144             : 
     145             : extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
     146             : extern void exit_sem(struct task_struct *tsk);
     147             : 
     148             : #else
     149             : static inline int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
     150             : {
     151             :         return 0;
     152             : }
     153             : 
     154             : static inline void exit_sem(struct task_struct *tsk)
     155             : {
     156             :         return;
     157             : }
     158             : #endif
     159             : 
     160             : #endif /* __KERNEL__ */
     161             : 
     162             : #endif /* _LINUX_SEM_H */

Generated by: LCOV version 1.10