The MIPS instruction architecture includes two instructions designed to let programs update memory from independent processes running concurrently in a multiprocessor.

The combination of LL and SC can be used to guarantee that a change to a memory location is effective, even when multiple concurrent CPUs are trying to update the same location. You can use LL and SC only from an assembly language module. However, the IRIX kernel contains a family of services that are implemented using LL/SC, and you can call them from C or C++. These calls are discussed under “Using Test-and-Set Functions”.

A lock is a small software object that stands for the exclusive right to use some resource. The resource could be the right to execute a section of code, or the right to modify a variable in memory, or the right to read or write in a file, or any other software operation that must by performed serially, by one process at a time. Before using a serial resource, the program claims the lock, and releases the lock when it is done with the resource.

The POSIX standard refers to an object of this kind as a mutex, a contraction of “mutual exclusion” that is a conventional term in computer science. This book uses the simpler word “lock” when discussing locks in general and IRIX locks in particular, and uses “mutex” when discussing POSIX mutexes.

You can use IRIX locks to coordinate between unrelated processes or lightweight processes through an IRIX shared memory arena. You can use POSIX mutexes to coordinate between POSIX threads in a threaded program only (not IRIX processes).

You define the meaning of a lock in terms that are relevant to your program's design. You decide what resources can be used freely at any time, and you decide what resources must be used serially, by one process at a time. You create and initialize a lock for each serial resource.

It is also your job to ensure that locks are used consistently in all parts of the program. Two errors are easy to make. You can forget to claim a lock, so that some part of the program uses a resource freely instead of serializing. Or you can forget to release a lock, so that other processes trying to claim the lock “hang,” or wait forever.

Both of these errors can be hard to find because the symptoms can be intermittent. Most of the time, there is no contention for the use of a shared variable. For example, if one process sometimes fails to claim a lock before updating memory, the program can seem to run correctly for hours (or months) before it suffers precisely the right combination of coincidences that cause two processes to update the variable at the same time.

A semaphore is an integer count that is accessed atomically using two operations that are conventionally called P and V:

You can use a semaphore in place of a lock, to enforce serial use of resource. You initialize the semaphore to a value of 1. The P operation claims the semaphore, leaving it at 0 so that the next process to do P will be suspended. The V operation releases the semaphore.

You can also use a semaphore to control access to a pool that contains a countable number for resources. For example, say that a buffer pool contains n buffers. A process can proceed if there is at least 1 buffer available in the pool, but if there are no buffers, the process should sleep until at least 1 buffer is returned.

A semaphore, initialized to n, represents the population of the buffer pool. The pool itself might be implemented as a LIFO queue. The right to update the queue anchor (either to remove a buffer or to return one) is a separate resource that is guarded by a lock. The procedure for obtaining a buffer from the pool is as follows:

The procedure for returning a buffer to the pool is as follows:

The same two basic procedures work to allocate any collection of objects. For example, the semaphore could represent the number of open slots in a ring buffer, and the lock could stand for the right to update the ring buffer pointers. (A LIFO queue can be managed without a lock; see “Using Compare-and-Swap”.)

Semaphores created using POSIX functions, and semaphores created by the SVR4 IPC facility, can be used to coordinate IRIX processes or POSIX threads. Semaphores supported by the IRIX IPC facility can be used to coordinate IRIX processes only.

A condition variable is a software object that represents the occurrence of an event. Typically the event is a software action such as “other thread has supplied needed data.”

Condition variable support is included in the POSIX pthreads library, and can be used only to coordinate among POSIX threads, not between IRIX processes. (See Chapter 13, “Thread-Level Parallelism” for information on the pthread library.)

A thread that wants to wait for an event claims the condition variable, which causes the thread to wait. The thread that recognizes the event signals the condition variable, releasing one or all threads that are waiting for the event.

In the expected mode of use, there is a shared resource that can be depleted. Access to the resource is represented by a mutex. A thread claims the mutex, but then finds that the shared resource is depleted or unready. This thread needs to do three things:

These three actions are combined into one action using a condition variable. When a thread claims a condition variable, it must pass a mutex that it owns. The claim releases the mutex, waits, and reclaims the mutex in one operation.

Barriers provide a convenient way of synchronizing parallel processes on multiprocessor systems. To understand barriers, think of a time when you planned to go to lunch with other people at your workplace. The group agrees to meet in the lobby of the building. Some of your coworkers reach the lobby early, and others arrive later. One comes running in last, apologizing. When all of you have gathered and you know that everyone is ready, you all leave the building in a group.

A barrier is the software equivalent of the lobby where you waited. A group of processes are going to work on a problem. None should start until all the data has been initialized. However, starting each process is part of the initialization, and they cannot all be started at the same time. Each process must be created; each must join an arena and perhaps open a file; and you cannot predict when they will all be ready. To coordinate them, you create a barrier. Each process, when it is ready to start the main operation, calls barrier(), passing the address of the barrier and the number of processes that will meet. When that many processes have called barrier(), all of them are released to begin execution.

Barriers are part of IRIX IPC and require the use of a shared arena. Barriers cannot be used to coordinate POSIX threads.

An unnamed semaphore is a semaphore object that exists in memory only. An unnamed semaphore can be identified only by its memory address, so it can be shared only by processes or threads that share that memory location.

The functions for creating and freeing unnamed semaphores are summarized in Table 4-1.

The type of a POSIX semaphore is sem_t, which is declared in the header file semaphore.h. You create an unnamed semaphore by allocating memory for a sem_t variable, either dynamically or statically, and initializing it with sem_init(). The function in Example 4-1 allocates and initializes an unnamed semaphore and returns its address. It returns NULL if there is a failure of either malloc() or sem_init().

sem_t * allocUnnSem(unsigned initVal)
{
   sem_t *psem = (sem_t*)malloc(sizeof(sem_t));
   if (psem) /* malloc worked */
   {
      if (sem_init(psem,0,initVal))
      {
         free(psem);
         psem = NULL;
      }
   }
   return psem;
}

The function in Example 4-1 passes the second argument of sem_init(), pshared, as 0, meaning the semaphore can only be used within the current process. A semaphore of this kind can be used to coordinate pthreads in a threaded program.

If you want to use a semaphore to coordinate between IRIX processes with separate address spaces, you must create the semaphore with a nonzero pshared, and place the semaphore in a memory segment that is shared among all processes. This feature is fully supported. However, you should specify pshared as 0 when possible, because nonshared semaphores have higher performance.

A named semaphore is named in the filesystem, so it can be opened by any process (subject to access permissions), even when the process does not share address space with the creator of the semaphore. The functions used to create and manage named semaphores are summarized in Table 4-2.

The sem_open() function takes the following arguments:

POSIX named and unnamed semaphores can be used to coordinate the actions of IRIX processes and POSIX threads. They are the only mutual-exclusion objects that can be freely used to coordinate between threaded and unthreaded programs alike. (Message queues can be used between threaded and unthreaded programs also; see Chapter 6, “Message Queues.”)

The functions that operate on semaphores are summarized in Table 4-3.

The abstract operation P is implemented as the sem_wait() function. Use this to decrement a semaphore's value and, if the result is negative, to suspend the calling function until the value is restored. The V operation is sem_post().

You can sample a semaphore's value using sem_getvalue(). The sem_trywait() operation is useful when a process or thread cannot tolerate being suspended.

Two additional types of mutual exclusion are available only within a threaded program, to coordinate the actions of POSIX threads. The mutex is comparable to a lock or to a semaphore initialized to a count of 1. The condition variable provides a convenient way for a thread to give up ownership of a mutex, wait for something to happen, and then reclaim the mutex.

Both of these facilities are covered in detail in Chapter 13, “Thread-Level Parallelism.” See the headings “Mutexes” and “Condition Variables”.

Two kinds of semaphores are supported in IRIX IPC: normal and polled. Both are allocated in a shared memory arena (see “IRIX Shared Memory Arenas”).

Creating Normal Semaphores

The functions for managing normal semaphores are summarized in Table 4-4.

Table 4-4. IRIX Functions to Manage Nonpolled Semaphores

Function Name	Purpose and Operation
usnewsema(3P)	Allocate a semaphore in an arena and give it an initial value.
usfreesema(3P)	Release arena memory used by a semaphore (does not release any process waiting on the semaphore).
usinitsema(3P)	Reset a semaphore value and its metering information (does not release any process waiting on the semaphore).
usctlsema(3P)	Set and reset semaphore metering information and other attributes.
usdumpsema(3P)	Dump semaphore metering information to a file.

To allocate a new shared-arena semaphore and set its initial value, call usnewsema(). Use usctlsema() to enable recursive use of the semaphore and to enable the collection of metering information. You can use the metering information to find out whether a semaphore is a bottleneck or not.

---

Tip: When reading the reference pages cited above, notice that usnewsema() returns the address of a usema_t object, and all the other functions take the address of a usema_t. That is, usema_t represents the type of the semaphore object itself, and you refer to a semaphore by its address. This is different from locks, which are discussed later in this chapter.

---

IRIX locks are implemented differently depending on the hardware architecture of the computer using them. On a multiprocessor computer, locks are busy-wait locks, so the processor continually tries to acquire the lock until it succeeds. This implementation makes sense only on multiprocessor systems, where one processor can release the lock while another processor is “spinning,” trying to acquire the lock. On a uniprocessor, a process waiting to claim a lock is suspended until the lock is released by another process.

Claiming and Releasing Locks

The functions for using locks are summarized in Table 4-8.

Table 4-8. IRIX IPC Functions for Using Locks

Function Name	Purpose and Operation
ussetlock(3P)	Seize a lock, suspending the caller if necessary, until the lock is available.
usunsetlock(3P)	Release a lock, making it available for other processes.
uscsetlock(3P)	Seize a lock if it is available; otherwise return a 1.
uswsetlock(3P)	Seize a lock, suspending the caller if necessary; takes a specified number of spins as an argument.
ustestlock(3P)	Test a lock, returning 0 if it is instantaneously available and 1 if it is not available.

---

Tip: When reading the reference pages cited above, notice that usnewlock() returns a ulock_t object, which is simply a pointer. All the functions that operate on locks take a ulock_t object—not a pointer to a ulock_t. That is, the ulock_t type represents a handle or reference to a lock, not a lock itself. This differs from the treatment of semaphores, which is described under “Creating Normal Semaphores”.

---

On uniprocessors, none of the functions us[c,w]setlock() spin; if the lock is available they return immediately, and if it is not, they suspend the calling process and give up the CPU. On multiprocessors, ussettlock() spins for a default number of times before it suspends the process. The function uswsetlock() is the same, but you can specify the number of spins to take before suspending.

A process can call usunsetlock() on a lock that is either not locked or locked by another process. In either case, the lock is unlocked. “Double tripping”—calling a set-lock function twice with the same lock—is also permissible. The caller blocks until another process unsets the lock.

The functions to manage and use barriers are summarized in Table 4-9.

The main process uses new_barrier() to allocate a barrier in some arena. To use the barrier, each process calls barrier(), passing the number of processes that are supposed to meet before proceeding.

---

Note: The barrier() function assumes that it is used on a multiprocessor. It always passes time by spinning in an empty loop. When used on a uniprocessor (or when used on a multiprocessor with fewer available CPUs than barrier processes), a call to barrier(n) can be quite inefficient. The waiting functions spin until each in turn uses up its time-slice. In general it is not a good idea to use barrier() except in a multiprocessor with a number of CPUs approximately equal to the number of coordinating processes.

---

The C library includes a family of functions that apply the MIPS instructions Load Linked and Store Conditional to modify memory words in a reliable way in a multiprocessor. These functions are detailed in the test_and_set(3) and uscas(3) reference pages. In addition, the MIPSpro C and C++ compilers, version 7.0 and after, contain built-in support for these operations.

#include <ulocks.h>
typedef struct item_s {
    struct item_s *next;
    /* ... other fields ... */
} item_t;
void push_item( item_t **lifo, item_t *new, usptr_t *u)
{
    item_t *old;
    do {
        new->next = old = *lifo;
    } while(0 == uscas(lifo,(ptrdiff_t)old,(ptrdiff_t)new,u));
}
item_t * pull_item( item_t **lifo, usptr_t *u)
{
    item_t *old, *new;  
    do {
        old = *lifo;
        if (!old) break;
        new = old->next;
    } while(0 == uscas(lifo,(ptrdiff_t)old,(ptrdiff_t)new,u));
    return old;
}
#include <stdio.h>
main()
{
    usptr_t *arena = usinit("/var/tmp/cas.arena");
    item_t *lifo = NULL;
    item_t t1, t2;
    item_t *p1, *p2;
    push_item(&lifo, &t1, arena);
    push_item(&lifo, &t2, arena);
    p2 = pull_item(&lifo, arena);
    p1 = pull_item(&lifo, arena);
    printf("%x == %x ?\n", &t1, p1);
    printf("%x == %x ?\n", &t2, p2);
}

__add_and_fetch(&shared,1);

test_then_add(&shared,1);

A process creates a semaphore set, or locates an existing set, using the semget() system function. The function creates a set only if the specified key is IPC_PRIVATE, or no set with that key exists, and the IPC_CREAT flag is used. When it creates a set, the arguments to the function establish

In addition, the effective user ID and group ID of the calling process become the creator and owner identification of the new semaphore set. (See “Example Uses of semget()” for example code.)

When semget() locates an existing set, access is controlled by the access permissions of the set and by the user ID and group ID of the calling process.

The value returned by semget() is the ID number of the semaphore set. It is used to identify the segment to other functions.

The semctl() function gives you the ability to get information about a semaphore set, or to modify its attributes. These operations are summarized in Table 4-12.

Examples of some of these uses can be found under “Example Uses of semctl() for Management”.

In addition, semctl() allows you to query or set information about individual semaphores within the set, as summarized in Table 4-13.

Examples of some of these uses can be seen under “Example Uses of semctl() for Query”.

---

Caution: Some operations of the semctl() function use only three arguments, but some operations require a fourth argument (see reference page semctl(2) for details). When passing a fourth argument to semctl(), it is extremely important that you pass a union semun, as specified in the reference page. You might look at the contents of the union and think that, since all its fields are addresses, there is no effective difference between passing a union and passing a plain address of a buffer or array. However, if your program is compiled with the -n32 or -64 options, the alignment of the two kinds of arguments is different. Always pass an address as shown in the example programs in this chapter:

---

union semun arg4;
...
arg4.buffer = &ds_buffer;
semctl(a,b,c,arg4);

If your program passes only the address, as in

semctl(a,b,c,&ds_buffer);

the code will not work correctly when compiled -n32 or -64.

You perform operations on the semaphores in a set by calling semop(). This function takes a semaphore set ID, and an array of one or more semaphore operation structures. Each of the operation structures specifies the following:

In the simplest case, you pass an array containing just one operation, to increment or decrement one semaphore by 1 (the traditional V or P operation). Used this way, a semaphore in a set is functionally the same as an IRIX or POSIX semaphore.

SVR4 semaphores permit additional operations not available with IRIX or POSIX semaphores. The negative or positive value in the operation structure is not required to be 1, so you can increment or decrement a semaphore by more than 1 in an operation. The wait-for-zero operation allows one process or thread to monitor the state of a semaphore, independent of the P and V operations performed on the semaphore by other processes or threads.

You can also perform a sequence of operations—a sequence of P, or V, or zero-wait operations, or a mix of operation types—on multiple semaphores in a single call. To do this, you specify an array containing more than one operation structure. The semop() function performs each operation in sequence.

You can use this feature, for example, to claim multiple resources, each represented by a different semaphore. Your array would specify the P operation on each of the semaphores in sequence. When semop() returns successfully, you own all the resources. A similar, multiple V operation returns all the resources at once.

The IPC_NOWAIT and SEM_UNDO flags are important when claiming multiple resources at once. Specify SEM_UNDO on all operations; and specify IPC_NOWAIT on all but the first one. If the second or later resource is unavailable, semop() restores all preceding claims and returns an error code. As long as all processes or threads operate on semaphores in the same order, this logic prevents deadlocks, and it avoids long, fruitless suspensions.

The programs in this section allow you to experiment with semaphore sets from the command line:

/*
|| semget: program to test semget(2) for creating semaphores.
||      semget [-k <key>] [-c] [-x] [-p <perms>] [-s <setsize>]
||          -k <key>        the key to use, default == 0 == IPC_PRIVATE
||          -p <perms>      permissions to use, default is 0666
||          -s <setsize>    size to use, default is 1
||          -c              use IPC_CREAT
||          -x              use IPC_EXCL
*/
#include <unistd.h> /* for getopt() */
#include <sys/sem.h>    /* for shmget etc */
#include <errno.h>  /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
    key_t key = IPC_PRIVATE;/* key */
    int nsems = 1;          /* setsize */
    int perms = 0600;       /* permissions */
    int semflg = 0;         /* flag values */
    struct semid_ds ds;     /* info struct */
    union semun arg4;       /* way to pass &ds properly aligned */
    int c, semid;
    while ( -1 != (c = getopt(argc,argv,"k:p:s:xc")) )
    {
        switch (c)
        {
        case 'k': /* key */
            key = (key_t) strtoul(optarg, NULL, 0);
            break;
        case 's': /* setsize */
            nsems = (int) strtoul(optarg, NULL, 0);
            break;
        case 'p': /* permissions */
            perms = (int) strtoul(optarg, NULL, 0);
            break;
        case 'c':
            semflg |= IPC_CREAT;
            break;
        case 'x':
            semflg |= IPC_EXCL;
            break;
        default: /* unknown or missing argument */
            return -1;      
        }
    }
    semid = semget(key,nsems,semflg+perms);
    if (-1 != semid)
    {
        printf("semid = %d\n",semid);
        arg4.buf = &ds;
        if (-1 != semctl(semid,0,IPC_STAT,arg4))
        {
            printf(
    "owner uid.gid: %d.%d  creator uid.gid: %d.%d  mode: 0%o nsems:%d\n",
            ds.sem_perm.uid,ds.sem_perm.gid,
            ds.sem_perm.cuid,ds.sem_perm.cgid,
            ds.sem_perm.mode, ds.sem_nsems);
        }
        else
            perror("semctl(IPC_STAT)");
    }
    else
        perror("semget()");
    return errno;
} 

/*
|| semmod: program to test semctl(2) for status, ownership and permissions.
||      semmod {-k <key> | -i <semid>} [-p <perms>] [-u <user>] [-g <group>]
||          -k <key>            the key to use, or..
||          -i <semid>          ..the semid to use
||          -p <perms>          permissions to set with IPC_SET
||          -u <uid>            uid to set as owner with IPC_SET
||          -g <gid>            gid to set as owner with IPC_SET
*/
#include <unistd.h> /* for getopt() */
#include <sys/sem.h> /* for shmget etc */
#include <errno.h> /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
    key_t key;              /* key */
    int semid = -1;         /* object ID */
    int perms, popt = 0;    /* perms to set, if given */
    int uid, uopt = 0;      /* uid to set, if given */
    int gid, gopt = 0;      /* gid to set, if given */
    int val, vopt = 0;      /* setall value if given */
    struct semid_ds ds;
    union semun arg4;       /* way to pass semctl 4th arg, properly aligned */
    int c;
    while ( -1 != (c = getopt(argc,argv,"k:i:p:u:g:")) )
    {
        switch (c)
        {
        case 'k': /* key */
            key = (key_t) strtoul(optarg, NULL, 0);
            break;
        case 'i': /* semid */
            semid = (int) strtoul(optarg, NULL, 0);
            break;
        case 'p': /* permissions */
            perms = (int) strtoul(optarg, NULL, 0);
            popt = 1;
            break;
        case 'u': /* uid */
            uid = (int) strtoul(optarg, NULL, 0);
            uopt = 1;
            break;
        case 'g': /* gid */
            gid = (int) strtoul(optarg, NULL, 0);
            gopt = 1;
            break;
        default: /* unknown or missing argument */
            return -1;      
        }
    }
    if (-1 == semid) /* -i not given, must have -k */
        semid = semget(key,0,0);
    if (-1 != semid)
    {
        arg4.buf = &ds;
        if (0 == semctl(semid,0,IPC_STAT,arg4))
        {
            if ((popt)||(uopt)||(gopt))
            {
                if (popt) ds.sem_perm.mode = perms;
                if (uopt) ds.sem_perm.uid = uid;
                if (gopt) ds.sem_perm.gid = gid;
                if (0 == semctl(semid,0,IPC_SET,arg4) )
                    semctl(semid,0,IPC_STAT,arg4); /* refresh info */
                else
                    perror("semctl(IPC_SET)");
            }
            printf(
    "owner uid.gid: %d.%d  creator uid.gid: %d.%d  mode: 0%o nsems:%d\n",
            ds.sem_perm.uid,ds.sem_perm.gid,
            ds.sem_perm.cuid,ds.sem_perm.cgid,
            ds.sem_perm.mode, ds.sem_nsems);
        }
        else
            perror("semctl(IPC_STAT)");
    }
    else
        perror("semget()");
}

/*
|| semsnap: program to test semctl(2) for semaphore status commands
||      semsnap {-k <key> | -i <semid>}
||          -k <key>            the key to use, or..
||          -i <semid>      ..the semid to use
*/
#include <unistd.h> /* for getopt() */
#include <sys/sem.h>    /* for shmget etc */
#include <errno.h>  /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
    key_t key;                  /* key */
    int semid = -1;         /* object ID */
    int nsems, j;               /* setsize, and loop variable */
    ushort_t semvals[25];   /* snapshot of values */
    ushort_t semns[25];     /* snapshot of P-waiting */
    ushort_t semzs[25];     /* snapshot of zero-waiting */  
    struct semid_ds ds;
    union semun arg4;       /* semctl 4th argument, properly aligned */
    int c;
    while ( -1 != (c = getopt(argc,argv,"k:i:")) )
    {
        switch (c)
        {
        case 'k': /* key */
            key = (key_t) strtoul(optarg, NULL, 0);
            break;
        case 'i': /* semid */
            semid = (int) strtoul(optarg, NULL, 0);
            break;
        default: /* unknown or missing argument */
            return -1;      
        }
    }
    if (-1 == semid) /* -i not given, must have -k */
        semid = semget(key,0,0);
    if (-1 != semid)
    {
        arg4.buf = &ds;
        if (0 == semctl(semid,0,IPC_STAT,arg4))
        {
            nsems = ds.sem_nsems;
            arg4.array = semvals;
            semctl(semid,0,GETALL,arg4);
            for (j=0; j<nsems; ++j)
            {
                semns[j] = semctl(semid,j,GETNCNT);
                semzs[j] = semctl(semid,j,GETZCNT);
            }
            printf("vals:");
            for (j=0; j<nsems; ++j) printf(" %2d",semvals[j]);
            printf("\nncnt:");
            for (j=0; j<nsems; ++j) printf(" %2d",semns[j]);
            printf("\nzcnt:");
            for (j=0; j<nsems; ++j) printf(" %2d",semzs[j]);
            putc('\n',stdout);
        }
        else
            perror("semctl(IPC_STAT)");
    }
    else
        perror("semget()");
}

semop -k 0x101 -z 4 -u -v 0 -n -p 2 -p 3

/*
|| semop: program to test semop(2) for all functions.
||      semop {-k <key> | -i <semid>} [-n] [-u] {-p <n> | -v <n> | -z <n>}...
||          -k <key>        the key to use, or..
||          -i <semid>      ..the semid to use
||          -n              use the IPC_NOWAIT flag on following ops
||          -u              use the SEM_UNDO flag on following ops
||          -p <n>          do the P operation (+1) on semaphore <n>
||          -v <n>          do the V operation (-1) on semaphore <n>
||          -z <n>          wait for <n> to become zero
*/
#include <unistd.h>     /* for getopt() */
#include <sys/sem.h>    /* for shmget etc */
#include <errno.h>      /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
    key_t key;                  /* key */
    int semid = -1;             /* object ID */
    int nsops = 0;              /* setsize, and loop variable */
    short flg = 0;              /* flag to use on all ops */
    struct semid_ds ds;
    int c, s;
    struct sembuf sops[25];
    while ( -1 != (c = getopt(argc,argv,"k:i:p:v:z:nu")) )
    {
        switch (c)
        {
        case 'k': /* key */
            key = (key_t) strtoul(optarg, NULL, 0);
            break;
        case 'i': /* semid */
            semid = (int) strtoul(optarg, NULL, 0);
            break;
        case 'n': /* use nowait */
            flg |= IPC_NOWAIT;
            break;
        case 'u': /* use undo */
            flg |= SEM_UNDO;
            break;
        case 'p': /* do the P() */
            sops[nsops].sem_num = (ushort_t) strtoul(optarg, NULL, 0);
            sops[nsops].sem_op = -1;
            sops[nsops++].sem_flg = flg;
            break;
        case 'v': /* do the V() */
            sops[nsops].sem_num = (ushort_t) strtoul(optarg, NULL, 0);
            sops[nsops].sem_op = +1;
            sops[nsops++].sem_flg = flg;
            break;
        case 'z': /* do the wait-for-zero */
            sops[nsops].sem_num = (ushort_t) strtoul(optarg, NULL, 0);
            sops[nsops].sem_op = 0;
            sops[nsops++].sem_flg = flg;
            break;
        default: /* unknown or missing argument */
            return -1;      
        }
    }
    if (-1 == semid) /* -i not given, must have -k */
        semid = semget(key,0,0);
    if (-1 != semid)
    {
        if (0 != semop(semid,sops,nsops) )
            perror("semop()");
    }
    else
        perror("semget()");
}

$ ipcs -s
IPC status from /dev/kmem as of Wed Jun 19 11:19:37 1996
T     ID     KEY        MODE       OWNER    GROUP
Semaphores:
$ semget -k 0xfab -c -x -p 0666 -s 4
semid = 130
owner uid.gid: 1110.20  creator uid.gid: 1110.20  mode: 0100666 nsems:4
$ ipcs -s
IPC status from /dev/kmem as of Wed Jun 19 11:19:59 1996
T     ID     KEY        MODE       OWNER    GROUP
Semaphores:
s    130 0x00000fab --ra-ra-ra-  cortesi     user

$ semget -k 0xfab -c -x
semget(): File exists

$ semmod -i 130 -p 0640
owner uid.gid: 1110.20  creator uid.gid: 1110.20  mode: 0100640 nsems:4
$ ipcs -s
IPC status from /dev/kmem as of Wed Jun 19 11:20:09 1996
T     ID     KEY        MODE       OWNER    GROUP
Semaphores:
s    130 0x00000fab --ra-r-----  cortesi     user

$ semsnap -i 130
vals:  0  0  0  0
ncnt:  0  0  0  0
zcnt:  0  0  0  0
$ semop -i 130 -v 0 -v 1
$ semsnap -i 130
vals:  1  1  0  0
ncnt:  0  0  0  0
zcnt:  0  0  0  0

$ semop -i 130 -z 0 -p 1 -p 2 &
9956
$ semsnap -i 130
vals:  1  1  0  0
ncnt:  0  0  0  0
zcnt:  1  0  0  0

$ semop -i 130 -p 0
$ semsnap -i 130
vals:  0  1  0  0
ncnt:  0  0  1  0
zcnt:  0  0  0  0

$ semop -i 130 -v 2
$ semsnap -i 130
vals:  0  0  0  0
ncnt:  0  0  0  0
zcnt:  0  0  0  0

$ semop -i 130 -p 0 &
9962
$ ipcrm -s 130
$ semop(): Identifier removed