/*
  Copyright 2005 Intel Corporation.  All rights reserved.

  This program is free software; you can redistribute it and/or modify it 
  under the terms of the GNU General Public License as published by the Free 
  Software Foundation; either version 2 of the License, or (at your option) 
  any later version.
  
  This program is distributed in the hope that it will be useful, but WITHOUT 
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
  more details.
  
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59 
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  
  The full GNU General Public License is included in this distribution in the
  file called LICENSE.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <asm/semaphore.h>
#include <asm/atomic.h>

static atomic_t sem_test_nr_threads = ATOMIC_INIT(0);	
static atomic_t sem_test_threads_done = ATOMIC_INIT(0);	
static atomic_t sem_test_failures = ATOMIC_INIT(0);	
static int delay_count = 100, repeat_count = 1000, thread_count = 5;
static int sem_test_go, sem_test_abort;

static char pad1[128] = "foo";
static struct semaphore sem_test_semaphore;
static int owner = -1;
static char pad2[128] = "bar";

static int sem_test_thread(void *dummy)
{
	int our_nr = (long)dummy;
	int i, good = 0;
	while (!sem_test_go) {
		if (sem_test_abort) {
			atomic_inc(&sem_test_failures);
			return 1;
		}
		schedule();
	}

	for (i=0; i<repeat_count; i++) {
		int good_pass = 1;
		int j;
		if (sem_test_abort) {
			atomic_inc(&sem_test_failures);
			return 1;
		}
		down(&sem_test_semaphore);
		j = owner;
		if (j != -1) {
			good_pass = 0;
			atomic_inc(&sem_test_failures);
			printk("owner was set to %d (our_nr = %d)!\n",
			       j, our_nr);
		}
		owner = our_nr;
		for (j=0; j<delay_count; j++) {
			if (sem_test_abort) {
				up(&sem_test_semaphore);
				atomic_inc(&sem_test_failures);
				return 1;
			}
			schedule();
		}
		j = owner;
		if (j != our_nr) {
			good_pass = 0;
			atomic_inc(&sem_test_failures);
			printk("owner not equal to our_nr: %d (our_nr = %d)!\n",
			       j, our_nr);
		}
		owner = -1;
		up(&sem_test_semaphore);
		good += good_pass;
	}

	if (atomic_dec_and_test(&sem_test_nr_threads))
		printk("sem_test: last thread exited\n");
	atomic_add(good, &sem_test_threads_done);
	return 0;
}

static void sem_test_exit(void)
{
	printk("sem_test_exit: unloading\n");
}

static void sem_test_wait(void)
{
	long timeout = HZ/10;
	printk("sem_test_wait: entered\n");
	while (atomic_read(&sem_test_nr_threads))
		schedule_timeout(HZ/10);
	printk("sem_test_wait: threads exited\n");
	do {
		timeout = schedule_timeout(timeout);
	} while (timeout);
	printk("sem_test_wait: %d/%d complete: %d failures: %s\n",
	       atomic_read(&sem_test_threads_done), repeat_count * thread_count,
	       atomic_read(&sem_test_failures),
	       atomic_read(&sem_test_failures) ? "FAIL" : "PASS"
	       );
}

static int __init sem_test_init(void)
{
	long i;

	init_MUTEX(&sem_test_semaphore);
	atomic_add(thread_count, &sem_test_nr_threads);

	printk("sem_test: loaded. %d threads, %d repeats, %d delay\n",
	       thread_count, repeat_count, delay_count);

	for (i=0; i<thread_count; i++) {
		if (kernel_thread(sem_test_thread, (void *)i, CLONE_KERNEL) < 0) {
			printk("failed creating thread %ld of %d\n",
			       i, thread_count);
			atomic_inc(&sem_test_failures);
			break;
		}
	}

	if (i < thread_count) {
		atomic_add(thread_count - i, &sem_test_nr_threads);
		sem_test_abort = 1;
		return -EIO;
	}
	sem_test_go = 1;
	sem_test_wait();
	return 0;
}

module_init(sem_test_init);
module_exit(sem_test_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Benjamin LaHaise <benjamin.c.lahaise@intel.com>");
module_param(delay_count, int, 0);
module_param(repeat_count, int, 1000);
module_param(thread_count, int, 2);