Colony

/*

   +----------------------------------------------------------------------+

   | PHP Version 5                                                        |

   +----------------------------------------------------------------------+

   | Copyright (c) 1997-2008 The PHP Group                                |

   +----------------------------------------------------------------------+

   | This source file is subject to version 3.01 of the PHP license,      |

   | that is bundled with this package in the file LICENSE, and is        |

   | available through the world-wide-web at the following url:           |

   | http://www.php.net/license/3_01.txt                                  |

   | If you did not receive a copy of the PHP license and are unable to   |

   | obtain it through the world-wide-web, please send a note to          |

   | license@php.net so we can mail you a copy immediately.               |

   +----------------------------------------------------------------------+

   | Authors: Tom May <tom@go2net.com>                                    |

   |          Gavin Sherry <gavin@linuxworld.com.au>                      |

   +----------------------------------------------------------------------+

 */

/* $Id: sysvsem.c,v 1.51.2.3.2.3 2007/12/31 07:20:13 sebastian Exp $ */

/* Latest update build anc tested on Linux 2.2.14

 *

 * This has been built and tested on Solaris 2.6 and Linux 2.1.122.

 * It may not compile or execute correctly on other systems.

 *

 * sas: Works for me on Linux 2.0.36 and FreeBSD 3.0-current

 */

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

#include <errno.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <php/main/php_config.h>

#include "php_sysvsem.h"

#if !HAVE_SEMUN

union semun {

        int val;                    /* value for SETVAL */

        struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */

        unsigned short int *array;  /* array for GETALL, SETALL */

        struct seminfo *__buf;      /* buffer for IPC_INFO */

};

#undef HAVE_SEMUN

#define HAVE_SEMUN 1

#endif

/* Semaphore functions using System V semaphores.  Each semaphore

 * actually consists of three semaphores allocated as a unit under the

 * same key.  Semaphore 0 (SYSVSEM_SEM) is the actual semaphore, it is

 * initialized to max_acquire and decremented as processes acquire it.

 * The value of semaphore 1 (SYSVSEM_USAGE) is a count of the number

 * of processes using the semaphore.  After calling semget(), if a

 * process finds that the usage count is 1, it will set the value of

 * SYSVSEM_SEM to max_acquire.  This allows max_acquire to be set and

 * track the PHP code without having a global init routine or external

 * semaphore init code.  Except see the bug regarding a race condition

 * php_sysvsem_get().  Semaphore 2 (SYSVSEM_SETVAL) serializes the

 * calls to GETVAL SYSVSEM_USAGE and SETVAL SYSVSEM_SEM.  It can be

 * acquired only when it is zero.

 */

#define SYSVSEM_SEM                0

#define SYSVSEM_USAGE        1

#define SYSVSEM_SETVAL        2

/* {{{ release_sysvsem_sem

 */

sysvsem::~sysvsem()

{

        struct sembuf sop[2];

        int opcount = 1;

        /* Decrement the usage count. */

        sop[0].sem_num = SYSVSEM_USAGE;

        sop[0].sem_op  = -1;

        sop[0].sem_flg = SEM_UNDO;

        /* Release the semaphore if it has been acquired but not released. */

        if (this->count) {

                sop[1].sem_num = SYSVSEM_SEM;

                sop[1].sem_op  = this->count;

                sop[1].sem_flg = SEM_UNDO;

                opcount++;

        }

        semop(this->semid, sop, opcount);

        //TODO: Need to auto remove() semaphore when SYSVSEM_USAGE is 0

        //efree(sem_ptr);

}

/* }}} */

#define SETVAL_WANTS_PTR

#if defined(_AIX)

#undef SETVAL_WANTS_PTR

#endif

/* {{{ proto resource sem_get(int key [, int max_acquire [, int perm [, int auto_release]])

         Return an id for the semaphore with the given key, and allow max_acquire (default 1) processes to acquire it simultaneously */

/*  max_aquire = 1, perm = 0666, auto_release = 1 */

sysvsem::sysvsem(long key, long max_acquire, long perm, long auto_release) throw (sysvsem_error)

{

        int semid;

        struct sembuf sop[3];

        int count;

        /* Get/create the semaphore.  Note that we rely on the semaphores

         * being zeroed when they are created.  Despite the fact that

         * the(?)  Linux semget() man page says they are not initialized,

         * the kernel versions 2.0.x and 2.1.z do in fact zero them.

         */

        semid = semget(key, 3, perm|IPC_CREAT);

        if (semid == -1) {

                fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                throw sysvsem_error("failed to open semaphore");

        }

        /* Find out how many processes are using this semaphore.  Note

         * that on Linux (at least) there is a race condition here because

         * semaphore undo on process exit is not atomic, so we could

         * acquire SYSVSEM_SETVAL before a crashed process has decremented

         * SYSVSEM_USAGE in which case count will be greater than it

         * should be and we won't set max_acquire.  Fortunately this

         * doesn't actually matter in practice.

         */

        /* Wait for sem 1 to be zero . . . */

        sop[0].sem_num = SYSVSEM_SETVAL;

        sop[0].sem_op  = 0;

        sop[0].sem_flg = 0;

        /* . . . and increment it so it becomes non-zero . . . */

        sop[1].sem_num = SYSVSEM_SETVAL;

        sop[1].sem_op  = 1;

        sop[1].sem_flg = SEM_UNDO;

        /* . . . and increment the usage count. */

        sop[2].sem_num = SYSVSEM_USAGE;

        sop[2].sem_op  = 1;

        sop[2].sem_flg = SEM_UNDO;

        while (semop(semid, sop, 3) == -1) {

                if (errno != EINTR) {

                        fprintf(stderr, "%s failed acquiring SYSVSEM_SETVAL for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                        break;

                }

        }

        /* Get the usage count. */

        count = semctl(semid, SYSVSEM_USAGE, GETVAL, NULL);

        if (count == -1) {

                fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

        }

        printf("proc count: %d\n", count);

        /* If we are the only user, then take this opportunity to set the max. */

        if (count == 1) {

#if HAVE_SEMUN

                /* This is correct for Linux which has union semun. */

                union semun semarg;

                semarg.val = max_acquire;

                if (semctl(semid, SYSVSEM_SEM, SETVAL, semarg) == -1) {

                        fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                }

#elif defined(SETVAL_WANTS_PTR)

                /* This is correct for Solaris 2.6 which does not have union semun. */

                if (semctl(semid, SYSVSEM_SEM, SETVAL, &max_acquire) == -1) {

                        fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                }

#else

                /* This works for i.e. AIX */

                if (semctl(semid, SYSVSEM_SEM, SETVAL, max_acquire) == -1) {

                        fprintf(stderr, "%s failed for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                }

#endif

        }

        /* Set semaphore 1 back to zero. */

        sop[0].sem_num = SYSVSEM_SETVAL;

        sop[0].sem_op  = -1;

        sop[0].sem_flg = SEM_UNDO;

        while (semop(semid, sop, 1) == -1) {

                if (errno != EINTR) {

                        fprintf(stderr, "%s failed releasing SYSVSEM_SETVAL for key 0x%lx: %s\n", __FUNCTION__, key, strerror(errno));

                        break;

                }

        }

        //sem_ptr = (sysvsem_sem *) emalloc(sizeof(sysvsem_sem));

        this->key   = key;

        this->semid = semid;

        this->count = 0;

        this->auto_release = auto_release;

        //this->id = (int)sem_ptr;

        //return sem_ptr;

}

/* }}} */

/* {{{ php_sysvsem_semop

 */

int sysvsem::php_sysvsem_semop(int acquire)

{

        struct sembuf sop;

        if (!acquire && this->count == 0) {

                fprintf(stderr, "SysV semaphore 0x%x is not currently acquired\n", this->key);

                return 0;

        }

        sop.sem_num = SYSVSEM_SEM;

        sop.sem_op  = acquire ? -1 : 1;

        sop.sem_flg = SEM_UNDO;

        while (semop(this->semid, &sop, 1) == -1) {

                if (errno != EINTR) {

                        fprintf(stderr, "%s failed to %s semaphore 0x%x: %s\n", __FUNCTION__, acquire ? "acquire" : "release", this->key, strerror(errno));

                        return 0;

                }

        }

        this->count -= acquire ? -1 : 1;

        return 1;

}

/* }}} */

/* {{{ proto bool sem_acquire(resource id)

         Acquires the semaphore with the given id, blocking if necessary */

int sysvsem::sem_acquire()

{

        return this->php_sysvsem_semop(1);

}

/* }}} */

/* {{{ proto bool sem_release(resource id)

         Releases the semaphore with the given id */

int sysvsem::sem_release()

{

        return this->php_sysvsem_semop(0);

}

/* }}} */

/* {{{ proto bool sem_remove(resource id)

         Removes semaphore from Unix systems */

/*

 * contributed by Gavin Sherry gavin@linuxworld.com.au

 * Fri Mar 16 00:50:13 EST 2001

 */

int sysvsem::sem_remove()

{

#if HAVE_SEMUN

        union semun un;

        struct semid_ds buf;

#endif

#if HAVE_SEMUN

        un.buf = &buf;

        if (semctl(this->semid, 0, IPC_STAT, un) < 0) {

#else

        if (semctl(this->semid, 0, IPC_STAT, NULL) < 0) {

#endif

                fprintf(stderr, "SysV semaphore 0x%x does not (any longer) exist\n", this->key);

                return 0;

        }

#if HAVE_SEMUN

        if (semctl(this->semid, 0, IPC_RMID, un) < 0) {

#else

        if (semctl(this->semid, 0, IPC_RMID, NULL) < 0) {

#endif

                fprintf(stderr, "%s failed for SysV sempphore 0x%x: %s\n", __FUNCTION__, this->key, strerror(errno));

                return 0;

        }

        /* let release_sysvsem_sem know we have removed

         * the semaphore to avoid issues with releasing.

         */

        this->count = -1;

        return 1;

}

/* }}} */

/*

 * Local variables:

 * tab-width: 4

 * c-basic-offset: 4

 * End:

 * vim600: sw=4 ts=4 fdm=marker

 * vim<600: sw=4 ts=4

 */