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

/*
 * Task I/O accounting operations
 */
#ifndef __TASK_IO_ACCOUNTING_OPS_INCLUDED
#define __TASK_IO_ACCOUNTING_OPS_INCLUDED

#include <linux/sched.h>

#ifdef CONFIG_TASK_IO_ACCOUNTING
static inline void task_io_account_read(size_t bytes)
{
	current->ioac.read_bytes += bytes;
}

/*
 * We approximate number of blocks, because we account bytes only.
 * A 'block' is 512 bytes
 */
static inline unsigned long task_io_get_inblock(const struct task_struct *p)
{
	return p->ioac.read_bytes >> 9;
}

static inline void task_io_account_write(size_t bytes)
{
	current->ioac.write_bytes += bytes;
}

/*
 * We approximate number of blocks, because we account bytes only.
 * A 'block' is 512 bytes
 */
static inline unsigned long task_io_get_oublock(const struct task_struct *p)
{
	return p->ioac.write_bytes >> 9;
}

static inline void task_io_account_cancelled_write(size_t bytes)
{
	current->ioac.cancelled_write_bytes += bytes;
}

static inline void task_io_accounting_init(struct task_io_accounting *ioac)
{
	memset(ioac, 0, sizeof(*ioac));
}

static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
						struct task_io_accounting *src)
{
	dst->read_bytes += src->read_bytes;
	dst->write_bytes += src->write_bytes;
	dst->cancelled_write_bytes += src->cancelled_write_bytes;
}

#else

static inline void task_io_account_read(size_t bytes)
{
}

static inline unsigned long task_io_get_inblock(const struct task_struct *p)
{
	return 0;
}

static inline void task_io_account_write(size_t bytes)
{
}

static inline unsigned long task_io_get_oublock(const struct task_struct *p)
{
	return 0;
}

static inline void task_io_account_cancelled_write(size_t bytes)
{
}

static inline void task_io_accounting_init(struct task_io_accounting *ioac)
{
}

static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
						struct task_io_accounting *src)
{
}

#endif /* CONFIG_TASK_IO_ACCOUNTING */

#ifdef CONFIG_TASK_XACCT
static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
						struct task_io_accounting *src)
{
	dst->rchar += src->rchar;
	dst->wchar += src->wchar;
	dst->syscr += src->syscr;
	dst->syscw += src->syscw;
}
#else
static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
						struct task_io_accounting *src)
{
}
#endif /* CONFIG_TASK_XACCT */

static inline void task_io_accounting_add(struct task_io_accounting *dst,
						struct task_io_accounting *src)
{
	task_chr_io_accounting_add(dst, src);
	task_blk_io_accounting_add(dst, src);
}
#endif /* __TASK_IO_ACCOUNTING_OPS_INCLUDED */
Commit	Line	Data
	1	/*
	2	* Task I/O accounting operations
	3	*/
	4	#ifndef __TASK_IO_ACCOUNTING_OPS_INCLUDED
	5	#define __TASK_IO_ACCOUNTING_OPS_INCLUDED
	6
	7	#include <linux/sched.h>
	8
	9	#ifdef CONFIG_TASK_IO_ACCOUNTING
	10	static inline void task_io_account_read(size_t bytes)
	11	{
	12	current->ioac.read_bytes += bytes;
	13	}
	14
	15	/*
	16	* We approximate number of blocks, because we account bytes only.
	17	* A 'block' is 512 bytes
	18	*/
	19	static inline unsigned long task_io_get_inblock(const struct task_struct *p)
	20	{
	21	return p->ioac.read_bytes >> 9;
	22	}
	23
	24	static inline void task_io_account_write(size_t bytes)
	25	{
	26	current->ioac.write_bytes += bytes;
	27	}
	28
	29	/*
	30	* We approximate number of blocks, because we account bytes only.
	31	* A 'block' is 512 bytes
	32	*/
	33	static inline unsigned long task_io_get_oublock(const struct task_struct *p)
	34	{
	35	return p->ioac.write_bytes >> 9;
	36	}
	37
	38	static inline void task_io_account_cancelled_write(size_t bytes)
	39	{
	40	current->ioac.cancelled_write_bytes += bytes;
	41	}
	42
	43	static inline void task_io_accounting_init(struct task_io_accounting *ioac)
	44	{
	45	memset(ioac, 0, sizeof(*ioac));
	46	}
	47
	48	static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
	49	struct task_io_accounting *src)
	50	{
	51	dst->read_bytes += src->read_bytes;
	52	dst->write_bytes += src->write_bytes;
	53	dst->cancelled_write_bytes += src->cancelled_write_bytes;
	54	}
	55
	56	#else
	57
	58	static inline void task_io_account_read(size_t bytes)
	59	{
	60	}
	61
	62	static inline unsigned long task_io_get_inblock(const struct task_struct *p)
	63	{
	64	return 0;
	65	}
	66
	67	static inline void task_io_account_write(size_t bytes)
	68	{
	69	}
	70
	71	static inline unsigned long task_io_get_oublock(const struct task_struct *p)
	72	{
	73	return 0;
	74	}
	75
	76	static inline void task_io_account_cancelled_write(size_t bytes)
	77	{
	78	}
	79
	80	static inline void task_io_accounting_init(struct task_io_accounting *ioac)
	81	{
	82	}
	83
	84	static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
	85	struct task_io_accounting *src)
	86	{
	87	}
	88
	89	#endif /* CONFIG_TASK_IO_ACCOUNTING */
	90
	91	#ifdef CONFIG_TASK_XACCT
	92	static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
	93	struct task_io_accounting *src)
	94	{
	95	dst->rchar += src->rchar;
	96	dst->wchar += src->wchar;
	97	dst->syscr += src->syscr;
	98	dst->syscw += src->syscw;
	99	}
	100	#else
	101	static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
	102	struct task_io_accounting *src)
	103	{
	104	}
	105	#endif /* CONFIG_TASK_XACCT */
	106
	107	static inline void task_io_accounting_add(struct task_io_accounting *dst,
	108	struct task_io_accounting *src)
	109	{
	110	task_chr_io_accounting_add(dst, src);
	111	task_blk_io_accounting_add(dst, src);
	112	}
	113	#endif /* __TASK_IO_ACCOUNTING_OPS_INCLUDED */