/*
 * GPL HEADER START
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 only,
 * as published by the Free Software Foundation.
 *
 * 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 version 2 for more details (a copy is included
 * in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; If not, see
 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 *
 * GPL HEADER END
 */
/*
 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 2012, Intel Corporation.
 */
/*
 * This file is part of Lustre, http://www.lustre.org/
 * Lustre is a trademark of Sun Microsystems, Inc.
 *
 * libcfs/include/libcfs/linux/linux-prim.h
 *
 * Basic library routines.
 */

#ifndef __LIBCFS_LINUX_CFS_PRIM_H__
#define __LIBCFS_LINUX_CFS_PRIM_H__

#ifndef __LIBCFS_LIBCFS_H__
#error Do not #include this file directly. #include <linux/libcfs/libcfs.h> instead
#endif


#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/proc_fs.h>
#include <linux/mm.h>
#include <linux/timer.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/random.h>

#include <linux/miscdevice.h>
#include <linux/libcfs/linux/portals_compat25.h>
#include <asm/div64.h>

#include <linux/libcfs/linux/linux-time.h>


/*
 * CPU
 */
#ifdef for_each_possible_cpu
#define cfs_for_each_possible_cpu(cpu) for_each_possible_cpu(cpu)
#elif defined(for_each_cpu)
#define cfs_for_each_possible_cpu(cpu) for_each_cpu(cpu)
#endif

#ifdef NR_CPUS
#else
#define NR_CPUS     1
#endif

/*
 * cache
 */

/*
 * IRQs
 */


/*
 * Pseudo device register
 */
typedef struct miscdevice		psdev_t;

/*
 * Sysctl register
 */
typedef struct ctl_table		ctl_table_t;
typedef struct ctl_table_header		ctl_table_header_t;

#define cfs_register_sysctl_table(t, a) register_sysctl_table(t)

#define DECLARE_PROC_HANDLER(name)		      \
static int					      \
LL_PROC_PROTO(name)				     \
{						       \
	DECLARE_LL_PROC_PPOS_DECL;		      \
							\
	return proc_call_handler(table->data, write,    \
				 ppos, buffer, lenp,    \
				 __##name);	     \
}

/*
 * Symbol register
 */
#define cfs_symbol_register(s, p)       do {} while(0)
#define cfs_symbol_unregister(s)	do {} while(0)
#define cfs_symbol_get(s)	       symbol_get(s)
#define cfs_symbol_put(s)	       symbol_put(s)

typedef struct module module_t;

/*
 * Proc file system APIs
 */
typedef struct proc_dir_entry	   proc_dir_entry_t;

/*
 * Wait Queue
 */


typedef long			    cfs_task_state_t;

#define CFS_DECL_WAITQ(wq)		DECLARE_WAIT_QUEUE_HEAD(wq)

/*
 * Task struct
 */
typedef struct task_struct	      task_t;
#define DECL_JOURNAL_DATA	   void *journal_info
#define PUSH_JOURNAL		do {    \
	journal_info = current->journal_info;   \
	current->journal_info = NULL;	   \
	} while(0)
#define POP_JOURNAL		 do {    \
	current->journal_info = journal_info;   \
	} while(0)

/* Module interfaces */
#define cfs_module(name, version, init, fini) \
	module_init(init);		    \
	module_exit(fini)

/*
 * Signal
 */

/*
 * Timer
 */
typedef struct timer_list timer_list_t;


#ifndef wait_event_timeout /* Only for RHEL3 2.4.21 kernel */
#define __wait_event_timeout(wq, condition, timeout, ret)	\
do {							     \
	int __ret = 0;					   \
	if (!(condition)) {				      \
		wait_queue_t __wait;			     \
		unsigned long expire;			    \
								 \
		init_waitqueue_entry(&__wait, current);	  \
		expire = timeout + jiffies;		      \
		add_wait_queue(&wq, &__wait);		    \
		for (;;) {				       \
			set_current_state(TASK_UNINTERRUPTIBLE); \
			if (condition)			   \
				break;			   \
			if (jiffies > expire) {		  \
				ret = jiffies - expire;	  \
				break;			   \
			}					\
			schedule_timeout(timeout);	       \
		}						\
		current->state = TASK_RUNNING;		   \
		remove_wait_queue(&wq, &__wait);		 \
	}							\
} while (0)
/*
   retval == 0; condition met; we're good.
   retval > 0; timed out.
*/
#define cfs_waitq_wait_event_timeout(wq, condition, timeout, ret)    \
do {								 \
	ret = 0;						     \
	if (!(condition))					    \
		__wait_event_timeout(wq, condition, timeout, ret);   \
} while (0)
#else
#define cfs_waitq_wait_event_timeout(wq, condition, timeout, ret)    \
	ret = wait_event_timeout(wq, condition, timeout)
#endif

#define cfs_waitq_wait_event_interruptible_timeout(wq, c, timeout, ret) \
	ret = wait_event_interruptible_timeout(wq, c, timeout)

/*
 * atomic
 */


#define cfs_atomic_add_unless(atom, a, u)    atomic_add_unless(atom, a, u)
#define cfs_atomic_cmpxchg(atom, old, nv)    atomic_cmpxchg(atom, old, nv)

/*
 * membar
 */


/*
 * interrupt
 */


/*
 * might_sleep
 */

/*
 * group_info
 */
typedef struct group_info group_info_t;


/*
 * Random bytes
 */
#endif