[deliverable/linux.git] / drivers / md / dm.h

/*
 * Internal header file for device mapper
 *
 * Copyright (C) 2001, 2002 Sistina Software
 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
 *
 * This file is released under the LGPL.
 */

#ifndef DM_INTERNAL_H
#define DM_INTERNAL_H

#include <linux/fs.h>
#include <linux/device-mapper.h>
#include <linux/list.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>
#include <linux/completion.h>
#include <linux/kobject.h>

#include "dm-stats.h"

/*
 * Suspend feature flags
 */
#define DM_SUSPEND_LOCKFS_FLAG		(1 << 0)
#define DM_SUSPEND_NOFLUSH_FLAG		(1 << 1)

/*
 * Status feature flags
 */
#define DM_STATUS_NOFLUSH_FLAG		(1 << 0)

/*
 * Type of table and mapped_device's mempool
 */
#define DM_TYPE_NONE			0
#define DM_TYPE_BIO_BASED		1
#define DM_TYPE_REQUEST_BASED		2
#define DM_TYPE_MQ_REQUEST_BASED	3

/*
 * List of devices that a metadevice uses and should open/close.
 */
struct dm_dev_internal {
	struct list_head list;
	atomic_t count;
	struct dm_dev *dm_dev;
};

struct dm_table;
struct dm_md_mempools;

/*-----------------------------------------------------------------
 * Internal table functions.
 *---------------------------------------------------------------*/
void dm_table_destroy(struct dm_table *t);
void dm_table_event_callback(struct dm_table *t,
			     void (*fn)(void *), void *context);
struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index);
struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector);
bool dm_table_has_no_data_devices(struct dm_table *table);
int dm_calculate_queue_limits(struct dm_table *table,
			      struct queue_limits *limits);
void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
			       struct queue_limits *limits);
struct list_head *dm_table_get_devices(struct dm_table *t);
void dm_table_presuspend_targets(struct dm_table *t);
void dm_table_presuspend_undo_targets(struct dm_table *t);
void dm_table_postsuspend_targets(struct dm_table *t);
int dm_table_resume_targets(struct dm_table *t);
int dm_table_any_congested(struct dm_table *t, int bdi_bits);
int dm_table_any_busy_target(struct dm_table *t);
unsigned dm_table_get_type(struct dm_table *t);
struct target_type *dm_table_get_immutable_target_type(struct dm_table *t);
bool dm_table_request_based(struct dm_table *t);
bool dm_table_mq_request_based(struct dm_table *t);
void dm_table_free_md_mempools(struct dm_table *t);
struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);

int dm_queue_merge_is_compulsory(struct request_queue *q);

void dm_lock_md_type(struct mapped_device *md);
void dm_unlock_md_type(struct mapped_device *md);
void dm_set_md_type(struct mapped_device *md, unsigned type);
unsigned dm_get_md_type(struct mapped_device *md);
struct target_type *dm_get_immutable_target_type(struct mapped_device *md);

int dm_setup_md_queue(struct mapped_device *md);

/*
 * To check the return value from dm_table_find_target().
 */
#define dm_target_is_valid(t) ((t)->table)

/*
 * To check whether the target type is bio-based or not (request-based).
 */
#define dm_target_bio_based(t) ((t)->type->map != NULL)

/*
 * To check whether the target type is request-based or not (bio-based).
 */
#define dm_target_request_based(t) (((t)->type->map_rq != NULL) || \
				    ((t)->type->clone_and_map_rq != NULL))

/*
 * To check whether the target type is a hybrid (capable of being
 * either request-based or bio-based).
 */
#define dm_target_hybrid(t) (dm_target_bio_based(t) && dm_target_request_based(t))

/*-----------------------------------------------------------------
 * A registry of target types.
 *---------------------------------------------------------------*/
int dm_target_init(void);
void dm_target_exit(void);
struct target_type *dm_get_target_type(const char *name);
void dm_put_target_type(struct target_type *tt);
int dm_target_iterate(void (*iter_func)(struct target_type *tt,
					void *param), void *param);

int dm_split_args(int *argc, char ***argvp, char *input);

/*
 * Is this mapped_device being deleted?
 */
int dm_deleting_md(struct mapped_device *md);

/*
 * Is this mapped_device suspended?
 */
int dm_suspended_md(struct mapped_device *md);

/*
 * Internal suspend and resume methods.
 */
int dm_suspended_internally_md(struct mapped_device *md);
void dm_internal_suspend_fast(struct mapped_device *md);
void dm_internal_resume_fast(struct mapped_device *md);
void dm_internal_suspend_noflush(struct mapped_device *md);
void dm_internal_resume(struct mapped_device *md);

/*
 * Test if the device is scheduled for deferred remove.
 */
int dm_test_deferred_remove_flag(struct mapped_device *md);

/*
 * Try to remove devices marked for deferred removal.
 */
void dm_deferred_remove(void);

/*
 * The device-mapper can be driven through one of two interfaces;
 * ioctl or filesystem, depending which patch you have applied.
 */
int dm_interface_init(void);
void dm_interface_exit(void);

/*
 * sysfs interface
 */
struct dm_kobject_holder {
	struct kobject kobj;
	struct completion completion;
};

static inline struct completion *dm_get_completion_from_kobject(struct kobject *kobj)
{
	return &container_of(kobj, struct dm_kobject_holder, kobj)->completion;
}

int dm_sysfs_init(struct mapped_device *md);
void dm_sysfs_exit(struct mapped_device *md);
struct kobject *dm_kobject(struct mapped_device *md);
struct mapped_device *dm_get_from_kobject(struct kobject *kobj);

/*
 * The kobject helper
 */
void dm_kobject_release(struct kobject *kobj);

/*
 * Targets for linear and striped mappings
 */
int dm_linear_init(void);
void dm_linear_exit(void);

int dm_stripe_init(void);
void dm_stripe_exit(void);

/*
 * mapped_device operations
 */
void dm_destroy(struct mapped_device *md);
void dm_destroy_immediate(struct mapped_device *md);
int dm_open_count(struct mapped_device *md);
int dm_lock_for_deletion(struct mapped_device *md, bool mark_deferred, bool only_deferred);
int dm_cancel_deferred_remove(struct mapped_device *md);
int dm_request_based(struct mapped_device *md);
sector_t dm_get_size(struct mapped_device *md);
struct request_queue *dm_get_md_queue(struct mapped_device *md);
int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode,
			struct dm_dev **result);
void dm_put_table_device(struct mapped_device *md, struct dm_dev *d);
struct dm_stats *dm_get_stats(struct mapped_device *md);

int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
		      unsigned cookie);

void dm_internal_suspend(struct mapped_device *md);
void dm_internal_resume(struct mapped_device *md);

int dm_io_init(void);
void dm_io_exit(void);

int dm_kcopyd_init(void);
void dm_kcopyd_exit(void);

/*
 * Mempool operations
 */
struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity, unsigned per_bio_data_size);
void dm_free_md_mempools(struct dm_md_mempools *pools);

/*
 * Helpers that are used by DM core
 */
unsigned dm_get_reserved_bio_based_ios(void);
unsigned dm_get_reserved_rq_based_ios(void);

static inline bool dm_message_test_buffer_overflow(char *result, unsigned maxlen)
{
	return !maxlen || strlen(result) + 1 >= maxlen;
}

#endif
Commit	Line	Data
	1	/*
	2	* Internal header file for device mapper
	3	*
	4	* Copyright (C) 2001, 2002 Sistina Software
	5	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
	6	*
	7	* This file is released under the LGPL.
	8	*/
	9
	10	#ifndef DM_INTERNAL_H
	11	#define DM_INTERNAL_H
	12
	13	#include <linux/fs.h>
	14	#include <linux/device-mapper.h>
	15	#include <linux/list.h>
	16	#include <linux/blkdev.h>
	17	#include <linux/hdreg.h>
	18	#include <linux/completion.h>
	19	#include <linux/kobject.h>
	20
	21	#include "dm-stats.h"
	22
	23	/*
	24	* Suspend feature flags
	25	*/
	26	#define DM_SUSPEND_LOCKFS_FLAG (1 << 0)
	27	#define DM_SUSPEND_NOFLUSH_FLAG (1 << 1)
	28
	29	/*
	30	* Status feature flags
	31	*/
	32	#define DM_STATUS_NOFLUSH_FLAG (1 << 0)
	33
	34	/*
	35	* Type of table and mapped_device's mempool
	36	*/
	37	#define DM_TYPE_NONE 0
	38	#define DM_TYPE_BIO_BASED 1
	39	#define DM_TYPE_REQUEST_BASED 2
	40	#define DM_TYPE_MQ_REQUEST_BASED 3
	41
	42	/*
	43	* List of devices that a metadevice uses and should open/close.
	44	*/
	45	struct dm_dev_internal {
	46	struct list_head list;
	47	atomic_t count;
	48	struct dm_dev *dm_dev;
	49	};
	50
	51	struct dm_table;
	52	struct dm_md_mempools;
	53
	54	/*-----------------------------------------------------------------
	55	* Internal table functions.
	56	---------------------------------------------------------------/
	57	void dm_table_destroy(struct dm_table *t);
	58	void dm_table_event_callback(struct dm_table *t,
	59	void (fn)(void ), void *context);
	60	struct dm_target dm_table_get_target(struct dm_table t, unsigned int index);
	61	struct dm_target dm_table_find_target(struct dm_table t, sector_t sector);
	62	bool dm_table_has_no_data_devices(struct dm_table *table);
	63	int dm_calculate_queue_limits(struct dm_table *table,
	64	struct queue_limits *limits);
	65	void dm_table_set_restrictions(struct dm_table t, struct request_queue q,
	66	struct queue_limits *limits);
	67	struct list_head dm_table_get_devices(struct dm_table t);
	68	void dm_table_presuspend_targets(struct dm_table *t);
	69	void dm_table_presuspend_undo_targets(struct dm_table *t);
	70	void dm_table_postsuspend_targets(struct dm_table *t);
	71	int dm_table_resume_targets(struct dm_table *t);
	72	int dm_table_any_congested(struct dm_table *t, int bdi_bits);
	73	int dm_table_any_busy_target(struct dm_table *t);
	74	unsigned dm_table_get_type(struct dm_table *t);
	75	struct target_type dm_table_get_immutable_target_type(struct dm_table t);
	76	bool dm_table_request_based(struct dm_table *t);
	77	bool dm_table_mq_request_based(struct dm_table *t);
	78	void dm_table_free_md_mempools(struct dm_table *t);
	79	struct dm_md_mempools dm_table_get_md_mempools(struct dm_table t);
	80
	81	int dm_queue_merge_is_compulsory(struct request_queue *q);
	82
	83	void dm_lock_md_type(struct mapped_device *md);
	84	void dm_unlock_md_type(struct mapped_device *md);
	85	void dm_set_md_type(struct mapped_device *md, unsigned type);
	86	unsigned dm_get_md_type(struct mapped_device *md);
	87	struct target_type dm_get_immutable_target_type(struct mapped_device md);
	88
	89	int dm_setup_md_queue(struct mapped_device *md);
	90
	91	/*
	92	* To check the return value from dm_table_find_target().
	93	*/
	94	#define dm_target_is_valid(t) ((t)->table)
	95
	96	/*
	97	* To check whether the target type is bio-based or not (request-based).
	98	*/
	99	#define dm_target_bio_based(t) ((t)->type->map != NULL)
	100
	101	/*
	102	* To check whether the target type is request-based or not (bio-based).
	103	*/
	104	#define dm_target_request_based(t) (((t)->type->map_rq != NULL) \|\| \
	105	((t)->type->clone_and_map_rq != NULL))
	106
	107	/*
	108	* To check whether the target type is a hybrid (capable of being
	109	* either request-based or bio-based).
	110	*/
	111	#define dm_target_hybrid(t) (dm_target_bio_based(t) && dm_target_request_based(t))
	112
	113	/*-----------------------------------------------------------------
	114	* A registry of target types.
	115	---------------------------------------------------------------/
	116	int dm_target_init(void);
	117	void dm_target_exit(void);
	118	struct target_type dm_get_target_type(const char name);
	119	void dm_put_target_type(struct target_type *tt);
	120	int dm_target_iterate(void (iter_func)(struct target_type tt,
	121	void param), void param);
	122
	123	int dm_split_args(int argc, char *argvp, char input);
	124
	125	/*
	126	* Is this mapped_device being deleted?
	127	*/
	128	int dm_deleting_md(struct mapped_device *md);
	129
	130	/*
	131	* Is this mapped_device suspended?
	132	*/
	133	int dm_suspended_md(struct mapped_device *md);
	134
	135	/*
	136	* Internal suspend and resume methods.
	137	*/
	138	int dm_suspended_internally_md(struct mapped_device *md);
	139	void dm_internal_suspend_fast(struct mapped_device *md);
	140	void dm_internal_resume_fast(struct mapped_device *md);
	141	void dm_internal_suspend_noflush(struct mapped_device *md);
	142	void dm_internal_resume(struct mapped_device *md);
	143
	144	/*
	145	* Test if the device is scheduled for deferred remove.
	146	*/
	147	int dm_test_deferred_remove_flag(struct mapped_device *md);
	148
	149	/*
	150	* Try to remove devices marked for deferred removal.
	151	*/
	152	void dm_deferred_remove(void);
	153
	154	/*
	155	* The device-mapper can be driven through one of two interfaces;
	156	* ioctl or filesystem, depending which patch you have applied.
	157	*/
	158	int dm_interface_init(void);
	159	void dm_interface_exit(void);
	160
	161	/*
	162	* sysfs interface
	163	*/
	164	struct dm_kobject_holder {
	165	struct kobject kobj;
	166	struct completion completion;
	167	};
	168
	169	static inline struct completion dm_get_completion_from_kobject(struct kobject kobj)
	170	{
	171	return &container_of(kobj, struct dm_kobject_holder, kobj)->completion;
	172	}
	173
	174	int dm_sysfs_init(struct mapped_device *md);
	175	void dm_sysfs_exit(struct mapped_device *md);
	176	struct kobject dm_kobject(struct mapped_device md);
	177	struct mapped_device dm_get_from_kobject(struct kobject kobj);
	178
	179	/*
	180	* The kobject helper
	181	*/
	182	void dm_kobject_release(struct kobject *kobj);
	183
	184	/*
	185	* Targets for linear and striped mappings
	186	*/
	187	int dm_linear_init(void);
	188	void dm_linear_exit(void);
	189
	190	int dm_stripe_init(void);
	191	void dm_stripe_exit(void);
	192
	193	/*
	194	* mapped_device operations
	195	*/
	196	void dm_destroy(struct mapped_device *md);
	197	void dm_destroy_immediate(struct mapped_device *md);
	198	int dm_open_count(struct mapped_device *md);
	199	int dm_lock_for_deletion(struct mapped_device *md, bool mark_deferred, bool only_deferred);
	200	int dm_cancel_deferred_remove(struct mapped_device *md);
	201	int dm_request_based(struct mapped_device *md);
	202	sector_t dm_get_size(struct mapped_device *md);
	203	struct request_queue dm_get_md_queue(struct mapped_device md);
	204	int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode,
	205	struct dm_dev **result);
	206	void dm_put_table_device(struct mapped_device md, struct dm_dev d);
	207	struct dm_stats dm_get_stats(struct mapped_device md);
	208
	209	int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
	210	unsigned cookie);
	211
	212	void dm_internal_suspend(struct mapped_device *md);
	213	void dm_internal_resume(struct mapped_device *md);
	214
	215	int dm_io_init(void);
	216	void dm_io_exit(void);
	217
	218	int dm_kcopyd_init(void);
	219	void dm_kcopyd_exit(void);
	220
	221	/*
	222	* Mempool operations
	223	*/
	224	struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity, unsigned per_bio_data_size);
	225	void dm_free_md_mempools(struct dm_md_mempools *pools);
	226
	227	/*
	228	* Helpers that are used by DM core
	229	*/
	230	unsigned dm_get_reserved_bio_based_ios(void);
	231	unsigned dm_get_reserved_rq_based_ios(void);
	232
	233	static inline bool dm_message_test_buffer_overflow(char *result, unsigned maxlen)
	234	{
	235	return !maxlen \|\| strlen(result) + 1 >= maxlen;
	236	}
	237
	238	#endif