Merge tag 'arc-4.10-rc1-part1' of git://git.kernel.org/pub/scm/linux/kernel/git/vgupt...
[linux-2.6-microblaze.git] / drivers / md / dm-linear.c
1 /*
2  * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
3  *
4  * This file is released under the GPL.
5  */
6
7 #include "dm.h"
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/blkdev.h>
11 #include <linux/bio.h>
12 #include <linux/slab.h>
13 #include <linux/device-mapper.h>
14
15 #define DM_MSG_PREFIX "linear"
16
17 /*
18  * Linear: maps a linear range of a device.
19  */
20 struct linear_c {
21         struct dm_dev *dev;
22         sector_t start;
23 };
24
25 /*
26  * Construct a linear mapping: <dev_path> <offset>
27  */
28 static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
29 {
30         struct linear_c *lc;
31         unsigned long long tmp;
32         char dummy;
33         int ret;
34
35         if (argc != 2) {
36                 ti->error = "Invalid argument count";
37                 return -EINVAL;
38         }
39
40         lc = kmalloc(sizeof(*lc), GFP_KERNEL);
41         if (lc == NULL) {
42                 ti->error = "Cannot allocate linear context";
43                 return -ENOMEM;
44         }
45
46         ret = -EINVAL;
47         if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1) {
48                 ti->error = "Invalid device sector";
49                 goto bad;
50         }
51         lc->start = tmp;
52
53         ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev);
54         if (ret) {
55                 ti->error = "Device lookup failed";
56                 goto bad;
57         }
58
59         ti->num_flush_bios = 1;
60         ti->num_discard_bios = 1;
61         ti->num_write_same_bios = 1;
62         ti->private = lc;
63         return 0;
64
65       bad:
66         kfree(lc);
67         return ret;
68 }
69
70 static void linear_dtr(struct dm_target *ti)
71 {
72         struct linear_c *lc = (struct linear_c *) ti->private;
73
74         dm_put_device(ti, lc->dev);
75         kfree(lc);
76 }
77
78 static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector)
79 {
80         struct linear_c *lc = ti->private;
81
82         return lc->start + dm_target_offset(ti, bi_sector);
83 }
84
85 static void linear_map_bio(struct dm_target *ti, struct bio *bio)
86 {
87         struct linear_c *lc = ti->private;
88
89         bio->bi_bdev = lc->dev->bdev;
90         if (bio_sectors(bio))
91                 bio->bi_iter.bi_sector =
92                         linear_map_sector(ti, bio->bi_iter.bi_sector);
93 }
94
95 static int linear_map(struct dm_target *ti, struct bio *bio)
96 {
97         linear_map_bio(ti, bio);
98
99         return DM_MAPIO_REMAPPED;
100 }
101
102 static void linear_status(struct dm_target *ti, status_type_t type,
103                           unsigned status_flags, char *result, unsigned maxlen)
104 {
105         struct linear_c *lc = (struct linear_c *) ti->private;
106
107         switch (type) {
108         case STATUSTYPE_INFO:
109                 result[0] = '\0';
110                 break;
111
112         case STATUSTYPE_TABLE:
113                 snprintf(result, maxlen, "%s %llu", lc->dev->name,
114                                 (unsigned long long)lc->start);
115                 break;
116         }
117 }
118
119 static int linear_prepare_ioctl(struct dm_target *ti,
120                 struct block_device **bdev, fmode_t *mode)
121 {
122         struct linear_c *lc = (struct linear_c *) ti->private;
123         struct dm_dev *dev = lc->dev;
124
125         *bdev = dev->bdev;
126
127         /*
128          * Only pass ioctls through if the device sizes match exactly.
129          */
130         if (lc->start ||
131             ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT)
132                 return 1;
133         return 0;
134 }
135
136 static int linear_iterate_devices(struct dm_target *ti,
137                                   iterate_devices_callout_fn fn, void *data)
138 {
139         struct linear_c *lc = ti->private;
140
141         return fn(ti, lc->dev, lc->start, ti->len, data);
142 }
143
144 static long linear_direct_access(struct dm_target *ti, sector_t sector,
145                                  void **kaddr, pfn_t *pfn, long size)
146 {
147         struct linear_c *lc = ti->private;
148         struct block_device *bdev = lc->dev->bdev;
149         struct blk_dax_ctl dax = {
150                 .sector = linear_map_sector(ti, sector),
151                 .size = size,
152         };
153         long ret;
154
155         ret = bdev_direct_access(bdev, &dax);
156         *kaddr = dax.addr;
157         *pfn = dax.pfn;
158
159         return ret;
160 }
161
162 static struct target_type linear_target = {
163         .name   = "linear",
164         .version = {1, 3, 0},
165         .module = THIS_MODULE,
166         .ctr    = linear_ctr,
167         .dtr    = linear_dtr,
168         .map    = linear_map,
169         .status = linear_status,
170         .prepare_ioctl = linear_prepare_ioctl,
171         .iterate_devices = linear_iterate_devices,
172         .direct_access = linear_direct_access,
173 };
174
175 int __init dm_linear_init(void)
176 {
177         int r = dm_register_target(&linear_target);
178
179         if (r < 0)
180                 DMERR("register failed %d", r);
181
182         return r;
183 }
184
185 void dm_linear_exit(void)
186 {
187         dm_unregister_target(&linear_target);
188 }