Return to semcon.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / io.386

Annotation of coherent/b/kernel/io.386/semcon.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * System V Compatible Semaphore Device Driver
        !             3:  *
        !             4:  *     This device driver provides System V compatible semaphore operations.
        !             5:  *     Operations are performed through the semaphore device (/dev/sem).
        !             6:  *     and are implemented as ioctl calls from semctl, semget, semop
        !             7:  *     utilities.
        !             8:  *
        !             9:  *     Author: Allan Cornish.
        !            10:  */
        !            11: 
        !            12: #include <sys/coherent.h>
        !            13: #include <sys/types.h>
        !            14: #include <sys/uproc.h>
        !            15: #include <errno.h>
        !            16: #include <sys/con.h>
        !            17: #include <sys/sem.h>
        !            18: #ifndef _I386
        !            19: #define getusd(arg)            getuwd(arg)
        !            20: #define putusd(arg1, arg2)     putuwd(arg1, arg2)
        !            21: #endif
        !            22: 
        !            23: /*
        !            24:  * Functions.
        !            25:  */
        !            26: 
        !            27: int seminit();
        !            28: int semioctl();
        !            29: int nulldev();
        !            30: int nonedev();
        !            31: 
        !            32: /*
        !            33:  * Device Configuration.
        !            34:  */
        !            35: 
        !            36: CON semcon = {
        !            37:        DFCHR,                  /* Flags                        */
        !            38:        23,                     /* Major Index                  */
        !            39:        nulldev,                /* Open                         */
        !            40:        nulldev,                /* Close                        */
        !            41:        nonedev,                /* Block                        */
        !            42:        nonedev,                /* Read                         */
        !            43:        nonedev,                /* Write                        */
        !            44:        semioctl,               /* Ioctl                        */
        !            45:        nulldev,                /* Power fail                   */
        !            46:        nulldev,                /* Timeout                      */
        !            47:        seminit,                /* Load                         */
        !            48:        nulldev                 /* Unload                       */
        !            49: };
        !            50: 
        !            51: /*
        !            52:  * Semaphore Device Ioctl.
        !            53:  */
        !            54: 
        !            55: static
        !            56: semioctl( dev, com, vec )
        !            57: 
        !            58: dev_t dev;  /* the id of the semaphore as determined by a previous open() of /dev/sem */
        !            59: short com;  /* command ofr use in switch() */
        !            60: register short *vec;  /* if calling semctl or semget, this is a pointer to a struct of 5 ints
        !            61:                        * if calling semop, this is a pointer to a struct of 4 ints.
        !            62:                        */
        !            63: 
        !            64: {
        !            65: /*     printf("semioctl() called: dev= %x (%d) cmd = %x (%d)  vec= %x (%d)\n", 
        !            66:  *             dev, dev, com, com, vec, vec);
        !            67:  *     printf("Vectors: [0] = %d ; key = %d ; key>>16 = %d ; nsems = %d ; semflg = 0%o\n",
        !            68:  *             vec[0],vec[1],vec[2],vec[3],vec[4]);
        !            69:  */
        !            70:        switch ( com ) {
        !            71: 
        !            72:        case SEMCTL:
        !            73:                putusd( vec+0,                       /* -1 passed from semop (286 libc) */
        !            74:                        usemctl(getusd( vec+1 ),     /* semaphore id */
        !            75:                                getusd( vec+2 ),     /* semaphore number */
        !            76:                                getusd( vec+3 ),     /* command passed to usemctl */
        !            77:                                getusd( vec+4 ) ));  /* address of struct semid_ds */
        !            78:                return;
        !            79: 
        !            80:        case SEMGET:
        !            81: /*             printf("semioctl: performing SEMGET\n");  */
        !            82:                putusd( vec+0,                        /* -1 passed from semget (286 libc) */                            
        !            83:                        usemget(getusd( vec+1 ),      /* bits 00 - 15 of semaphore key */
        !            84: /*                             getusd( vec+2 ), */   /* bits 16 - 31 of semaphore key */
        !            85:                                getusd( vec+3 ),      /* number of semaphores to make room for */
        !            86:                                getusd( vec+4 ) ));   /* semaphore flag (IPC_CREAT|0644) */
        !            87:                return;
        !            88: 
        !            89:        case SEMOP:
        !            90:                putusd( vec+0,                        /* -1 passed from semop (286 libc) */
        !            91:                        usemop( getusd( vec+1 ),      /* semaphore id */
        !            92:                                getusd( vec+2 ),      /* address of struct sembuf (ops on value) */
        !            93:                                getusd( vec+3 ) ));   /* # of struct sembufs */
        !            94:                return;
        !            95: 
        !            96:        default:
        !            97:                printf("semioctl(): received invalid cmd!\n");
        !            98:                u.u_error = EINVAL;
        !            99:                return;
        !           100:        }
        !           101: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.