projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drbd: Actually allow BIOs up to 128k (was 32k).
[deliverable/linux.git] / drivers / block / drbd / drbd_main.c
CommitLineData
b411b363
PR		 1/*
2 drbd.c
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 Thanks to Carter Burden, Bart Grantham and Gennadiy Nerubayev
11 from Logicworks, Inc. for making SDP replication support possible.
12
13 drbd is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
16 any later version.
17
18 drbd is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with drbd; see the file COPYING. If not, write to
25 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26
27 */
28
b411b363 29#include <linux/module.h>
b411b363
PR		 30#include <linux/drbd.h>
31#include <asm/uaccess.h>
32#include <asm/types.h>
33#include <net/sock.h>
34#include <linux/ctype.h>
35#include <linux/smp_lock.h>
36#include <linux/fs.h>
37#include <linux/file.h>
38#include <linux/proc_fs.h>
39#include <linux/init.h>
40#include <linux/mm.h>
41#include <linux/memcontrol.h>
42#include <linux/mm_inline.h>
43#include <linux/slab.h>
44#include <linux/random.h>
45#include <linux/reboot.h>
46#include <linux/notifier.h>
47#include <linux/kthread.h>
48
49#define __KERNEL_SYSCALLS__
50#include <linux/unistd.h>
51#include <linux/vmalloc.h>
52
53#include <linux/drbd_limits.h>
54#include "drbd_int.h"
b411b363
PR		 55#include "drbd_req.h" /* only for _req_mod in tl_release and tl_clear */
56
57#include "drbd_vli.h"
58
59struct after_state_chg_work {
60 struct drbd_work w;
61 union drbd_state os;
62 union drbd_state ns;
63 enum chg_state_flags flags;
64 struct completion *done;
65};
66
67int drbdd_init(struct drbd_thread *);
68int drbd_worker(struct drbd_thread *);
69int drbd_asender(struct drbd_thread *);
70
71int drbd_init(void);
72static int drbd_open(struct block_device *bdev, fmode_t mode);
73static int drbd_release(struct gendisk *gd, fmode_t mode);
74static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused);
75static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
76 union drbd_state ns, enum chg_state_flags flags);
77static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused);
78static void md_sync_timer_fn(unsigned long data);
79static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused);
80
b411b363
PR		 81MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
82 "Lars Ellenberg <lars@linbit.com>");
83MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
84MODULE_VERSION(REL_VERSION);
85MODULE_LICENSE("GPL");
86MODULE_PARM_DESC(minor_count, "Maximum number of drbd devices (1-255)");
87MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
88
89#include <linux/moduleparam.h>
90/* allow_open_on_secondary */
91MODULE_PARM_DESC(allow_oos, "DONT USE!");
92/* thanks to these macros, if compiled into the kernel (not-module),
93 * this becomes the boot parameter drbd.minor_count */
94module_param(minor_count, uint, 0444);
95module_param(disable_sendpage, bool, 0644);
96module_param(allow_oos, bool, 0);
97module_param(cn_idx, uint, 0444);
98module_param(proc_details, int, 0644);
99
100#ifdef CONFIG_DRBD_FAULT_INJECTION
101int enable_faults;
102int fault_rate;
103static int fault_count;
104int fault_devs;
105/* bitmap of enabled faults */
106module_param(enable_faults, int, 0664);
107/* fault rate % value - applies to all enabled faults */
108module_param(fault_rate, int, 0664);
109/* count of faults inserted */
110module_param(fault_count, int, 0664);
111/* bitmap of devices to insert faults on */
112module_param(fault_devs, int, 0644);
113#endif
114
115/* module parameter, defined */
116unsigned int minor_count = 32;
117int disable_sendpage;
118int allow_oos;
119unsigned int cn_idx = CN_IDX_DRBD;
120int proc_details; /* Detail level in proc drbd*/
121
122/* Module parameter for setting the user mode helper program
123 * to run. Default is /sbin/drbdadm */
124char usermode_helper[80] = "/sbin/drbdadm";
125
126module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
127
128/* in 2.6.x, our device mapping and config info contains our virtual gendisks
129 * as member "struct gendisk *vdisk;"
130 */
131struct drbd_conf **minor_table;
132
133struct kmem_cache *drbd_request_cache;
134struct kmem_cache *drbd_ee_cache; /* epoch entries */
135struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
136struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
137mempool_t *drbd_request_mempool;
138mempool_t *drbd_ee_mempool;
139
140/* I do not use a standard mempool, because:
141 1) I want to hand out the pre-allocated objects first.
142 2) I want to be able to interrupt sleeping allocation with a signal.
143 Note: This is a single linked list, the next pointer is the private
144 member of struct page.
145 */
146struct page *drbd_pp_pool;
147spinlock_t drbd_pp_lock;
148int drbd_pp_vacant;
149wait_queue_head_t drbd_pp_wait;
150
151DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
152
7d4e9d09 153static const struct block_device_operations drbd_ops = {
b411b363
PR		 154 .owner = THIS_MODULE,
155 .open = drbd_open,
156 .release = drbd_release,
157};
158
159#define ARRY_SIZE(A) (sizeof(A)/sizeof(A[0]))
160
161#ifdef __CHECKER__
162/* When checking with sparse, and this is an inline function, sparse will
163 give tons of false positives. When this is a real functions sparse works.
164 */
165int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
166{
167 int io_allowed;
168
169 atomic_inc(&mdev->local_cnt);
170 io_allowed = (mdev->state.disk >= mins);
171 if (!io_allowed) {
172 if (atomic_dec_and_test(&mdev->local_cnt))
173 wake_up(&mdev->misc_wait);
174 }
175 return io_allowed;
176}
177
178#endif
179
180/**
181 * DOC: The transfer log
182 *
183 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
184 * mdev->newest_tle points to the head, mdev->oldest_tle points to the tail
185 * of the list. There is always at least one &struct drbd_tl_epoch object.
186 *
187 * Each &struct drbd_tl_epoch has a circular double linked list of requests
188 * attached.
189 */
190static int tl_init(struct drbd_conf *mdev)
191{
192 struct drbd_tl_epoch *b;
193
194 /* during device minor initialization, we may well use GFP_KERNEL */
195 b = kmalloc(sizeof(struct drbd_tl_epoch), GFP_KERNEL);
196 if (!b)
197 return 0;
198 INIT_LIST_HEAD(&b->requests);
199 INIT_LIST_HEAD(&b->w.list);
200 b->next = NULL;
201 b->br_number = 4711;
7e602c0a 202 b->n_writes = 0;
b411b363
PR		 203 b->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
204
205 mdev->oldest_tle = b;
206 mdev->newest_tle = b;
207 INIT_LIST_HEAD(&mdev->out_of_sequence_requests);
208
209 mdev->tl_hash = NULL;
210 mdev->tl_hash_s = 0;
211
212 return 1;
213}
214
215static void tl_cleanup(struct drbd_conf *mdev)
216{
217 D_ASSERT(mdev->oldest_tle == mdev->newest_tle);
218 D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
219 kfree(mdev->oldest_tle);
220 mdev->oldest_tle = NULL;
221 kfree(mdev->unused_spare_tle);
222 mdev->unused_spare_tle = NULL;
223 kfree(mdev->tl_hash);
224 mdev->tl_hash = NULL;
225 mdev->tl_hash_s = 0;
226}
227
228/**
229 * _tl_add_barrier() - Adds a barrier to the transfer log
230 * @mdev: DRBD device.
231 * @new: Barrier to be added before the current head of the TL.
232 *
233 * The caller must hold the req_lock.
234 */
235void _tl_add_barrier(struct drbd_conf *mdev, struct drbd_tl_epoch *new)
236{
237 struct drbd_tl_epoch *newest_before;
238
239 INIT_LIST_HEAD(&new->requests);
240 INIT_LIST_HEAD(&new->w.list);
241 new->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
242 new->next = NULL;
7e602c0a 243 new->n_writes = 0;
b411b363
PR		 244
245 newest_before = mdev->newest_tle;
246 /* never send a barrier number == 0, because that is special-cased
247 * when using TCQ for our write ordering code */
248 new->br_number = (newest_before->br_number+1) ?: 1;
249 if (mdev->newest_tle != new) {
250 mdev->newest_tle->next = new;
251 mdev->newest_tle = new;
252 }
253}
254
255/**
256 * tl_release() - Free or recycle the oldest &struct drbd_tl_epoch object of the TL
257 * @mdev: DRBD device.
258 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
259 * @set_size: Expected number of requests before that barrier.
260 *
261 * In case the passed barrier_nr or set_size does not match the oldest
262 * &struct drbd_tl_epoch objects this function will cause a termination
263 * of the connection.
264 */
265void tl_release(struct drbd_conf *mdev, unsigned int barrier_nr,
266 unsigned int set_size)
267{
268 struct drbd_tl_epoch *b, *nob; /* next old barrier */
269 struct list_head *le, *tle;
270 struct drbd_request *r;
271
272 spin_lock_irq(&mdev->req_lock);
273
274 b = mdev->oldest_tle;
275
276 /* first some paranoia code */
277 if (b == NULL) {
278 dev_err(DEV, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
279 barrier_nr);
280 goto bail;
281 }
282 if (b->br_number != barrier_nr) {
283 dev_err(DEV, "BAD! BarrierAck #%u received, expected #%u!\n",
284 barrier_nr, b->br_number);
285 goto bail;
286 }
7e602c0a
PR		 287 if (b->n_writes != set_size) {
288 dev_err(DEV, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
289 barrier_nr, set_size, b->n_writes);
b411b363
PR		 290 goto bail;
291 }
292
293 /* Clean up list of requests processed during current epoch */
294 list_for_each_safe(le, tle, &b->requests) {
295 r = list_entry(le, struct drbd_request, tl_requests);
296 _req_mod(r, barrier_acked);
297 }
298 /* There could be requests on the list waiting for completion
299 of the write to the local disk. To avoid corruptions of
300 slab's data structures we have to remove the lists head.
301
302 Also there could have been a barrier ack out of sequence, overtaking
303 the write acks - which would be a bug and violating write ordering.
304 To not deadlock in case we lose connection while such requests are
305 still pending, we need some way to find them for the
306 _req_mode(connection_lost_while_pending).
307
308 These have been list_move'd to the out_of_sequence_requests list in
309 _req_mod(, barrier_acked) above.
310 */
311 list_del_init(&b->requests);
312
313 nob = b->next;
314 if (test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) {
315 _tl_add_barrier(mdev, b);
316 if (nob)
317 mdev->oldest_tle = nob;
318 /* if nob == NULL b was the only barrier, and becomes the new
319 barrier. Therefore mdev->oldest_tle points already to b */
320 } else {
321 D_ASSERT(nob != NULL);
322 mdev->oldest_tle = nob;
323 kfree(b);
324 }
325
326 spin_unlock_irq(&mdev->req_lock);
327 dec_ap_pending(mdev);
328
329 return;
330
331bail:
332 spin_unlock_irq(&mdev->req_lock);
333 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
334}
335
b411b363 336/**
11b58e73 337 * _tl_restart() - Walks the transfer log, and applies an action to all requests
b411b363 338 * @mdev: DRBD device.
11b58e73 339 * @what: The action/event to perform with all request objects
b411b363 340 *
11b58e73
PR		 341 * @what might be one of connection_lost_while_pending, resend, fail_frozen_disk_io,
342 * restart_frozen_disk_io.
b411b363 343 */
11b58e73 344static void _tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
b411b363 345{
11b58e73 346 struct drbd_tl_epoch *b, *tmp, **pn;
b9b98716 347 struct list_head *le, *tle, carry_reads;
11b58e73
PR		 348 struct drbd_request *req;
349 int rv, n_writes, n_reads;
b411b363
PR		 350
351 b = mdev->oldest_tle;
11b58e73 352 pn = &mdev->oldest_tle;
b411b363 353 while (b) {
11b58e73
PR		 354 n_writes = 0;
355 n_reads = 0;
b9b98716 356 INIT_LIST_HEAD(&carry_reads);
b411b363 357 list_for_each_safe(le, tle, &b->requests) {
11b58e73
PR		 358 req = list_entry(le, struct drbd_request, tl_requests);
359 rv = _req_mod(req, what);
360
361 n_writes += (rv & MR_WRITE) >> MR_WRITE_SHIFT;
362 n_reads += (rv & MR_READ) >> MR_READ_SHIFT;
b411b363
PR		 363 }
364 tmp = b->next;
365
b9b98716 366 if (n_writes) {
11b58e73
PR		 367 if (what == resend) {
368 b->n_writes = n_writes;
369 if (b->w.cb == NULL) {
370 b->w.cb = w_send_barrier;
371 inc_ap_pending(mdev);
372 set_bit(CREATE_BARRIER, &mdev->flags);
373 }
374
375 drbd_queue_work(&mdev->data.work, &b->w);
376 }
377 pn = &b->next;
378 } else {
b9b98716
PR		 379 if (n_reads)
380 list_add(&carry_reads, &b->requests);
11b58e73
PR		 381 /* there could still be requests on that ring list,
382 * in case local io is still pending */
383 list_del(&b->requests);
384
385 /* dec_ap_pending corresponding to queue_barrier.
386 * the newest barrier may not have been queued yet,
387 * in which case w.cb is still NULL. */
388 if (b->w.cb != NULL)
389 dec_ap_pending(mdev);
390
391 if (b == mdev->newest_tle) {
392 /* recycle, but reinit! */
393 D_ASSERT(tmp == NULL);
394 INIT_LIST_HEAD(&b->requests);
b9b98716 395 list_splice(&carry_reads, &b->requests);
11b58e73
PR		 396 INIT_LIST_HEAD(&b->w.list);
397 b->w.cb = NULL;
398 b->br_number = net_random();
399 b->n_writes = 0;
400
401 *pn = b;
402 break;
403 }
404 *pn = tmp;
405 kfree(b);
b411b363 406 }
b411b363 407 b = tmp;
b9b98716 408 list_splice(&carry_reads, &b->requests);
b411b363 409 }
11b58e73
PR		 410}
411
412
413/**
414 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
415 * @mdev: DRBD device.
416 *
417 * This is called after the connection to the peer was lost. The storage covered
418 * by the requests on the transfer gets marked as our of sync. Called from the
419 * receiver thread and the worker thread.
420 */
421void tl_clear(struct drbd_conf *mdev)
422{
423 struct list_head *le, *tle;
424 struct drbd_request *r;
425
426 spin_lock_irq(&mdev->req_lock);
427
428 _tl_restart(mdev, connection_lost_while_pending);
b411b363
PR		 429
430 /* we expect this list to be empty. */
431 D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
432
433 /* but just in case, clean it up anyways! */
434 list_for_each_safe(le, tle, &mdev->out_of_sequence_requests) {
435 r = list_entry(le, struct drbd_request, tl_requests);
436 /* It would be nice to complete outside of spinlock.
437 * But this is easier for now. */
438 _req_mod(r, connection_lost_while_pending);
439 }
440
441 /* ensure bit indicating barrier is required is clear */
442 clear_bit(CREATE_BARRIER, &mdev->flags);
443
288f422e
PR		 444 memset(mdev->app_reads_hash, 0, APP_R_HSIZE*sizeof(void *));
445
b411b363
PR		 446 spin_unlock_irq(&mdev->req_lock);
447}
448
11b58e73
PR		 449void tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
450{
451 spin_lock_irq(&mdev->req_lock);
452 _tl_restart(mdev, what);
453 spin_unlock_irq(&mdev->req_lock);
454}
455
b411b363
PR		 456/**
457 * cl_wide_st_chg() - TRUE if the state change is a cluster wide one
458 * @mdev: DRBD device.
459 * @os: old (current) state.
460 * @ns: new (wanted) state.
461 */
462static int cl_wide_st_chg(struct drbd_conf *mdev,
463 union drbd_state os, union drbd_state ns)
464{
465 return (os.conn >= C_CONNECTED && ns.conn >= C_CONNECTED &&
466 ((os.role != R_PRIMARY && ns.role == R_PRIMARY) ||
467 (os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
468 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S) ||
469 (os.disk != D_DISKLESS && ns.disk == D_DISKLESS))) ||
470 (os.conn >= C_CONNECTED && ns.conn == C_DISCONNECTING) ||
471 (os.conn == C_CONNECTED && ns.conn == C_VERIFY_S);
472}
473
474int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f,
475 union drbd_state mask, union drbd_state val)
476{
477 unsigned long flags;
478 union drbd_state os, ns;
479 int rv;
480
481 spin_lock_irqsave(&mdev->req_lock, flags);
482 os = mdev->state;
483 ns.i = (os.i & ~mask.i) | val.i;
484 rv = _drbd_set_state(mdev, ns, f, NULL);
485 ns = mdev->state;
486 spin_unlock_irqrestore(&mdev->req_lock, flags);
487
488 return rv;
489}
490
491/**
492 * drbd_force_state() - Impose a change which happens outside our control on our state
493 * @mdev: DRBD device.
494 * @mask: mask of state bits to change.
495 * @val: value of new state bits.
496 */
497void drbd_force_state(struct drbd_conf *mdev,
498 union drbd_state mask, union drbd_state val)
499{
500 drbd_change_state(mdev, CS_HARD, mask, val);
501}
502
503static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns);
504static int is_valid_state_transition(struct drbd_conf *,
505 union drbd_state, union drbd_state);
506static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
507 union drbd_state ns, int *warn_sync_abort);
508int drbd_send_state_req(struct drbd_conf *,
509 union drbd_state, union drbd_state);
510
511static enum drbd_state_ret_codes _req_st_cond(struct drbd_conf *mdev,
512 union drbd_state mask, union drbd_state val)
513{
514 union drbd_state os, ns;
515 unsigned long flags;
516 int rv;
517
518 if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &mdev->flags))
519 return SS_CW_SUCCESS;
520
521 if (test_and_clear_bit(CL_ST_CHG_FAIL, &mdev->flags))
522 return SS_CW_FAILED_BY_PEER;
523
524 rv = 0;
525 spin_lock_irqsave(&mdev->req_lock, flags);
526 os = mdev->state;
527 ns.i = (os.i & ~mask.i) | val.i;
528 ns = sanitize_state(mdev, os, ns, NULL);
529
530 if (!cl_wide_st_chg(mdev, os, ns))
531 rv = SS_CW_NO_NEED;
532 if (!rv) {
533 rv = is_valid_state(mdev, ns);
534 if (rv == SS_SUCCESS) {
535 rv = is_valid_state_transition(mdev, ns, os);
536 if (rv == SS_SUCCESS)
537 rv = 0; /* cont waiting, otherwise fail. */
538 }
539 }
540 spin_unlock_irqrestore(&mdev->req_lock, flags);
541
542 return rv;
543}
544
545/**
546 * drbd_req_state() - Perform an eventually cluster wide state change
547 * @mdev: DRBD device.
548 * @mask: mask of state bits to change.
549 * @val: value of new state bits.
550 * @f: flags
551 *
552 * Should not be called directly, use drbd_request_state() or
553 * _drbd_request_state().
554 */
555static int drbd_req_state(struct drbd_conf *mdev,
556 union drbd_state mask, union drbd_state val,
557 enum chg_state_flags f)
558{
559 struct completion done;
560 unsigned long flags;
561 union drbd_state os, ns;
562 int rv;
563
564 init_completion(&done);
565
566 if (f & CS_SERIALIZE)
567 mutex_lock(&mdev->state_mutex);
568
569 spin_lock_irqsave(&mdev->req_lock, flags);
570 os = mdev->state;
571 ns.i = (os.i & ~mask.i) | val.i;
572 ns = sanitize_state(mdev, os, ns, NULL);
573
574 if (cl_wide_st_chg(mdev, os, ns)) {
575 rv = is_valid_state(mdev, ns);
576 if (rv == SS_SUCCESS)
577 rv = is_valid_state_transition(mdev, ns, os);
578 spin_unlock_irqrestore(&mdev->req_lock, flags);
579
580 if (rv < SS_SUCCESS) {
581 if (f & CS_VERBOSE)
582 print_st_err(mdev, os, ns, rv);
583 goto abort;
584 }
585
586 drbd_state_lock(mdev);
587 if (!drbd_send_state_req(mdev, mask, val)) {
588 drbd_state_unlock(mdev);
589 rv = SS_CW_FAILED_BY_PEER;
590 if (f & CS_VERBOSE)
591 print_st_err(mdev, os, ns, rv);
592 goto abort;
593 }
594
595 wait_event(mdev->state_wait,
596 (rv = _req_st_cond(mdev, mask, val)));
597
598 if (rv < SS_SUCCESS) {
599 drbd_state_unlock(mdev);
600 if (f & CS_VERBOSE)
601 print_st_err(mdev, os, ns, rv);
602 goto abort;
603 }
604 spin_lock_irqsave(&mdev->req_lock, flags);
605 os = mdev->state;
606 ns.i = (os.i & ~mask.i) | val.i;
607 rv = _drbd_set_state(mdev, ns, f, &done);
608 drbd_state_unlock(mdev);
609 } else {
610 rv = _drbd_set_state(mdev, ns, f, &done);
611 }
612
613 spin_unlock_irqrestore(&mdev->req_lock, flags);
614
615 if (f & CS_WAIT_COMPLETE && rv == SS_SUCCESS) {
616 D_ASSERT(current != mdev->worker.task);
617 wait_for_completion(&done);
618 }
619
620abort:
621 if (f & CS_SERIALIZE)
622 mutex_unlock(&mdev->state_mutex);
623
624 return rv;
625}
626
627/**
628 * _drbd_request_state() - Request a state change (with flags)
629 * @mdev: DRBD device.
630 * @mask: mask of state bits to change.
631 * @val: value of new state bits.
632 * @f: flags
633 *
634 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE
635 * flag, or when logging of failed state change requests is not desired.
636 */
637int _drbd_request_state(struct drbd_conf *mdev, union drbd_state mask,
638 union drbd_state val, enum chg_state_flags f)
639{
640 int rv;
641
642 wait_event(mdev->state_wait,
643 (rv = drbd_req_state(mdev, mask, val, f)) != SS_IN_TRANSIENT_STATE);
644
645 return rv;
646}
647
648static void print_st(struct drbd_conf *mdev, char *name, union drbd_state ns)
649{
650 dev_err(DEV, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c }\n",
651 name,
652 drbd_conn_str(ns.conn),
653 drbd_role_str(ns.role),
654 drbd_role_str(ns.peer),
655 drbd_disk_str(ns.disk),
656 drbd_disk_str(ns.pdsk),
657 ns.susp ? 's' : 'r',
658 ns.aftr_isp ? 'a' : '-',
659 ns.peer_isp ? 'p' : '-',
660 ns.user_isp ? 'u' : '-'
661 );
662}
663
664void print_st_err(struct drbd_conf *mdev,
665 union drbd_state os, union drbd_state ns, int err)
666{
667 if (err == SS_IN_TRANSIENT_STATE)
668 return;
669 dev_err(DEV, "State change failed: %s\n", drbd_set_st_err_str(err));
670 print_st(mdev, " state", os);
671 print_st(mdev, "wanted", ns);
672}
673
674
675#define drbd_peer_str drbd_role_str
676#define drbd_pdsk_str drbd_disk_str
677
678#define drbd_susp_str(A) ((A) ? "1" : "0")
679#define drbd_aftr_isp_str(A) ((A) ? "1" : "0")
680#define drbd_peer_isp_str(A) ((A) ? "1" : "0")
681#define drbd_user_isp_str(A) ((A) ? "1" : "0")
682
683#define PSC(A) \
684 ({ if (ns.A != os.A) { \
685 pbp += sprintf(pbp, #A "( %s -> %s ) ", \
686 drbd_##A##_str(os.A), \
687 drbd_##A##_str(ns.A)); \
688 } })
689
690/**
691 * is_valid_state() - Returns an SS_ error code if ns is not valid
692 * @mdev: DRBD device.
693 * @ns: State to consider.
694 */
695static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns)
696{
697 /* See drbd_state_sw_errors in drbd_strings.c */
698
699 enum drbd_fencing_p fp;
700 int rv = SS_SUCCESS;
701
702 fp = FP_DONT_CARE;
703 if (get_ldev(mdev)) {
704 fp = mdev->ldev->dc.fencing;
705 put_ldev(mdev);
706 }
707
708 if (get_net_conf(mdev)) {
709 if (!mdev->net_conf->two_primaries &&
710 ns.role == R_PRIMARY && ns.peer == R_PRIMARY)
711 rv = SS_TWO_PRIMARIES;
712 put_net_conf(mdev);
713 }
714
715 if (rv <= 0)
716 /* already found a reason to abort */;
717 else if (ns.role == R_SECONDARY && mdev->open_cnt)
718 rv = SS_DEVICE_IN_USE;
719
720 else if (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.disk < D_UP_TO_DATE)
721 rv = SS_NO_UP_TO_DATE_DISK;
722
723 else if (fp >= FP_RESOURCE &&
724 ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk >= D_UNKNOWN)
725 rv = SS_PRIMARY_NOP;
726
727 else if (ns.role == R_PRIMARY && ns.disk <= D_INCONSISTENT && ns.pdsk <= D_INCONSISTENT)
728 rv = SS_NO_UP_TO_DATE_DISK;
729
730 else if (ns.conn > C_CONNECTED && ns.disk < D_INCONSISTENT)
731 rv = SS_NO_LOCAL_DISK;
732
733 else if (ns.conn > C_CONNECTED && ns.pdsk < D_INCONSISTENT)
734 rv = SS_NO_REMOTE_DISK;
735
8d4ce82b
LE		 736 else if (ns.conn > C_CONNECTED && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE)
737 rv = SS_NO_UP_TO_DATE_DISK;
738
b411b363
PR		 739 else if ((ns.conn == C_CONNECTED ||
740 ns.conn == C_WF_BITMAP_S ||
741 ns.conn == C_SYNC_SOURCE ||
742 ns.conn == C_PAUSED_SYNC_S) &&
743 ns.disk == D_OUTDATED)
744 rv = SS_CONNECTED_OUTDATES;
745
746 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
747 (mdev->sync_conf.verify_alg[0] == 0))
748 rv = SS_NO_VERIFY_ALG;
749
750 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
751 mdev->agreed_pro_version < 88)
752 rv = SS_NOT_SUPPORTED;
753
754 return rv;
755}
756
757/**
758 * is_valid_state_transition() - Returns an SS_ error code if the state transition is not possible
759 * @mdev: DRBD device.
760 * @ns: new state.
761 * @os: old state.
762 */
763static int is_valid_state_transition(struct drbd_conf *mdev,
764 union drbd_state ns, union drbd_state os)
765{
766 int rv = SS_SUCCESS;
767
768 if ((ns.conn == C_STARTING_SYNC_T || ns.conn == C_STARTING_SYNC_S) &&
769 os.conn > C_CONNECTED)
770 rv = SS_RESYNC_RUNNING;
771
772 if (ns.conn == C_DISCONNECTING && os.conn == C_STANDALONE)
773 rv = SS_ALREADY_STANDALONE;
774
775 if (ns.disk > D_ATTACHING && os.disk == D_DISKLESS)
776 rv = SS_IS_DISKLESS;
777
778 if (ns.conn == C_WF_CONNECTION && os.conn < C_UNCONNECTED)
779 rv = SS_NO_NET_CONFIG;
780
781 if (ns.disk == D_OUTDATED && os.disk < D_OUTDATED && os.disk != D_ATTACHING)
782 rv = SS_LOWER_THAN_OUTDATED;
783
784 if (ns.conn == C_DISCONNECTING && os.conn == C_UNCONNECTED)
785 rv = SS_IN_TRANSIENT_STATE;
786
787 if (ns.conn == os.conn && ns.conn == C_WF_REPORT_PARAMS)
788 rv = SS_IN_TRANSIENT_STATE;
789
790 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && os.conn < C_CONNECTED)
791 rv = SS_NEED_CONNECTION;
792
793 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
794 ns.conn != os.conn && os.conn > C_CONNECTED)
795 rv = SS_RESYNC_RUNNING;
796
797 if ((ns.conn == C_STARTING_SYNC_S || ns.conn == C_STARTING_SYNC_T) &&
798 os.conn < C_CONNECTED)
799 rv = SS_NEED_CONNECTION;
800
801 return rv;
802}
803
804/**
805 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition
806 * @mdev: DRBD device.
807 * @os: old state.
808 * @ns: new state.
809 * @warn_sync_abort:
810 *
811 * When we loose connection, we have to set the state of the peers disk (pdsk)
812 * to D_UNKNOWN. This rule and many more along those lines are in this function.
813 */
814static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
815 union drbd_state ns, int *warn_sync_abort)
816{
817 enum drbd_fencing_p fp;
818
819 fp = FP_DONT_CARE;
820 if (get_ldev(mdev)) {
821 fp = mdev->ldev->dc.fencing;
822 put_ldev(mdev);
823 }
824
825 /* Disallow Network errors to configure a device's network part */
826 if ((ns.conn >= C_TIMEOUT && ns.conn <= C_TEAR_DOWN) &&
827 os.conn <= C_DISCONNECTING)
828 ns.conn = os.conn;
829
830 /* After a network error (+C_TEAR_DOWN) only C_UNCONNECTED or C_DISCONNECTING can follow */
831 if (os.conn >= C_TIMEOUT && os.conn <= C_TEAR_DOWN &&
832 ns.conn != C_UNCONNECTED && ns.conn != C_DISCONNECTING)
833 ns.conn = os.conn;
834
835 /* After C_DISCONNECTING only C_STANDALONE may follow */
836 if (os.conn == C_DISCONNECTING && ns.conn != C_STANDALONE)
837 ns.conn = os.conn;
838
839 if (ns.conn < C_CONNECTED) {
840 ns.peer_isp = 0;
841 ns.peer = R_UNKNOWN;
842 if (ns.pdsk > D_UNKNOWN || ns.pdsk < D_INCONSISTENT)
843 ns.pdsk = D_UNKNOWN;
844 }
845
846 /* Clear the aftr_isp when becoming unconfigured */
847 if (ns.conn == C_STANDALONE && ns.disk == D_DISKLESS && ns.role == R_SECONDARY)
848 ns.aftr_isp = 0;
849
b411b363
PR		 850 /* Abort resync if a disk fails/detaches */
851 if (os.conn > C_CONNECTED && ns.conn > C_CONNECTED &&
852 (ns.disk <= D_FAILED || ns.pdsk <= D_FAILED)) {
853 if (warn_sync_abort)
854 *warn_sync_abort = 1;
855 ns.conn = C_CONNECTED;
856 }
857
858 if (ns.conn >= C_CONNECTED &&
859 ((ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED) ||
860 (ns.disk == D_NEGOTIATING && ns.conn == C_WF_BITMAP_T))) {
861 switch (ns.conn) {
862 case C_WF_BITMAP_T:
863 case C_PAUSED_SYNC_T:
864 ns.disk = D_OUTDATED;
865 break;
866 case C_CONNECTED:
867 case C_WF_BITMAP_S:
868 case C_SYNC_SOURCE:
869 case C_PAUSED_SYNC_S:
870 ns.disk = D_UP_TO_DATE;
871 break;
872 case C_SYNC_TARGET:
873 ns.disk = D_INCONSISTENT;
874 dev_warn(DEV, "Implicitly set disk state Inconsistent!\n");
875 break;
876 }
877 if (os.disk == D_OUTDATED && ns.disk == D_UP_TO_DATE)
878 dev_warn(DEV, "Implicitly set disk from Outdated to UpToDate\n");
879 }
880
881 if (ns.conn >= C_CONNECTED &&
882 (ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED)) {
883 switch (ns.conn) {
884 case C_CONNECTED:
885 case C_WF_BITMAP_T:
886 case C_PAUSED_SYNC_T:
887 case C_SYNC_TARGET:
888 ns.pdsk = D_UP_TO_DATE;
889 break;
890 case C_WF_BITMAP_S:
891 case C_PAUSED_SYNC_S:
e0f83012
LE		 892 /* remap any consistent state to D_OUTDATED,
893 * but disallow "upgrade" of not even consistent states.
894 */
895 ns.pdsk =
896 (D_DISKLESS < os.pdsk && os.pdsk < D_OUTDATED)
897 ? os.pdsk : D_OUTDATED;
b411b363
PR		 898 break;
899 case C_SYNC_SOURCE:
900 ns.pdsk = D_INCONSISTENT;
901 dev_warn(DEV, "Implicitly set pdsk Inconsistent!\n");
902 break;
903 }
904 if (os.pdsk == D_OUTDATED && ns.pdsk == D_UP_TO_DATE)
905 dev_warn(DEV, "Implicitly set pdsk from Outdated to UpToDate\n");
906 }
907
908 /* Connection breaks down before we finished "Negotiating" */
909 if (ns.conn < C_CONNECTED && ns.disk == D_NEGOTIATING &&
910 get_ldev_if_state(mdev, D_NEGOTIATING)) {
911 if (mdev->ed_uuid == mdev->ldev->md.uuid[UI_CURRENT]) {
912 ns.disk = mdev->new_state_tmp.disk;
913 ns.pdsk = mdev->new_state_tmp.pdsk;
914 } else {
915 dev_alert(DEV, "Connection lost while negotiating, no data!\n");
916 ns.disk = D_DISKLESS;
917 ns.pdsk = D_UNKNOWN;
918 }
919 put_ldev(mdev);
920 }
921
922 if (fp == FP_STONITH &&
0a492166
PR		 923 (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk > D_OUTDATED) &&
924 !(os.role == R_PRIMARY && os.conn < C_CONNECTED && os.pdsk > D_OUTDATED))
265be2d0
PR		 925 ns.susp = 1; /* Suspend IO while fence-peer handler runs (peer lost) */
926
927 if (mdev->sync_conf.on_no_data == OND_SUSPEND_IO &&
928 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE) &&
929 !(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE))
930 ns.susp = 1; /* Suspend IO while no data available (no accessible data available) */
b411b363
PR		 931
932 if (ns.aftr_isp || ns.peer_isp || ns.user_isp) {
933 if (ns.conn == C_SYNC_SOURCE)
934 ns.conn = C_PAUSED_SYNC_S;
935 if (ns.conn == C_SYNC_TARGET)
936 ns.conn = C_PAUSED_SYNC_T;
937 } else {
938 if (ns.conn == C_PAUSED_SYNC_S)
939 ns.conn = C_SYNC_SOURCE;
940 if (ns.conn == C_PAUSED_SYNC_T)
941 ns.conn = C_SYNC_TARGET;
942 }
943
944 return ns;
945}
946
947/* helper for __drbd_set_state */
948static void set_ov_position(struct drbd_conf *mdev, enum drbd_conns cs)
949{
950 if (cs == C_VERIFY_T) {
951 /* starting online verify from an arbitrary position
952 * does not fit well into the existing protocol.
953 * on C_VERIFY_T, we initialize ov_left and friends
954 * implicitly in receive_DataRequest once the
955 * first P_OV_REQUEST is received */
956 mdev->ov_start_sector = ~(sector_t)0;
957 } else {
958 unsigned long bit = BM_SECT_TO_BIT(mdev->ov_start_sector);
959 if (bit >= mdev->rs_total)
960 mdev->ov_start_sector =
961 BM_BIT_TO_SECT(mdev->rs_total - 1);
962 mdev->ov_position = mdev->ov_start_sector;
963 }
964}
965
966/**
967 * __drbd_set_state() - Set a new DRBD state
968 * @mdev: DRBD device.
969 * @ns: new state.
970 * @flags: Flags
971 * @done: Optional completion, that will get completed after the after_state_ch() finished
972 *
973 * Caller needs to hold req_lock, and global_state_lock. Do not call directly.
974 */
975int __drbd_set_state(struct drbd_conf *mdev,
976 union drbd_state ns, enum chg_state_flags flags,
977 struct completion *done)
978{
979 union drbd_state os;
980 int rv = SS_SUCCESS;
981 int warn_sync_abort = 0;
982 struct after_state_chg_work *ascw;
983
984 os = mdev->state;
985
986 ns = sanitize_state(mdev, os, ns, &warn_sync_abort);
987
988 if (ns.i == os.i)
989 return SS_NOTHING_TO_DO;
990
991 if (!(flags & CS_HARD)) {
992 /* pre-state-change checks ; only look at ns */
993 /* See drbd_state_sw_errors in drbd_strings.c */
994
995 rv = is_valid_state(mdev, ns);
996 if (rv < SS_SUCCESS) {
997 /* If the old state was illegal as well, then let
998 this happen...*/
999
1616a254 1000 if (is_valid_state(mdev, os) == rv)
b411b363 1001 rv = is_valid_state_transition(mdev, ns, os);
b411b363
PR		 1002 } else
1003 rv = is_valid_state_transition(mdev, ns, os);
1004 }
1005
1006 if (rv < SS_SUCCESS) {
1007 if (flags & CS_VERBOSE)
1008 print_st_err(mdev, os, ns, rv);
1009 return rv;
1010 }
1011
1012 if (warn_sync_abort)
1013 dev_warn(DEV, "Resync aborted.\n");
1014
1015 {
1016 char *pbp, pb[300];
1017 pbp = pb;
1018 *pbp = 0;
1019 PSC(role);
1020 PSC(peer);
1021 PSC(conn);
1022 PSC(disk);
1023 PSC(pdsk);
1024 PSC(susp);
1025 PSC(aftr_isp);
1026 PSC(peer_isp);
1027 PSC(user_isp);
1028 dev_info(DEV, "%s\n", pb);
1029 }
1030
1031 /* solve the race between becoming unconfigured,
1032 * worker doing the cleanup, and
1033 * admin reconfiguring us:
1034 * on (re)configure, first set CONFIG_PENDING,
1035 * then wait for a potentially exiting worker,
1036 * start the worker, and schedule one no_op.
1037 * then proceed with configuration.
1038 */
1039 if (ns.disk == D_DISKLESS &&
1040 ns.conn == C_STANDALONE &&
1041 ns.role == R_SECONDARY &&
1042 !test_and_set_bit(CONFIG_PENDING, &mdev->flags))
1043 set_bit(DEVICE_DYING, &mdev->flags);
1044
1045 mdev->state.i = ns.i;
1046 wake_up(&mdev->misc_wait);
1047 wake_up(&mdev->state_wait);
1048
1049 /* post-state-change actions */
1050 if (os.conn >= C_SYNC_SOURCE && ns.conn <= C_CONNECTED) {
1051 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1052 mod_timer(&mdev->resync_timer, jiffies);
1053 }
1054
1055 /* aborted verify run. log the last position */
1056 if ((os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) &&
1057 ns.conn < C_CONNECTED) {
1058 mdev->ov_start_sector =
1059 BM_BIT_TO_SECT(mdev->rs_total - mdev->ov_left);
1060 dev_info(DEV, "Online Verify reached sector %llu\n",
1061 (unsigned long long)mdev->ov_start_sector);
1062 }
1063
1064 if ((os.conn == C_PAUSED_SYNC_T || os.conn == C_PAUSED_SYNC_S) &&
1065 (ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE)) {
1066 dev_info(DEV, "Syncer continues.\n");
1d7734a0
LE		 1067 mdev->rs_paused += (long)jiffies
1068 -(long)mdev->rs_mark_time[mdev->rs_last_mark];
b411b363
PR		 1069 if (ns.conn == C_SYNC_TARGET) {
1070 if (!test_and_clear_bit(STOP_SYNC_TIMER, &mdev->flags))
1071 mod_timer(&mdev->resync_timer, jiffies);
1072 /* This if (!test_bit) is only needed for the case
1073 that a device that has ceased to used its timer,
1074 i.e. it is already in drbd_resync_finished() gets
1075 paused and resumed. */
1076 }
1077 }
1078
1079 if ((os.conn == C_SYNC_TARGET || os.conn == C_SYNC_SOURCE) &&
1080 (ns.conn == C_PAUSED_SYNC_T || ns.conn == C_PAUSED_SYNC_S)) {
1081 dev_info(DEV, "Resync suspended\n");
1d7734a0 1082 mdev->rs_mark_time[mdev->rs_last_mark] = jiffies;
b411b363
PR		 1083 if (ns.conn == C_PAUSED_SYNC_T)
1084 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1085 }
1086
1087 if (os.conn == C_CONNECTED &&
1088 (ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T)) {
1d7734a0
LE		 1089 unsigned long now = jiffies;
1090 int i;
1091
b411b363 1092 mdev->ov_position = 0;
1d7734a0 1093 mdev->rs_total = drbd_bm_bits(mdev);
b411b363
PR		 1094 if (mdev->agreed_pro_version >= 90)
1095 set_ov_position(mdev, ns.conn);
1096 else
1097 mdev->ov_start_sector = 0;
1098 mdev->ov_left = mdev->rs_total
1099 - BM_SECT_TO_BIT(mdev->ov_position);
1d7734a0 1100 mdev->rs_start = now;
0f0601f4
LE		 1101 mdev->rs_last_events = 0;
1102 mdev->rs_last_sect_ev = 0;
b411b363
PR		 1103 mdev->ov_last_oos_size = 0;
1104 mdev->ov_last_oos_start = 0;
1105
1d7734a0
LE		 1106 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
1107 mdev->rs_mark_left[i] = mdev->rs_total;
1108 mdev->rs_mark_time[i] = now;
1109 }
1110
b411b363
PR		 1111 if (ns.conn == C_VERIFY_S) {
1112 dev_info(DEV, "Starting Online Verify from sector %llu\n",
1113 (unsigned long long)mdev->ov_position);
1114 mod_timer(&mdev->resync_timer, jiffies);
1115 }
1116 }
1117
1118 if (get_ldev(mdev)) {
1119 u32 mdf = mdev->ldev->md.flags & ~(MDF_CONSISTENT|MDF_PRIMARY_IND|
1120 MDF_CONNECTED_IND|MDF_WAS_UP_TO_DATE|
1121 MDF_PEER_OUT_DATED|MDF_CRASHED_PRIMARY);
1122
1123 if (test_bit(CRASHED_PRIMARY, &mdev->flags))
1124 mdf |= MDF_CRASHED_PRIMARY;
1125 if (mdev->state.role == R_PRIMARY ||
1126 (mdev->state.pdsk < D_INCONSISTENT && mdev->state.peer == R_PRIMARY))
1127 mdf |= MDF_PRIMARY_IND;
1128 if (mdev->state.conn > C_WF_REPORT_PARAMS)
1129 mdf |= MDF_CONNECTED_IND;
1130 if (mdev->state.disk > D_INCONSISTENT)
1131 mdf |= MDF_CONSISTENT;
1132 if (mdev->state.disk > D_OUTDATED)
1133 mdf |= MDF_WAS_UP_TO_DATE;
1134 if (mdev->state.pdsk <= D_OUTDATED && mdev->state.pdsk >= D_INCONSISTENT)
1135 mdf |= MDF_PEER_OUT_DATED;
1136 if (mdf != mdev->ldev->md.flags) {
1137 mdev->ldev->md.flags = mdf;
1138 drbd_md_mark_dirty(mdev);
1139 }
1140 if (os.disk < D_CONSISTENT && ns.disk >= D_CONSISTENT)
1141 drbd_set_ed_uuid(mdev, mdev->ldev->md.uuid[UI_CURRENT]);
1142 put_ldev(mdev);
1143 }
1144
1145 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */
1146 if (os.disk == D_INCONSISTENT && os.pdsk == D_INCONSISTENT &&
1147 os.peer == R_SECONDARY && ns.peer == R_PRIMARY)
1148 set_bit(CONSIDER_RESYNC, &mdev->flags);
1149
1150 /* Receiver should clean up itself */
1151 if (os.conn != C_DISCONNECTING && ns.conn == C_DISCONNECTING)
1152 drbd_thread_stop_nowait(&mdev->receiver);
1153
1154 /* Now the receiver finished cleaning up itself, it should die */
1155 if (os.conn != C_STANDALONE && ns.conn == C_STANDALONE)
1156 drbd_thread_stop_nowait(&mdev->receiver);
1157
1158 /* Upon network failure, we need to restart the receiver. */
1159 if (os.conn > C_TEAR_DOWN &&
1160 ns.conn <= C_TEAR_DOWN && ns.conn >= C_TIMEOUT)
1161 drbd_thread_restart_nowait(&mdev->receiver);
1162
1163 ascw = kmalloc(sizeof(*ascw), GFP_ATOMIC);
1164 if (ascw) {
1165 ascw->os = os;
1166 ascw->ns = ns;
1167 ascw->flags = flags;
1168 ascw->w.cb = w_after_state_ch;
1169 ascw->done = done;
1170 drbd_queue_work(&mdev->data.work, &ascw->w);
1171 } else {
1172 dev_warn(DEV, "Could not kmalloc an ascw\n");
1173 }
1174
1175 return rv;
1176}
1177
1178static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1179{
1180 struct after_state_chg_work *ascw =
1181 container_of(w, struct after_state_chg_work, w);
1182 after_state_ch(mdev, ascw->os, ascw->ns, ascw->flags);
1183 if (ascw->flags & CS_WAIT_COMPLETE) {
1184 D_ASSERT(ascw->done != NULL);
1185 complete(ascw->done);
1186 }
1187 kfree(ascw);
1188
1189 return 1;
1190}
1191
1192static void abw_start_sync(struct drbd_conf *mdev, int rv)
1193{
1194 if (rv) {
1195 dev_err(DEV, "Writing the bitmap failed not starting resync.\n");
1196 _drbd_request_state(mdev, NS(conn, C_CONNECTED), CS_VERBOSE);
1197 return;
1198 }
1199
1200 switch (mdev->state.conn) {
1201 case C_STARTING_SYNC_T:
1202 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
1203 break;
1204 case C_STARTING_SYNC_S:
1205 drbd_start_resync(mdev, C_SYNC_SOURCE);
1206 break;
1207 }
1208}
1209
1210/**
1211 * after_state_ch() - Perform after state change actions that may sleep
1212 * @mdev: DRBD device.
1213 * @os: old state.
1214 * @ns: new state.
1215 * @flags: Flags
1216 */
1217static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
1218 union drbd_state ns, enum chg_state_flags flags)
1219{
1220 enum drbd_fencing_p fp;
67098930 1221 enum drbd_req_event what = nothing;
b411b363
PR		 1222
1223 if (os.conn != C_CONNECTED && ns.conn == C_CONNECTED) {
1224 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1225 if (mdev->p_uuid)
1226 mdev->p_uuid[UI_FLAGS] &= ~((u64)2);
1227 }
1228
1229 fp = FP_DONT_CARE;
1230 if (get_ldev(mdev)) {
1231 fp = mdev->ldev->dc.fencing;
1232 put_ldev(mdev);
1233 }
1234
1235 /* Inform userspace about the change... */
1236 drbd_bcast_state(mdev, ns);
1237
1238 if (!(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE) &&
1239 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE))
1240 drbd_khelper(mdev, "pri-on-incon-degr");
1241
1242 /* Here we have the actions that are performed after a
1243 state change. This function might sleep */
1244
265be2d0
PR		 1245 if (os.susp && ns.susp && mdev->sync_conf.on_no_data == OND_SUSPEND_IO) {
1246 if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED) {
67098930
PR		 1247 if (ns.conn == C_CONNECTED)
1248 what = resend;
1249 else /* ns.conn > C_CONNECTED */
265be2d0
PR		 1250 dev_err(DEV, "Unexpected Resynd going on!\n");
1251 }
1252
67098930
PR		 1253 if (os.disk == D_ATTACHING && ns.disk > D_ATTACHING)
1254 what = restart_frozen_disk_io;
265be2d0
PR		 1255 }
1256
b411b363 1257 if (fp == FP_STONITH && ns.susp) {
43a5182c
PR		 1258 /* case1: The outdate peer handler is successful: */
1259 if (os.pdsk > D_OUTDATED && ns.pdsk <= D_OUTDATED) {
b411b363 1260 tl_clear(mdev);
43a5182c
PR		 1261 if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
1262 drbd_uuid_new_current(mdev);
1263 clear_bit(NEW_CUR_UUID, &mdev->flags);
1264 drbd_md_sync(mdev);
1265 }
b411b363
PR		 1266 spin_lock_irq(&mdev->req_lock);
1267 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1268 spin_unlock_irq(&mdev->req_lock);
1269 }
43a5182c
PR		 1270 /* case2: The connection was established again: */
1271 if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED) {
1272 clear_bit(NEW_CUR_UUID, &mdev->flags);
67098930 1273 what = resend;
43a5182c 1274 }
b411b363 1275 }
67098930
PR		 1276
1277 if (what != nothing) {
1278 spin_lock_irq(&mdev->req_lock);
1279 _tl_restart(mdev, what);
1280 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1281 spin_unlock_irq(&mdev->req_lock);
1282 }
1283
b411b363
PR		 1284 /* Do not change the order of the if above and the two below... */
1285 if (os.pdsk == D_DISKLESS && ns.pdsk > D_DISKLESS) { /* attach on the peer */
1286 drbd_send_uuids(mdev);
1287 drbd_send_state(mdev);
1288 }
1289 if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S)
1290 drbd_queue_bitmap_io(mdev, &drbd_send_bitmap, NULL, "send_bitmap (WFBitMapS)");
1291
1292 /* Lost contact to peer's copy of the data */
1293 if ((os.pdsk >= D_INCONSISTENT &&
1294 os.pdsk != D_UNKNOWN &&
1295 os.pdsk != D_OUTDATED)
1296 && (ns.pdsk < D_INCONSISTENT ||
1297 ns.pdsk == D_UNKNOWN ||
1298 ns.pdsk == D_OUTDATED)) {
b411b363
PR		 1299 if (get_ldev(mdev)) {
1300 if ((ns.role == R_PRIMARY || ns.peer == R_PRIMARY) &&
2c8d1967 1301 mdev->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) {
43a5182c
PR		 1302 if (mdev->state.susp) {
1303 set_bit(NEW_CUR_UUID, &mdev->flags);
1304 } else {
1305 drbd_uuid_new_current(mdev);
1306 drbd_send_uuids(mdev);
1307 }
2c8d1967 1308 }
b411b363
PR		 1309 put_ldev(mdev);
1310 }
1311 }
1312
1313 if (ns.pdsk < D_INCONSISTENT && get_ldev(mdev)) {
18a50fa2 1314 if (ns.peer == R_PRIMARY && mdev->ldev->md.uuid[UI_BITMAP] == 0) {
2c8d1967 1315 drbd_uuid_new_current(mdev);
18a50fa2
PR		 1316 drbd_send_uuids(mdev);
1317 }
b411b363
PR		 1318
1319 /* D_DISKLESS Peer becomes secondary */
1320 if (os.peer == R_PRIMARY && ns.peer == R_SECONDARY)
1321 drbd_al_to_on_disk_bm(mdev);
1322 put_ldev(mdev);
1323 }
1324
1325 /* Last part of the attaching process ... */
1326 if (ns.conn >= C_CONNECTED &&
1327 os.disk == D_ATTACHING && ns.disk == D_NEGOTIATING) {
e89b591c 1328 drbd_send_sizes(mdev, 0, 0); /* to start sync... */
b411b363
PR		 1329 drbd_send_uuids(mdev);
1330 drbd_send_state(mdev);
1331 }
1332
1333 /* We want to pause/continue resync, tell peer. */
1334 if (ns.conn >= C_CONNECTED &&
1335 ((os.aftr_isp != ns.aftr_isp) ||
1336 (os.user_isp != ns.user_isp)))
1337 drbd_send_state(mdev);
1338
1339 /* In case one of the isp bits got set, suspend other devices. */
1340 if ((!os.aftr_isp && !os.peer_isp && !os.user_isp) &&
1341 (ns.aftr_isp || ns.peer_isp || ns.user_isp))
1342 suspend_other_sg(mdev);
1343
1344 /* Make sure the peer gets informed about eventual state
1345 changes (ISP bits) while we were in WFReportParams. */
1346 if (os.conn == C_WF_REPORT_PARAMS && ns.conn >= C_CONNECTED)
1347 drbd_send_state(mdev);
1348
1349 /* We are in the progress to start a full sync... */
1350 if ((os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
1351 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S))
1352 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, &abw_start_sync, "set_n_write from StartingSync");
1353
1354 /* We are invalidating our self... */
1355 if (os.conn < C_CONNECTED && ns.conn < C_CONNECTED &&
1356 os.disk > D_INCONSISTENT && ns.disk == D_INCONSISTENT)
1357 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL, "set_n_write from invalidate");
1358
1359 if (os.disk > D_FAILED && ns.disk == D_FAILED) {
1360 enum drbd_io_error_p eh;
1361
1362 eh = EP_PASS_ON;
1363 if (get_ldev_if_state(mdev, D_FAILED)) {
1364 eh = mdev->ldev->dc.on_io_error;
1365 put_ldev(mdev);
1366 }
1367
1368 drbd_rs_cancel_all(mdev);
1369 /* since get_ldev() only works as long as disk>=D_INCONSISTENT,
1370 and it is D_DISKLESS here, local_cnt can only go down, it can
1371 not increase... It will reach zero */
1372 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
1373 mdev->rs_total = 0;
1374 mdev->rs_failed = 0;
1375 atomic_set(&mdev->rs_pending_cnt, 0);
1376
1377 spin_lock_irq(&mdev->req_lock);
1378 _drbd_set_state(_NS(mdev, disk, D_DISKLESS), CS_HARD, NULL);
1379 spin_unlock_irq(&mdev->req_lock);
1380
1381 if (eh == EP_CALL_HELPER)
1382 drbd_khelper(mdev, "local-io-error");
1383 }
1384
1385 if (os.disk > D_DISKLESS && ns.disk == D_DISKLESS) {
1386
1387 if (os.disk == D_FAILED) /* && ns.disk == D_DISKLESS*/ {
1388 if (drbd_send_state(mdev))
1389 dev_warn(DEV, "Notified peer that my disk is broken.\n");
1390 else
1391 dev_err(DEV, "Sending state in drbd_io_error() failed\n");
1392 }
1393
0a6dbf2b 1394 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
b411b363
PR		 1395 lc_destroy(mdev->resync);
1396 mdev->resync = NULL;
1397 lc_destroy(mdev->act_log);
1398 mdev->act_log = NULL;
1399 __no_warn(local,
1400 drbd_free_bc(mdev->ldev);
1401 mdev->ldev = NULL;);
1402
1403 if (mdev->md_io_tmpp)
1404 __free_page(mdev->md_io_tmpp);
1405 }
1406
1407 /* Disks got bigger while they were detached */
1408 if (ns.disk > D_NEGOTIATING && ns.pdsk > D_NEGOTIATING &&
1409 test_and_clear_bit(RESYNC_AFTER_NEG, &mdev->flags)) {
1410 if (ns.conn == C_CONNECTED)
1411 resync_after_online_grow(mdev);
1412 }
1413
1414 /* A resync finished or aborted, wake paused devices... */
1415 if ((os.conn > C_CONNECTED && ns.conn <= C_CONNECTED) ||
1416 (os.peer_isp && !ns.peer_isp) ||
1417 (os.user_isp && !ns.user_isp))
1418 resume_next_sg(mdev);
1419
f70b3511
PR		 1420 /* free tl_hash if we Got thawed and are C_STANDALONE */
1421 if (ns.conn == C_STANDALONE && ns.susp == 0 && mdev->tl_hash)
1422 drbd_free_tl_hash(mdev);
1423
b411b363
PR		 1424 /* Upon network connection, we need to start the receiver */
1425 if (os.conn == C_STANDALONE && ns.conn == C_UNCONNECTED)
1426 drbd_thread_start(&mdev->receiver);
1427
1428 /* Terminate worker thread if we are unconfigured - it will be
1429 restarted as needed... */
1430 if (ns.disk == D_DISKLESS &&
1431 ns.conn == C_STANDALONE &&
1432 ns.role == R_SECONDARY) {
1433 if (os.aftr_isp != ns.aftr_isp)
1434 resume_next_sg(mdev);
1435 /* set in __drbd_set_state, unless CONFIG_PENDING was set */
1436 if (test_bit(DEVICE_DYING, &mdev->flags))
1437 drbd_thread_stop_nowait(&mdev->worker);
1438 }
1439
1440 drbd_md_sync(mdev);
1441}
1442
1443
1444static int drbd_thread_setup(void *arg)
1445{
1446 struct drbd_thread *thi = (struct drbd_thread *) arg;
1447 struct drbd_conf *mdev = thi->mdev;
1448 unsigned long flags;
1449 int retval;
1450
1451restart:
1452 retval = thi->function(thi);
1453
1454 spin_lock_irqsave(&thi->t_lock, flags);
1455
1456 /* if the receiver has been "Exiting", the last thing it did
1457 * was set the conn state to "StandAlone",
1458 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
1459 * and receiver thread will be "started".
1460 * drbd_thread_start needs to set "Restarting" in that case.
1461 * t_state check and assignment needs to be within the same spinlock,
1462 * so either thread_start sees Exiting, and can remap to Restarting,
1463 * or thread_start see None, and can proceed as normal.
1464 */
1465
1466 if (thi->t_state == Restarting) {
1467 dev_info(DEV, "Restarting %s\n", current->comm);
1468 thi->t_state = Running;
1469 spin_unlock_irqrestore(&thi->t_lock, flags);
1470 goto restart;
1471 }
1472
1473 thi->task = NULL;
1474 thi->t_state = None;
1475 smp_mb();
1476 complete(&thi->stop);
1477 spin_unlock_irqrestore(&thi->t_lock, flags);
1478
1479 dev_info(DEV, "Terminating %s\n", current->comm);
1480
1481 /* Release mod reference taken when thread was started */
1482 module_put(THIS_MODULE);
1483 return retval;
1484}
1485
1486static void drbd_thread_init(struct drbd_conf *mdev, struct drbd_thread *thi,
1487 int (*func) (struct drbd_thread *))
1488{
1489 spin_lock_init(&thi->t_lock);
1490 thi->task = NULL;
1491 thi->t_state = None;
1492 thi->function = func;
1493 thi->mdev = mdev;
1494}
1495
1496int drbd_thread_start(struct drbd_thread *thi)
1497{
1498 struct drbd_conf *mdev = thi->mdev;
1499 struct task_struct *nt;
1500 unsigned long flags;
1501
1502 const char *me =
1503 thi == &mdev->receiver ? "receiver" :
1504 thi == &mdev->asender ? "asender" :
1505 thi == &mdev->worker ? "worker" : "NONSENSE";
1506
1507 /* is used from state engine doing drbd_thread_stop_nowait,
1508 * while holding the req lock irqsave */
1509 spin_lock_irqsave(&thi->t_lock, flags);
1510
1511 switch (thi->t_state) {
1512 case None:
1513 dev_info(DEV, "Starting %s thread (from %s [%d])\n",
1514 me, current->comm, current->pid);
1515
1516 /* Get ref on module for thread - this is released when thread exits */
1517 if (!try_module_get(THIS_MODULE)) {
1518 dev_err(DEV, "Failed to get module reference in drbd_thread_start\n");
1519 spin_unlock_irqrestore(&thi->t_lock, flags);
1520 return FALSE;
1521 }
1522
1523 init_completion(&thi->stop);
1524 D_ASSERT(thi->task == NULL);
1525 thi->reset_cpu_mask = 1;
1526 thi->t_state = Running;
1527 spin_unlock_irqrestore(&thi->t_lock, flags);
1528 flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
1529
1530 nt = kthread_create(drbd_thread_setup, (void *) thi,
1531 "drbd%d_%s", mdev_to_minor(mdev), me);
1532
1533 if (IS_ERR(nt)) {
1534 dev_err(DEV, "Couldn't start thread\n");
1535
1536 module_put(THIS_MODULE);
1537 return FALSE;
1538 }
1539 spin_lock_irqsave(&thi->t_lock, flags);
1540 thi->task = nt;
1541 thi->t_state = Running;
1542 spin_unlock_irqrestore(&thi->t_lock, flags);
1543 wake_up_process(nt);
1544 break;
1545 case Exiting:
1546 thi->t_state = Restarting;
1547 dev_info(DEV, "Restarting %s thread (from %s [%d])\n",
1548 me, current->comm, current->pid);
1549 /* fall through */
1550 case Running:
1551 case Restarting:
1552 default:
1553 spin_unlock_irqrestore(&thi->t_lock, flags);
1554 break;
1555 }
1556
1557 return TRUE;
1558}
1559
1560
1561void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
1562{
1563 unsigned long flags;
1564
1565 enum drbd_thread_state ns = restart ? Restarting : Exiting;
1566
1567 /* may be called from state engine, holding the req lock irqsave */
1568 spin_lock_irqsave(&thi->t_lock, flags);
1569
1570 if (thi->t_state == None) {
1571 spin_unlock_irqrestore(&thi->t_lock, flags);
1572 if (restart)
1573 drbd_thread_start(thi);
1574 return;
1575 }
1576
1577 if (thi->t_state != ns) {
1578 if (thi->task == NULL) {
1579 spin_unlock_irqrestore(&thi->t_lock, flags);
1580 return;
1581 }
1582
1583 thi->t_state = ns;
1584 smp_mb();
1585 init_completion(&thi->stop);
1586 if (thi->task != current)
1587 force_sig(DRBD_SIGKILL, thi->task);
1588
1589 }
1590
1591 spin_unlock_irqrestore(&thi->t_lock, flags);
1592
1593 if (wait)
1594 wait_for_completion(&thi->stop);
1595}
1596
1597#ifdef CONFIG_SMP
1598/**
1599 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
1600 * @mdev: DRBD device.
1601 *
1602 * Forces all threads of a device onto the same CPU. This is beneficial for
1603 * DRBD's performance. May be overwritten by user's configuration.
1604 */
1605void drbd_calc_cpu_mask(struct drbd_conf *mdev)
1606{
1607 int ord, cpu;
1608
1609 /* user override. */
1610 if (cpumask_weight(mdev->cpu_mask))
1611 return;
1612
1613 ord = mdev_to_minor(mdev) % cpumask_weight(cpu_online_mask);
1614 for_each_online_cpu(cpu) {
1615 if (ord-- == 0) {
1616 cpumask_set_cpu(cpu, mdev->cpu_mask);
1617 return;
1618 }
1619 }
1620 /* should not be reached */
1621 cpumask_setall(mdev->cpu_mask);
1622}
1623
1624/**
1625 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
1626 * @mdev: DRBD device.
1627 *
1628 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
1629 * prematurely.
1630 */
1631void drbd_thread_current_set_cpu(struct drbd_conf *mdev)
1632{
1633 struct task_struct *p = current;
1634 struct drbd_thread *thi =
1635 p == mdev->asender.task ? &mdev->asender :
1636 p == mdev->receiver.task ? &mdev->receiver :
1637 p == mdev->worker.task ? &mdev->worker :
1638 NULL;
1639 ERR_IF(thi == NULL)
1640 return;
1641 if (!thi->reset_cpu_mask)
1642 return;
1643 thi->reset_cpu_mask = 0;
1644 set_cpus_allowed_ptr(p, mdev->cpu_mask);
1645}
1646#endif
1647
1648/* the appropriate socket mutex must be held already */
1649int _drbd_send_cmd(struct drbd_conf *mdev, struct socket *sock,
0b70a13d 1650 enum drbd_packets cmd, struct p_header80 *h,
b411b363
PR		 1651 size_t size, unsigned msg_flags)
1652{
1653 int sent, ok;
1654
1655 ERR_IF(!h) return FALSE;
1656 ERR_IF(!size) return FALSE;
1657
1658 h->magic = BE_DRBD_MAGIC;
1659 h->command = cpu_to_be16(cmd);
0b70a13d 1660 h->length = cpu_to_be16(size-sizeof(struct p_header80));
b411b363 1661
b411b363
PR		 1662 sent = drbd_send(mdev, sock, h, size, msg_flags);
1663
1664 ok = (sent == size);
1665 if (!ok)
1666 dev_err(DEV, "short sent %s size=%d sent=%d\n",
1667 cmdname(cmd), (int)size, sent);
1668 return ok;
1669}
1670
1671/* don't pass the socket. we may only look at it
1672 * when we hold the appropriate socket mutex.
1673 */
1674int drbd_send_cmd(struct drbd_conf *mdev, int use_data_socket,
0b70a13d 1675 enum drbd_packets cmd, struct p_header80 *h, size_t size)
b411b363
PR		 1676{
1677 int ok = 0;
1678 struct socket *sock;
1679
1680 if (use_data_socket) {
1681 mutex_lock(&mdev->data.mutex);
1682 sock = mdev->data.socket;
1683 } else {
1684 mutex_lock(&mdev->meta.mutex);
1685 sock = mdev->meta.socket;
1686 }
1687
1688 /* drbd_disconnect() could have called drbd_free_sock()
1689 * while we were waiting in down()... */
1690 if (likely(sock != NULL))
1691 ok = _drbd_send_cmd(mdev, sock, cmd, h, size, 0);
1692
1693 if (use_data_socket)
1694 mutex_unlock(&mdev->data.mutex);
1695 else
1696 mutex_unlock(&mdev->meta.mutex);
1697 return ok;
1698}
1699
1700int drbd_send_cmd2(struct drbd_conf *mdev, enum drbd_packets cmd, char *data,
1701 size_t size)
1702{
0b70a13d 1703 struct p_header80 h;
b411b363
PR		 1704 int ok;
1705
1706 h.magic = BE_DRBD_MAGIC;
1707 h.command = cpu_to_be16(cmd);
1708 h.length = cpu_to_be16(size);
1709
1710 if (!drbd_get_data_sock(mdev))
1711 return 0;
1712
b411b363
PR		 1713 ok = (sizeof(h) ==
1714 drbd_send(mdev, mdev->data.socket, &h, sizeof(h), 0));
1715 ok = ok && (size ==
1716 drbd_send(mdev, mdev->data.socket, data, size, 0));
1717
1718 drbd_put_data_sock(mdev);
1719
1720 return ok;
1721}
1722
1723int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc)
1724{
8e26f9cc 1725 struct p_rs_param_95 *p;
b411b363
PR		 1726 struct socket *sock;
1727 int size, rv;
1728 const int apv = mdev->agreed_pro_version;
1729
1730 size = apv <= 87 ? sizeof(struct p_rs_param)
1731 : apv == 88 ? sizeof(struct p_rs_param)
1732 + strlen(mdev->sync_conf.verify_alg) + 1
8e26f9cc
PR		 1733 : apv <= 94 ? sizeof(struct p_rs_param_89)
1734 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
b411b363
PR		 1735
1736 /* used from admin command context and receiver/worker context.
1737 * to avoid kmalloc, grab the socket right here,
1738 * then use the pre-allocated sbuf there */
1739 mutex_lock(&mdev->data.mutex);
1740 sock = mdev->data.socket;
1741
1742 if (likely(sock != NULL)) {
1743 enum drbd_packets cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
1744
8e26f9cc 1745 p = &mdev->data.sbuf.rs_param_95;
b411b363
PR		 1746
1747 /* initialize verify_alg and csums_alg */
1748 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
1749
1750 p->rate = cpu_to_be32(sc->rate);
8e26f9cc
PR		 1751 p->c_plan_ahead = cpu_to_be32(sc->c_plan_ahead);
1752 p->c_delay_target = cpu_to_be32(sc->c_delay_target);
1753 p->c_fill_target = cpu_to_be32(sc->c_fill_target);
1754 p->c_max_rate = cpu_to_be32(sc->c_max_rate);
b411b363
PR		 1755
1756 if (apv >= 88)
1757 strcpy(p->verify_alg, mdev->sync_conf.verify_alg);
1758 if (apv >= 89)
1759 strcpy(p->csums_alg, mdev->sync_conf.csums_alg);
1760
1761 rv = _drbd_send_cmd(mdev, sock, cmd, &p->head, size, 0);
1762 } else
1763 rv = 0; /* not ok */
1764
1765 mutex_unlock(&mdev->data.mutex);
1766
1767 return rv;
1768}
1769
1770int drbd_send_protocol(struct drbd_conf *mdev)
1771{
1772 struct p_protocol *p;
cf14c2e9 1773 int size, cf, rv;
b411b363
PR		 1774
1775 size = sizeof(struct p_protocol);
1776
1777 if (mdev->agreed_pro_version >= 87)
1778 size += strlen(mdev->net_conf->integrity_alg) + 1;
1779
1780 /* we must not recurse into our own queue,
1781 * as that is blocked during handshake */
1782 p = kmalloc(size, GFP_NOIO);
1783 if (p == NULL)
1784 return 0;
1785
1786 p->protocol = cpu_to_be32(mdev->net_conf->wire_protocol);
1787 p->after_sb_0p = cpu_to_be32(mdev->net_conf->after_sb_0p);
1788 p->after_sb_1p = cpu_to_be32(mdev->net_conf->after_sb_1p);
1789 p->after_sb_2p = cpu_to_be32(mdev->net_conf->after_sb_2p);
b411b363
PR		 1790 p->two_primaries = cpu_to_be32(mdev->net_conf->two_primaries);
1791
cf14c2e9
PR		 1792 cf = 0;
1793 if (mdev->net_conf->want_lose)
1794 cf |= CF_WANT_LOSE;
1795 if (mdev->net_conf->dry_run) {
1796 if (mdev->agreed_pro_version >= 92)
1797 cf |= CF_DRY_RUN;
1798 else {
1799 dev_err(DEV, "--dry-run is not supported by peer");
7ac314c8 1800 kfree(p);
cf14c2e9
PR		 1801 return 0;
1802 }
1803 }
1804 p->conn_flags = cpu_to_be32(cf);
1805
b411b363
PR		 1806 if (mdev->agreed_pro_version >= 87)
1807 strcpy(p->integrity_alg, mdev->net_conf->integrity_alg);
1808
1809 rv = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_PROTOCOL,
0b70a13d 1810 (struct p_header80 *)p, size);
b411b363
PR		 1811 kfree(p);
1812 return rv;
1813}
1814
1815int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
1816{
1817 struct p_uuids p;
1818 int i;
1819
1820 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
1821 return 1;
1822
1823 for (i = UI_CURRENT; i < UI_SIZE; i++)
1824 p.uuid[i] = mdev->ldev ? cpu_to_be64(mdev->ldev->md.uuid[i]) : 0;
1825
1826 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
1827 p.uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
1828 uuid_flags |= mdev->net_conf->want_lose ? 1 : 0;
1829 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
1830 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
1831 p.uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
1832
1833 put_ldev(mdev);
1834
1835 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_UUIDS,
0b70a13d 1836 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 1837}
1838
1839int drbd_send_uuids(struct drbd_conf *mdev)
1840{
1841 return _drbd_send_uuids(mdev, 0);
1842}
1843
1844int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
1845{
1846 return _drbd_send_uuids(mdev, 8);
1847}
1848
1849
1850int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val)
1851{
1852 struct p_rs_uuid p;
1853
1854 p.uuid = cpu_to_be64(val);
1855
1856 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SYNC_UUID,
0b70a13d 1857 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 1858}
1859
e89b591c 1860int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
b411b363
PR		 1861{
1862 struct p_sizes p;
1863 sector_t d_size, u_size;
1864 int q_order_type;
1865 int ok;
1866
1867 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
1868 D_ASSERT(mdev->ldev->backing_bdev);
1869 d_size = drbd_get_max_capacity(mdev->ldev);
1870 u_size = mdev->ldev->dc.disk_size;
1871 q_order_type = drbd_queue_order_type(mdev);
b411b363
PR		 1872 put_ldev(mdev);
1873 } else {
1874 d_size = 0;
1875 u_size = 0;
1876 q_order_type = QUEUE_ORDERED_NONE;
1877 }
1878
1879 p.d_size = cpu_to_be64(d_size);
1880 p.u_size = cpu_to_be64(u_size);
1881 p.c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
1882 p.max_segment_size = cpu_to_be32(queue_max_segment_size(mdev->rq_queue));
e89b591c
PR		 1883 p.queue_order_type = cpu_to_be16(q_order_type);
1884 p.dds_flags = cpu_to_be16(flags);
b411b363
PR		 1885
1886 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SIZES,
0b70a13d 1887 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 1888 return ok;
1889}
1890
1891/**
1892 * drbd_send_state() - Sends the drbd state to the peer
1893 * @mdev: DRBD device.
1894 */
1895int drbd_send_state(struct drbd_conf *mdev)
1896{
1897 struct socket *sock;
1898 struct p_state p;
1899 int ok = 0;
1900
1901 /* Grab state lock so we wont send state if we're in the middle
1902 * of a cluster wide state change on another thread */
1903 drbd_state_lock(mdev);
1904
1905 mutex_lock(&mdev->data.mutex);
1906
1907 p.state = cpu_to_be32(mdev->state.i); /* Within the send mutex */
1908 sock = mdev->data.socket;
1909
1910 if (likely(sock != NULL)) {
1911 ok = _drbd_send_cmd(mdev, sock, P_STATE,
0b70a13d 1912 (struct p_header80 *)&p, sizeof(p), 0);
b411b363
PR		 1913 }
1914
1915 mutex_unlock(&mdev->data.mutex);
1916
1917 drbd_state_unlock(mdev);
1918 return ok;
1919}
1920
1921int drbd_send_state_req(struct drbd_conf *mdev,
1922 union drbd_state mask, union drbd_state val)
1923{
1924 struct p_req_state p;
1925
1926 p.mask = cpu_to_be32(mask.i);
1927 p.val = cpu_to_be32(val.i);
1928
1929 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_STATE_CHG_REQ,
0b70a13d 1930 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 1931}
1932
1933int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode)
1934{
1935 struct p_req_state_reply p;
1936
1937 p.retcode = cpu_to_be32(retcode);
1938
1939 return drbd_send_cmd(mdev, USE_META_SOCKET, P_STATE_CHG_REPLY,
0b70a13d 1940 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 1941}
1942
1943int fill_bitmap_rle_bits(struct drbd_conf *mdev,
1944 struct p_compressed_bm *p,
1945 struct bm_xfer_ctx *c)
1946{
1947 struct bitstream bs;
1948 unsigned long plain_bits;
1949 unsigned long tmp;
1950 unsigned long rl;
1951 unsigned len;
1952 unsigned toggle;
1953 int bits;
1954
1955 /* may we use this feature? */
1956 if ((mdev->sync_conf.use_rle == 0) ||
1957 (mdev->agreed_pro_version < 90))
1958 return 0;
1959
1960 if (c->bit_offset >= c->bm_bits)
1961 return 0; /* nothing to do. */
1962
1963 /* use at most thus many bytes */
1964 bitstream_init(&bs, p->code, BM_PACKET_VLI_BYTES_MAX, 0);
1965 memset(p->code, 0, BM_PACKET_VLI_BYTES_MAX);
1966 /* plain bits covered in this code string */
1967 plain_bits = 0;
1968
1969 /* p->encoding & 0x80 stores whether the first run length is set.
1970 * bit offset is implicit.
1971 * start with toggle == 2 to be able to tell the first iteration */
1972 toggle = 2;
1973
1974 /* see how much plain bits we can stuff into one packet
1975 * using RLE and VLI. */
1976 do {
1977 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1978 : _drbd_bm_find_next(mdev, c->bit_offset);
1979 if (tmp == -1UL)
1980 tmp = c->bm_bits;
1981 rl = tmp - c->bit_offset;
1982
1983 if (toggle == 2) { /* first iteration */
1984 if (rl == 0) {
1985 /* the first checked bit was set,
1986 * store start value, */
1987 DCBP_set_start(p, 1);
1988 /* but skip encoding of zero run length */
1989 toggle = !toggle;
1990 continue;
1991 }
1992 DCBP_set_start(p, 0);
1993 }
1994
1995 /* paranoia: catch zero runlength.
1996 * can only happen if bitmap is modified while we scan it. */
1997 if (rl == 0) {
1998 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1999 "t:%u bo:%lu\n", toggle, c->bit_offset);
2000 return -1;
2001 }
2002
2003 bits = vli_encode_bits(&bs, rl);
2004 if (bits == -ENOBUFS) /* buffer full */
2005 break;
2006 if (bits <= 0) {
2007 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
2008 return 0;
2009 }
2010
2011 toggle = !toggle;
2012 plain_bits += rl;
2013 c->bit_offset = tmp;
2014 } while (c->bit_offset < c->bm_bits);
2015
2016 len = bs.cur.b - p->code + !!bs.cur.bit;
2017
2018 if (plain_bits < (len << 3)) {
2019 /* incompressible with this method.
2020 * we need to rewind both word and bit position. */
2021 c->bit_offset -= plain_bits;
2022 bm_xfer_ctx_bit_to_word_offset(c);
2023 c->bit_offset = c->word_offset * BITS_PER_LONG;
2024 return 0;
2025 }
2026
2027 /* RLE + VLI was able to compress it just fine.
2028 * update c->word_offset. */
2029 bm_xfer_ctx_bit_to_word_offset(c);
2030
2031 /* store pad_bits */
2032 DCBP_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
2033
2034 return len;
2035}
2036
2037enum { OK, FAILED, DONE }
2038send_bitmap_rle_or_plain(struct drbd_conf *mdev,
0b70a13d 2039 struct p_header80 *h, struct bm_xfer_ctx *c)
b411b363
PR		 2040{
2041 struct p_compressed_bm *p = (void*)h;
2042 unsigned long num_words;
2043 int len;
2044 int ok;
2045
2046 len = fill_bitmap_rle_bits(mdev, p, c);
2047
2048 if (len < 0)
2049 return FAILED;
2050
2051 if (len) {
2052 DCBP_set_code(p, RLE_VLI_Bits);
2053 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_COMPRESSED_BITMAP, h,
2054 sizeof(*p) + len, 0);
2055
2056 c->packets[0]++;
2057 c->bytes[0] += sizeof(*p) + len;
2058
2059 if (c->bit_offset >= c->bm_bits)
2060 len = 0; /* DONE */
2061 } else {
2062 /* was not compressible.
2063 * send a buffer full of plain text bits instead. */
2064 num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
2065 len = num_words * sizeof(long);
2066 if (len)
2067 drbd_bm_get_lel(mdev, c->word_offset, num_words, (unsigned long*)h->payload);
2068 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_BITMAP,
0b70a13d 2069 h, sizeof(struct p_header80) + len, 0);
b411b363
PR		 2070 c->word_offset += num_words;
2071 c->bit_offset = c->word_offset * BITS_PER_LONG;
2072
2073 c->packets[1]++;
0b70a13d 2074 c->bytes[1] += sizeof(struct p_header80) + len;
b411b363
PR		 2075
2076 if (c->bit_offset > c->bm_bits)
2077 c->bit_offset = c->bm_bits;
2078 }
2079 ok = ok ? ((len == 0) ? DONE : OK) : FAILED;
2080
2081 if (ok == DONE)
2082 INFO_bm_xfer_stats(mdev, "send", c);
2083 return ok;
2084}
2085
2086/* See the comment at receive_bitmap() */
2087int _drbd_send_bitmap(struct drbd_conf *mdev)
2088{
2089 struct bm_xfer_ctx c;
0b70a13d 2090 struct p_header80 *p;
b411b363
PR		 2091 int ret;
2092
2093 ERR_IF(!mdev->bitmap) return FALSE;
2094
2095 /* maybe we should use some per thread scratch page,
2096 * and allocate that during initial device creation? */
0b70a13d 2097 p = (struct p_header80 *) __get_free_page(GFP_NOIO);
b411b363
PR		 2098 if (!p) {
2099 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
2100 return FALSE;
2101 }
2102
2103 if (get_ldev(mdev)) {
2104 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
2105 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
2106 drbd_bm_set_all(mdev);
2107 if (drbd_bm_write(mdev)) {
2108 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
2109 * but otherwise process as per normal - need to tell other
2110 * side that a full resync is required! */
2111 dev_err(DEV, "Failed to write bitmap to disk!\n");
2112 } else {
2113 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
2114 drbd_md_sync(mdev);
2115 }
2116 }
2117 put_ldev(mdev);
2118 }
2119
2120 c = (struct bm_xfer_ctx) {
2121 .bm_bits = drbd_bm_bits(mdev),
2122 .bm_words = drbd_bm_words(mdev),
2123 };
2124
2125 do {
2126 ret = send_bitmap_rle_or_plain(mdev, p, &c);
2127 } while (ret == OK);
2128
2129 free_page((unsigned long) p);
2130 return (ret == DONE);
2131}
2132
2133int drbd_send_bitmap(struct drbd_conf *mdev)
2134{
2135 int err;
2136
2137 if (!drbd_get_data_sock(mdev))
2138 return -1;
2139 err = !_drbd_send_bitmap(mdev);
2140 drbd_put_data_sock(mdev);
2141 return err;
2142}
2143
2144int drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, u32 set_size)
2145{
2146 int ok;
2147 struct p_barrier_ack p;
2148
2149 p.barrier = barrier_nr;
2150 p.set_size = cpu_to_be32(set_size);
2151
2152 if (mdev->state.conn < C_CONNECTED)
2153 return FALSE;
2154 ok = drbd_send_cmd(mdev, USE_META_SOCKET, P_BARRIER_ACK,
0b70a13d 2155 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 2156 return ok;
2157}
2158
2159/**
2160 * _drbd_send_ack() - Sends an ack packet
2161 * @mdev: DRBD device.
2162 * @cmd: Packet command code.
2163 * @sector: sector, needs to be in big endian byte order
2164 * @blksize: size in byte, needs to be in big endian byte order
2165 * @block_id: Id, big endian byte order
2166 */
2167static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packets cmd,
2168 u64 sector,
2169 u32 blksize,
2170 u64 block_id)
2171{
2172 int ok;
2173 struct p_block_ack p;
2174
2175 p.sector = sector;
2176 p.block_id = block_id;
2177 p.blksize = blksize;
2178 p.seq_num = cpu_to_be32(atomic_add_return(1, &mdev->packet_seq));
2179
2180 if (!mdev->meta.socket || mdev->state.conn < C_CONNECTED)
2181 return FALSE;
2182 ok = drbd_send_cmd(mdev, USE_META_SOCKET, cmd,
0b70a13d 2183 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 2184 return ok;
2185}
2186
2187int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packets cmd,
2188 struct p_data *dp)
2189{
2190 const int header_size = sizeof(struct p_data)
0b70a13d
PR		 2191 - sizeof(struct p_header80);
2192 int data_size = ((struct p_header80 *)dp)->length - header_size;
b411b363
PR		 2193
2194 return _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
2195 dp->block_id);
2196}
2197
2198int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packets cmd,
2199 struct p_block_req *rp)
2200{
2201 return _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
2202}
2203
2204/**
2205 * drbd_send_ack() - Sends an ack packet
2206 * @mdev: DRBD device.
2207 * @cmd: Packet command code.
2208 * @e: Epoch entry.
2209 */
2210int drbd_send_ack(struct drbd_conf *mdev,
2211 enum drbd_packets cmd, struct drbd_epoch_entry *e)
2212{
2213 return _drbd_send_ack(mdev, cmd,
2214 cpu_to_be64(e->sector),
2215 cpu_to_be32(e->size),
2216 e->block_id);
2217}
2218
2219/* This function misuses the block_id field to signal if the blocks
2220 * are is sync or not. */
2221int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packets cmd,
2222 sector_t sector, int blksize, u64 block_id)
2223{
2224 return _drbd_send_ack(mdev, cmd,
2225 cpu_to_be64(sector),
2226 cpu_to_be32(blksize),
2227 cpu_to_be64(block_id));
2228}
2229
2230int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
2231 sector_t sector, int size, u64 block_id)
2232{
2233 int ok;
2234 struct p_block_req p;
2235
2236 p.sector = cpu_to_be64(sector);
2237 p.block_id = block_id;
2238 p.blksize = cpu_to_be32(size);
2239
2240 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, cmd,
0b70a13d 2241 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 2242 return ok;
2243}
2244
2245int drbd_send_drequest_csum(struct drbd_conf *mdev,
2246 sector_t sector, int size,
2247 void *digest, int digest_size,
2248 enum drbd_packets cmd)
2249{
2250 int ok;
2251 struct p_block_req p;
2252
2253 p.sector = cpu_to_be64(sector);
2254 p.block_id = BE_DRBD_MAGIC + 0xbeef;
2255 p.blksize = cpu_to_be32(size);
2256
2257 p.head.magic = BE_DRBD_MAGIC;
2258 p.head.command = cpu_to_be16(cmd);
0b70a13d 2259 p.head.length = cpu_to_be16(sizeof(p) - sizeof(struct p_header80) + digest_size);
b411b363
PR		 2260
2261 mutex_lock(&mdev->data.mutex);
2262
2263 ok = (sizeof(p) == drbd_send(mdev, mdev->data.socket, &p, sizeof(p), 0));
2264 ok = ok && (digest_size == drbd_send(mdev, mdev->data.socket, digest, digest_size, 0));
2265
2266 mutex_unlock(&mdev->data.mutex);
2267
2268 return ok;
2269}
2270
2271int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
2272{
2273 int ok;
2274 struct p_block_req p;
2275
2276 p.sector = cpu_to_be64(sector);
2277 p.block_id = BE_DRBD_MAGIC + 0xbabe;
2278 p.blksize = cpu_to_be32(size);
2279
2280 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_OV_REQUEST,
0b70a13d 2281 (struct p_header80 *)&p, sizeof(p));
b411b363
PR		 2282 return ok;
2283}
2284
2285/* called on sndtimeo
2286 * returns FALSE if we should retry,
2287 * TRUE if we think connection is dead
2288 */
2289static int we_should_drop_the_connection(struct drbd_conf *mdev, struct socket *sock)
2290{
2291 int drop_it;
2292 /* long elapsed = (long)(jiffies - mdev->last_received); */
2293
2294 drop_it = mdev->meta.socket == sock
2295 || !mdev->asender.task
2296 || get_t_state(&mdev->asender) != Running
2297 || mdev->state.conn < C_CONNECTED;
2298
2299 if (drop_it)
2300 return TRUE;
2301
2302 drop_it = !--mdev->ko_count;
2303 if (!drop_it) {
2304 dev_err(DEV, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
2305 current->comm, current->pid, mdev->ko_count);
2306 request_ping(mdev);
2307 }
2308
2309 return drop_it; /* && (mdev->state == R_PRIMARY) */;
2310}
2311
2312/* The idea of sendpage seems to be to put some kind of reference
2313 * to the page into the skb, and to hand it over to the NIC. In
2314 * this process get_page() gets called.
2315 *
2316 * As soon as the page was really sent over the network put_page()
2317 * gets called by some part of the network layer. [ NIC driver? ]
2318 *
2319 * [ get_page() / put_page() increment/decrement the count. If count
2320 * reaches 0 the page will be freed. ]
2321 *
2322 * This works nicely with pages from FSs.
2323 * But this means that in protocol A we might signal IO completion too early!
2324 *
2325 * In order not to corrupt data during a resync we must make sure
2326 * that we do not reuse our own buffer pages (EEs) to early, therefore
2327 * we have the net_ee list.
2328 *
2329 * XFS seems to have problems, still, it submits pages with page_count == 0!
2330 * As a workaround, we disable sendpage on pages
2331 * with page_count == 0 or PageSlab.
2332 */
2333static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 2334 int offset, size_t size, unsigned msg_flags)
b411b363 2335{
ba11ad9a 2336 int sent = drbd_send(mdev, mdev->data.socket, kmap(page) + offset, size, msg_flags);
b411b363
PR		 2337 kunmap(page);
2338 if (sent == size)
2339 mdev->send_cnt += size>>9;
2340 return sent == size;
2341}
2342
2343static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 2344 int offset, size_t size, unsigned msg_flags)
b411b363
PR		 2345{
2346 mm_segment_t oldfs = get_fs();
2347 int sent, ok;
2348 int len = size;
2349
2350 /* e.g. XFS meta- & log-data is in slab pages, which have a
2351 * page_count of 0 and/or have PageSlab() set.
2352 * we cannot use send_page for those, as that does get_page();
2353 * put_page(); and would cause either a VM_BUG directly, or
2354 * __page_cache_release a page that would actually still be referenced
2355 * by someone, leading to some obscure delayed Oops somewhere else. */
2356 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
ba11ad9a 2357 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
b411b363 2358
ba11ad9a 2359 msg_flags |= MSG_NOSIGNAL;
b411b363
PR		 2360 drbd_update_congested(mdev);
2361 set_fs(KERNEL_DS);
2362 do {
2363 sent = mdev->data.socket->ops->sendpage(mdev->data.socket, page,
2364 offset, len,
ba11ad9a 2365 msg_flags);
b411b363
PR		 2366 if (sent == -EAGAIN) {
2367 if (we_should_drop_the_connection(mdev,
2368 mdev->data.socket))
2369 break;
2370 else
2371 continue;
2372 }
2373 if (sent <= 0) {
2374 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
2375 __func__, (int)size, len, sent);
2376 break;
2377 }
2378 len -= sent;
2379 offset += sent;
2380 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
2381 set_fs(oldfs);
2382 clear_bit(NET_CONGESTED, &mdev->flags);
2383
2384 ok = (len == 0);
2385 if (likely(ok))
2386 mdev->send_cnt += size>>9;
2387 return ok;
2388}
2389
2390static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
2391{
2392 struct bio_vec *bvec;
2393 int i;
ba11ad9a 2394 /* hint all but last page with MSG_MORE */
b411b363
PR		 2395 __bio_for_each_segment(bvec, bio, i, 0) {
2396 if (!_drbd_no_send_page(mdev, bvec->bv_page,
ba11ad9a
LE		 2397 bvec->bv_offset, bvec->bv_len,
2398 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR		 2399 return 0;
2400 }
2401 return 1;
2402}
2403
2404static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
2405{
2406 struct bio_vec *bvec;
2407 int i;
ba11ad9a 2408 /* hint all but last page with MSG_MORE */
b411b363
PR		 2409 __bio_for_each_segment(bvec, bio, i, 0) {
2410 if (!_drbd_send_page(mdev, bvec->bv_page,
ba11ad9a
LE		 2411 bvec->bv_offset, bvec->bv_len,
2412 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR		 2413 return 0;
2414 }
b411b363
PR		 2415 return 1;
2416}
2417
45bb912b
LE		 2418static int _drbd_send_zc_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e)
2419{
2420 struct page *page = e->pages;
2421 unsigned len = e->size;
ba11ad9a 2422 /* hint all but last page with MSG_MORE */
45bb912b
LE		 2423 page_chain_for_each(page) {
2424 unsigned l = min_t(unsigned, len, PAGE_SIZE);
ba11ad9a
LE		 2425 if (!_drbd_send_page(mdev, page, 0, l,
2426 page_chain_next(page) ? MSG_MORE : 0))
45bb912b
LE		 2427 return 0;
2428 len -= l;
2429 }
2430 return 1;
2431}
2432
b411b363
PR		 2433/* Used to send write requests
2434 * R_PRIMARY -> Peer (P_DATA)
2435 */
2436int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
2437{
2438 int ok = 1;
2439 struct p_data p;
2440 unsigned int dp_flags = 0;
2441 void *dgb;
2442 int dgs;
2443
2444 if (!drbd_get_data_sock(mdev))
2445 return 0;
2446
2447 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2448 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2449
d5373389 2450 if (req->size <= DRBD_MAX_SIZE_H80_PACKET) {
0b70a13d
PR		 2451 p.head.h80.magic = BE_DRBD_MAGIC;
2452 p.head.h80.command = cpu_to_be16(P_DATA);
2453 p.head.h80.length =
2454 cpu_to_be16(sizeof(p) - sizeof(union p_header) + dgs + req->size);
2455 } else {
2456 p.head.h95.magic = BE_DRBD_MAGIC_BIG;
2457 p.head.h95.command = cpu_to_be16(P_DATA);
2458 p.head.h95.length =
2459 cpu_to_be32(sizeof(p) - sizeof(union p_header) + dgs + req->size);
2460 }
b411b363
PR		 2461
2462 p.sector = cpu_to_be64(req->sector);
2463 p.block_id = (unsigned long)req;
2464 p.seq_num = cpu_to_be32(req->seq_num =
2465 atomic_add_return(1, &mdev->packet_seq));
2466 dp_flags = 0;
2467
2468 /* NOTE: no need to check if barriers supported here as we would
2469 * not pass the test in make_request_common in that case
2470 */
7b6d91da 2471 if (req->master_bio->bi_rw & REQ_HARDBARRIER) {
b411b363
PR		 2472 dev_err(DEV, "ASSERT FAILED would have set DP_HARDBARRIER\n");
2473 /* dp_flags |= DP_HARDBARRIER; */
2474 }
7b6d91da 2475 if (req->master_bio->bi_rw & REQ_SYNC)
b411b363
PR		 2476 dp_flags |= DP_RW_SYNC;
2477 /* for now handle SYNCIO and UNPLUG
2478 * as if they still were one and the same flag */
7b6d91da 2479 if (req->master_bio->bi_rw & REQ_UNPLUG)
b411b363
PR		 2480 dp_flags |= DP_RW_SYNC;
2481 if (mdev->state.conn >= C_SYNC_SOURCE &&
2482 mdev->state.conn <= C_PAUSED_SYNC_T)
2483 dp_flags |= DP_MAY_SET_IN_SYNC;
2484
2485 p.dp_flags = cpu_to_be32(dp_flags);
b411b363
PR		 2486 set_bit(UNPLUG_REMOTE, &mdev->flags);
2487 ok = (sizeof(p) ==
ba11ad9a 2488 drbd_send(mdev, mdev->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0));
b411b363
PR		 2489 if (ok && dgs) {
2490 dgb = mdev->int_dig_out;
45bb912b 2491 drbd_csum_bio(mdev, mdev->integrity_w_tfm, req->master_bio, dgb);
ba11ad9a 2492 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
b411b363
PR		 2493 }
2494 if (ok) {
2495 if (mdev->net_conf->wire_protocol == DRBD_PROT_A)
2496 ok = _drbd_send_bio(mdev, req->master_bio);
2497 else
2498 ok = _drbd_send_zc_bio(mdev, req->master_bio);
2499 }
2500
2501 drbd_put_data_sock(mdev);
bd26bfc5 2502
b411b363
PR		 2503 return ok;
2504}
2505
2506/* answer packet, used to send data back for read requests:
2507 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
2508 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
2509 */
2510int drbd_send_block(struct drbd_conf *mdev, enum drbd_packets cmd,
2511 struct drbd_epoch_entry *e)
2512{
2513 int ok;
2514 struct p_data p;
2515 void *dgb;
2516 int dgs;
2517
2518 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2519 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2520
d5373389 2521 if (e->size <= DRBD_MAX_SIZE_H80_PACKET) {
0b70a13d
PR		 2522 p.head.h80.magic = BE_DRBD_MAGIC;
2523 p.head.h80.command = cpu_to_be16(cmd);
2524 p.head.h80.length =
2525 cpu_to_be16(sizeof(p) - sizeof(struct p_header80) + dgs + e->size);
2526 } else {
2527 p.head.h95.magic = BE_DRBD_MAGIC_BIG;
2528 p.head.h95.command = cpu_to_be16(cmd);
2529 p.head.h95.length =
2530 cpu_to_be32(sizeof(p) - sizeof(struct p_header80) + dgs + e->size);
2531 }
b411b363
PR		 2532
2533 p.sector = cpu_to_be64(e->sector);
2534 p.block_id = e->block_id;
2535 /* p.seq_num = 0; No sequence numbers here.. */
2536
2537 /* Only called by our kernel thread.
2538 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
2539 * in response to admin command or module unload.
2540 */
2541 if (!drbd_get_data_sock(mdev))
2542 return 0;
2543
0b70a13d 2544 ok = sizeof(p) == drbd_send(mdev, mdev->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0);
b411b363
PR		 2545 if (ok && dgs) {
2546 dgb = mdev->int_dig_out;
45bb912b 2547 drbd_csum_ee(mdev, mdev->integrity_w_tfm, e, dgb);
ba11ad9a 2548 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
b411b363
PR		 2549 }
2550 if (ok)
45bb912b 2551 ok = _drbd_send_zc_ee(mdev, e);
b411b363
PR		 2552
2553 drbd_put_data_sock(mdev);
bd26bfc5 2554
b411b363
PR		 2555 return ok;
2556}
2557
2558/*
2559 drbd_send distinguishes two cases:
2560
2561 Packets sent via the data socket "sock"
2562 and packets sent via the meta data socket "msock"
2563
2564 sock msock
2565 -----------------+-------------------------+------------------------------
2566 timeout conf.timeout / 2 conf.timeout / 2
2567 timeout action send a ping via msock Abort communication
2568 and close all sockets
2569*/
2570
2571/*
2572 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
2573 */
2574int drbd_send(struct drbd_conf *mdev, struct socket *sock,
2575 void *buf, size_t size, unsigned msg_flags)
2576{
2577 struct kvec iov;
2578 struct msghdr msg;
2579 int rv, sent = 0;
2580
2581 if (!sock)
2582 return -1000;
2583
2584 /* THINK if (signal_pending) return ... ? */
2585
2586 iov.iov_base = buf;
2587 iov.iov_len = size;
2588
2589 msg.msg_name = NULL;
2590 msg.msg_namelen = 0;
2591 msg.msg_control = NULL;
2592 msg.msg_controllen = 0;
2593 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
2594
2595 if (sock == mdev->data.socket) {
2596 mdev->ko_count = mdev->net_conf->ko_count;
2597 drbd_update_congested(mdev);
2598 }
2599 do {
2600 /* STRANGE
2601 * tcp_sendmsg does _not_ use its size parameter at all ?
2602 *
2603 * -EAGAIN on timeout, -EINTR on signal.
2604 */
2605/* THINK
2606 * do we need to block DRBD_SIG if sock == &meta.socket ??
2607 * otherwise wake_asender() might interrupt some send_*Ack !
2608 */
2609 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
2610 if (rv == -EAGAIN) {
2611 if (we_should_drop_the_connection(mdev, sock))
2612 break;
2613 else
2614 continue;
2615 }
2616 D_ASSERT(rv != 0);
2617 if (rv == -EINTR) {
2618 flush_signals(current);
2619 rv = 0;
2620 }
2621 if (rv < 0)
2622 break;
2623 sent += rv;
2624 iov.iov_base += rv;
2625 iov.iov_len -= rv;
2626 } while (sent < size);
2627
2628 if (sock == mdev->data.socket)
2629 clear_bit(NET_CONGESTED, &mdev->flags);
2630
2631 if (rv <= 0) {
2632 if (rv != -EAGAIN) {
2633 dev_err(DEV, "%s_sendmsg returned %d\n",
2634 sock == mdev->meta.socket ? "msock" : "sock",
2635 rv);
2636 drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE));
2637 } else
2638 drbd_force_state(mdev, NS(conn, C_TIMEOUT));
2639 }
2640
2641 return sent;
2642}
2643
2644static int drbd_open(struct block_device *bdev, fmode_t mode)
2645{
2646 struct drbd_conf *mdev = bdev->bd_disk->private_data;
2647 unsigned long flags;
2648 int rv = 0;
2649
6e9624b8 2650 lock_kernel();
b411b363
PR		 2651 spin_lock_irqsave(&mdev->req_lock, flags);
2652 /* to have a stable mdev->state.role
2653 * and no race with updating open_cnt */
2654
2655 if (mdev->state.role != R_PRIMARY) {
2656 if (mode & FMODE_WRITE)
2657 rv = -EROFS;
2658 else if (!allow_oos)
2659 rv = -EMEDIUMTYPE;
2660 }
2661
2662 if (!rv)
2663 mdev->open_cnt++;
2664 spin_unlock_irqrestore(&mdev->req_lock, flags);
6e9624b8 2665 unlock_kernel();
b411b363
PR		 2666
2667 return rv;
2668}
2669
2670static int drbd_release(struct gendisk *gd, fmode_t mode)
2671{
2672 struct drbd_conf *mdev = gd->private_data;
6e9624b8 2673 lock_kernel();
b411b363 2674 mdev->open_cnt--;
6e9624b8 2675 unlock_kernel();
b411b363
PR		 2676 return 0;
2677}
2678
2679static void drbd_unplug_fn(struct request_queue *q)
2680{
2681 struct drbd_conf *mdev = q->queuedata;
2682
b411b363
PR		 2683 /* unplug FIRST */
2684 spin_lock_irq(q->queue_lock);
2685 blk_remove_plug(q);
2686 spin_unlock_irq(q->queue_lock);
2687
2688 /* only if connected */
2689 spin_lock_irq(&mdev->req_lock);
2690 if (mdev->state.pdsk >= D_INCONSISTENT && mdev->state.conn >= C_CONNECTED) {
2691 D_ASSERT(mdev->state.role == R_PRIMARY);
2692 if (test_and_clear_bit(UNPLUG_REMOTE, &mdev->flags)) {
2693 /* add to the data.work queue,
2694 * unless already queued.
2695 * XXX this might be a good addition to drbd_queue_work
2696 * anyways, to detect "double queuing" ... */
2697 if (list_empty(&mdev->unplug_work.list))
2698 drbd_queue_work(&mdev->data.work,
2699 &mdev->unplug_work);
2700 }
2701 }
2702 spin_unlock_irq(&mdev->req_lock);
2703
2704 if (mdev->state.disk >= D_INCONSISTENT)
2705 drbd_kick_lo(mdev);
2706}
2707
2708static void drbd_set_defaults(struct drbd_conf *mdev)
2709{
85f4cc17
PR		 2710 /* This way we get a compile error when sync_conf grows,
2711 and we forgot to initialize it here */
2712 mdev->sync_conf = (struct syncer_conf) {
2713 /* .rate = */ DRBD_RATE_DEF,
2714 /* .after = */ DRBD_AFTER_DEF,
2715 /* .al_extents = */ DRBD_AL_EXTENTS_DEF,
85f4cc17
PR		 2716 /* .verify_alg = */ {}, 0,
2717 /* .cpu_mask = */ {}, 0,
2718 /* .csums_alg = */ {}, 0,
e756414f 2719 /* .use_rle = */ 0,
9a31d716
PR		 2720 /* .on_no_data = */ DRBD_ON_NO_DATA_DEF,
2721 /* .c_plan_ahead = */ DRBD_C_PLAN_AHEAD_DEF,
2722 /* .c_delay_target = */ DRBD_C_DELAY_TARGET_DEF,
2723 /* .c_fill_target = */ DRBD_C_FILL_TARGET_DEF,
0f0601f4
LE		 2724 /* .c_max_rate = */ DRBD_C_MAX_RATE_DEF,
2725 /* .c_min_rate = */ DRBD_C_MIN_RATE_DEF
85f4cc17
PR		 2726 };
2727
2728 /* Have to use that way, because the layout differs between
2729 big endian and little endian */
b411b363
PR		 2730 mdev->state = (union drbd_state) {
2731 { .role = R_SECONDARY,
2732 .peer = R_UNKNOWN,
2733 .conn = C_STANDALONE,
2734 .disk = D_DISKLESS,
2735 .pdsk = D_UNKNOWN,
2736 .susp = 0
2737 } };
2738}
2739
2740void drbd_init_set_defaults(struct drbd_conf *mdev)
2741{
2742 /* the memset(,0,) did most of this.
2743 * note: only assignments, no allocation in here */
2744
2745 drbd_set_defaults(mdev);
2746
2747 /* for now, we do NOT yet support it,
2748 * even though we start some framework
2749 * to eventually support barriers */
2750 set_bit(NO_BARRIER_SUPP, &mdev->flags);
2751
2752 atomic_set(&mdev->ap_bio_cnt, 0);
2753 atomic_set(&mdev->ap_pending_cnt, 0);
2754 atomic_set(&mdev->rs_pending_cnt, 0);
2755 atomic_set(&mdev->unacked_cnt, 0);
2756 atomic_set(&mdev->local_cnt, 0);
2757 atomic_set(&mdev->net_cnt, 0);
2758 atomic_set(&mdev->packet_seq, 0);
2759 atomic_set(&mdev->pp_in_use, 0);
778f271d 2760 atomic_set(&mdev->rs_sect_in, 0);
0f0601f4 2761 atomic_set(&mdev->rs_sect_ev, 0);
b411b363
PR		 2762
2763 mutex_init(&mdev->md_io_mutex);
2764 mutex_init(&mdev->data.mutex);
2765 mutex_init(&mdev->meta.mutex);
2766 sema_init(&mdev->data.work.s, 0);
2767 sema_init(&mdev->meta.work.s, 0);
2768 mutex_init(&mdev->state_mutex);
2769
2770 spin_lock_init(&mdev->data.work.q_lock);
2771 spin_lock_init(&mdev->meta.work.q_lock);
2772
2773 spin_lock_init(&mdev->al_lock);
2774 spin_lock_init(&mdev->req_lock);
2775 spin_lock_init(&mdev->peer_seq_lock);
2776 spin_lock_init(&mdev->epoch_lock);
2777
2778 INIT_LIST_HEAD(&mdev->active_ee);
2779 INIT_LIST_HEAD(&mdev->sync_ee);
2780 INIT_LIST_HEAD(&mdev->done_ee);
2781 INIT_LIST_HEAD(&mdev->read_ee);
2782 INIT_LIST_HEAD(&mdev->net_ee);
2783 INIT_LIST_HEAD(&mdev->resync_reads);
2784 INIT_LIST_HEAD(&mdev->data.work.q);
2785 INIT_LIST_HEAD(&mdev->meta.work.q);
2786 INIT_LIST_HEAD(&mdev->resync_work.list);
2787 INIT_LIST_HEAD(&mdev->unplug_work.list);
2788 INIT_LIST_HEAD(&mdev->md_sync_work.list);
2789 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
0ced55a3 2790
b411b363
PR		 2791 mdev->resync_work.cb = w_resync_inactive;
2792 mdev->unplug_work.cb = w_send_write_hint;
2793 mdev->md_sync_work.cb = w_md_sync;
2794 mdev->bm_io_work.w.cb = w_bitmap_io;
2795 init_timer(&mdev->resync_timer);
2796 init_timer(&mdev->md_sync_timer);
2797 mdev->resync_timer.function = resync_timer_fn;
2798 mdev->resync_timer.data = (unsigned long) mdev;
2799 mdev->md_sync_timer.function = md_sync_timer_fn;
2800 mdev->md_sync_timer.data = (unsigned long) mdev;
2801
2802 init_waitqueue_head(&mdev->misc_wait);
2803 init_waitqueue_head(&mdev->state_wait);
84dfb9f5 2804 init_waitqueue_head(&mdev->net_cnt_wait);
b411b363
PR		 2805 init_waitqueue_head(&mdev->ee_wait);
2806 init_waitqueue_head(&mdev->al_wait);
2807 init_waitqueue_head(&mdev->seq_wait);
2808
2809 drbd_thread_init(mdev, &mdev->receiver, drbdd_init);
2810 drbd_thread_init(mdev, &mdev->worker, drbd_worker);
2811 drbd_thread_init(mdev, &mdev->asender, drbd_asender);
2812
2813 mdev->agreed_pro_version = PRO_VERSION_MAX;
2814 mdev->write_ordering = WO_bio_barrier;
2815 mdev->resync_wenr = LC_FREE;
2816}
2817
2818void drbd_mdev_cleanup(struct drbd_conf *mdev)
2819{
1d7734a0 2820 int i;
b411b363
PR		 2821 if (mdev->receiver.t_state != None)
2822 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
2823 mdev->receiver.t_state);
2824
2825 /* no need to lock it, I'm the only thread alive */
2826 if (atomic_read(&mdev->current_epoch->epoch_size) != 0)
2827 dev_err(DEV, "epoch_size:%d\n", atomic_read(&mdev->current_epoch->epoch_size));
2828 mdev->al_writ_cnt =
2829 mdev->bm_writ_cnt =
2830 mdev->read_cnt =
2831 mdev->recv_cnt =
2832 mdev->send_cnt =
2833 mdev->writ_cnt =
2834 mdev->p_size =
2835 mdev->rs_start =
2836 mdev->rs_total =
1d7734a0
LE		 2837 mdev->rs_failed = 0;
2838 mdev->rs_last_events = 0;
0f0601f4 2839 mdev->rs_last_sect_ev = 0;
1d7734a0
LE		 2840 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
2841 mdev->rs_mark_left[i] = 0;
2842 mdev->rs_mark_time[i] = 0;
2843 }
b411b363
PR		 2844 D_ASSERT(mdev->net_conf == NULL);
2845
2846 drbd_set_my_capacity(mdev, 0);
2847 if (mdev->bitmap) {
2848 /* maybe never allocated. */
02d9a94b 2849 drbd_bm_resize(mdev, 0, 1);
b411b363
PR		 2850 drbd_bm_cleanup(mdev);
2851 }
2852
2853 drbd_free_resources(mdev);
2854
2855 /*
2856 * currently we drbd_init_ee only on module load, so
2857 * we may do drbd_release_ee only on module unload!
2858 */
2859 D_ASSERT(list_empty(&mdev->active_ee));
2860 D_ASSERT(list_empty(&mdev->sync_ee));
2861 D_ASSERT(list_empty(&mdev->done_ee));
2862 D_ASSERT(list_empty(&mdev->read_ee));
2863 D_ASSERT(list_empty(&mdev->net_ee));
2864 D_ASSERT(list_empty(&mdev->resync_reads));
2865 D_ASSERT(list_empty(&mdev->data.work.q));
2866 D_ASSERT(list_empty(&mdev->meta.work.q));
2867 D_ASSERT(list_empty(&mdev->resync_work.list));
2868 D_ASSERT(list_empty(&mdev->unplug_work.list));
2869
2870}
2871
2872
2873static void drbd_destroy_mempools(void)
2874{
2875 struct page *page;
2876
2877 while (drbd_pp_pool) {
2878 page = drbd_pp_pool;
2879 drbd_pp_pool = (struct page *)page_private(page);
2880 __free_page(page);
2881 drbd_pp_vacant--;
2882 }
2883
2884 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
2885
2886 if (drbd_ee_mempool)
2887 mempool_destroy(drbd_ee_mempool);
2888 if (drbd_request_mempool)
2889 mempool_destroy(drbd_request_mempool);
2890 if (drbd_ee_cache)
2891 kmem_cache_destroy(drbd_ee_cache);
2892 if (drbd_request_cache)
2893 kmem_cache_destroy(drbd_request_cache);
2894 if (drbd_bm_ext_cache)
2895 kmem_cache_destroy(drbd_bm_ext_cache);
2896 if (drbd_al_ext_cache)
2897 kmem_cache_destroy(drbd_al_ext_cache);
2898
2899 drbd_ee_mempool = NULL;
2900 drbd_request_mempool = NULL;
2901 drbd_ee_cache = NULL;
2902 drbd_request_cache = NULL;
2903 drbd_bm_ext_cache = NULL;
2904 drbd_al_ext_cache = NULL;
2905
2906 return;
2907}
2908
2909static int drbd_create_mempools(void)
2910{
2911 struct page *page;
2912 const int number = (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE) * minor_count;
2913 int i;
2914
2915 /* prepare our caches and mempools */
2916 drbd_request_mempool = NULL;
2917 drbd_ee_cache = NULL;
2918 drbd_request_cache = NULL;
2919 drbd_bm_ext_cache = NULL;
2920 drbd_al_ext_cache = NULL;
2921 drbd_pp_pool = NULL;
2922
2923 /* caches */
2924 drbd_request_cache = kmem_cache_create(
2925 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2926 if (drbd_request_cache == NULL)
2927 goto Enomem;
2928
2929 drbd_ee_cache = kmem_cache_create(
2930 "drbd_ee", sizeof(struct drbd_epoch_entry), 0, 0, NULL);
2931 if (drbd_ee_cache == NULL)
2932 goto Enomem;
2933
2934 drbd_bm_ext_cache = kmem_cache_create(
2935 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2936 if (drbd_bm_ext_cache == NULL)
2937 goto Enomem;
2938
2939 drbd_al_ext_cache = kmem_cache_create(
2940 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2941 if (drbd_al_ext_cache == NULL)
2942 goto Enomem;
2943
2944 /* mempools */
2945 drbd_request_mempool = mempool_create(number,
2946 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2947 if (drbd_request_mempool == NULL)
2948 goto Enomem;
2949
2950 drbd_ee_mempool = mempool_create(number,
2951 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2952 if (drbd_request_mempool == NULL)
2953 goto Enomem;
2954
2955 /* drbd's page pool */
2956 spin_lock_init(&drbd_pp_lock);
2957
2958 for (i = 0; i < number; i++) {
2959 page = alloc_page(GFP_HIGHUSER);
2960 if (!page)
2961 goto Enomem;
2962 set_page_private(page, (unsigned long)drbd_pp_pool);
2963 drbd_pp_pool = page;
2964 }
2965 drbd_pp_vacant = number;
2966
2967 return 0;
2968
2969Enomem:
2970 drbd_destroy_mempools(); /* in case we allocated some */
2971 return -ENOMEM;
2972}
2973
2974static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2975 void *unused)
2976{
2977 /* just so we have it. you never know what interesting things we
2978 * might want to do here some day...
2979 */
2980
2981 return NOTIFY_DONE;
2982}
2983
2984static struct notifier_block drbd_notifier = {
2985 .notifier_call = drbd_notify_sys,
2986};
2987
2988static void drbd_release_ee_lists(struct drbd_conf *mdev)
2989{
2990 int rr;
2991
2992 rr = drbd_release_ee(mdev, &mdev->active_ee);
2993 if (rr)
2994 dev_err(DEV, "%d EEs in active list found!\n", rr);
2995
2996 rr = drbd_release_ee(mdev, &mdev->sync_ee);
2997 if (rr)
2998 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2999
3000 rr = drbd_release_ee(mdev, &mdev->read_ee);
3001 if (rr)
3002 dev_err(DEV, "%d EEs in read list found!\n", rr);
3003
3004 rr = drbd_release_ee(mdev, &mdev->done_ee);
3005 if (rr)
3006 dev_err(DEV, "%d EEs in done list found!\n", rr);
3007
3008 rr = drbd_release_ee(mdev, &mdev->net_ee);
3009 if (rr)
3010 dev_err(DEV, "%d EEs in net list found!\n", rr);
3011}
3012
3013/* caution. no locking.
3014 * currently only used from module cleanup code. */
3015static void drbd_delete_device(unsigned int minor)
3016{
3017 struct drbd_conf *mdev = minor_to_mdev(minor);
3018
3019 if (!mdev)
3020 return;
3021
3022 /* paranoia asserts */
3023 if (mdev->open_cnt != 0)
3024 dev_err(DEV, "open_cnt = %d in %s:%u", mdev->open_cnt,
3025 __FILE__ , __LINE__);
3026
3027 ERR_IF (!list_empty(&mdev->data.work.q)) {
3028 struct list_head *lp;
3029 list_for_each(lp, &mdev->data.work.q) {
3030 dev_err(DEV, "lp = %p\n", lp);
3031 }
3032 };
3033 /* end paranoia asserts */
3034
3035 del_gendisk(mdev->vdisk);
3036
3037 /* cleanup stuff that may have been allocated during
3038 * device (re-)configuration or state changes */
3039
3040 if (mdev->this_bdev)
3041 bdput(mdev->this_bdev);
3042
3043 drbd_free_resources(mdev);
3044
3045 drbd_release_ee_lists(mdev);
3046
3047 /* should be free'd on disconnect? */
3048 kfree(mdev->ee_hash);
3049 /*
3050 mdev->ee_hash_s = 0;
3051 mdev->ee_hash = NULL;
3052 */
3053
3054 lc_destroy(mdev->act_log);
3055 lc_destroy(mdev->resync);
3056
3057 kfree(mdev->p_uuid);
3058 /* mdev->p_uuid = NULL; */
3059
3060 kfree(mdev->int_dig_out);
3061 kfree(mdev->int_dig_in);
3062 kfree(mdev->int_dig_vv);
3063
3064 /* cleanup the rest that has been
3065 * allocated from drbd_new_device
3066 * and actually free the mdev itself */
3067 drbd_free_mdev(mdev);
3068}
3069
3070static void drbd_cleanup(void)
3071{
3072 unsigned int i;
3073
3074 unregister_reboot_notifier(&drbd_notifier);
3075
3076 drbd_nl_cleanup();
3077
3078 if (minor_table) {
3079 if (drbd_proc)
3080 remove_proc_entry("drbd", NULL);
3081 i = minor_count;
3082 while (i--)
3083 drbd_delete_device(i);
3084 drbd_destroy_mempools();
3085 }
3086
3087 kfree(minor_table);
3088
3089 unregister_blkdev(DRBD_MAJOR, "drbd");
3090
3091 printk(KERN_INFO "drbd: module cleanup done.\n");
3092}
3093
3094/**
3095 * drbd_congested() - Callback for pdflush
3096 * @congested_data: User data
3097 * @bdi_bits: Bits pdflush is currently interested in
3098 *
3099 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
3100 */
3101static int drbd_congested(void *congested_data, int bdi_bits)
3102{
3103 struct drbd_conf *mdev = congested_data;
3104 struct request_queue *q;
3105 char reason = '-';
3106 int r = 0;
3107
3108 if (!__inc_ap_bio_cond(mdev)) {
3109 /* DRBD has frozen IO */
3110 r = bdi_bits;
3111 reason = 'd';
3112 goto out;
3113 }
3114
3115 if (get_ldev(mdev)) {
3116 q = bdev_get_queue(mdev->ldev->backing_bdev);
3117 r = bdi_congested(&q->backing_dev_info, bdi_bits);
3118 put_ldev(mdev);
3119 if (r)
3120 reason = 'b';
3121 }
3122
3123 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->flags)) {
3124 r |= (1 << BDI_async_congested);
3125 reason = reason == 'b' ? 'a' : 'n';
3126 }
3127
3128out:
3129 mdev->congestion_reason = reason;
3130 return r;
3131}
3132
3133struct drbd_conf *drbd_new_device(unsigned int minor)
3134{
3135 struct drbd_conf *mdev;
3136 struct gendisk *disk;
3137 struct request_queue *q;
3138
3139 /* GFP_KERNEL, we are outside of all write-out paths */
3140 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
3141 if (!mdev)
3142 return NULL;
3143 if (!zalloc_cpumask_var(&mdev->cpu_mask, GFP_KERNEL))
3144 goto out_no_cpumask;
3145
3146 mdev->minor = minor;
3147
3148 drbd_init_set_defaults(mdev);
3149
3150 q = blk_alloc_queue(GFP_KERNEL);
3151 if (!q)
3152 goto out_no_q;
3153 mdev->rq_queue = q;
3154 q->queuedata = mdev;
b411b363
PR		 3155
3156 disk = alloc_disk(1);
3157 if (!disk)
3158 goto out_no_disk;
3159 mdev->vdisk = disk;
3160
3161 set_disk_ro(disk, TRUE);
3162
3163 disk->queue = q;
3164 disk->major = DRBD_MAJOR;
3165 disk->first_minor = minor;
3166 disk->fops = &drbd_ops;
3167 sprintf(disk->disk_name, "drbd%d", minor);
3168 disk->private_data = mdev;
3169
3170 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
3171 /* we have no partitions. we contain only ourselves. */
3172 mdev->this_bdev->bd_contains = mdev->this_bdev;
3173
3174 q->backing_dev_info.congested_fn = drbd_congested;
3175 q->backing_dev_info.congested_data = mdev;
3176
3177 blk_queue_make_request(q, drbd_make_request_26);
98ec286e 3178 blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
b411b363
PR		 3179 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
3180 blk_queue_merge_bvec(q, drbd_merge_bvec);
3181 q->queue_lock = &mdev->req_lock; /* needed since we use */
3182 /* plugging on a queue, that actually has no requests! */
3183 q->unplug_fn = drbd_unplug_fn;
3184
3185 mdev->md_io_page = alloc_page(GFP_KERNEL);
3186 if (!mdev->md_io_page)
3187 goto out_no_io_page;
3188
3189 if (drbd_bm_init(mdev))
3190 goto out_no_bitmap;
3191 /* no need to lock access, we are still initializing this minor device. */
3192 if (!tl_init(mdev))
3193 goto out_no_tl;
3194
3195 mdev->app_reads_hash = kzalloc(APP_R_HSIZE*sizeof(void *), GFP_KERNEL);
3196 if (!mdev->app_reads_hash)
3197 goto out_no_app_reads;
3198
3199 mdev->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
3200 if (!mdev->current_epoch)
3201 goto out_no_epoch;
3202
3203 INIT_LIST_HEAD(&mdev->current_epoch->list);
3204 mdev->epochs = 1;
3205
3206 return mdev;
3207
3208/* out_whatever_else:
3209 kfree(mdev->current_epoch); */
3210out_no_epoch:
3211 kfree(mdev->app_reads_hash);
3212out_no_app_reads:
3213 tl_cleanup(mdev);
3214out_no_tl:
3215 drbd_bm_cleanup(mdev);
3216out_no_bitmap:
3217 __free_page(mdev->md_io_page);
3218out_no_io_page:
3219 put_disk(disk);
3220out_no_disk:
3221 blk_cleanup_queue(q);
3222out_no_q:
3223 free_cpumask_var(mdev->cpu_mask);
3224out_no_cpumask:
3225 kfree(mdev);
3226 return NULL;
3227}
3228
3229/* counterpart of drbd_new_device.
3230 * last part of drbd_delete_device. */
3231void drbd_free_mdev(struct drbd_conf *mdev)
3232{
3233 kfree(mdev->current_epoch);
3234 kfree(mdev->app_reads_hash);
3235 tl_cleanup(mdev);
3236 if (mdev->bitmap) /* should no longer be there. */
3237 drbd_bm_cleanup(mdev);
3238 __free_page(mdev->md_io_page);
3239 put_disk(mdev->vdisk);
3240 blk_cleanup_queue(mdev->rq_queue);
3241 free_cpumask_var(mdev->cpu_mask);
3242 kfree(mdev);
3243}
3244
3245
3246int __init drbd_init(void)
3247{
3248 int err;
3249
3250 if (sizeof(struct p_handshake) != 80) {
3251 printk(KERN_ERR
3252 "drbd: never change the size or layout "
3253 "of the HandShake packet.\n");
3254 return -EINVAL;
3255 }
3256
3257 if (1 > minor_count || minor_count > 255) {
3258 printk(KERN_ERR
3259 "drbd: invalid minor_count (%d)\n", minor_count);
3260#ifdef MODULE
3261 return -EINVAL;
3262#else
3263 minor_count = 8;
3264#endif
3265 }
3266
3267 err = drbd_nl_init();
3268 if (err)
3269 return err;
3270
3271 err = register_blkdev(DRBD_MAJOR, "drbd");
3272 if (err) {
3273 printk(KERN_ERR
3274 "drbd: unable to register block device major %d\n",
3275 DRBD_MAJOR);
3276 return err;
3277 }
3278
3279 register_reboot_notifier(&drbd_notifier);
3280
3281 /*
3282 * allocate all necessary structs
3283 */
3284 err = -ENOMEM;
3285
3286 init_waitqueue_head(&drbd_pp_wait);
3287
3288 drbd_proc = NULL; /* play safe for drbd_cleanup */
3289 minor_table = kzalloc(sizeof(struct drbd_conf *)*minor_count,
3290 GFP_KERNEL);
3291 if (!minor_table)
3292 goto Enomem;
3293
3294 err = drbd_create_mempools();
3295 if (err)
3296 goto Enomem;
3297
8c484ee4 3298 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
b411b363
PR		 3299 if (!drbd_proc) {
3300 printk(KERN_ERR "drbd: unable to register proc file\n");
3301 goto Enomem;
3302 }
3303
3304 rwlock_init(&global_state_lock);
3305
3306 printk(KERN_INFO "drbd: initialized. "
3307 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
3308 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
3309 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
3310 printk(KERN_INFO "drbd: registered as block device major %d\n",
3311 DRBD_MAJOR);
3312 printk(KERN_INFO "drbd: minor_table @ 0x%p\n", minor_table);
3313
3314 return 0; /* Success! */
3315
3316Enomem:
3317 drbd_cleanup();
3318 if (err == -ENOMEM)
3319 /* currently always the case */
3320 printk(KERN_ERR "drbd: ran out of memory\n");
3321 else
3322 printk(KERN_ERR "drbd: initialization failure\n");
3323 return err;
3324}
3325
3326void drbd_free_bc(struct drbd_backing_dev *ldev)
3327{
3328 if (ldev == NULL)
3329 return;
3330
3331 bd_release(ldev->backing_bdev);
3332 bd_release(ldev->md_bdev);
3333
3334 fput(ldev->lo_file);
3335 fput(ldev->md_file);
3336
3337 kfree(ldev);
3338}
3339
3340void drbd_free_sock(struct drbd_conf *mdev)
3341{
3342 if (mdev->data.socket) {
4589d7f8 3343 mutex_lock(&mdev->data.mutex);
b411b363
PR		 3344 kernel_sock_shutdown(mdev->data.socket, SHUT_RDWR);
3345 sock_release(mdev->data.socket);
3346 mdev->data.socket = NULL;
4589d7f8 3347 mutex_unlock(&mdev->data.mutex);
b411b363
PR		 3348 }
3349 if (mdev->meta.socket) {
4589d7f8 3350 mutex_lock(&mdev->meta.mutex);
b411b363
PR		 3351 kernel_sock_shutdown(mdev->meta.socket, SHUT_RDWR);
3352 sock_release(mdev->meta.socket);
3353 mdev->meta.socket = NULL;
4589d7f8 3354 mutex_unlock(&mdev->meta.mutex);
b411b363
PR		 3355 }
3356}
3357
3358
3359void drbd_free_resources(struct drbd_conf *mdev)
3360{
3361 crypto_free_hash(mdev->csums_tfm);
3362 mdev->csums_tfm = NULL;
3363 crypto_free_hash(mdev->verify_tfm);
3364 mdev->verify_tfm = NULL;
3365 crypto_free_hash(mdev->cram_hmac_tfm);
3366 mdev->cram_hmac_tfm = NULL;
3367 crypto_free_hash(mdev->integrity_w_tfm);
3368 mdev->integrity_w_tfm = NULL;
3369 crypto_free_hash(mdev->integrity_r_tfm);
3370 mdev->integrity_r_tfm = NULL;
3371
3372 drbd_free_sock(mdev);
3373
3374 __no_warn(local,
3375 drbd_free_bc(mdev->ldev);
3376 mdev->ldev = NULL;);
3377}
3378
3379/* meta data management */
3380
3381struct meta_data_on_disk {
3382 u64 la_size; /* last agreed size. */
3383 u64 uuid[UI_SIZE]; /* UUIDs. */
3384 u64 device_uuid;
3385 u64 reserved_u64_1;
3386 u32 flags; /* MDF */
3387 u32 magic;
3388 u32 md_size_sect;
3389 u32 al_offset; /* offset to this block */
3390 u32 al_nr_extents; /* important for restoring the AL */
3391 /* `-- act_log->nr_elements <-- sync_conf.al_extents */
3392 u32 bm_offset; /* offset to the bitmap, from here */
3393 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
3394 u32 reserved_u32[4];
3395
3396} __packed;
3397
3398/**
3399 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
3400 * @mdev: DRBD device.
3401 */
3402void drbd_md_sync(struct drbd_conf *mdev)
3403{
3404 struct meta_data_on_disk *buffer;
3405 sector_t sector;
3406 int i;
3407
3408 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
3409 return;
3410 del_timer(&mdev->md_sync_timer);
3411
3412 /* We use here D_FAILED and not D_ATTACHING because we try to write
3413 * metadata even if we detach due to a disk failure! */
3414 if (!get_ldev_if_state(mdev, D_FAILED))
3415 return;
3416
b411b363
PR		 3417 mutex_lock(&mdev->md_io_mutex);
3418 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3419 memset(buffer, 0, 512);
3420
3421 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
3422 for (i = UI_CURRENT; i < UI_SIZE; i++)
3423 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
3424 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
3425 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC);
3426
3427 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
3428 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
3429 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
3430 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
3431 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
3432
3433 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
3434
3435 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
3436 sector = mdev->ldev->md.md_offset;
3437
3438 if (drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
3439 clear_bit(MD_DIRTY, &mdev->flags);
3440 } else {
3441 /* this was a try anyways ... */
3442 dev_err(DEV, "meta data update failed!\n");
3443
3444 drbd_chk_io_error(mdev, 1, TRUE);
3445 }
3446
3447 /* Update mdev->ldev->md.la_size_sect,
3448 * since we updated it on metadata. */
3449 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
3450
3451 mutex_unlock(&mdev->md_io_mutex);
3452 put_ldev(mdev);
3453}
3454
3455/**
3456 * drbd_md_read() - Reads in the meta data super block
3457 * @mdev: DRBD device.
3458 * @bdev: Device from which the meta data should be read in.
3459 *
3460 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_codes in case
3461 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
3462 */
3463int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
3464{
3465 struct meta_data_on_disk *buffer;
3466 int i, rv = NO_ERROR;
3467
3468 if (!get_ldev_if_state(mdev, D_ATTACHING))
3469 return ERR_IO_MD_DISK;
3470
b411b363
PR		 3471 mutex_lock(&mdev->md_io_mutex);
3472 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3473
3474 if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
3475 /* NOTE: cant do normal error processing here as this is
3476 called BEFORE disk is attached */
3477 dev_err(DEV, "Error while reading metadata.\n");
3478 rv = ERR_IO_MD_DISK;
3479 goto err;
3480 }
3481
3482 if (be32_to_cpu(buffer->magic) != DRBD_MD_MAGIC) {
3483 dev_err(DEV, "Error while reading metadata, magic not found.\n");
3484 rv = ERR_MD_INVALID;
3485 goto err;
3486 }
3487 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
3488 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
3489 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
3490 rv = ERR_MD_INVALID;
3491 goto err;
3492 }
3493 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
3494 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
3495 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
3496 rv = ERR_MD_INVALID;
3497 goto err;
3498 }
3499 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
3500 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
3501 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
3502 rv = ERR_MD_INVALID;
3503 goto err;
3504 }
3505
3506 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
3507 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3508 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
3509 rv = ERR_MD_INVALID;
3510 goto err;
3511 }
3512
3513 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
3514 for (i = UI_CURRENT; i < UI_SIZE; i++)
3515 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
3516 bdev->md.flags = be32_to_cpu(buffer->flags);
3517 mdev->sync_conf.al_extents = be32_to_cpu(buffer->al_nr_extents);
3518 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
3519
3520 if (mdev->sync_conf.al_extents < 7)
3521 mdev->sync_conf.al_extents = 127;
3522
3523 err:
3524 mutex_unlock(&mdev->md_io_mutex);
3525 put_ldev(mdev);
3526
3527 return rv;
3528}
3529
3530/**
3531 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3532 * @mdev: DRBD device.
3533 *
3534 * Call this function if you change anything that should be written to
3535 * the meta-data super block. This function sets MD_DIRTY, and starts a
3536 * timer that ensures that within five seconds you have to call drbd_md_sync().
3537 */
3538void drbd_md_mark_dirty(struct drbd_conf *mdev)
3539{
3540 set_bit(MD_DIRTY, &mdev->flags);
3541 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
3542}
3543
3544
3545static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
3546{
3547 int i;
3548
6a0afdf5 3549 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
b411b363 3550 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
b411b363
PR		 3551}
3552
3553void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3554{
3555 if (idx == UI_CURRENT) {
3556 if (mdev->state.role == R_PRIMARY)
3557 val |= 1;
3558 else
3559 val &= ~((u64)1);
3560
3561 drbd_set_ed_uuid(mdev, val);
3562 }
3563
3564 mdev->ldev->md.uuid[idx] = val;
b411b363
PR		 3565 drbd_md_mark_dirty(mdev);
3566}
3567
3568
3569void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3570{
3571 if (mdev->ldev->md.uuid[idx]) {
3572 drbd_uuid_move_history(mdev);
3573 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
b411b363
PR		 3574 }
3575 _drbd_uuid_set(mdev, idx, val);
3576}
3577
3578/**
3579 * drbd_uuid_new_current() - Creates a new current UUID
3580 * @mdev: DRBD device.
3581 *
3582 * Creates a new current UUID, and rotates the old current UUID into
3583 * the bitmap slot. Causes an incremental resync upon next connect.
3584 */
3585void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
3586{
3587 u64 val;
3588
3589 dev_info(DEV, "Creating new current UUID\n");
3590 D_ASSERT(mdev->ldev->md.uuid[UI_BITMAP] == 0);
3591 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
b411b363
PR		 3592
3593 get_random_bytes(&val, sizeof(u64));
3594 _drbd_uuid_set(mdev, UI_CURRENT, val);
3595}
3596
3597void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
3598{
3599 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
3600 return;
3601
3602 if (val == 0) {
3603 drbd_uuid_move_history(mdev);
3604 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
3605 mdev->ldev->md.uuid[UI_BITMAP] = 0;
b411b363
PR		 3606 } else {
3607 if (mdev->ldev->md.uuid[UI_BITMAP])
3608 dev_warn(DEV, "bm UUID already set");
3609
3610 mdev->ldev->md.uuid[UI_BITMAP] = val;
3611 mdev->ldev->md.uuid[UI_BITMAP] &= ~((u64)1);
3612
b411b363
PR		 3613 }
3614 drbd_md_mark_dirty(mdev);
3615}
3616
3617/**
3618 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3619 * @mdev: DRBD device.
3620 *
3621 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3622 */
3623int drbd_bmio_set_n_write(struct drbd_conf *mdev)
3624{
3625 int rv = -EIO;
3626
3627 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3628 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3629 drbd_md_sync(mdev);
3630 drbd_bm_set_all(mdev);
3631
3632 rv = drbd_bm_write(mdev);
3633
3634 if (!rv) {
3635 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
3636 drbd_md_sync(mdev);
3637 }
3638
3639 put_ldev(mdev);
3640 }
3641
3642 return rv;
3643}
3644
3645/**
3646 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3647 * @mdev: DRBD device.
3648 *
3649 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3650 */
3651int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
3652{
3653 int rv = -EIO;
3654
3655 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3656 drbd_bm_clear_all(mdev);
3657 rv = drbd_bm_write(mdev);
3658 put_ldev(mdev);
3659 }
3660
3661 return rv;
3662}
3663
3664static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3665{
3666 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
3667 int rv;
3668
3669 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
3670
3671 drbd_bm_lock(mdev, work->why);
3672 rv = work->io_fn(mdev);
3673 drbd_bm_unlock(mdev);
3674
3675 clear_bit(BITMAP_IO, &mdev->flags);
3676 wake_up(&mdev->misc_wait);
3677
3678 if (work->done)
3679 work->done(mdev, rv);
3680
3681 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
3682 work->why = NULL;
3683
3684 return 1;
3685}
3686
3687/**
3688 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3689 * @mdev: DRBD device.
3690 * @io_fn: IO callback to be called when bitmap IO is possible
3691 * @done: callback to be called after the bitmap IO was performed
3692 * @why: Descriptive text of the reason for doing the IO
3693 *
3694 * While IO on the bitmap happens we freeze application IO thus we ensure
3695 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3696 * called from worker context. It MUST NOT be used while a previous such
3697 * work is still pending!
3698 */
3699void drbd_queue_bitmap_io(struct drbd_conf *mdev,
3700 int (*io_fn)(struct drbd_conf *),
3701 void (*done)(struct drbd_conf *, int),
3702 char *why)
3703{
3704 D_ASSERT(current == mdev->worker.task);
3705
3706 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
3707 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
3708 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
3709 if (mdev->bm_io_work.why)
3710 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
3711 why, mdev->bm_io_work.why);
3712
3713 mdev->bm_io_work.io_fn = io_fn;
3714 mdev->bm_io_work.done = done;
3715 mdev->bm_io_work.why = why;
3716
3717 set_bit(BITMAP_IO, &mdev->flags);
3718 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
3719 if (list_empty(&mdev->bm_io_work.w.list)) {
3720 set_bit(BITMAP_IO_QUEUED, &mdev->flags);
3721 drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);
3722 } else
3723 dev_err(DEV, "FIXME avoided double queuing bm_io_work\n");
3724 }
3725}
3726
3727/**
3728 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3729 * @mdev: DRBD device.
3730 * @io_fn: IO callback to be called when bitmap IO is possible
3731 * @why: Descriptive text of the reason for doing the IO
3732 *
3733 * freezes application IO while that the actual IO operations runs. This
3734 * functions MAY NOT be called from worker context.
3735 */
3736int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *), char *why)
3737{
3738 int rv;
3739
3740 D_ASSERT(current != mdev->worker.task);
3741
3742 drbd_suspend_io(mdev);
3743
3744 drbd_bm_lock(mdev, why);
3745 rv = io_fn(mdev);
3746 drbd_bm_unlock(mdev);
3747
3748 drbd_resume_io(mdev);
3749
3750 return rv;
3751}
3752
3753void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3754{
3755 if ((mdev->ldev->md.flags & flag) != flag) {
3756 drbd_md_mark_dirty(mdev);
3757 mdev->ldev->md.flags |= flag;
3758 }
3759}
3760
3761void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3762{
3763 if ((mdev->ldev->md.flags & flag) != 0) {
3764 drbd_md_mark_dirty(mdev);
3765 mdev->ldev->md.flags &= ~flag;
3766 }
3767}
3768int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3769{
3770 return (bdev->md.flags & flag) != 0;
3771}
3772
3773static void md_sync_timer_fn(unsigned long data)
3774{
3775 struct drbd_conf *mdev = (struct drbd_conf *) data;
3776
3777 drbd_queue_work_front(&mdev->data.work, &mdev->md_sync_work);
3778}
3779
3780static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3781{
3782 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
3783 drbd_md_sync(mdev);
3784
3785 return 1;
3786}
3787
3788#ifdef CONFIG_DRBD_FAULT_INJECTION
3789/* Fault insertion support including random number generator shamelessly
3790 * stolen from kernel/rcutorture.c */
3791struct fault_random_state {
3792 unsigned long state;
3793 unsigned long count;
3794};
3795
3796#define FAULT_RANDOM_MULT 39916801 /* prime */
3797#define FAULT_RANDOM_ADD 479001701 /* prime */
3798#define FAULT_RANDOM_REFRESH 10000
3799
3800/*
3801 * Crude but fast random-number generator. Uses a linear congruential
3802 * generator, with occasional help from get_random_bytes().
3803 */
3804static unsigned long
3805_drbd_fault_random(struct fault_random_state *rsp)
3806{
3807 long refresh;
3808
49829ea7 3809 if (!rsp->count--) {
b411b363
PR		 3810 get_random_bytes(&refresh, sizeof(refresh));
3811 rsp->state += refresh;
3812 rsp->count = FAULT_RANDOM_REFRESH;
3813 }
3814 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3815 return swahw32(rsp->state);
3816}
3817
3818static char *
3819_drbd_fault_str(unsigned int type) {
3820 static char *_faults[] = {
3821 [DRBD_FAULT_MD_WR] = "Meta-data write",
3822 [DRBD_FAULT_MD_RD] = "Meta-data read",
3823 [DRBD_FAULT_RS_WR] = "Resync write",
3824 [DRBD_FAULT_RS_RD] = "Resync read",
3825 [DRBD_FAULT_DT_WR] = "Data write",
3826 [DRBD_FAULT_DT_RD] = "Data read",
3827 [DRBD_FAULT_DT_RA] = "Data read ahead",
3828 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
6b4388ac
PR		 3829 [DRBD_FAULT_AL_EE] = "EE allocation",
3830 [DRBD_FAULT_RECEIVE] = "receive data corruption",
b411b363
PR		 3831 };
3832
3833 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3834}
3835
3836unsigned int
3837_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3838{
3839 static struct fault_random_state rrs = {0, 0};
3840
3841 unsigned int ret = (
3842 (fault_devs == 0 ||
3843 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3844 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3845
3846 if (ret) {
3847 fault_count++;
3848
7383506c 3849 if (__ratelimit(&drbd_ratelimit_state))
b411b363
PR		 3850 dev_warn(DEV, "***Simulating %s failure\n",
3851 _drbd_fault_str(type));
3852 }
3853
3854 return ret;
3855}
3856#endif
3857
3858const char *drbd_buildtag(void)
3859{
3860 /* DRBD built from external sources has here a reference to the
3861 git hash of the source code. */
3862
3863 static char buildtag[38] = "\0uilt-in";
3864
3865 if (buildtag[0] == 0) {
3866#ifdef CONFIG_MODULES
3867 if (THIS_MODULE != NULL)
3868 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3869 else
3870#endif
3871 buildtag[0] = 'b';
3872 }
3873
3874 return buildtag;
3875}
3876
3877module_init(drbd_init)
3878module_exit(drbd_cleanup)
3879
b411b363
PR		 3880EXPORT_SYMBOL(drbd_conn_str);
3881EXPORT_SYMBOL(drbd_role_str);
3882EXPORT_SYMBOL(drbd_disk_str);
3883EXPORT_SYMBOL(drbd_set_st_err_str);
Linux kernel - Deliverables
This page took 0.660304 seconds and 5 git commands to generate.