[mirror_ubuntu-artful-kernel.git] / include / linux / backing-dev.h

/*
 * include/linux/backing-dev.h
 *
 * low-level device information and state which is propagated up through
 * to high-level code.
 */

#ifndef _LINUX_BACKING_DEV_H
#define _LINUX_BACKING_DEV_H

#include <linux/percpu_counter.h>
#include <linux/log2.h>
#include <linux/proportions.h>
#include <linux/kernel.h>
#include <asm/atomic.h>

struct page;
struct device;
struct dentry;

/*
 * Bits in backing_dev_info.state
 */
enum bdi_state {
	BDI_pdflush,		/* A pdflush thread is working this device */
	BDI_write_congested,	/* The write queue is getting full */
	BDI_read_congested,	/* The read queue is getting full */
	BDI_unused,		/* Available bits start here */
};

typedef int (congested_fn)(void *, int);

enum bdi_stat_item {
	BDI_RECLAIMABLE,
	BDI_WRITEBACK,
	NR_BDI_STAT_ITEMS
};

#define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))

struct backing_dev_info {
	unsigned long ra_pages;	/* max readahead in PAGE_CACHE_SIZE units */
	unsigned long state;	/* Always use atomic bitops on this */
	unsigned int capabilities; /* Device capabilities */
	congested_fn *congested_fn; /* Function pointer if device is md/dm */
	void *congested_data;	/* Pointer to aux data for congested func */
	void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
	void *unplug_io_data;

	struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];

	struct prop_local_percpu completions;
	int dirty_exceeded;

	unsigned int min_ratio;
	unsigned int max_ratio, max_prop_frac;

	struct device *dev;

#ifdef CONFIG_DEBUG_FS
	struct dentry *debug_dir;
	struct dentry *debug_stats;
#endif
};

int bdi_init(struct backing_dev_info *bdi);
void bdi_destroy(struct backing_dev_info *bdi);

int bdi_register(struct backing_dev_info *bdi, struct device *parent,
		const char *fmt, ...);
int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
void bdi_unregister(struct backing_dev_info *bdi);

static inline void __add_bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item, s64 amount)
{
	__percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH);
}

static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	__add_bdi_stat(bdi, item, 1);
}

static inline void inc_bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	unsigned long flags;

	local_irq_save(flags);
	__inc_bdi_stat(bdi, item);
	local_irq_restore(flags);
}

static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	__add_bdi_stat(bdi, item, -1);
}

static inline void dec_bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	unsigned long flags;

	local_irq_save(flags);
	__dec_bdi_stat(bdi, item);
	local_irq_restore(flags);
}

static inline s64 bdi_stat(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	return percpu_counter_read_positive(&bdi->bdi_stat[item]);
}

static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
}

static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
		enum bdi_stat_item item)
{
	s64 sum;
	unsigned long flags;

	local_irq_save(flags);
	sum = __bdi_stat_sum(bdi, item);
	local_irq_restore(flags);

	return sum;
}

/*
 * maximal error of a stat counter.
 */
static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
{
#ifdef CONFIG_SMP
	return nr_cpu_ids * BDI_STAT_BATCH;
#else
	return 1;
#endif
}

int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);

/*
 * Flags in backing_dev_info::capability
 * - The first two flags control whether dirty pages will contribute to the
 *   VM's accounting and whether writepages() should be called for dirty pages
 *   (something that would not, for example, be appropriate for ramfs)
 * - These flags let !MMU mmap() govern direct device mapping vs immediate
 *   copying more easily for MAP_PRIVATE, especially for ROM filesystems
 */
#define BDI_CAP_NO_ACCT_DIRTY	0x00000001	/* Dirty pages shouldn't contribute to accounting */
#define BDI_CAP_NO_WRITEBACK	0x00000002	/* Don't write pages back */
#define BDI_CAP_MAP_COPY	0x00000004	/* Copy can be mapped (MAP_PRIVATE) */
#define BDI_CAP_MAP_DIRECT	0x00000008	/* Can be mapped directly (MAP_SHARED) */
#define BDI_CAP_READ_MAP	0x00000010	/* Can be mapped for reading */
#define BDI_CAP_WRITE_MAP	0x00000020	/* Can be mapped for writing */
#define BDI_CAP_EXEC_MAP	0x00000040	/* Can be mapped for execution */
#define BDI_CAP_VMFLAGS \
	(BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)

#if defined(VM_MAYREAD) && \
	(BDI_CAP_READ_MAP != VM_MAYREAD || \
	 BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
	 BDI_CAP_EXEC_MAP != VM_MAYEXEC)
#error please change backing_dev_info::capabilities flags
#endif

extern struct backing_dev_info default_backing_dev_info;
void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);

int writeback_in_progress(struct backing_dev_info *bdi);

static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
{
	if (bdi->congested_fn)
		return bdi->congested_fn(bdi->congested_data, bdi_bits);
	return (bdi->state & bdi_bits);
}

static inline int bdi_read_congested(struct backing_dev_info *bdi)
{
	return bdi_congested(bdi, 1 << BDI_read_congested);
}

static inline int bdi_write_congested(struct backing_dev_info *bdi)
{
	return bdi_congested(bdi, 1 << BDI_write_congested);
}

static inline int bdi_rw_congested(struct backing_dev_info *bdi)
{
	return bdi_congested(bdi, (1 << BDI_read_congested)|
				  (1 << BDI_write_congested));
}

void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
void set_bdi_congested(struct backing_dev_info *bdi, int rw);
long congestion_wait(int rw, long timeout);

#define bdi_cap_writeback_dirty(bdi) \
	(!((bdi)->capabilities & BDI_CAP_NO_WRITEBACK))

#define bdi_cap_account_dirty(bdi) \
	(!((bdi)->capabilities & BDI_CAP_NO_ACCT_DIRTY))

#define mapping_cap_writeback_dirty(mapping) \
	bdi_cap_writeback_dirty((mapping)->backing_dev_info)

#define mapping_cap_account_dirty(mapping) \
	bdi_cap_account_dirty((mapping)->backing_dev_info)


#endif		/* _LINUX_BACKING_DEV_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* include/linux/backing-dev.h
	3	*
	4	* low-level device information and state which is propagated up through
	5	* to high-level code.
	6	*/
	7
	8	#ifndef _LINUX_BACKING_DEV_H
	9	#define _LINUX_BACKING_DEV_H
	10
b2e8fb6e PZ	11	#include <linux/percpu_counter.h>
b2e8fb6e PZ	12	#include <linux/log2.h>
04fbfdc1	13	#include <linux/proportions.h>
cf0ca9fe	14	#include <linux/kernel.h>
1da177e4 LT	15	#include <asm/atomic.h>
1da177e4 LT	16
3fcfab16	17	struct page;
cf0ca9fe	18	struct device;
76f1418b	19	struct dentry;
3fcfab16	20
1da177e4 LT	21	/*
	22	* Bits in backing_dev_info.state
	23	*/
	24	enum bdi_state {
	25	BDI_pdflush, /* A pdflush thread is working this device */
	26	BDI_write_congested, /* The write queue is getting full */
	27	BDI_read_congested, /* The read queue is getting full */
	28	BDI_unused, /* Available bits start here */
	29	};
	30
	31	typedef int (congested_fn)(void *, int);
	32
b2e8fb6e	33	enum bdi_stat_item {
c9e51e41	34	BDI_RECLAIMABLE,
69cb51d1	35	BDI_WRITEBACK,
b2e8fb6e PZ	36	NR_BDI_STAT_ITEMS
	37	};
	38
	39	#define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
	40
1da177e4 LT	41	struct backing_dev_info {
	42	unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
	43	unsigned long state; /* Always use atomic bitops on this */
	44	unsigned int capabilities; /* Device capabilities */
	45	congested_fn congested_fn; / Function pointer if device is md/dm */
	46	void congested_data; / Pointer to aux data for congested func */
	47	void (unplug_io_fn)(struct backing_dev_info , struct page *);
	48	void *unplug_io_data;
b2e8fb6e PZ	49
b2e8fb6e PZ	50	struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
04fbfdc1 PZ	51
	52	struct prop_local_percpu completions;
	53	int dirty_exceeded;
cf0ca9fe	54
189d3c4a	55	unsigned int min_ratio;
a42dde04	56	unsigned int max_ratio, max_prop_frac;
189d3c4a	57
cf0ca9fe	58	struct device *dev;
76f1418b MS	59
	60	#ifdef CONFIG_DEBUG_FS
	61	struct dentry *debug_dir;
	62	struct dentry *debug_stats;
	63	#endif
1da177e4 LT	64	};
1da177e4 LT	65
b2e8fb6e PZ	66	int bdi_init(struct backing_dev_info *bdi);
	67	void bdi_destroy(struct backing_dev_info *bdi);
	68
cf0ca9fe PZ	69	int bdi_register(struct backing_dev_info bdi, struct device parent,
	70	const char *fmt, ...);
	71	int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
	72	void bdi_unregister(struct backing_dev_info *bdi);
	73
b2e8fb6e PZ	74	static inline void __add_bdi_stat(struct backing_dev_info *bdi,
	75	enum bdi_stat_item item, s64 amount)
	76	{
	77	__percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH);
	78	}
	79
	80	static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
	81	enum bdi_stat_item item)
	82	{
	83	__add_bdi_stat(bdi, item, 1);
	84	}
	85
	86	static inline void inc_bdi_stat(struct backing_dev_info *bdi,
	87	enum bdi_stat_item item)
	88	{
	89	unsigned long flags;
	90
	91	local_irq_save(flags);
	92	__inc_bdi_stat(bdi, item);
	93	local_irq_restore(flags);
	94	}
	95
	96	static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
	97	enum bdi_stat_item item)
	98	{
	99	__add_bdi_stat(bdi, item, -1);
	100	}
	101
	102	static inline void dec_bdi_stat(struct backing_dev_info *bdi,
	103	enum bdi_stat_item item)
	104	{
	105	unsigned long flags;
	106
	107	local_irq_save(flags);
	108	__dec_bdi_stat(bdi, item);
	109	local_irq_restore(flags);
	110	}
	111
	112	static inline s64 bdi_stat(struct backing_dev_info *bdi,
	113	enum bdi_stat_item item)
	114	{
	115	return percpu_counter_read_positive(&bdi->bdi_stat[item]);
	116	}
	117
	118	static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
	119	enum bdi_stat_item item)
	120	{
	121	return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
	122	}
	123
	124	static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
	125	enum bdi_stat_item item)
e0bf68dd	126	{
b2e8fb6e PZ	127	s64 sum;
	128	unsigned long flags;
	129
	130	local_irq_save(flags);
	131	sum = __bdi_stat_sum(bdi, item);
	132	local_irq_restore(flags);
	133
	134	return sum;
e0bf68dd PZ	135	}
e0bf68dd PZ	136
b2e8fb6e PZ	137	/*
	138	* maximal error of a stat counter.
	139	*/
	140	static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
e0bf68dd	141	{
b2e8fb6e PZ	142	#ifdef CONFIG_SMP
	143	return nr_cpu_ids * BDI_STAT_BATCH;
	144	#else
	145	return 1;
	146	#endif
e0bf68dd	147	}
1da177e4	148
189d3c4a	149	int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
a42dde04	150	int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
189d3c4a	151
1da177e4 LT	152	/*
	153	* Flags in backing_dev_info::capability
	154	* - The first two flags control whether dirty pages will contribute to the
	155	* VM's accounting and whether writepages() should be called for dirty pages
	156	* (something that would not, for example, be appropriate for ramfs)
	157	* - These flags let !MMU mmap() govern direct device mapping vs immediate
	158	* copying more easily for MAP_PRIVATE, especially for ROM filesystems
	159	*/
	160	#define BDI_CAP_NO_ACCT_DIRTY 0x00000001 /* Dirty pages shouldn't contribute to accounting */
	161	#define BDI_CAP_NO_WRITEBACK 0x00000002 /* Don't write pages back */
	162	#define BDI_CAP_MAP_COPY 0x00000004 /* Copy can be mapped (MAP_PRIVATE) */
	163	#define BDI_CAP_MAP_DIRECT 0x00000008 /* Can be mapped directly (MAP_SHARED) */
	164	#define BDI_CAP_READ_MAP 0x00000010 /* Can be mapped for reading */
	165	#define BDI_CAP_WRITE_MAP 0x00000020 /* Can be mapped for writing */
	166	#define BDI_CAP_EXEC_MAP 0x00000040 /* Can be mapped for execution */
	167	#define BDI_CAP_VMFLAGS \
	168	(BDI_CAP_READ_MAP \| BDI_CAP_WRITE_MAP \| BDI_CAP_EXEC_MAP)
	169
	170	#if defined(VM_MAYREAD) && \
	171	(BDI_CAP_READ_MAP != VM_MAYREAD \|\| \
	172	BDI_CAP_WRITE_MAP != VM_MAYWRITE \|\| \
	173	BDI_CAP_EXEC_MAP != VM_MAYEXEC)
	174	#error please change backing_dev_info::capabilities flags
	175	#endif
	176
	177	extern struct backing_dev_info default_backing_dev_info;
	178	void default_unplug_io_fn(struct backing_dev_info bdi, struct page page);
	179
1da177e4	180	int writeback_in_progress(struct backing_dev_info *bdi);
1da177e4 LT	181
	182	static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
	183	{
	184	if (bdi->congested_fn)
	185	return bdi->congested_fn(bdi->congested_data, bdi_bits);
	186	return (bdi->state & bdi_bits);
	187	}
	188
	189	static inline int bdi_read_congested(struct backing_dev_info *bdi)
	190	{
	191	return bdi_congested(bdi, 1 << BDI_read_congested);
	192	}
	193
	194	static inline int bdi_write_congested(struct backing_dev_info *bdi)
	195	{
	196	return bdi_congested(bdi, 1 << BDI_write_congested);
	197	}
	198
	199	static inline int bdi_rw_congested(struct backing_dev_info *bdi)
	200	{
	201	return bdi_congested(bdi, (1 << BDI_read_congested)\|
	202	(1 << BDI_write_congested));
	203	}
	204
3fcfab16 AM	205	void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
	206	void set_bdi_congested(struct backing_dev_info *bdi, int rw);
	207	long congestion_wait(int rw, long timeout);
3fcfab16	208
1da177e4 LT	209	#define bdi_cap_writeback_dirty(bdi) \
	210	(!((bdi)->capabilities & BDI_CAP_NO_WRITEBACK))
	211
	212	#define bdi_cap_account_dirty(bdi) \
	213	(!((bdi)->capabilities & BDI_CAP_NO_ACCT_DIRTY))
	214
	215	#define mapping_cap_writeback_dirty(mapping) \
	216	bdi_cap_writeback_dirty((mapping)->backing_dev_info)
	217
	218	#define mapping_cap_account_dirty(mapping) \
	219	bdi_cap_account_dirty((mapping)->backing_dev_info)
	220
	221
	222	#endif /* _LINUX_BACKING_DEV_H */