/*
 * Copyright (C) 1998 by the Board of Trustees
 *    of Leland Stanford Junior University.
 * Copyright (C) 1998 Digital Equipment Corporation
 *
 * This file is part of the SimOS distribution.
 * See LICENSE file for terms of the license.
 *
 */


/*
 * Routines for supporting System V semaphores and shared memory.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>   
#include <sys/shm.h>
#include <errno.h>

#include "gamma.h"
#include "opcodes.h"
#include "globals.h"
#include "ipc.h"
#include "task.h"
#include "protos.h"
#include "alpha_regs.h"
#include "sim_error.h"
#include "aint.h"
#ifdef ITRACE
extern FILE *itrace;
#endif


#define _arg1 16
#define _arg2 17
#define _arg3 18
#define _arg4 19
#define _arg5 20
#define _arg6 21



static struct sysv_semid_ds sem_set[MAX_SEMASET];
int shm_max_inuse = -1;

static void alloc_semset (struct sysv_semid_ds *, int, int, int);
static void free_semset (struct sysv_semid_ds *);


/* Support for semaphores */

/*
 * int semget (
 *         key_t key,
 *         int nsems,
 *	   int semflg );
 */
SyscallStatus aint_semget( thread_ptr pthread)
{
    int key, nsems, flags;
    int i;

    key = pthread->st.reg[_arg1];
    nsems = pthread->st.reg[_arg2];
    flags = pthread->st.reg[_arg3];

    if (key == 0) {
	/* search for a free slot */
	for (i = 0; i < MAX_SEMASET; i++)
	    if (sem_set[i].inuse == 0)
		break;

	/* out of semaphore sets, return an error */
	if (i == MAX_SEMASET) {
	    pthread->st.reg[REG_V0] = -1;
	    *pthread->perrno = ENOSPC;
	    pthread->st.reg[_arg4] = ENOSPC;
	    return SYSCALL_NEXT;
	}

	/* found a free slot */
	alloc_semset (&sem_set[i], key, nsems, pthread->pid);

	/* return the semid */
	pthread->st.reg[REG_V0] = i;
	pthread->st.reg[_arg4] = 0;
	return SYSCALL_NEXT;
    }

    /* search for a matching key */
    for (i = 0; i < MAX_SEMASET; i++)
	if (sem_set[i].sem_perm.key == key)
	    break;
    if (sem_set[i].sem_perm.key == key) {
	/* if they wanted a new exclusive semaphore, then it's an error */
	if ((flags & (IPC_EXCL | IPC_CREAT)) == (IPC_EXCL | IPC_CREAT)) {
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = *pthread->perrno = EEXIST;
	    return SYSCALL_NEXT;
	}
	/* return the semid */
	pthread->st.reg[REG_V0] = i;
	pthread->st.reg[_arg4] = 0;
	return SYSCALL_NEXT;
    }

    /* semid matching key not found */
    if (flags & IPC_CREAT) {
	/* search for a free slot */
	for (i = 0; i < MAX_SEMASET; i++)
	    if (sem_set[i].inuse == 0)
		break;

	/* out of semaphore sets, return an error */
	if (i == MAX_SEMASET) {
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = *pthread->perrno = ENOSPC;
	    return SYSCALL_NEXT;
	}

	/* found a free slot */
	alloc_semset (&sem_set[i], key, nsems, pthread->pid);

	/* return the semid */
	pthread->st.reg[REG_V0] = i;
	pthread->st.reg[_arg4] = 0;
	return SYSCALL_NEXT;
    }

    /* no match and IPC_CREAT not set, so it's an error */
    pthread->st.reg[REG_V0] = -1;
    pthread->st.reg[_arg4] = *pthread->perrno = ENOENT;
    return SYSCALL_NEXT;
}

static void
alloc_semset (struct sysv_semid_ds *psemset, int key, int nsems, int pid)
{
    int i;
    struct sysv_sem *psem;

    psemset->inuse = 1;
    psemset->sem_perm.key = key;
    psemset->sem_nsems = nsems;
    psem = (struct sysv_sem *) malloc (nsems * sizeof (struct sysv_sem));
    if (psem == NULL)
	fatal ("alloc_semset: cannot allocate 0x%x bytes for semaphores.\n",
	       nsems * sizeof (struct sysv_sem));
    psemset->sem_base = psem;

    for (i = 0; i < nsems; i++) {
	psem[i].semval = 0;
	psem[i].sempid = pid;
	psem[i].semncnt = 0;
	psem[i].semzcnt = 0;
	INLINE_INIT_Q (&psem[i].nwait_q);
	INLINE_INIT_Q (&psem[i].zwait_q);
    }
}

static void
free_semset (struct sysv_semid_ds *psemset)
{
    psemset->inuse = 0;
    psemset->sem_perm.key = 0;
    free (psemset->sem_base);
}

void
semcpin (struct sysv_semid_ds *psemset, struct sysv_semid_ds *buf)
{
    int mode;

    psemset->sem_perm.uid = buf->sem_perm.uid;
    psemset->sem_perm.gid = buf->sem_perm.gid;

    mode = buf->sem_perm.mode & 0777;
    psemset->sem_perm.mode = (psemset->sem_perm.mode & ~0777) | mode;
}

void
semcpout (struct sysv_semid_ds *buf, struct sysv_semid_ds *psemset)
{
    buf->sem_perm.uid = psemset->sem_perm.uid;
    buf->sem_perm.gid = psemset->sem_perm.gid;
    buf->sem_perm.cuid = psemset->sem_perm.cuid;
    buf->sem_perm.cgid = psemset->sem_perm.cgid;
    buf->sem_perm.mode = psemset->sem_perm.mode & 0777;
    buf->sem_perm.seq = psemset->sem_perm.seq;
    buf->sem_perm.key = psemset->sem_perm.key;
    buf->sem_nsems = psemset->sem_nsems;
    buf->sem_otime = psemset->sem_otime;
    buf->sem_ctime = psemset->sem_ctime;
}

/*
 * int semop(
 *   int semid,
 *   struct sembuf *sops,
 *   u_int nsops);
 */
SyscallStatus aint_semop( thread_ptr pthread)
{
    int i, sem_num, sem_op, sem_flg;
    int semid, r5, nsops;
    struct sembuf *sops;
    struct sysv_semid_ds *psemset;
    struct sysv_sem *psem;
    thread_ptr pthr, tnext;
    aint_time_t duration;
    event_ptr pevent;

    semid = pthread->st.reg[_arg1];
    r5 = pthread->st.reg[_arg2];
    nsops = pthread->st.reg[_arg3];

    sops = (struct sembuf *) (long) MAP (r5);
    psemset = &sem_set[semid];

    /*
     * First loop through all the semaphores to check that all requested
     * operations can be performed.
     */
    for (i = 0; i < nsops; i++) {
	sem_num = sops[i].sem_num;
	sem_op = sops[i].sem_op;
	sem_flg = sops[i].sem_flg;
	if (sem_flg & SEM_UNDO)
	    fatal ("mint_semop: SEM_UNDO not supported yet.\n");
	psem = &psemset->sem_base[sem_num];
	if (sem_op < 0) {
	    if (psem->semval < -sem_op) {
		if (sem_flg & IPC_NOWAIT) {
		    pthread->st.reg[REG_V0] = -1;
		    pthread->st.reg[_arg4] = *pthread->perrno = EAGAIN;
		    return SYSCALL_NEXT;
		}
		/* need to suspend this process */
		pthread->semval = -sem_op;
		psem->semncnt++;
		event_block (pthread, E_PSEMA_ATTEMPT);
		block_thr ( (thread_ptr) &psem->nwait_q, pthread);
		/* return to this routine to try the semaphores again */
		return SYSCALL_SAME;
	    }
	}
	else if (sem_op == 0) {
	    if (psem->semval) {
		if (sem_flg & IPC_NOWAIT) {
		    pthread->st.reg[REG_V0] = -1;
		    pthread->st.reg[_arg4] = *pthread->perrno = EAGAIN;
		    return SYSCALL_NEXT;
		}
		/* need to suspend this process */
		psem->semzcnt++;
		event_block (pthread, E_PSEMA_ATTEMPT);
		block_thr ( (thread_ptr) &psem->zwait_q, pthread);
		/* return to this routine to try the semaphores again */
		return SYSCALL_SAME;
	    }
	}
    }

    /*
     * Loop through the operations again, this time performing them,
     * since we know that none will block.
     */
    for (i = 0; i < nsops; i++) {
	sem_num = sops[i].sem_num;
	sem_op = sops[i].sem_op;
	sem_flg = sops[i].sem_flg;
	psem = &psemset->sem_base[sem_num];
	/* need to check for blocked processes */
	if (sem_op < 0)
	    psem->semval += sem_op;
	else if (sem_op > 0) {
	    psem->semval += sem_op;
	    /*
	     * If there are processes waiting for this semaphore,
	     * we need to check if they should be awakened.
	     */
	    if (psem->semval > 0 && psem->semncnt) {
		/*
		 * Wake up everyone waiting for this to be large enough.
		 * We don't know who will be able to proceed since they
		 * may have to atomically change other semaphores, so we
		 * wake them all up and let them fight it out.
		 */
		pthr = (thread_ptr) psem->nwait_q.next;
		while (pthr != (thread_ptr) & psem->nwait_q) {
		    tnext = (thread_ptr) pthr->next;
		    if (pthr->runstate != R_BLOCK)
			fatal ("mint_semop: runstate (%d) "
			       "not R_BLOCK for thread %d\n",
			       pthr->runstate, pthr->pid);
		    if (psem->semval >= pthr->semval) {
			/* wake up this thread */
			wakeup_thr (pthr);
#ifdef SOLO
			ASSERT(0); duration = 1;
#else
			duration = pthread->time + picode->cycles - pthr->time;
			if (duration < 0)
			    fatal ("mint_usvsema: negative wait "
				   "duration (%.1f) at time %.0f\n",
				   duration, pthread->time + picode->cycles);
			pthr->time += duration;
			pevent = event_unblock_list (pthread, pthr);
			pevent->duration = duration;
			pevent->utype = E_PSEMA_ATTEMPT;
			psem->semncnt--;
#endif

		    }
		    pthr = tnext;
		}
	    }
	}

	/*
	 * If this semaphore is now zero, and there are waiting processes,
	 * then wake them up.
	 */
	if (psem->semval == 0 || psem->semzcnt) {
	    /* wake up everyone waiting for this to be zero */
	    for (i = 0; i < psem->semzcnt; i++) {
		pthr = unblock_thr ((thread_ptr) & psem->zwait_q);
#ifdef SOLO
		ASSERT(0); duration = 1;
#else
		duration = pthread->time + picode->cycles - pthr->time;
		if (duration < 0)
		    fatal ("mint_usvsema: negative wait "
			   "duration (%.1f) at time %.0f\n",
			   duration, pthread->time + picode->cycles);
		pthr->time += duration;
		pevent = event_unblock_list (pthread, pthr);
		pevent->duration = duration;
		pevent->utype = E_PSEMA_ATTEMPT;
#endif

	    }
	    psem->semzcnt = 0;
	}
    }

    pthread->st.reg[_arg4] = pthread->st.reg[REG_V0] = 0;
    return SYSCALL_NEXT;
}

/*
 *  int semctl(
 *	    int semid,
 *	    int semnum,
 *	    int cmd,
 *	    union semun {
 *		    int val;
 *		    struct semid_ds *buf;
 *		    u_short *array;
 *	    } arg );
 */
SyscallStatus aint_semctl( thread_ptr pthread)
{
    int i;
    int semid, semnum, cmd;
    long arg;			/* really "union semun" */
    ushort *array;
    struct semid_ds *axpbuf;
    struct sysv_semid_ds *buf;
    struct sysv_semid_ds *psemset;
    struct sysv_sem *psem;

    semid = pthread->st.reg[_arg1];
    semnum = pthread->st.reg[_arg2];
    cmd = pthread->st.reg[_arg3];
    arg = pthread->st.reg[_arg4];

    /* check for invalid semid */
    if (semid >= MAX_SEMASET || sem_set[semid].inuse == 0) {
	pthread->st.reg[REG_V0] = -1;
	pthread->st.reg[_arg4] = *pthread->perrno = EINVAL;
	return SYSCALL_NEXT;
    }
    psemset = &sem_set[semid];
    if (semnum < 0 || semnum >= psemset->sem_nsems) {
	pthread->st.reg[REG_V0] = -1;
	pthread->st.reg[_arg4] = *pthread->perrno = EINVAL;
	return SYSCALL_NEXT;
    }
    psem = &psemset->sem_base[semnum];

    switch (cmd) {
	case GETVAL:
	    pthread->st.reg[REG_V0] = psem->semval;
	    pthread->st.reg[_arg4] = 0;
	    break;
	case SETVAL:
	    psem->semval = (int) arg;
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	case GETPID:
	    pthread->st.reg[REG_V0] = psem->sempid;
	    pthread->st.reg[_arg4] = 0;
	    break;
	case GETNCNT:
	    pthread->st.reg[REG_V0] = psem->semncnt;
	    pthread->st.reg[_arg4] = 0;
	    break;
	case GETZCNT:
	    pthread->st.reg[REG_V0] = psem->semzcnt;
	    break;
	case GETALL:
	    array = (ushort *) (long) MAP (arg);
	    for (i = 0; i < psemset->sem_nsems; i++)
		array[i] = psemset->sem_base[i].semval;
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	case SETALL:
	    array = (ushort *) (long) MAP (arg);
	    for (i = 0; i < psemset->sem_nsems; i++)
		psemset->sem_base[i].semval = array[i];
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	case IPC_STAT:
	    buf = (struct sysv_semid_ds *) (long) MAP (arg);
	    semcpout (buf, psemset);
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	case IPC_SET:
	    buf = (struct sysv_semid_ds *) (long) MAP (arg);
	    semcpin (psemset, buf);
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	case IPC_RMID:
	    /*
	     * Need to check here if any process is blocked on a semaphore
	     * in this set.
	     */
	    free_semset (psemset);
	    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;
	    break;
	default:
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = *pthread->perrno = EINVAL;
	    break;
    }

    return SYSCALL_NEXT;
}

/* Support for shared memory */

/*
 * int shmget (
 *	  key_t	key,
 *	  size_t size,
 *	  int flags );
 */
SyscallStatus aint_shmget( thread_ptr pthread)
{
    int i;
    key_t key;
    size_t size;
    int flags;

    key = pthread->st.reg[_arg1];
    size = pthread->st.reg[_arg2];
    flags = pthread->st.reg[_arg3];

#ifdef DEBUG
    fprintf(stderr, "%d: shmget: key = %lx, size = %lx, flags = %x\n",
	    pthread->pid,
	    key, size, flags);
#endif
    
    /* round size up to a page boundary */
    size = (size + TB_PAGESIZE - 1) & ~(TB_PAGESIZE - 1);

    /* If a non-zero key was specified, then we have to search for a
     * segment with a matching key.
     */
    if (key) {
	/* search for a matching key */
	for (i = 0; i < MAX_SHMSEG; i++) {
	    if (shm_seg[i].shm_perm.key == key) {
		/* If this process requested a new exclusive copy,
		 * then it's an error.
		 */
		if ((flags & (IPC_EXCL | IPC_CREAT))
		    == (IPC_EXCL | IPC_CREAT)) {
		    /* return an error */
#ifdef DEBUG
		    fprintf(stderr, "aint_shmget: Requesting a new exclusive"
			    " copy of a segment in use\n");
#endif
		    pthread->st.reg[REG_V0] = -1;
		    pthread->st.reg[_arg4] = *pthread->perrno = EEXIST;
		    return SYSCALL_NEXT;
		}
		else {
		    /* return the shmid */
		    pthread->st.reg[REG_V0] = i;
		    pthread->st.reg[_arg4] = 0;
		    return SYSCALL_NEXT;
		}
	    }
	}

	/* if we get here then we did not find a matching key */
	if ((flags & IPC_CREAT) == 0) {
#ifdef DEBUG
	    fprintf(stderr, "aint_shmget: Key %d not found and IPC_CREAT not"
		    " specified\n", key);
	    fprintf(stderr, "flags: %x\n", flags);
#endif
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = *pthread->perrno = ENOENT;
	    return SYSCALL_NEXT;
	}
    }

    /* search for an unused shmid */
    for (i = 0; i < MAX_SHMSEG; i++)
	if (shm_seg[i].inuse == 0)
	    break;

    /* Out of shared memory segments, return an error */
    if (i == MAX_SHMSEG) {

#ifdef DEBUG
	fprintf(stderr, "aint_shmget: No more shared memory segments\n");
#endif
	pthread->st.reg[REG_V0] = -1;
	pthread->st.reg[_arg4] = *pthread->perrno = ENOSPC;
	return SYSCALL_NEXT;
    }
    /* the return value is the shmid */
    pthread->st.reg[REG_V0] = i;
    pthread->st.reg[_arg4] = 0;

    if (i > shm_max_inuse)
	shm_max_inuse = i;

    /* make sure there is enough space */
    if (shmem_end + size > shmem_start + shmem_size)
	fatal ("aint_shmget: not enough shared memory "
	       "(requested size = 0x%x, used = 0x%x)\n",
	       size, shmem_end - shmem_start);

    /* initialize the shared memory segment */

    shm_seg[i].addr = shmem_end;
    shm_seg[i].size = size;
    shm_seg[i].inuse = 1;
    shm_seg[i].shm_perm.key = key;

    /* Update size of used shared-space */
    shmem_end += size;

    return SYSCALL_NEXT;
}

/*
 * void *shmat(
 *	  int shmid,
 *	  void *shmaddr,
 *	  int shmflg);
 */
SyscallStatus aint_shmat( thread_ptr pthread)
{
    int shmid, flags;
    int id, size;
    long addr, real_addr;
    struct shm_descriptor *new_shm_ds;

    shmid = pthread->st.reg[_arg1];
    addr = pthread->st.reg[_arg2];
    flags = pthread->st.reg[_arg3];

#ifdef DEBUG
    fprintf(stderr, "%d: shmat: shmid = %lx, addr = %lx, flags = %x\n",
	    pthread->pid,
	    shmid, addr, flags);
#endif

    /* check that the shmid is a valid index */
    if ((shmid < 0) || (shmid > MAX_SHMSEG)) {

#ifdef DEBUG
	fprintf(stderr, "aint_shmat: Invalid shmid\n");
#endif
	pthread->st.reg[REG_V0] = -1;
	pthread->st.reg[_arg4] = *pthread->perrno = EINVAL;
	return SYSCALL_NEXT;
    }

    /* check that this shared memory segment has been allocated */
    if (shm_seg[shmid].inuse == 0) {

#ifdef DEBUG
	fprintf(stderr, "aint_shmat: Segment has not been allocated\n");
#endif	
	pthread->st.reg[REG_V0] = -1;
	pthread->st.reg[_arg4] = *pthread->perrno = EINVAL;
	return SYSCALL_NEXT;
    }

    size = shm_seg[shmid].size;

    /*
     * If addr is zero, get the next valid addr: unsp_shmat_current upto
     * unsp_shmat_current+size
     */ 
    if (addr == 0) {
	addr = pthread->unsp_shmat_current;
	pthread->unsp_shmat_current += ALIGN(size, TB_PAGESIZE);
	if (pthread->unsp_shmat_current >= UNSP_SHMAT_END) {
	    /* Cannot attach - full */

#ifdef DEBUG
	    fprintf(stderr, "aint_shmat: Address space full\n");
#endif	    
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = *pthread->perrno = ENOMEM;
	    return SYSCALL_NEXT;
	}
	/* Plug in the address in the per-process table */
	new_shm_ds = (struct shm_descriptor *)
	    malloc (sizeof (struct shm_descriptor));
	new_shm_ds->shmid = shmid;
	new_shm_ds->size = size;
	new_shm_ds->addr = addr;
	/* Enter new_shm_ds in the per-process shared-region descriptor */
	new_shm_ds->next = pthread->shmem_regions;
	pthread->shmem_regions = new_shm_ds;

	/* return values */
	pthread->st.reg[REG_V0] = addr;
	pthread->st.reg[_arg4] = 0;

	return SYSCALL_NEXT;
    }
    else {
	/*
	 * If the address was specified, it should be within SP_SHMAT_START
         * and SP_SHMAT_END
	 */
	addr = (addr + TB_PAGESIZE - 1) & ~(TB_PAGESIZE - 1);
	if ((addr < SP_SHMAT_START) || ((addr + size) >= SP_SHMAT_END)) {
#ifdef DEBUG
	    fprintf(stderr, "aint_shmat: Address specified, %ld,"
		    " not in the correct range\n", addr);
#endif
	    
	    pthread->st.reg[REG_V0] = -1;
	    pthread->st.reg[_arg4] = EINVAL;
	    return SYSCALL_NEXT;
	}
    }
    /* Address is valid. Allocate a per-process shared-region descriptor */
    new_shm_ds = (struct shm_descriptor *)
	malloc (sizeof (struct shm_descriptor));
    new_shm_ds->shmid = shmid;
    new_shm_ds->size = size;
    new_shm_ds->addr = addr;
    new_shm_ds->next = pthread->shmem_regions;
    pthread->shmem_regions = new_shm_ds;

    /* return values */
    pthread->st.reg[REG_V0] = addr;
    pthread->st.reg[_arg4] = 0;

    return SYSCALL_NEXT;
}


/*
 * int shmdt(
 *	  const	void *addr);
 *
 */
SyscallStatus aint_shmdt( thread_ptr pthread)
{
    struct shm_descriptor *sd, *last;
    ulong addr = pthread->st.reg[_arg1];
    size_t size;
    ulong num_pages;
    int i;
    
#ifdef DEBUG
    fprintf(stderr, "%d: shmdt: addr = %lx\n",
	    pthread->pid,
	    pthread->st.reg[_arg1]);
#endif
    
    /* first locate the descriptor corresponding to the region */
    sd = last = pthread->shmem_regions;

    /* while there are more descriptors */
    while(sd) {
	if (sd->addr == addr)
	    break;

	/* traverse the list */
	last = sd;
	sd = sd->next;
    }

    if (sd->addr != addr) {
	/* didn't find a shmem region at the specified address */
	pthread->st.reg[REG_V0] = -1;
#ifdef DEBUG
	fprintf(stderr, "shmdt: no shmem region at %lx\n", addr);
#endif
    }

    /* note the size down */
    size = sd->size;
    
    /* now remove the descriptor from the list */
    if (sd == last) {
	/* it was the first element */
	pthread->shmem_regions = sd->next;
	/* free the node */
	free(sd);
    }

    /* unmap all the pages */
    
    /* round up the length to the next multiple of the page size */
    num_pages = size / TB_PAGESIZE;

    for ( i=0; i < num_pages ; i++) {
	page_unmap(pthread, addr + i * TB_PAGESIZE);
    }

    /* all clear */
    pthread->st.reg[REG_V0] = pthread->st.reg[_arg4] = 0;

    return SYSCALL_NEXT;
}

/*
 * int shmctl(
 *	  int shmid,
 *	  int cmd,
 *	  struct shmid_ds *buf);
 *
 * Does nothing right now.
 */
SyscallStatus aint_shmctl( thread_ptr pthread)
{
    pthread->st.reg[_arg4] = pthread->st.reg[REG_V0] = 0;
    return SYSCALL_NEXT;
}