/*
- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
/*
* John Bellardo modified the implementation for Darwin. 12/2000
*/
+/*
+ * NOTICE: This file was modified by McAfee Research in 2004 to introduce
+ * support for mandatory and extensible security protections. This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ * Copyright (c) 2005-2006 SPARTA, Inc.
+ */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/ipcs.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>
+#if CONFIG_MACF
+#include <security/mac_framework.h>
+#endif
#include <bsm/audit_kernel.h>
+#if SYSV_SEM
+
/* Uncomment this line to see the debugging output */
/* #define SEM_DEBUG */
+/* Uncomment this line to see MAC debugging output. */
+/* #define MAC_DEBUG */
+#if CONFIG_MACF_DEBUG
+#define MPRINTF(a) printf(a)
+#else
+#define MPRINTF(a)
+#endif
+
#define M_SYSVSEM M_TEMP
};
-static struct sem_undo *semu_alloc(struct proc *p);
-static int semundo_adjust(struct proc *p, struct sem_undo **supptr,
+static int semu_alloc(struct proc *p);
+static int semundo_adjust(struct proc *p, int *supidx,
int semid, int semnum, int adjval);
static void semundo_clear(int semid, int semnum);
};
static int semtot = 0; /* # of used semaphores */
-struct user_semid_ds *sema = NULL; /* semaphore id pool */
+struct semid_kernel *sema = NULL; /* semaphore id pool */
struct sem *sem_pool = NULL; /* semaphore pool */
-static struct sem_undo *semu_list = NULL; /* active undo structures */
+static int semu_list_idx = -1; /* active undo structures */
struct sem_undo *semu = NULL; /* semaphore undo pool */
{
sysv_sem_subsys_lck_grp_attr = lck_grp_attr_alloc_init();
- lck_grp_attr_setstat(sysv_sem_subsys_lck_grp_attr);
- sysv_sem_subsys_lck_grp = lck_grp_alloc_init("sysv_shm_subsys_lock", sysv_sem_subsys_lck_grp_attr);
+ sysv_sem_subsys_lck_grp = lck_grp_alloc_init("sysv_sem_subsys_lock", sysv_sem_subsys_lck_grp_attr);
sysv_sem_subsys_lck_attr = lck_attr_alloc_init();
- lck_attr_setdebug(sysv_sem_subsys_lck_attr);
lck_mtx_init(&sysv_sem_subsys_mutex, sysv_sem_subsys_lck_grp, sysv_sem_subsys_lck_attr);
}
static int
grow_sema_array(int newSize)
{
- register struct user_semid_ds *newSema;
+ register struct semid_kernel *newSema;
register int i;
if (newSize <= seminfo.semmni)
#ifdef SEM_DEBUG
printf("growing sema[] from %d to %d\n", seminfo.semmni, newSize);
#endif
- MALLOC(newSema, struct user_semid_ds *,
- sizeof (struct user_semid_ds) * newSize,
+ MALLOC(newSema, struct semid_kernel *,
+ sizeof (struct semid_kernel) * newSize,
M_SYSVSEM, M_WAITOK | M_ZERO);
if (NULL == newSema)
{
* this with the existing code, so we wake up the
* process and let it do a lot of work to determine the
* semaphore set is really not available yet, and then
- * sleep on the correct, reallocated user_semid_ds pointer.
+ * sleep on the correct, reallocated semid_kernel pointer.
*/
- if (sema[i].sem_perm.mode & SEM_ALLOC)
+ if (sema[i].u.sem_perm.mode & SEM_ALLOC)
wakeup((caddr_t)&sema[i]);
}
+
+#if CONFIG_MACF
+ for (i = seminfo.semmni; i < newSize; i++)
+ {
+ mac_sysvsem_label_init(&newSema[i]);
+ }
+#endif
+
/*
* The new elements (from newSema[i] to newSema[newSize-1]) have their
* "sem_base" and "sem_perm.mode" set to 0 (i.e. NULL) by the M_ZERO
/* Update our id structures to point to the new semaphores */
for(i = 0; i < seminfo.semmni; i++) {
- if (sema[i].sem_perm.mode & SEM_ALLOC) /* ID in use */
- sema[i].sem_base += (new_sem_pool - sem_pool);
+ if (sema[i].u.sem_perm.mode & SEM_ALLOC) /* ID in use */
+ sema[i].u.sem_base += (new_sem_pool - sem_pool);
}
sem_free = sem_pool;
* Assumes we already hold the subsystem lock.
*/
-static struct sem_undo *
+static int
semu_alloc(struct proc *p)
{
register int i;
register struct sem_undo *suptr;
- register struct sem_undo **supptr;
+ int *supidx;
int attempt;
/*
for (i = 0; i < seminfo.semmnu; i++) {
suptr = SEMU(i);
if (suptr->un_proc == NULL) {
- suptr->un_next = semu_list;
- semu_list = suptr;
+ suptr->un_next_idx = semu_list_idx;
+ semu_list_idx = i;
suptr->un_cnt = 0;
suptr->un_ent = NULL;
suptr->un_proc = p;
- return(suptr);
+ return i;
}
}
/* All the structures are in use - try to free some */
int did_something = 0;
- supptr = &semu_list;
- while ((suptr = *supptr) != NULL) {
+ supidx = &semu_list_idx;
+ while (*supidx != -1) {
+ suptr = SEMU(*supidx);
if (suptr->un_cnt == 0) {
suptr->un_proc = NULL;
- *supptr = suptr->un_next;
+ *supidx = suptr->un_next_idx;
did_something = 1;
} else
- supptr = &(suptr->un_next);
+ supidx = &(suptr->un_next_idx);
}
/* If we didn't free anything. Try expanding
*/
if (!did_something)
if (!grow_semu_array(seminfo.semmnu + 1))
- return(NULL);
+ return -1;
} else {
/*
* The second pass failed even though we freed
panic("semu_alloc - second attempt failed");
}
}
- return (NULL);
+ return -1;
}
/*
* Assumes we already hold the subsystem lock.
*/
static int
-semundo_adjust(struct proc *p, struct sem_undo **supptr, int semid,
+semundo_adjust(struct proc *p, int *supidx, int semid,
int semnum, int adjval)
{
register struct sem_undo *suptr;
+ int suidx;
register struct undo *sueptr, **suepptr, *new_sueptr;
int i;
* Look for and remember the sem_undo if the caller doesn't provide it
*/
- suptr = *supptr;
- if (suptr == NULL) {
- for (suptr = semu_list; suptr != NULL;
- suptr = suptr->un_next) {
+ suidx = *supidx;
+ if (suidx == -1) {
+ for (suidx = semu_list_idx; suidx != -1;
+ suidx = suptr->un_next_idx) {
+ suptr = SEMU(suidx);
if (suptr->un_proc == p) {
- *supptr = suptr;
+ *supidx = suidx;
break;
}
}
- if (suptr == NULL) {
+ if (suidx == -1) {
if (adjval == 0)
return(0);
- suptr = semu_alloc(p);
- if (suptr == NULL)
+ suidx = semu_alloc(p);
+ if (suidx == -1)
return(ENOSPC);
- *supptr = suptr;
+ *supidx = suidx;
}
}
* Look for the requested entry and adjust it (delete if adjval becomes
* 0).
*/
+ suptr = SEMU(suidx);
new_sueptr = NULL;
for (i = 0, suepptr = &suptr->un_ent, sueptr = suptr->un_ent;
i < suptr->un_cnt;
semundo_clear(int semid, int semnum)
{
struct sem_undo *suptr;
+ int suidx;
- for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) {
+ for (suidx = semu_list_idx; suidx != -1; suidx = suptr->un_next_idx) {
struct undo *sueptr;
struct undo **suepptr;
int i = 0;
+ suptr = SEMU(suidx);
sueptr = suptr->un_ent;
suepptr = &suptr->un_ent;
while (i < suptr->un_cnt) {
kauth_cred_t cred = kauth_cred_get();
int i, rval, eval;
struct user_semid_ds sbuf;
- struct user_semid_ds *semaptr;
+ struct semid_kernel *semakptr;
struct user_semid_ds uds;
goto semctlout;
}
- semaptr = &sema[semid];
- if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
- semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid)) {
+ semakptr = &sema[semid];
+ if ((semakptr->u.sem_perm.mode & SEM_ALLOC) == 0 ||
+ semakptr->u.sem_perm._seq != IPCID_TO_SEQ(uap->semid)) {
eval = EINVAL;
goto semctlout;
}
+#if CONFIG_MACF
+ eval = mac_sysvsem_check_semctl(cred, semakptr, cmd);
+ if (eval)
+ goto semctlout;
+#endif
eval = 0;
rval = 0;
switch (cmd) {
case IPC_RMID:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_M)))
goto semctlout;
- semaptr->sem_perm.cuid = kauth_cred_getuid(cred);
- semaptr->sem_perm.uid = kauth_cred_getuid(cred);
- semtot -= semaptr->sem_nsems;
- for (i = semaptr->sem_base - sem_pool; i < semtot; i++)
- sem_pool[i] = sem_pool[i + semaptr->sem_nsems];
+ semakptr->u.sem_perm.cuid = kauth_cred_getuid(cred);
+ semakptr->u.sem_perm.uid = kauth_cred_getuid(cred);
+ semtot -= semakptr->u.sem_nsems;
+ for (i = semakptr->u.sem_base - sem_pool; i < semtot; i++)
+ sem_pool[i] = sem_pool[i + semakptr->u.sem_nsems];
for (i = 0; i < seminfo.semmni; i++) {
- if ((sema[i].sem_perm.mode & SEM_ALLOC) &&
- sema[i].sem_base > semaptr->sem_base)
- sema[i].sem_base -= semaptr->sem_nsems;
+ if ((sema[i].u.sem_perm.mode & SEM_ALLOC) &&
+ sema[i].u.sem_base > semakptr->u.sem_base)
+ sema[i].u.sem_base -= semakptr->u.sem_nsems;
}
- semaptr->sem_perm.mode = 0;
+ semakptr->u.sem_perm.mode = 0;
+#if CONFIG_MACF
+ mac_sysvsem_label_recycle(semakptr);
+#endif
semundo_clear(semid, -1);
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
break;
case IPC_SET:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_M)))
goto semctlout;
if (IS_64BIT_PROCESS(p)) {
goto semctlout;
}
- semaptr->sem_perm.uid = sbuf.sem_perm.uid;
- semaptr->sem_perm.gid = sbuf.sem_perm.gid;
- semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) |
- (sbuf.sem_perm.mode & 0777);
- semaptr->sem_ctime = sysv_semtime();
+ semakptr->u.sem_perm.uid = sbuf.sem_perm.uid;
+ semakptr->u.sem_perm.gid = sbuf.sem_perm.gid;
+ semakptr->u.sem_perm.mode = (semakptr->u.sem_perm.mode &
+ ~0777) | (sbuf.sem_perm.mode & 0777);
+ semakptr->u.sem_ctime = sysv_semtime();
break;
case IPC_STAT:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
- bcopy(semaptr, &uds, sizeof(struct user_semid_ds));
+ bcopy((caddr_t)&semakptr->u, &uds, sizeof(struct user_semid_ds));
if (IS_64BIT_PROCESS(p)) {
eval = copyout(&uds, user_arg.buf, sizeof(struct user_semid_ds));
} else {
break;
case GETNCNT:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
- if (semnum < 0 || semnum >= semaptr->sem_nsems) {
+ if (semnum < 0 || semnum >= semakptr->u.sem_nsems) {
eval = EINVAL;
goto semctlout;
}
- rval = semaptr->sem_base[semnum].semncnt;
+ rval = semakptr->u.sem_base[semnum].semncnt;
break;
case GETPID:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
- if (semnum < 0 || semnum >= semaptr->sem_nsems) {
+ if (semnum < 0 || semnum >= semakptr->u.sem_nsems) {
eval = EINVAL;
goto semctlout;
}
- rval = semaptr->sem_base[semnum].sempid;
+ rval = semakptr->u.sem_base[semnum].sempid;
break;
case GETVAL:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
- if (semnum < 0 || semnum >= semaptr->sem_nsems) {
+ if (semnum < 0 || semnum >= semakptr->u.sem_nsems) {
eval = EINVAL;
goto semctlout;
}
- rval = semaptr->sem_base[semnum].semval;
+ rval = semakptr->u.sem_base[semnum].semval;
break;
case GETALL:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
/* XXXXXXXXXXXXXXXX TBD XXXXXXXXXXXXXXXX */
- for (i = 0; i < semaptr->sem_nsems; i++) {
+ for (i = 0; i < semakptr->u.sem_nsems; i++) {
/* XXX could be done in one go... */
- eval = copyout((caddr_t)&semaptr->sem_base[i].semval,
+ eval = copyout((caddr_t)&semakptr->u.sem_base[i].semval,
user_arg.array + (i * sizeof(unsigned short)),
sizeof(unsigned short));
if (eval != 0)
break;
case GETZCNT:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_R)))
goto semctlout;
- if (semnum < 0 || semnum >= semaptr->sem_nsems) {
+ if (semnum < 0 || semnum >= semakptr->u.sem_nsems) {
eval = EINVAL;
goto semctlout;
}
- rval = semaptr->sem_base[semnum].semzcnt;
+ rval = semakptr->u.sem_base[semnum].semzcnt;
break;
case SETVAL:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_W)))
{
#ifdef SEM_DEBUG
printf("Invalid credentials for write\n");
#endif
goto semctlout;
}
- if (semnum < 0 || semnum >= semaptr->sem_nsems)
+ if (semnum < 0 || semnum >= semakptr->u.sem_nsems)
{
#ifdef SEM_DEBUG
printf("Invalid number out of range for set\n");
* to avoid introducing endieness and a pad field into the
* header file. Ugly, but it works.
*/
- semaptr->sem_base[semnum].semval = CAST_DOWN(int,user_arg.buf);
+ semakptr->u.sem_base[semnum].semval = CAST_DOWN(int,user_arg.buf);
+ semakptr->u.sem_base[semnum].sempid = p->p_pid;
+ /* XXX scottl Should there be a MAC call here? */
semundo_clear(semid, semnum);
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
break;
case SETALL:
- if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
+ if ((eval = ipcperm(cred, &semakptr->u.sem_perm, IPC_W)))
goto semctlout;
/*** XXXXXXXXXXXX TBD ********/
- for (i = 0; i < semaptr->sem_nsems; i++) {
+ for (i = 0; i < semakptr->u.sem_nsems; i++) {
/* XXX could be done in one go... */
eval = copyin(user_arg.array + (i * sizeof(unsigned short)),
- (caddr_t)&semaptr->sem_base[i].semval,
+ (caddr_t)&semakptr->u.sem_base[i].semval,
sizeof(unsigned short));
if (eval != 0)
break;
+ semakptr->u.sem_base[i].sempid = p->p_pid;
}
+ /* XXX scottl Should there be a MAC call here? */
semundo_clear(semid, -1);
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
break;
default:
if (key != IPC_PRIVATE) {
for (semid = 0; semid < seminfo.semmni; semid++) {
- if ((sema[semid].sem_perm.mode & SEM_ALLOC) &&
- sema[semid].sem_perm.key == key)
+ if ((sema[semid].u.sem_perm.mode & SEM_ALLOC) &&
+ sema[semid].u.sem_perm._key == key)
break;
}
if (semid < seminfo.semmni) {
#ifdef SEM_DEBUG
printf("found public key\n");
#endif
- if ((eval = ipcperm(cred, &sema[semid].sem_perm,
+ if ((eval = ipcperm(cred, &sema[semid].u.sem_perm,
semflg & 0700)))
goto semgetout;
- if (nsems < 0 || sema[semid].sem_nsems < nsems) {
+ if (nsems < 0 || sema[semid].u.sem_nsems < nsems) {
#ifdef SEM_DEBUG
printf("too small\n");
#endif
eval = EEXIST;
goto semgetout;
}
+#if CONFIG_MACF
+ eval = mac_sysvsem_check_semget(cred, &sema[semid]);
+ if (eval)
+ goto semgetout;
+#endif
goto found;
}
}
}
}
for (semid = 0; semid < seminfo.semmni; semid++) {
- if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0)
+ if ((sema[semid].u.sem_perm.mode & SEM_ALLOC) == 0)
break;
}
if (semid == seminfo.semmni) {
#ifdef SEM_DEBUG
printf("semid %d is available\n", semid);
#endif
- sema[semid].sem_perm.key = key;
- sema[semid].sem_perm.cuid = kauth_cred_getuid(cred);
- sema[semid].sem_perm.uid = kauth_cred_getuid(cred);
- sema[semid].sem_perm.cgid = cred->cr_gid;
- sema[semid].sem_perm.gid = cred->cr_gid;
- sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC;
- sema[semid].sem_perm.seq =
- (sema[semid].sem_perm.seq + 1) & 0x7fff;
- sema[semid].sem_nsems = nsems;
- sema[semid].sem_otime = 0;
- sema[semid].sem_ctime = sysv_semtime();
- sema[semid].sem_base = &sem_pool[semtot];
+ sema[semid].u.sem_perm._key = key;
+ sema[semid].u.sem_perm.cuid = kauth_cred_getuid(cred);
+ sema[semid].u.sem_perm.uid = kauth_cred_getuid(cred);
+ sema[semid].u.sem_perm.cgid = cred->cr_gid;
+ sema[semid].u.sem_perm.gid = cred->cr_gid;
+ sema[semid].u.sem_perm.mode = (semflg & 0777) | SEM_ALLOC;
+ sema[semid].u.sem_perm._seq =
+ (sema[semid].u.sem_perm._seq + 1) & 0x7fff;
+ sema[semid].u.sem_nsems = nsems;
+ sema[semid].u.sem_otime = 0;
+ sema[semid].u.sem_ctime = sysv_semtime();
+ sema[semid].u.sem_base = &sem_pool[semtot];
semtot += nsems;
- bzero(sema[semid].sem_base,
- sizeof(sema[semid].sem_base[0])*nsems);
+ bzero(sema[semid].u.sem_base,
+ sizeof(sema[semid].u.sem_base[0])*nsems);
+#if CONFIG_MACF
+ mac_sysvsem_label_associate(cred, &sema[semid]);
+#endif
#ifdef SEM_DEBUG
- printf("sembase = 0x%x, next = 0x%x\n", sema[semid].sem_base,
+ printf("sembase = 0x%x, next = 0x%x\n", sema[semid].u.sem_base,
&sem_pool[semtot]);
#endif
} else {
}
found:
- *retval = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm);
+ *retval = IXSEQ_TO_IPCID(semid, sema[semid].u.sem_perm);
AUDIT_ARG(svipc_id, *retval);
#ifdef SEM_DEBUG
printf("semget is done, returning %d\n", *retval);
int semid = uap->semid;
int nsops = uap->nsops;
struct sembuf sops[MAX_SOPS];
- register struct user_semid_ds *semaptr;
+ register struct semid_kernel *semakptr;
register struct sembuf *sopptr = NULL; /* protected by 'semptr' */
register struct sem *semptr = NULL; /* protected by 'if' */
- struct sem_undo *suptr = NULL;
+ int supidx = -1;
int i, j, eval;
int do_wakeup, do_undos;
goto semopout;
}
- semaptr = &sema[semid];
- if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0) {
+ semakptr = &sema[semid];
+ if ((semakptr->u.sem_perm.mode & SEM_ALLOC) == 0) {
eval = EINVAL;
goto semopout;
}
- if (semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid)) {
+ if (semakptr->u.sem_perm._seq != IPCID_TO_SEQ(uap->semid)) {
eval = EINVAL;
goto semopout;
}
- if ((eval = ipcperm(kauth_cred_get(), &semaptr->sem_perm, IPC_W))) {
+ if ((eval = ipcperm(kauth_cred_get(), &semakptr->u.sem_perm, IPC_W))) {
#ifdef SEM_DEBUG
printf("eval = %d from ipaccess\n", eval);
#endif
goto semopout;
}
+#if CONFIG_MACF
+ /*
+ * Initial pass thru sops to see what permissions are needed.
+ */
+ j = 0; /* permission needed */
+ for (i = 0; i < nsops; i++)
+ j |= (sops[i].sem_op == 0) ? SEM_R : SEM_A;
+
+ /*
+ * The MAC hook checks whether the thread has read (and possibly
+ * write) permissions to the semaphore array based on the
+ * sopptr->sem_op value.
+ */
+ eval = mac_sysvsem_check_semop(kauth_cred_get(), semakptr, j);
+ if (eval)
+ goto semopout;
+#endif
+
if (nsops < 0 || nsops > MAX_SOPS) {
#ifdef SEM_DEBUG
printf("too many sops (max=%d, nsops=%d)\n", MAX_SOPS, nsops);
for (i = 0; i < nsops; i++) {
sopptr = &sops[i];
- if (sopptr->sem_num >= semaptr->sem_nsems) {
+ if (sopptr->sem_num >= semakptr->u.sem_nsems) {
eval = EFBIG;
goto semopout;
}
- semptr = &semaptr->sem_base[sopptr->sem_num];
+ semptr = &semakptr->u.sem_base[sopptr->sem_num];
#ifdef SEM_DEBUG
- printf("semop: semaptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n",
- semaptr, semaptr->sem_base, semptr,
+ printf("semop: semakptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n",
+ semakptr, semakptr->u.sem_base, semptr,
sopptr->sem_num, semptr->semval, sopptr->sem_op,
(sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait");
#endif
printf("semop: rollback 0 through %d\n", i-1);
#endif
for (j = 0; j < i; j++)
- semaptr->sem_base[sops[j].sem_num].semval -=
+ semakptr->u.sem_base[sops[j].sem_num].semval -=
sops[j].sem_op;
/*
* waiting for. We will get the lock back after we
* wake up.
*/
- eval = msleep((caddr_t)semaptr, &sysv_sem_subsys_mutex , (PZERO - 4) | PCATCH,
+ eval = msleep((caddr_t)semakptr, &sysv_sem_subsys_mutex , (PZERO - 4) | PCATCH,
"semwait", 0);
#ifdef SEM_DEBUG
* structures and re-validate them.
*/
- suptr = NULL; /* sem_undo may have been reallocated */
- semaptr = &sema[semid]; /* sema may have been reallocated */
+ semptr = NULL;
/*
* Make sure that the semaphore still exists
+ *
+ * XXX POSIX: Third test this 'if' and 'EINTR' precedence may
+ * fail testing; if so, we will need to revert this code.
*/
- if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
- semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid) ||
- sopptr->sem_num >= semaptr->sem_nsems) {
+ semakptr = &sema[semid]; /* sema may have been reallocated */
+ if ((semakptr->u.sem_perm.mode & SEM_ALLOC) == 0 ||
+ semakptr->u.sem_perm._seq != IPCID_TO_SEQ(uap->semid) ||
+ sopptr->sem_num >= semakptr->u.sem_nsems) {
+ /* The man page says to return EIDRM. */
+ /* Unfortunately, BSD doesn't define that code! */
if (eval == EINTR) {
/*
* EINTR takes precedence over the fact that
* sleeping...
*/
} else {
- /*
- * The man page says to return EIDRM.
- * Unfortunately, BSD doesn't define that code!
- */
#ifdef EIDRM
eval = EIDRM;
#else
- eval = EINVAL;
+ eval = EINVAL; /* Ancient past */
#endif
}
goto semopout;
* because the sem[] may have been reallocated while
* we were sleeping, updating our sem_base pointer.
*/
- semptr = &semaptr->sem_base[sopptr->sem_num];
+ semptr = &semakptr->u.sem_base[sopptr->sem_num];
if (sopptr->sem_op == 0)
semptr->semzcnt--;
else
adjval = sops[i].sem_op;
if (adjval == 0)
continue;
- eval = semundo_adjust(p, &suptr, semid,
+ eval = semundo_adjust(p, &supidx, semid,
sops[i].sem_num, -adjval);
if (eval == 0)
continue;
adjval = sops[j].sem_op;
if (adjval == 0)
continue;
- if (semundo_adjust(p, &suptr, semid,
+ if (semundo_adjust(p, &supidx, semid,
sops[j].sem_num, adjval) != 0)
panic("semop - can't undo undos");
}
for (j = 0; j < nsops; j++)
- semaptr->sem_base[sops[j].sem_num].semval -=
+ semakptr->u.sem_base[sops[j].sem_num].semval -=
sops[j].sem_op;
#ifdef SEM_DEBUG
/* We're definitely done - set the sempid's */
for (i = 0; i < nsops; i++) {
sopptr = &sops[i];
- semptr = &semaptr->sem_base[sopptr->sem_num];
+ semptr = &semakptr->u.sem_base[sopptr->sem_num];
semptr->sempid = p->p_pid;
}
+ semakptr->u.sem_otime = sysv_semtime();
if (do_wakeup) {
#ifdef SEM_DEBUG
printf("semop: doing wakeup\n");
#ifdef SEM_WAKEUP
- sem_wakeup((caddr_t)semaptr);
+ sem_wakeup((caddr_t)semakptr);
#else
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
#endif
printf("semop: back from wakeup\n");
#else
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
#endif
}
#ifdef SEM_DEBUG
void
semexit(struct proc *p)
{
- register struct sem_undo *suptr;
- register struct sem_undo **supptr;
+ register struct sem_undo *suptr = NULL;
+ int suidx;
+ int *supidx;
int did_something;
/* If we have not allocated our semaphores yet there can't be
* associated with this process.
*/
- for (supptr = &semu_list; (suptr = *supptr) != NULL;
- supptr = &suptr->un_next) {
+ for (supidx = &semu_list_idx; (suidx = *supidx) != -1;
+ supidx = &suptr->un_next_idx) {
+ suptr = SEMU(suidx);
if (suptr->un_proc == p)
break;
}
- if (suptr == NULL)
+ if (suidx == -1)
goto unlock;
#ifdef SEM_DEBUG
int semid;
int semnum;
int adjval;
- struct user_semid_ds *semaptr;
+ struct semid_kernel *semakptr;
sueptr = suptr->un_ent;
semid = sueptr->une_id;
semnum = sueptr->une_num;
adjval = sueptr->une_adjval;
- semaptr = &sema[semid];
- if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0)
+ semakptr = &sema[semid];
+ if ((semakptr->u.sem_perm.mode & SEM_ALLOC) == 0)
panic("semexit - semid not allocated");
- if (semnum >= semaptr->sem_nsems)
+ if (semnum >= semakptr->u.sem_nsems)
panic("semexit - semnum out of range");
#ifdef SEM_DEBUG
semid,
semnum,
adjval,
- semaptr->sem_base[semnum].semval);
+ semakptr->u.sem_base[semnum].semval);
#endif
if (adjval < 0) {
- if (semaptr->sem_base[semnum].semval < -adjval)
- semaptr->sem_base[semnum].semval = 0;
+ if (semakptr->u.sem_base[semnum].semval < -adjval)
+ semakptr->u.sem_base[semnum].semval = 0;
else
- semaptr->sem_base[semnum].semval +=
+ semakptr->u.sem_base[semnum].semval +=
adjval;
} else
- semaptr->sem_base[semnum].semval += adjval;
+ semakptr->u.sem_base[semnum].semval += adjval;
- /* Maybe we should build a list of semaptr's to wake
+ /* Maybe we should build a list of semakptr's to wake
* up, finish all access to data structures, release the
* subsystem lock, and wake all the processes. Something
* to think about. It wouldn't buy us anything unless
* in the BSD code at once.
*/
#ifdef SEM_WAKEUP
- sem_wakeup((caddr_t)semaptr);
+ sem_wakeup((caddr_t)semakptr);
#else
- wakeup((caddr_t)semaptr);
+ wakeup((caddr_t)semakptr);
#endif
#ifdef SEM_DEBUG
printf("semexit: back from wakeup\n");
printf("removing vector\n");
#endif
suptr->un_proc = NULL;
- *supptr = suptr->un_next;
+ *supidx = suptr->un_next_idx;
unlock:
/*
if ((sem_pool == NULL) &&
(sema == NULL) &&
(semu == NULL) &&
- (semu_list == NULL)) {
+ (semu_list_idx == -1)) {
if ((error = SYSCTL_IN(req, arg1, sizeof(int)))) {
goto out;
}
/* SYSCTL_NODE(_kern, KERN_SYSV, sysv, CTLFLAG_RW, 0, "SYSV"); */
extern struct sysctl_oid_list sysctl__kern_sysv_children;
-SYSCTL_PROC(_kern_sysv, KSYSV_SEMMNI, semmni, CTLTYPE_INT | CTLFLAG_RW,
+SYSCTL_PROC(_kern_sysv, OID_AUTO, semmni, CTLTYPE_INT | CTLFLAG_RW,
&limitseminfo.semmni, 0, &sysctl_seminfo ,"I","semmni");
-SYSCTL_PROC(_kern_sysv, KSYSV_SEMMNS, semmns, CTLTYPE_INT | CTLFLAG_RW,
+SYSCTL_PROC(_kern_sysv, OID_AUTO, semmns, CTLTYPE_INT | CTLFLAG_RW,
&limitseminfo.semmns, 0, &sysctl_seminfo ,"I","semmns");
-SYSCTL_PROC(_kern_sysv, KSYSV_SEMMNU, semmnu, CTLTYPE_INT | CTLFLAG_RW,
+SYSCTL_PROC(_kern_sysv, OID_AUTO, semmnu, CTLTYPE_INT | CTLFLAG_RW,
&limitseminfo.semmnu, 0, &sysctl_seminfo ,"I","semmnu");
-SYSCTL_PROC(_kern_sysv, KSYSV_SEMMSL, semmsl, CTLTYPE_INT | CTLFLAG_RW,
+SYSCTL_PROC(_kern_sysv, OID_AUTO, semmsl, CTLTYPE_INT | CTLFLAG_RW,
&limitseminfo.semmsl, 0, &sysctl_seminfo ,"I","semmsl");
-SYSCTL_PROC(_kern_sysv, KSYSV_SEMUNE, semume, CTLTYPE_INT | CTLFLAG_RW,
+SYSCTL_PROC(_kern_sysv, OID_AUTO, semume, CTLTYPE_INT | CTLFLAG_RW,
&limitseminfo.semume, 0, &sysctl_seminfo ,"I","semume");
size_t semid_ds_sz = sizeof(struct user_semid_ds);
struct proc *p = current_proc();
+ if (!IS_64BIT_PROCESS(p)) {
+ ipcs_sz = sizeof(struct IPCS_command);
+ semid_ds_sz = sizeof(struct semid_ds);
+ }
+
/* Copy in the command structure */
if ((error = SYSCTL_IN(req, &ipcs, ipcs_sz)) != 0) {
return(error);
}
- if (!IS_64BIT_PROCESS(p)) {
- ipcs_sz = sizeof(struct IPCS_command);
- semid_ds_sz = sizeof(struct semid_ds);
- }
+ if (!IS_64BIT_PROCESS(p)) /* convert in place */
+ ipcs.u64.ipcs_data = CAST_USER_ADDR_T(ipcs.u32.ipcs_data);
/* Let us version this interface... */
if (ipcs.u64.ipcs_magic != IPCS_MAGIC) {
break;
}
for( ; cursor < seminfo.semmni; cursor++) {
- if (sema[cursor].sem_perm.mode & SEM_ALLOC)
+ if (sema[cursor].u.sem_perm.mode & SEM_ALLOC)
break;
continue;
}
break;
}
- semid_dsp = &sema[cursor]; /* default: 64 bit */
+ semid_dsp = &sema[cursor].u; /* default: 64 bit */
/*
* If necessary, convert the 64 bit kernel segment
0, 0, IPCS_sem_sysctl,
"S,IPCS_sem_command",
"ipcs sem command interface");
+
+#endif /* SYSV_SEM */
projects / apple / xnu.git / blobdiff