haiku.git

/*
 * Copyright 2008, Salvatore Benedetto, salvatore.benedetto@gmail.com.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <time.h>

#include <OS.h>

#include "TestUnitUtils.h"

#define KEY			((key_t)12345)
#define NUM_OF_SEMS	10

union semun {
	int val;
	struct semid_ds *buf;
	unsigned short *array;
};


static status_t
remove_semaphore(int semID)
{
	return semctl(semID, 0, IPC_RMID, 0);
}


static void
test_semget()
{
	TEST_SET("semget({IPC_PRIVATE, key})");

	const char* currentTest = NULL;

	// Open private set with IPC_PRIVATE
	TEST("semget(IPC_PRIVATE) - private");
	int semID = semget(IPC_PRIVATE, NUM_OF_SEMS, S_IRUSR | S_IWUSR);
	assert_posix_bool_success(semID != -1);

	// Destroy private semaphore
	TEST("semctl(IPC_RMID) - private");
	status_t status = remove_semaphore(semID);
	assert_posix_bool_success(status != -1);

	// Open non-private non-existing set with IPC_CREAT
	TEST("semget(KEY, IPC_CREAT) non-existing");
	semID = semget(KEY, NUM_OF_SEMS, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
		| S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
	assert_posix_bool_success(status != -1);

	// Re-open non-private existing without IPC_CREAT
	TEST("semget(KEY) re-open existing without IPC_CREAT");
	int returnID = semget(KEY, 0, 0);
	assert_equals(semID, returnID);

	// Re-open non-private existing with IPC_CREAT
	TEST("semget(IPC_CREATE) re-open existing with IPC_CREAT");
	returnID = semget(KEY, 0, IPC_CREAT | IPC_EXCL);
	assert_posix_bool_success(errno == EEXIST);

	// Destroy non-private semaphore
	TEST("semctl(IPC_RMID)");
	status = remove_semaphore(semID);
	assert_posix_bool_success(status != -1);

	// Open non-private non-existing without IPC_CREAT
	TEST("semget(IPC_CREATE) non-existing without IPC_CREAT");
	semID = semget(KEY, NUM_OF_SEMS, IPC_EXCL | S_IRUSR | S_IWUSR
		| S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
	assert_posix_bool_success(errno == ENOENT);

	// Destroy non-existing semaphore
	TEST("semctl()");
	status = remove_semaphore(semID);
	assert_posix_bool_success(errno == EINVAL);

	TEST("done");
}


static void
test_semop2()
{
	TEST_SET("semop2()");

	const char* currentTest = NULL;

	// Re-open non-private existing without IPC_CREAT
	TEST("semget(KEY) re-open existing without IPC_CREAT");
	int returnedID = semget(KEY, 0, 0);
	assert_posix_bool_success(returnedID != -1);

	TEST("semop(IPC_NOWAIT) - wait for zero");
	// Set up array of semaphores
	struct sembuf array[NUM_OF_SEMS];
	for (int i = 0; i < NUM_OF_SEMS; i++) {
		array[i].sem_num = i;
		array[i].sem_op = 0;
		array[i].sem_flg = IPC_NOWAIT;
	}
	semop(returnedID, array, NUM_OF_SEMS);
	assert_posix_bool_success(errno == EAGAIN);

	TEST("semop(IPC_NOWAIT) - wait to increase");
	for (int i = 0; i < NUM_OF_SEMS; i++) {
		array[i].sem_num = i;
		array[i].sem_op = -9;
		array[i].sem_flg = IPC_NOWAIT;
	}
	semop(returnedID, array, NUM_OF_SEMS);
	assert_posix_bool_success(errno == EAGAIN);

	TEST("semop(IPC_NOWAIT) - acquire resource sem #0");
	struct sembuf ops;
	ops.sem_num = 0;
	ops.sem_op = -8;
	ops.sem_flg = 0;
	status_t status = semop(returnedID, &ops, 1);
	assert_posix_bool_success(status != -1);

	TEST("semop(IPC_NOWAIT) - acquire zero sem #0");
	ops.sem_num = 0;
	ops.sem_op = 0;
	ops.sem_flg = 0;
	status = semop(returnedID, &ops, 1);

	TEST("semop(IPC_NOWAIT) - revert semop sem #0");
	ops.sem_num = 0;
	ops.sem_op = 8;
	ops.sem_flg = 0;
	status = semop(returnedID, &ops, 1);

	// Decrease to zero even semaphores and 
	// use SEM_UNDO flag on odd semaphores in order
	// to wake up the father on exit
	// Set up array of semaphores
	for (int i = 0; i < NUM_OF_SEMS; i++) {
		array[i].sem_num = i;
		array[i].sem_op = -8;
		if (i % 2)
			array[i].sem_flg = 0;
		else
			array[i].sem_flg = SEM_UNDO;
	}
	TEST("semop() - father");
	status = semop(returnedID, array, NUM_OF_SEMS);
	assert_posix_bool_success(status != -1);

	TEST("done");
}


static void
test_semop()
{	
	TEST_SET("semop()");
	const char* currentTest = NULL;

	// Open non-private non-existing set with IPC_CREAT
	TEST("semget(IPC_CREATE) non-existing");
	int semID = semget(KEY, NUM_OF_SEMS, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
		| S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
	assert_posix_bool_success(semID != -1);

	// SETALL
	TEST("semctl(SETALL)");
	union semun args;
	args.array = (unsigned short *)malloc(sizeof(unsigned short) * NUM_OF_SEMS);
	for (int i = 0; i < NUM_OF_SEMS; i++)
		args.array[i] = 8;
	status_t status = semctl(semID, 0, SETALL, args);
	assert_posix_bool_success(status != -1);
	free(args.array);

	pid_t child = fork();
	if (child == 0) {
		// The child first will test the IPC_NOWAIT
		// feature, while the father waits for him,
		// by waiting for zero on even semaphores, 
		// and to increase for odd semaphores, which
		// will happen on process exit due to SEM_UNDO
		// feature.
		test_semop2();
		exit(0);
	}

	wait_for_child(child);

	// Set up array of semaphores
	struct sembuf array[NUM_OF_SEMS];
	for (int i = 0; i < NUM_OF_SEMS; i++) {
		array[i].sem_num = i;
		if (i % 2)
			array[i].sem_op = 0; // wait for zero
		else 
			array[i].sem_op = -8; // wait to increase
		array[i].sem_flg = 0;
	}
	TEST("semop() - father acquired set");
	status = semop(semID, array, NUM_OF_SEMS);
	assert_posix_bool_success(status != -1);

	// Destroy non-private semaphore
	TEST("semctl(IPC_RMID)");
	status = remove_semaphore(semID);
	assert_posix_bool_success(status != 1);

	TEST("done");
}


static void
test_semctl()
{
	TEST_SET("semctl({GETVAL, SETVAL, GETPID, GETNCNT, GETZCNT, GETALL, SETALL, IPC_STAT, IPC_SET, IPC_RMID})");

	const char* currentTest = NULL;

	// Open non-private non-existing set with IPC_CREAT
	TEST("semget(IPC_CREATE) non-existing");
	int semID = semget(KEY, NUM_OF_SEMS, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
		| S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
	assert_posix_bool_success(semID != -1);

	// GETVAL
	TEST("semctl(GETVAL)");
	union semun args;
	status_t status = semctl(semID, NUM_OF_SEMS - 1, GETVAL, args);
	// Semaphore is not initialized. Value is unknown.
	// We care about not crashing into KDL.
	assert_posix_bool_success(status != -1);

	// SETALL
	TEST("semctl(SETALL)");
	args.array = (unsigned short *)malloc(sizeof(unsigned short) * NUM_OF_SEMS);
	for (int i = 0; i < NUM_OF_SEMS; i++)
		args.array[i] = 5;
	status = semctl(semID, 0, SETALL, args);
	assert_posix_bool_success(status != -1);
	free(args.array);

	// GETVAL semaphore 4
	int returnedValue = semctl(semID, 4, GETVAL, 0);
	assert_equals((unsigned short)returnedValue, (unsigned short)5);

	// GETALL
	TEST("semctl(GETALL)");
	args.array = (unsigned short *)malloc(sizeof(unsigned short) * NUM_OF_SEMS);
	semctl(semID, 0, GETALL, args);
	// Check only last semaphore value
	assert_equals(args.array[NUM_OF_SEMS - 1], (unsigned short)5);
	free(args.array);

	// SETVAL semaphore 2
	TEST("semctl(SETVAL) - semaphore #2");
	args.val = 7;
	status = semctl(semID, 2, SETVAL, args);
	assert_posix_bool_success(status != 1);

	// GETALL
	TEST("semctl(GETALL)");
	args.array = (unsigned short *)malloc(sizeof(unsigned short) * NUM_OF_SEMS);
	status = semctl(semID, 0, GETALL, args);
	assert_posix_bool_success(status != -1);
	TEST("semctl(GETALL) - semaphore #10");
	assert_equals(args.array[NUM_OF_SEMS - 1], (unsigned short)5);
	TEST("semctl(GETALL) - semaphore #2");
	assert_equals(args.array[NUM_OF_SEMS - 1], (unsigned short)5);
	free(args.array);

	// IPC_SET
	TEST("semctl(IPC_SET)");
	struct semid_ds semaphore;
	memset(&semaphore, 0, sizeof(struct semid_ds));
	semaphore.sem_perm.uid = getuid() + 3;
	semaphore.sem_perm.gid = getgid() + 3;
	semaphore.sem_perm.mode = 0666;
	args.buf = &semaphore;
	status = semctl(semID, 0, IPC_SET, args);
	assert_posix_bool_success(status != 1);

	// IPC_STAT set
	TEST("semctl(IPC_STAT)");
	memset(&semaphore, 0, sizeof(struct semid_ds));
	args.buf = &semaphore;
	status = semctl(semID, 0, IPC_STAT, args);
	assert_posix_bool_success(status != 1);
	TEST("semctl(IPC_STAT): number of sems");
	assert_equals((unsigned short)args.buf->sem_nsems, (unsigned short)NUM_OF_SEMS);
	TEST("semctl(IPC_STAT): uid");
	assert_equals(args.buf->sem_perm.uid, getuid() + 3);
	TEST("semctl(IPC_STAT): gid");
	assert_equals(args.buf->sem_perm.gid, getgid() + 3);
	
	// Destroy non-private semaphore
	TEST("semctl(IPC_RMID)");
	status = remove_semaphore(semID);
	assert_posix_bool_success(status != 1);

	TEST("done");
}


int
main()
{
	test_semget();
	test_semctl();
	test_semop();

	printf("\nAll tests OK\n");
}