Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Copyright (c) 2019 Intel Corporation
       3                 :            :  *
       4                 :            :  * SPDX-License-Identifier: Apache-2.0
       5                 :            :  */
       6                 :            : 
       7                 :            : #include <zephyr/sys/sem.h>
       8                 :            : #include <zephyr/internal/syscall_handler.h>
       9                 :            : 
      10                 :            : #ifdef CONFIG_USERSPACE
      11                 :            : #define SYS_SEM_MINIMUM      0
      12                 :            : #define SYS_SEM_CONTENDED    (SYS_SEM_MINIMUM - 1)
      13                 :            : 
      14                 :            : static inline atomic_t bounded_dec(atomic_t *val, atomic_t minimum)
      15                 :            : {
      16                 :            :         atomic_t old_value, new_value;
      17                 :            : 
      18                 :            :         do {
      19                 :            :                 old_value = atomic_get(val);
      20                 :            :                 if (old_value < minimum) {
      21                 :            :                         break;
      22                 :            :                 }
      23                 :            : 
      24                 :            :                 new_value = old_value - 1;
      25                 :            :         } while (atomic_cas(val, old_value, new_value) == 0);
      26                 :            : 
      27                 :            :         return old_value;
      28                 :            : }
      29                 :            : 
      30                 :            : static inline atomic_t bounded_inc(atomic_t *val, atomic_t minimum,
      31                 :            :                                    atomic_t maximum)
      32                 :            : {
      33                 :            :         atomic_t old_value, new_value;
      34                 :            : 
      35                 :            :         do {
      36                 :            :                 old_value = atomic_get(val);
      37                 :            :                 if (old_value >= maximum) {
      38                 :            :                         break;
      39                 :            :                 }
      40                 :            : 
      41                 :            :                 new_value = ((old_value < minimum) ? minimum : old_value) + 1;
      42                 :            :         } while (atomic_cas(val, old_value, new_value) == 0U);
      43                 :            : 
      44                 :            :         return old_value;
      45                 :            : }
      46                 :            : 
      47                 :            : int sys_sem_init(struct sys_sem *sem, unsigned int initial_count,
      48                 :            :                  unsigned int limit)
      49                 :            : {
      50                 :            :         if ((sem == NULL) || (limit == SYS_SEM_MINIMUM) ||
      51                 :            :             (initial_count > limit) || (limit > INT_MAX)) {
      52                 :            :                 return -EINVAL;
      53                 :            :         }
      54                 :            : 
      55                 :            :         (void)atomic_set(&sem->futex.val, initial_count);
      56                 :            :         sem->limit = limit;
      57                 :            : 
      58                 :            :         return 0;
      59                 :            : }
      60                 :            : 
      61                 :            : int sys_sem_give(struct sys_sem *sem)
      62                 :            : {
      63                 :            :         int ret = 0;
      64                 :            :         atomic_t old_value;
      65                 :            : 
      66                 :            :         old_value = bounded_inc(&sem->futex.val,
      67                 :            :                                 SYS_SEM_MINIMUM, sem->limit);
      68                 :            :         if (old_value < 0) {
      69                 :            :                 ret = k_futex_wake(&sem->futex, true);
      70                 :            : 
      71                 :            :                 if (ret > 0) {
      72                 :            :                         return 0;
      73                 :            :                 }
      74                 :            :         } else if (old_value >= sem->limit) {
      75                 :            :                 return -EAGAIN;
      76                 :            :         } else {
      77                 :            :                 ;
      78                 :            :         }
      79                 :            :         return ret;
      80                 :            : }
      81                 :            : 
      82                 :            : int sys_sem_take(struct sys_sem *sem, k_timeout_t timeout)
      83                 :            : {
      84                 :            :         int ret = 0;
      85                 :            :         atomic_t old_value;
      86                 :            : 
      87                 :            :         do {
      88                 :            :                 old_value = bounded_dec(&sem->futex.val,
      89                 :            :                                         SYS_SEM_MINIMUM);
      90                 :            :                 if (old_value > 0) {
      91                 :            :                         return 0;
      92                 :            :                 }
      93                 :            : 
      94                 :            :                 ret = k_futex_wait(&sem->futex,
      95                 :            :                                    SYS_SEM_CONTENDED, timeout);
      96                 :            :         } while (ret == 0 || ret == -EAGAIN);
      97                 :            : 
      98                 :            :         return ret;
      99                 :            : }
     100                 :            : 
     101                 :            : unsigned int sys_sem_count_get(struct sys_sem *sem)
     102                 :            : {
     103                 :            :         int value = atomic_get(&sem->futex.val);
     104                 :            : 
     105                 :            :         return (value > SYS_SEM_MINIMUM) ? value : SYS_SEM_MINIMUM;
     106                 :            : }
     107                 :            : #else
     108                 :          0 : int sys_sem_init(struct sys_sem *sem, unsigned int initial_count,
     109                 :            :                  unsigned int limit)
     110                 :            : {
     111                 :          0 :         k_sem_init(&sem->kernel_sem, initial_count, limit);
     112                 :            : 
     113                 :          0 :         return 0;
     114                 :            : }
     115                 :            : 
     116                 :          0 : int sys_sem_give(struct sys_sem *sem)
     117                 :            : {
     118                 :          0 :         k_sem_give(&sem->kernel_sem);
     119                 :            : 
     120                 :          0 :         return 0;
     121                 :            : }
     122                 :            : 
     123                 :          0 : int sys_sem_take(struct sys_sem *sem, k_timeout_t timeout)
     124                 :            : {
     125                 :          0 :         int ret_value = 0;
     126                 :            : 
     127                 :          0 :         ret_value = k_sem_take(&sem->kernel_sem, timeout);
     128         [ #  # ]:          0 :         if ((ret_value == -EAGAIN) || (ret_value == -EBUSY)) {
     129                 :          0 :                 ret_value = -ETIMEDOUT;
     130                 :            :         }
     131                 :            : 
     132                 :          0 :         return ret_value;
     133                 :            : }
     134                 :            : 
     135                 :          0 : unsigned int sys_sem_count_get(struct sys_sem *sem)
     136                 :            : {
     137                 :          0 :         return k_sem_count_get(&sem->kernel_sem);
     138                 :            : }
     139                 :            : #endif