device-mapper.h 17.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
Alasdair G Kergon's avatar
Alasdair G Kergon committed
3
 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10
 *
 * This file is released under the LGPL.
 */

#ifndef _LINUX_DEVICE_MAPPER_H
#define _LINUX_DEVICE_MAPPER_H

11
#include <linux/bio.h>
Milan Broz's avatar
Milan Broz committed
12
#include <linux/blkdev.h>
13
#include <linux/math64.h>
14
#include <linux/ratelimit.h>
15

16
struct dm_dev;
Linus Torvalds's avatar
Linus Torvalds committed
17 18
struct dm_target;
struct dm_table;
19
struct mapped_device;
Milan Broz's avatar
Milan Broz committed
20
struct bio_vec;
Linus Torvalds's avatar
Linus Torvalds committed
21

22 23 24 25 26 27 28
/*
 * Type of table, mapped_device's mempool and request_queue
 */
#define DM_TYPE_NONE			0
#define DM_TYPE_BIO_BASED		1
#define DM_TYPE_REQUEST_BASED		2
#define DM_TYPE_MQ_REQUEST_BASED	3
29
#define DM_TYPE_DAX_BIO_BASED		4
30

Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;

union map_info {
	void *ptr;
};

/*
 * In the constructor the target parameter will already have the
 * table, type, begin and len fields filled in.
 */
typedef int (*dm_ctr_fn) (struct dm_target *target,
			  unsigned int argc, char **argv);

/*
 * The destructor doesn't need to free the dm_target, just
 * anything hidden ti->private.
 */
typedef void (*dm_dtr_fn) (struct dm_target *ti);

/*
 * The map function must return:
 * < 0: error
 * = 0: The target will handle the io by resubmitting it later
54
 * = 1: simple remap complete
55
 * = 2: The target wants to push back the io
Linus Torvalds's avatar
Linus Torvalds committed
56
 */
Mikulas Patocka's avatar
Mikulas Patocka committed
57
typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
58 59
typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
				  union map_info *map_context);
60 61 62 63 64
typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,
					    struct request *rq,
					    union map_info *map_context,
					    struct request **clone);
typedef void (*dm_release_clone_request_fn) (struct request *clone);
Linus Torvalds's avatar
Linus Torvalds committed
65 66 67 68 69 70 71

/*
 * Returns:
 * < 0 : error (currently ignored)
 * 0   : ended successfully
 * 1   : for some reason the io has still not completed (eg,
 *       multipath target might want to requeue a failed io).
72
 * 2   : The target wants to push back the io
Linus Torvalds's avatar
Linus Torvalds committed
73 74
 */
typedef int (*dm_endio_fn) (struct dm_target *ti,
Mikulas Patocka's avatar
Mikulas Patocka committed
75
			    struct bio *bio, int error);
76 77 78
typedef int (*dm_request_endio_fn) (struct dm_target *ti,
				    struct request *clone, int error,
				    union map_info *map_context);
Linus Torvalds's avatar
Linus Torvalds committed
79 80

typedef void (*dm_presuspend_fn) (struct dm_target *ti);
81
typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);
Linus Torvalds's avatar
Linus Torvalds committed
82
typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
83
typedef int (*dm_preresume_fn) (struct dm_target *ti);
Linus Torvalds's avatar
Linus Torvalds committed
84 85
typedef void (*dm_resume_fn) (struct dm_target *ti);

86 87
typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
			      unsigned status_flags, char *result, unsigned maxlen);
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90

typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);

91 92
typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti,
			    struct block_device **bdev, fmode_t *mode);
93

94 95 96 97 98 99 100 101 102 103
/*
 * These iteration functions are typically used to check (and combine)
 * properties of underlying devices.
 * E.g. Does at least one underlying device support flush?
 *      Does any underlying device not support WRITE_SAME?
 *
 * The callout function is called once for each contiguous section of
 * an underlying device.  State can be maintained in *data.
 * Return non-zero to stop iterating through any further devices.
 */
104 105
typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
					   struct dm_dev *dev,
106
					   sector_t start, sector_t len,
107 108
					   void *data);

109 110 111 112 113
/*
 * This function must iterate through each section of device used by the
 * target until it encounters a non-zero return code, which it then returns.
 * Returns zero if no callout returned non-zero.
 */
114 115 116 117
typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
				      iterate_devices_callout_fn fn,
				      void *data);

118 119 120
typedef void (*dm_io_hints_fn) (struct dm_target *ti,
				struct queue_limits *limits);

121 122 123 124 125 126 127
/*
 * Returns:
 *    0: The target can handle the next I/O immediately.
 *    1: The target can't handle the next I/O immediately.
 */
typedef int (*dm_busy_fn) (struct dm_target *ti);

128 129 130 131 132 133
/*
 * Returns:
 *  < 0 : error
 * >= 0 : the number of bytes accessible at the address
 */
typedef long (*dm_direct_access_fn) (struct dm_target *ti, sector_t sector,
134
				     void **kaddr, pfn_t *pfn, long size);
135

Linus Torvalds's avatar
Linus Torvalds committed
136 137
void dm_error(const char *message);

138 139
struct dm_dev {
	struct block_device *bdev;
140
	fmode_t mode;
141 142 143
	char name[16];
};

144 145
dev_t dm_get_dev_t(const char *path);

Linus Torvalds's avatar
Linus Torvalds committed
146 147 148 149
/*
 * Constructors should call these functions to ensure destination devices
 * are opened/closed correctly.
 */
150
int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
151
		  struct dm_dev **result);
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155 156
void dm_put_device(struct dm_target *ti, struct dm_dev *d);

/*
 * Information about a target type
 */
157

Linus Torvalds's avatar
Linus Torvalds committed
158
struct target_type {
159
	uint64_t features;
Linus Torvalds's avatar
Linus Torvalds committed
160 161
	const char *name;
	struct module *module;
162
	unsigned version[3];
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165
	dm_ctr_fn ctr;
	dm_dtr_fn dtr;
	dm_map_fn map;
166
	dm_map_request_fn map_rq;
167 168
	dm_clone_and_map_request_fn clone_and_map_rq;
	dm_release_clone_request_fn release_clone_rq;
Linus Torvalds's avatar
Linus Torvalds committed
169
	dm_endio_fn end_io;
170
	dm_request_endio_fn rq_end_io;
Linus Torvalds's avatar
Linus Torvalds committed
171
	dm_presuspend_fn presuspend;
172
	dm_presuspend_undo_fn presuspend_undo;
Linus Torvalds's avatar
Linus Torvalds committed
173
	dm_postsuspend_fn postsuspend;
174
	dm_preresume_fn preresume;
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177
	dm_resume_fn resume;
	dm_status_fn status;
	dm_message_fn message;
178
	dm_prepare_ioctl_fn prepare_ioctl;
179
	dm_busy_fn busy;
180
	dm_iterate_devices_fn iterate_devices;
181
	dm_io_hints_fn io_hints;
182
	dm_direct_access_fn direct_access;
183 184 185

	/* For internal device-mapper use. */
	struct list_head list;
Linus Torvalds's avatar
Linus Torvalds committed
186 187
};

188 189 190 191 192 193 194 195 196 197
/*
 * Target features
 */

/*
 * Any table that contains an instance of this target must have only one.
 */
#define DM_TARGET_SINGLETON		0x00000001
#define dm_target_needs_singleton(type)	((type)->features & DM_TARGET_SINGLETON)

198 199 200 201 202 203 204
/*
 * Indicates that a target does not support read-only devices.
 */
#define DM_TARGET_ALWAYS_WRITEABLE	0x00000002
#define dm_target_always_writeable(type) \
		((type)->features & DM_TARGET_ALWAYS_WRITEABLE)

205 206 207 208 209 210 211
/*
 * Any device that contains a table with an instance of this target may never
 * have tables containing any different target type.
 */
#define DM_TARGET_IMMUTABLE		0x00000004
#define dm_target_is_immutable(type)	((type)->features & DM_TARGET_IMMUTABLE)

212 213 214 215 216 217 218
/*
 * Indicates that a target may replace any target; even immutable targets.
 * .map, .map_rq, .clone_and_map_rq and .release_clone_rq are all defined.
 */
#define DM_TARGET_WILDCARD		0x00000008
#define dm_target_is_wildcard(type)	((type)->features & DM_TARGET_WILDCARD)

219 220 221 222 223 224 225 226
/*
 * Some targets need to be sent the same WRITE bio severals times so
 * that they can send copies of it to different devices.  This function
 * examines any supplied bio and returns the number of copies of it the
 * target requires.
 */
typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);

Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232 233 234
struct dm_target {
	struct dm_table *table;
	struct target_type *type;

	/* target limits */
	sector_t begin;
	sector_t len;

235 236
	/* If non-zero, maximum size of I/O submitted to a target. */
	uint32_t max_io_len;
Linus Torvalds's avatar
Linus Torvalds committed
237

238
	/*
239
	 * A number of zero-length barrier bios that will be submitted
240 241
	 * to the target for the purpose of flushing cache.
	 *
242 243
	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
	 * It is a responsibility of the target driver to remap these bios
244 245
	 * to the real underlying devices.
	 */
246
	unsigned num_flush_bios;
247

248
	/*
249 250
	 * The number of discard bios that will be submitted to the target.
	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
251
	 */
252
	unsigned num_discard_bios;
253

254
	/*
255 256
	 * The number of WRITE SAME bios that will be submitted to the target.
	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
257
	 */
258
	unsigned num_write_same_bios;
259

260
	/*
261 262
	 * The minimum number of extra bytes allocated in each io for the
	 * target to use.
263
	 */
264
	unsigned per_io_data_size;
265

266 267 268 269 270 271 272
	/*
	 * If defined, this function is called to find out how many
	 * duplicate bios should be sent to the target when writing
	 * data.
	 */
	dm_num_write_bios_fn num_write_bios;

Linus Torvalds's avatar
Linus Torvalds committed
273 274 275 276 277
	/* target specific data */
	void *private;

	/* Used to provide an error string from the ctr */
	char *error;
278

279 280 281 282 283 284
	/*
	 * Set if this target needs to receive flushes regardless of
	 * whether or not its underlying devices have support.
	 */
	bool flush_supported:1;

285 286 287 288
	/*
	 * Set if this target needs to receive discards regardless of
	 * whether or not its underlying devices have support.
	 */
289
	bool discards_supported:1;
290

291
	/*
292
	 * Set if the target required discard bios to be split
293 294
	 * on max_io_len boundary.
	 */
295
	bool split_discard_bios:1;
296

297 298 299
	/*
	 * Set if this target does not return zeroes on discarded blocks.
	 */
300
	bool discard_zeroes_data_unsupported:1;
Linus Torvalds's avatar
Linus Torvalds committed
301 302
};

303 304 305 306 307 308
/* Each target can link one of these into the table */
struct dm_target_callbacks {
	struct list_head list;
	int (*congested_fn) (struct dm_target_callbacks *, int);
};

309 310 311 312 313 314 315 316 317 318
/*
 * For bio-based dm.
 * One of these is allocated for each bio.
 * This structure shouldn't be touched directly by target drivers.
 * It is here so that we can inline dm_per_bio_data and
 * dm_bio_from_per_bio_data
 */
struct dm_target_io {
	struct dm_io *io;
	struct dm_target *ti;
319
	unsigned target_bio_nr;
320
	unsigned *len_ptr;
321 322 323 324 325 326 327 328 329 330 331 332 333
	struct bio clone;
};

static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
{
	return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
}

static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
{
	return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
}

334
static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
335
{
336
	return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
337 338
}

Linus Torvalds's avatar
Linus Torvalds committed
339
int dm_register_target(struct target_type *t);
340
void dm_unregister_target(struct target_type *t);
341

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
/*
 * Target argument parsing.
 */
struct dm_arg_set {
	unsigned argc;
	char **argv;
};

/*
 * The minimum and maximum value of a numeric argument, together with
 * the error message to use if the number is found to be outside that range.
 */
struct dm_arg {
	unsigned min;
	unsigned max;
	char *error;
};

/*
 * Validate the next argument, either returning it as *value or, if invalid,
 * returning -EINVAL and setting *error.
 */
int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
		unsigned *value, char **error);

/*
 * Process the next argument as the start of a group containing between
 * arg->min and arg->max further arguments. Either return the size as
 * *num_args or, if invalid, return -EINVAL and set *error.
 */
int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
		      unsigned *num_args, char **error);

/*
 * Return the current argument and shift to the next.
 */
const char *dm_shift_arg(struct dm_arg_set *as);

/*
 * Move through num_args arguments.
 */
void dm_consume_args(struct dm_arg_set *as, unsigned num_args);

385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
/*-----------------------------------------------------------------
 * Functions for creating and manipulating mapped devices.
 * Drop the reference with dm_put when you finish with the object.
 *---------------------------------------------------------------*/

/*
 * DM_ANY_MINOR chooses the next available minor number.
 */
#define DM_ANY_MINOR (-1)
int dm_create(int minor, struct mapped_device **md);

/*
 * Reference counting for md.
 */
struct mapped_device *dm_get_md(dev_t dev);
void dm_get(struct mapped_device *md);
401
int dm_hold(struct mapped_device *md);
402 403 404 405 406 407 408 409 410 411 412
void dm_put(struct mapped_device *md);

/*
 * An arbitrary pointer may be stored alongside a mapped device.
 */
void dm_set_mdptr(struct mapped_device *md, void *ptr);
void *dm_get_mdptr(struct mapped_device *md);

/*
 * A device can still be used while suspended, but I/O is deferred.
 */
413
int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
414 415 416 417 418 419 420
int dm_resume(struct mapped_device *md);

/*
 * Event functions.
 */
uint32_t dm_get_event_nr(struct mapped_device *md);
int dm_wait_event(struct mapped_device *md, int event_nr);
421 422
uint32_t dm_next_uevent_seq(struct mapped_device *md);
void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
423 424 425 426

/*
 * Info functions.
 */
427
const char *dm_device_name(struct mapped_device *md);
Mike Anderson's avatar
Mike Anderson committed
428
int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
429
struct gendisk *dm_disk(struct mapped_device *md);
430
int dm_suspended(struct dm_target *ti);
431
int dm_noflush_suspending(struct dm_target *ti);
432
void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
433
union map_info *dm_get_rq_mapinfo(struct request *rq);
434

435 436
struct queue_limits *dm_get_queue_limits(struct mapped_device *md);

437 438 439 440 441 442 443 444 445 446 447 448 449
/*
 * Geometry functions.
 */
int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);

/*-----------------------------------------------------------------
 * Functions for manipulating device-mapper tables.
 *---------------------------------------------------------------*/

/*
 * First create an empty table.
 */
450
int dm_table_create(struct dm_table **result, fmode_t mode,
451 452 453 454 455 456 457 458
		    unsigned num_targets, struct mapped_device *md);

/*
 * Then call this once for each target.
 */
int dm_table_add_target(struct dm_table *t, const char *type,
			sector_t start, sector_t len, char *params);

459 460 461 462
/*
 * Target_ctr should call this if it needs to add any callbacks.
 */
void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
463 464 465 466 467 468 469 470

/*
 * Target can use this to set the table's type.
 * Can only ever be called from a target's ctr.
 * Useful for "hybrid" target (supports both bio-based
 * and request-based).
 */
void dm_table_set_type(struct dm_table *t, unsigned type);
471

472 473 474 475 476
/*
 * Finally call this to make the table ready for use.
 */
int dm_table_complete(struct dm_table *t);

477 478 479 480 481
/*
 * Target may require that it is never sent I/O larger than len.
 */
int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);

482 483 484
/*
 * Table reference counting.
 */
485 486 487
struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx);
void dm_put_live_table(struct mapped_device *md, int srcu_idx);
void dm_sync_table(struct mapped_device *md);
488 489 490 491 492 493

/*
 * Queries
 */
sector_t dm_table_get_size(struct dm_table *t);
unsigned int dm_table_get_num_targets(struct dm_table *t);
494
fmode_t dm_table_get_mode(struct dm_table *t);
495 496 497 498 499 500 501
struct mapped_device *dm_table_get_md(struct dm_table *t);

/*
 * Trigger an event.
 */
void dm_table_event(struct dm_table *t);

502 503 504 505 506
/*
 * Run the queue for request-based targets.
 */
void dm_table_run_md_queue_async(struct dm_table *t);

507 508
/*
 * The device must be suspended before calling this method.
509
 * Returns the previous table, which the caller must destroy.
510
 */
511 512
struct dm_table *dm_swap_table(struct mapped_device *md,
			       struct dm_table *t);
513

Mikulas Patocka's avatar
Mikulas Patocka committed
514 515 516 517 518
/*
 * A wrapper around vmalloc.
 */
void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);

Alasdair G Kergon's avatar
Alasdair G Kergon committed
519 520 521 522 523
/*-----------------------------------------------------------------
 * Macros.
 *---------------------------------------------------------------*/
#define DM_NAME "device-mapper"

524 525 526 527 528 529 530 531
#ifdef CONFIG_PRINTK
extern struct ratelimit_state dm_ratelimit_state;

#define dm_ratelimit()	__ratelimit(&dm_ratelimit_state)
#else
#define dm_ratelimit()	0
#endif

532 533 534
#define DMCRIT(f, arg...) \
	printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)

Alasdair G Kergon's avatar
Alasdair G Kergon committed
535 536 537 538
#define DMERR(f, arg...) \
	printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
#define DMERR_LIMIT(f, arg...) \
	do { \
539
		if (dm_ratelimit())	\
Alasdair G Kergon's avatar
Alasdair G Kergon committed
540 541 542 543 544 545 546 547
			printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
			       f "\n", ## arg); \
	} while (0)

#define DMWARN(f, arg...) \
	printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
#define DMWARN_LIMIT(f, arg...) \
	do { \
548
		if (dm_ratelimit())	\
Alasdair G Kergon's avatar
Alasdair G Kergon committed
549 550 551 552 553 554 555 556
			printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
			       f "\n", ## arg); \
	} while (0)

#define DMINFO(f, arg...) \
	printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
#define DMINFO_LIMIT(f, arg...) \
	do { \
557
		if (dm_ratelimit())	\
Alasdair G Kergon's avatar
Alasdair G Kergon committed
558 559 560 561 562 563 564 565 566
			printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
			       "\n", ## arg); \
	} while (0)

#ifdef CONFIG_DM_DEBUG
#  define DMDEBUG(f, arg...) \
	printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
#  define DMDEBUG_LIMIT(f, arg...) \
	do { \
567
		if (dm_ratelimit())	\
Alasdair G Kergon's avatar
Alasdair G Kergon committed
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
			printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
			       "\n", ## arg); \
	} while (0)
#else
#  define DMDEBUG(f, arg...) do {} while (0)
#  define DMDEBUG_LIMIT(f, arg...) do {} while (0)
#endif

#define DMEMIT(x...) sz += ((sz >= maxlen) ? \
			  0 : scnprintf(result + sz, maxlen - sz, x))

#define SECTOR_SHIFT 9

/*
 * Definitions of return values from target end_io function.
 */
#define DM_ENDIO_INCOMPLETE	1
#define DM_ENDIO_REQUEUE	2

/*
 * Definitions of return values from target map function.
 */
#define DM_MAPIO_SUBMITTED	0
#define DM_MAPIO_REMAPPED	1
#define DM_MAPIO_REQUEUE	DM_ENDIO_REQUEUE

594 595 596 597 598 599 600 601
#define dm_sector_div64(x, y)( \
{ \
	u64 _res; \
	(x) = div64_u64_rem(x, y, &_res); \
	_res; \
} \
)

Alasdair G Kergon's avatar
Alasdair G Kergon committed
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
/*
 * Ceiling(n / sz)
 */
#define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))

#define dm_sector_div_up(n, sz) ( \
{ \
	sector_t _r = ((n) + (sz) - 1); \
	sector_div(_r, (sz)); \
	_r; \
} \
)

/*
 * ceiling(n / size) * size
 */
#define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))

620 621 622
#define dm_array_too_big(fixed, obj, num) \
	((num) > (UINT_MAX - (fixed)) / (obj))

623 624 625 626 627 628
/*
 * Sector offset taken relative to the start of the target instead of
 * relative to the start of the device.
 */
#define dm_target_offset(ti, sector) ((sector) - (ti)->begin)

Alasdair G Kergon's avatar
Alasdair G Kergon committed
629 630 631 632 633 634 635 636 637 638
static inline sector_t to_sector(unsigned long n)
{
	return (n >> SECTOR_SHIFT);
}

static inline unsigned long to_bytes(sector_t n)
{
	return (n << SECTOR_SHIFT);
}

639
#endif	/* _LINUX_DEVICE_MAPPER_H */