4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
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>.
10 Thanks to Carter Burden, Bart Grantham and Gennadiy Nerubayev
11 from Logicworks, Inc. for making SDP replication support possible.
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)
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.
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.
29 #include <linux/module.h>
30 #include <linux/drbd.h>
31 #include <asm/uaccess.h>
32 #include <asm/types.h>
34 #include <linux/ctype.h>
35 #include <linux/smp_lock.h>
37 #include <linux/file.h>
38 #include <linux/proc_fs.h>
39 #include <linux/init.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>
49 #define __KERNEL_SYSCALLS__
50 #include <linux/unistd.h>
51 #include <linux/vmalloc.h>
53 #include <linux/drbd_limits.h>
55 #include "drbd_req.h" /* only for _req_mod in tl_release and tl_clear */
59 struct after_state_chg_work {
63 enum chg_state_flags flags;
64 struct completion *done;
67 int drbdd_init(struct drbd_thread *);
68 int drbd_worker(struct drbd_thread *);
69 int drbd_asender(struct drbd_thread *);
72 static int drbd_open(struct block_device *bdev, fmode_t mode);
73 static int drbd_release(struct gendisk *gd, fmode_t mode);
74 static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused);
75 static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
76 union drbd_state ns, enum chg_state_flags flags);
77 static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused);
78 static void md_sync_timer_fn(unsigned long data);
79 static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused);
81 MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
82 "Lars Ellenberg <lars@linbit.com>");
83 MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
84 MODULE_VERSION(REL_VERSION);
85 MODULE_LICENSE("GPL");
86 MODULE_PARM_DESC(minor_count, "Maximum number of drbd devices (1-255)");
87 MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
89 #include <linux/moduleparam.h>
90 /* allow_open_on_secondary */
91 MODULE_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 */
94 module_param(minor_count, uint, 0444);
95 module_param(disable_sendpage, bool, 0644);
96 module_param(allow_oos, bool, 0);
97 module_param(cn_idx, uint, 0444);
98 module_param(proc_details, int, 0644);
100 #ifdef CONFIG_DRBD_FAULT_INJECTION
103 static int fault_count;
105 /* bitmap of enabled faults */
106 module_param(enable_faults, int, 0664);
107 /* fault rate % value - applies to all enabled faults */
108 module_param(fault_rate, int, 0664);
109 /* count of faults inserted */
110 module_param(fault_count, int, 0664);
111 /* bitmap of devices to insert faults on */
112 module_param(fault_devs, int, 0644);
115 /* module parameter, defined */
116 unsigned int minor_count = 32;
117 int disable_sendpage;
119 unsigned int cn_idx = CN_IDX_DRBD;
120 int proc_details; /* Detail level in proc drbd*/
122 /* Module parameter for setting the user mode helper program
123 * to run. Default is /sbin/drbdadm */
124 char usermode_helper[80] = "/sbin/drbdadm";
126 module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
128 /* in 2.6.x, our device mapping and config info contains our virtual gendisks
129 * as member "struct gendisk *vdisk;"
131 struct drbd_conf **minor_table;
133 struct kmem_cache *drbd_request_cache;
134 struct kmem_cache *drbd_ee_cache; /* epoch entries */
135 struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
136 struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
137 mempool_t *drbd_request_mempool;
138 mempool_t *drbd_ee_mempool;
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.
146 struct page *drbd_pp_pool;
147 spinlock_t drbd_pp_lock;
149 wait_queue_head_t drbd_pp_wait;
151 DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
153 static const struct block_device_operations drbd_ops = {
154 .owner = THIS_MODULE,
156 .release = drbd_release,
159 #define ARRY_SIZE(A) (sizeof(A)/sizeof(A[0]))
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.
165 int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
169 atomic_inc(&mdev->local_cnt);
170 io_allowed = (mdev->state.disk >= mins);
172 if (atomic_dec_and_test(&mdev->local_cnt))
173 wake_up(&mdev->misc_wait);
181 * DOC: The transfer log
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.
187 * Each &struct drbd_tl_epoch has a circular double linked list of requests
190 static int tl_init(struct drbd_conf *mdev)
192 struct drbd_tl_epoch *b;
194 /* during device minor initialization, we may well use GFP_KERNEL */
195 b = kmalloc(sizeof(struct drbd_tl_epoch), GFP_KERNEL);
198 INIT_LIST_HEAD(&b->requests);
199 INIT_LIST_HEAD(&b->w.list);
203 b->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
205 mdev->oldest_tle = b;
206 mdev->newest_tle = b;
207 INIT_LIST_HEAD(&mdev->out_of_sequence_requests);
209 mdev->tl_hash = NULL;
215 static void tl_cleanup(struct drbd_conf *mdev)
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;
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.
233 * The caller must hold the req_lock.
235 void _tl_add_barrier(struct drbd_conf *mdev, struct drbd_tl_epoch *new)
237 struct drbd_tl_epoch *newest_before;
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 */
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;
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.
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
265 void tl_release(struct drbd_conf *mdev, unsigned int barrier_nr,
266 unsigned int set_size)
268 struct drbd_tl_epoch *b, *nob; /* next old barrier */
269 struct list_head *le, *tle;
270 struct drbd_request *r;
272 spin_lock_irq(&mdev->req_lock);
274 b = mdev->oldest_tle;
276 /* first some paranoia code */
278 dev_err(DEV, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
282 if (b->br_number != barrier_nr) {
283 dev_err(DEV, "BAD! BarrierAck #%u received, expected #%u!\n",
284 barrier_nr, b->br_number);
287 if (b->n_req != set_size) {
288 dev_err(DEV, "BAD! BarrierAck #%u received with n_req=%u, expected n_req=%u!\n",
289 barrier_nr, set_size, b->n_req);
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);
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.
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).
308 These have been list_move'd to the out_of_sequence_requests list in
309 _req_mod(, barrier_acked) above.
311 list_del_init(&b->requests);
314 if (test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) {
315 _tl_add_barrier(mdev, b);
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 */
321 D_ASSERT(nob != NULL);
322 mdev->oldest_tle = nob;
326 spin_unlock_irq(&mdev->req_lock);
327 dec_ap_pending(mdev);
332 spin_unlock_irq(&mdev->req_lock);
333 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
338 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
339 * @mdev: DRBD device.
341 * This is called after the connection to the peer was lost. The storage covered
342 * by the requests on the transfer gets marked as our of sync. Called from the
343 * receiver thread and the worker thread.
345 void tl_clear(struct drbd_conf *mdev)
347 struct drbd_tl_epoch *b, *tmp;
348 struct list_head *le, *tle;
349 struct drbd_request *r;
350 int new_initial_bnr = net_random();
352 spin_lock_irq(&mdev->req_lock);
354 b = mdev->oldest_tle;
356 list_for_each_safe(le, tle, &b->requests) {
357 r = list_entry(le, struct drbd_request, tl_requests);
358 /* It would be nice to complete outside of spinlock.
359 * But this is easier for now. */
360 _req_mod(r, connection_lost_while_pending);
364 /* there could still be requests on that ring list,
365 * in case local io is still pending */
366 list_del(&b->requests);
368 /* dec_ap_pending corresponding to queue_barrier.
369 * the newest barrier may not have been queued yet,
370 * in which case w.cb is still NULL. */
372 dec_ap_pending(mdev);
374 if (b == mdev->newest_tle) {
375 /* recycle, but reinit! */
376 D_ASSERT(tmp == NULL);
377 INIT_LIST_HEAD(&b->requests);
378 INIT_LIST_HEAD(&b->w.list);
380 b->br_number = new_initial_bnr;
383 mdev->oldest_tle = b;
390 /* we expect this list to be empty. */
391 D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
393 /* but just in case, clean it up anyways! */
394 list_for_each_safe(le, tle, &mdev->out_of_sequence_requests) {
395 r = list_entry(le, struct drbd_request, tl_requests);
396 /* It would be nice to complete outside of spinlock.
397 * But this is easier for now. */
398 _req_mod(r, connection_lost_while_pending);
401 /* ensure bit indicating barrier is required is clear */
402 clear_bit(CREATE_BARRIER, &mdev->flags);
404 spin_unlock_irq(&mdev->req_lock);
408 * cl_wide_st_chg() - TRUE if the state change is a cluster wide one
409 * @mdev: DRBD device.
410 * @os: old (current) state.
411 * @ns: new (wanted) state.
413 static int cl_wide_st_chg(struct drbd_conf *mdev,
414 union drbd_state os, union drbd_state ns)
416 return (os.conn >= C_CONNECTED && ns.conn >= C_CONNECTED &&
417 ((os.role != R_PRIMARY && ns.role == R_PRIMARY) ||
418 (os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
419 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S) ||
420 (os.disk != D_DISKLESS && ns.disk == D_DISKLESS))) ||
421 (os.conn >= C_CONNECTED && ns.conn == C_DISCONNECTING) ||
422 (os.conn == C_CONNECTED && ns.conn == C_VERIFY_S);
425 int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f,
426 union drbd_state mask, union drbd_state val)
429 union drbd_state os, ns;
432 spin_lock_irqsave(&mdev->req_lock, flags);
434 ns.i = (os.i & ~mask.i) | val.i;
435 rv = _drbd_set_state(mdev, ns, f, NULL);
437 spin_unlock_irqrestore(&mdev->req_lock, flags);
443 * drbd_force_state() - Impose a change which happens outside our control on our state
444 * @mdev: DRBD device.
445 * @mask: mask of state bits to change.
446 * @val: value of new state bits.
448 void drbd_force_state(struct drbd_conf *mdev,
449 union drbd_state mask, union drbd_state val)
451 drbd_change_state(mdev, CS_HARD, mask, val);
454 static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns);
455 static int is_valid_state_transition(struct drbd_conf *,
456 union drbd_state, union drbd_state);
457 static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
458 union drbd_state ns, int *warn_sync_abort);
459 int drbd_send_state_req(struct drbd_conf *,
460 union drbd_state, union drbd_state);
462 static enum drbd_state_ret_codes _req_st_cond(struct drbd_conf *mdev,
463 union drbd_state mask, union drbd_state val)
465 union drbd_state os, ns;
469 if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &mdev->flags))
470 return SS_CW_SUCCESS;
472 if (test_and_clear_bit(CL_ST_CHG_FAIL, &mdev->flags))
473 return SS_CW_FAILED_BY_PEER;
476 spin_lock_irqsave(&mdev->req_lock, flags);
478 ns.i = (os.i & ~mask.i) | val.i;
479 ns = sanitize_state(mdev, os, ns, NULL);
481 if (!cl_wide_st_chg(mdev, os, ns))
484 rv = is_valid_state(mdev, ns);
485 if (rv == SS_SUCCESS) {
486 rv = is_valid_state_transition(mdev, ns, os);
487 if (rv == SS_SUCCESS)
488 rv = 0; /* cont waiting, otherwise fail. */
491 spin_unlock_irqrestore(&mdev->req_lock, flags);
497 * drbd_req_state() - Perform an eventually cluster wide state change
498 * @mdev: DRBD device.
499 * @mask: mask of state bits to change.
500 * @val: value of new state bits.
503 * Should not be called directly, use drbd_request_state() or
504 * _drbd_request_state().
506 static int drbd_req_state(struct drbd_conf *mdev,
507 union drbd_state mask, union drbd_state val,
508 enum chg_state_flags f)
510 struct completion done;
512 union drbd_state os, ns;
515 init_completion(&done);
517 if (f & CS_SERIALIZE)
518 mutex_lock(&mdev->state_mutex);
520 spin_lock_irqsave(&mdev->req_lock, flags);
522 ns.i = (os.i & ~mask.i) | val.i;
523 ns = sanitize_state(mdev, os, ns, NULL);
525 if (cl_wide_st_chg(mdev, os, ns)) {
526 rv = is_valid_state(mdev, ns);
527 if (rv == SS_SUCCESS)
528 rv = is_valid_state_transition(mdev, ns, os);
529 spin_unlock_irqrestore(&mdev->req_lock, flags);
531 if (rv < SS_SUCCESS) {
533 print_st_err(mdev, os, ns, rv);
537 drbd_state_lock(mdev);
538 if (!drbd_send_state_req(mdev, mask, val)) {
539 drbd_state_unlock(mdev);
540 rv = SS_CW_FAILED_BY_PEER;
542 print_st_err(mdev, os, ns, rv);
546 wait_event(mdev->state_wait,
547 (rv = _req_st_cond(mdev, mask, val)));
549 if (rv < SS_SUCCESS) {
550 drbd_state_unlock(mdev);
552 print_st_err(mdev, os, ns, rv);
555 spin_lock_irqsave(&mdev->req_lock, flags);
557 ns.i = (os.i & ~mask.i) | val.i;
558 rv = _drbd_set_state(mdev, ns, f, &done);
559 drbd_state_unlock(mdev);
561 rv = _drbd_set_state(mdev, ns, f, &done);
564 spin_unlock_irqrestore(&mdev->req_lock, flags);
566 if (f & CS_WAIT_COMPLETE && rv == SS_SUCCESS) {
567 D_ASSERT(current != mdev->worker.task);
568 wait_for_completion(&done);
572 if (f & CS_SERIALIZE)
573 mutex_unlock(&mdev->state_mutex);
579 * _drbd_request_state() - Request a state change (with flags)
580 * @mdev: DRBD device.
581 * @mask: mask of state bits to change.
582 * @val: value of new state bits.
585 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE
586 * flag, or when logging of failed state change requests is not desired.
588 int _drbd_request_state(struct drbd_conf *mdev, union drbd_state mask,
589 union drbd_state val, enum chg_state_flags f)
593 wait_event(mdev->state_wait,
594 (rv = drbd_req_state(mdev, mask, val, f)) != SS_IN_TRANSIENT_STATE);
599 static void print_st(struct drbd_conf *mdev, char *name, union drbd_state ns)
601 dev_err(DEV, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c }\n",
603 drbd_conn_str(ns.conn),
604 drbd_role_str(ns.role),
605 drbd_role_str(ns.peer),
606 drbd_disk_str(ns.disk),
607 drbd_disk_str(ns.pdsk),
609 ns.aftr_isp ? 'a' : '-',
610 ns.peer_isp ? 'p' : '-',
611 ns.user_isp ? 'u' : '-'
615 void print_st_err(struct drbd_conf *mdev,
616 union drbd_state os, union drbd_state ns, int err)
618 if (err == SS_IN_TRANSIENT_STATE)
620 dev_err(DEV, "State change failed: %s\n", drbd_set_st_err_str(err));
621 print_st(mdev, " state", os);
622 print_st(mdev, "wanted", ns);
626 #define drbd_peer_str drbd_role_str
627 #define drbd_pdsk_str drbd_disk_str
629 #define drbd_susp_str(A) ((A) ? "1" : "0")
630 #define drbd_aftr_isp_str(A) ((A) ? "1" : "0")
631 #define drbd_peer_isp_str(A) ((A) ? "1" : "0")
632 #define drbd_user_isp_str(A) ((A) ? "1" : "0")
635 ({ if (ns.A != os.A) { \
636 pbp += sprintf(pbp, #A "( %s -> %s ) ", \
637 drbd_##A##_str(os.A), \
638 drbd_##A##_str(ns.A)); \
642 * is_valid_state() - Returns an SS_ error code if ns is not valid
643 * @mdev: DRBD device.
644 * @ns: State to consider.
646 static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns)
648 /* See drbd_state_sw_errors in drbd_strings.c */
650 enum drbd_fencing_p fp;
654 if (get_ldev(mdev)) {
655 fp = mdev->ldev->dc.fencing;
659 if (get_net_conf(mdev)) {
660 if (!mdev->net_conf->two_primaries &&
661 ns.role == R_PRIMARY && ns.peer == R_PRIMARY)
662 rv = SS_TWO_PRIMARIES;
667 /* already found a reason to abort */;
668 else if (ns.role == R_SECONDARY && mdev->open_cnt)
669 rv = SS_DEVICE_IN_USE;
671 else if (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.disk < D_UP_TO_DATE)
672 rv = SS_NO_UP_TO_DATE_DISK;
674 else if (fp >= FP_RESOURCE &&
675 ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk >= D_UNKNOWN)
678 else if (ns.role == R_PRIMARY && ns.disk <= D_INCONSISTENT && ns.pdsk <= D_INCONSISTENT)
679 rv = SS_NO_UP_TO_DATE_DISK;
681 else if (ns.conn > C_CONNECTED && ns.disk < D_INCONSISTENT)
682 rv = SS_NO_LOCAL_DISK;
684 else if (ns.conn > C_CONNECTED && ns.pdsk < D_INCONSISTENT)
685 rv = SS_NO_REMOTE_DISK;
687 else if (ns.conn > C_CONNECTED && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE)
688 rv = SS_NO_UP_TO_DATE_DISK;
690 else if ((ns.conn == C_CONNECTED ||
691 ns.conn == C_WF_BITMAP_S ||
692 ns.conn == C_SYNC_SOURCE ||
693 ns.conn == C_PAUSED_SYNC_S) &&
694 ns.disk == D_OUTDATED)
695 rv = SS_CONNECTED_OUTDATES;
697 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
698 (mdev->sync_conf.verify_alg[0] == 0))
699 rv = SS_NO_VERIFY_ALG;
701 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
702 mdev->agreed_pro_version < 88)
703 rv = SS_NOT_SUPPORTED;
709 * is_valid_state_transition() - Returns an SS_ error code if the state transition is not possible
710 * @mdev: DRBD device.
714 static int is_valid_state_transition(struct drbd_conf *mdev,
715 union drbd_state ns, union drbd_state os)
719 if ((ns.conn == C_STARTING_SYNC_T || ns.conn == C_STARTING_SYNC_S) &&
720 os.conn > C_CONNECTED)
721 rv = SS_RESYNC_RUNNING;
723 if (ns.conn == C_DISCONNECTING && os.conn == C_STANDALONE)
724 rv = SS_ALREADY_STANDALONE;
726 if (ns.disk > D_ATTACHING && os.disk == D_DISKLESS)
729 if (ns.conn == C_WF_CONNECTION && os.conn < C_UNCONNECTED)
730 rv = SS_NO_NET_CONFIG;
732 if (ns.disk == D_OUTDATED && os.disk < D_OUTDATED && os.disk != D_ATTACHING)
733 rv = SS_LOWER_THAN_OUTDATED;
735 if (ns.conn == C_DISCONNECTING && os.conn == C_UNCONNECTED)
736 rv = SS_IN_TRANSIENT_STATE;
738 if (ns.conn == os.conn && ns.conn == C_WF_REPORT_PARAMS)
739 rv = SS_IN_TRANSIENT_STATE;
741 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && os.conn < C_CONNECTED)
742 rv = SS_NEED_CONNECTION;
744 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
745 ns.conn != os.conn && os.conn > C_CONNECTED)
746 rv = SS_RESYNC_RUNNING;
748 if ((ns.conn == C_STARTING_SYNC_S || ns.conn == C_STARTING_SYNC_T) &&
749 os.conn < C_CONNECTED)
750 rv = SS_NEED_CONNECTION;
756 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition
757 * @mdev: DRBD device.
762 * When we loose connection, we have to set the state of the peers disk (pdsk)
763 * to D_UNKNOWN. This rule and many more along those lines are in this function.
765 static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
766 union drbd_state ns, int *warn_sync_abort)
768 enum drbd_fencing_p fp;
771 if (get_ldev(mdev)) {
772 fp = mdev->ldev->dc.fencing;
776 /* Disallow Network errors to configure a device's network part */
777 if ((ns.conn >= C_TIMEOUT && ns.conn <= C_TEAR_DOWN) &&
778 os.conn <= C_DISCONNECTING)
781 /* After a network error (+C_TEAR_DOWN) only C_UNCONNECTED or C_DISCONNECTING can follow */
782 if (os.conn >= C_TIMEOUT && os.conn <= C_TEAR_DOWN &&
783 ns.conn != C_UNCONNECTED && ns.conn != C_DISCONNECTING)
786 /* After C_DISCONNECTING only C_STANDALONE may follow */
787 if (os.conn == C_DISCONNECTING && ns.conn != C_STANDALONE)
790 if (ns.conn < C_CONNECTED) {
793 if (ns.pdsk > D_UNKNOWN || ns.pdsk < D_INCONSISTENT)
797 /* Clear the aftr_isp when becoming unconfigured */
798 if (ns.conn == C_STANDALONE && ns.disk == D_DISKLESS && ns.role == R_SECONDARY)
801 if (ns.conn <= C_DISCONNECTING && ns.disk == D_DISKLESS)
804 /* Abort resync if a disk fails/detaches */
805 if (os.conn > C_CONNECTED && ns.conn > C_CONNECTED &&
806 (ns.disk <= D_FAILED || ns.pdsk <= D_FAILED)) {
808 *warn_sync_abort = 1;
809 ns.conn = C_CONNECTED;
812 if (ns.conn >= C_CONNECTED &&
813 ((ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED) ||
814 (ns.disk == D_NEGOTIATING && ns.conn == C_WF_BITMAP_T))) {
817 case C_PAUSED_SYNC_T:
818 ns.disk = D_OUTDATED;
823 case C_PAUSED_SYNC_S:
824 ns.disk = D_UP_TO_DATE;
827 ns.disk = D_INCONSISTENT;
828 dev_warn(DEV, "Implicitly set disk state Inconsistent!\n");
831 if (os.disk == D_OUTDATED && ns.disk == D_UP_TO_DATE)
832 dev_warn(DEV, "Implicitly set disk from Outdated to UpToDate\n");
835 if (ns.conn >= C_CONNECTED &&
836 (ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED)) {
840 case C_PAUSED_SYNC_T:
842 ns.pdsk = D_UP_TO_DATE;
845 case C_PAUSED_SYNC_S:
846 /* remap any consistent state to D_OUTDATED,
847 * but disallow "upgrade" of not even consistent states.
850 (D_DISKLESS < os.pdsk && os.pdsk < D_OUTDATED)
851 ? os.pdsk : D_OUTDATED;
854 ns.pdsk = D_INCONSISTENT;
855 dev_warn(DEV, "Implicitly set pdsk Inconsistent!\n");
858 if (os.pdsk == D_OUTDATED && ns.pdsk == D_UP_TO_DATE)
859 dev_warn(DEV, "Implicitly set pdsk from Outdated to UpToDate\n");
862 /* Connection breaks down before we finished "Negotiating" */
863 if (ns.conn < C_CONNECTED && ns.disk == D_NEGOTIATING &&
864 get_ldev_if_state(mdev, D_NEGOTIATING)) {
865 if (mdev->ed_uuid == mdev->ldev->md.uuid[UI_CURRENT]) {
866 ns.disk = mdev->new_state_tmp.disk;
867 ns.pdsk = mdev->new_state_tmp.pdsk;
869 dev_alert(DEV, "Connection lost while negotiating, no data!\n");
870 ns.disk = D_DISKLESS;
876 if (fp == FP_STONITH &&
877 (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk > D_OUTDATED) &&
878 !(os.role == R_PRIMARY && os.conn < C_CONNECTED && os.pdsk > D_OUTDATED))
881 if (ns.aftr_isp || ns.peer_isp || ns.user_isp) {
882 if (ns.conn == C_SYNC_SOURCE)
883 ns.conn = C_PAUSED_SYNC_S;
884 if (ns.conn == C_SYNC_TARGET)
885 ns.conn = C_PAUSED_SYNC_T;
887 if (ns.conn == C_PAUSED_SYNC_S)
888 ns.conn = C_SYNC_SOURCE;
889 if (ns.conn == C_PAUSED_SYNC_T)
890 ns.conn = C_SYNC_TARGET;
896 /* helper for __drbd_set_state */
897 static void set_ov_position(struct drbd_conf *mdev, enum drbd_conns cs)
899 if (cs == C_VERIFY_T) {
900 /* starting online verify from an arbitrary position
901 * does not fit well into the existing protocol.
902 * on C_VERIFY_T, we initialize ov_left and friends
903 * implicitly in receive_DataRequest once the
904 * first P_OV_REQUEST is received */
905 mdev->ov_start_sector = ~(sector_t)0;
907 unsigned long bit = BM_SECT_TO_BIT(mdev->ov_start_sector);
908 if (bit >= mdev->rs_total)
909 mdev->ov_start_sector =
910 BM_BIT_TO_SECT(mdev->rs_total - 1);
911 mdev->ov_position = mdev->ov_start_sector;
916 * __drbd_set_state() - Set a new DRBD state
917 * @mdev: DRBD device.
920 * @done: Optional completion, that will get completed after the after_state_ch() finished
922 * Caller needs to hold req_lock, and global_state_lock. Do not call directly.
924 int __drbd_set_state(struct drbd_conf *mdev,
925 union drbd_state ns, enum chg_state_flags flags,
926 struct completion *done)
930 int warn_sync_abort = 0;
931 struct after_state_chg_work *ascw;
935 ns = sanitize_state(mdev, os, ns, &warn_sync_abort);
938 return SS_NOTHING_TO_DO;
940 if (!(flags & CS_HARD)) {
941 /* pre-state-change checks ; only look at ns */
942 /* See drbd_state_sw_errors in drbd_strings.c */
944 rv = is_valid_state(mdev, ns);
945 if (rv < SS_SUCCESS) {
946 /* If the old state was illegal as well, then let
949 if (is_valid_state(mdev, os) == rv) {
950 dev_err(DEV, "Considering state change from bad state. "
951 "Error would be: '%s'\n",
952 drbd_set_st_err_str(rv));
953 print_st(mdev, "old", os);
954 print_st(mdev, "new", ns);
955 rv = is_valid_state_transition(mdev, ns, os);
958 rv = is_valid_state_transition(mdev, ns, os);
961 if (rv < SS_SUCCESS) {
962 if (flags & CS_VERBOSE)
963 print_st_err(mdev, os, ns, rv);
968 dev_warn(DEV, "Resync aborted.\n");
983 dev_info(DEV, "%s\n", pb);
986 /* solve the race between becoming unconfigured,
987 * worker doing the cleanup, and
988 * admin reconfiguring us:
989 * on (re)configure, first set CONFIG_PENDING,
990 * then wait for a potentially exiting worker,
991 * start the worker, and schedule one no_op.
992 * then proceed with configuration.
994 if (ns.disk == D_DISKLESS &&
995 ns.conn == C_STANDALONE &&
996 ns.role == R_SECONDARY &&
997 !test_and_set_bit(CONFIG_PENDING, &mdev->flags))
998 set_bit(DEVICE_DYING, &mdev->flags);
1000 mdev->state.i = ns.i;
1001 wake_up(&mdev->misc_wait);
1002 wake_up(&mdev->state_wait);
1004 /* post-state-change actions */
1005 if (os.conn >= C_SYNC_SOURCE && ns.conn <= C_CONNECTED) {
1006 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1007 mod_timer(&mdev->resync_timer, jiffies);
1010 /* aborted verify run. log the last position */
1011 if ((os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) &&
1012 ns.conn < C_CONNECTED) {
1013 mdev->ov_start_sector =
1014 BM_BIT_TO_SECT(mdev->rs_total - mdev->ov_left);
1015 dev_info(DEV, "Online Verify reached sector %llu\n",
1016 (unsigned long long)mdev->ov_start_sector);
1019 if ((os.conn == C_PAUSED_SYNC_T || os.conn == C_PAUSED_SYNC_S) &&
1020 (ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE)) {
1021 dev_info(DEV, "Syncer continues.\n");
1022 mdev->rs_paused += (long)jiffies-(long)mdev->rs_mark_time;
1023 if (ns.conn == C_SYNC_TARGET) {
1024 if (!test_and_clear_bit(STOP_SYNC_TIMER, &mdev->flags))
1025 mod_timer(&mdev->resync_timer, jiffies);
1026 /* This if (!test_bit) is only needed for the case
1027 that a device that has ceased to used its timer,
1028 i.e. it is already in drbd_resync_finished() gets
1029 paused and resumed. */
1033 if ((os.conn == C_SYNC_TARGET || os.conn == C_SYNC_SOURCE) &&
1034 (ns.conn == C_PAUSED_SYNC_T || ns.conn == C_PAUSED_SYNC_S)) {
1035 dev_info(DEV, "Resync suspended\n");
1036 mdev->rs_mark_time = jiffies;
1037 if (ns.conn == C_PAUSED_SYNC_T)
1038 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1041 if (os.conn == C_CONNECTED &&
1042 (ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T)) {
1043 mdev->ov_position = 0;
1045 mdev->rs_mark_left = drbd_bm_bits(mdev);
1046 if (mdev->agreed_pro_version >= 90)
1047 set_ov_position(mdev, ns.conn);
1049 mdev->ov_start_sector = 0;
1050 mdev->ov_left = mdev->rs_total
1051 - BM_SECT_TO_BIT(mdev->ov_position);
1053 mdev->rs_mark_time = jiffies;
1054 mdev->ov_last_oos_size = 0;
1055 mdev->ov_last_oos_start = 0;
1057 if (ns.conn == C_VERIFY_S) {
1058 dev_info(DEV, "Starting Online Verify from sector %llu\n",
1059 (unsigned long long)mdev->ov_position);
1060 mod_timer(&mdev->resync_timer, jiffies);
1064 if (get_ldev(mdev)) {
1065 u32 mdf = mdev->ldev->md.flags & ~(MDF_CONSISTENT|MDF_PRIMARY_IND|
1066 MDF_CONNECTED_IND|MDF_WAS_UP_TO_DATE|
1067 MDF_PEER_OUT_DATED|MDF_CRASHED_PRIMARY);
1069 if (test_bit(CRASHED_PRIMARY, &mdev->flags))
1070 mdf |= MDF_CRASHED_PRIMARY;
1071 if (mdev->state.role == R_PRIMARY ||
1072 (mdev->state.pdsk < D_INCONSISTENT && mdev->state.peer == R_PRIMARY))
1073 mdf |= MDF_PRIMARY_IND;
1074 if (mdev->state.conn > C_WF_REPORT_PARAMS)
1075 mdf |= MDF_CONNECTED_IND;
1076 if (mdev->state.disk > D_INCONSISTENT)
1077 mdf |= MDF_CONSISTENT;
1078 if (mdev->state.disk > D_OUTDATED)
1079 mdf |= MDF_WAS_UP_TO_DATE;
1080 if (mdev->state.pdsk <= D_OUTDATED && mdev->state.pdsk >= D_INCONSISTENT)
1081 mdf |= MDF_PEER_OUT_DATED;
1082 if (mdf != mdev->ldev->md.flags) {
1083 mdev->ldev->md.flags = mdf;
1084 drbd_md_mark_dirty(mdev);
1086 if (os.disk < D_CONSISTENT && ns.disk >= D_CONSISTENT)
1087 drbd_set_ed_uuid(mdev, mdev->ldev->md.uuid[UI_CURRENT]);
1091 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */
1092 if (os.disk == D_INCONSISTENT && os.pdsk == D_INCONSISTENT &&
1093 os.peer == R_SECONDARY && ns.peer == R_PRIMARY)
1094 set_bit(CONSIDER_RESYNC, &mdev->flags);
1096 /* Receiver should clean up itself */
1097 if (os.conn != C_DISCONNECTING && ns.conn == C_DISCONNECTING)
1098 drbd_thread_stop_nowait(&mdev->receiver);
1100 /* Now the receiver finished cleaning up itself, it should die */
1101 if (os.conn != C_STANDALONE && ns.conn == C_STANDALONE)
1102 drbd_thread_stop_nowait(&mdev->receiver);
1104 /* Upon network failure, we need to restart the receiver. */
1105 if (os.conn > C_TEAR_DOWN &&
1106 ns.conn <= C_TEAR_DOWN && ns.conn >= C_TIMEOUT)
1107 drbd_thread_restart_nowait(&mdev->receiver);
1109 ascw = kmalloc(sizeof(*ascw), GFP_ATOMIC);
1113 ascw->flags = flags;
1114 ascw->w.cb = w_after_state_ch;
1116 drbd_queue_work(&mdev->data.work, &ascw->w);
1118 dev_warn(DEV, "Could not kmalloc an ascw\n");
1124 static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1126 struct after_state_chg_work *ascw =
1127 container_of(w, struct after_state_chg_work, w);
1128 after_state_ch(mdev, ascw->os, ascw->ns, ascw->flags);
1129 if (ascw->flags & CS_WAIT_COMPLETE) {
1130 D_ASSERT(ascw->done != NULL);
1131 complete(ascw->done);
1138 static void abw_start_sync(struct drbd_conf *mdev, int rv)
1141 dev_err(DEV, "Writing the bitmap failed not starting resync.\n");
1142 _drbd_request_state(mdev, NS(conn, C_CONNECTED), CS_VERBOSE);
1146 switch (mdev->state.conn) {
1147 case C_STARTING_SYNC_T:
1148 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
1150 case C_STARTING_SYNC_S:
1151 drbd_start_resync(mdev, C_SYNC_SOURCE);
1157 * after_state_ch() - Perform after state change actions that may sleep
1158 * @mdev: DRBD device.
1163 static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
1164 union drbd_state ns, enum chg_state_flags flags)
1166 enum drbd_fencing_p fp;
1168 if (os.conn != C_CONNECTED && ns.conn == C_CONNECTED) {
1169 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1171 mdev->p_uuid[UI_FLAGS] &= ~((u64)2);
1175 if (get_ldev(mdev)) {
1176 fp = mdev->ldev->dc.fencing;
1180 /* Inform userspace about the change... */
1181 drbd_bcast_state(mdev, ns);
1183 if (!(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE) &&
1184 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE))
1185 drbd_khelper(mdev, "pri-on-incon-degr");
1187 /* Here we have the actions that are performed after a
1188 state change. This function might sleep */
1190 if (fp == FP_STONITH && ns.susp) {
1191 /* case1: The outdate peer handler is successful:
1192 * case2: The connection was established again: */
1193 if ((os.pdsk > D_OUTDATED && ns.pdsk <= D_OUTDATED) ||
1194 (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED)) {
1196 spin_lock_irq(&mdev->req_lock);
1197 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1198 spin_unlock_irq(&mdev->req_lock);
1201 /* Do not change the order of the if above and the two below... */
1202 if (os.pdsk == D_DISKLESS && ns.pdsk > D_DISKLESS) { /* attach on the peer */
1203 drbd_send_uuids(mdev);
1204 drbd_send_state(mdev);
1206 if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S)
1207 drbd_queue_bitmap_io(mdev, &drbd_send_bitmap, NULL, "send_bitmap (WFBitMapS)");
1209 /* Lost contact to peer's copy of the data */
1210 if ((os.pdsk >= D_INCONSISTENT &&
1211 os.pdsk != D_UNKNOWN &&
1212 os.pdsk != D_OUTDATED)
1213 && (ns.pdsk < D_INCONSISTENT ||
1214 ns.pdsk == D_UNKNOWN ||
1215 ns.pdsk == D_OUTDATED)) {
1216 if (get_ldev(mdev)) {
1217 if ((ns.role == R_PRIMARY || ns.peer == R_PRIMARY) &&
1218 mdev->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) {
1219 drbd_uuid_new_current(mdev);
1220 drbd_send_uuids(mdev);
1226 if (ns.pdsk < D_INCONSISTENT && get_ldev(mdev)) {
1227 if (ns.peer == R_PRIMARY && mdev->ldev->md.uuid[UI_BITMAP] == 0)
1228 drbd_uuid_new_current(mdev);
1230 /* D_DISKLESS Peer becomes secondary */
1231 if (os.peer == R_PRIMARY && ns.peer == R_SECONDARY)
1232 drbd_al_to_on_disk_bm(mdev);
1236 /* Last part of the attaching process ... */
1237 if (ns.conn >= C_CONNECTED &&
1238 os.disk == D_ATTACHING && ns.disk == D_NEGOTIATING) {
1239 drbd_send_sizes(mdev, 0, 0); /* to start sync... */
1240 drbd_send_uuids(mdev);
1241 drbd_send_state(mdev);
1244 /* We want to pause/continue resync, tell peer. */
1245 if (ns.conn >= C_CONNECTED &&
1246 ((os.aftr_isp != ns.aftr_isp) ||
1247 (os.user_isp != ns.user_isp)))
1248 drbd_send_state(mdev);
1250 /* In case one of the isp bits got set, suspend other devices. */
1251 if ((!os.aftr_isp && !os.peer_isp && !os.user_isp) &&
1252 (ns.aftr_isp || ns.peer_isp || ns.user_isp))
1253 suspend_other_sg(mdev);
1255 /* Make sure the peer gets informed about eventual state
1256 changes (ISP bits) while we were in WFReportParams. */
1257 if (os.conn == C_WF_REPORT_PARAMS && ns.conn >= C_CONNECTED)
1258 drbd_send_state(mdev);
1260 /* We are in the progress to start a full sync... */
1261 if ((os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
1262 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S))
1263 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, &abw_start_sync, "set_n_write from StartingSync");
1265 /* We are invalidating our self... */
1266 if (os.conn < C_CONNECTED && ns.conn < C_CONNECTED &&
1267 os.disk > D_INCONSISTENT && ns.disk == D_INCONSISTENT)
1268 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL, "set_n_write from invalidate");
1270 if (os.disk > D_FAILED && ns.disk == D_FAILED) {
1271 enum drbd_io_error_p eh;
1274 if (get_ldev_if_state(mdev, D_FAILED)) {
1275 eh = mdev->ldev->dc.on_io_error;
1279 drbd_rs_cancel_all(mdev);
1280 /* since get_ldev() only works as long as disk>=D_INCONSISTENT,
1281 and it is D_DISKLESS here, local_cnt can only go down, it can
1282 not increase... It will reach zero */
1283 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
1285 mdev->rs_failed = 0;
1286 atomic_set(&mdev->rs_pending_cnt, 0);
1288 spin_lock_irq(&mdev->req_lock);
1289 _drbd_set_state(_NS(mdev, disk, D_DISKLESS), CS_HARD, NULL);
1290 spin_unlock_irq(&mdev->req_lock);
1292 if (eh == EP_CALL_HELPER)
1293 drbd_khelper(mdev, "local-io-error");
1296 if (os.disk > D_DISKLESS && ns.disk == D_DISKLESS) {
1298 if (os.disk == D_FAILED) /* && ns.disk == D_DISKLESS*/ {
1299 if (drbd_send_state(mdev))
1300 dev_warn(DEV, "Notified peer that my disk is broken.\n");
1302 dev_err(DEV, "Sending state in drbd_io_error() failed\n");
1305 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
1306 lc_destroy(mdev->resync);
1307 mdev->resync = NULL;
1308 lc_destroy(mdev->act_log);
1309 mdev->act_log = NULL;
1311 drbd_free_bc(mdev->ldev);
1312 mdev->ldev = NULL;);
1314 if (mdev->md_io_tmpp)
1315 __free_page(mdev->md_io_tmpp);
1318 /* Disks got bigger while they were detached */
1319 if (ns.disk > D_NEGOTIATING && ns.pdsk > D_NEGOTIATING &&
1320 test_and_clear_bit(RESYNC_AFTER_NEG, &mdev->flags)) {
1321 if (ns.conn == C_CONNECTED)
1322 resync_after_online_grow(mdev);
1325 /* A resync finished or aborted, wake paused devices... */
1326 if ((os.conn > C_CONNECTED && ns.conn <= C_CONNECTED) ||
1327 (os.peer_isp && !ns.peer_isp) ||
1328 (os.user_isp && !ns.user_isp))
1329 resume_next_sg(mdev);
1331 /* Upon network connection, we need to start the receiver */
1332 if (os.conn == C_STANDALONE && ns.conn == C_UNCONNECTED)
1333 drbd_thread_start(&mdev->receiver);
1335 /* Terminate worker thread if we are unconfigured - it will be
1336 restarted as needed... */
1337 if (ns.disk == D_DISKLESS &&
1338 ns.conn == C_STANDALONE &&
1339 ns.role == R_SECONDARY) {
1340 if (os.aftr_isp != ns.aftr_isp)
1341 resume_next_sg(mdev);
1342 /* set in __drbd_set_state, unless CONFIG_PENDING was set */
1343 if (test_bit(DEVICE_DYING, &mdev->flags))
1344 drbd_thread_stop_nowait(&mdev->worker);
1351 static int drbd_thread_setup(void *arg)
1353 struct drbd_thread *thi = (struct drbd_thread *) arg;
1354 struct drbd_conf *mdev = thi->mdev;
1355 unsigned long flags;
1359 retval = thi->function(thi);
1361 spin_lock_irqsave(&thi->t_lock, flags);
1363 /* if the receiver has been "Exiting", the last thing it did
1364 * was set the conn state to "StandAlone",
1365 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
1366 * and receiver thread will be "started".
1367 * drbd_thread_start needs to set "Restarting" in that case.
1368 * t_state check and assignment needs to be within the same spinlock,
1369 * so either thread_start sees Exiting, and can remap to Restarting,
1370 * or thread_start see None, and can proceed as normal.
1373 if (thi->t_state == Restarting) {
1374 dev_info(DEV, "Restarting %s\n", current->comm);
1375 thi->t_state = Running;
1376 spin_unlock_irqrestore(&thi->t_lock, flags);
1381 thi->t_state = None;
1383 complete(&thi->stop);
1384 spin_unlock_irqrestore(&thi->t_lock, flags);
1386 dev_info(DEV, "Terminating %s\n", current->comm);
1388 /* Release mod reference taken when thread was started */
1389 module_put(THIS_MODULE);
1393 static void drbd_thread_init(struct drbd_conf *mdev, struct drbd_thread *thi,
1394 int (*func) (struct drbd_thread *))
1396 spin_lock_init(&thi->t_lock);
1398 thi->t_state = None;
1399 thi->function = func;
1403 int drbd_thread_start(struct drbd_thread *thi)
1405 struct drbd_conf *mdev = thi->mdev;
1406 struct task_struct *nt;
1407 unsigned long flags;
1410 thi == &mdev->receiver ? "receiver" :
1411 thi == &mdev->asender ? "asender" :
1412 thi == &mdev->worker ? "worker" : "NONSENSE";
1414 /* is used from state engine doing drbd_thread_stop_nowait,
1415 * while holding the req lock irqsave */
1416 spin_lock_irqsave(&thi->t_lock, flags);
1418 switch (thi->t_state) {
1420 dev_info(DEV, "Starting %s thread (from %s [%d])\n",
1421 me, current->comm, current->pid);
1423 /* Get ref on module for thread - this is released when thread exits */
1424 if (!try_module_get(THIS_MODULE)) {
1425 dev_err(DEV, "Failed to get module reference in drbd_thread_start\n");
1426 spin_unlock_irqrestore(&thi->t_lock, flags);
1430 init_completion(&thi->stop);
1431 D_ASSERT(thi->task == NULL);
1432 thi->reset_cpu_mask = 1;
1433 thi->t_state = Running;
1434 spin_unlock_irqrestore(&thi->t_lock, flags);
1435 flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
1437 nt = kthread_create(drbd_thread_setup, (void *) thi,
1438 "drbd%d_%s", mdev_to_minor(mdev), me);
1441 dev_err(DEV, "Couldn't start thread\n");
1443 module_put(THIS_MODULE);
1446 spin_lock_irqsave(&thi->t_lock, flags);
1448 thi->t_state = Running;
1449 spin_unlock_irqrestore(&thi->t_lock, flags);
1450 wake_up_process(nt);
1453 thi->t_state = Restarting;
1454 dev_info(DEV, "Restarting %s thread (from %s [%d])\n",
1455 me, current->comm, current->pid);
1460 spin_unlock_irqrestore(&thi->t_lock, flags);
1468 void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
1470 unsigned long flags;
1472 enum drbd_thread_state ns = restart ? Restarting : Exiting;
1474 /* may be called from state engine, holding the req lock irqsave */
1475 spin_lock_irqsave(&thi->t_lock, flags);
1477 if (thi->t_state == None) {
1478 spin_unlock_irqrestore(&thi->t_lock, flags);
1480 drbd_thread_start(thi);
1484 if (thi->t_state != ns) {
1485 if (thi->task == NULL) {
1486 spin_unlock_irqrestore(&thi->t_lock, flags);
1492 init_completion(&thi->stop);
1493 if (thi->task != current)
1494 force_sig(DRBD_SIGKILL, thi->task);
1498 spin_unlock_irqrestore(&thi->t_lock, flags);
1501 wait_for_completion(&thi->stop);
1506 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
1507 * @mdev: DRBD device.
1509 * Forces all threads of a device onto the same CPU. This is beneficial for
1510 * DRBD's performance. May be overwritten by user's configuration.
1512 void drbd_calc_cpu_mask(struct drbd_conf *mdev)
1516 /* user override. */
1517 if (cpumask_weight(mdev->cpu_mask))
1520 ord = mdev_to_minor(mdev) % cpumask_weight(cpu_online_mask);
1521 for_each_online_cpu(cpu) {
1523 cpumask_set_cpu(cpu, mdev->cpu_mask);
1527 /* should not be reached */
1528 cpumask_setall(mdev->cpu_mask);
1532 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
1533 * @mdev: DRBD device.
1535 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
1538 void drbd_thread_current_set_cpu(struct drbd_conf *mdev)
1540 struct task_struct *p = current;
1541 struct drbd_thread *thi =
1542 p == mdev->asender.task ? &mdev->asender :
1543 p == mdev->receiver.task ? &mdev->receiver :
1544 p == mdev->worker.task ? &mdev->worker :
1548 if (!thi->reset_cpu_mask)
1550 thi->reset_cpu_mask = 0;
1551 set_cpus_allowed_ptr(p, mdev->cpu_mask);
1555 /* the appropriate socket mutex must be held already */
1556 int _drbd_send_cmd(struct drbd_conf *mdev, struct socket *sock,
1557 enum drbd_packets cmd, struct p_header *h,
1558 size_t size, unsigned msg_flags)
1562 ERR_IF(!h) return FALSE;
1563 ERR_IF(!size) return FALSE;
1565 h->magic = BE_DRBD_MAGIC;
1566 h->command = cpu_to_be16(cmd);
1567 h->length = cpu_to_be16(size-sizeof(struct p_header));
1569 sent = drbd_send(mdev, sock, h, size, msg_flags);
1571 ok = (sent == size);
1573 dev_err(DEV, "short sent %s size=%d sent=%d\n",
1574 cmdname(cmd), (int)size, sent);
1578 /* don't pass the socket. we may only look at it
1579 * when we hold the appropriate socket mutex.
1581 int drbd_send_cmd(struct drbd_conf *mdev, int use_data_socket,
1582 enum drbd_packets cmd, struct p_header *h, size_t size)
1585 struct socket *sock;
1587 if (use_data_socket) {
1588 mutex_lock(&mdev->data.mutex);
1589 sock = mdev->data.socket;
1591 mutex_lock(&mdev->meta.mutex);
1592 sock = mdev->meta.socket;
1595 /* drbd_disconnect() could have called drbd_free_sock()
1596 * while we were waiting in down()... */
1597 if (likely(sock != NULL))
1598 ok = _drbd_send_cmd(mdev, sock, cmd, h, size, 0);
1600 if (use_data_socket)
1601 mutex_unlock(&mdev->data.mutex);
1603 mutex_unlock(&mdev->meta.mutex);
1607 int drbd_send_cmd2(struct drbd_conf *mdev, enum drbd_packets cmd, char *data,
1613 h.magic = BE_DRBD_MAGIC;
1614 h.command = cpu_to_be16(cmd);
1615 h.length = cpu_to_be16(size);
1617 if (!drbd_get_data_sock(mdev))
1621 drbd_send(mdev, mdev->data.socket, &h, sizeof(h), 0));
1623 drbd_send(mdev, mdev->data.socket, data, size, 0));
1625 drbd_put_data_sock(mdev);
1630 int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc)
1632 struct p_rs_param_89 *p;
1633 struct socket *sock;
1635 const int apv = mdev->agreed_pro_version;
1637 size = apv <= 87 ? sizeof(struct p_rs_param)
1638 : apv == 88 ? sizeof(struct p_rs_param)
1639 + strlen(mdev->sync_conf.verify_alg) + 1
1640 : /* 89 */ sizeof(struct p_rs_param_89);
1642 /* used from admin command context and receiver/worker context.
1643 * to avoid kmalloc, grab the socket right here,
1644 * then use the pre-allocated sbuf there */
1645 mutex_lock(&mdev->data.mutex);
1646 sock = mdev->data.socket;
1648 if (likely(sock != NULL)) {
1649 enum drbd_packets cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
1651 p = &mdev->data.sbuf.rs_param_89;
1653 /* initialize verify_alg and csums_alg */
1654 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
1656 p->rate = cpu_to_be32(sc->rate);
1659 strcpy(p->verify_alg, mdev->sync_conf.verify_alg);
1661 strcpy(p->csums_alg, mdev->sync_conf.csums_alg);
1663 rv = _drbd_send_cmd(mdev, sock, cmd, &p->head, size, 0);
1665 rv = 0; /* not ok */
1667 mutex_unlock(&mdev->data.mutex);
1672 int drbd_send_protocol(struct drbd_conf *mdev)
1674 struct p_protocol *p;
1677 size = sizeof(struct p_protocol);
1679 if (mdev->agreed_pro_version >= 87)
1680 size += strlen(mdev->net_conf->integrity_alg) + 1;
1682 /* we must not recurse into our own queue,
1683 * as that is blocked during handshake */
1684 p = kmalloc(size, GFP_NOIO);
1688 p->protocol = cpu_to_be32(mdev->net_conf->wire_protocol);
1689 p->after_sb_0p = cpu_to_be32(mdev->net_conf->after_sb_0p);
1690 p->after_sb_1p = cpu_to_be32(mdev->net_conf->after_sb_1p);
1691 p->after_sb_2p = cpu_to_be32(mdev->net_conf->after_sb_2p);
1692 p->two_primaries = cpu_to_be32(mdev->net_conf->two_primaries);
1695 if (mdev->net_conf->want_lose)
1697 if (mdev->net_conf->dry_run) {
1698 if (mdev->agreed_pro_version >= 92)
1701 dev_err(DEV, "--dry-run is not supported by peer");
1706 p->conn_flags = cpu_to_be32(cf);
1708 if (mdev->agreed_pro_version >= 87)
1709 strcpy(p->integrity_alg, mdev->net_conf->integrity_alg);
1711 rv = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_PROTOCOL,
1712 (struct p_header *)p, size);
1717 int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
1722 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
1725 for (i = UI_CURRENT; i < UI_SIZE; i++)
1726 p.uuid[i] = mdev->ldev ? cpu_to_be64(mdev->ldev->md.uuid[i]) : 0;
1728 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
1729 p.uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
1730 uuid_flags |= mdev->net_conf->want_lose ? 1 : 0;
1731 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
1732 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
1733 p.uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
1737 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_UUIDS,
1738 (struct p_header *)&p, sizeof(p));
1741 int drbd_send_uuids(struct drbd_conf *mdev)
1743 return _drbd_send_uuids(mdev, 0);
1746 int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
1748 return _drbd_send_uuids(mdev, 8);
1752 int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val)
1756 p.uuid = cpu_to_be64(val);
1758 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SYNC_UUID,
1759 (struct p_header *)&p, sizeof(p));
1762 int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
1765 sector_t d_size, u_size;
1769 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
1770 D_ASSERT(mdev->ldev->backing_bdev);
1771 d_size = drbd_get_max_capacity(mdev->ldev);
1772 u_size = mdev->ldev->dc.disk_size;
1773 q_order_type = drbd_queue_order_type(mdev);
1778 q_order_type = QUEUE_ORDERED_NONE;
1781 p.d_size = cpu_to_be64(d_size);
1782 p.u_size = cpu_to_be64(u_size);
1783 p.c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
1784 p.max_segment_size = cpu_to_be32(queue_max_segment_size(mdev->rq_queue));
1785 p.queue_order_type = cpu_to_be16(q_order_type);
1786 p.dds_flags = cpu_to_be16(flags);
1788 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SIZES,
1789 (struct p_header *)&p, sizeof(p));
1794 * drbd_send_state() - Sends the drbd state to the peer
1795 * @mdev: DRBD device.
1797 int drbd_send_state(struct drbd_conf *mdev)
1799 struct socket *sock;
1803 /* Grab state lock so we wont send state if we're in the middle
1804 * of a cluster wide state change on another thread */
1805 drbd_state_lock(mdev);
1807 mutex_lock(&mdev->data.mutex);
1809 p.state = cpu_to_be32(mdev->state.i); /* Within the send mutex */
1810 sock = mdev->data.socket;
1812 if (likely(sock != NULL)) {
1813 ok = _drbd_send_cmd(mdev, sock, P_STATE,
1814 (struct p_header *)&p, sizeof(p), 0);
1817 mutex_unlock(&mdev->data.mutex);
1819 drbd_state_unlock(mdev);
1823 int drbd_send_state_req(struct drbd_conf *mdev,
1824 union drbd_state mask, union drbd_state val)
1826 struct p_req_state p;
1828 p.mask = cpu_to_be32(mask.i);
1829 p.val = cpu_to_be32(val.i);
1831 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_STATE_CHG_REQ,
1832 (struct p_header *)&p, sizeof(p));
1835 int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode)
1837 struct p_req_state_reply p;
1839 p.retcode = cpu_to_be32(retcode);
1841 return drbd_send_cmd(mdev, USE_META_SOCKET, P_STATE_CHG_REPLY,
1842 (struct p_header *)&p, sizeof(p));
1845 int fill_bitmap_rle_bits(struct drbd_conf *mdev,
1846 struct p_compressed_bm *p,
1847 struct bm_xfer_ctx *c)
1849 struct bitstream bs;
1850 unsigned long plain_bits;
1857 /* may we use this feature? */
1858 if ((mdev->sync_conf.use_rle == 0) ||
1859 (mdev->agreed_pro_version < 90))
1862 if (c->bit_offset >= c->bm_bits)
1863 return 0; /* nothing to do. */
1865 /* use at most thus many bytes */
1866 bitstream_init(&bs, p->code, BM_PACKET_VLI_BYTES_MAX, 0);
1867 memset(p->code, 0, BM_PACKET_VLI_BYTES_MAX);
1868 /* plain bits covered in this code string */
1871 /* p->encoding & 0x80 stores whether the first run length is set.
1872 * bit offset is implicit.
1873 * start with toggle == 2 to be able to tell the first iteration */
1876 /* see how much plain bits we can stuff into one packet
1877 * using RLE and VLI. */
1879 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1880 : _drbd_bm_find_next(mdev, c->bit_offset);
1883 rl = tmp - c->bit_offset;
1885 if (toggle == 2) { /* first iteration */
1887 /* the first checked bit was set,
1888 * store start value, */
1889 DCBP_set_start(p, 1);
1890 /* but skip encoding of zero run length */
1894 DCBP_set_start(p, 0);
1897 /* paranoia: catch zero runlength.
1898 * can only happen if bitmap is modified while we scan it. */
1900 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1901 "t:%u bo:%lu\n", toggle, c->bit_offset);
1905 bits = vli_encode_bits(&bs, rl);
1906 if (bits == -ENOBUFS) /* buffer full */
1909 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
1915 c->bit_offset = tmp;
1916 } while (c->bit_offset < c->bm_bits);
1918 len = bs.cur.b - p->code + !!bs.cur.bit;
1920 if (plain_bits < (len << 3)) {
1921 /* incompressible with this method.
1922 * we need to rewind both word and bit position. */
1923 c->bit_offset -= plain_bits;
1924 bm_xfer_ctx_bit_to_word_offset(c);
1925 c->bit_offset = c->word_offset * BITS_PER_LONG;
1929 /* RLE + VLI was able to compress it just fine.
1930 * update c->word_offset. */
1931 bm_xfer_ctx_bit_to_word_offset(c);
1933 /* store pad_bits */
1934 DCBP_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
1939 enum { OK, FAILED, DONE }
1940 send_bitmap_rle_or_plain(struct drbd_conf *mdev,
1941 struct p_header *h, struct bm_xfer_ctx *c)
1943 struct p_compressed_bm *p = (void*)h;
1944 unsigned long num_words;
1948 len = fill_bitmap_rle_bits(mdev, p, c);
1954 DCBP_set_code(p, RLE_VLI_Bits);
1955 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_COMPRESSED_BITMAP, h,
1956 sizeof(*p) + len, 0);
1959 c->bytes[0] += sizeof(*p) + len;
1961 if (c->bit_offset >= c->bm_bits)
1964 /* was not compressible.
1965 * send a buffer full of plain text bits instead. */
1966 num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
1967 len = num_words * sizeof(long);
1969 drbd_bm_get_lel(mdev, c->word_offset, num_words, (unsigned long*)h->payload);
1970 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_BITMAP,
1971 h, sizeof(struct p_header) + len, 0);
1972 c->word_offset += num_words;
1973 c->bit_offset = c->word_offset * BITS_PER_LONG;
1976 c->bytes[1] += sizeof(struct p_header) + len;
1978 if (c->bit_offset > c->bm_bits)
1979 c->bit_offset = c->bm_bits;
1981 ok = ok ? ((len == 0) ? DONE : OK) : FAILED;
1984 INFO_bm_xfer_stats(mdev, "send", c);
1988 /* See the comment at receive_bitmap() */
1989 int _drbd_send_bitmap(struct drbd_conf *mdev)
1991 struct bm_xfer_ctx c;
1995 ERR_IF(!mdev->bitmap) return FALSE;
1997 /* maybe we should use some per thread scratch page,
1998 * and allocate that during initial device creation? */
1999 p = (struct p_header *) __get_free_page(GFP_NOIO);
2001 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
2005 if (get_ldev(mdev)) {
2006 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
2007 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
2008 drbd_bm_set_all(mdev);
2009 if (drbd_bm_write(mdev)) {
2010 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
2011 * but otherwise process as per normal - need to tell other
2012 * side that a full resync is required! */
2013 dev_err(DEV, "Failed to write bitmap to disk!\n");
2015 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
2022 c = (struct bm_xfer_ctx) {
2023 .bm_bits = drbd_bm_bits(mdev),
2024 .bm_words = drbd_bm_words(mdev),
2028 ret = send_bitmap_rle_or_plain(mdev, p, &c);
2029 } while (ret == OK);
2031 free_page((unsigned long) p);
2032 return (ret == DONE);
2035 int drbd_send_bitmap(struct drbd_conf *mdev)
2039 if (!drbd_get_data_sock(mdev))
2041 err = !_drbd_send_bitmap(mdev);
2042 drbd_put_data_sock(mdev);
2046 int drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, u32 set_size)
2049 struct p_barrier_ack p;
2051 p.barrier = barrier_nr;
2052 p.set_size = cpu_to_be32(set_size);
2054 if (mdev->state.conn < C_CONNECTED)
2056 ok = drbd_send_cmd(mdev, USE_META_SOCKET, P_BARRIER_ACK,
2057 (struct p_header *)&p, sizeof(p));
2062 * _drbd_send_ack() - Sends an ack packet
2063 * @mdev: DRBD device.
2064 * @cmd: Packet command code.
2065 * @sector: sector, needs to be in big endian byte order
2066 * @blksize: size in byte, needs to be in big endian byte order
2067 * @block_id: Id, big endian byte order
2069 static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packets cmd,
2075 struct p_block_ack p;
2078 p.block_id = block_id;
2079 p.blksize = blksize;
2080 p.seq_num = cpu_to_be32(atomic_add_return(1, &mdev->packet_seq));
2082 if (!mdev->meta.socket || mdev->state.conn < C_CONNECTED)
2084 ok = drbd_send_cmd(mdev, USE_META_SOCKET, cmd,
2085 (struct p_header *)&p, sizeof(p));
2089 int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packets cmd,
2092 const int header_size = sizeof(struct p_data)
2093 - sizeof(struct p_header);
2094 int data_size = ((struct p_header *)dp)->length - header_size;
2096 return _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
2100 int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packets cmd,
2101 struct p_block_req *rp)
2103 return _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
2107 * drbd_send_ack() - Sends an ack packet
2108 * @mdev: DRBD device.
2109 * @cmd: Packet command code.
2112 int drbd_send_ack(struct drbd_conf *mdev,
2113 enum drbd_packets cmd, struct drbd_epoch_entry *e)
2115 return _drbd_send_ack(mdev, cmd,
2116 cpu_to_be64(e->sector),
2117 cpu_to_be32(e->size),
2121 /* This function misuses the block_id field to signal if the blocks
2122 * are is sync or not. */
2123 int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packets cmd,
2124 sector_t sector, int blksize, u64 block_id)
2126 return _drbd_send_ack(mdev, cmd,
2127 cpu_to_be64(sector),
2128 cpu_to_be32(blksize),
2129 cpu_to_be64(block_id));
2132 int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
2133 sector_t sector, int size, u64 block_id)
2136 struct p_block_req p;
2138 p.sector = cpu_to_be64(sector);
2139 p.block_id = block_id;
2140 p.blksize = cpu_to_be32(size);
2142 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, cmd,
2143 (struct p_header *)&p, sizeof(p));
2147 int drbd_send_drequest_csum(struct drbd_conf *mdev,
2148 sector_t sector, int size,
2149 void *digest, int digest_size,
2150 enum drbd_packets cmd)
2153 struct p_block_req p;
2155 p.sector = cpu_to_be64(sector);
2156 p.block_id = BE_DRBD_MAGIC + 0xbeef;
2157 p.blksize = cpu_to_be32(size);
2159 p.head.magic = BE_DRBD_MAGIC;
2160 p.head.command = cpu_to_be16(cmd);
2161 p.head.length = cpu_to_be16(sizeof(p) - sizeof(struct p_header) + digest_size);
2163 mutex_lock(&mdev->data.mutex);
2165 ok = (sizeof(p) == drbd_send(mdev, mdev->data.socket, &p, sizeof(p), 0));
2166 ok = ok && (digest_size == drbd_send(mdev, mdev->data.socket, digest, digest_size, 0));
2168 mutex_unlock(&mdev->data.mutex);
2173 int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
2176 struct p_block_req p;
2178 p.sector = cpu_to_be64(sector);
2179 p.block_id = BE_DRBD_MAGIC + 0xbabe;
2180 p.blksize = cpu_to_be32(size);
2182 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_OV_REQUEST,
2183 (struct p_header *)&p, sizeof(p));
2187 static int drbd_send_delay_probe(struct drbd_conf *mdev, struct drbd_socket *ds)
2189 struct p_delay_probe dp;
2193 mutex_lock(&ds->mutex);
2194 if (likely(ds->socket)) {
2195 do_gettimeofday(&now);
2196 offset = now.tv_usec - mdev->dps_time.tv_usec +
2197 (now.tv_sec - mdev->dps_time.tv_sec) * 1000000;
2198 dp.seq_num = cpu_to_be32(mdev->delay_seq);
2199 dp.offset = cpu_to_be32(offset);
2201 ok = _drbd_send_cmd(mdev, ds->socket, P_DELAY_PROBE,
2202 (struct p_header *)&dp, sizeof(dp), 0);
2204 mutex_unlock(&ds->mutex);
2209 static int drbd_send_delay_probes(struct drbd_conf *mdev)
2214 do_gettimeofday(&mdev->dps_time);
2215 ok = drbd_send_delay_probe(mdev, &mdev->meta);
2216 ok = ok && drbd_send_delay_probe(mdev, &mdev->data);
2218 mdev->dp_volume_last = mdev->send_cnt;
2219 mod_timer(&mdev->delay_probe_timer, jiffies + mdev->sync_conf.dp_interval * HZ / 10);
2224 /* called on sndtimeo
2225 * returns FALSE if we should retry,
2226 * TRUE if we think connection is dead
2228 static int we_should_drop_the_connection(struct drbd_conf *mdev, struct socket *sock)
2231 /* long elapsed = (long)(jiffies - mdev->last_received); */
2233 drop_it = mdev->meta.socket == sock
2234 || !mdev->asender.task
2235 || get_t_state(&mdev->asender) != Running
2236 || mdev->state.conn < C_CONNECTED;
2241 drop_it = !--mdev->ko_count;
2243 dev_err(DEV, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
2244 current->comm, current->pid, mdev->ko_count);
2248 return drop_it; /* && (mdev->state == R_PRIMARY) */;
2251 /* The idea of sendpage seems to be to put some kind of reference
2252 * to the page into the skb, and to hand it over to the NIC. In
2253 * this process get_page() gets called.
2255 * As soon as the page was really sent over the network put_page()
2256 * gets called by some part of the network layer. [ NIC driver? ]
2258 * [ get_page() / put_page() increment/decrement the count. If count
2259 * reaches 0 the page will be freed. ]
2261 * This works nicely with pages from FSs.
2262 * But this means that in protocol A we might signal IO completion too early!
2264 * In order not to corrupt data during a resync we must make sure
2265 * that we do not reuse our own buffer pages (EEs) to early, therefore
2266 * we have the net_ee list.
2268 * XFS seems to have problems, still, it submits pages with page_count == 0!
2269 * As a workaround, we disable sendpage on pages
2270 * with page_count == 0 or PageSlab.
2272 static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
2273 int offset, size_t size, unsigned msg_flags)
2275 int sent = drbd_send(mdev, mdev->data.socket, kmap(page) + offset, size, msg_flags);
2278 mdev->send_cnt += size>>9;
2279 return sent == size;
2282 static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
2283 int offset, size_t size, unsigned msg_flags)
2285 mm_segment_t oldfs = get_fs();
2289 /* e.g. XFS meta- & log-data is in slab pages, which have a
2290 * page_count of 0 and/or have PageSlab() set.
2291 * we cannot use send_page for those, as that does get_page();
2292 * put_page(); and would cause either a VM_BUG directly, or
2293 * __page_cache_release a page that would actually still be referenced
2294 * by someone, leading to some obscure delayed Oops somewhere else. */
2295 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
2296 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
2298 msg_flags |= MSG_NOSIGNAL;
2299 drbd_update_congested(mdev);
2302 sent = mdev->data.socket->ops->sendpage(mdev->data.socket, page,
2305 if (sent == -EAGAIN) {
2306 if (we_should_drop_the_connection(mdev,
2313 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
2314 __func__, (int)size, len, sent);
2319 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
2321 clear_bit(NET_CONGESTED, &mdev->flags);
2325 mdev->send_cnt += size>>9;
2329 static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
2331 struct bio_vec *bvec;
2333 /* hint all but last page with MSG_MORE */
2334 __bio_for_each_segment(bvec, bio, i, 0) {
2335 if (!_drbd_no_send_page(mdev, bvec->bv_page,
2336 bvec->bv_offset, bvec->bv_len,
2337 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
2343 static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
2345 struct bio_vec *bvec;
2347 /* hint all but last page with MSG_MORE */
2348 __bio_for_each_segment(bvec, bio, i, 0) {
2349 if (!_drbd_send_page(mdev, bvec->bv_page,
2350 bvec->bv_offset, bvec->bv_len,
2351 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
2357 static int _drbd_send_zc_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e)
2359 struct page *page = e->pages;
2360 unsigned len = e->size;
2361 /* hint all but last page with MSG_MORE */
2362 page_chain_for_each(page) {
2363 unsigned l = min_t(unsigned, len, PAGE_SIZE);
2364 if (!_drbd_send_page(mdev, page, 0, l,
2365 page_chain_next(page) ? MSG_MORE : 0))
2372 static void consider_delay_probes(struct drbd_conf *mdev)
2374 if (mdev->state.conn != C_SYNC_SOURCE || mdev->agreed_pro_version < 93)
2377 if (mdev->dp_volume_last + mdev->sync_conf.dp_volume * 2 < mdev->send_cnt)
2378 drbd_send_delay_probes(mdev);
2381 static int w_delay_probes(struct drbd_conf *mdev, struct drbd_work *w, int cancel)
2383 if (!cancel && mdev->state.conn == C_SYNC_SOURCE)
2384 drbd_send_delay_probes(mdev);
2389 static void delay_probe_timer_fn(unsigned long data)
2391 struct drbd_conf *mdev = (struct drbd_conf *) data;
2393 if (list_empty(&mdev->delay_probe_work.list))
2394 drbd_queue_work(&mdev->data.work, &mdev->delay_probe_work);
2397 /* Used to send write requests
2398 * R_PRIMARY -> Peer (P_DATA)
2400 int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
2404 unsigned int dp_flags = 0;
2408 if (!drbd_get_data_sock(mdev))
2411 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2412 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2414 p.head.magic = BE_DRBD_MAGIC;
2415 p.head.command = cpu_to_be16(P_DATA);
2417 cpu_to_be16(sizeof(p) - sizeof(struct p_header) + dgs + req->size);
2419 p.sector = cpu_to_be64(req->sector);
2420 p.block_id = (unsigned long)req;
2421 p.seq_num = cpu_to_be32(req->seq_num =
2422 atomic_add_return(1, &mdev->packet_seq));
2425 /* NOTE: no need to check if barriers supported here as we would
2426 * not pass the test in make_request_common in that case
2428 if (bio_rw_flagged(req->master_bio, BIO_RW_BARRIER)) {
2429 dev_err(DEV, "ASSERT FAILED would have set DP_HARDBARRIER\n");
2430 /* dp_flags |= DP_HARDBARRIER; */
2432 if (bio_rw_flagged(req->master_bio, BIO_RW_SYNCIO))
2433 dp_flags |= DP_RW_SYNC;
2434 /* for now handle SYNCIO and UNPLUG
2435 * as if they still were one and the same flag */
2436 if (bio_rw_flagged(req->master_bio, BIO_RW_UNPLUG))
2437 dp_flags |= DP_RW_SYNC;
2438 if (mdev->state.conn >= C_SYNC_SOURCE &&
2439 mdev->state.conn <= C_PAUSED_SYNC_T)
2440 dp_flags |= DP_MAY_SET_IN_SYNC;
2442 p.dp_flags = cpu_to_be32(dp_flags);
2443 set_bit(UNPLUG_REMOTE, &mdev->flags);
2445 drbd_send(mdev, mdev->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0));
2447 dgb = mdev->int_dig_out;
2448 drbd_csum_bio(mdev, mdev->integrity_w_tfm, req->master_bio, dgb);
2449 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
2452 if (mdev->net_conf->wire_protocol == DRBD_PROT_A)
2453 ok = _drbd_send_bio(mdev, req->master_bio);
2455 ok = _drbd_send_zc_bio(mdev, req->master_bio);
2458 drbd_put_data_sock(mdev);
2461 consider_delay_probes(mdev);
2466 /* answer packet, used to send data back for read requests:
2467 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
2468 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
2470 int drbd_send_block(struct drbd_conf *mdev, enum drbd_packets cmd,
2471 struct drbd_epoch_entry *e)
2478 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2479 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2481 p.head.magic = BE_DRBD_MAGIC;
2482 p.head.command = cpu_to_be16(cmd);
2484 cpu_to_be16(sizeof(p) - sizeof(struct p_header) + dgs + e->size);
2486 p.sector = cpu_to_be64(e->sector);
2487 p.block_id = e->block_id;
2488 /* p.seq_num = 0; No sequence numbers here.. */
2490 /* Only called by our kernel thread.
2491 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
2492 * in response to admin command or module unload.
2494 if (!drbd_get_data_sock(mdev))
2497 ok = sizeof(p) == drbd_send(mdev, mdev->data.socket, &p,
2498 sizeof(p), dgs ? MSG_MORE : 0);
2500 dgb = mdev->int_dig_out;
2501 drbd_csum_ee(mdev, mdev->integrity_w_tfm, e, dgb);
2502 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
2505 ok = _drbd_send_zc_ee(mdev, e);
2507 drbd_put_data_sock(mdev);
2510 consider_delay_probes(mdev);
2516 drbd_send distinguishes two cases:
2518 Packets sent via the data socket "sock"
2519 and packets sent via the meta data socket "msock"
2522 -----------------+-------------------------+------------------------------
2523 timeout conf.timeout / 2 conf.timeout / 2
2524 timeout action send a ping via msock Abort communication
2525 and close all sockets
2529 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
2531 int drbd_send(struct drbd_conf *mdev, struct socket *sock,
2532 void *buf, size_t size, unsigned msg_flags)
2541 /* THINK if (signal_pending) return ... ? */
2546 msg.msg_name = NULL;
2547 msg.msg_namelen = 0;
2548 msg.msg_control = NULL;
2549 msg.msg_controllen = 0;
2550 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
2552 if (sock == mdev->data.socket) {
2553 mdev->ko_count = mdev->net_conf->ko_count;
2554 drbd_update_congested(mdev);
2558 * tcp_sendmsg does _not_ use its size parameter at all ?
2560 * -EAGAIN on timeout, -EINTR on signal.
2563 * do we need to block DRBD_SIG if sock == &meta.socket ??
2564 * otherwise wake_asender() might interrupt some send_*Ack !
2566 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
2567 if (rv == -EAGAIN) {
2568 if (we_should_drop_the_connection(mdev, sock))
2575 flush_signals(current);
2583 } while (sent < size);
2585 if (sock == mdev->data.socket)
2586 clear_bit(NET_CONGESTED, &mdev->flags);
2589 if (rv != -EAGAIN) {
2590 dev_err(DEV, "%s_sendmsg returned %d\n",
2591 sock == mdev->meta.socket ? "msock" : "sock",
2593 drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE));
2595 drbd_force_state(mdev, NS(conn, C_TIMEOUT));
2601 static int drbd_open(struct block_device *bdev, fmode_t mode)
2603 struct drbd_conf *mdev = bdev->bd_disk->private_data;
2604 unsigned long flags;
2607 spin_lock_irqsave(&mdev->req_lock, flags);
2608 /* to have a stable mdev->state.role
2609 * and no race with updating open_cnt */
2611 if (mdev->state.role != R_PRIMARY) {
2612 if (mode & FMODE_WRITE)
2614 else if (!allow_oos)
2620 spin_unlock_irqrestore(&mdev->req_lock, flags);
2625 static int drbd_release(struct gendisk *gd, fmode_t mode)
2627 struct drbd_conf *mdev = gd->private_data;
2632 static void drbd_unplug_fn(struct request_queue *q)
2634 struct drbd_conf *mdev = q->queuedata;
2637 spin_lock_irq(q->queue_lock);
2639 spin_unlock_irq(q->queue_lock);
2641 /* only if connected */
2642 spin_lock_irq(&mdev->req_lock);
2643 if (mdev->state.pdsk >= D_INCONSISTENT && mdev->state.conn >= C_CONNECTED) {
2644 D_ASSERT(mdev->state.role == R_PRIMARY);
2645 if (test_and_clear_bit(UNPLUG_REMOTE, &mdev->flags)) {
2646 /* add to the data.work queue,
2647 * unless already queued.
2648 * XXX this might be a good addition to drbd_queue_work
2649 * anyways, to detect "double queuing" ... */
2650 if (list_empty(&mdev->unplug_work.list))
2651 drbd_queue_work(&mdev->data.work,
2652 &mdev->unplug_work);
2655 spin_unlock_irq(&mdev->req_lock);
2657 if (mdev->state.disk >= D_INCONSISTENT)
2661 static void drbd_set_defaults(struct drbd_conf *mdev)
2663 /* This way we get a compile error when sync_conf grows,
2664 and we forgot to initialize it here */
2665 mdev->sync_conf = (struct syncer_conf) {
2666 /* .rate = */ DRBD_RATE_DEF,
2667 /* .after = */ DRBD_AFTER_DEF,
2668 /* .al_extents = */ DRBD_AL_EXTENTS_DEF,
2669 /* .dp_volume = */ DRBD_DP_VOLUME_DEF,
2670 /* .dp_interval = */ DRBD_DP_INTERVAL_DEF,
2671 /* .throttle_th = */ DRBD_RS_THROTTLE_TH_DEF,
2672 /* .hold_off_th = */ DRBD_RS_HOLD_OFF_TH_DEF,
2673 /* .verify_alg = */ {}, 0,
2674 /* .cpu_mask = */ {}, 0,
2675 /* .csums_alg = */ {}, 0,
2679 /* Have to use that way, because the layout differs between
2680 big endian and little endian */
2681 mdev->state = (union drbd_state) {
2682 { .role = R_SECONDARY,
2684 .conn = C_STANDALONE,
2691 void drbd_init_set_defaults(struct drbd_conf *mdev)
2693 /* the memset(,0,) did most of this.
2694 * note: only assignments, no allocation in here */
2696 drbd_set_defaults(mdev);
2698 /* for now, we do NOT yet support it,
2699 * even though we start some framework
2700 * to eventually support barriers */
2701 set_bit(NO_BARRIER_SUPP, &mdev->flags);
2703 atomic_set(&mdev->ap_bio_cnt, 0);
2704 atomic_set(&mdev->ap_pending_cnt, 0);
2705 atomic_set(&mdev->rs_pending_cnt, 0);
2706 atomic_set(&mdev->unacked_cnt, 0);
2707 atomic_set(&mdev->local_cnt, 0);
2708 atomic_set(&mdev->net_cnt, 0);
2709 atomic_set(&mdev->packet_seq, 0);
2710 atomic_set(&mdev->pp_in_use, 0);
2712 mutex_init(&mdev->md_io_mutex);
2713 mutex_init(&mdev->data.mutex);
2714 mutex_init(&mdev->meta.mutex);
2715 sema_init(&mdev->data.work.s, 0);
2716 sema_init(&mdev->meta.work.s, 0);
2717 mutex_init(&mdev->state_mutex);
2719 spin_lock_init(&mdev->data.work.q_lock);
2720 spin_lock_init(&mdev->meta.work.q_lock);
2722 spin_lock_init(&mdev->al_lock);
2723 spin_lock_init(&mdev->req_lock);
2724 spin_lock_init(&mdev->peer_seq_lock);
2725 spin_lock_init(&mdev->epoch_lock);
2727 INIT_LIST_HEAD(&mdev->active_ee);
2728 INIT_LIST_HEAD(&mdev->sync_ee);
2729 INIT_LIST_HEAD(&mdev->done_ee);
2730 INIT_LIST_HEAD(&mdev->read_ee);
2731 INIT_LIST_HEAD(&mdev->net_ee);
2732 INIT_LIST_HEAD(&mdev->resync_reads);
2733 INIT_LIST_HEAD(&mdev->data.work.q);
2734 INIT_LIST_HEAD(&mdev->meta.work.q);
2735 INIT_LIST_HEAD(&mdev->resync_work.list);
2736 INIT_LIST_HEAD(&mdev->unplug_work.list);
2737 INIT_LIST_HEAD(&mdev->md_sync_work.list);
2738 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
2739 INIT_LIST_HEAD(&mdev->delay_probes);
2740 INIT_LIST_HEAD(&mdev->delay_probe_work.list);
2742 mdev->resync_work.cb = w_resync_inactive;
2743 mdev->unplug_work.cb = w_send_write_hint;
2744 mdev->md_sync_work.cb = w_md_sync;
2745 mdev->bm_io_work.w.cb = w_bitmap_io;
2746 mdev->delay_probe_work.cb = w_delay_probes;
2747 init_timer(&mdev->resync_timer);
2748 init_timer(&mdev->md_sync_timer);
2749 init_timer(&mdev->delay_probe_timer);
2750 mdev->resync_timer.function = resync_timer_fn;
2751 mdev->resync_timer.data = (unsigned long) mdev;
2752 mdev->md_sync_timer.function = md_sync_timer_fn;
2753 mdev->md_sync_timer.data = (unsigned long) mdev;
2754 mdev->delay_probe_timer.function = delay_probe_timer_fn;
2755 mdev->delay_probe_timer.data = (unsigned long) mdev;
2758 init_waitqueue_head(&mdev->misc_wait);
2759 init_waitqueue_head(&mdev->state_wait);
2760 init_waitqueue_head(&mdev->ee_wait);
2761 init_waitqueue_head(&mdev->al_wait);
2762 init_waitqueue_head(&mdev->seq_wait);
2764 drbd_thread_init(mdev, &mdev->receiver, drbdd_init);
2765 drbd_thread_init(mdev, &mdev->worker, drbd_worker);
2766 drbd_thread_init(mdev, &mdev->asender, drbd_asender);
2768 mdev->agreed_pro_version = PRO_VERSION_MAX;
2769 mdev->write_ordering = WO_bio_barrier;
2770 mdev->resync_wenr = LC_FREE;
2773 void drbd_mdev_cleanup(struct drbd_conf *mdev)
2775 if (mdev->receiver.t_state != None)
2776 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
2777 mdev->receiver.t_state);
2779 /* no need to lock it, I'm the only thread alive */
2780 if (atomic_read(&mdev->current_epoch->epoch_size) != 0)
2781 dev_err(DEV, "epoch_size:%d\n", atomic_read(&mdev->current_epoch->epoch_size));
2792 mdev->rs_mark_left =
2793 mdev->rs_mark_time = 0;
2794 D_ASSERT(mdev->net_conf == NULL);
2796 drbd_set_my_capacity(mdev, 0);
2798 /* maybe never allocated. */
2799 drbd_bm_resize(mdev, 0, 1);
2800 drbd_bm_cleanup(mdev);
2803 drbd_free_resources(mdev);
2806 * currently we drbd_init_ee only on module load, so
2807 * we may do drbd_release_ee only on module unload!
2809 D_ASSERT(list_empty(&mdev->active_ee));
2810 D_ASSERT(list_empty(&mdev->sync_ee));
2811 D_ASSERT(list_empty(&mdev->done_ee));
2812 D_ASSERT(list_empty(&mdev->read_ee));
2813 D_ASSERT(list_empty(&mdev->net_ee));
2814 D_ASSERT(list_empty(&mdev->resync_reads));
2815 D_ASSERT(list_empty(&mdev->data.work.q));
2816 D_ASSERT(list_empty(&mdev->meta.work.q));
2817 D_ASSERT(list_empty(&mdev->resync_work.list));
2818 D_ASSERT(list_empty(&mdev->unplug_work.list));
2823 static void drbd_destroy_mempools(void)
2827 while (drbd_pp_pool) {
2828 page = drbd_pp_pool;
2829 drbd_pp_pool = (struct page *)page_private(page);
2834 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
2836 if (drbd_ee_mempool)
2837 mempool_destroy(drbd_ee_mempool);
2838 if (drbd_request_mempool)
2839 mempool_destroy(drbd_request_mempool);
2841 kmem_cache_destroy(drbd_ee_cache);
2842 if (drbd_request_cache)
2843 kmem_cache_destroy(drbd_request_cache);
2844 if (drbd_bm_ext_cache)
2845 kmem_cache_destroy(drbd_bm_ext_cache);
2846 if (drbd_al_ext_cache)
2847 kmem_cache_destroy(drbd_al_ext_cache);
2849 drbd_ee_mempool = NULL;
2850 drbd_request_mempool = NULL;
2851 drbd_ee_cache = NULL;
2852 drbd_request_cache = NULL;
2853 drbd_bm_ext_cache = NULL;
2854 drbd_al_ext_cache = NULL;
2859 static int drbd_create_mempools(void)
2862 const int number = (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE) * minor_count;
2865 /* prepare our caches and mempools */
2866 drbd_request_mempool = NULL;
2867 drbd_ee_cache = NULL;
2868 drbd_request_cache = NULL;
2869 drbd_bm_ext_cache = NULL;
2870 drbd_al_ext_cache = NULL;
2871 drbd_pp_pool = NULL;
2874 drbd_request_cache = kmem_cache_create(
2875 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2876 if (drbd_request_cache == NULL)
2879 drbd_ee_cache = kmem_cache_create(
2880 "drbd_ee", sizeof(struct drbd_epoch_entry), 0, 0, NULL);
2881 if (drbd_ee_cache == NULL)
2884 drbd_bm_ext_cache = kmem_cache_create(
2885 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2886 if (drbd_bm_ext_cache == NULL)
2889 drbd_al_ext_cache = kmem_cache_create(
2890 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2891 if (drbd_al_ext_cache == NULL)
2895 drbd_request_mempool = mempool_create(number,
2896 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2897 if (drbd_request_mempool == NULL)
2900 drbd_ee_mempool = mempool_create(number,
2901 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2902 if (drbd_request_mempool == NULL)
2905 /* drbd's page pool */
2906 spin_lock_init(&drbd_pp_lock);
2908 for (i = 0; i < number; i++) {
2909 page = alloc_page(GFP_HIGHUSER);
2912 set_page_private(page, (unsigned long)drbd_pp_pool);
2913 drbd_pp_pool = page;
2915 drbd_pp_vacant = number;
2920 drbd_destroy_mempools(); /* in case we allocated some */
2924 static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2927 /* just so we have it. you never know what interesting things we
2928 * might want to do here some day...
2934 static struct notifier_block drbd_notifier = {
2935 .notifier_call = drbd_notify_sys,
2938 static void drbd_release_ee_lists(struct drbd_conf *mdev)
2942 rr = drbd_release_ee(mdev, &mdev->active_ee);
2944 dev_err(DEV, "%d EEs in active list found!\n", rr);
2946 rr = drbd_release_ee(mdev, &mdev->sync_ee);
2948 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2950 rr = drbd_release_ee(mdev, &mdev->read_ee);
2952 dev_err(DEV, "%d EEs in read list found!\n", rr);
2954 rr = drbd_release_ee(mdev, &mdev->done_ee);
2956 dev_err(DEV, "%d EEs in done list found!\n", rr);
2958 rr = drbd_release_ee(mdev, &mdev->net_ee);
2960 dev_err(DEV, "%d EEs in net list found!\n", rr);
2963 /* caution. no locking.
2964 * currently only used from module cleanup code. */
2965 static void drbd_delete_device(unsigned int minor)
2967 struct drbd_conf *mdev = minor_to_mdev(minor);
2972 /* paranoia asserts */
2973 if (mdev->open_cnt != 0)
2974 dev_err(DEV, "open_cnt = %d in %s:%u", mdev->open_cnt,
2975 __FILE__ , __LINE__);
2977 ERR_IF (!list_empty(&mdev->data.work.q)) {
2978 struct list_head *lp;
2979 list_for_each(lp, &mdev->data.work.q) {
2980 dev_err(DEV, "lp = %p\n", lp);
2983 /* end paranoia asserts */
2985 del_gendisk(mdev->vdisk);
2987 /* cleanup stuff that may have been allocated during
2988 * device (re-)configuration or state changes */
2990 if (mdev->this_bdev)
2991 bdput(mdev->this_bdev);
2993 drbd_free_resources(mdev);
2995 drbd_release_ee_lists(mdev);
2997 /* should be free'd on disconnect? */
2998 kfree(mdev->ee_hash);
3000 mdev->ee_hash_s = 0;
3001 mdev->ee_hash = NULL;
3004 lc_destroy(mdev->act_log);
3005 lc_destroy(mdev->resync);
3007 kfree(mdev->p_uuid);
3008 /* mdev->p_uuid = NULL; */
3010 kfree(mdev->int_dig_out);
3011 kfree(mdev->int_dig_in);
3012 kfree(mdev->int_dig_vv);
3014 /* cleanup the rest that has been
3015 * allocated from drbd_new_device
3016 * and actually free the mdev itself */
3017 drbd_free_mdev(mdev);
3020 static void drbd_cleanup(void)
3024 unregister_reboot_notifier(&drbd_notifier);
3030 remove_proc_entry("drbd", NULL);
3033 drbd_delete_device(i);
3034 drbd_destroy_mempools();
3039 unregister_blkdev(DRBD_MAJOR, "drbd");
3041 printk(KERN_INFO "drbd: module cleanup done.\n");
3045 * drbd_congested() - Callback for pdflush
3046 * @congested_data: User data
3047 * @bdi_bits: Bits pdflush is currently interested in
3049 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
3051 static int drbd_congested(void *congested_data, int bdi_bits)
3053 struct drbd_conf *mdev = congested_data;
3054 struct request_queue *q;
3058 if (!__inc_ap_bio_cond(mdev)) {
3059 /* DRBD has frozen IO */
3065 if (get_ldev(mdev)) {
3066 q = bdev_get_queue(mdev->ldev->backing_bdev);
3067 r = bdi_congested(&q->backing_dev_info, bdi_bits);
3073 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->flags)) {
3074 r |= (1 << BDI_async_congested);
3075 reason = reason == 'b' ? 'a' : 'n';
3079 mdev->congestion_reason = reason;
3083 struct drbd_conf *drbd_new_device(unsigned int minor)
3085 struct drbd_conf *mdev;
3086 struct gendisk *disk;
3087 struct request_queue *q;
3089 /* GFP_KERNEL, we are outside of all write-out paths */
3090 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
3093 if (!zalloc_cpumask_var(&mdev->cpu_mask, GFP_KERNEL))
3094 goto out_no_cpumask;
3096 mdev->minor = minor;
3098 drbd_init_set_defaults(mdev);
3100 q = blk_alloc_queue(GFP_KERNEL);
3104 q->queuedata = mdev;
3106 disk = alloc_disk(1);
3111 set_disk_ro(disk, TRUE);
3114 disk->major = DRBD_MAJOR;
3115 disk->first_minor = minor;
3116 disk->fops = &drbd_ops;
3117 sprintf(disk->disk_name, "drbd%d", minor);
3118 disk->private_data = mdev;
3120 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
3121 /* we have no partitions. we contain only ourselves. */
3122 mdev->this_bdev->bd_contains = mdev->this_bdev;
3124 q->backing_dev_info.congested_fn = drbd_congested;
3125 q->backing_dev_info.congested_data = mdev;
3127 blk_queue_make_request(q, drbd_make_request_26);
3128 blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
3129 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
3130 blk_queue_merge_bvec(q, drbd_merge_bvec);
3131 q->queue_lock = &mdev->req_lock; /* needed since we use */
3132 /* plugging on a queue, that actually has no requests! */
3133 q->unplug_fn = drbd_unplug_fn;
3135 mdev->md_io_page = alloc_page(GFP_KERNEL);
3136 if (!mdev->md_io_page)
3137 goto out_no_io_page;
3139 if (drbd_bm_init(mdev))
3141 /* no need to lock access, we are still initializing this minor device. */
3145 mdev->app_reads_hash = kzalloc(APP_R_HSIZE*sizeof(void *), GFP_KERNEL);
3146 if (!mdev->app_reads_hash)
3147 goto out_no_app_reads;
3149 mdev->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
3150 if (!mdev->current_epoch)
3153 INIT_LIST_HEAD(&mdev->current_epoch->list);
3158 /* out_whatever_else:
3159 kfree(mdev->current_epoch); */
3161 kfree(mdev->app_reads_hash);
3165 drbd_bm_cleanup(mdev);
3167 __free_page(mdev->md_io_page);
3171 blk_cleanup_queue(q);
3173 free_cpumask_var(mdev->cpu_mask);
3179 /* counterpart of drbd_new_device.
3180 * last part of drbd_delete_device. */
3181 void drbd_free_mdev(struct drbd_conf *mdev)
3183 kfree(mdev->current_epoch);
3184 kfree(mdev->app_reads_hash);
3186 if (mdev->bitmap) /* should no longer be there. */
3187 drbd_bm_cleanup(mdev);
3188 __free_page(mdev->md_io_page);
3189 put_disk(mdev->vdisk);
3190 blk_cleanup_queue(mdev->rq_queue);
3191 free_cpumask_var(mdev->cpu_mask);
3196 int __init drbd_init(void)
3200 if (sizeof(struct p_handshake) != 80) {
3202 "drbd: never change the size or layout "
3203 "of the HandShake packet.\n");
3207 if (1 > minor_count || minor_count > 255) {
3209 "drbd: invalid minor_count (%d)\n", minor_count);
3217 err = drbd_nl_init();
3221 err = register_blkdev(DRBD_MAJOR, "drbd");
3224 "drbd: unable to register block device major %d\n",
3229 register_reboot_notifier(&drbd_notifier);
3232 * allocate all necessary structs
3236 init_waitqueue_head(&drbd_pp_wait);
3238 drbd_proc = NULL; /* play safe for drbd_cleanup */
3239 minor_table = kzalloc(sizeof(struct drbd_conf *)*minor_count,
3244 err = drbd_create_mempools();
3248 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
3250 printk(KERN_ERR "drbd: unable to register proc file\n");
3254 rwlock_init(&global_state_lock);
3256 printk(KERN_INFO "drbd: initialized. "
3257 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
3258 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
3259 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
3260 printk(KERN_INFO "drbd: registered as block device major %d\n",
3262 printk(KERN_INFO "drbd: minor_table @ 0x%p\n", minor_table);
3264 return 0; /* Success! */
3269 /* currently always the case */
3270 printk(KERN_ERR "drbd: ran out of memory\n");
3272 printk(KERN_ERR "drbd: initialization failure\n");
3276 void drbd_free_bc(struct drbd_backing_dev *ldev)
3281 bd_release(ldev->backing_bdev);
3282 bd_release(ldev->md_bdev);
3284 fput(ldev->lo_file);
3285 fput(ldev->md_file);
3290 void drbd_free_sock(struct drbd_conf *mdev)
3292 if (mdev->data.socket) {
3293 mutex_lock(&mdev->data.mutex);
3294 kernel_sock_shutdown(mdev->data.socket, SHUT_RDWR);
3295 sock_release(mdev->data.socket);
3296 mdev->data.socket = NULL;
3297 mutex_unlock(&mdev->data.mutex);
3299 if (mdev->meta.socket) {
3300 mutex_lock(&mdev->meta.mutex);
3301 kernel_sock_shutdown(mdev->meta.socket, SHUT_RDWR);
3302 sock_release(mdev->meta.socket);
3303 mdev->meta.socket = NULL;
3304 mutex_unlock(&mdev->meta.mutex);
3309 void drbd_free_resources(struct drbd_conf *mdev)
3311 crypto_free_hash(mdev->csums_tfm);
3312 mdev->csums_tfm = NULL;
3313 crypto_free_hash(mdev->verify_tfm);
3314 mdev->verify_tfm = NULL;
3315 crypto_free_hash(mdev->cram_hmac_tfm);
3316 mdev->cram_hmac_tfm = NULL;
3317 crypto_free_hash(mdev->integrity_w_tfm);
3318 mdev->integrity_w_tfm = NULL;
3319 crypto_free_hash(mdev->integrity_r_tfm);
3320 mdev->integrity_r_tfm = NULL;
3322 drbd_free_sock(mdev);
3325 drbd_free_bc(mdev->ldev);
3326 mdev->ldev = NULL;);
3329 /* meta data management */
3331 struct meta_data_on_disk {
3332 u64 la_size; /* last agreed size. */
3333 u64 uuid[UI_SIZE]; /* UUIDs. */
3336 u32 flags; /* MDF */
3339 u32 al_offset; /* offset to this block */
3340 u32 al_nr_extents; /* important for restoring the AL */
3341 /* `-- act_log->nr_elements <-- sync_conf.al_extents */
3342 u32 bm_offset; /* offset to the bitmap, from here */
3343 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
3344 u32 reserved_u32[4];
3349 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
3350 * @mdev: DRBD device.
3352 void drbd_md_sync(struct drbd_conf *mdev)
3354 struct meta_data_on_disk *buffer;
3358 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
3360 del_timer(&mdev->md_sync_timer);
3362 /* We use here D_FAILED and not D_ATTACHING because we try to write
3363 * metadata even if we detach due to a disk failure! */
3364 if (!get_ldev_if_state(mdev, D_FAILED))
3367 mutex_lock(&mdev->md_io_mutex);
3368 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3369 memset(buffer, 0, 512);
3371 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
3372 for (i = UI_CURRENT; i < UI_SIZE; i++)
3373 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
3374 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
3375 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC);
3377 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
3378 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
3379 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
3380 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
3381 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
3383 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
3385 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
3386 sector = mdev->ldev->md.md_offset;
3388 if (drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
3389 clear_bit(MD_DIRTY, &mdev->flags);
3391 /* this was a try anyways ... */
3392 dev_err(DEV, "meta data update failed!\n");
3394 drbd_chk_io_error(mdev, 1, TRUE);
3397 /* Update mdev->ldev->md.la_size_sect,
3398 * since we updated it on metadata. */
3399 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
3401 mutex_unlock(&mdev->md_io_mutex);
3406 * drbd_md_read() - Reads in the meta data super block
3407 * @mdev: DRBD device.
3408 * @bdev: Device from which the meta data should be read in.
3410 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_codes in case
3411 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
3413 int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
3415 struct meta_data_on_disk *buffer;
3416 int i, rv = NO_ERROR;
3418 if (!get_ldev_if_state(mdev, D_ATTACHING))
3419 return ERR_IO_MD_DISK;
3421 mutex_lock(&mdev->md_io_mutex);
3422 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3424 if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
3425 /* NOTE: cant do normal error processing here as this is
3426 called BEFORE disk is attached */
3427 dev_err(DEV, "Error while reading metadata.\n");
3428 rv = ERR_IO_MD_DISK;
3432 if (be32_to_cpu(buffer->magic) != DRBD_MD_MAGIC) {
3433 dev_err(DEV, "Error while reading metadata, magic not found.\n");
3434 rv = ERR_MD_INVALID;
3437 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
3438 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
3439 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
3440 rv = ERR_MD_INVALID;
3443 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
3444 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
3445 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
3446 rv = ERR_MD_INVALID;
3449 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
3450 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
3451 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
3452 rv = ERR_MD_INVALID;
3456 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
3457 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3458 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
3459 rv = ERR_MD_INVALID;
3463 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
3464 for (i = UI_CURRENT; i < UI_SIZE; i++)
3465 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
3466 bdev->md.flags = be32_to_cpu(buffer->flags);
3467 mdev->sync_conf.al_extents = be32_to_cpu(buffer->al_nr_extents);
3468 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
3470 if (mdev->sync_conf.al_extents < 7)
3471 mdev->sync_conf.al_extents = 127;
3474 mutex_unlock(&mdev->md_io_mutex);
3481 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3482 * @mdev: DRBD device.
3484 * Call this function if you change anything that should be written to
3485 * the meta-data super block. This function sets MD_DIRTY, and starts a
3486 * timer that ensures that within five seconds you have to call drbd_md_sync().
3488 void drbd_md_mark_dirty(struct drbd_conf *mdev)
3490 set_bit(MD_DIRTY, &mdev->flags);
3491 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
3495 static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
3499 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
3500 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
3503 void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3505 if (idx == UI_CURRENT) {
3506 if (mdev->state.role == R_PRIMARY)
3511 drbd_set_ed_uuid(mdev, val);
3514 mdev->ldev->md.uuid[idx] = val;
3515 drbd_md_mark_dirty(mdev);
3519 void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3521 if (mdev->ldev->md.uuid[idx]) {
3522 drbd_uuid_move_history(mdev);
3523 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
3525 _drbd_uuid_set(mdev, idx, val);
3529 * drbd_uuid_new_current() - Creates a new current UUID
3530 * @mdev: DRBD device.
3532 * Creates a new current UUID, and rotates the old current UUID into
3533 * the bitmap slot. Causes an incremental resync upon next connect.
3535 void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
3539 dev_info(DEV, "Creating new current UUID\n");
3540 D_ASSERT(mdev->ldev->md.uuid[UI_BITMAP] == 0);
3541 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
3543 get_random_bytes(&val, sizeof(u64));
3544 _drbd_uuid_set(mdev, UI_CURRENT, val);
3547 void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
3549 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
3553 drbd_uuid_move_history(mdev);
3554 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
3555 mdev->ldev->md.uuid[UI_BITMAP] = 0;
3557 if (mdev->ldev->md.uuid[UI_BITMAP])
3558 dev_warn(DEV, "bm UUID already set");
3560 mdev->ldev->md.uuid[UI_BITMAP] = val;
3561 mdev->ldev->md.uuid[UI_BITMAP] &= ~((u64)1);
3564 drbd_md_mark_dirty(mdev);
3568 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3569 * @mdev: DRBD device.
3571 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3573 int drbd_bmio_set_n_write(struct drbd_conf *mdev)
3577 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3578 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3580 drbd_bm_set_all(mdev);
3582 rv = drbd_bm_write(mdev);
3585 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
3596 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3597 * @mdev: DRBD device.
3599 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3601 int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
3605 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3606 drbd_bm_clear_all(mdev);
3607 rv = drbd_bm_write(mdev);
3614 static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3616 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
3619 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
3621 drbd_bm_lock(mdev, work->why);
3622 rv = work->io_fn(mdev);
3623 drbd_bm_unlock(mdev);
3625 clear_bit(BITMAP_IO, &mdev->flags);
3626 wake_up(&mdev->misc_wait);
3629 work->done(mdev, rv);
3631 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
3638 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3639 * @mdev: DRBD device.
3640 * @io_fn: IO callback to be called when bitmap IO is possible
3641 * @done: callback to be called after the bitmap IO was performed
3642 * @why: Descriptive text of the reason for doing the IO
3644 * While IO on the bitmap happens we freeze application IO thus we ensure
3645 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3646 * called from worker context. It MUST NOT be used while a previous such
3647 * work is still pending!
3649 void drbd_queue_bitmap_io(struct drbd_conf *mdev,
3650 int (*io_fn)(struct drbd_conf *),
3651 void (*done)(struct drbd_conf *, int),
3654 D_ASSERT(current == mdev->worker.task);
3656 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
3657 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
3658 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
3659 if (mdev->bm_io_work.why)
3660 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
3661 why, mdev->bm_io_work.why);
3663 mdev->bm_io_work.io_fn = io_fn;
3664 mdev->bm_io_work.done = done;
3665 mdev->bm_io_work.why = why;
3667 set_bit(BITMAP_IO, &mdev->flags);
3668 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
3669 if (list_empty(&mdev->bm_io_work.w.list)) {
3670 set_bit(BITMAP_IO_QUEUED, &mdev->flags);
3671 drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);
3673 dev_err(DEV, "FIXME avoided double queuing bm_io_work\n");
3678 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3679 * @mdev: DRBD device.
3680 * @io_fn: IO callback to be called when bitmap IO is possible
3681 * @why: Descriptive text of the reason for doing the IO
3683 * freezes application IO while that the actual IO operations runs. This
3684 * functions MAY NOT be called from worker context.
3686 int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *), char *why)
3690 D_ASSERT(current != mdev->worker.task);
3692 drbd_suspend_io(mdev);
3694 drbd_bm_lock(mdev, why);
3696 drbd_bm_unlock(mdev);
3698 drbd_resume_io(mdev);
3703 void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3705 if ((mdev->ldev->md.flags & flag) != flag) {
3706 drbd_md_mark_dirty(mdev);
3707 mdev->ldev->md.flags |= flag;
3711 void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3713 if ((mdev->ldev->md.flags & flag) != 0) {
3714 drbd_md_mark_dirty(mdev);
3715 mdev->ldev->md.flags &= ~flag;
3718 int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3720 return (bdev->md.flags & flag) != 0;
3723 static void md_sync_timer_fn(unsigned long data)
3725 struct drbd_conf *mdev = (struct drbd_conf *) data;
3727 drbd_queue_work_front(&mdev->data.work, &mdev->md_sync_work);
3730 static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3732 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
3738 #ifdef CONFIG_DRBD_FAULT_INJECTION
3739 /* Fault insertion support including random number generator shamelessly
3740 * stolen from kernel/rcutorture.c */
3741 struct fault_random_state {
3742 unsigned long state;
3743 unsigned long count;
3746 #define FAULT_RANDOM_MULT 39916801 /* prime */
3747 #define FAULT_RANDOM_ADD 479001701 /* prime */
3748 #define FAULT_RANDOM_REFRESH 10000
3751 * Crude but fast random-number generator. Uses a linear congruential
3752 * generator, with occasional help from get_random_bytes().
3754 static unsigned long
3755 _drbd_fault_random(struct fault_random_state *rsp)
3759 if (!rsp->count--) {
3760 get_random_bytes(&refresh, sizeof(refresh));
3761 rsp->state += refresh;
3762 rsp->count = FAULT_RANDOM_REFRESH;
3764 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3765 return swahw32(rsp->state);
3769 _drbd_fault_str(unsigned int type) {
3770 static char *_faults[] = {
3771 [DRBD_FAULT_MD_WR] = "Meta-data write",
3772 [DRBD_FAULT_MD_RD] = "Meta-data read",
3773 [DRBD_FAULT_RS_WR] = "Resync write",
3774 [DRBD_FAULT_RS_RD] = "Resync read",
3775 [DRBD_FAULT_DT_WR] = "Data write",
3776 [DRBD_FAULT_DT_RD] = "Data read",
3777 [DRBD_FAULT_DT_RA] = "Data read ahead",
3778 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
3779 [DRBD_FAULT_AL_EE] = "EE allocation",
3780 [DRBD_FAULT_RECEIVE] = "receive data corruption",
3783 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3787 _drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3789 static struct fault_random_state rrs = {0, 0};
3791 unsigned int ret = (
3793 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3794 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3799 if (__ratelimit(&drbd_ratelimit_state))
3800 dev_warn(DEV, "***Simulating %s failure\n",
3801 _drbd_fault_str(type));
3808 const char *drbd_buildtag(void)
3810 /* DRBD built from external sources has here a reference to the
3811 git hash of the source code. */
3813 static char buildtag[38] = "\0uilt-in";
3815 if (buildtag[0] == 0) {
3816 #ifdef CONFIG_MODULES
3817 if (THIS_MODULE != NULL)
3818 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3827 module_init(drbd_init)
3828 module_exit(drbd_cleanup)
3830 EXPORT_SYMBOL(drbd_conn_str);
3831 EXPORT_SYMBOL(drbd_role_str);
3832 EXPORT_SYMBOL(drbd_disk_str);
3833 EXPORT_SYMBOL(drbd_set_st_err_str);