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/mutex.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 static DEFINE_MUTEX(drbd_main_mutex
);
68 int drbdd_init(struct drbd_thread
*);
69 int drbd_worker(struct drbd_thread
*);
70 int drbd_asender(struct drbd_thread
*);
73 static int drbd_open(struct block_device
*bdev
, fmode_t mode
);
74 static int drbd_release(struct gendisk
*gd
, fmode_t mode
);
75 static int w_after_state_ch(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
);
76 static void after_state_ch(struct drbd_conf
*mdev
, union drbd_state os
,
77 union drbd_state ns
, enum chg_state_flags flags
);
78 static int w_md_sync(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
);
79 static void md_sync_timer_fn(unsigned long data
);
80 static int w_bitmap_io(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
);
81 static int w_go_diskless(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
);
83 MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
84 "Lars Ellenberg <lars@linbit.com>");
85 MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION
);
86 MODULE_VERSION(REL_VERSION
);
87 MODULE_LICENSE("GPL");
88 MODULE_PARM_DESC(minor_count
, "Maximum number of drbd devices ("
89 __stringify(DRBD_MINOR_COUNT_MIN
) "-" __stringify(DRBD_MINOR_COUNT_MAX
) ")");
90 MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR
);
92 #include <linux/moduleparam.h>
93 /* allow_open_on_secondary */
94 MODULE_PARM_DESC(allow_oos
, "DONT USE!");
95 /* thanks to these macros, if compiled into the kernel (not-module),
96 * this becomes the boot parameter drbd.minor_count */
97 module_param(minor_count
, uint
, 0444);
98 module_param(disable_sendpage
, bool, 0644);
99 module_param(allow_oos
, bool, 0);
100 module_param(cn_idx
, uint
, 0444);
101 module_param(proc_details
, int, 0644);
103 #ifdef CONFIG_DRBD_FAULT_INJECTION
106 static int fault_count
;
108 /* bitmap of enabled faults */
109 module_param(enable_faults
, int, 0664);
110 /* fault rate % value - applies to all enabled faults */
111 module_param(fault_rate
, int, 0664);
112 /* count of faults inserted */
113 module_param(fault_count
, int, 0664);
114 /* bitmap of devices to insert faults on */
115 module_param(fault_devs
, int, 0644);
118 /* module parameter, defined */
119 unsigned int minor_count
= DRBD_MINOR_COUNT_DEF
;
120 bool disable_sendpage
;
122 unsigned int cn_idx
= CN_IDX_DRBD
;
123 int proc_details
; /* Detail level in proc drbd*/
125 /* Module parameter for setting the user mode helper program
126 * to run. Default is /sbin/drbdadm */
127 char usermode_helper
[80] = "/sbin/drbdadm";
129 module_param_string(usermode_helper
, usermode_helper
, sizeof(usermode_helper
), 0644);
131 /* in 2.6.x, our device mapping and config info contains our virtual gendisks
132 * as member "struct gendisk *vdisk;"
134 struct drbd_conf
**minor_table
;
136 struct kmem_cache
*drbd_request_cache
;
137 struct kmem_cache
*drbd_ee_cache
; /* epoch entries */
138 struct kmem_cache
*drbd_bm_ext_cache
; /* bitmap extents */
139 struct kmem_cache
*drbd_al_ext_cache
; /* activity log extents */
140 mempool_t
*drbd_request_mempool
;
141 mempool_t
*drbd_ee_mempool
;
143 /* I do not use a standard mempool, because:
144 1) I want to hand out the pre-allocated objects first.
145 2) I want to be able to interrupt sleeping allocation with a signal.
146 Note: This is a single linked list, the next pointer is the private
147 member of struct page.
149 struct page
*drbd_pp_pool
;
150 spinlock_t drbd_pp_lock
;
152 wait_queue_head_t drbd_pp_wait
;
154 DEFINE_RATELIMIT_STATE(drbd_ratelimit_state
, 5 * HZ
, 5);
156 static const struct block_device_operations drbd_ops
= {
157 .owner
= THIS_MODULE
,
159 .release
= drbd_release
,
162 #define ARRY_SIZE(A) (sizeof(A)/sizeof(A[0]))
165 /* When checking with sparse, and this is an inline function, sparse will
166 give tons of false positives. When this is a real functions sparse works.
168 int _get_ldev_if_state(struct drbd_conf
*mdev
, enum drbd_disk_state mins
)
172 atomic_inc(&mdev
->local_cnt
);
173 io_allowed
= (mdev
->state
.disk
>= mins
);
175 if (atomic_dec_and_test(&mdev
->local_cnt
))
176 wake_up(&mdev
->misc_wait
);
184 * DOC: The transfer log
186 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
187 * mdev->newest_tle points to the head, mdev->oldest_tle points to the tail
188 * of the list. There is always at least one &struct drbd_tl_epoch object.
190 * Each &struct drbd_tl_epoch has a circular double linked list of requests
193 static int tl_init(struct drbd_conf
*mdev
)
195 struct drbd_tl_epoch
*b
;
197 /* during device minor initialization, we may well use GFP_KERNEL */
198 b
= kmalloc(sizeof(struct drbd_tl_epoch
), GFP_KERNEL
);
201 INIT_LIST_HEAD(&b
->requests
);
202 INIT_LIST_HEAD(&b
->w
.list
);
206 b
->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
208 mdev
->oldest_tle
= b
;
209 mdev
->newest_tle
= b
;
210 INIT_LIST_HEAD(&mdev
->out_of_sequence_requests
);
211 INIT_LIST_HEAD(&mdev
->barrier_acked_requests
);
213 mdev
->tl_hash
= NULL
;
219 static void tl_cleanup(struct drbd_conf
*mdev
)
221 D_ASSERT(mdev
->oldest_tle
== mdev
->newest_tle
);
222 D_ASSERT(list_empty(&mdev
->out_of_sequence_requests
));
223 kfree(mdev
->oldest_tle
);
224 mdev
->oldest_tle
= NULL
;
225 kfree(mdev
->unused_spare_tle
);
226 mdev
->unused_spare_tle
= NULL
;
227 kfree(mdev
->tl_hash
);
228 mdev
->tl_hash
= NULL
;
233 * _tl_add_barrier() - Adds a barrier to the transfer log
234 * @mdev: DRBD device.
235 * @new: Barrier to be added before the current head of the TL.
237 * The caller must hold the req_lock.
239 void _tl_add_barrier(struct drbd_conf
*mdev
, struct drbd_tl_epoch
*new)
241 struct drbd_tl_epoch
*newest_before
;
243 INIT_LIST_HEAD(&new->requests
);
244 INIT_LIST_HEAD(&new->w
.list
);
245 new->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
249 newest_before
= mdev
->newest_tle
;
250 /* never send a barrier number == 0, because that is special-cased
251 * when using TCQ for our write ordering code */
252 new->br_number
= (newest_before
->br_number
+1) ?: 1;
253 if (mdev
->newest_tle
!= new) {
254 mdev
->newest_tle
->next
= new;
255 mdev
->newest_tle
= new;
260 * tl_release() - Free or recycle the oldest &struct drbd_tl_epoch object of the TL
261 * @mdev: DRBD device.
262 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
263 * @set_size: Expected number of requests before that barrier.
265 * In case the passed barrier_nr or set_size does not match the oldest
266 * &struct drbd_tl_epoch objects this function will cause a termination
269 void tl_release(struct drbd_conf
*mdev
, unsigned int barrier_nr
,
270 unsigned int set_size
)
272 struct drbd_tl_epoch
*b
, *nob
; /* next old barrier */
273 struct list_head
*le
, *tle
;
274 struct drbd_request
*r
;
276 spin_lock_irq(&mdev
->req_lock
);
278 b
= mdev
->oldest_tle
;
280 /* first some paranoia code */
282 dev_err(DEV
, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
286 if (b
->br_number
!= barrier_nr
) {
287 dev_err(DEV
, "BAD! BarrierAck #%u received, expected #%u!\n",
288 barrier_nr
, b
->br_number
);
291 if (b
->n_writes
!= set_size
) {
292 dev_err(DEV
, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
293 barrier_nr
, set_size
, b
->n_writes
);
297 /* Clean up list of requests processed during current epoch */
298 list_for_each_safe(le
, tle
, &b
->requests
) {
299 r
= list_entry(le
, struct drbd_request
, tl_requests
);
300 _req_mod(r
, barrier_acked
);
302 /* There could be requests on the list waiting for completion
303 of the write to the local disk. To avoid corruptions of
304 slab's data structures we have to remove the lists head.
306 Also there could have been a barrier ack out of sequence, overtaking
307 the write acks - which would be a bug and violating write ordering.
308 To not deadlock in case we lose connection while such requests are
309 still pending, we need some way to find them for the
310 _req_mode(connection_lost_while_pending).
312 These have been list_move'd to the out_of_sequence_requests list in
313 _req_mod(, barrier_acked) above.
315 list_splice_init(&b
->requests
, &mdev
->barrier_acked_requests
);
318 if (test_and_clear_bit(CREATE_BARRIER
, &mdev
->flags
)) {
319 _tl_add_barrier(mdev
, b
);
321 mdev
->oldest_tle
= nob
;
322 /* if nob == NULL b was the only barrier, and becomes the new
323 barrier. Therefore mdev->oldest_tle points already to b */
325 D_ASSERT(nob
!= NULL
);
326 mdev
->oldest_tle
= nob
;
330 spin_unlock_irq(&mdev
->req_lock
);
331 dec_ap_pending(mdev
);
336 spin_unlock_irq(&mdev
->req_lock
);
337 drbd_force_state(mdev
, NS(conn
, C_PROTOCOL_ERROR
));
342 * _tl_restart() - Walks the transfer log, and applies an action to all requests
343 * @mdev: DRBD device.
344 * @what: The action/event to perform with all request objects
346 * @what might be one of connection_lost_while_pending, resend, fail_frozen_disk_io,
347 * restart_frozen_disk_io.
349 static void _tl_restart(struct drbd_conf
*mdev
, enum drbd_req_event what
)
351 struct drbd_tl_epoch
*b
, *tmp
, **pn
;
352 struct list_head
*le
, *tle
, carry_reads
;
353 struct drbd_request
*req
;
354 int rv
, n_writes
, n_reads
;
356 b
= mdev
->oldest_tle
;
357 pn
= &mdev
->oldest_tle
;
361 INIT_LIST_HEAD(&carry_reads
);
362 list_for_each_safe(le
, tle
, &b
->requests
) {
363 req
= list_entry(le
, struct drbd_request
, tl_requests
);
364 rv
= _req_mod(req
, what
);
366 n_writes
+= (rv
& MR_WRITE
) >> MR_WRITE_SHIFT
;
367 n_reads
+= (rv
& MR_READ
) >> MR_READ_SHIFT
;
372 if (what
== resend
) {
373 b
->n_writes
= n_writes
;
374 if (b
->w
.cb
== NULL
) {
375 b
->w
.cb
= w_send_barrier
;
376 inc_ap_pending(mdev
);
377 set_bit(CREATE_BARRIER
, &mdev
->flags
);
380 drbd_queue_work(&mdev
->data
.work
, &b
->w
);
385 list_add(&carry_reads
, &b
->requests
);
386 /* there could still be requests on that ring list,
387 * in case local io is still pending */
388 list_del(&b
->requests
);
390 /* dec_ap_pending corresponding to queue_barrier.
391 * the newest barrier may not have been queued yet,
392 * in which case w.cb is still NULL. */
394 dec_ap_pending(mdev
);
396 if (b
== mdev
->newest_tle
) {
397 /* recycle, but reinit! */
398 D_ASSERT(tmp
== NULL
);
399 INIT_LIST_HEAD(&b
->requests
);
400 list_splice(&carry_reads
, &b
->requests
);
401 INIT_LIST_HEAD(&b
->w
.list
);
403 b
->br_number
= net_random();
413 list_splice(&carry_reads
, &b
->requests
);
416 /* Actions operating on the disk state, also want to work on
417 requests that got barrier acked. */
419 case fail_frozen_disk_io
:
420 case restart_frozen_disk_io
:
421 list_for_each_safe(le
, tle
, &mdev
->barrier_acked_requests
) {
422 req
= list_entry(le
, struct drbd_request
, tl_requests
);
426 case connection_lost_while_pending
:
430 dev_err(DEV
, "what = %d in _tl_restart()\n", what
);
436 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
437 * @mdev: DRBD device.
439 * This is called after the connection to the peer was lost. The storage covered
440 * by the requests on the transfer gets marked as our of sync. Called from the
441 * receiver thread and the worker thread.
443 void tl_clear(struct drbd_conf
*mdev
)
445 struct list_head
*le
, *tle
;
446 struct drbd_request
*r
;
448 spin_lock_irq(&mdev
->req_lock
);
450 _tl_restart(mdev
, connection_lost_while_pending
);
452 /* we expect this list to be empty. */
453 D_ASSERT(list_empty(&mdev
->out_of_sequence_requests
));
455 /* but just in case, clean it up anyways! */
456 list_for_each_safe(le
, tle
, &mdev
->out_of_sequence_requests
) {
457 r
= list_entry(le
, struct drbd_request
, tl_requests
);
458 /* It would be nice to complete outside of spinlock.
459 * But this is easier for now. */
460 _req_mod(r
, connection_lost_while_pending
);
463 /* ensure bit indicating barrier is required is clear */
464 clear_bit(CREATE_BARRIER
, &mdev
->flags
);
466 memset(mdev
->app_reads_hash
, 0, APP_R_HSIZE
*sizeof(void *));
468 spin_unlock_irq(&mdev
->req_lock
);
471 void tl_restart(struct drbd_conf
*mdev
, enum drbd_req_event what
)
473 spin_lock_irq(&mdev
->req_lock
);
474 _tl_restart(mdev
, what
);
475 spin_unlock_irq(&mdev
->req_lock
);
479 * tl_abort_disk_io() - Abort disk I/O for all requests for a certain mdev in the TL
480 * @mdev: DRBD device.
482 void tl_abort_disk_io(struct drbd_conf
*mdev
)
484 struct drbd_tl_epoch
*b
;
485 struct list_head
*le
, *tle
;
486 struct drbd_request
*req
;
488 spin_lock_irq(&mdev
->req_lock
);
489 b
= mdev
->oldest_tle
;
491 list_for_each_safe(le
, tle
, &b
->requests
) {
492 req
= list_entry(le
, struct drbd_request
, tl_requests
);
493 if (!(req
->rq_state
& RQ_LOCAL_PENDING
))
495 _req_mod(req
, abort_disk_io
);
500 list_for_each_safe(le
, tle
, &mdev
->barrier_acked_requests
) {
501 req
= list_entry(le
, struct drbd_request
, tl_requests
);
502 if (!(req
->rq_state
& RQ_LOCAL_PENDING
))
504 _req_mod(req
, abort_disk_io
);
507 spin_unlock_irq(&mdev
->req_lock
);
511 * cl_wide_st_chg() - true if the state change is a cluster wide one
512 * @mdev: DRBD device.
513 * @os: old (current) state.
514 * @ns: new (wanted) state.
516 static int cl_wide_st_chg(struct drbd_conf
*mdev
,
517 union drbd_state os
, union drbd_state ns
)
519 return (os
.conn
>= C_CONNECTED
&& ns
.conn
>= C_CONNECTED
&&
520 ((os
.role
!= R_PRIMARY
&& ns
.role
== R_PRIMARY
) ||
521 (os
.conn
!= C_STARTING_SYNC_T
&& ns
.conn
== C_STARTING_SYNC_T
) ||
522 (os
.conn
!= C_STARTING_SYNC_S
&& ns
.conn
== C_STARTING_SYNC_S
) ||
523 (os
.disk
!= D_FAILED
&& ns
.disk
== D_FAILED
))) ||
524 (os
.conn
>= C_CONNECTED
&& ns
.conn
== C_DISCONNECTING
) ||
525 (os
.conn
== C_CONNECTED
&& ns
.conn
== C_VERIFY_S
);
529 drbd_change_state(struct drbd_conf
*mdev
, enum chg_state_flags f
,
530 union drbd_state mask
, union drbd_state val
)
533 union drbd_state os
, ns
;
534 enum drbd_state_rv rv
;
536 spin_lock_irqsave(&mdev
->req_lock
, flags
);
538 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
539 rv
= _drbd_set_state(mdev
, ns
, f
, NULL
);
541 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
547 * drbd_force_state() - Impose a change which happens outside our control on our state
548 * @mdev: DRBD device.
549 * @mask: mask of state bits to change.
550 * @val: value of new state bits.
552 void drbd_force_state(struct drbd_conf
*mdev
,
553 union drbd_state mask
, union drbd_state val
)
555 drbd_change_state(mdev
, CS_HARD
, mask
, val
);
558 static enum drbd_state_rv
is_valid_state(struct drbd_conf
*, union drbd_state
);
559 static enum drbd_state_rv
is_valid_state_transition(struct drbd_conf
*,
562 enum sanitize_state_warnings
{
564 ABORTED_ONLINE_VERIFY
,
566 CONNECTION_LOST_NEGOTIATING
,
567 IMPLICITLY_UPGRADED_DISK
,
568 IMPLICITLY_UPGRADED_PDSK
,
570 static union drbd_state
sanitize_state(struct drbd_conf
*mdev
, union drbd_state os
,
571 union drbd_state ns
, enum sanitize_state_warnings
*warn
);
572 int drbd_send_state_req(struct drbd_conf
*,
573 union drbd_state
, union drbd_state
);
575 static enum drbd_state_rv
576 _req_st_cond(struct drbd_conf
*mdev
, union drbd_state mask
,
577 union drbd_state val
)
579 union drbd_state os
, ns
;
581 enum drbd_state_rv rv
;
583 if (test_and_clear_bit(CL_ST_CHG_SUCCESS
, &mdev
->flags
))
584 return SS_CW_SUCCESS
;
586 if (test_and_clear_bit(CL_ST_CHG_FAIL
, &mdev
->flags
))
587 return SS_CW_FAILED_BY_PEER
;
590 spin_lock_irqsave(&mdev
->req_lock
, flags
);
592 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
593 ns
= sanitize_state(mdev
, os
, ns
, NULL
);
595 if (!cl_wide_st_chg(mdev
, os
, ns
))
598 rv
= is_valid_state(mdev
, ns
);
599 if (rv
== SS_SUCCESS
) {
600 rv
= is_valid_state_transition(mdev
, ns
, os
);
601 if (rv
== SS_SUCCESS
)
602 rv
= SS_UNKNOWN_ERROR
; /* cont waiting, otherwise fail. */
605 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
611 * drbd_req_state() - Perform an eventually cluster wide state change
612 * @mdev: DRBD device.
613 * @mask: mask of state bits to change.
614 * @val: value of new state bits.
617 * Should not be called directly, use drbd_request_state() or
618 * _drbd_request_state().
620 static enum drbd_state_rv
621 drbd_req_state(struct drbd_conf
*mdev
, union drbd_state mask
,
622 union drbd_state val
, enum chg_state_flags f
)
624 struct completion done
;
626 union drbd_state os
, ns
;
627 enum drbd_state_rv rv
;
629 init_completion(&done
);
631 if (f
& CS_SERIALIZE
)
632 mutex_lock(&mdev
->state_mutex
);
634 spin_lock_irqsave(&mdev
->req_lock
, flags
);
636 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
637 ns
= sanitize_state(mdev
, os
, ns
, NULL
);
639 if (cl_wide_st_chg(mdev
, os
, ns
)) {
640 rv
= is_valid_state(mdev
, ns
);
641 if (rv
== SS_SUCCESS
)
642 rv
= is_valid_state_transition(mdev
, ns
, os
);
643 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
645 if (rv
< SS_SUCCESS
) {
647 print_st_err(mdev
, os
, ns
, rv
);
651 drbd_state_lock(mdev
);
652 if (!drbd_send_state_req(mdev
, mask
, val
)) {
653 drbd_state_unlock(mdev
);
654 rv
= SS_CW_FAILED_BY_PEER
;
656 print_st_err(mdev
, os
, ns
, rv
);
660 wait_event(mdev
->state_wait
,
661 (rv
= _req_st_cond(mdev
, mask
, val
)));
663 if (rv
< SS_SUCCESS
) {
664 drbd_state_unlock(mdev
);
666 print_st_err(mdev
, os
, ns
, rv
);
669 spin_lock_irqsave(&mdev
->req_lock
, flags
);
671 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
672 rv
= _drbd_set_state(mdev
, ns
, f
, &done
);
673 drbd_state_unlock(mdev
);
675 rv
= _drbd_set_state(mdev
, ns
, f
, &done
);
678 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
680 if (f
& CS_WAIT_COMPLETE
&& rv
== SS_SUCCESS
) {
681 D_ASSERT(current
!= mdev
->worker
.task
);
682 wait_for_completion(&done
);
686 if (f
& CS_SERIALIZE
)
687 mutex_unlock(&mdev
->state_mutex
);
693 * _drbd_request_state() - Request a state change (with flags)
694 * @mdev: DRBD device.
695 * @mask: mask of state bits to change.
696 * @val: value of new state bits.
699 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE
700 * flag, or when logging of failed state change requests is not desired.
703 _drbd_request_state(struct drbd_conf
*mdev
, union drbd_state mask
,
704 union drbd_state val
, enum chg_state_flags f
)
706 enum drbd_state_rv rv
;
708 wait_event(mdev
->state_wait
,
709 (rv
= drbd_req_state(mdev
, mask
, val
, f
)) != SS_IN_TRANSIENT_STATE
);
714 static void print_st(struct drbd_conf
*mdev
, char *name
, union drbd_state ns
)
716 dev_err(DEV
, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c }\n",
718 drbd_conn_str(ns
.conn
),
719 drbd_role_str(ns
.role
),
720 drbd_role_str(ns
.peer
),
721 drbd_disk_str(ns
.disk
),
722 drbd_disk_str(ns
.pdsk
),
723 is_susp(ns
) ? 's' : 'r',
724 ns
.aftr_isp
? 'a' : '-',
725 ns
.peer_isp
? 'p' : '-',
726 ns
.user_isp
? 'u' : '-'
730 void print_st_err(struct drbd_conf
*mdev
, union drbd_state os
,
731 union drbd_state ns
, enum drbd_state_rv err
)
733 if (err
== SS_IN_TRANSIENT_STATE
)
735 dev_err(DEV
, "State change failed: %s\n", drbd_set_st_err_str(err
));
736 print_st(mdev
, " state", os
);
737 print_st(mdev
, "wanted", ns
);
742 * is_valid_state() - Returns an SS_ error code if ns is not valid
743 * @mdev: DRBD device.
744 * @ns: State to consider.
746 static enum drbd_state_rv
747 is_valid_state(struct drbd_conf
*mdev
, union drbd_state ns
)
749 /* See drbd_state_sw_errors in drbd_strings.c */
751 enum drbd_fencing_p fp
;
752 enum drbd_state_rv rv
= SS_SUCCESS
;
755 if (get_ldev(mdev
)) {
756 fp
= mdev
->ldev
->dc
.fencing
;
760 if (get_net_conf(mdev
)) {
761 if (!mdev
->net_conf
->two_primaries
&&
762 ns
.role
== R_PRIMARY
&& ns
.peer
== R_PRIMARY
)
763 rv
= SS_TWO_PRIMARIES
;
768 /* already found a reason to abort */;
769 else if (ns
.role
== R_SECONDARY
&& mdev
->open_cnt
)
770 rv
= SS_DEVICE_IN_USE
;
772 else if (ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.disk
< D_UP_TO_DATE
)
773 rv
= SS_NO_UP_TO_DATE_DISK
;
775 else if (fp
>= FP_RESOURCE
&&
776 ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.pdsk
>= D_UNKNOWN
)
779 else if (ns
.role
== R_PRIMARY
&& ns
.disk
<= D_INCONSISTENT
&& ns
.pdsk
<= D_INCONSISTENT
)
780 rv
= SS_NO_UP_TO_DATE_DISK
;
782 else if (ns
.conn
> C_CONNECTED
&& ns
.disk
< D_INCONSISTENT
)
783 rv
= SS_NO_LOCAL_DISK
;
785 else if (ns
.conn
> C_CONNECTED
&& ns
.pdsk
< D_INCONSISTENT
)
786 rv
= SS_NO_REMOTE_DISK
;
788 else if (ns
.conn
> C_CONNECTED
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
)
789 rv
= SS_NO_UP_TO_DATE_DISK
;
791 else if ((ns
.conn
== C_CONNECTED
||
792 ns
.conn
== C_WF_BITMAP_S
||
793 ns
.conn
== C_SYNC_SOURCE
||
794 ns
.conn
== C_PAUSED_SYNC_S
) &&
795 ns
.disk
== D_OUTDATED
)
796 rv
= SS_CONNECTED_OUTDATES
;
798 else if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
799 (mdev
->sync_conf
.verify_alg
[0] == 0))
800 rv
= SS_NO_VERIFY_ALG
;
802 else if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
803 mdev
->agreed_pro_version
< 88)
804 rv
= SS_NOT_SUPPORTED
;
806 else if (ns
.conn
>= C_CONNECTED
&& ns
.pdsk
== D_UNKNOWN
)
807 rv
= SS_CONNECTED_OUTDATES
;
813 * is_valid_state_transition() - Returns an SS_ error code if the state transition is not possible
814 * @mdev: DRBD device.
818 static enum drbd_state_rv
819 is_valid_state_transition(struct drbd_conf
*mdev
, union drbd_state ns
,
822 enum drbd_state_rv rv
= SS_SUCCESS
;
824 if ((ns
.conn
== C_STARTING_SYNC_T
|| ns
.conn
== C_STARTING_SYNC_S
) &&
825 os
.conn
> C_CONNECTED
)
826 rv
= SS_RESYNC_RUNNING
;
828 if (ns
.conn
== C_DISCONNECTING
&& os
.conn
== C_STANDALONE
)
829 rv
= SS_ALREADY_STANDALONE
;
831 if (ns
.disk
> D_ATTACHING
&& os
.disk
== D_DISKLESS
)
834 if (ns
.conn
== C_WF_CONNECTION
&& os
.conn
< C_UNCONNECTED
)
835 rv
= SS_NO_NET_CONFIG
;
837 if (ns
.disk
== D_OUTDATED
&& os
.disk
< D_OUTDATED
&& os
.disk
!= D_ATTACHING
)
838 rv
= SS_LOWER_THAN_OUTDATED
;
840 if (ns
.conn
== C_DISCONNECTING
&& os
.conn
== C_UNCONNECTED
)
841 rv
= SS_IN_TRANSIENT_STATE
;
843 if (ns
.conn
== os
.conn
&& ns
.conn
== C_WF_REPORT_PARAMS
)
844 rv
= SS_IN_TRANSIENT_STATE
;
846 if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) && os
.conn
< C_CONNECTED
)
847 rv
= SS_NEED_CONNECTION
;
849 if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
850 ns
.conn
!= os
.conn
&& os
.conn
> C_CONNECTED
)
851 rv
= SS_RESYNC_RUNNING
;
853 if ((ns
.conn
== C_STARTING_SYNC_S
|| ns
.conn
== C_STARTING_SYNC_T
) &&
854 os
.conn
< C_CONNECTED
)
855 rv
= SS_NEED_CONNECTION
;
857 if ((ns
.conn
== C_SYNC_TARGET
|| ns
.conn
== C_SYNC_SOURCE
)
858 && os
.conn
< C_WF_REPORT_PARAMS
)
859 rv
= SS_NEED_CONNECTION
; /* No NetworkFailure -> SyncTarget etc... */
864 static void print_sanitize_warnings(struct drbd_conf
*mdev
, enum sanitize_state_warnings warn
)
866 static const char *msg_table
[] = {
868 [ABORTED_ONLINE_VERIFY
] = "Online-verify aborted.",
869 [ABORTED_RESYNC
] = "Resync aborted.",
870 [CONNECTION_LOST_NEGOTIATING
] = "Connection lost while negotiating, no data!",
871 [IMPLICITLY_UPGRADED_DISK
] = "Implicitly upgraded disk",
872 [IMPLICITLY_UPGRADED_PDSK
] = "Implicitly upgraded pdsk",
875 if (warn
!= NO_WARNING
)
876 dev_warn(DEV
, "%s\n", msg_table
[warn
]);
880 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition
881 * @mdev: DRBD device.
886 * When we loose connection, we have to set the state of the peers disk (pdsk)
887 * to D_UNKNOWN. This rule and many more along those lines are in this function.
889 static union drbd_state
sanitize_state(struct drbd_conf
*mdev
, union drbd_state os
,
890 union drbd_state ns
, enum sanitize_state_warnings
*warn
)
892 enum drbd_fencing_p fp
;
893 enum drbd_disk_state disk_min
, disk_max
, pdsk_min
, pdsk_max
;
899 if (get_ldev(mdev
)) {
900 fp
= mdev
->ldev
->dc
.fencing
;
904 /* Disallow Network errors to configure a device's network part */
905 if ((ns
.conn
>= C_TIMEOUT
&& ns
.conn
<= C_TEAR_DOWN
) &&
906 os
.conn
<= C_DISCONNECTING
)
909 /* After a network error (+C_TEAR_DOWN) only C_UNCONNECTED or C_DISCONNECTING can follow.
910 * If you try to go into some Sync* state, that shall fail (elsewhere). */
911 if (os
.conn
>= C_TIMEOUT
&& os
.conn
<= C_TEAR_DOWN
&&
912 ns
.conn
!= C_UNCONNECTED
&& ns
.conn
!= C_DISCONNECTING
&& ns
.conn
<= C_TEAR_DOWN
)
915 /* we cannot fail (again) if we already detached */
916 if (ns
.disk
== D_FAILED
&& os
.disk
== D_DISKLESS
)
917 ns
.disk
= D_DISKLESS
;
919 /* if we are only D_ATTACHING yet,
920 * we can (and should) go directly to D_DISKLESS. */
921 if (ns
.disk
== D_FAILED
&& os
.disk
== D_ATTACHING
)
922 ns
.disk
= D_DISKLESS
;
924 /* After C_DISCONNECTING only C_STANDALONE may follow */
925 if (os
.conn
== C_DISCONNECTING
&& ns
.conn
!= C_STANDALONE
)
928 if (ns
.conn
< C_CONNECTED
) {
931 if (ns
.pdsk
> D_UNKNOWN
|| ns
.pdsk
< D_INCONSISTENT
)
935 /* Clear the aftr_isp when becoming unconfigured */
936 if (ns
.conn
== C_STANDALONE
&& ns
.disk
== D_DISKLESS
&& ns
.role
== R_SECONDARY
)
939 /* Abort resync if a disk fails/detaches */
940 if (os
.conn
> C_CONNECTED
&& ns
.conn
> C_CONNECTED
&&
941 (ns
.disk
<= D_FAILED
|| ns
.pdsk
<= D_FAILED
)) {
943 *warn
= os
.conn
== C_VERIFY_S
|| os
.conn
== C_VERIFY_T
?
944 ABORTED_ONLINE_VERIFY
: ABORTED_RESYNC
;
945 ns
.conn
= C_CONNECTED
;
948 /* Connection breaks down before we finished "Negotiating" */
949 if (ns
.conn
< C_CONNECTED
&& ns
.disk
== D_NEGOTIATING
&&
950 get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
951 if (mdev
->ed_uuid
== mdev
->ldev
->md
.uuid
[UI_CURRENT
]) {
952 ns
.disk
= mdev
->new_state_tmp
.disk
;
953 ns
.pdsk
= mdev
->new_state_tmp
.pdsk
;
956 *warn
= CONNECTION_LOST_NEGOTIATING
;
957 ns
.disk
= D_DISKLESS
;
963 /* D_CONSISTENT and D_OUTDATED vanish when we get connected */
964 if (ns
.conn
>= C_CONNECTED
&& ns
.conn
< C_AHEAD
) {
965 if (ns
.disk
== D_CONSISTENT
|| ns
.disk
== D_OUTDATED
)
966 ns
.disk
= D_UP_TO_DATE
;
967 if (ns
.pdsk
== D_CONSISTENT
|| ns
.pdsk
== D_OUTDATED
)
968 ns
.pdsk
= D_UP_TO_DATE
;
971 /* Implications of the connection stat on the disk states */
972 disk_min
= D_DISKLESS
;
973 disk_max
= D_UP_TO_DATE
;
974 pdsk_min
= D_INCONSISTENT
;
975 pdsk_max
= D_UNKNOWN
;
976 switch ((enum drbd_conns
)ns
.conn
) {
978 case C_PAUSED_SYNC_T
:
979 case C_STARTING_SYNC_T
:
982 disk_min
= D_INCONSISTENT
;
983 disk_max
= D_OUTDATED
;
984 pdsk_min
= D_UP_TO_DATE
;
985 pdsk_max
= D_UP_TO_DATE
;
989 disk_min
= D_UP_TO_DATE
;
990 disk_max
= D_UP_TO_DATE
;
991 pdsk_min
= D_UP_TO_DATE
;
992 pdsk_max
= D_UP_TO_DATE
;
995 disk_min
= D_DISKLESS
;
996 disk_max
= D_UP_TO_DATE
;
997 pdsk_min
= D_DISKLESS
;
998 pdsk_max
= D_UP_TO_DATE
;
1001 case C_PAUSED_SYNC_S
:
1002 case C_STARTING_SYNC_S
:
1004 disk_min
= D_UP_TO_DATE
;
1005 disk_max
= D_UP_TO_DATE
;
1006 pdsk_min
= D_INCONSISTENT
;
1007 pdsk_max
= D_CONSISTENT
; /* D_OUTDATED would be nice. But explicit outdate necessary*/
1010 disk_min
= D_INCONSISTENT
;
1011 disk_max
= D_INCONSISTENT
;
1012 pdsk_min
= D_UP_TO_DATE
;
1013 pdsk_max
= D_UP_TO_DATE
;
1016 disk_min
= D_UP_TO_DATE
;
1017 disk_max
= D_UP_TO_DATE
;
1018 pdsk_min
= D_INCONSISTENT
;
1019 pdsk_max
= D_INCONSISTENT
;
1022 case C_DISCONNECTING
:
1026 case C_NETWORK_FAILURE
:
1027 case C_PROTOCOL_ERROR
:
1029 case C_WF_CONNECTION
:
1030 case C_WF_REPORT_PARAMS
:
1034 if (ns
.disk
> disk_max
)
1037 if (ns
.disk
< disk_min
) {
1039 *warn
= IMPLICITLY_UPGRADED_DISK
;
1042 if (ns
.pdsk
> pdsk_max
)
1045 if (ns
.pdsk
< pdsk_min
) {
1047 *warn
= IMPLICITLY_UPGRADED_PDSK
;
1051 if (fp
== FP_STONITH
&&
1052 (ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.pdsk
> D_OUTDATED
) &&
1053 !(os
.role
== R_PRIMARY
&& os
.conn
< C_CONNECTED
&& os
.pdsk
> D_OUTDATED
))
1054 ns
.susp_fen
= 1; /* Suspend IO while fence-peer handler runs (peer lost) */
1056 if (mdev
->sync_conf
.on_no_data
== OND_SUSPEND_IO
&&
1057 (ns
.role
== R_PRIMARY
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
) &&
1058 !(os
.role
== R_PRIMARY
&& os
.disk
< D_UP_TO_DATE
&& os
.pdsk
< D_UP_TO_DATE
))
1059 ns
.susp_nod
= 1; /* Suspend IO while no data available (no accessible data available) */
1061 if (ns
.aftr_isp
|| ns
.peer_isp
|| ns
.user_isp
) {
1062 if (ns
.conn
== C_SYNC_SOURCE
)
1063 ns
.conn
= C_PAUSED_SYNC_S
;
1064 if (ns
.conn
== C_SYNC_TARGET
)
1065 ns
.conn
= C_PAUSED_SYNC_T
;
1067 if (ns
.conn
== C_PAUSED_SYNC_S
)
1068 ns
.conn
= C_SYNC_SOURCE
;
1069 if (ns
.conn
== C_PAUSED_SYNC_T
)
1070 ns
.conn
= C_SYNC_TARGET
;
1076 /* helper for __drbd_set_state */
1077 static void set_ov_position(struct drbd_conf
*mdev
, enum drbd_conns cs
)
1079 if (mdev
->agreed_pro_version
< 90)
1080 mdev
->ov_start_sector
= 0;
1081 mdev
->rs_total
= drbd_bm_bits(mdev
);
1082 mdev
->ov_position
= 0;
1083 if (cs
== C_VERIFY_T
) {
1084 /* starting online verify from an arbitrary position
1085 * does not fit well into the existing protocol.
1086 * on C_VERIFY_T, we initialize ov_left and friends
1087 * implicitly in receive_DataRequest once the
1088 * first P_OV_REQUEST is received */
1089 mdev
->ov_start_sector
= ~(sector_t
)0;
1091 unsigned long bit
= BM_SECT_TO_BIT(mdev
->ov_start_sector
);
1092 if (bit
>= mdev
->rs_total
) {
1093 mdev
->ov_start_sector
=
1094 BM_BIT_TO_SECT(mdev
->rs_total
- 1);
1097 mdev
->rs_total
-= bit
;
1098 mdev
->ov_position
= mdev
->ov_start_sector
;
1100 mdev
->ov_left
= mdev
->rs_total
;
1103 static void drbd_resume_al(struct drbd_conf
*mdev
)
1105 if (test_and_clear_bit(AL_SUSPENDED
, &mdev
->flags
))
1106 dev_info(DEV
, "Resumed AL updates\n");
1110 * __drbd_set_state() - Set a new DRBD state
1111 * @mdev: DRBD device.
1114 * @done: Optional completion, that will get completed after the after_state_ch() finished
1116 * Caller needs to hold req_lock, and global_state_lock. Do not call directly.
1119 __drbd_set_state(struct drbd_conf
*mdev
, union drbd_state ns
,
1120 enum chg_state_flags flags
, struct completion
*done
)
1122 union drbd_state os
;
1123 enum drbd_state_rv rv
= SS_SUCCESS
;
1124 enum sanitize_state_warnings ssw
;
1125 struct after_state_chg_work
*ascw
;
1129 ns
= sanitize_state(mdev
, os
, ns
, &ssw
);
1132 return SS_NOTHING_TO_DO
;
1134 if (!(flags
& CS_HARD
)) {
1135 /* pre-state-change checks ; only look at ns */
1136 /* See drbd_state_sw_errors in drbd_strings.c */
1138 rv
= is_valid_state(mdev
, ns
);
1139 if (rv
< SS_SUCCESS
) {
1140 /* If the old state was illegal as well, then let
1143 if (is_valid_state(mdev
, os
) == rv
)
1144 rv
= is_valid_state_transition(mdev
, ns
, os
);
1146 rv
= is_valid_state_transition(mdev
, ns
, os
);
1149 if (rv
< SS_SUCCESS
) {
1150 if (flags
& CS_VERBOSE
)
1151 print_st_err(mdev
, os
, ns
, rv
);
1155 print_sanitize_warnings(mdev
, ssw
);
1161 if (ns
.role
!= os
.role
)
1162 pbp
+= sprintf(pbp
, "role( %s -> %s ) ",
1163 drbd_role_str(os
.role
),
1164 drbd_role_str(ns
.role
));
1165 if (ns
.peer
!= os
.peer
)
1166 pbp
+= sprintf(pbp
, "peer( %s -> %s ) ",
1167 drbd_role_str(os
.peer
),
1168 drbd_role_str(ns
.peer
));
1169 if (ns
.conn
!= os
.conn
)
1170 pbp
+= sprintf(pbp
, "conn( %s -> %s ) ",
1171 drbd_conn_str(os
.conn
),
1172 drbd_conn_str(ns
.conn
));
1173 if (ns
.disk
!= os
.disk
)
1174 pbp
+= sprintf(pbp
, "disk( %s -> %s ) ",
1175 drbd_disk_str(os
.disk
),
1176 drbd_disk_str(ns
.disk
));
1177 if (ns
.pdsk
!= os
.pdsk
)
1178 pbp
+= sprintf(pbp
, "pdsk( %s -> %s ) ",
1179 drbd_disk_str(os
.pdsk
),
1180 drbd_disk_str(ns
.pdsk
));
1181 if (is_susp(ns
) != is_susp(os
))
1182 pbp
+= sprintf(pbp
, "susp( %d -> %d ) ",
1185 if (ns
.aftr_isp
!= os
.aftr_isp
)
1186 pbp
+= sprintf(pbp
, "aftr_isp( %d -> %d ) ",
1189 if (ns
.peer_isp
!= os
.peer_isp
)
1190 pbp
+= sprintf(pbp
, "peer_isp( %d -> %d ) ",
1193 if (ns
.user_isp
!= os
.user_isp
)
1194 pbp
+= sprintf(pbp
, "user_isp( %d -> %d ) ",
1197 dev_info(DEV
, "%s\n", pb
);
1200 /* solve the race between becoming unconfigured,
1201 * worker doing the cleanup, and
1202 * admin reconfiguring us:
1203 * on (re)configure, first set CONFIG_PENDING,
1204 * then wait for a potentially exiting worker,
1205 * start the worker, and schedule one no_op.
1206 * then proceed with configuration.
1208 if (ns
.disk
== D_DISKLESS
&&
1209 ns
.conn
== C_STANDALONE
&&
1210 ns
.role
== R_SECONDARY
&&
1211 !test_and_set_bit(CONFIG_PENDING
, &mdev
->flags
))
1212 set_bit(DEVICE_DYING
, &mdev
->flags
);
1214 /* if we are going -> D_FAILED or D_DISKLESS, grab one extra reference
1215 * on the ldev here, to be sure the transition -> D_DISKLESS resp.
1216 * drbd_ldev_destroy() won't happen before our corresponding
1217 * after_state_ch works run, where we put_ldev again. */
1218 if ((os
.disk
!= D_FAILED
&& ns
.disk
== D_FAILED
) ||
1219 (os
.disk
!= D_DISKLESS
&& ns
.disk
== D_DISKLESS
))
1220 atomic_inc(&mdev
->local_cnt
);
1224 if (os
.disk
== D_ATTACHING
&& ns
.disk
>= D_NEGOTIATING
)
1225 drbd_print_uuids(mdev
, "attached to UUIDs");
1227 wake_up(&mdev
->misc_wait
);
1228 wake_up(&mdev
->state_wait
);
1230 /* aborted verify run. log the last position */
1231 if ((os
.conn
== C_VERIFY_S
|| os
.conn
== C_VERIFY_T
) &&
1232 ns
.conn
< C_CONNECTED
) {
1233 mdev
->ov_start_sector
=
1234 BM_BIT_TO_SECT(drbd_bm_bits(mdev
) - mdev
->ov_left
);
1235 dev_info(DEV
, "Online Verify reached sector %llu\n",
1236 (unsigned long long)mdev
->ov_start_sector
);
1239 if ((os
.conn
== C_PAUSED_SYNC_T
|| os
.conn
== C_PAUSED_SYNC_S
) &&
1240 (ns
.conn
== C_SYNC_TARGET
|| ns
.conn
== C_SYNC_SOURCE
)) {
1241 dev_info(DEV
, "Syncer continues.\n");
1242 mdev
->rs_paused
+= (long)jiffies
1243 -(long)mdev
->rs_mark_time
[mdev
->rs_last_mark
];
1244 if (ns
.conn
== C_SYNC_TARGET
)
1245 mod_timer(&mdev
->resync_timer
, jiffies
);
1248 if ((os
.conn
== C_SYNC_TARGET
|| os
.conn
== C_SYNC_SOURCE
) &&
1249 (ns
.conn
== C_PAUSED_SYNC_T
|| ns
.conn
== C_PAUSED_SYNC_S
)) {
1250 dev_info(DEV
, "Resync suspended\n");
1251 mdev
->rs_mark_time
[mdev
->rs_last_mark
] = jiffies
;
1254 if (os
.conn
== C_CONNECTED
&&
1255 (ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
)) {
1256 unsigned long now
= jiffies
;
1259 set_ov_position(mdev
, ns
.conn
);
1260 mdev
->rs_start
= now
;
1261 mdev
->rs_last_events
= 0;
1262 mdev
->rs_last_sect_ev
= 0;
1263 mdev
->ov_last_oos_size
= 0;
1264 mdev
->ov_last_oos_start
= 0;
1266 for (i
= 0; i
< DRBD_SYNC_MARKS
; i
++) {
1267 mdev
->rs_mark_left
[i
] = mdev
->ov_left
;
1268 mdev
->rs_mark_time
[i
] = now
;
1271 drbd_rs_controller_reset(mdev
);
1273 if (ns
.conn
== C_VERIFY_S
) {
1274 dev_info(DEV
, "Starting Online Verify from sector %llu\n",
1275 (unsigned long long)mdev
->ov_position
);
1276 mod_timer(&mdev
->resync_timer
, jiffies
);
1280 if (get_ldev(mdev
)) {
1281 u32 mdf
= mdev
->ldev
->md
.flags
& ~(MDF_CONSISTENT
|MDF_PRIMARY_IND
|
1282 MDF_CONNECTED_IND
|MDF_WAS_UP_TO_DATE
|
1283 MDF_PEER_OUT_DATED
|MDF_CRASHED_PRIMARY
);
1285 if (test_bit(CRASHED_PRIMARY
, &mdev
->flags
))
1286 mdf
|= MDF_CRASHED_PRIMARY
;
1287 if (mdev
->state
.role
== R_PRIMARY
||
1288 (mdev
->state
.pdsk
< D_INCONSISTENT
&& mdev
->state
.peer
== R_PRIMARY
))
1289 mdf
|= MDF_PRIMARY_IND
;
1290 if (mdev
->state
.conn
> C_WF_REPORT_PARAMS
)
1291 mdf
|= MDF_CONNECTED_IND
;
1292 if (mdev
->state
.disk
> D_INCONSISTENT
)
1293 mdf
|= MDF_CONSISTENT
;
1294 if (mdev
->state
.disk
> D_OUTDATED
)
1295 mdf
|= MDF_WAS_UP_TO_DATE
;
1296 if (mdev
->state
.pdsk
<= D_OUTDATED
&& mdev
->state
.pdsk
>= D_INCONSISTENT
)
1297 mdf
|= MDF_PEER_OUT_DATED
;
1298 if (mdf
!= mdev
->ldev
->md
.flags
) {
1299 mdev
->ldev
->md
.flags
= mdf
;
1300 drbd_md_mark_dirty(mdev
);
1302 if (os
.disk
< D_CONSISTENT
&& ns
.disk
>= D_CONSISTENT
)
1303 drbd_set_ed_uuid(mdev
, mdev
->ldev
->md
.uuid
[UI_CURRENT
]);
1307 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */
1308 if (os
.disk
== D_INCONSISTENT
&& os
.pdsk
== D_INCONSISTENT
&&
1309 os
.peer
== R_SECONDARY
&& ns
.peer
== R_PRIMARY
)
1310 set_bit(CONSIDER_RESYNC
, &mdev
->flags
);
1312 /* Receiver should clean up itself */
1313 if (os
.conn
!= C_DISCONNECTING
&& ns
.conn
== C_DISCONNECTING
)
1314 drbd_thread_stop_nowait(&mdev
->receiver
);
1316 /* Now the receiver finished cleaning up itself, it should die */
1317 if (os
.conn
!= C_STANDALONE
&& ns
.conn
== C_STANDALONE
)
1318 drbd_thread_stop_nowait(&mdev
->receiver
);
1320 /* Upon network failure, we need to restart the receiver. */
1321 if (os
.conn
> C_WF_CONNECTION
&&
1322 ns
.conn
<= C_TEAR_DOWN
&& ns
.conn
>= C_TIMEOUT
)
1323 drbd_thread_restart_nowait(&mdev
->receiver
);
1325 /* Resume AL writing if we get a connection */
1326 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
)
1327 drbd_resume_al(mdev
);
1329 ascw
= kmalloc(sizeof(*ascw
), GFP_ATOMIC
);
1333 ascw
->flags
= flags
;
1334 ascw
->w
.cb
= w_after_state_ch
;
1336 drbd_queue_work(&mdev
->data
.work
, &ascw
->w
);
1338 dev_warn(DEV
, "Could not kmalloc an ascw\n");
1344 static int w_after_state_ch(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
1346 struct after_state_chg_work
*ascw
=
1347 container_of(w
, struct after_state_chg_work
, w
);
1348 after_state_ch(mdev
, ascw
->os
, ascw
->ns
, ascw
->flags
);
1349 if (ascw
->flags
& CS_WAIT_COMPLETE
) {
1350 D_ASSERT(ascw
->done
!= NULL
);
1351 complete(ascw
->done
);
1358 static void abw_start_sync(struct drbd_conf
*mdev
, int rv
)
1361 dev_err(DEV
, "Writing the bitmap failed not starting resync.\n");
1362 _drbd_request_state(mdev
, NS(conn
, C_CONNECTED
), CS_VERBOSE
);
1366 switch (mdev
->state
.conn
) {
1367 case C_STARTING_SYNC_T
:
1368 _drbd_request_state(mdev
, NS(conn
, C_WF_SYNC_UUID
), CS_VERBOSE
);
1370 case C_STARTING_SYNC_S
:
1371 drbd_start_resync(mdev
, C_SYNC_SOURCE
);
1376 int drbd_bitmap_io_from_worker(struct drbd_conf
*mdev
,
1377 int (*io_fn
)(struct drbd_conf
*),
1378 char *why
, enum bm_flag flags
)
1382 D_ASSERT(current
== mdev
->worker
.task
);
1384 /* open coded non-blocking drbd_suspend_io(mdev); */
1385 set_bit(SUSPEND_IO
, &mdev
->flags
);
1387 drbd_bm_lock(mdev
, why
, flags
);
1389 drbd_bm_unlock(mdev
);
1391 drbd_resume_io(mdev
);
1397 * after_state_ch() - Perform after state change actions that may sleep
1398 * @mdev: DRBD device.
1403 static void after_state_ch(struct drbd_conf
*mdev
, union drbd_state os
,
1404 union drbd_state ns
, enum chg_state_flags flags
)
1406 enum drbd_fencing_p fp
;
1407 enum drbd_req_event what
= nothing
;
1408 union drbd_state nsm
= (union drbd_state
){ .i
= -1 };
1410 if (os
.conn
!= C_CONNECTED
&& ns
.conn
== C_CONNECTED
) {
1411 clear_bit(CRASHED_PRIMARY
, &mdev
->flags
);
1413 mdev
->p_uuid
[UI_FLAGS
] &= ~((u64
)2);
1417 if (get_ldev(mdev
)) {
1418 fp
= mdev
->ldev
->dc
.fencing
;
1422 /* Inform userspace about the change... */
1423 drbd_bcast_state(mdev
, ns
);
1425 if (!(os
.role
== R_PRIMARY
&& os
.disk
< D_UP_TO_DATE
&& os
.pdsk
< D_UP_TO_DATE
) &&
1426 (ns
.role
== R_PRIMARY
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
))
1427 drbd_khelper(mdev
, "pri-on-incon-degr");
1429 /* Here we have the actions that are performed after a
1430 state change. This function might sleep */
1432 if (os
.disk
<= D_NEGOTIATING
&& ns
.disk
> D_NEGOTIATING
)
1433 mod_timer(&mdev
->request_timer
, jiffies
+ HZ
);
1437 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
)
1440 if ((os
.disk
== D_ATTACHING
|| os
.disk
== D_NEGOTIATING
) &&
1441 ns
.disk
> D_NEGOTIATING
)
1442 what
= restart_frozen_disk_io
;
1444 if (what
!= nothing
)
1449 /* case1: The outdate peer handler is successful: */
1450 if (os
.pdsk
> D_OUTDATED
&& ns
.pdsk
<= D_OUTDATED
) {
1452 if (test_bit(NEW_CUR_UUID
, &mdev
->flags
)) {
1453 drbd_uuid_new_current(mdev
);
1454 clear_bit(NEW_CUR_UUID
, &mdev
->flags
);
1456 spin_lock_irq(&mdev
->req_lock
);
1457 _drbd_set_state(_NS(mdev
, susp_fen
, 0), CS_VERBOSE
, NULL
);
1458 spin_unlock_irq(&mdev
->req_lock
);
1460 /* case2: The connection was established again: */
1461 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
) {
1462 clear_bit(NEW_CUR_UUID
, &mdev
->flags
);
1468 if (what
!= nothing
) {
1469 spin_lock_irq(&mdev
->req_lock
);
1470 _tl_restart(mdev
, what
);
1471 nsm
.i
&= mdev
->state
.i
;
1472 _drbd_set_state(mdev
, nsm
, CS_VERBOSE
, NULL
);
1473 spin_unlock_irq(&mdev
->req_lock
);
1476 /* Became sync source. With protocol >= 96, we still need to send out
1477 * the sync uuid now. Need to do that before any drbd_send_state, or
1478 * the other side may go "paused sync" before receiving the sync uuids,
1479 * which is unexpected. */
1480 if ((os
.conn
!= C_SYNC_SOURCE
&& os
.conn
!= C_PAUSED_SYNC_S
) &&
1481 (ns
.conn
== C_SYNC_SOURCE
|| ns
.conn
== C_PAUSED_SYNC_S
) &&
1482 mdev
->agreed_pro_version
>= 96 && get_ldev(mdev
)) {
1483 drbd_gen_and_send_sync_uuid(mdev
);
1487 /* Do not change the order of the if above and the two below... */
1488 if (os
.pdsk
== D_DISKLESS
&& ns
.pdsk
> D_DISKLESS
) { /* attach on the peer */
1489 drbd_send_uuids(mdev
);
1490 drbd_send_state(mdev
);
1492 /* No point in queuing send_bitmap if we don't have a connection
1493 * anymore, so check also the _current_ state, not only the new state
1494 * at the time this work was queued. */
1495 if (os
.conn
!= C_WF_BITMAP_S
&& ns
.conn
== C_WF_BITMAP_S
&&
1496 mdev
->state
.conn
== C_WF_BITMAP_S
)
1497 drbd_queue_bitmap_io(mdev
, &drbd_send_bitmap
, NULL
,
1498 "send_bitmap (WFBitMapS)",
1499 BM_LOCKED_TEST_ALLOWED
);
1501 /* Lost contact to peer's copy of the data */
1502 if ((os
.pdsk
>= D_INCONSISTENT
&&
1503 os
.pdsk
!= D_UNKNOWN
&&
1504 os
.pdsk
!= D_OUTDATED
)
1505 && (ns
.pdsk
< D_INCONSISTENT
||
1506 ns
.pdsk
== D_UNKNOWN
||
1507 ns
.pdsk
== D_OUTDATED
)) {
1508 if (get_ldev(mdev
)) {
1509 if ((ns
.role
== R_PRIMARY
|| ns
.peer
== R_PRIMARY
) &&
1510 mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && ns
.disk
>= D_UP_TO_DATE
) {
1511 if (is_susp(mdev
->state
)) {
1512 set_bit(NEW_CUR_UUID
, &mdev
->flags
);
1514 drbd_uuid_new_current(mdev
);
1515 drbd_send_uuids(mdev
);
1522 if (ns
.pdsk
< D_INCONSISTENT
&& get_ldev(mdev
)) {
1523 if (os
.peer
== R_SECONDARY
&& ns
.peer
== R_PRIMARY
&&
1524 mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && ns
.disk
>= D_UP_TO_DATE
) {
1525 drbd_uuid_new_current(mdev
);
1526 drbd_send_uuids(mdev
);
1528 /* D_DISKLESS Peer becomes secondary */
1529 if (os
.peer
== R_PRIMARY
&& ns
.peer
== R_SECONDARY
)
1530 /* We may still be Primary ourselves.
1531 * No harm done if the bitmap still changes,
1532 * redirtied pages will follow later. */
1533 drbd_bitmap_io_from_worker(mdev
, &drbd_bm_write
,
1534 "demote diskless peer", BM_LOCKED_SET_ALLOWED
);
1538 /* Write out all changed bits on demote.
1539 * Though, no need to da that just yet
1540 * if there is a resync going on still */
1541 if (os
.role
== R_PRIMARY
&& ns
.role
== R_SECONDARY
&&
1542 mdev
->state
.conn
<= C_CONNECTED
&& get_ldev(mdev
)) {
1543 /* No changes to the bitmap expected this time, so assert that,
1544 * even though no harm was done if it did change. */
1545 drbd_bitmap_io_from_worker(mdev
, &drbd_bm_write
,
1546 "demote", BM_LOCKED_TEST_ALLOWED
);
1550 /* Last part of the attaching process ... */
1551 if (ns
.conn
>= C_CONNECTED
&&
1552 os
.disk
== D_ATTACHING
&& ns
.disk
== D_NEGOTIATING
) {
1553 drbd_send_sizes(mdev
, 0, 0); /* to start sync... */
1554 drbd_send_uuids(mdev
);
1555 drbd_send_state(mdev
);
1558 /* We want to pause/continue resync, tell peer. */
1559 if (ns
.conn
>= C_CONNECTED
&&
1560 ((os
.aftr_isp
!= ns
.aftr_isp
) ||
1561 (os
.user_isp
!= ns
.user_isp
)))
1562 drbd_send_state(mdev
);
1564 /* In case one of the isp bits got set, suspend other devices. */
1565 if ((!os
.aftr_isp
&& !os
.peer_isp
&& !os
.user_isp
) &&
1566 (ns
.aftr_isp
|| ns
.peer_isp
|| ns
.user_isp
))
1567 suspend_other_sg(mdev
);
1569 /* Make sure the peer gets informed about eventual state
1570 changes (ISP bits) while we were in WFReportParams. */
1571 if (os
.conn
== C_WF_REPORT_PARAMS
&& ns
.conn
>= C_CONNECTED
)
1572 drbd_send_state(mdev
);
1574 if (os
.conn
!= C_AHEAD
&& ns
.conn
== C_AHEAD
)
1575 drbd_send_state(mdev
);
1577 /* We are in the progress to start a full sync... */
1578 if ((os
.conn
!= C_STARTING_SYNC_T
&& ns
.conn
== C_STARTING_SYNC_T
) ||
1579 (os
.conn
!= C_STARTING_SYNC_S
&& ns
.conn
== C_STARTING_SYNC_S
))
1580 /* no other bitmap changes expected during this phase */
1581 drbd_queue_bitmap_io(mdev
,
1582 &drbd_bmio_set_n_write
, &abw_start_sync
,
1583 "set_n_write from StartingSync", BM_LOCKED_TEST_ALLOWED
);
1585 /* We are invalidating our self... */
1586 if (os
.conn
< C_CONNECTED
&& ns
.conn
< C_CONNECTED
&&
1587 os
.disk
> D_INCONSISTENT
&& ns
.disk
== D_INCONSISTENT
)
1588 /* other bitmap operation expected during this phase */
1589 drbd_queue_bitmap_io(mdev
, &drbd_bmio_set_n_write
, NULL
,
1590 "set_n_write from invalidate", BM_LOCKED_MASK
);
1592 /* first half of local IO error, failure to attach,
1593 * or administrative detach */
1594 if (os
.disk
!= D_FAILED
&& ns
.disk
== D_FAILED
) {
1595 enum drbd_io_error_p eh
;
1597 /* corresponding get_ldev was in __drbd_set_state, to serialize
1598 * our cleanup here with the transition to D_DISKLESS,
1599 * so it is safe to dreference ldev here. */
1600 eh
= mdev
->ldev
->dc
.on_io_error
;
1601 was_io_error
= test_and_clear_bit(WAS_IO_ERROR
, &mdev
->flags
);
1603 /* Immediately allow completion of all application IO, that waits
1604 for completion from the local disk. */
1605 tl_abort_disk_io(mdev
);
1607 /* current state still has to be D_FAILED,
1608 * there is only one way out: to D_DISKLESS,
1609 * and that may only happen after our put_ldev below. */
1610 if (mdev
->state
.disk
!= D_FAILED
)
1612 "ASSERT FAILED: disk is %s during detach\n",
1613 drbd_disk_str(mdev
->state
.disk
));
1615 if (drbd_send_state(mdev
))
1616 dev_info(DEV
, "Notified peer that I am detaching my disk\n");
1618 drbd_rs_cancel_all(mdev
);
1620 /* In case we want to get something to stable storage still,
1621 * this may be the last chance.
1622 * Following put_ldev may transition to D_DISKLESS. */
1626 if (was_io_error
&& eh
== EP_CALL_HELPER
)
1627 drbd_khelper(mdev
, "local-io-error");
1630 /* second half of local IO error, failure to attach,
1631 * or administrative detach,
1632 * after local_cnt references have reached zero again */
1633 if (os
.disk
!= D_DISKLESS
&& ns
.disk
== D_DISKLESS
) {
1634 /* We must still be diskless,
1635 * re-attach has to be serialized with this! */
1636 if (mdev
->state
.disk
!= D_DISKLESS
)
1638 "ASSERT FAILED: disk is %s while going diskless\n",
1639 drbd_disk_str(mdev
->state
.disk
));
1642 mdev
->rs_failed
= 0;
1643 atomic_set(&mdev
->rs_pending_cnt
, 0);
1645 if (drbd_send_state(mdev
))
1646 dev_info(DEV
, "Notified peer that I'm now diskless.\n");
1647 /* corresponding get_ldev in __drbd_set_state
1648 * this may finally trigger drbd_ldev_destroy. */
1652 /* Notify peer that I had a local IO error, and did not detached.. */
1653 if (os
.disk
== D_UP_TO_DATE
&& ns
.disk
== D_INCONSISTENT
)
1654 drbd_send_state(mdev
);
1656 /* Disks got bigger while they were detached */
1657 if (ns
.disk
> D_NEGOTIATING
&& ns
.pdsk
> D_NEGOTIATING
&&
1658 test_and_clear_bit(RESYNC_AFTER_NEG
, &mdev
->flags
)) {
1659 if (ns
.conn
== C_CONNECTED
)
1660 resync_after_online_grow(mdev
);
1663 /* A resync finished or aborted, wake paused devices... */
1664 if ((os
.conn
> C_CONNECTED
&& ns
.conn
<= C_CONNECTED
) ||
1665 (os
.peer_isp
&& !ns
.peer_isp
) ||
1666 (os
.user_isp
&& !ns
.user_isp
))
1667 resume_next_sg(mdev
);
1669 /* sync target done with resync. Explicitly notify peer, even though
1670 * it should (at least for non-empty resyncs) already know itself. */
1671 if (os
.disk
< D_UP_TO_DATE
&& os
.conn
>= C_SYNC_SOURCE
&& ns
.conn
== C_CONNECTED
)
1672 drbd_send_state(mdev
);
1674 /* This triggers bitmap writeout of potentially still unwritten pages
1675 * if the resync finished cleanly, or aborted because of peer disk
1676 * failure, or because of connection loss.
1677 * For resync aborted because of local disk failure, we cannot do
1678 * any bitmap writeout anymore.
1679 * No harm done if some bits change during this phase.
1681 if (os
.conn
> C_CONNECTED
&& ns
.conn
<= C_CONNECTED
&& get_ldev(mdev
)) {
1682 drbd_queue_bitmap_io(mdev
, &drbd_bm_write
, NULL
,
1683 "write from resync_finished", BM_LOCKED_SET_ALLOWED
);
1687 /* free tl_hash if we Got thawed and are C_STANDALONE */
1688 if (ns
.conn
== C_STANDALONE
&& !is_susp(ns
) && mdev
->tl_hash
)
1689 drbd_free_tl_hash(mdev
);
1691 /* Upon network connection, we need to start the receiver */
1692 if (os
.conn
== C_STANDALONE
&& ns
.conn
== C_UNCONNECTED
)
1693 drbd_thread_start(&mdev
->receiver
);
1695 /* Terminate worker thread if we are unconfigured - it will be
1696 restarted as needed... */
1697 if (ns
.disk
== D_DISKLESS
&&
1698 ns
.conn
== C_STANDALONE
&&
1699 ns
.role
== R_SECONDARY
) {
1700 if (os
.aftr_isp
!= ns
.aftr_isp
)
1701 resume_next_sg(mdev
);
1702 /* set in __drbd_set_state, unless CONFIG_PENDING was set */
1703 if (test_bit(DEVICE_DYING
, &mdev
->flags
))
1704 drbd_thread_stop_nowait(&mdev
->worker
);
1711 static int drbd_thread_setup(void *arg
)
1713 struct drbd_thread
*thi
= (struct drbd_thread
*) arg
;
1714 struct drbd_conf
*mdev
= thi
->mdev
;
1715 unsigned long flags
;
1719 retval
= thi
->function(thi
);
1721 spin_lock_irqsave(&thi
->t_lock
, flags
);
1723 /* if the receiver has been "Exiting", the last thing it did
1724 * was set the conn state to "StandAlone",
1725 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
1726 * and receiver thread will be "started".
1727 * drbd_thread_start needs to set "Restarting" in that case.
1728 * t_state check and assignment needs to be within the same spinlock,
1729 * so either thread_start sees Exiting, and can remap to Restarting,
1730 * or thread_start see None, and can proceed as normal.
1733 if (thi
->t_state
== Restarting
) {
1734 dev_info(DEV
, "Restarting %s\n", current
->comm
);
1735 thi
->t_state
= Running
;
1736 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1741 thi
->t_state
= None
;
1743 complete(&thi
->stop
);
1744 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1746 dev_info(DEV
, "Terminating %s\n", current
->comm
);
1748 /* Release mod reference taken when thread was started */
1749 module_put(THIS_MODULE
);
1753 static void drbd_thread_init(struct drbd_conf
*mdev
, struct drbd_thread
*thi
,
1754 int (*func
) (struct drbd_thread
*))
1756 spin_lock_init(&thi
->t_lock
);
1758 thi
->t_state
= None
;
1759 thi
->function
= func
;
1763 int drbd_thread_start(struct drbd_thread
*thi
)
1765 struct drbd_conf
*mdev
= thi
->mdev
;
1766 struct task_struct
*nt
;
1767 unsigned long flags
;
1770 thi
== &mdev
->receiver
? "receiver" :
1771 thi
== &mdev
->asender
? "asender" :
1772 thi
== &mdev
->worker
? "worker" : "NONSENSE";
1774 /* is used from state engine doing drbd_thread_stop_nowait,
1775 * while holding the req lock irqsave */
1776 spin_lock_irqsave(&thi
->t_lock
, flags
);
1778 switch (thi
->t_state
) {
1780 dev_info(DEV
, "Starting %s thread (from %s [%d])\n",
1781 me
, current
->comm
, current
->pid
);
1783 /* Get ref on module for thread - this is released when thread exits */
1784 if (!try_module_get(THIS_MODULE
)) {
1785 dev_err(DEV
, "Failed to get module reference in drbd_thread_start\n");
1786 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1790 init_completion(&thi
->stop
);
1791 D_ASSERT(thi
->task
== NULL
);
1792 thi
->reset_cpu_mask
= 1;
1793 thi
->t_state
= Running
;
1794 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1795 flush_signals(current
); /* otherw. may get -ERESTARTNOINTR */
1797 nt
= kthread_create(drbd_thread_setup
, (void *) thi
,
1798 "drbd%d_%s", mdev_to_minor(mdev
), me
);
1801 dev_err(DEV
, "Couldn't start thread\n");
1803 module_put(THIS_MODULE
);
1806 spin_lock_irqsave(&thi
->t_lock
, flags
);
1808 thi
->t_state
= Running
;
1809 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1810 wake_up_process(nt
);
1813 thi
->t_state
= Restarting
;
1814 dev_info(DEV
, "Restarting %s thread (from %s [%d])\n",
1815 me
, current
->comm
, current
->pid
);
1820 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1828 void _drbd_thread_stop(struct drbd_thread
*thi
, int restart
, int wait
)
1830 unsigned long flags
;
1832 enum drbd_thread_state ns
= restart
? Restarting
: Exiting
;
1834 /* may be called from state engine, holding the req lock irqsave */
1835 spin_lock_irqsave(&thi
->t_lock
, flags
);
1837 if (thi
->t_state
== None
) {
1838 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1840 drbd_thread_start(thi
);
1844 if (thi
->t_state
!= ns
) {
1845 if (thi
->task
== NULL
) {
1846 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1852 init_completion(&thi
->stop
);
1853 if (thi
->task
!= current
)
1854 force_sig(DRBD_SIGKILL
, thi
->task
);
1858 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1861 wait_for_completion(&thi
->stop
);
1866 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
1867 * @mdev: DRBD device.
1869 * Forces all threads of a device onto the same CPU. This is beneficial for
1870 * DRBD's performance. May be overwritten by user's configuration.
1872 void drbd_calc_cpu_mask(struct drbd_conf
*mdev
)
1876 /* user override. */
1877 if (cpumask_weight(mdev
->cpu_mask
))
1880 ord
= mdev_to_minor(mdev
) % cpumask_weight(cpu_online_mask
);
1881 for_each_online_cpu(cpu
) {
1883 cpumask_set_cpu(cpu
, mdev
->cpu_mask
);
1887 /* should not be reached */
1888 cpumask_setall(mdev
->cpu_mask
);
1892 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
1893 * @mdev: DRBD device.
1895 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
1898 void drbd_thread_current_set_cpu(struct drbd_conf
*mdev
)
1900 struct task_struct
*p
= current
;
1901 struct drbd_thread
*thi
=
1902 p
== mdev
->asender
.task
? &mdev
->asender
:
1903 p
== mdev
->receiver
.task
? &mdev
->receiver
:
1904 p
== mdev
->worker
.task
? &mdev
->worker
:
1908 if (!thi
->reset_cpu_mask
)
1910 thi
->reset_cpu_mask
= 0;
1911 set_cpus_allowed_ptr(p
, mdev
->cpu_mask
);
1915 /* the appropriate socket mutex must be held already */
1916 int _drbd_send_cmd(struct drbd_conf
*mdev
, struct socket
*sock
,
1917 enum drbd_packets cmd
, struct p_header80
*h
,
1918 size_t size
, unsigned msg_flags
)
1922 ERR_IF(!h
) return false;
1923 ERR_IF(!size
) return false;
1925 h
->magic
= BE_DRBD_MAGIC
;
1926 h
->command
= cpu_to_be16(cmd
);
1927 h
->length
= cpu_to_be16(size
-sizeof(struct p_header80
));
1929 sent
= drbd_send(mdev
, sock
, h
, size
, msg_flags
);
1931 ok
= (sent
== size
);
1932 if (!ok
&& !signal_pending(current
))
1933 dev_warn(DEV
, "short sent %s size=%d sent=%d\n",
1934 cmdname(cmd
), (int)size
, sent
);
1938 /* don't pass the socket. we may only look at it
1939 * when we hold the appropriate socket mutex.
1941 int drbd_send_cmd(struct drbd_conf
*mdev
, int use_data_socket
,
1942 enum drbd_packets cmd
, struct p_header80
*h
, size_t size
)
1945 struct socket
*sock
;
1947 if (use_data_socket
) {
1948 mutex_lock(&mdev
->data
.mutex
);
1949 sock
= mdev
->data
.socket
;
1951 mutex_lock(&mdev
->meta
.mutex
);
1952 sock
= mdev
->meta
.socket
;
1955 /* drbd_disconnect() could have called drbd_free_sock()
1956 * while we were waiting in down()... */
1957 if (likely(sock
!= NULL
))
1958 ok
= _drbd_send_cmd(mdev
, sock
, cmd
, h
, size
, 0);
1960 if (use_data_socket
)
1961 mutex_unlock(&mdev
->data
.mutex
);
1963 mutex_unlock(&mdev
->meta
.mutex
);
1967 int drbd_send_cmd2(struct drbd_conf
*mdev
, enum drbd_packets cmd
, char *data
,
1970 struct p_header80 h
;
1973 h
.magic
= BE_DRBD_MAGIC
;
1974 h
.command
= cpu_to_be16(cmd
);
1975 h
.length
= cpu_to_be16(size
);
1977 if (!drbd_get_data_sock(mdev
))
1981 drbd_send(mdev
, mdev
->data
.socket
, &h
, sizeof(h
), 0));
1983 drbd_send(mdev
, mdev
->data
.socket
, data
, size
, 0));
1985 drbd_put_data_sock(mdev
);
1990 int drbd_send_sync_param(struct drbd_conf
*mdev
, struct syncer_conf
*sc
)
1992 struct p_rs_param_95
*p
;
1993 struct socket
*sock
;
1995 const int apv
= mdev
->agreed_pro_version
;
1997 size
= apv
<= 87 ? sizeof(struct p_rs_param
)
1998 : apv
== 88 ? sizeof(struct p_rs_param
)
1999 + strlen(mdev
->sync_conf
.verify_alg
) + 1
2000 : apv
<= 94 ? sizeof(struct p_rs_param_89
)
2001 : /* apv >= 95 */ sizeof(struct p_rs_param_95
);
2003 /* used from admin command context and receiver/worker context.
2004 * to avoid kmalloc, grab the socket right here,
2005 * then use the pre-allocated sbuf there */
2006 mutex_lock(&mdev
->data
.mutex
);
2007 sock
= mdev
->data
.socket
;
2009 if (likely(sock
!= NULL
)) {
2010 enum drbd_packets cmd
= apv
>= 89 ? P_SYNC_PARAM89
: P_SYNC_PARAM
;
2012 p
= &mdev
->data
.sbuf
.rs_param_95
;
2014 /* initialize verify_alg and csums_alg */
2015 memset(p
->verify_alg
, 0, 2 * SHARED_SECRET_MAX
);
2017 p
->rate
= cpu_to_be32(sc
->rate
);
2018 p
->c_plan_ahead
= cpu_to_be32(sc
->c_plan_ahead
);
2019 p
->c_delay_target
= cpu_to_be32(sc
->c_delay_target
);
2020 p
->c_fill_target
= cpu_to_be32(sc
->c_fill_target
);
2021 p
->c_max_rate
= cpu_to_be32(sc
->c_max_rate
);
2024 strcpy(p
->verify_alg
, mdev
->sync_conf
.verify_alg
);
2026 strcpy(p
->csums_alg
, mdev
->sync_conf
.csums_alg
);
2028 rv
= _drbd_send_cmd(mdev
, sock
, cmd
, &p
->head
, size
, 0);
2030 rv
= 0; /* not ok */
2032 mutex_unlock(&mdev
->data
.mutex
);
2037 int drbd_send_protocol(struct drbd_conf
*mdev
)
2039 struct p_protocol
*p
;
2042 size
= sizeof(struct p_protocol
);
2044 if (mdev
->agreed_pro_version
>= 87)
2045 size
+= strlen(mdev
->net_conf
->integrity_alg
) + 1;
2047 /* we must not recurse into our own queue,
2048 * as that is blocked during handshake */
2049 p
= kmalloc(size
, GFP_NOIO
);
2053 p
->protocol
= cpu_to_be32(mdev
->net_conf
->wire_protocol
);
2054 p
->after_sb_0p
= cpu_to_be32(mdev
->net_conf
->after_sb_0p
);
2055 p
->after_sb_1p
= cpu_to_be32(mdev
->net_conf
->after_sb_1p
);
2056 p
->after_sb_2p
= cpu_to_be32(mdev
->net_conf
->after_sb_2p
);
2057 p
->two_primaries
= cpu_to_be32(mdev
->net_conf
->two_primaries
);
2060 if (mdev
->net_conf
->want_lose
)
2062 if (mdev
->net_conf
->dry_run
) {
2063 if (mdev
->agreed_pro_version
>= 92)
2066 dev_err(DEV
, "--dry-run is not supported by peer");
2071 p
->conn_flags
= cpu_to_be32(cf
);
2073 if (mdev
->agreed_pro_version
>= 87)
2074 strcpy(p
->integrity_alg
, mdev
->net_conf
->integrity_alg
);
2076 rv
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_PROTOCOL
,
2077 (struct p_header80
*)p
, size
);
2082 int _drbd_send_uuids(struct drbd_conf
*mdev
, u64 uuid_flags
)
2087 if (!get_ldev_if_state(mdev
, D_NEGOTIATING
))
2090 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
2091 p
.uuid
[i
] = mdev
->ldev
? cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]) : 0;
2093 mdev
->comm_bm_set
= drbd_bm_total_weight(mdev
);
2094 p
.uuid
[UI_SIZE
] = cpu_to_be64(mdev
->comm_bm_set
);
2095 uuid_flags
|= mdev
->net_conf
->want_lose
? 1 : 0;
2096 uuid_flags
|= test_bit(CRASHED_PRIMARY
, &mdev
->flags
) ? 2 : 0;
2097 uuid_flags
|= mdev
->new_state_tmp
.disk
== D_INCONSISTENT
? 4 : 0;
2098 p
.uuid
[UI_FLAGS
] = cpu_to_be64(uuid_flags
);
2102 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_UUIDS
,
2103 (struct p_header80
*)&p
, sizeof(p
));
2106 int drbd_send_uuids(struct drbd_conf
*mdev
)
2108 return _drbd_send_uuids(mdev
, 0);
2111 int drbd_send_uuids_skip_initial_sync(struct drbd_conf
*mdev
)
2113 return _drbd_send_uuids(mdev
, 8);
2116 void drbd_print_uuids(struct drbd_conf
*mdev
, const char *text
)
2118 if (get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
2119 u64
*uuid
= mdev
->ldev
->md
.uuid
;
2120 dev_info(DEV
, "%s %016llX:%016llX:%016llX:%016llX\n",
2122 (unsigned long long)uuid
[UI_CURRENT
],
2123 (unsigned long long)uuid
[UI_BITMAP
],
2124 (unsigned long long)uuid
[UI_HISTORY_START
],
2125 (unsigned long long)uuid
[UI_HISTORY_END
]);
2128 dev_info(DEV
, "%s effective data uuid: %016llX\n",
2130 (unsigned long long)mdev
->ed_uuid
);
2134 int drbd_gen_and_send_sync_uuid(struct drbd_conf
*mdev
)
2139 D_ASSERT(mdev
->state
.disk
== D_UP_TO_DATE
);
2141 uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
] + UUID_NEW_BM_OFFSET
;
2142 drbd_uuid_set(mdev
, UI_BITMAP
, uuid
);
2143 drbd_print_uuids(mdev
, "updated sync UUID");
2145 p
.uuid
= cpu_to_be64(uuid
);
2147 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_SYNC_UUID
,
2148 (struct p_header80
*)&p
, sizeof(p
));
2151 int drbd_send_sizes(struct drbd_conf
*mdev
, int trigger_reply
, enum dds_flags flags
)
2154 sector_t d_size
, u_size
;
2155 int q_order_type
, max_bio_size
;
2158 if (get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
2159 D_ASSERT(mdev
->ldev
->backing_bdev
);
2160 d_size
= drbd_get_max_capacity(mdev
->ldev
);
2161 u_size
= mdev
->ldev
->dc
.disk_size
;
2162 q_order_type
= drbd_queue_order_type(mdev
);
2163 max_bio_size
= queue_max_hw_sectors(mdev
->ldev
->backing_bdev
->bd_disk
->queue
) << 9;
2164 max_bio_size
= min_t(int, max_bio_size
, DRBD_MAX_BIO_SIZE
);
2169 q_order_type
= QUEUE_ORDERED_NONE
;
2170 max_bio_size
= DRBD_MAX_BIO_SIZE
; /* ... multiple BIOs per peer_request */
2173 /* Never allow old drbd (up to 8.3.7) to see more than 32KiB */
2174 if (mdev
->agreed_pro_version
<= 94)
2175 max_bio_size
= min_t(int, max_bio_size
, DRBD_MAX_SIZE_H80_PACKET
);
2177 p
.d_size
= cpu_to_be64(d_size
);
2178 p
.u_size
= cpu_to_be64(u_size
);
2179 p
.c_size
= cpu_to_be64(trigger_reply
? 0 : drbd_get_capacity(mdev
->this_bdev
));
2180 p
.max_bio_size
= cpu_to_be32(max_bio_size
);
2181 p
.queue_order_type
= cpu_to_be16(q_order_type
);
2182 p
.dds_flags
= cpu_to_be16(flags
);
2184 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_SIZES
,
2185 (struct p_header80
*)&p
, sizeof(p
));
2190 * drbd_send_state() - Sends the drbd state to the peer
2191 * @mdev: DRBD device.
2193 int drbd_send_state(struct drbd_conf
*mdev
)
2195 struct socket
*sock
;
2199 /* Grab state lock so we wont send state if we're in the middle
2200 * of a cluster wide state change on another thread */
2201 drbd_state_lock(mdev
);
2203 mutex_lock(&mdev
->data
.mutex
);
2205 p
.state
= cpu_to_be32(mdev
->state
.i
); /* Within the send mutex */
2206 sock
= mdev
->data
.socket
;
2208 if (likely(sock
!= NULL
)) {
2209 ok
= _drbd_send_cmd(mdev
, sock
, P_STATE
,
2210 (struct p_header80
*)&p
, sizeof(p
), 0);
2213 mutex_unlock(&mdev
->data
.mutex
);
2215 drbd_state_unlock(mdev
);
2219 int drbd_send_state_req(struct drbd_conf
*mdev
,
2220 union drbd_state mask
, union drbd_state val
)
2222 struct p_req_state p
;
2224 p
.mask
= cpu_to_be32(mask
.i
);
2225 p
.val
= cpu_to_be32(val
.i
);
2227 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_STATE_CHG_REQ
,
2228 (struct p_header80
*)&p
, sizeof(p
));
2231 int drbd_send_sr_reply(struct drbd_conf
*mdev
, enum drbd_state_rv retcode
)
2233 struct p_req_state_reply p
;
2235 p
.retcode
= cpu_to_be32(retcode
);
2237 return drbd_send_cmd(mdev
, USE_META_SOCKET
, P_STATE_CHG_REPLY
,
2238 (struct p_header80
*)&p
, sizeof(p
));
2241 int fill_bitmap_rle_bits(struct drbd_conf
*mdev
,
2242 struct p_compressed_bm
*p
,
2243 struct bm_xfer_ctx
*c
)
2245 struct bitstream bs
;
2246 unsigned long plain_bits
;
2253 /* may we use this feature? */
2254 if ((mdev
->sync_conf
.use_rle
== 0) ||
2255 (mdev
->agreed_pro_version
< 90))
2258 if (c
->bit_offset
>= c
->bm_bits
)
2259 return 0; /* nothing to do. */
2261 /* use at most thus many bytes */
2262 bitstream_init(&bs
, p
->code
, BM_PACKET_VLI_BYTES_MAX
, 0);
2263 memset(p
->code
, 0, BM_PACKET_VLI_BYTES_MAX
);
2264 /* plain bits covered in this code string */
2267 /* p->encoding & 0x80 stores whether the first run length is set.
2268 * bit offset is implicit.
2269 * start with toggle == 2 to be able to tell the first iteration */
2272 /* see how much plain bits we can stuff into one packet
2273 * using RLE and VLI. */
2275 tmp
= (toggle
== 0) ? _drbd_bm_find_next_zero(mdev
, c
->bit_offset
)
2276 : _drbd_bm_find_next(mdev
, c
->bit_offset
);
2279 rl
= tmp
- c
->bit_offset
;
2281 if (toggle
== 2) { /* first iteration */
2283 /* the first checked bit was set,
2284 * store start value, */
2285 DCBP_set_start(p
, 1);
2286 /* but skip encoding of zero run length */
2290 DCBP_set_start(p
, 0);
2293 /* paranoia: catch zero runlength.
2294 * can only happen if bitmap is modified while we scan it. */
2296 dev_err(DEV
, "unexpected zero runlength while encoding bitmap "
2297 "t:%u bo:%lu\n", toggle
, c
->bit_offset
);
2301 bits
= vli_encode_bits(&bs
, rl
);
2302 if (bits
== -ENOBUFS
) /* buffer full */
2305 dev_err(DEV
, "error while encoding bitmap: %d\n", bits
);
2311 c
->bit_offset
= tmp
;
2312 } while (c
->bit_offset
< c
->bm_bits
);
2314 len
= bs
.cur
.b
- p
->code
+ !!bs
.cur
.bit
;
2316 if (plain_bits
< (len
<< 3)) {
2317 /* incompressible with this method.
2318 * we need to rewind both word and bit position. */
2319 c
->bit_offset
-= plain_bits
;
2320 bm_xfer_ctx_bit_to_word_offset(c
);
2321 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
2325 /* RLE + VLI was able to compress it just fine.
2326 * update c->word_offset. */
2327 bm_xfer_ctx_bit_to_word_offset(c
);
2329 /* store pad_bits */
2330 DCBP_set_pad_bits(p
, (8 - bs
.cur
.bit
) & 0x7);
2336 * send_bitmap_rle_or_plain
2338 * Return 0 when done, 1 when another iteration is needed, and a negative error
2339 * code upon failure.
2342 send_bitmap_rle_or_plain(struct drbd_conf
*mdev
,
2343 struct p_header80
*h
, struct bm_xfer_ctx
*c
)
2345 struct p_compressed_bm
*p
= (void*)h
;
2346 unsigned long num_words
;
2350 len
= fill_bitmap_rle_bits(mdev
, p
, c
);
2356 DCBP_set_code(p
, RLE_VLI_Bits
);
2357 ok
= _drbd_send_cmd(mdev
, mdev
->data
.socket
, P_COMPRESSED_BITMAP
, h
,
2358 sizeof(*p
) + len
, 0);
2361 c
->bytes
[0] += sizeof(*p
) + len
;
2363 if (c
->bit_offset
>= c
->bm_bits
)
2366 /* was not compressible.
2367 * send a buffer full of plain text bits instead. */
2368 num_words
= min_t(size_t, BM_PACKET_WORDS
, c
->bm_words
- c
->word_offset
);
2369 len
= num_words
* sizeof(long);
2371 drbd_bm_get_lel(mdev
, c
->word_offset
, num_words
, (unsigned long*)h
->payload
);
2372 ok
= _drbd_send_cmd(mdev
, mdev
->data
.socket
, P_BITMAP
,
2373 h
, sizeof(struct p_header80
) + len
, 0);
2374 c
->word_offset
+= num_words
;
2375 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
2378 c
->bytes
[1] += sizeof(struct p_header80
) + len
;
2380 if (c
->bit_offset
> c
->bm_bits
)
2381 c
->bit_offset
= c
->bm_bits
;
2385 INFO_bm_xfer_stats(mdev
, "send", c
);
2393 /* See the comment at receive_bitmap() */
2394 int _drbd_send_bitmap(struct drbd_conf
*mdev
)
2396 struct bm_xfer_ctx c
;
2397 struct p_header80
*p
;
2400 ERR_IF(!mdev
->bitmap
) return false;
2402 /* maybe we should use some per thread scratch page,
2403 * and allocate that during initial device creation? */
2404 p
= (struct p_header80
*) __get_free_page(GFP_NOIO
);
2406 dev_err(DEV
, "failed to allocate one page buffer in %s\n", __func__
);
2410 if (get_ldev(mdev
)) {
2411 if (drbd_md_test_flag(mdev
->ldev
, MDF_FULL_SYNC
)) {
2412 dev_info(DEV
, "Writing the whole bitmap, MDF_FullSync was set.\n");
2413 drbd_bm_set_all(mdev
);
2414 if (drbd_bm_write(mdev
)) {
2415 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
2416 * but otherwise process as per normal - need to tell other
2417 * side that a full resync is required! */
2418 dev_err(DEV
, "Failed to write bitmap to disk!\n");
2420 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
2427 c
= (struct bm_xfer_ctx
) {
2428 .bm_bits
= drbd_bm_bits(mdev
),
2429 .bm_words
= drbd_bm_words(mdev
),
2433 err
= send_bitmap_rle_or_plain(mdev
, p
, &c
);
2436 free_page((unsigned long) p
);
2440 int drbd_send_bitmap(struct drbd_conf
*mdev
)
2444 if (!drbd_get_data_sock(mdev
))
2446 err
= !_drbd_send_bitmap(mdev
);
2447 drbd_put_data_sock(mdev
);
2451 int drbd_send_b_ack(struct drbd_conf
*mdev
, u32 barrier_nr
, u32 set_size
)
2454 struct p_barrier_ack p
;
2456 p
.barrier
= barrier_nr
;
2457 p
.set_size
= cpu_to_be32(set_size
);
2459 if (mdev
->state
.conn
< C_CONNECTED
)
2461 ok
= drbd_send_cmd(mdev
, USE_META_SOCKET
, P_BARRIER_ACK
,
2462 (struct p_header80
*)&p
, sizeof(p
));
2467 * _drbd_send_ack() - Sends an ack packet
2468 * @mdev: DRBD device.
2469 * @cmd: Packet command code.
2470 * @sector: sector, needs to be in big endian byte order
2471 * @blksize: size in byte, needs to be in big endian byte order
2472 * @block_id: Id, big endian byte order
2474 static int _drbd_send_ack(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2480 struct p_block_ack p
;
2483 p
.block_id
= block_id
;
2484 p
.blksize
= blksize
;
2485 p
.seq_num
= cpu_to_be32(atomic_add_return(1, &mdev
->packet_seq
));
2487 if (!mdev
->meta
.socket
|| mdev
->state
.conn
< C_CONNECTED
)
2489 ok
= drbd_send_cmd(mdev
, USE_META_SOCKET
, cmd
,
2490 (struct p_header80
*)&p
, sizeof(p
));
2494 /* dp->sector and dp->block_id already/still in network byte order,
2495 * data_size is payload size according to dp->head,
2496 * and may need to be corrected for digest size. */
2497 int drbd_send_ack_dp(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2498 struct p_data
*dp
, int data_size
)
2500 data_size
-= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_r_tfm
) ?
2501 crypto_hash_digestsize(mdev
->integrity_r_tfm
) : 0;
2502 return _drbd_send_ack(mdev
, cmd
, dp
->sector
, cpu_to_be32(data_size
),
2506 int drbd_send_ack_rp(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2507 struct p_block_req
*rp
)
2509 return _drbd_send_ack(mdev
, cmd
, rp
->sector
, rp
->blksize
, rp
->block_id
);
2513 * drbd_send_ack() - Sends an ack packet
2514 * @mdev: DRBD device.
2515 * @cmd: Packet command code.
2518 int drbd_send_ack(struct drbd_conf
*mdev
,
2519 enum drbd_packets cmd
, struct drbd_epoch_entry
*e
)
2521 return _drbd_send_ack(mdev
, cmd
,
2522 cpu_to_be64(e
->sector
),
2523 cpu_to_be32(e
->size
),
2527 /* This function misuses the block_id field to signal if the blocks
2528 * are is sync or not. */
2529 int drbd_send_ack_ex(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2530 sector_t sector
, int blksize
, u64 block_id
)
2532 return _drbd_send_ack(mdev
, cmd
,
2533 cpu_to_be64(sector
),
2534 cpu_to_be32(blksize
),
2535 cpu_to_be64(block_id
));
2538 int drbd_send_drequest(struct drbd_conf
*mdev
, int cmd
,
2539 sector_t sector
, int size
, u64 block_id
)
2542 struct p_block_req p
;
2544 p
.sector
= cpu_to_be64(sector
);
2545 p
.block_id
= block_id
;
2546 p
.blksize
= cpu_to_be32(size
);
2548 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, cmd
,
2549 (struct p_header80
*)&p
, sizeof(p
));
2553 int drbd_send_drequest_csum(struct drbd_conf
*mdev
,
2554 sector_t sector
, int size
,
2555 void *digest
, int digest_size
,
2556 enum drbd_packets cmd
)
2559 struct p_block_req p
;
2561 p
.sector
= cpu_to_be64(sector
);
2562 p
.block_id
= BE_DRBD_MAGIC
+ 0xbeef;
2563 p
.blksize
= cpu_to_be32(size
);
2565 p
.head
.magic
= BE_DRBD_MAGIC
;
2566 p
.head
.command
= cpu_to_be16(cmd
);
2567 p
.head
.length
= cpu_to_be16(sizeof(p
) - sizeof(struct p_header80
) + digest_size
);
2569 mutex_lock(&mdev
->data
.mutex
);
2571 ok
= (sizeof(p
) == drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), 0));
2572 ok
= ok
&& (digest_size
== drbd_send(mdev
, mdev
->data
.socket
, digest
, digest_size
, 0));
2574 mutex_unlock(&mdev
->data
.mutex
);
2579 int drbd_send_ov_request(struct drbd_conf
*mdev
, sector_t sector
, int size
)
2582 struct p_block_req p
;
2584 p
.sector
= cpu_to_be64(sector
);
2585 p
.block_id
= BE_DRBD_MAGIC
+ 0xbabe;
2586 p
.blksize
= cpu_to_be32(size
);
2588 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_OV_REQUEST
,
2589 (struct p_header80
*)&p
, sizeof(p
));
2593 /* called on sndtimeo
2594 * returns false if we should retry,
2595 * true if we think connection is dead
2597 static int we_should_drop_the_connection(struct drbd_conf
*mdev
, struct socket
*sock
)
2600 /* long elapsed = (long)(jiffies - mdev->last_received); */
2602 drop_it
= mdev
->meta
.socket
== sock
2603 || !mdev
->asender
.task
2604 || get_t_state(&mdev
->asender
) != Running
2605 || mdev
->state
.conn
< C_CONNECTED
;
2610 drop_it
= !--mdev
->ko_count
;
2612 dev_err(DEV
, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
2613 current
->comm
, current
->pid
, mdev
->ko_count
);
2617 return drop_it
; /* && (mdev->state == R_PRIMARY) */;
2620 /* The idea of sendpage seems to be to put some kind of reference
2621 * to the page into the skb, and to hand it over to the NIC. In
2622 * this process get_page() gets called.
2624 * As soon as the page was really sent over the network put_page()
2625 * gets called by some part of the network layer. [ NIC driver? ]
2627 * [ get_page() / put_page() increment/decrement the count. If count
2628 * reaches 0 the page will be freed. ]
2630 * This works nicely with pages from FSs.
2631 * But this means that in protocol A we might signal IO completion too early!
2633 * In order not to corrupt data during a resync we must make sure
2634 * that we do not reuse our own buffer pages (EEs) to early, therefore
2635 * we have the net_ee list.
2637 * XFS seems to have problems, still, it submits pages with page_count == 0!
2638 * As a workaround, we disable sendpage on pages
2639 * with page_count == 0 or PageSlab.
2641 static int _drbd_no_send_page(struct drbd_conf
*mdev
, struct page
*page
,
2642 int offset
, size_t size
, unsigned msg_flags
)
2644 int sent
= drbd_send(mdev
, mdev
->data
.socket
, kmap(page
) + offset
, size
, msg_flags
);
2647 mdev
->send_cnt
+= size
>>9;
2648 return sent
== size
;
2651 static int _drbd_send_page(struct drbd_conf
*mdev
, struct page
*page
,
2652 int offset
, size_t size
, unsigned msg_flags
)
2654 mm_segment_t oldfs
= get_fs();
2658 /* e.g. XFS meta- & log-data is in slab pages, which have a
2659 * page_count of 0 and/or have PageSlab() set.
2660 * we cannot use send_page for those, as that does get_page();
2661 * put_page(); and would cause either a VM_BUG directly, or
2662 * __page_cache_release a page that would actually still be referenced
2663 * by someone, leading to some obscure delayed Oops somewhere else. */
2664 if (disable_sendpage
|| (page_count(page
) < 1) || PageSlab(page
))
2665 return _drbd_no_send_page(mdev
, page
, offset
, size
, msg_flags
);
2667 msg_flags
|= MSG_NOSIGNAL
;
2668 drbd_update_congested(mdev
);
2671 sent
= mdev
->data
.socket
->ops
->sendpage(mdev
->data
.socket
, page
,
2674 if (sent
== -EAGAIN
) {
2675 if (we_should_drop_the_connection(mdev
,
2682 dev_warn(DEV
, "%s: size=%d len=%d sent=%d\n",
2683 __func__
, (int)size
, len
, sent
);
2688 } while (len
> 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
2690 clear_bit(NET_CONGESTED
, &mdev
->flags
);
2694 mdev
->send_cnt
+= size
>>9;
2698 static int _drbd_send_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
2700 struct bio_vec
*bvec
;
2702 /* hint all but last page with MSG_MORE */
2703 __bio_for_each_segment(bvec
, bio
, i
, 0) {
2704 if (!_drbd_no_send_page(mdev
, bvec
->bv_page
,
2705 bvec
->bv_offset
, bvec
->bv_len
,
2706 i
== bio
->bi_vcnt
-1 ? 0 : MSG_MORE
))
2712 static int _drbd_send_zc_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
2714 struct bio_vec
*bvec
;
2716 /* hint all but last page with MSG_MORE */
2717 __bio_for_each_segment(bvec
, bio
, i
, 0) {
2718 if (!_drbd_send_page(mdev
, bvec
->bv_page
,
2719 bvec
->bv_offset
, bvec
->bv_len
,
2720 i
== bio
->bi_vcnt
-1 ? 0 : MSG_MORE
))
2726 static int _drbd_send_zc_ee(struct drbd_conf
*mdev
, struct drbd_epoch_entry
*e
)
2728 struct page
*page
= e
->pages
;
2729 unsigned len
= e
->size
;
2730 /* hint all but last page with MSG_MORE */
2731 page_chain_for_each(page
) {
2732 unsigned l
= min_t(unsigned, len
, PAGE_SIZE
);
2733 if (!_drbd_send_page(mdev
, page
, 0, l
,
2734 page_chain_next(page
) ? MSG_MORE
: 0))
2741 static u32
bio_flags_to_wire(struct drbd_conf
*mdev
, unsigned long bi_rw
)
2743 if (mdev
->agreed_pro_version
>= 95)
2744 return (bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0) |
2745 (bi_rw
& REQ_FUA
? DP_FUA
: 0) |
2746 (bi_rw
& REQ_FLUSH
? DP_FLUSH
: 0) |
2747 (bi_rw
& REQ_DISCARD
? DP_DISCARD
: 0);
2749 return bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0;
2752 /* Used to send write requests
2753 * R_PRIMARY -> Peer (P_DATA)
2755 int drbd_send_dblock(struct drbd_conf
*mdev
, struct drbd_request
*req
)
2759 unsigned int dp_flags
= 0;
2763 if (!drbd_get_data_sock(mdev
))
2766 dgs
= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_w_tfm
) ?
2767 crypto_hash_digestsize(mdev
->integrity_w_tfm
) : 0;
2769 if (req
->size
<= DRBD_MAX_SIZE_H80_PACKET
) {
2770 p
.head
.h80
.magic
= BE_DRBD_MAGIC
;
2771 p
.head
.h80
.command
= cpu_to_be16(P_DATA
);
2773 cpu_to_be16(sizeof(p
) - sizeof(union p_header
) + dgs
+ req
->size
);
2775 p
.head
.h95
.magic
= BE_DRBD_MAGIC_BIG
;
2776 p
.head
.h95
.command
= cpu_to_be16(P_DATA
);
2778 cpu_to_be32(sizeof(p
) - sizeof(union p_header
) + dgs
+ req
->size
);
2781 p
.sector
= cpu_to_be64(req
->sector
);
2782 p
.block_id
= (unsigned long)req
;
2783 p
.seq_num
= cpu_to_be32(req
->seq_num
=
2784 atomic_add_return(1, &mdev
->packet_seq
));
2786 dp_flags
= bio_flags_to_wire(mdev
, req
->master_bio
->bi_rw
);
2788 if (mdev
->state
.conn
>= C_SYNC_SOURCE
&&
2789 mdev
->state
.conn
<= C_PAUSED_SYNC_T
)
2790 dp_flags
|= DP_MAY_SET_IN_SYNC
;
2792 p
.dp_flags
= cpu_to_be32(dp_flags
);
2793 set_bit(UNPLUG_REMOTE
, &mdev
->flags
);
2795 drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), dgs
? MSG_MORE
: 0));
2797 dgb
= mdev
->int_dig_out
;
2798 drbd_csum_bio(mdev
, mdev
->integrity_w_tfm
, req
->master_bio
, dgb
);
2799 ok
= dgs
== drbd_send(mdev
, mdev
->data
.socket
, dgb
, dgs
, 0);
2802 /* For protocol A, we have to memcpy the payload into
2803 * socket buffers, as we may complete right away
2804 * as soon as we handed it over to tcp, at which point the data
2805 * pages may become invalid.
2807 * For data-integrity enabled, we copy it as well, so we can be
2808 * sure that even if the bio pages may still be modified, it
2809 * won't change the data on the wire, thus if the digest checks
2810 * out ok after sending on this side, but does not fit on the
2811 * receiving side, we sure have detected corruption elsewhere.
2813 if (mdev
->net_conf
->wire_protocol
== DRBD_PROT_A
|| dgs
)
2814 ok
= _drbd_send_bio(mdev
, req
->master_bio
);
2816 ok
= _drbd_send_zc_bio(mdev
, req
->master_bio
);
2818 /* double check digest, sometimes buffers have been modified in flight. */
2819 if (dgs
> 0 && dgs
<= 64) {
2820 /* 64 byte, 512 bit, is the largest digest size
2821 * currently supported in kernel crypto. */
2822 unsigned char digest
[64];
2823 drbd_csum_bio(mdev
, mdev
->integrity_w_tfm
, req
->master_bio
, digest
);
2824 if (memcmp(mdev
->int_dig_out
, digest
, dgs
)) {
2826 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
2827 (unsigned long long)req
->sector
, req
->size
);
2829 } /* else if (dgs > 64) {
2830 ... Be noisy about digest too large ...
2834 drbd_put_data_sock(mdev
);
2839 /* answer packet, used to send data back for read requests:
2840 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
2841 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
2843 int drbd_send_block(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2844 struct drbd_epoch_entry
*e
)
2851 dgs
= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_w_tfm
) ?
2852 crypto_hash_digestsize(mdev
->integrity_w_tfm
) : 0;
2854 if (e
->size
<= DRBD_MAX_SIZE_H80_PACKET
) {
2855 p
.head
.h80
.magic
= BE_DRBD_MAGIC
;
2856 p
.head
.h80
.command
= cpu_to_be16(cmd
);
2858 cpu_to_be16(sizeof(p
) - sizeof(struct p_header80
) + dgs
+ e
->size
);
2860 p
.head
.h95
.magic
= BE_DRBD_MAGIC_BIG
;
2861 p
.head
.h95
.command
= cpu_to_be16(cmd
);
2863 cpu_to_be32(sizeof(p
) - sizeof(struct p_header80
) + dgs
+ e
->size
);
2866 p
.sector
= cpu_to_be64(e
->sector
);
2867 p
.block_id
= e
->block_id
;
2868 /* p.seq_num = 0; No sequence numbers here.. */
2870 /* Only called by our kernel thread.
2871 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
2872 * in response to admin command or module unload.
2874 if (!drbd_get_data_sock(mdev
))
2877 ok
= sizeof(p
) == drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), dgs
? MSG_MORE
: 0);
2879 dgb
= mdev
->int_dig_out
;
2880 drbd_csum_ee(mdev
, mdev
->integrity_w_tfm
, e
, dgb
);
2881 ok
= dgs
== drbd_send(mdev
, mdev
->data
.socket
, dgb
, dgs
, 0);
2884 ok
= _drbd_send_zc_ee(mdev
, e
);
2886 drbd_put_data_sock(mdev
);
2891 int drbd_send_oos(struct drbd_conf
*mdev
, struct drbd_request
*req
)
2893 struct p_block_desc p
;
2895 p
.sector
= cpu_to_be64(req
->sector
);
2896 p
.blksize
= cpu_to_be32(req
->size
);
2898 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_OUT_OF_SYNC
, &p
.head
, sizeof(p
));
2902 drbd_send distinguishes two cases:
2904 Packets sent via the data socket "sock"
2905 and packets sent via the meta data socket "msock"
2908 -----------------+-------------------------+------------------------------
2909 timeout conf.timeout / 2 conf.timeout / 2
2910 timeout action send a ping via msock Abort communication
2911 and close all sockets
2915 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
2917 int drbd_send(struct drbd_conf
*mdev
, struct socket
*sock
,
2918 void *buf
, size_t size
, unsigned msg_flags
)
2927 /* THINK if (signal_pending) return ... ? */
2932 msg
.msg_name
= NULL
;
2933 msg
.msg_namelen
= 0;
2934 msg
.msg_control
= NULL
;
2935 msg
.msg_controllen
= 0;
2936 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
2938 if (sock
== mdev
->data
.socket
) {
2939 mdev
->ko_count
= mdev
->net_conf
->ko_count
;
2940 drbd_update_congested(mdev
);
2944 * tcp_sendmsg does _not_ use its size parameter at all ?
2946 * -EAGAIN on timeout, -EINTR on signal.
2949 * do we need to block DRBD_SIG if sock == &meta.socket ??
2950 * otherwise wake_asender() might interrupt some send_*Ack !
2952 rv
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
2953 if (rv
== -EAGAIN
) {
2954 if (we_should_drop_the_connection(mdev
, sock
))
2961 flush_signals(current
);
2969 } while (sent
< size
);
2971 if (sock
== mdev
->data
.socket
)
2972 clear_bit(NET_CONGESTED
, &mdev
->flags
);
2975 if (rv
!= -EAGAIN
) {
2976 dev_err(DEV
, "%s_sendmsg returned %d\n",
2977 sock
== mdev
->meta
.socket
? "msock" : "sock",
2979 drbd_force_state(mdev
, NS(conn
, C_BROKEN_PIPE
));
2981 drbd_force_state(mdev
, NS(conn
, C_TIMEOUT
));
2987 static int drbd_open(struct block_device
*bdev
, fmode_t mode
)
2989 struct drbd_conf
*mdev
= bdev
->bd_disk
->private_data
;
2990 unsigned long flags
;
2993 mutex_lock(&drbd_main_mutex
);
2994 spin_lock_irqsave(&mdev
->req_lock
, flags
);
2995 /* to have a stable mdev->state.role
2996 * and no race with updating open_cnt */
2998 if (mdev
->state
.role
!= R_PRIMARY
) {
2999 if (mode
& FMODE_WRITE
)
3001 else if (!allow_oos
)
3007 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
3008 mutex_unlock(&drbd_main_mutex
);
3013 static int drbd_release(struct gendisk
*gd
, fmode_t mode
)
3015 struct drbd_conf
*mdev
= gd
->private_data
;
3016 mutex_lock(&drbd_main_mutex
);
3018 mutex_unlock(&drbd_main_mutex
);
3022 static void drbd_set_defaults(struct drbd_conf
*mdev
)
3024 /* This way we get a compile error when sync_conf grows,
3025 and we forgot to initialize it here */
3026 mdev
->sync_conf
= (struct syncer_conf
) {
3027 /* .rate = */ DRBD_RATE_DEF
,
3028 /* .after = */ DRBD_AFTER_DEF
,
3029 /* .al_extents = */ DRBD_AL_EXTENTS_DEF
,
3030 /* .verify_alg = */ {}, 0,
3031 /* .cpu_mask = */ {}, 0,
3032 /* .csums_alg = */ {}, 0,
3034 /* .on_no_data = */ DRBD_ON_NO_DATA_DEF
,
3035 /* .c_plan_ahead = */ DRBD_C_PLAN_AHEAD_DEF
,
3036 /* .c_delay_target = */ DRBD_C_DELAY_TARGET_DEF
,
3037 /* .c_fill_target = */ DRBD_C_FILL_TARGET_DEF
,
3038 /* .c_max_rate = */ DRBD_C_MAX_RATE_DEF
,
3039 /* .c_min_rate = */ DRBD_C_MIN_RATE_DEF
3042 /* Have to use that way, because the layout differs between
3043 big endian and little endian */
3044 mdev
->state
= (union drbd_state
) {
3045 { .role
= R_SECONDARY
,
3047 .conn
= C_STANDALONE
,
3056 void drbd_init_set_defaults(struct drbd_conf
*mdev
)
3058 /* the memset(,0,) did most of this.
3059 * note: only assignments, no allocation in here */
3061 drbd_set_defaults(mdev
);
3063 atomic_set(&mdev
->ap_bio_cnt
, 0);
3064 atomic_set(&mdev
->ap_pending_cnt
, 0);
3065 atomic_set(&mdev
->rs_pending_cnt
, 0);
3066 atomic_set(&mdev
->unacked_cnt
, 0);
3067 atomic_set(&mdev
->local_cnt
, 0);
3068 atomic_set(&mdev
->net_cnt
, 0);
3069 atomic_set(&mdev
->packet_seq
, 0);
3070 atomic_set(&mdev
->pp_in_use
, 0);
3071 atomic_set(&mdev
->pp_in_use_by_net
, 0);
3072 atomic_set(&mdev
->rs_sect_in
, 0);
3073 atomic_set(&mdev
->rs_sect_ev
, 0);
3074 atomic_set(&mdev
->ap_in_flight
, 0);
3075 atomic_set(&mdev
->md_io_in_use
, 0);
3077 mutex_init(&mdev
->data
.mutex
);
3078 mutex_init(&mdev
->meta
.mutex
);
3079 sema_init(&mdev
->data
.work
.s
, 0);
3080 sema_init(&mdev
->meta
.work
.s
, 0);
3081 mutex_init(&mdev
->state_mutex
);
3083 spin_lock_init(&mdev
->data
.work
.q_lock
);
3084 spin_lock_init(&mdev
->meta
.work
.q_lock
);
3086 spin_lock_init(&mdev
->al_lock
);
3087 spin_lock_init(&mdev
->req_lock
);
3088 spin_lock_init(&mdev
->peer_seq_lock
);
3089 spin_lock_init(&mdev
->epoch_lock
);
3091 INIT_LIST_HEAD(&mdev
->active_ee
);
3092 INIT_LIST_HEAD(&mdev
->sync_ee
);
3093 INIT_LIST_HEAD(&mdev
->done_ee
);
3094 INIT_LIST_HEAD(&mdev
->read_ee
);
3095 INIT_LIST_HEAD(&mdev
->net_ee
);
3096 INIT_LIST_HEAD(&mdev
->resync_reads
);
3097 INIT_LIST_HEAD(&mdev
->data
.work
.q
);
3098 INIT_LIST_HEAD(&mdev
->meta
.work
.q
);
3099 INIT_LIST_HEAD(&mdev
->resync_work
.list
);
3100 INIT_LIST_HEAD(&mdev
->unplug_work
.list
);
3101 INIT_LIST_HEAD(&mdev
->go_diskless
.list
);
3102 INIT_LIST_HEAD(&mdev
->md_sync_work
.list
);
3103 INIT_LIST_HEAD(&mdev
->start_resync_work
.list
);
3104 INIT_LIST_HEAD(&mdev
->bm_io_work
.w
.list
);
3106 mdev
->resync_work
.cb
= w_resync_timer
;
3107 mdev
->unplug_work
.cb
= w_send_write_hint
;
3108 mdev
->go_diskless
.cb
= w_go_diskless
;
3109 mdev
->md_sync_work
.cb
= w_md_sync
;
3110 mdev
->bm_io_work
.w
.cb
= w_bitmap_io
;
3111 mdev
->start_resync_work
.cb
= w_start_resync
;
3112 init_timer(&mdev
->resync_timer
);
3113 init_timer(&mdev
->md_sync_timer
);
3114 init_timer(&mdev
->start_resync_timer
);
3115 init_timer(&mdev
->request_timer
);
3116 mdev
->resync_timer
.function
= resync_timer_fn
;
3117 mdev
->resync_timer
.data
= (unsigned long) mdev
;
3118 mdev
->md_sync_timer
.function
= md_sync_timer_fn
;
3119 mdev
->md_sync_timer
.data
= (unsigned long) mdev
;
3120 mdev
->start_resync_timer
.function
= start_resync_timer_fn
;
3121 mdev
->start_resync_timer
.data
= (unsigned long) mdev
;
3122 mdev
->request_timer
.function
= request_timer_fn
;
3123 mdev
->request_timer
.data
= (unsigned long) mdev
;
3125 init_waitqueue_head(&mdev
->misc_wait
);
3126 init_waitqueue_head(&mdev
->state_wait
);
3127 init_waitqueue_head(&mdev
->net_cnt_wait
);
3128 init_waitqueue_head(&mdev
->ee_wait
);
3129 init_waitqueue_head(&mdev
->al_wait
);
3130 init_waitqueue_head(&mdev
->seq_wait
);
3132 drbd_thread_init(mdev
, &mdev
->receiver
, drbdd_init
);
3133 drbd_thread_init(mdev
, &mdev
->worker
, drbd_worker
);
3134 drbd_thread_init(mdev
, &mdev
->asender
, drbd_asender
);
3136 mdev
->agreed_pro_version
= PRO_VERSION_MAX
;
3137 mdev
->write_ordering
= WO_bdev_flush
;
3138 mdev
->resync_wenr
= LC_FREE
;
3139 mdev
->peer_max_bio_size
= DRBD_MAX_BIO_SIZE_SAFE
;
3140 mdev
->local_max_bio_size
= DRBD_MAX_BIO_SIZE_SAFE
;
3143 void drbd_mdev_cleanup(struct drbd_conf
*mdev
)
3146 if (mdev
->receiver
.t_state
!= None
)
3147 dev_err(DEV
, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
3148 mdev
->receiver
.t_state
);
3150 /* no need to lock it, I'm the only thread alive */
3151 if (atomic_read(&mdev
->current_epoch
->epoch_size
) != 0)
3152 dev_err(DEV
, "epoch_size:%d\n", atomic_read(&mdev
->current_epoch
->epoch_size
));
3162 mdev
->rs_failed
= 0;
3163 mdev
->rs_last_events
= 0;
3164 mdev
->rs_last_sect_ev
= 0;
3165 for (i
= 0; i
< DRBD_SYNC_MARKS
; i
++) {
3166 mdev
->rs_mark_left
[i
] = 0;
3167 mdev
->rs_mark_time
[i
] = 0;
3169 D_ASSERT(mdev
->net_conf
== NULL
);
3171 drbd_set_my_capacity(mdev
, 0);
3173 /* maybe never allocated. */
3174 drbd_bm_resize(mdev
, 0, 1);
3175 drbd_bm_cleanup(mdev
);
3178 drbd_free_resources(mdev
);
3179 clear_bit(AL_SUSPENDED
, &mdev
->flags
);
3182 * currently we drbd_init_ee only on module load, so
3183 * we may do drbd_release_ee only on module unload!
3185 D_ASSERT(list_empty(&mdev
->active_ee
));
3186 D_ASSERT(list_empty(&mdev
->sync_ee
));
3187 D_ASSERT(list_empty(&mdev
->done_ee
));
3188 D_ASSERT(list_empty(&mdev
->read_ee
));
3189 D_ASSERT(list_empty(&mdev
->net_ee
));
3190 D_ASSERT(list_empty(&mdev
->resync_reads
));
3191 D_ASSERT(list_empty(&mdev
->data
.work
.q
));
3192 D_ASSERT(list_empty(&mdev
->meta
.work
.q
));
3193 D_ASSERT(list_empty(&mdev
->resync_work
.list
));
3194 D_ASSERT(list_empty(&mdev
->unplug_work
.list
));
3195 D_ASSERT(list_empty(&mdev
->go_diskless
.list
));
3197 drbd_set_defaults(mdev
);
3201 static void drbd_destroy_mempools(void)
3205 while (drbd_pp_pool
) {
3206 page
= drbd_pp_pool
;
3207 drbd_pp_pool
= (struct page
*)page_private(page
);
3212 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
3214 if (drbd_ee_mempool
)
3215 mempool_destroy(drbd_ee_mempool
);
3216 if (drbd_request_mempool
)
3217 mempool_destroy(drbd_request_mempool
);
3219 kmem_cache_destroy(drbd_ee_cache
);
3220 if (drbd_request_cache
)
3221 kmem_cache_destroy(drbd_request_cache
);
3222 if (drbd_bm_ext_cache
)
3223 kmem_cache_destroy(drbd_bm_ext_cache
);
3224 if (drbd_al_ext_cache
)
3225 kmem_cache_destroy(drbd_al_ext_cache
);
3227 drbd_ee_mempool
= NULL
;
3228 drbd_request_mempool
= NULL
;
3229 drbd_ee_cache
= NULL
;
3230 drbd_request_cache
= NULL
;
3231 drbd_bm_ext_cache
= NULL
;
3232 drbd_al_ext_cache
= NULL
;
3237 static int drbd_create_mempools(void)
3240 const int number
= (DRBD_MAX_BIO_SIZE
/PAGE_SIZE
) * minor_count
;
3243 /* prepare our caches and mempools */
3244 drbd_request_mempool
= NULL
;
3245 drbd_ee_cache
= NULL
;
3246 drbd_request_cache
= NULL
;
3247 drbd_bm_ext_cache
= NULL
;
3248 drbd_al_ext_cache
= NULL
;
3249 drbd_pp_pool
= NULL
;
3252 drbd_request_cache
= kmem_cache_create(
3253 "drbd_req", sizeof(struct drbd_request
), 0, 0, NULL
);
3254 if (drbd_request_cache
== NULL
)
3257 drbd_ee_cache
= kmem_cache_create(
3258 "drbd_ee", sizeof(struct drbd_epoch_entry
), 0, 0, NULL
);
3259 if (drbd_ee_cache
== NULL
)
3262 drbd_bm_ext_cache
= kmem_cache_create(
3263 "drbd_bm", sizeof(struct bm_extent
), 0, 0, NULL
);
3264 if (drbd_bm_ext_cache
== NULL
)
3267 drbd_al_ext_cache
= kmem_cache_create(
3268 "drbd_al", sizeof(struct lc_element
), 0, 0, NULL
);
3269 if (drbd_al_ext_cache
== NULL
)
3273 drbd_request_mempool
= mempool_create(number
,
3274 mempool_alloc_slab
, mempool_free_slab
, drbd_request_cache
);
3275 if (drbd_request_mempool
== NULL
)
3278 drbd_ee_mempool
= mempool_create(number
,
3279 mempool_alloc_slab
, mempool_free_slab
, drbd_ee_cache
);
3280 if (drbd_ee_mempool
== NULL
)
3283 /* drbd's page pool */
3284 spin_lock_init(&drbd_pp_lock
);
3286 for (i
= 0; i
< number
; i
++) {
3287 page
= alloc_page(GFP_HIGHUSER
);
3290 set_page_private(page
, (unsigned long)drbd_pp_pool
);
3291 drbd_pp_pool
= page
;
3293 drbd_pp_vacant
= number
;
3298 drbd_destroy_mempools(); /* in case we allocated some */
3302 static int drbd_notify_sys(struct notifier_block
*this, unsigned long code
,
3305 /* just so we have it. you never know what interesting things we
3306 * might want to do here some day...
3312 static struct notifier_block drbd_notifier
= {
3313 .notifier_call
= drbd_notify_sys
,
3316 static void drbd_release_ee_lists(struct drbd_conf
*mdev
)
3320 rr
= drbd_release_ee(mdev
, &mdev
->active_ee
);
3322 dev_err(DEV
, "%d EEs in active list found!\n", rr
);
3324 rr
= drbd_release_ee(mdev
, &mdev
->sync_ee
);
3326 dev_err(DEV
, "%d EEs in sync list found!\n", rr
);
3328 rr
= drbd_release_ee(mdev
, &mdev
->read_ee
);
3330 dev_err(DEV
, "%d EEs in read list found!\n", rr
);
3332 rr
= drbd_release_ee(mdev
, &mdev
->done_ee
);
3334 dev_err(DEV
, "%d EEs in done list found!\n", rr
);
3336 rr
= drbd_release_ee(mdev
, &mdev
->net_ee
);
3338 dev_err(DEV
, "%d EEs in net list found!\n", rr
);
3341 /* caution. no locking.
3342 * currently only used from module cleanup code. */
3343 static void drbd_delete_device(unsigned int minor
)
3345 struct drbd_conf
*mdev
= minor_to_mdev(minor
);
3350 del_timer_sync(&mdev
->request_timer
);
3352 /* paranoia asserts */
3353 if (mdev
->open_cnt
!= 0)
3354 dev_err(DEV
, "open_cnt = %d in %s:%u", mdev
->open_cnt
,
3355 __FILE__
, __LINE__
);
3357 ERR_IF (!list_empty(&mdev
->data
.work
.q
)) {
3358 struct list_head
*lp
;
3359 list_for_each(lp
, &mdev
->data
.work
.q
) {
3360 dev_err(DEV
, "lp = %p\n", lp
);
3363 /* end paranoia asserts */
3365 del_gendisk(mdev
->vdisk
);
3367 /* cleanup stuff that may have been allocated during
3368 * device (re-)configuration or state changes */
3370 if (mdev
->this_bdev
)
3371 bdput(mdev
->this_bdev
);
3373 drbd_free_resources(mdev
);
3375 drbd_release_ee_lists(mdev
);
3377 /* should be freed on disconnect? */
3378 kfree(mdev
->ee_hash
);
3380 mdev->ee_hash_s = 0;
3381 mdev->ee_hash = NULL;
3384 lc_destroy(mdev
->act_log
);
3385 lc_destroy(mdev
->resync
);
3387 kfree(mdev
->p_uuid
);
3388 /* mdev->p_uuid = NULL; */
3390 kfree(mdev
->int_dig_out
);
3391 kfree(mdev
->int_dig_in
);
3392 kfree(mdev
->int_dig_vv
);
3394 /* cleanup the rest that has been
3395 * allocated from drbd_new_device
3396 * and actually free the mdev itself */
3397 drbd_free_mdev(mdev
);
3400 static void drbd_cleanup(void)
3404 unregister_reboot_notifier(&drbd_notifier
);
3406 /* first remove proc,
3407 * drbdsetup uses it's presence to detect
3408 * whether DRBD is loaded.
3409 * If we would get stuck in proc removal,
3410 * but have netlink already deregistered,
3411 * some drbdsetup commands may wait forever
3415 remove_proc_entry("drbd", NULL
);
3422 drbd_delete_device(i
);
3423 drbd_destroy_mempools();
3428 unregister_blkdev(DRBD_MAJOR
, "drbd");
3430 printk(KERN_INFO
"drbd: module cleanup done.\n");
3434 * drbd_congested() - Callback for pdflush
3435 * @congested_data: User data
3436 * @bdi_bits: Bits pdflush is currently interested in
3438 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
3440 static int drbd_congested(void *congested_data
, int bdi_bits
)
3442 struct drbd_conf
*mdev
= congested_data
;
3443 struct request_queue
*q
;
3447 if (!may_inc_ap_bio(mdev
)) {
3448 /* DRBD has frozen IO */
3454 if (get_ldev(mdev
)) {
3455 q
= bdev_get_queue(mdev
->ldev
->backing_bdev
);
3456 r
= bdi_congested(&q
->backing_dev_info
, bdi_bits
);
3462 if (bdi_bits
& (1 << BDI_async_congested
) && test_bit(NET_CONGESTED
, &mdev
->flags
)) {
3463 r
|= (1 << BDI_async_congested
);
3464 reason
= reason
== 'b' ? 'a' : 'n';
3468 mdev
->congestion_reason
= reason
;
3472 struct drbd_conf
*drbd_new_device(unsigned int minor
)
3474 struct drbd_conf
*mdev
;
3475 struct gendisk
*disk
;
3476 struct request_queue
*q
;
3478 /* GFP_KERNEL, we are outside of all write-out paths */
3479 mdev
= kzalloc(sizeof(struct drbd_conf
), GFP_KERNEL
);
3482 if (!zalloc_cpumask_var(&mdev
->cpu_mask
, GFP_KERNEL
))
3483 goto out_no_cpumask
;
3485 mdev
->minor
= minor
;
3487 drbd_init_set_defaults(mdev
);
3489 q
= blk_alloc_queue(GFP_KERNEL
);
3493 q
->queuedata
= mdev
;
3495 disk
= alloc_disk(1);
3500 set_disk_ro(disk
, true);
3503 disk
->major
= DRBD_MAJOR
;
3504 disk
->first_minor
= minor
;
3505 disk
->fops
= &drbd_ops
;
3506 sprintf(disk
->disk_name
, "drbd%d", minor
);
3507 disk
->private_data
= mdev
;
3509 mdev
->this_bdev
= bdget(MKDEV(DRBD_MAJOR
, minor
));
3510 /* we have no partitions. we contain only ourselves. */
3511 mdev
->this_bdev
->bd_contains
= mdev
->this_bdev
;
3513 q
->backing_dev_info
.congested_fn
= drbd_congested
;
3514 q
->backing_dev_info
.congested_data
= mdev
;
3516 blk_queue_make_request(q
, drbd_make_request
);
3517 /* Setting the max_hw_sectors to an odd value of 8kibyte here
3518 This triggers a max_bio_size message upon first attach or connect */
3519 blk_queue_max_hw_sectors(q
, DRBD_MAX_BIO_SIZE_SAFE
>> 8);
3520 blk_queue_bounce_limit(q
, BLK_BOUNCE_ANY
);
3521 blk_queue_merge_bvec(q
, drbd_merge_bvec
);
3522 q
->queue_lock
= &mdev
->req_lock
;
3524 mdev
->md_io_page
= alloc_page(GFP_KERNEL
);
3525 if (!mdev
->md_io_page
)
3526 goto out_no_io_page
;
3528 if (drbd_bm_init(mdev
))
3530 /* no need to lock access, we are still initializing this minor device. */
3534 mdev
->app_reads_hash
= kzalloc(APP_R_HSIZE
*sizeof(void *), GFP_KERNEL
);
3535 if (!mdev
->app_reads_hash
)
3536 goto out_no_app_reads
;
3538 mdev
->current_epoch
= kzalloc(sizeof(struct drbd_epoch
), GFP_KERNEL
);
3539 if (!mdev
->current_epoch
)
3542 INIT_LIST_HEAD(&mdev
->current_epoch
->list
);
3547 /* out_whatever_else:
3548 kfree(mdev->current_epoch); */
3550 kfree(mdev
->app_reads_hash
);
3554 drbd_bm_cleanup(mdev
);
3556 __free_page(mdev
->md_io_page
);
3560 blk_cleanup_queue(q
);
3562 free_cpumask_var(mdev
->cpu_mask
);
3568 /* counterpart of drbd_new_device.
3569 * last part of drbd_delete_device. */
3570 void drbd_free_mdev(struct drbd_conf
*mdev
)
3572 kfree(mdev
->current_epoch
);
3573 kfree(mdev
->app_reads_hash
);
3575 if (mdev
->bitmap
) /* should no longer be there. */
3576 drbd_bm_cleanup(mdev
);
3577 __free_page(mdev
->md_io_page
);
3578 put_disk(mdev
->vdisk
);
3579 blk_cleanup_queue(mdev
->rq_queue
);
3580 free_cpumask_var(mdev
->cpu_mask
);
3581 drbd_free_tl_hash(mdev
);
3586 int __init
drbd_init(void)
3590 if (sizeof(struct p_handshake
) != 80) {
3592 "drbd: never change the size or layout "
3593 "of the HandShake packet.\n");
3597 if (minor_count
< DRBD_MINOR_COUNT_MIN
|| minor_count
> DRBD_MINOR_COUNT_MAX
) {
3599 "drbd: invalid minor_count (%d)\n", minor_count
);
3607 err
= drbd_nl_init();
3611 err
= register_blkdev(DRBD_MAJOR
, "drbd");
3614 "drbd: unable to register block device major %d\n",
3619 register_reboot_notifier(&drbd_notifier
);
3622 * allocate all necessary structs
3626 init_waitqueue_head(&drbd_pp_wait
);
3628 drbd_proc
= NULL
; /* play safe for drbd_cleanup */
3629 minor_table
= kzalloc(sizeof(struct drbd_conf
*)*minor_count
,
3634 err
= drbd_create_mempools();
3638 drbd_proc
= proc_create_data("drbd", S_IFREG
| S_IRUGO
, NULL
, &drbd_proc_fops
, NULL
);
3640 printk(KERN_ERR
"drbd: unable to register proc file\n");
3644 rwlock_init(&global_state_lock
);
3646 printk(KERN_INFO
"drbd: initialized. "
3647 "Version: " REL_VERSION
" (api:%d/proto:%d-%d)\n",
3648 API_VERSION
, PRO_VERSION_MIN
, PRO_VERSION_MAX
);
3649 printk(KERN_INFO
"drbd: %s\n", drbd_buildtag());
3650 printk(KERN_INFO
"drbd: registered as block device major %d\n",
3652 printk(KERN_INFO
"drbd: minor_table @ 0x%p\n", minor_table
);
3654 return 0; /* Success! */
3659 /* currently always the case */
3660 printk(KERN_ERR
"drbd: ran out of memory\n");
3662 printk(KERN_ERR
"drbd: initialization failure\n");
3666 void drbd_free_bc(struct drbd_backing_dev
*ldev
)
3671 blkdev_put(ldev
->backing_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
3672 blkdev_put(ldev
->md_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
3677 void drbd_free_sock(struct drbd_conf
*mdev
)
3679 if (mdev
->data
.socket
) {
3680 mutex_lock(&mdev
->data
.mutex
);
3681 kernel_sock_shutdown(mdev
->data
.socket
, SHUT_RDWR
);
3682 sock_release(mdev
->data
.socket
);
3683 mdev
->data
.socket
= NULL
;
3684 mutex_unlock(&mdev
->data
.mutex
);
3686 if (mdev
->meta
.socket
) {
3687 mutex_lock(&mdev
->meta
.mutex
);
3688 kernel_sock_shutdown(mdev
->meta
.socket
, SHUT_RDWR
);
3689 sock_release(mdev
->meta
.socket
);
3690 mdev
->meta
.socket
= NULL
;
3691 mutex_unlock(&mdev
->meta
.mutex
);
3696 void drbd_free_resources(struct drbd_conf
*mdev
)
3698 crypto_free_hash(mdev
->csums_tfm
);
3699 mdev
->csums_tfm
= NULL
;
3700 crypto_free_hash(mdev
->verify_tfm
);
3701 mdev
->verify_tfm
= NULL
;
3702 crypto_free_hash(mdev
->cram_hmac_tfm
);
3703 mdev
->cram_hmac_tfm
= NULL
;
3704 crypto_free_hash(mdev
->integrity_w_tfm
);
3705 mdev
->integrity_w_tfm
= NULL
;
3706 crypto_free_hash(mdev
->integrity_r_tfm
);
3707 mdev
->integrity_r_tfm
= NULL
;
3709 drbd_free_sock(mdev
);
3712 drbd_free_bc(mdev
->ldev
);
3713 mdev
->ldev
= NULL
;);
3716 /* meta data management */
3718 struct meta_data_on_disk
{
3719 u64 la_size
; /* last agreed size. */
3720 u64 uuid
[UI_SIZE
]; /* UUIDs. */
3723 u32 flags
; /* MDF */
3726 u32 al_offset
; /* offset to this block */
3727 u32 al_nr_extents
; /* important for restoring the AL */
3728 /* `-- act_log->nr_elements <-- sync_conf.al_extents */
3729 u32 bm_offset
; /* offset to the bitmap, from here */
3730 u32 bm_bytes_per_bit
; /* BM_BLOCK_SIZE */
3731 u32 la_peer_max_bio_size
; /* last peer max_bio_size */
3732 u32 reserved_u32
[3];
3737 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
3738 * @mdev: DRBD device.
3740 void drbd_md_sync(struct drbd_conf
*mdev
)
3742 struct meta_data_on_disk
*buffer
;
3746 del_timer(&mdev
->md_sync_timer
);
3747 /* timer may be rearmed by drbd_md_mark_dirty() now. */
3748 if (!test_and_clear_bit(MD_DIRTY
, &mdev
->flags
))
3751 /* We use here D_FAILED and not D_ATTACHING because we try to write
3752 * metadata even if we detach due to a disk failure! */
3753 if (!get_ldev_if_state(mdev
, D_FAILED
))
3756 buffer
= drbd_md_get_buffer(mdev
);
3760 memset(buffer
, 0, 512);
3762 buffer
->la_size
= cpu_to_be64(drbd_get_capacity(mdev
->this_bdev
));
3763 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
3764 buffer
->uuid
[i
] = cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]);
3765 buffer
->flags
= cpu_to_be32(mdev
->ldev
->md
.flags
);
3766 buffer
->magic
= cpu_to_be32(DRBD_MD_MAGIC
);
3768 buffer
->md_size_sect
= cpu_to_be32(mdev
->ldev
->md
.md_size_sect
);
3769 buffer
->al_offset
= cpu_to_be32(mdev
->ldev
->md
.al_offset
);
3770 buffer
->al_nr_extents
= cpu_to_be32(mdev
->act_log
->nr_elements
);
3771 buffer
->bm_bytes_per_bit
= cpu_to_be32(BM_BLOCK_SIZE
);
3772 buffer
->device_uuid
= cpu_to_be64(mdev
->ldev
->md
.device_uuid
);
3774 buffer
->bm_offset
= cpu_to_be32(mdev
->ldev
->md
.bm_offset
);
3775 buffer
->la_peer_max_bio_size
= cpu_to_be32(mdev
->peer_max_bio_size
);
3777 D_ASSERT(drbd_md_ss__(mdev
, mdev
->ldev
) == mdev
->ldev
->md
.md_offset
);
3778 sector
= mdev
->ldev
->md
.md_offset
;
3780 if (!drbd_md_sync_page_io(mdev
, mdev
->ldev
, sector
, WRITE
)) {
3781 /* this was a try anyways ... */
3782 dev_err(DEV
, "meta data update failed!\n");
3783 drbd_chk_io_error(mdev
, 1, true);
3786 /* Update mdev->ldev->md.la_size_sect,
3787 * since we updated it on metadata. */
3788 mdev
->ldev
->md
.la_size_sect
= drbd_get_capacity(mdev
->this_bdev
);
3790 drbd_md_put_buffer(mdev
);
3796 * drbd_md_read() - Reads in the meta data super block
3797 * @mdev: DRBD device.
3798 * @bdev: Device from which the meta data should be read in.
3800 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
3801 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
3803 int drbd_md_read(struct drbd_conf
*mdev
, struct drbd_backing_dev
*bdev
)
3805 struct meta_data_on_disk
*buffer
;
3806 int i
, rv
= NO_ERROR
;
3808 if (!get_ldev_if_state(mdev
, D_ATTACHING
))
3809 return ERR_IO_MD_DISK
;
3811 buffer
= drbd_md_get_buffer(mdev
);
3815 if (!drbd_md_sync_page_io(mdev
, bdev
, bdev
->md
.md_offset
, READ
)) {
3816 /* NOTE: can't do normal error processing here as this is
3817 called BEFORE disk is attached */
3818 dev_err(DEV
, "Error while reading metadata.\n");
3819 rv
= ERR_IO_MD_DISK
;
3823 if (be32_to_cpu(buffer
->magic
) != DRBD_MD_MAGIC
) {
3824 dev_err(DEV
, "Error while reading metadata, magic not found.\n");
3825 rv
= ERR_MD_INVALID
;
3828 if (be32_to_cpu(buffer
->al_offset
) != bdev
->md
.al_offset
) {
3829 dev_err(DEV
, "unexpected al_offset: %d (expected %d)\n",
3830 be32_to_cpu(buffer
->al_offset
), bdev
->md
.al_offset
);
3831 rv
= ERR_MD_INVALID
;
3834 if (be32_to_cpu(buffer
->bm_offset
) != bdev
->md
.bm_offset
) {
3835 dev_err(DEV
, "unexpected bm_offset: %d (expected %d)\n",
3836 be32_to_cpu(buffer
->bm_offset
), bdev
->md
.bm_offset
);
3837 rv
= ERR_MD_INVALID
;
3840 if (be32_to_cpu(buffer
->md_size_sect
) != bdev
->md
.md_size_sect
) {
3841 dev_err(DEV
, "unexpected md_size: %u (expected %u)\n",
3842 be32_to_cpu(buffer
->md_size_sect
), bdev
->md
.md_size_sect
);
3843 rv
= ERR_MD_INVALID
;
3847 if (be32_to_cpu(buffer
->bm_bytes_per_bit
) != BM_BLOCK_SIZE
) {
3848 dev_err(DEV
, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3849 be32_to_cpu(buffer
->bm_bytes_per_bit
), BM_BLOCK_SIZE
);
3850 rv
= ERR_MD_INVALID
;
3854 bdev
->md
.la_size_sect
= be64_to_cpu(buffer
->la_size
);
3855 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
3856 bdev
->md
.uuid
[i
] = be64_to_cpu(buffer
->uuid
[i
]);
3857 bdev
->md
.flags
= be32_to_cpu(buffer
->flags
);
3858 mdev
->sync_conf
.al_extents
= be32_to_cpu(buffer
->al_nr_extents
);
3859 bdev
->md
.device_uuid
= be64_to_cpu(buffer
->device_uuid
);
3861 spin_lock_irq(&mdev
->req_lock
);
3862 if (mdev
->state
.conn
< C_CONNECTED
) {
3864 peer
= be32_to_cpu(buffer
->la_peer_max_bio_size
);
3865 peer
= max_t(int, peer
, DRBD_MAX_BIO_SIZE_SAFE
);
3866 mdev
->peer_max_bio_size
= peer
;
3868 spin_unlock_irq(&mdev
->req_lock
);
3870 if (mdev
->sync_conf
.al_extents
< 7)
3871 mdev
->sync_conf
.al_extents
= 127;
3874 drbd_md_put_buffer(mdev
);
3882 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3883 * @mdev: DRBD device.
3885 * Call this function if you change anything that should be written to
3886 * the meta-data super block. This function sets MD_DIRTY, and starts a
3887 * timer that ensures that within five seconds you have to call drbd_md_sync().
3890 void drbd_md_mark_dirty_(struct drbd_conf
*mdev
, unsigned int line
, const char *func
)
3892 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
)) {
3893 mod_timer(&mdev
->md_sync_timer
, jiffies
+ HZ
);
3894 mdev
->last_md_mark_dirty
.line
= line
;
3895 mdev
->last_md_mark_dirty
.func
= func
;
3899 void drbd_md_mark_dirty(struct drbd_conf
*mdev
)
3901 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
))
3902 mod_timer(&mdev
->md_sync_timer
, jiffies
+ 5*HZ
);
3906 static void drbd_uuid_move_history(struct drbd_conf
*mdev
) __must_hold(local
)
3910 for (i
= UI_HISTORY_START
; i
< UI_HISTORY_END
; i
++)
3911 mdev
->ldev
->md
.uuid
[i
+1] = mdev
->ldev
->md
.uuid
[i
];
3914 void _drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3916 if (idx
== UI_CURRENT
) {
3917 if (mdev
->state
.role
== R_PRIMARY
)
3922 drbd_set_ed_uuid(mdev
, val
);
3925 mdev
->ldev
->md
.uuid
[idx
] = val
;
3926 drbd_md_mark_dirty(mdev
);
3930 void drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3932 if (mdev
->ldev
->md
.uuid
[idx
]) {
3933 drbd_uuid_move_history(mdev
);
3934 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[idx
];
3936 _drbd_uuid_set(mdev
, idx
, val
);
3940 * drbd_uuid_new_current() - Creates a new current UUID
3941 * @mdev: DRBD device.
3943 * Creates a new current UUID, and rotates the old current UUID into
3944 * the bitmap slot. Causes an incremental resync upon next connect.
3946 void drbd_uuid_new_current(struct drbd_conf
*mdev
) __must_hold(local
)
3949 unsigned long long bm_uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3952 dev_warn(DEV
, "bm UUID was already set: %llX\n", bm_uuid
);
3954 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = mdev
->ldev
->md
.uuid
[UI_CURRENT
];
3956 get_random_bytes(&val
, sizeof(u64
));
3957 _drbd_uuid_set(mdev
, UI_CURRENT
, val
);
3958 drbd_print_uuids(mdev
, "new current UUID");
3959 /* get it to stable storage _now_ */
3963 void drbd_uuid_set_bm(struct drbd_conf
*mdev
, u64 val
) __must_hold(local
)
3965 if (mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && val
== 0)
3969 drbd_uuid_move_history(mdev
);
3970 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3971 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = 0;
3973 unsigned long long bm_uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3975 dev_warn(DEV
, "bm UUID was already set: %llX\n", bm_uuid
);
3977 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = val
& ~((u64
)1);
3979 drbd_md_mark_dirty(mdev
);
3983 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3984 * @mdev: DRBD device.
3986 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3988 int drbd_bmio_set_n_write(struct drbd_conf
*mdev
)
3992 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
3993 drbd_md_set_flag(mdev
, MDF_FULL_SYNC
);
3995 drbd_bm_set_all(mdev
);
3997 rv
= drbd_bm_write(mdev
);
4000 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
4011 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
4012 * @mdev: DRBD device.
4014 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
4016 int drbd_bmio_clear_n_write(struct drbd_conf
*mdev
)
4020 drbd_resume_al(mdev
);
4021 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
4022 drbd_bm_clear_all(mdev
);
4023 rv
= drbd_bm_write(mdev
);
4030 static int w_bitmap_io(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
4032 struct bm_io_work
*work
= container_of(w
, struct bm_io_work
, w
);
4035 D_ASSERT(atomic_read(&mdev
->ap_bio_cnt
) == 0);
4037 if (get_ldev(mdev
)) {
4038 drbd_bm_lock(mdev
, work
->why
, work
->flags
);
4039 rv
= work
->io_fn(mdev
);
4040 drbd_bm_unlock(mdev
);
4044 clear_bit(BITMAP_IO
, &mdev
->flags
);
4045 smp_mb__after_clear_bit();
4046 wake_up(&mdev
->misc_wait
);
4049 work
->done(mdev
, rv
);
4051 clear_bit(BITMAP_IO_QUEUED
, &mdev
->flags
);
4058 void drbd_ldev_destroy(struct drbd_conf
*mdev
)
4060 lc_destroy(mdev
->resync
);
4061 mdev
->resync
= NULL
;
4062 lc_destroy(mdev
->act_log
);
4063 mdev
->act_log
= NULL
;
4065 drbd_free_bc(mdev
->ldev
);
4066 mdev
->ldev
= NULL
;);
4068 if (mdev
->md_io_tmpp
) {
4069 __free_page(mdev
->md_io_tmpp
);
4070 mdev
->md_io_tmpp
= NULL
;
4072 clear_bit(GO_DISKLESS
, &mdev
->flags
);
4075 static int w_go_diskless(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
4077 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
4078 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
4079 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
4080 * the protected members anymore, though, so once put_ldev reaches zero
4081 * again, it will be safe to free them. */
4082 drbd_force_state(mdev
, NS(disk
, D_DISKLESS
));
4086 void drbd_go_diskless(struct drbd_conf
*mdev
)
4088 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
4089 if (!test_and_set_bit(GO_DISKLESS
, &mdev
->flags
))
4090 drbd_queue_work(&mdev
->data
.work
, &mdev
->go_diskless
);
4094 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
4095 * @mdev: DRBD device.
4096 * @io_fn: IO callback to be called when bitmap IO is possible
4097 * @done: callback to be called after the bitmap IO was performed
4098 * @why: Descriptive text of the reason for doing the IO
4100 * While IO on the bitmap happens we freeze application IO thus we ensure
4101 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
4102 * called from worker context. It MUST NOT be used while a previous such
4103 * work is still pending!
4105 void drbd_queue_bitmap_io(struct drbd_conf
*mdev
,
4106 int (*io_fn
)(struct drbd_conf
*),
4107 void (*done
)(struct drbd_conf
*, int),
4108 char *why
, enum bm_flag flags
)
4110 D_ASSERT(current
== mdev
->worker
.task
);
4112 D_ASSERT(!test_bit(BITMAP_IO_QUEUED
, &mdev
->flags
));
4113 D_ASSERT(!test_bit(BITMAP_IO
, &mdev
->flags
));
4114 D_ASSERT(list_empty(&mdev
->bm_io_work
.w
.list
));
4115 if (mdev
->bm_io_work
.why
)
4116 dev_err(DEV
, "FIXME going to queue '%s' but '%s' still pending?\n",
4117 why
, mdev
->bm_io_work
.why
);
4119 mdev
->bm_io_work
.io_fn
= io_fn
;
4120 mdev
->bm_io_work
.done
= done
;
4121 mdev
->bm_io_work
.why
= why
;
4122 mdev
->bm_io_work
.flags
= flags
;
4124 spin_lock_irq(&mdev
->req_lock
);
4125 set_bit(BITMAP_IO
, &mdev
->flags
);
4126 if (atomic_read(&mdev
->ap_bio_cnt
) == 0) {
4127 if (!test_and_set_bit(BITMAP_IO_QUEUED
, &mdev
->flags
))
4128 drbd_queue_work(&mdev
->data
.work
, &mdev
->bm_io_work
.w
);
4130 spin_unlock_irq(&mdev
->req_lock
);
4134 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
4135 * @mdev: DRBD device.
4136 * @io_fn: IO callback to be called when bitmap IO is possible
4137 * @why: Descriptive text of the reason for doing the IO
4139 * freezes application IO while that the actual IO operations runs. This
4140 * functions MAY NOT be called from worker context.
4142 int drbd_bitmap_io(struct drbd_conf
*mdev
, int (*io_fn
)(struct drbd_conf
*),
4143 char *why
, enum bm_flag flags
)
4147 D_ASSERT(current
!= mdev
->worker
.task
);
4149 if ((flags
& BM_LOCKED_SET_ALLOWED
) == 0)
4150 drbd_suspend_io(mdev
);
4152 drbd_bm_lock(mdev
, why
, flags
);
4154 drbd_bm_unlock(mdev
);
4156 if ((flags
& BM_LOCKED_SET_ALLOWED
) == 0)
4157 drbd_resume_io(mdev
);
4162 void drbd_md_set_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
4164 if ((mdev
->ldev
->md
.flags
& flag
) != flag
) {
4165 drbd_md_mark_dirty(mdev
);
4166 mdev
->ldev
->md
.flags
|= flag
;
4170 void drbd_md_clear_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
4172 if ((mdev
->ldev
->md
.flags
& flag
) != 0) {
4173 drbd_md_mark_dirty(mdev
);
4174 mdev
->ldev
->md
.flags
&= ~flag
;
4177 int drbd_md_test_flag(struct drbd_backing_dev
*bdev
, int flag
)
4179 return (bdev
->md
.flags
& flag
) != 0;
4182 static void md_sync_timer_fn(unsigned long data
)
4184 struct drbd_conf
*mdev
= (struct drbd_conf
*) data
;
4186 drbd_queue_work_front(&mdev
->data
.work
, &mdev
->md_sync_work
);
4189 static int w_md_sync(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
4191 dev_warn(DEV
, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
4193 dev_warn(DEV
, "last md_mark_dirty: %s:%u\n",
4194 mdev
->last_md_mark_dirty
.func
, mdev
->last_md_mark_dirty
.line
);
4200 #ifdef CONFIG_DRBD_FAULT_INJECTION
4201 /* Fault insertion support including random number generator shamelessly
4202 * stolen from kernel/rcutorture.c */
4203 struct fault_random_state
{
4204 unsigned long state
;
4205 unsigned long count
;
4208 #define FAULT_RANDOM_MULT 39916801 /* prime */
4209 #define FAULT_RANDOM_ADD 479001701 /* prime */
4210 #define FAULT_RANDOM_REFRESH 10000
4213 * Crude but fast random-number generator. Uses a linear congruential
4214 * generator, with occasional help from get_random_bytes().
4216 static unsigned long
4217 _drbd_fault_random(struct fault_random_state
*rsp
)
4221 if (!rsp
->count
--) {
4222 get_random_bytes(&refresh
, sizeof(refresh
));
4223 rsp
->state
+= refresh
;
4224 rsp
->count
= FAULT_RANDOM_REFRESH
;
4226 rsp
->state
= rsp
->state
* FAULT_RANDOM_MULT
+ FAULT_RANDOM_ADD
;
4227 return swahw32(rsp
->state
);
4231 _drbd_fault_str(unsigned int type
) {
4232 static char *_faults
[] = {
4233 [DRBD_FAULT_MD_WR
] = "Meta-data write",
4234 [DRBD_FAULT_MD_RD
] = "Meta-data read",
4235 [DRBD_FAULT_RS_WR
] = "Resync write",
4236 [DRBD_FAULT_RS_RD
] = "Resync read",
4237 [DRBD_FAULT_DT_WR
] = "Data write",
4238 [DRBD_FAULT_DT_RD
] = "Data read",
4239 [DRBD_FAULT_DT_RA
] = "Data read ahead",
4240 [DRBD_FAULT_BM_ALLOC
] = "BM allocation",
4241 [DRBD_FAULT_AL_EE
] = "EE allocation",
4242 [DRBD_FAULT_RECEIVE
] = "receive data corruption",
4245 return (type
< DRBD_FAULT_MAX
) ? _faults
[type
] : "**Unknown**";
4249 _drbd_insert_fault(struct drbd_conf
*mdev
, unsigned int type
)
4251 static struct fault_random_state rrs
= {0, 0};
4253 unsigned int ret
= (
4255 ((1 << mdev_to_minor(mdev
)) & fault_devs
) != 0) &&
4256 (((_drbd_fault_random(&rrs
) % 100) + 1) <= fault_rate
));
4261 if (__ratelimit(&drbd_ratelimit_state
))
4262 dev_warn(DEV
, "***Simulating %s failure\n",
4263 _drbd_fault_str(type
));
4270 const char *drbd_buildtag(void)
4272 /* DRBD built from external sources has here a reference to the
4273 git hash of the source code. */
4275 static char buildtag
[38] = "\0uilt-in";
4277 if (buildtag
[0] == 0) {
4278 #ifdef CONFIG_MODULES
4279 if (THIS_MODULE
!= NULL
)
4280 sprintf(buildtag
, "srcversion: %-24s", THIS_MODULE
->srcversion
);
4289 module_init(drbd_init
)
4290 module_exit(drbd_cleanup
)
4292 EXPORT_SYMBOL(drbd_conn_str
);
4293 EXPORT_SYMBOL(drbd_role_str
);
4294 EXPORT_SYMBOL(drbd_disk_str
);
4295 EXPORT_SYMBOL(drbd_set_st_err_str
);