[deliverable/linux.git] / include / linux / mman.h

#ifndef _LINUX_MMAN_H
#define _LINUX_MMAN_H

#include <asm/mman.h>

#define MREMAP_MAYMOVE	1
#define MREMAP_FIXED	2

#define OVERCOMMIT_GUESS		0
#define OVERCOMMIT_ALWAYS		1
#define OVERCOMMIT_NEVER		2

#ifdef __KERNEL__
#include <linux/mm.h>
#include <linux/percpu_counter.h>

#include <linux/atomic.h>

extern int sysctl_overcommit_memory;
extern int sysctl_overcommit_ratio;
extern struct percpu_counter vm_committed_as;

static inline void vm_acct_memory(long pages)
{
	percpu_counter_add(&vm_committed_as, pages);
}

static inline void vm_unacct_memory(long pages)
{
	vm_acct_memory(-pages);
}

/*
 * Allow architectures to handle additional protection bits
 */

#ifndef arch_calc_vm_prot_bits
#define arch_calc_vm_prot_bits(prot) 0
#endif

#ifndef arch_vm_get_page_prot
#define arch_vm_get_page_prot(vm_flags) __pgprot(0)
#endif

#ifndef arch_validate_prot
/*
 * This is called from mprotect().  PROT_GROWSDOWN and PROT_GROWSUP have
 * already been masked out.
 *
 * Returns true if the prot flags are valid
 */
static inline int arch_validate_prot(unsigned long prot)
{
	return (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC | PROT_SEM)) == 0;
}
#define arch_validate_prot arch_validate_prot
#endif

/*
 * Optimisation macro.  It is equivalent to:
 *      (x & bit1) ? bit2 : 0
 * but this version is faster.
 * ("bit1" and "bit2" must be single bits)
 */
#define _calc_vm_trans(x, bit1, bit2) \
  ((bit1) <= (bit2) ? ((x) & (bit1)) * ((bit2) / (bit1)) \
   : ((x) & (bit1)) / ((bit1) / (bit2)))

/*
 * Combine the mmap "prot" argument into "vm_flags" used internally.
 */
static inline unsigned long
calc_vm_prot_bits(unsigned long prot)
{
	return _calc_vm_trans(prot, PROT_READ,  VM_READ ) |
	       _calc_vm_trans(prot, PROT_WRITE, VM_WRITE) |
	       _calc_vm_trans(prot, PROT_EXEC,  VM_EXEC) |
	       arch_calc_vm_prot_bits(prot);
}

/*
 * Combine the mmap "flags" argument into "vm_flags" used internally.
 */
static inline unsigned long
calc_vm_flag_bits(unsigned long flags)
{
	return _calc_vm_trans(flags, MAP_GROWSDOWN,  VM_GROWSDOWN ) |
	       _calc_vm_trans(flags, MAP_DENYWRITE,  VM_DENYWRITE ) |
	       _calc_vm_trans(flags, MAP_LOCKED,     VM_LOCKED    );
}
#endif /* __KERNEL__ */
#endif /* _LINUX_MMAN_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX_MMAN_H
	2	#define _LINUX_MMAN_H
	3
1da177e4 LT	4	#include <asm/mman.h>
	5
	6	#define MREMAP_MAYMOVE 1
	7	#define MREMAP_FIXED 2
	8
	9	#define OVERCOMMIT_GUESS 0
	10	#define OVERCOMMIT_ALWAYS 1
	11	#define OVERCOMMIT_NEVER 2
9cdcb566 DW	12
9cdcb566 DW	13	#ifdef __KERNEL__
9cdcb566	14	#include <linux/mm.h>
00a62ce9	15	#include <linux/percpu_counter.h>
9cdcb566	16
60063497	17	#include <linux/atomic.h>
9cdcb566	18
1da177e4 LT	19	extern int sysctl_overcommit_memory;
1da177e4 LT	20	extern int sysctl_overcommit_ratio;
00a62ce9	21	extern struct percpu_counter vm_committed_as;
1da177e4	22
1da177e4 LT	23	static inline void vm_acct_memory(long pages)
1da177e4 LT	24	{
00a62ce9	25	percpu_counter_add(&vm_committed_as, pages);
1da177e4	26	}
1da177e4 LT	27
	28	static inline void vm_unacct_memory(long pages)
	29	{
	30	vm_acct_memory(-pages);
	31	}
	32
b845f313 DK	33	/*
	34	* Allow architectures to handle additional protection bits
	35	*/
	36
	37	#ifndef arch_calc_vm_prot_bits
	38	#define arch_calc_vm_prot_bits(prot) 0
	39	#endif
	40
	41	#ifndef arch_vm_get_page_prot
	42	#define arch_vm_get_page_prot(vm_flags) __pgprot(0)
	43	#endif
	44
	45	#ifndef arch_validate_prot
	46	/*
	47	* This is called from mprotect(). PROT_GROWSDOWN and PROT_GROWSUP have
	48	* already been masked out.
	49	*
	50	* Returns true if the prot flags are valid
	51	*/
	52	static inline int arch_validate_prot(unsigned long prot)
	53	{
	54	return (prot & ~(PROT_READ \| PROT_WRITE \| PROT_EXEC \| PROT_SEM)) == 0;
	55	}
	56	#define arch_validate_prot arch_validate_prot
	57	#endif
	58
1da177e4 LT	59	/*
	60	* Optimisation macro. It is equivalent to:
	61	* (x & bit1) ? bit2 : 0
	62	* but this version is faster.
	63	* ("bit1" and "bit2" must be single bits)
	64	*/
	65	#define _calc_vm_trans(x, bit1, bit2) \
	66	((bit1) <= (bit2) ? ((x) & (bit1)) * ((bit2) / (bit1)) \
	67	: ((x) & (bit1)) / ((bit1) / (bit2)))
	68
	69	/*
	70	* Combine the mmap "prot" argument into "vm_flags" used internally.
	71	*/
	72	static inline unsigned long
	73	calc_vm_prot_bits(unsigned long prot)
	74	{
	75	return _calc_vm_trans(prot, PROT_READ, VM_READ ) \|
	76	_calc_vm_trans(prot, PROT_WRITE, VM_WRITE) \|
b845f313 DK	77	_calc_vm_trans(prot, PROT_EXEC, VM_EXEC) \|
b845f313 DK	78	arch_calc_vm_prot_bits(prot);
1da177e4 LT	79	}
	80
	81	/*
	82	* Combine the mmap "flags" argument into "vm_flags" used internally.
	83	*/
	84	static inline unsigned long
	85	calc_vm_flag_bits(unsigned long flags)
	86	{
	87	return _calc_vm_trans(flags, MAP_GROWSDOWN, VM_GROWSDOWN ) \|
	88	_calc_vm_trans(flags, MAP_DENYWRITE, VM_DENYWRITE ) \|
1da177e4 LT	89	_calc_vm_trans(flags, MAP_LOCKED, VM_LOCKED );
1da177e4 LT	90	}
9cdcb566	91	#endif /* __KERNEL__ */
1da177e4	92	#endif /* _LINUX_MMAN_H */