sysdeps/pthread/sem_routines.c

   1 /* Helper code for POSIX semaphore implementation.
   2    Copyright (C) 2021-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <search.h>
  20 #include <semaphoreP.h>
  21 #include <sys/mman.h>
  22 #include <sem_routines.h>
  23
  24 /* Keeping track of currently used mappings.  */
  25 struct inuse_sem
  26 {
  27   dev_t dev;
  28   ino64_t ino;
  29   int refcnt;
  30   sem_t *sem;
  31   char name[];
  32 };
  33
  34 struct search_sem
  35 {
  36   dev_t dev;
  37   ino64_t ino;
  38   int refcnt;
  39   sem_t *sem;
  40   char name[NAME_MAX + 1];
  41 };
  42
  43 /* Comparison function for search of existing mapping.  */
  44 static int
  45 sem_search (const void *a, const void *b)
  46 {
  47   const struct inuse_sem *as = (const struct inuse_sem *) a;
  48   const struct inuse_sem *bs = (const struct inuse_sem *) b;
  49
  50   if (as->ino != bs->ino)
  51     /* Cannot return the difference the type is larger than int.  */
  52     return as->ino < bs->ino ? -1 : (as->ino == bs->ino ? 0 : 1);
  53
  54   if (as->dev != bs->dev)
  55     /* Cannot return the difference the type is larger than int.  */
  56     return as->dev < bs->dev ? -1 : (as->dev == bs->dev ? 0 : 1);
  57
  58   return strcmp (as->name, bs->name);
  59 }
  60
  61 /* The search tree for existing mappings.  */
  62 static void *sem_mappings;
  63
  64 /* Lock to protect the search tree.  */
  65 static int sem_mappings_lock = LLL_LOCK_INITIALIZER;
  66
  67
  68 /* Search for existing mapping and if possible add the one provided.  */
  69 sem_t *
  70 __sem_check_add_mapping (const char *name, int fd, sem_t *existing)
  71 {
  72   size_t namelen = strlen (name);
  73   if (namelen > NAME_MAX)
  74     return SEM_FAILED;
  75   namelen += 1;
  76
  77   sem_t *result = SEM_FAILED;
  78
  79   /* Get the information about the file.  */
  80   struct __stat64_t64 st;
  81   if (__fstat64_time64 (fd, &st) == 0)
  82     {
  83       /* Get the lock.  */
  84       lll_lock (sem_mappings_lock, LLL_PRIVATE);
  85
  86       /* Search for an existing mapping given the information we have.  */
  87       struct search_sem fake;
  88       memcpy (fake.name, name, namelen);
  89       fake.dev = st.st_dev;
  90       fake.ino = st.st_ino;
  91
  92       struct inuse_sem **foundp = __tfind (&fake, &sem_mappings, sem_search);
  93       if (foundp != NULL)
  94         {
  95           /* There is already a mapping.  Use it.  */
  96           result = (*foundp)->sem;
  97           ++(*foundp)->refcnt;
  98         }
  99       else
 100         {
 101           /* We haven't found a mapping.  Install ione.  */
 102           struct inuse_sem *newp;
 103
 104           newp = (struct inuse_sem *) malloc (sizeof (*newp) + namelen);
 105           if (newp != NULL)
 106             {
 107               /* If the caller hasn't provided any map it now.  */
 108               if (existing == SEM_FAILED)
 109                 existing = (sem_t *) __mmap (NULL, sizeof (sem_t),
 110                                              PROT_READ | PROT_WRITE,
 111                                              MAP_SHARED, fd, 0);
 112
 113               newp->dev = st.st_dev;
 114               newp->ino = st.st_ino;
 115               newp->refcnt = 1;
 116               newp->sem = existing;
 117               memcpy (newp->name, name, namelen);
 118
 119               /* Insert the new value.  */
 120               if (existing != MAP_FAILED
 121                   && __tsearch (newp, &sem_mappings, sem_search) != NULL)
 122                 /* Successful.  */
 123                 result = existing;
 124               else
 125                 /* Something went wrong while inserting the new
 126                    value.  We fail completely.  */
 127                 free (newp);
 128             }
 129         }
 130
 131       /* Release the lock.  */
 132       lll_unlock (sem_mappings_lock, LLL_PRIVATE);
 133     }
 134
 135   if (result != existing && existing != SEM_FAILED && existing != MAP_FAILED)
 136     {
 137       /* Do not disturb errno.  */
 138       int save = errno;
 139       __munmap (existing, sizeof (sem_t));
 140       errno = save;
 141     }
 142
 143   return result;
 144 }
 145
 146 struct walk_closure
 147 {
 148   sem_t *the_sem;
 149   struct inuse_sem *rec;
 150 };
 151
 152 static void
 153 walker (const void *inodep, VISIT which, void *closure0)
 154 {
 155   struct walk_closure *closure = closure0;
 156   struct inuse_sem *nodep = *(struct inuse_sem **) inodep;
 157
 158   if (nodep->sem == closure->the_sem)
 159     closure->rec = nodep;
 160 }
 161
 162 bool
 163 __sem_remove_mapping (sem_t *sem)
 164 {
 165   bool ret = true;
 166
 167   /* Get the lock.  */
 168   lll_lock (sem_mappings_lock, LLL_PRIVATE);
 169
 170   /* Locate the entry for the mapping the caller provided.  */
 171   struct inuse_sem *rec;
 172   {
 173     struct walk_closure closure = { .the_sem = sem, .rec = NULL };
 174     __twalk_r (sem_mappings, walker, &closure);
 175     rec = closure.rec;
 176   }
 177   if (rec != NULL)
 178     {
 179       /* Check the reference counter.  If it is going to be zero, free
 180          all the resources.  */
 181       if (--rec->refcnt == 0)
 182         {
 183           /* Remove the record from the tree.  */
 184           __tdelete (rec, &sem_mappings, sem_search);
 185
 186           if (__munmap (rec->sem, sizeof (sem_t)) == -1)
 187             ret = false;
 188
 189           free (rec);
 190         }
 191     }
 192   else
 193     ret = false;
 194
 195   /* Release the lock.  */
 196   lll_unlock (sem_mappings_lock, LLL_PRIVATE);
 197
 198   return ret;
 199 }