blob: ddda531723dcecd5e53d3dc644e41743dc6379a8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2003 Sistina Software Limited.
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01003 * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This file is released under the GPL.
6 */
7
Jonathan Brassow06386bb2008-02-08 02:11:37 +00008#include "dm-bio-record.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -07009
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/init.h>
11#include <linux/mempool.h>
12#include <linux/module.h>
13#include <linux/pagemap.h>
14#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/workqueue.h>
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010016#include <linux/device-mapper.h>
Alasdair G Kergona765e202008-04-24 22:02:01 +010017#include <linux/dm-io.h>
18#include <linux/dm-dirty-log.h>
19#include <linux/dm-kcopyd.h>
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010020#include <linux/dm-region-hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Alasdair G Kergon72d94862006-06-26 00:27:35 -070022#define DM_MSG_PREFIX "raid1"
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010023
24#define MAX_RECOVERY 1 /* Maximum number of regions recovered in parallel. */
Milan Broz88be1632007-05-09 02:33:04 -070025#define DM_IO_PAGES 64
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010026#define DM_KCOPYD_PAGES 64
Alasdair G Kergon72d94862006-06-26 00:27:35 -070027
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -070028#define DM_RAID1_HANDLE_ERRORS 0x01
Jonathan Brassowf44db672007-07-12 17:29:04 +010029#define errors_handled(p) ((p)->features & DM_RAID1_HANDLE_ERRORS)
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -070030
Jonathan E Brassow33184042006-11-08 17:44:44 -080031static DECLARE_WAIT_QUEUE_HEAD(_kmirrord_recovery_stopped);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/*-----------------------------------------------------------------
Neil Browne4c8b3b2006-06-26 00:27:26 -070034 * Mirror set structures.
35 *---------------------------------------------------------------*/
Jonathan Brassow72f4b312008-02-08 02:11:29 +000036enum dm_raid1_error {
37 DM_RAID1_WRITE_ERROR,
Mikulas Patocka64b30c42009-12-10 23:52:02 +000038 DM_RAID1_FLUSH_ERROR,
Jonathan Brassow72f4b312008-02-08 02:11:29 +000039 DM_RAID1_SYNC_ERROR,
40 DM_RAID1_READ_ERROR
41};
42
Neil Browne4c8b3b2006-06-26 00:27:26 -070043struct mirror {
Jonathan Brassowaa5617c2007-10-19 22:47:58 +010044 struct mirror_set *ms;
Neil Browne4c8b3b2006-06-26 00:27:26 -070045 atomic_t error_count;
Al Viro39ed7ad2008-02-13 03:53:00 +000046 unsigned long error_type;
Neil Browne4c8b3b2006-06-26 00:27:26 -070047 struct dm_dev *dev;
48 sector_t offset;
49};
50
51struct mirror_set {
52 struct dm_target *ti;
53 struct list_head list;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010054
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -070055 uint64_t features;
Neil Browne4c8b3b2006-06-26 00:27:26 -070056
Jonathan Brassow72f4b312008-02-08 02:11:29 +000057 spinlock_t lock; /* protects the lists */
Neil Browne4c8b3b2006-06-26 00:27:26 -070058 struct bio_list reads;
59 struct bio_list writes;
Jonathan Brassow72f4b312008-02-08 02:11:29 +000060 struct bio_list failures;
Mikulas Patocka04788502009-12-10 23:52:03 +000061 struct bio_list holds; /* bios are waiting until suspend */
Neil Browne4c8b3b2006-06-26 00:27:26 -070062
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010063 struct dm_region_hash *rh;
64 struct dm_kcopyd_client *kcopyd_client;
Milan Broz88be1632007-05-09 02:33:04 -070065 struct dm_io_client *io_client;
Jonathan Brassow06386bb2008-02-08 02:11:37 +000066 mempool_t *read_record_pool;
Milan Broz88be1632007-05-09 02:33:04 -070067
Neil Browne4c8b3b2006-06-26 00:27:26 -070068 /* recovery */
69 region_t nr_regions;
70 int in_sync;
Jonathan Brassowfc1ff952007-07-12 17:29:15 +010071 int log_failure;
Mikulas Patocka929be8f2009-12-10 23:52:06 +000072 int leg_failure;
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +000073 atomic_t suspend;
Neil Browne4c8b3b2006-06-26 00:27:26 -070074
Jonathan Brassow72f4b312008-02-08 02:11:29 +000075 atomic_t default_mirror; /* Default mirror */
Neil Browne4c8b3b2006-06-26 00:27:26 -070076
Holger Smolinski6ad36fe2007-05-09 02:32:50 -070077 struct workqueue_struct *kmirrord_wq;
78 struct work_struct kmirrord_work;
Mikulas Patockaa2aebe02008-04-24 22:10:42 +010079 struct timer_list timer;
80 unsigned long timer_pending;
81
Jonathan Brassow72f4b312008-02-08 02:11:29 +000082 struct work_struct trigger_event;
Holger Smolinski6ad36fe2007-05-09 02:32:50 -070083
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010084 unsigned nr_mirrors;
Neil Browne4c8b3b2006-06-26 00:27:26 -070085 struct mirror mirror[0];
86};
87
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010088static void wakeup_mirrord(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +010090 struct mirror_set *ms = context;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Holger Smolinski6ad36fe2007-05-09 02:32:50 -070092 queue_work(ms->kmirrord_wq, &ms->kmirrord_work);
93}
94
Mikulas Patockaa2aebe02008-04-24 22:10:42 +010095static void delayed_wake_fn(unsigned long data)
96{
97 struct mirror_set *ms = (struct mirror_set *) data;
98
99 clear_bit(0, &ms->timer_pending);
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100100 wakeup_mirrord(ms);
Mikulas Patockaa2aebe02008-04-24 22:10:42 +0100101}
102
103static void delayed_wake(struct mirror_set *ms)
104{
105 if (test_and_set_bit(0, &ms->timer_pending))
106 return;
107
108 ms->timer.expires = jiffies + HZ / 5;
109 ms->timer.data = (unsigned long) ms;
110 ms->timer.function = delayed_wake_fn;
111 add_timer(&ms->timer);
112}
113
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100114static void wakeup_all_recovery_waiters(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100116 wake_up_all(&_kmirrord_recovery_stopped);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117}
118
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100119static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
121 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 int should_wake = 0;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100123 struct bio_list *bl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100125 bl = (rw == WRITE) ? &ms->writes : &ms->reads;
126 spin_lock_irqsave(&ms->lock, flags);
127 should_wake = !(bl->head);
128 bio_list_add(bl, bio);
129 spin_unlock_irqrestore(&ms->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131 if (should_wake)
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100132 wakeup_mirrord(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100135static void dispatch_bios(void *context, struct bio_list *bio_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100137 struct mirror_set *ms = context;
138 struct bio *bio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100140 while ((bio = bio_list_pop(bio_list)))
141 queue_bio(ms, bio, WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000144#define MIN_READ_RECORDS 20
145struct dm_raid1_read_record {
146 struct mirror *m;
147 struct dm_bio_details details;
148};
149
Mikulas Patocka95f8fac2009-04-02 19:55:24 +0100150static struct kmem_cache *_dm_raid1_read_record_cache;
151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152/*
153 * Every mirror should look like this one.
154 */
155#define DEFAULT_MIRROR 0
156
157/*
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000158 * This is yucky. We squirrel the mirror struct away inside
159 * bi_next for read/write buffers. This is safe since the bh
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 * doesn't get submitted to the lower levels of block layer.
161 */
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000162static struct mirror *bio_get_m(struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163{
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000164 return (struct mirror *) bio->bi_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000167static void bio_set_m(struct bio *bio, struct mirror *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000169 bio->bi_next = (struct bio *) m;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170}
171
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000172static struct mirror *get_default_mirror(struct mirror_set *ms)
173{
174 return &ms->mirror[atomic_read(&ms->default_mirror)];
175}
176
177static void set_default_mirror(struct mirror *m)
178{
179 struct mirror_set *ms = m->ms;
180 struct mirror *m0 = &(ms->mirror[0]);
181
182 atomic_set(&ms->default_mirror, m - m0);
183}
184
Mikulas Patocka87968dd2009-12-10 23:52:04 +0000185static struct mirror *get_valid_mirror(struct mirror_set *ms)
186{
187 struct mirror *m;
188
189 for (m = ms->mirror; m < ms->mirror + ms->nr_mirrors; m++)
190 if (!atomic_read(&m->error_count))
191 return m;
192
193 return NULL;
194}
195
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000196/* fail_mirror
197 * @m: mirror device to fail
198 * @error_type: one of the enum's, DM_RAID1_*_ERROR
199 *
200 * If errors are being handled, record the type of
201 * error encountered for this device. If this type
202 * of error has already been recorded, we can return;
203 * otherwise, we must signal userspace by triggering
204 * an event. Additionally, if the device is the
205 * primary device, we must choose a new primary, but
206 * only if the mirror is in-sync.
207 *
208 * This function must not block.
209 */
210static void fail_mirror(struct mirror *m, enum dm_raid1_error error_type)
211{
212 struct mirror_set *ms = m->ms;
213 struct mirror *new;
214
Mikulas Patocka929be8f2009-12-10 23:52:06 +0000215 ms->leg_failure = 1;
216
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000217 /*
218 * error_count is used for nothing more than a
219 * simple way to tell if a device has encountered
220 * errors.
221 */
222 atomic_inc(&m->error_count);
223
224 if (test_and_set_bit(error_type, &m->error_type))
225 return;
226
Jonathan Brassowd460c652009-01-06 03:04:57 +0000227 if (!errors_handled(ms))
228 return;
229
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000230 if (m != get_default_mirror(ms))
231 goto out;
232
233 if (!ms->in_sync) {
234 /*
235 * Better to issue requests to same failing device
236 * than to risk returning corrupt data.
237 */
238 DMERR("Primary mirror (%s) failed while out-of-sync: "
239 "Reads may fail.", m->dev->name);
240 goto out;
241 }
242
Mikulas Patocka87968dd2009-12-10 23:52:04 +0000243 new = get_valid_mirror(ms);
244 if (new)
245 set_default_mirror(new);
246 else
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000247 DMWARN("All sides of mirror have failed.");
248
249out:
250 schedule_work(&ms->trigger_event);
251}
252
Mikulas Patockac0da3742009-12-10 23:52:02 +0000253static int mirror_flush(struct dm_target *ti)
254{
255 struct mirror_set *ms = ti->private;
256 unsigned long error_bits;
257
258 unsigned int i;
259 struct dm_io_region io[ms->nr_mirrors];
260 struct mirror *m;
261 struct dm_io_request io_req = {
262 .bi_rw = WRITE_BARRIER,
263 .mem.type = DM_IO_KMEM,
264 .mem.ptr.bvec = NULL,
265 .client = ms->io_client,
266 };
267
268 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++) {
269 io[i].bdev = m->dev->bdev;
270 io[i].sector = 0;
271 io[i].count = 0;
272 }
273
274 error_bits = -1;
275 dm_io(&io_req, ms->nr_mirrors, io, &error_bits);
276 if (unlikely(error_bits != 0)) {
277 for (i = 0; i < ms->nr_mirrors; i++)
278 if (test_bit(i, &error_bits))
279 fail_mirror(ms->mirror + i,
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000280 DM_RAID1_FLUSH_ERROR);
Mikulas Patockac0da3742009-12-10 23:52:02 +0000281 return -EIO;
282 }
283
284 return 0;
285}
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287/*-----------------------------------------------------------------
288 * Recovery.
289 *
290 * When a mirror is first activated we may find that some regions
291 * are in the no-sync state. We have to recover these by
292 * recopying from the default mirror to all the others.
293 *---------------------------------------------------------------*/
Alasdair G Kergon4cdc1d12008-03-28 14:16:10 -0700294static void recovery_complete(int read_err, unsigned long write_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 void *context)
296{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100297 struct dm_region *reg = context;
298 struct mirror_set *ms = dm_rh_region_context(reg);
Jonathan Brassow8f0205b2008-02-08 02:11:32 +0000299 int m, bit = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Jonathan Brassow8f0205b2008-02-08 02:11:32 +0000301 if (read_err) {
Jonathan Brassowf44db672007-07-12 17:29:04 +0100302 /* Read error means the failure of default mirror. */
303 DMERR_LIMIT("Unable to read primary mirror during recovery");
Jonathan Brassow8f0205b2008-02-08 02:11:32 +0000304 fail_mirror(get_default_mirror(ms), DM_RAID1_SYNC_ERROR);
305 }
Jonathan Brassowf44db672007-07-12 17:29:04 +0100306
Jonathan Brassow8f0205b2008-02-08 02:11:32 +0000307 if (write_err) {
Alasdair G Kergon4cdc1d12008-03-28 14:16:10 -0700308 DMERR_LIMIT("Write error during recovery (error = 0x%lx)",
Jonathan Brassowf44db672007-07-12 17:29:04 +0100309 write_err);
Jonathan Brassow8f0205b2008-02-08 02:11:32 +0000310 /*
311 * Bits correspond to devices (excluding default mirror).
312 * The default mirror cannot change during recovery.
313 */
314 for (m = 0; m < ms->nr_mirrors; m++) {
315 if (&ms->mirror[m] == get_default_mirror(ms))
316 continue;
317 if (test_bit(bit, &write_err))
318 fail_mirror(ms->mirror + m,
319 DM_RAID1_SYNC_ERROR);
320 bit++;
321 }
322 }
Jonathan Brassowf44db672007-07-12 17:29:04 +0100323
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100324 dm_rh_recovery_end(reg, !(read_err || write_err));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100327static int recover(struct mirror_set *ms, struct dm_region *reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
329 int r;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100330 unsigned i;
Heinz Mauelshageneb69aca2008-04-24 21:43:19 +0100331 struct dm_io_region from, to[DM_KCOPYD_MAX_REGIONS], *dest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 struct mirror *m;
333 unsigned long flags = 0;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100334 region_t key = dm_rh_get_region_key(reg);
335 sector_t region_size = dm_rh_get_region_size(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337 /* fill in the source */
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000338 m = get_default_mirror(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 from.bdev = m->dev->bdev;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100340 from.sector = m->offset + dm_rh_region_to_sector(ms->rh, key);
341 if (key == (ms->nr_regions - 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 /*
343 * The final region may be smaller than
344 * region_size.
345 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100346 from.count = ms->ti->len & (region_size - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 if (!from.count)
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100348 from.count = region_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 } else
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100350 from.count = region_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 /* fill in the destinations */
353 for (i = 0, dest = to; i < ms->nr_mirrors; i++) {
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000354 if (&ms->mirror[i] == get_default_mirror(ms))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 continue;
356
357 m = ms->mirror + i;
358 dest->bdev = m->dev->bdev;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100359 dest->sector = m->offset + dm_rh_region_to_sector(ms->rh, key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 dest->count = from.count;
361 dest++;
362 }
363
364 /* hand to kcopyd */
Jonathan Brassowf7c83e22008-10-10 13:36:59 +0100365 if (!errors_handled(ms))
366 set_bit(DM_KCOPYD_IGNORE_ERROR, &flags);
367
Heinz Mauelshageneb69aca2008-04-24 21:43:19 +0100368 r = dm_kcopyd_copy(ms->kcopyd_client, &from, ms->nr_mirrors - 1, to,
369 flags, recovery_complete, reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 return r;
372}
373
374static void do_recovery(struct mirror_set *ms)
375{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100376 struct dm_region *reg;
377 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 /*
381 * Start quiescing some regions.
382 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100383 dm_rh_recovery_prepare(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 /*
386 * Copy any already quiesced regions.
387 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100388 while ((reg = dm_rh_recovery_start(ms->rh))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 r = recover(ms, reg);
390 if (r)
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100391 dm_rh_recovery_end(reg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393
394 /*
395 * Update the in sync flag.
396 */
397 if (!ms->in_sync &&
398 (log->type->get_sync_count(log) == ms->nr_regions)) {
399 /* the sync is complete */
400 dm_table_event(ms->ti->table);
401 ms->in_sync = 1;
402 }
403}
404
405/*-----------------------------------------------------------------
406 * Reads
407 *---------------------------------------------------------------*/
408static struct mirror *choose_mirror(struct mirror_set *ms, sector_t sector)
409{
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000410 struct mirror *m = get_default_mirror(ms);
411
412 do {
413 if (likely(!atomic_read(&m->error_count)))
414 return m;
415
416 if (m-- == ms->mirror)
417 m += ms->nr_mirrors;
418 } while (m != get_default_mirror(ms));
419
420 return NULL;
421}
422
423static int default_ok(struct mirror *m)
424{
425 struct mirror *default_mirror = get_default_mirror(m->ms);
426
427 return !atomic_read(&default_mirror->error_count);
428}
429
430static int mirror_available(struct mirror_set *ms, struct bio *bio)
431{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100432 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
433 region_t region = dm_rh_bio_to_region(ms->rh, bio);
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000434
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100435 if (log->type->in_sync(log, region, 0))
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000436 return choose_mirror(ms, bio->bi_sector) ? 1 : 0;
437
438 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439}
440
441/*
442 * remap a buffer to a particular mirror.
443 */
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000444static sector_t map_sector(struct mirror *m, struct bio *bio)
445{
Mikulas Patocka41841532009-12-10 23:51:59 +0000446 if (unlikely(!bio->bi_size))
447 return 0;
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000448 return m->offset + (bio->bi_sector - m->ms->ti->begin);
449}
450
451static void map_bio(struct mirror *m, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
453 bio->bi_bdev = m->dev->bdev;
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000454 bio->bi_sector = map_sector(m, bio);
455}
456
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100457static void map_region(struct dm_io_region *io, struct mirror *m,
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000458 struct bio *bio)
459{
460 io->bdev = m->dev->bdev;
461 io->sector = map_sector(m, bio);
462 io->count = bio->bi_size >> 9;
463}
464
Mikulas Patocka04788502009-12-10 23:52:03 +0000465static void hold_bio(struct mirror_set *ms, struct bio *bio)
466{
467 /*
Takahiro Yasuif0703042010-03-06 02:32:35 +0000468 * Lock is required to avoid race condition during suspend
469 * process.
Mikulas Patocka04788502009-12-10 23:52:03 +0000470 */
Takahiro Yasuif0703042010-03-06 02:32:35 +0000471 spin_lock_irq(&ms->lock);
472
Mikulas Patocka04788502009-12-10 23:52:03 +0000473 if (atomic_read(&ms->suspend)) {
Takahiro Yasuif0703042010-03-06 02:32:35 +0000474 spin_unlock_irq(&ms->lock);
475
476 /*
477 * If device is suspended, complete the bio.
478 */
Mikulas Patocka04788502009-12-10 23:52:03 +0000479 if (dm_noflush_suspending(ms->ti))
480 bio_endio(bio, DM_ENDIO_REQUEUE);
481 else
482 bio_endio(bio, -EIO);
483 return;
484 }
485
486 /*
487 * Hold bio until the suspend is complete.
488 */
Mikulas Patocka04788502009-12-10 23:52:03 +0000489 bio_list_add(&ms->holds, bio);
490 spin_unlock_irq(&ms->lock);
491}
492
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000493/*-----------------------------------------------------------------
494 * Reads
495 *---------------------------------------------------------------*/
496static void read_callback(unsigned long error, void *context)
497{
498 struct bio *bio = context;
499 struct mirror *m;
500
501 m = bio_get_m(bio);
502 bio_set_m(bio, NULL);
503
504 if (likely(!error)) {
505 bio_endio(bio, 0);
506 return;
507 }
508
509 fail_mirror(m, DM_RAID1_READ_ERROR);
510
511 if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
512 DMWARN_LIMIT("Read failure on mirror device %s. "
513 "Trying alternative device.",
514 m->dev->name);
515 queue_bio(m->ms, bio, bio_rw(bio));
516 return;
517 }
518
519 DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
520 m->dev->name);
521 bio_endio(bio, -EIO);
522}
523
524/* Asynchronous read. */
525static void read_async_bio(struct mirror *m, struct bio *bio)
526{
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100527 struct dm_io_region io;
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000528 struct dm_io_request io_req = {
529 .bi_rw = READ,
530 .mem.type = DM_IO_BVEC,
531 .mem.ptr.bvec = bio->bi_io_vec + bio->bi_idx,
532 .notify.fn = read_callback,
533 .notify.context = bio,
534 .client = m->ms->io_client,
535 };
536
537 map_region(&io, m, bio);
538 bio_set_m(bio, m);
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100539 BUG_ON(dm_io(&io_req, 1, &io, NULL));
540}
541
542static inline int region_in_sync(struct mirror_set *ms, region_t region,
543 int may_block)
544{
545 int state = dm_rh_get_state(ms->rh, region, may_block);
546 return state == DM_RH_CLEAN || state == DM_RH_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
549static void do_reads(struct mirror_set *ms, struct bio_list *reads)
550{
551 region_t region;
552 struct bio *bio;
553 struct mirror *m;
554
555 while ((bio = bio_list_pop(reads))) {
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100556 region = dm_rh_bio_to_region(ms->rh, bio);
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000557 m = get_default_mirror(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 /*
560 * We can only read balance if the region is in sync.
561 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100562 if (likely(region_in_sync(ms, region, 1)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 m = choose_mirror(ms, bio->bi_sector);
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000564 else if (m && atomic_read(&m->error_count))
565 m = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000567 if (likely(m))
568 read_async_bio(m, bio);
569 else
570 bio_endio(bio, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 }
572}
573
574/*-----------------------------------------------------------------
575 * Writes.
576 *
577 * We do different things with the write io depending on the
578 * state of the region that it's in:
579 *
580 * SYNC: increment pending, use kcopyd to write to *all* mirrors
581 * RECOVERING: delay the io until recovery completes
582 * NOSYNC: increment pending, just write to the default mirror
583 *---------------------------------------------------------------*/
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000584
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586static void write_callback(unsigned long error, void *context)
587{
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000588 unsigned i, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 struct bio *bio = (struct bio *) context;
590 struct mirror_set *ms;
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000591 int should_wake = 0;
592 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000594 ms = bio_get_m(bio)->ms;
595 bio_set_m(bio, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
597 /*
598 * NOTE: We don't decrement the pending count here,
599 * instead it is done by the targets endio function.
600 * This way we handle both writes to SYNC and NOSYNC
601 * regions with the same code.
602 */
Mikulas Patocka60f355e2009-12-10 23:52:05 +0000603 if (likely(!error)) {
604 bio_endio(bio, ret);
605 return;
606 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000608 for (i = 0; i < ms->nr_mirrors; i++)
609 if (test_bit(i, &error))
610 fail_mirror(ms->mirror + i, DM_RAID1_WRITE_ERROR);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000611
Mikulas Patocka60f355e2009-12-10 23:52:05 +0000612 /*
613 * Need to raise event. Since raising
614 * events can block, we need to do it in
615 * the main thread.
616 */
617 spin_lock_irqsave(&ms->lock, flags);
618 if (!ms->failures.head)
619 should_wake = 1;
620 bio_list_add(&ms->failures, bio);
621 spin_unlock_irqrestore(&ms->lock, flags);
622 if (should_wake)
623 wakeup_mirrord(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624}
625
626static void do_write(struct mirror_set *ms, struct bio *bio)
627{
628 unsigned int i;
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100629 struct dm_io_region io[ms->nr_mirrors], *dest = io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 struct mirror *m;
Milan Broz88be1632007-05-09 02:33:04 -0700631 struct dm_io_request io_req = {
Mikulas Patocka41841532009-12-10 23:51:59 +0000632 .bi_rw = WRITE | (bio->bi_rw & WRITE_BARRIER),
Milan Broz88be1632007-05-09 02:33:04 -0700633 .mem.type = DM_IO_BVEC,
634 .mem.ptr.bvec = bio->bi_io_vec + bio->bi_idx,
635 .notify.fn = write_callback,
636 .notify.context = bio,
637 .client = ms->io_client,
638 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000640 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++)
641 map_region(dest++, m, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000643 /*
644 * Use default mirror because we only need it to retrieve the reference
645 * to the mirror set in write_callback().
646 */
647 bio_set_m(bio, get_default_mirror(ms));
Milan Broz88be1632007-05-09 02:33:04 -0700648
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100649 BUG_ON(dm_io(&io_req, ms->nr_mirrors, io, NULL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650}
651
652static void do_writes(struct mirror_set *ms, struct bio_list *writes)
653{
654 int state;
655 struct bio *bio;
656 struct bio_list sync, nosync, recover, *this_list = NULL;
Jonathan Brassow7513c2a2009-04-02 19:55:30 +0100657 struct bio_list requeue;
658 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
659 region_t region;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
661 if (!writes->head)
662 return;
663
664 /*
665 * Classify each write.
666 */
667 bio_list_init(&sync);
668 bio_list_init(&nosync);
669 bio_list_init(&recover);
Jonathan Brassow7513c2a2009-04-02 19:55:30 +0100670 bio_list_init(&requeue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672 while ((bio = bio_list_pop(writes))) {
Mikulas Patocka41841532009-12-10 23:51:59 +0000673 if (unlikely(bio_empty_barrier(bio))) {
674 bio_list_add(&sync, bio);
675 continue;
676 }
677
Jonathan Brassow7513c2a2009-04-02 19:55:30 +0100678 region = dm_rh_bio_to_region(ms->rh, bio);
679
680 if (log->type->is_remote_recovering &&
681 log->type->is_remote_recovering(log, region)) {
682 bio_list_add(&requeue, bio);
683 continue;
684 }
685
686 state = dm_rh_get_state(ms->rh, region, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 switch (state) {
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100688 case DM_RH_CLEAN:
689 case DM_RH_DIRTY:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 this_list = &sync;
691 break;
692
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100693 case DM_RH_NOSYNC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 this_list = &nosync;
695 break;
696
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100697 case DM_RH_RECOVERING:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 this_list = &recover;
699 break;
700 }
701
702 bio_list_add(this_list, bio);
703 }
704
705 /*
Jonathan Brassow7513c2a2009-04-02 19:55:30 +0100706 * Add bios that are delayed due to remote recovery
707 * back on to the write queue
708 */
709 if (unlikely(requeue.head)) {
710 spin_lock_irq(&ms->lock);
711 bio_list_merge(&ms->writes, &requeue);
712 spin_unlock_irq(&ms->lock);
Mikulas Patocka69885682009-07-23 20:30:37 +0100713 delayed_wake(ms);
Jonathan Brassow7513c2a2009-04-02 19:55:30 +0100714 }
715
716 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 * Increment the pending counts for any regions that will
718 * be written to (writes to recover regions are going to
719 * be delayed).
720 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100721 dm_rh_inc_pending(ms->rh, &sync);
722 dm_rh_inc_pending(ms->rh, &nosync);
Jonathan Brassowd2b69862009-09-04 20:40:32 +0100723
724 /*
725 * If the flush fails on a previous call and succeeds here,
726 * we must not reset the log_failure variable. We need
727 * userspace interaction to do that.
728 */
729 ms->log_failure = dm_rh_flush(ms->rh) ? 1 : ms->log_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 /*
732 * Dispatch io.
733 */
Mikulas Patocka5528d172010-02-16 18:42:55 +0000734 if (unlikely(ms->log_failure) && errors_handled(ms)) {
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000735 spin_lock_irq(&ms->lock);
736 bio_list_merge(&ms->failures, &sync);
737 spin_unlock_irq(&ms->lock);
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100738 wakeup_mirrord(ms);
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000739 } else
Jonathan Brassowfc1ff952007-07-12 17:29:15 +0100740 while ((bio = bio_list_pop(&sync)))
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000741 do_write(ms, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 while ((bio = bio_list_pop(&recover)))
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100744 dm_rh_delay(ms->rh, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 while ((bio = bio_list_pop(&nosync))) {
Mikulas Patockaede5ea02010-03-06 02:32:22 +0000747 if (unlikely(ms->leg_failure) && errors_handled(ms)) {
748 spin_lock_irq(&ms->lock);
749 bio_list_add(&ms->failures, bio);
750 spin_unlock_irq(&ms->lock);
751 wakeup_mirrord(ms);
752 } else {
Mikulas Patocka929be8f2009-12-10 23:52:06 +0000753 map_bio(get_default_mirror(ms), bio);
754 generic_make_request(bio);
755 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
757}
758
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000759static void do_failures(struct mirror_set *ms, struct bio_list *failures)
760{
761 struct bio *bio;
762
Mikulas Patocka0f398a82009-12-10 23:52:04 +0000763 if (likely(!failures->head))
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000764 return;
765
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000766 /*
767 * If the log has failed, unattempted writes are being
Mikulas Patocka0f398a82009-12-10 23:52:04 +0000768 * put on the holds list. We can't issue those writes
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000769 * until a log has been marked, so we must store them.
770 *
771 * If a 'noflush' suspend is in progress, we can requeue
772 * the I/O's to the core. This give userspace a chance
773 * to reconfigure the mirror, at which point the core
774 * will reissue the writes. If the 'noflush' flag is
775 * not set, we have no choice but to return errors.
776 *
777 * Some writes on the failures list may have been
778 * submitted before the log failure and represent a
779 * failure to write to one of the devices. It is ok
780 * for us to treat them the same and requeue them
781 * as well.
782 */
Mikulas Patocka0f398a82009-12-10 23:52:04 +0000783 while ((bio = bio_list_pop(failures))) {
Mikulas Patocka60f355e2009-12-10 23:52:05 +0000784 if (!ms->log_failure) {
Mikulas Patocka0f398a82009-12-10 23:52:04 +0000785 ms->in_sync = 0;
Mikulas Patockac58098b2009-12-10 23:52:05 +0000786 dm_rh_mark_nosync(ms->rh, bio);
Mikulas Patocka0f398a82009-12-10 23:52:04 +0000787 }
Mikulas Patocka60f355e2009-12-10 23:52:05 +0000788
789 /*
790 * If all the legs are dead, fail the I/O.
791 * If we have been told to handle errors, hold the bio
792 * and wait for userspace to deal with the problem.
793 * Otherwise pretend that the I/O succeeded. (This would
794 * be wrong if the failed leg returned after reboot and
795 * got replicated back to the good legs.)
796 */
797 if (!get_valid_mirror(ms))
798 bio_endio(bio, -EIO);
799 else if (errors_handled(ms))
800 hold_bio(ms, bio);
801 else
802 bio_endio(bio, 0);
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000803 }
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000804}
805
806static void trigger_event(struct work_struct *work)
807{
808 struct mirror_set *ms =
809 container_of(work, struct mirror_set, trigger_event);
810
811 dm_table_event(ms->ti->table);
812}
813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814/*-----------------------------------------------------------------
815 * kmirrord
816 *---------------------------------------------------------------*/
Mikulas Patockaa2aebe02008-04-24 22:10:42 +0100817static void do_mirror(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100819 struct mirror_set *ms = container_of(work, struct mirror_set,
820 kmirrord_work);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000821 struct bio_list reads, writes, failures;
822 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000824 spin_lock_irqsave(&ms->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 reads = ms->reads;
826 writes = ms->writes;
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000827 failures = ms->failures;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 bio_list_init(&ms->reads);
829 bio_list_init(&ms->writes);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000830 bio_list_init(&ms->failures);
831 spin_unlock_irqrestore(&ms->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100833 dm_rh_update_states(ms->rh, errors_handled(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 do_recovery(ms);
835 do_reads(ms, &reads);
836 do_writes(ms, &writes);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000837 do_failures(ms, &failures);
Mikulas Patocka7ff14a32008-04-24 22:10:47 +0100838
839 dm_table_unplug_all(ms->ti->table);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000840}
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842/*-----------------------------------------------------------------
843 * Target functions
844 *---------------------------------------------------------------*/
845static struct mirror_set *alloc_context(unsigned int nr_mirrors,
846 uint32_t region_size,
847 struct dm_target *ti,
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100848 struct dm_dirty_log *dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849{
850 size_t len;
851 struct mirror_set *ms = NULL;
852
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 len = sizeof(*ms) + (sizeof(ms->mirror[0]) * nr_mirrors);
854
Yoann Padioleaudd00cc42007-07-19 01:49:03 -0700855 ms = kzalloc(len, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 if (!ms) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700857 ti->error = "Cannot allocate mirror context";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 return NULL;
859 }
860
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 spin_lock_init(&ms->lock);
Mikulas Patocka5339fc22009-12-10 23:52:06 +0000862 bio_list_init(&ms->reads);
863 bio_list_init(&ms->writes);
864 bio_list_init(&ms->failures);
865 bio_list_init(&ms->holds);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
867 ms->ti = ti;
868 ms->nr_mirrors = nr_mirrors;
869 ms->nr_regions = dm_sector_div_up(ti->len, region_size);
870 ms->in_sync = 0;
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000871 ms->log_failure = 0;
Mikulas Patocka929be8f2009-12-10 23:52:06 +0000872 ms->leg_failure = 0;
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +0000873 atomic_set(&ms->suspend, 0);
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000874 atomic_set(&ms->default_mirror, DEFAULT_MIRROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
Mikulas Patocka95f8fac2009-04-02 19:55:24 +0100876 ms->read_record_pool = mempool_create_slab_pool(MIN_READ_RECORDS,
877 _dm_raid1_read_record_cache);
878
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000879 if (!ms->read_record_pool) {
880 ti->error = "Error creating mirror read_record_pool";
881 kfree(ms);
882 return NULL;
883 }
884
Milan Broz88be1632007-05-09 02:33:04 -0700885 ms->io_client = dm_io_client_create(DM_IO_PAGES);
886 if (IS_ERR(ms->io_client)) {
887 ti->error = "Error creating dm_io client";
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000888 mempool_destroy(ms->read_record_pool);
Milan Broz88be1632007-05-09 02:33:04 -0700889 kfree(ms);
890 return NULL;
891 }
892
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100893 ms->rh = dm_region_hash_create(ms, dispatch_bios, wakeup_mirrord,
894 wakeup_all_recovery_waiters,
895 ms->ti->begin, MAX_RECOVERY,
896 dl, region_size, ms->nr_regions);
897 if (IS_ERR(ms->rh)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700898 ti->error = "Error creating dirty region hash";
Dmitry Monakhova72cf732007-10-19 22:38:39 +0100899 dm_io_client_destroy(ms->io_client);
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000900 mempool_destroy(ms->read_record_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 kfree(ms);
902 return NULL;
903 }
904
905 return ms;
906}
907
908static void free_context(struct mirror_set *ms, struct dm_target *ti,
909 unsigned int m)
910{
911 while (m--)
912 dm_put_device(ti, ms->mirror[m].dev);
913
Milan Broz88be1632007-05-09 02:33:04 -0700914 dm_io_client_destroy(ms->io_client);
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100915 dm_region_hash_destroy(ms->rh);
Jonathan Brassow06386bb2008-02-08 02:11:37 +0000916 mempool_destroy(ms->read_record_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 kfree(ms);
918}
919
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920static int get_mirror(struct mirror_set *ms, struct dm_target *ti,
921 unsigned int mirror, char **argv)
922{
Andrew Morton4ee218c2006-03-27 01:17:48 -0800923 unsigned long long offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Andrew Morton4ee218c2006-03-27 01:17:48 -0800925 if (sscanf(argv[1], "%llu", &offset) != 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700926 ti->error = "Invalid offset";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 return -EINVAL;
928 }
929
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +0000930 if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 &ms->mirror[mirror].dev)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700932 ti->error = "Device lookup failure";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return -ENXIO;
934 }
935
Jonathan Brassowaa5617c2007-10-19 22:47:58 +0100936 ms->mirror[mirror].ms = ms;
Jonathan Brassow72f4b312008-02-08 02:11:29 +0000937 atomic_set(&(ms->mirror[mirror].error_count), 0);
938 ms->mirror[mirror].error_type = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 ms->mirror[mirror].offset = offset;
940
941 return 0;
942}
943
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944/*
945 * Create dirty log: log_type #log_params <log_params>
946 */
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100947static struct dm_dirty_log *create_dirty_log(struct dm_target *ti,
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100948 unsigned argc, char **argv,
949 unsigned *args_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950{
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +0100951 unsigned param_count;
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100952 struct dm_dirty_log *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954 if (argc < 2) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700955 ti->error = "Insufficient mirror log arguments";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 return NULL;
957 }
958
959 if (sscanf(argv[1], "%u", &param_count) != 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700960 ti->error = "Invalid mirror log argument count";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 return NULL;
962 }
963
964 *args_used = 2 + param_count;
965
966 if (argc < *args_used) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700967 ti->error = "Insufficient mirror log arguments";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 return NULL;
969 }
970
Mikulas Patockac0da3742009-12-10 23:52:02 +0000971 dl = dm_dirty_log_create(argv[0], ti, mirror_flush, param_count,
972 argv + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (!dl) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700974 ti->error = "Error creating mirror dirty log";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 return NULL;
976 }
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 return dl;
979}
980
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -0700981static int parse_features(struct mirror_set *ms, unsigned argc, char **argv,
982 unsigned *args_used)
983{
984 unsigned num_features;
985 struct dm_target *ti = ms->ti;
986
987 *args_used = 0;
988
989 if (!argc)
990 return 0;
991
992 if (sscanf(argv[0], "%u", &num_features) != 1) {
993 ti->error = "Invalid number of features";
994 return -EINVAL;
995 }
996
997 argc--;
998 argv++;
999 (*args_used)++;
1000
1001 if (num_features > argc) {
1002 ti->error = "Not enough arguments to support feature count";
1003 return -EINVAL;
1004 }
1005
1006 if (!strcmp("handle_errors", argv[0]))
1007 ms->features |= DM_RAID1_HANDLE_ERRORS;
1008 else {
1009 ti->error = "Unrecognised feature requested";
1010 return -EINVAL;
1011 }
1012
1013 (*args_used)++;
1014
1015 return 0;
1016}
1017
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018/*
1019 * Construct a mirror mapping:
1020 *
1021 * log_type #log_params <log_params>
1022 * #mirrors [mirror_path offset]{2,}
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001023 * [#features <features>]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 *
1025 * log_type is "core" or "disk"
1026 * #log_params is between 1 and 3
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001027 *
1028 * If present, features must be "handle_errors".
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
1031{
1032 int r;
1033 unsigned int nr_mirrors, m, args_used;
1034 struct mirror_set *ms;
Heinz Mauelshagen416cd172008-04-24 21:43:35 +01001035 struct dm_dirty_log *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
1037 dl = create_dirty_log(ti, argc, argv, &args_used);
1038 if (!dl)
1039 return -EINVAL;
1040
1041 argv += args_used;
1042 argc -= args_used;
1043
1044 if (!argc || sscanf(argv[0], "%u", &nr_mirrors) != 1 ||
Heinz Mauelshageneb69aca2008-04-24 21:43:19 +01001045 nr_mirrors < 2 || nr_mirrors > DM_KCOPYD_MAX_REGIONS + 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001046 ti->error = "Invalid number of mirrors";
Heinz Mauelshagen416cd172008-04-24 21:43:35 +01001047 dm_dirty_log_destroy(dl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 return -EINVAL;
1049 }
1050
1051 argv++, argc--;
1052
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001053 if (argc < nr_mirrors * 2) {
1054 ti->error = "Too few mirror arguments";
Heinz Mauelshagen416cd172008-04-24 21:43:35 +01001055 dm_dirty_log_destroy(dl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 return -EINVAL;
1057 }
1058
1059 ms = alloc_context(nr_mirrors, dl->type->get_region_size(dl), ti, dl);
1060 if (!ms) {
Heinz Mauelshagen416cd172008-04-24 21:43:35 +01001061 dm_dirty_log_destroy(dl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 return -ENOMEM;
1063 }
1064
1065 /* Get the mirror parameter sets */
1066 for (m = 0; m < nr_mirrors; m++) {
1067 r = get_mirror(ms, ti, m, argv);
1068 if (r) {
1069 free_context(ms, ti, m);
1070 return r;
1071 }
1072 argv += 2;
1073 argc -= 2;
1074 }
1075
1076 ti->private = ms;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001077 ti->split_io = dm_rh_get_region_size(ms->rh);
Mikulas Patocka41841532009-12-10 23:51:59 +00001078 ti->num_flush_requests = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Holger Smolinski6ad36fe2007-05-09 02:32:50 -07001080 ms->kmirrord_wq = create_singlethread_workqueue("kmirrord");
1081 if (!ms->kmirrord_wq) {
1082 DMERR("couldn't start kmirrord");
Dmitry Monakhova72cf732007-10-19 22:38:39 +01001083 r = -ENOMEM;
1084 goto err_free_context;
Holger Smolinski6ad36fe2007-05-09 02:32:50 -07001085 }
1086 INIT_WORK(&ms->kmirrord_work, do_mirror);
Mikulas Patockaa2aebe02008-04-24 22:10:42 +01001087 init_timer(&ms->timer);
1088 ms->timer_pending = 0;
Jonathan Brassow72f4b312008-02-08 02:11:29 +00001089 INIT_WORK(&ms->trigger_event, trigger_event);
Holger Smolinski6ad36fe2007-05-09 02:32:50 -07001090
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001091 r = parse_features(ms, argc, argv, &args_used);
Dmitry Monakhova72cf732007-10-19 22:38:39 +01001092 if (r)
1093 goto err_destroy_wq;
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001094
1095 argv += args_used;
1096 argc -= args_used;
1097
Jonathan Brassowf44db672007-07-12 17:29:04 +01001098 /*
1099 * Any read-balancing addition depends on the
1100 * DM_RAID1_HANDLE_ERRORS flag being present.
1101 * This is because the decision to balance depends
1102 * on the sync state of a region. If the above
1103 * flag is not present, we ignore errors; and
1104 * the sync state may be inaccurate.
1105 */
1106
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001107 if (argc) {
1108 ti->error = "Too many mirror arguments";
Dmitry Monakhova72cf732007-10-19 22:38:39 +01001109 r = -EINVAL;
1110 goto err_destroy_wq;
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001111 }
1112
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001113 r = dm_kcopyd_client_create(DM_KCOPYD_PAGES, &ms->kcopyd_client);
Dmitry Monakhova72cf732007-10-19 22:38:39 +01001114 if (r)
1115 goto err_destroy_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001117 wakeup_mirrord(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 return 0;
Dmitry Monakhova72cf732007-10-19 22:38:39 +01001119
1120err_destroy_wq:
1121 destroy_workqueue(ms->kmirrord_wq);
1122err_free_context:
1123 free_context(ms, ti, ms->nr_mirrors);
1124 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125}
1126
1127static void mirror_dtr(struct dm_target *ti)
1128{
1129 struct mirror_set *ms = (struct mirror_set *) ti->private;
1130
Mikulas Patockaa2aebe02008-04-24 22:10:42 +01001131 del_timer_sync(&ms->timer);
Holger Smolinski6ad36fe2007-05-09 02:32:50 -07001132 flush_workqueue(ms->kmirrord_wq);
Mikulas Patocka18776c72008-11-13 23:38:52 +00001133 flush_scheduled_work();
Heinz Mauelshageneb69aca2008-04-24 21:43:19 +01001134 dm_kcopyd_client_destroy(ms->kcopyd_client);
Holger Smolinski6ad36fe2007-05-09 02:32:50 -07001135 destroy_workqueue(ms->kmirrord_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 free_context(ms, ti, ms->nr_mirrors);
1137}
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139/*
1140 * Mirror mapping function
1141 */
1142static int mirror_map(struct dm_target *ti, struct bio *bio,
1143 union map_info *map_context)
1144{
1145 int r, rw = bio_rw(bio);
1146 struct mirror *m;
1147 struct mirror_set *ms = ti->private;
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001148 struct dm_raid1_read_record *read_record = NULL;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001149 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 if (rw == WRITE) {
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001152 /* Save region for mirror_end_io() handler */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001153 map_context->ll = dm_rh_bio_to_region(ms->rh, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 queue_bio(ms, bio, rw);
Kiyoshi Uedad2a7ad22006-12-08 02:41:06 -08001155 return DM_MAPIO_SUBMITTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 }
1157
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001158 r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 if (r < 0 && r != -EWOULDBLOCK)
1160 return r;
1161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 /*
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001163 * If region is not in-sync queue the bio.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 */
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001165 if (!r || (r == -EWOULDBLOCK)) {
1166 if (rw == READA)
1167 return -EWOULDBLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 queue_bio(ms, bio, rw);
Kiyoshi Uedad2a7ad22006-12-08 02:41:06 -08001170 return DM_MAPIO_SUBMITTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001173 /*
1174 * The region is in-sync and we can perform reads directly.
1175 * Store enough information so we can retry if it fails.
1176 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 m = choose_mirror(ms, bio->bi_sector);
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001178 if (unlikely(!m))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 return -EIO;
1180
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001181 read_record = mempool_alloc(ms->read_record_pool, GFP_NOIO);
1182 if (likely(read_record)) {
1183 dm_bio_record(&read_record->details, bio);
1184 map_context->ptr = read_record;
1185 read_record->m = m;
1186 }
1187
1188 map_bio(m, bio);
1189
Kiyoshi Uedad2a7ad22006-12-08 02:41:06 -08001190 return DM_MAPIO_REMAPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191}
1192
1193static int mirror_end_io(struct dm_target *ti, struct bio *bio,
1194 int error, union map_info *map_context)
1195{
1196 int rw = bio_rw(bio);
1197 struct mirror_set *ms = (struct mirror_set *) ti->private;
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001198 struct mirror *m = NULL;
1199 struct dm_bio_details *bd = NULL;
1200 struct dm_raid1_read_record *read_record = map_context->ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
1202 /*
1203 * We need to dec pending if this was a write.
1204 */
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001205 if (rw == WRITE) {
Mikulas Patocka41841532009-12-10 23:51:59 +00001206 if (likely(!bio_empty_barrier(bio)))
1207 dm_rh_dec(ms->rh, map_context->ll);
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001208 return error;
1209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001211 if (error == -EOPNOTSUPP)
1212 goto out;
1213
Jens Axboe1f98a132009-09-11 14:32:04 +02001214 if ((error == -EWOULDBLOCK) && bio_rw_flagged(bio, BIO_RW_AHEAD))
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001215 goto out;
1216
1217 if (unlikely(error)) {
1218 if (!read_record) {
1219 /*
1220 * There wasn't enough memory to record necessary
1221 * information for a retry or there was no other
1222 * mirror in-sync.
1223 */
Adrian Bunke03f1a82008-02-19 19:44:19 +00001224 DMERR_LIMIT("Mirror read failed.");
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001225 return -EIO;
1226 }
Adrian Bunke03f1a82008-02-19 19:44:19 +00001227
1228 m = read_record->m;
1229
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001230 DMERR("Mirror read failed from %s. Trying alternative device.",
1231 m->dev->name);
1232
Jonathan Brassow06386bb2008-02-08 02:11:37 +00001233 fail_mirror(m, DM_RAID1_READ_ERROR);
1234
1235 /*
1236 * A failed read is requeued for another attempt using an intact
1237 * mirror.
1238 */
1239 if (default_ok(m) || mirror_available(ms, bio)) {
1240 bd = &read_record->details;
1241
1242 dm_bio_restore(bd, bio);
1243 mempool_free(read_record, ms->read_record_pool);
1244 map_context->ptr = NULL;
1245 queue_bio(ms, bio, rw);
1246 return 1;
1247 }
1248 DMERR("All replicated volumes dead, failing I/O");
1249 }
1250
1251out:
1252 if (read_record) {
1253 mempool_free(read_record, ms->read_record_pool);
1254 map_context->ptr = NULL;
1255 }
1256
1257 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258}
1259
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001260static void mirror_presuspend(struct dm_target *ti)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261{
1262 struct mirror_set *ms = (struct mirror_set *) ti->private;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001263 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Mikulas Patocka04788502009-12-10 23:52:03 +00001265 struct bio_list holds;
1266 struct bio *bio;
1267
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001268 atomic_set(&ms->suspend, 1);
1269
1270 /*
Takahiro Yasuif0703042010-03-06 02:32:35 +00001271 * Process bios in the hold list to start recovery waiting
1272 * for bios in the hold list. After the process, no bio has
1273 * a chance to be added in the hold list because ms->suspend
1274 * is set.
1275 */
1276 spin_lock_irq(&ms->lock);
1277 holds = ms->holds;
1278 bio_list_init(&ms->holds);
1279 spin_unlock_irq(&ms->lock);
1280
1281 while ((bio = bio_list_pop(&holds)))
1282 hold_bio(ms, bio);
1283
1284 /*
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001285 * We must finish up all the work that we've
1286 * generated (i.e. recovery work).
1287 */
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001288 dm_rh_stop_recovery(ms->rh);
Jonathan E Brassow33184042006-11-08 17:44:44 -08001289
Jonathan E Brassow33184042006-11-08 17:44:44 -08001290 wait_event(_kmirrord_recovery_stopped,
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001291 !dm_rh_recovery_in_flight(ms->rh));
Jonathan E Brassow33184042006-11-08 17:44:44 -08001292
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001293 if (log->type->presuspend && log->type->presuspend(log))
1294 /* FIXME: need better error handling */
1295 DMWARN("log presuspend failed");
1296
1297 /*
1298 * Now that recovery is complete/stopped and the
1299 * delayed bios are queued, we need to wait for
1300 * the worker thread to complete. This way,
1301 * we know that all of our I/O has been pushed.
1302 */
1303 flush_workqueue(ms->kmirrord_wq);
1304}
1305
1306static void mirror_postsuspend(struct dm_target *ti)
1307{
1308 struct mirror_set *ms = ti->private;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001309 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001310
Jonathan Brassow6b3df0d2007-10-19 22:47:57 +01001311 if (log->type->postsuspend && log->type->postsuspend(log))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 /* FIXME: need better error handling */
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001313 DMWARN("log postsuspend failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
1315
1316static void mirror_resume(struct dm_target *ti)
1317{
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001318 struct mirror_set *ms = ti->private;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001319 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001320
1321 atomic_set(&ms->suspend, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 if (log->type->resume && log->type->resume(log))
1323 /* FIXME: need better error handling */
1324 DMWARN("log resume failed");
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001325 dm_rh_start_recovery(ms->rh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326}
1327
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001328/*
1329 * device_status_char
1330 * @m: mirror device/leg we want the status of
1331 *
1332 * We return one character representing the most severe error
1333 * we have encountered.
1334 * A => Alive - No failures
1335 * D => Dead - A write failure occurred leaving mirror out-of-sync
1336 * S => Sync - A sychronization failure occurred, mirror out-of-sync
1337 * R => Read - A read failure occurred, mirror data unaffected
1338 *
1339 * Returns: <char>
1340 */
1341static char device_status_char(struct mirror *m)
1342{
1343 if (!atomic_read(&(m->error_count)))
1344 return 'A';
1345
Mikulas Patocka64b30c42009-12-10 23:52:02 +00001346 return (test_bit(DM_RAID1_FLUSH_ERROR, &(m->error_type))) ? 'F' :
1347 (test_bit(DM_RAID1_WRITE_ERROR, &(m->error_type))) ? 'D' :
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001348 (test_bit(DM_RAID1_SYNC_ERROR, &(m->error_type))) ? 'S' :
1349 (test_bit(DM_RAID1_READ_ERROR, &(m->error_type))) ? 'R' : 'U';
1350}
1351
1352
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353static int mirror_status(struct dm_target *ti, status_type_t type,
1354 char *result, unsigned int maxlen)
1355{
Jonathan E Brassow315dcc22007-05-09 02:32:58 -07001356 unsigned int m, sz = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 struct mirror_set *ms = (struct mirror_set *) ti->private;
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001358 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001359 char buffer[ms->nr_mirrors + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 switch (type) {
1362 case STATUSTYPE_INFO:
1363 DMEMIT("%d ", ms->nr_mirrors);
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001364 for (m = 0; m < ms->nr_mirrors; m++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 DMEMIT("%s ", ms->mirror[m].dev->name);
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001366 buffer[m] = device_status_char(&(ms->mirror[m]));
1367 }
1368 buffer[m] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001370 DMEMIT("%llu/%llu 1 %s ",
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001371 (unsigned long long)log->type->get_sync_count(log),
Jonathan Brassowaf195ac2008-02-08 02:11:39 +00001372 (unsigned long long)ms->nr_regions, buffer);
Jonathan E Brassow315dcc22007-05-09 02:32:58 -07001373
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001374 sz += log->type->status(log, type, result+sz, maxlen-sz);
Jonathan E Brassow315dcc22007-05-09 02:32:58 -07001375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 break;
1377
1378 case STATUSTYPE_TABLE:
Heinz Mauelshagen1f965b12008-10-21 17:45:06 +01001379 sz = log->type->status(log, type, result, maxlen);
Jonathan E Brassow315dcc22007-05-09 02:32:58 -07001380
Jonathan Brassowe52b8f62006-10-03 01:15:32 -07001381 DMEMIT("%d", ms->nr_mirrors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 for (m = 0; m < ms->nr_mirrors; m++)
Jonathan Brassowe52b8f62006-10-03 01:15:32 -07001383 DMEMIT(" %s %llu", ms->mirror[m].dev->name,
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001384 (unsigned long long)ms->mirror[m].offset);
Jonathan E Brassowa8e6afa2007-05-09 02:32:59 -07001385
1386 if (ms->features & DM_RAID1_HANDLE_ERRORS)
1387 DMEMIT(" 1 handle_errors");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 }
1389
1390 return 0;
1391}
1392
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001393static int mirror_iterate_devices(struct dm_target *ti,
1394 iterate_devices_callout_fn fn, void *data)
1395{
1396 struct mirror_set *ms = ti->private;
1397 int ret = 0;
1398 unsigned i;
1399
1400 for (i = 0; !ret && i < ms->nr_mirrors; i++)
1401 ret = fn(ti, ms->mirror[i].dev,
Mike Snitzer5dea2712009-07-23 20:30:42 +01001402 ms->mirror[i].offset, ti->len, data);
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001403
1404 return ret;
1405}
1406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407static struct target_type mirror_target = {
1408 .name = "mirror",
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001409 .version = {1, 12, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 .module = THIS_MODULE,
1411 .ctr = mirror_ctr,
1412 .dtr = mirror_dtr,
1413 .map = mirror_map,
1414 .end_io = mirror_end_io,
Jonathan Brassowb80aa7a2008-02-08 02:11:35 +00001415 .presuspend = mirror_presuspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 .postsuspend = mirror_postsuspend,
1417 .resume = mirror_resume,
1418 .status = mirror_status,
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001419 .iterate_devices = mirror_iterate_devices,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420};
1421
1422static int __init dm_mirror_init(void)
1423{
1424 int r;
1425
Mikulas Patocka95f8fac2009-04-02 19:55:24 +01001426 _dm_raid1_read_record_cache = KMEM_CACHE(dm_raid1_read_record, 0);
1427 if (!_dm_raid1_read_record_cache) {
1428 DMERR("Can't allocate dm_raid1_read_record cache");
1429 r = -ENOMEM;
1430 goto bad_cache;
1431 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
Mikulas Patocka95f8fac2009-04-02 19:55:24 +01001433 r = dm_register_target(&mirror_target);
1434 if (r < 0) {
1435 DMERR("Failed to register mirror target");
1436 goto bad_target;
1437 }
1438
1439 return 0;
1440
1441bad_target:
1442 kmem_cache_destroy(_dm_raid1_read_record_cache);
1443bad_cache:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 return r;
1445}
1446
1447static void __exit dm_mirror_exit(void)
1448{
Mikulas Patocka10d3bd02009-01-06 03:04:58 +00001449 dm_unregister_target(&mirror_target);
Mikulas Patocka95f8fac2009-04-02 19:55:24 +01001450 kmem_cache_destroy(_dm_raid1_read_record_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451}
1452
1453/* Module hooks */
1454module_init(dm_mirror_init);
1455module_exit(dm_mirror_exit);
1456
1457MODULE_DESCRIPTION(DM_NAME " mirror target");
1458MODULE_AUTHOR("Joe Thornber");
1459MODULE_LICENSE("GPL");