sysdeps/unix/sysv/linux/semctl.c

   1 /* Copyright (C) 1995-2024 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <sys/sem.h>
  19 #include <stdarg.h>
  20 #include <ipc_priv.h>
  21 #include <sysdep.h>
  22 #include <shlib-compat.h>
  23 #include <linux/posix_types.h>             /* For __kernel_mode_t.  */
  24
  25 /* The struct used to issue the syscall.  For architectures that assume
  26    64-bit time as default (!__ASSUME_TIME64_SYSCALLS) the syscall will
  27    split the resulting 64-bit sem_{o,c}time in two fields (sem_{o,c}time
  28    and __sem_{o,c}time_high).  */
  29 union semun
  30 {
  31   int val;                      /* value for SETVAL */
  32   struct semid_ds *buf;         /* buffer for IPC_STAT & IPC_SET */
  33   unsigned short int *array;    /* array for GETALL & SETALL */
  34   struct seminfo *__buf;        /* buffer for IPC_INFO */
  35 };
  36
  37 #if __IPC_TIME64 == 0
  38 # define semun64 semun
  39 typedef union semun semctl_arg_t;
  40 #else
  41 # include <struct_kernel_semid64_ds.h>
  42
  43 union ksemun64
  44 {
  45   int val;
  46   struct kernel_semid64_ds *buf;
  47   unsigned short int *array;
  48   struct seminfo *__buf;
  49 };
  50
  51 # if __TIMESIZE == 64
  52 #  define semun64 semun
  53 # else
  54 /* The struct used when __semctl64 is called.  */
  55 union semun64
  56 {
  57   int val;
  58   struct __semid64_ds *buf;
  59   unsigned short int *array;
  60   struct seminfo *__buf;
  61 };
  62 # endif
  63
  64 static void
  65 semid64_to_ksemid64 (const struct __semid64_ds *semid64,
  66                      struct kernel_semid64_ds *ksemid)
  67 {
  68   ksemid->sem_perm       = semid64->sem_perm;
  69   ksemid->sem_otime      = semid64->sem_otime;
  70   ksemid->sem_otime_high = semid64->sem_otime >> 32;
  71   ksemid->sem_ctime      = semid64->sem_ctime;
  72   ksemid->sem_ctime_high = semid64->sem_ctime >> 32;
  73   ksemid->sem_nsems      = semid64->sem_nsems;
  74 }
  75
  76 static void
  77 ksemid64_to_semid64 (const struct kernel_semid64_ds *ksemid,
  78                      struct __semid64_ds *semid64)
  79 {
  80   semid64->sem_perm  = ksemid->sem_perm;
  81   semid64->sem_otime = ksemid->sem_otime
  82                        | ((__time64_t) ksemid->sem_otime_high << 32);
  83   semid64->sem_ctime = ksemid->sem_ctime
  84                        | ((__time64_t) ksemid->sem_ctime_high << 32);
  85   semid64->sem_nsems = ksemid->sem_nsems;
  86 }
  87
  88 static union ksemun64
  89 semun64_to_ksemun64 (int cmd, union semun64 semun64,
  90                      struct kernel_semid64_ds *buf)
  91 {
  92   union ksemun64 r = { 0 };
  93   switch (cmd)
  94     {
  95     case SETVAL:
  96       r.val = semun64.val;
  97       break;
  98     case GETALL:
  99     case SETALL:
 100       r.array = semun64.array;
 101       break;
 102     case SEM_STAT:
 103     case SEM_STAT_ANY:
 104     case IPC_STAT:
 105     case IPC_SET:
 106       r.buf = buf;
 107       semid64_to_ksemid64 (semun64.buf, r.buf);
 108       break;
 109     case IPC_INFO:
 110     case SEM_INFO:
 111       r.__buf = semun64.__buf;
 112       break;
 113     }
 114   return r;
 115 }
 116
 117 typedef union ksemun64 semctl_arg_t;
 118 #endif
 119
 120 static int
 121 semctl_syscall (int semid, int semnum, int cmd, semctl_arg_t arg)
 122 {
 123 #ifdef __ASSUME_DIRECT_SYSVIPC_SYSCALLS
 124   return INLINE_SYSCALL_CALL (semctl, semid, semnum, cmd | __IPC_64,
 125                               arg.array);
 126 #else
 127   return INLINE_SYSCALL_CALL (ipc, IPCOP_semctl, semid, semnum, cmd | __IPC_64,
 128                               SEMCTL_ARG_ADDRESS (arg));
 129 #endif
 130 }
 131
 132 /* POSIX states ipc_perm mode should have type of mode_t.  */
 133 _Static_assert (sizeof ((struct semid_ds){0}.sem_perm.mode)
 134                 == sizeof (mode_t),
 135                 "sizeof (msqid_ds.msg_perm.mode) != sizeof (mode_t)");
 136
 137 int
 138 __semctl64 (int semid, int semnum, int cmd, ...)
 139 {
 140   union semun64 arg64 = { 0 };
 141   va_list ap;
 142
 143   /* Some applications pass the __IPC_64 flag in cmd, to invoke
 144      previously unsupported commands back when there was no EINVAL
 145      error checking in glibc.  Mask the flag for the switch statements
 146      below.  semctl_syscall adds back the __IPC_64 flag for the actual
 147      system call.  */
 148   cmd &= ~__IPC_64;
 149
 150   /* Get the argument only if required.  */
 151   switch (cmd)
 152     {
 153     case SETVAL:        /* arg.val */
 154     case GETALL:        /* arg.array */
 155     case SETALL:
 156     case IPC_STAT:      /* arg.buf */
 157     case IPC_SET:
 158     case SEM_STAT:
 159     case SEM_STAT_ANY:
 160     case IPC_INFO:      /* arg.__buf */
 161     case SEM_INFO:
 162       va_start (ap, cmd);
 163       arg64 = va_arg (ap, union semun64);
 164       va_end (ap);
 165       break;
 166     case IPC_RMID:      /* arg ignored.  */
 167     case GETNCNT:
 168     case GETPID:
 169     case GETVAL:
 170     case GETZCNT:
 171       break;
 172     default:
 173       __set_errno (EINVAL);
 174       return -1;
 175     }
 176
 177 #if __IPC_TIME64
 178   struct kernel_semid64_ds ksemid;
 179   union ksemun64 ksemun = semun64_to_ksemun64 (cmd, arg64, &ksemid);
 180 # ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
 181   if (cmd == IPC_SET)
 182     ksemid.sem_perm.mode *= 0x10000U;
 183 # endif
 184   union ksemun64 arg = ksemun;
 185 #else
 186   union semun arg = arg64;
 187 #endif
 188
 189   int ret = semctl_syscall (semid, semnum, cmd, arg);
 190   if (ret < 0)
 191     return ret;
 192
 193   switch (cmd)
 194     {
 195     case IPC_STAT:
 196     case SEM_STAT:
 197     case SEM_STAT_ANY:
 198 #ifdef __ASSUME_SYSVIPC_BROKEN_MODE_T
 199       arg.buf->sem_perm.mode >>= 16;
 200 #else
 201       /* Old Linux kernel versions might not clear the mode padding.  */
 202       if (sizeof ((struct semid_ds){0}.sem_perm.mode)
 203           != sizeof (__kernel_mode_t))
 204         arg.buf->sem_perm.mode &= 0xFFFF;
 205 #endif
 206
 207 #if __IPC_TIME64
 208       ksemid64_to_semid64 (arg.buf, arg64.buf);
 209 #endif
 210     }
 211
 212   return ret;
 213 }
 214 #if __TIMESIZE != 64
 215 libc_hidden_def (__semctl64)
 216
 217
 218 /* The 64-bit time_t semid_ds version might have a different layout and
 219    internal field alignment.  */
 220
 221 static void
 222 semid_to_semid64 (struct __semid64_ds *ds64, const struct semid_ds *ds)
 223 {
 224   ds64->sem_perm  = ds->sem_perm;
 225   ds64->sem_otime = ds->sem_otime
 226                     | ((__time64_t) ds->__sem_otime_high << 32);
 227   ds64->sem_ctime = ds->sem_ctime
 228                     | ((__time64_t) ds->__sem_ctime_high << 32);
 229   ds64->sem_nsems = ds->sem_nsems;
 230 }
 231
 232 static void
 233 semid64_to_semid (struct semid_ds *ds, const struct __semid64_ds *ds64)
 234 {
 235   ds->sem_perm         = ds64->sem_perm;
 236   ds->sem_otime        = ds64->sem_otime;
 237   ds->__sem_otime_high = 0;
 238   ds->sem_ctime        = ds64->sem_ctime;
 239   ds->__sem_ctime_high = 0;
 240   ds->sem_nsems        = ds64->sem_nsems;
 241 }
 242
 243 static union semun64
 244 semun_to_semun64 (int cmd, union semun semun, struct __semid64_ds *semid64)
 245 {
 246   union semun64 r = { 0 };
 247   switch (cmd)
 248     {
 249     case SETVAL:
 250       r.val = semun.val;
 251       break;
 252     case GETALL:
 253     case SETALL:
 254       r.array = semun.array;
 255       break;
 256     case SEM_STAT:
 257     case SEM_STAT_ANY:
 258     case IPC_STAT:
 259     case IPC_SET:
 260       r.buf = semid64;
 261       semid_to_semid64 (r.buf, semun.buf);
 262       break;
 263     case IPC_INFO:
 264     case SEM_INFO:
 265       r.__buf = semun.__buf;
 266       break;
 267     }
 268   return r;
 269 }
 270
 271 int
 272 __semctl (int semid, int semnum, int cmd, ...)
 273 {
 274   union semun arg = { 0 };
 275
 276   va_list ap;
 277
 278   /* Get the argument only if required.  */
 279   switch (cmd)
 280     {
 281     case SETVAL:        /* arg.val */
 282     case GETALL:        /* arg.array */
 283     case SETALL:
 284     case IPC_STAT:      /* arg.buf */
 285     case IPC_SET:
 286     case SEM_STAT:
 287     case SEM_STAT_ANY:
 288     case IPC_INFO:      /* arg.__buf */
 289     case SEM_INFO:
 290       va_start (ap, cmd);
 291       arg = va_arg (ap, union semun);
 292       va_end (ap);
 293       break;
 294     /* __semctl64 handles non-supported commands.  */
 295     }
 296
 297   struct __semid64_ds semid64;
 298   union semun64 arg64 = semun_to_semun64 (cmd, arg, &semid64);
 299
 300   int ret = __semctl64 (semid, semnum, cmd, arg64);
 301   if (ret < 0)
 302     return ret;
 303
 304   switch (cmd)
 305     {
 306     case IPC_STAT:
 307     case SEM_STAT:
 308     case SEM_STAT_ANY:
 309       semid64_to_semid (arg.buf, arg64.buf);
 310     }
 311
 312   return ret;
 313 }
 314 #endif
 315
 316 #ifndef DEFAULT_VERSION
 317 # ifndef __ASSUME_SYSVIPC_BROKEN_MODE_T
 318 #  define DEFAULT_VERSION GLIBC_2_2
 319 # else
 320 #  define DEFAULT_VERSION GLIBC_2_31
 321 # endif
 322 #endif
 323 versioned_symbol (libc, __semctl, semctl, DEFAULT_VERSION);
 324
 325 #if defined __ASSUME_SYSVIPC_BROKEN_MODE_T \
 326     && SHLIB_COMPAT (libc, GLIBC_2_2, GLIBC_2_31)
 327 int
 328 attribute_compat_text_section
 329 __semctl_mode16 (int semid, int semnum, int cmd, ...)
 330 {
 331   semctl_arg_t arg = { 0 };
 332   va_list ap;
 333
 334   /* Get the argument only if required.  */
 335   switch (cmd)
 336     {
 337     case SETVAL:        /* arg.val */
 338     case GETALL:        /* arg.array */
 339     case SETALL:
 340     case IPC_STAT:      /* arg.buf */
 341     case IPC_SET:
 342     case SEM_STAT:
 343     case SEM_STAT_ANY:
 344     case IPC_INFO:      /* arg.__buf */
 345     case SEM_INFO:
 346       va_start (ap, cmd);
 347       arg = va_arg (ap, semctl_arg_t);
 348       va_end (ap);
 349       break;
 350     }
 351
 352   return semctl_syscall (semid, semnum, cmd, arg);
 353 }
 354 compat_symbol (libc, __semctl_mode16, semctl, GLIBC_2_2);
 355 #endif
 356
 357 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
 358 /* Since semctl use a variadic argument for semid_ds there is not need to
 359    define and tie the compatibility symbol to the old 'union semun'
 360    definition.  */
 361 int
 362 attribute_compat_text_section
 363 __old_semctl (int semid, int semnum, int cmd, ...)
 364 {
 365   union semun arg = { 0 };
 366   va_list ap;
 367
 368   /* Get the argument only if required.  */
 369   switch (cmd)
 370     {
 371     case SETVAL:        /* arg.val */
 372     case GETALL:        /* arg.array */
 373     case SETALL:
 374     case IPC_STAT:      /* arg.buf */
 375     case IPC_SET:
 376     case SEM_STAT:
 377     case SEM_STAT_ANY:
 378     case IPC_INFO:      /* arg.__buf */
 379     case SEM_INFO:
 380       va_start (ap, cmd);
 381       arg = va_arg (ap, union semun);
 382       va_end (ap);
 383       break;
 384     }
 385
 386 #if defined __ASSUME_DIRECT_SYSVIPC_SYSCALLS \
 387     && !defined __ASSUME_SYSVIPC_DEFAULT_IPC_64
 388  /* For architectures that have wire-up semctl but also have __IPC_64 to a
 389     value different than default (0x0) it means the compat symbol used the
 390     __NR_ipc syscall.  */
 391   return INLINE_SYSCALL_CALL (semctl, semid, semnum, cmd, arg.array);
 392 # else
 393   return INLINE_SYSCALL_CALL (ipc, IPCOP_semctl, semid, semnum, cmd,
 394                               SEMCTL_ARG_ADDRESS (arg));
 395 # endif
 396 }
 397 compat_symbol (libc, __old_semctl, semctl, GLIBC_2_0);
 398 #endif