lib/pthread_mutex_timedlock.c

   1 /* Lock a mutex, abandoning after a certain time.
   2    Copyright (C) 2019-2024 Free Software Foundation, Inc.
   3
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8
   9    This file is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #include <config.h>
  18
  19 /* Specification.  */
  20 #include <pthread.h>
  21
  22 #include <errno.h>
  23 #include <limits.h>
  24 #include <sys/time.h>
  25 #include <time.h>
  26
  27 #ifndef MIN
  28 # define MIN(a, b) ((a) < (b) ? (a) : (b))
  29 #endif
  30
  31 int
  32 pthread_mutex_timedlock (pthread_mutex_t *mutex, const struct timespec *abstime)
  33 {
  34   /* Poll the mutex's state in regular intervals.  Ugh.  */
  35   /* POSIX says:
  36       "Under no circumstance shall the function fail with a timeout if
  37        the mutex can be locked immediately. The validity of the abstime
  38        parameter need not be checked if the mutex can be locked
  39        immediately."
  40      Therefore start the loop with a pthread_mutex_trylock call.  */
  41   for (;;)
  42     {
  43       int err;
  44       struct timeval currtime;
  45       unsigned long remaining;
  46
  47       err = pthread_mutex_trylock (mutex);
  48       if (err != EBUSY)
  49         return err;
  50
  51       gettimeofday (&currtime, NULL);
  52
  53       if (currtime.tv_sec > abstime->tv_sec)
  54         remaining = 0;
  55       else
  56         {
  57           unsigned long seconds = abstime->tv_sec - currtime.tv_sec;
  58           remaining = seconds * 1000000000;
  59           if (remaining / 1000000000 != seconds) /* overflow? */
  60             remaining = ULONG_MAX;
  61           else
  62             {
  63               long nanoseconds =
  64                 abstime->tv_nsec - currtime.tv_usec * 1000;
  65               if (nanoseconds >= 0)
  66                 {
  67                   remaining += nanoseconds;
  68                   if (remaining < nanoseconds) /* overflow? */
  69                     remaining = ULONG_MAX;
  70                 }
  71               else
  72                 {
  73                   if (remaining >= - nanoseconds)
  74                     remaining -= (- nanoseconds);
  75                   else
  76                     remaining = 0;
  77                 }
  78             }
  79         }
  80       if (remaining == 0)
  81         return ETIMEDOUT;
  82
  83       /* Sleep 1 ms.  */
  84       struct timespec duration =
  85         {
  86           .tv_sec = 0,
  87           .tv_nsec = MIN (1000000, remaining)
  88         };
  89       nanosleep (&duration, NULL);
  90     }
  91 }