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 (1-255)");
89 MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR
);
91 #include <linux/moduleparam.h>
92 /* allow_open_on_secondary */
93 MODULE_PARM_DESC(allow_oos
, "DONT USE!");
94 /* thanks to these macros, if compiled into the kernel (not-module),
95 * this becomes the boot parameter drbd.minor_count */
96 module_param(minor_count
, uint
, 0444);
97 module_param(disable_sendpage
, bool, 0644);
98 module_param(allow_oos
, bool, 0);
99 module_param(cn_idx
, uint
, 0444);
100 module_param(proc_details
, int, 0644);
102 #ifdef CONFIG_DRBD_FAULT_INJECTION
105 static int fault_count
;
107 /* bitmap of enabled faults */
108 module_param(enable_faults
, int, 0664);
109 /* fault rate % value - applies to all enabled faults */
110 module_param(fault_rate
, int, 0664);
111 /* count of faults inserted */
112 module_param(fault_count
, int, 0664);
113 /* bitmap of devices to insert faults on */
114 module_param(fault_devs
, int, 0644);
117 /* module parameter, defined */
118 unsigned int minor_count
= 32;
119 int disable_sendpage
;
121 unsigned int cn_idx
= CN_IDX_DRBD
;
122 int proc_details
; /* Detail level in proc drbd*/
124 /* Module parameter for setting the user mode helper program
125 * to run. Default is /sbin/drbdadm */
126 char usermode_helper
[80] = "/sbin/drbdadm";
128 module_param_string(usermode_helper
, usermode_helper
, sizeof(usermode_helper
), 0644);
130 /* in 2.6.x, our device mapping and config info contains our virtual gendisks
131 * as member "struct gendisk *vdisk;"
133 struct drbd_conf
**minor_table
;
135 struct kmem_cache
*drbd_request_cache
;
136 struct kmem_cache
*drbd_ee_cache
; /* epoch entries */
137 struct kmem_cache
*drbd_bm_ext_cache
; /* bitmap extents */
138 struct kmem_cache
*drbd_al_ext_cache
; /* activity log extents */
139 mempool_t
*drbd_request_mempool
;
140 mempool_t
*drbd_ee_mempool
;
142 /* I do not use a standard mempool, because:
143 1) I want to hand out the pre-allocated objects first.
144 2) I want to be able to interrupt sleeping allocation with a signal.
145 Note: This is a single linked list, the next pointer is the private
146 member of struct page.
148 struct page
*drbd_pp_pool
;
149 spinlock_t drbd_pp_lock
;
151 wait_queue_head_t drbd_pp_wait
;
153 DEFINE_RATELIMIT_STATE(drbd_ratelimit_state
, 5 * HZ
, 5);
155 static const struct block_device_operations drbd_ops
= {
156 .owner
= THIS_MODULE
,
158 .release
= drbd_release
,
161 #define ARRY_SIZE(A) (sizeof(A)/sizeof(A[0]))
164 /* When checking with sparse, and this is an inline function, sparse will
165 give tons of false positives. When this is a real functions sparse works.
167 int _get_ldev_if_state(struct drbd_conf
*mdev
, enum drbd_disk_state mins
)
171 atomic_inc(&mdev
->local_cnt
);
172 io_allowed
= (mdev
->state
.disk
>= mins
);
174 if (atomic_dec_and_test(&mdev
->local_cnt
))
175 wake_up(&mdev
->misc_wait
);
183 * DOC: The transfer log
185 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
186 * mdev->newest_tle points to the head, mdev->oldest_tle points to the tail
187 * of the list. There is always at least one &struct drbd_tl_epoch object.
189 * Each &struct drbd_tl_epoch has a circular double linked list of requests
192 static int tl_init(struct drbd_conf
*mdev
)
194 struct drbd_tl_epoch
*b
;
196 /* during device minor initialization, we may well use GFP_KERNEL */
197 b
= kmalloc(sizeof(struct drbd_tl_epoch
), GFP_KERNEL
);
200 INIT_LIST_HEAD(&b
->requests
);
201 INIT_LIST_HEAD(&b
->w
.list
);
205 b
->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
207 mdev
->oldest_tle
= b
;
208 mdev
->newest_tle
= b
;
209 INIT_LIST_HEAD(&mdev
->out_of_sequence_requests
);
211 mdev
->tl_hash
= NULL
;
217 static void tl_cleanup(struct drbd_conf
*mdev
)
219 D_ASSERT(mdev
->oldest_tle
== mdev
->newest_tle
);
220 D_ASSERT(list_empty(&mdev
->out_of_sequence_requests
));
221 kfree(mdev
->oldest_tle
);
222 mdev
->oldest_tle
= NULL
;
223 kfree(mdev
->unused_spare_tle
);
224 mdev
->unused_spare_tle
= NULL
;
225 kfree(mdev
->tl_hash
);
226 mdev
->tl_hash
= NULL
;
231 * _tl_add_barrier() - Adds a barrier to the transfer log
232 * @mdev: DRBD device.
233 * @new: Barrier to be added before the current head of the TL.
235 * The caller must hold the req_lock.
237 void _tl_add_barrier(struct drbd_conf
*mdev
, struct drbd_tl_epoch
*new)
239 struct drbd_tl_epoch
*newest_before
;
241 INIT_LIST_HEAD(&new->requests
);
242 INIT_LIST_HEAD(&new->w
.list
);
243 new->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
247 newest_before
= mdev
->newest_tle
;
248 /* never send a barrier number == 0, because that is special-cased
249 * when using TCQ for our write ordering code */
250 new->br_number
= (newest_before
->br_number
+1) ?: 1;
251 if (mdev
->newest_tle
!= new) {
252 mdev
->newest_tle
->next
= new;
253 mdev
->newest_tle
= new;
258 * tl_release() - Free or recycle the oldest &struct drbd_tl_epoch object of the TL
259 * @mdev: DRBD device.
260 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
261 * @set_size: Expected number of requests before that barrier.
263 * In case the passed barrier_nr or set_size does not match the oldest
264 * &struct drbd_tl_epoch objects this function will cause a termination
267 void tl_release(struct drbd_conf
*mdev
, unsigned int barrier_nr
,
268 unsigned int set_size
)
270 struct drbd_tl_epoch
*b
, *nob
; /* next old barrier */
271 struct list_head
*le
, *tle
;
272 struct drbd_request
*r
;
274 spin_lock_irq(&mdev
->req_lock
);
276 b
= mdev
->oldest_tle
;
278 /* first some paranoia code */
280 dev_err(DEV
, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
284 if (b
->br_number
!= barrier_nr
) {
285 dev_err(DEV
, "BAD! BarrierAck #%u received, expected #%u!\n",
286 barrier_nr
, b
->br_number
);
289 if (b
->n_writes
!= set_size
) {
290 dev_err(DEV
, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
291 barrier_nr
, set_size
, b
->n_writes
);
295 /* Clean up list of requests processed during current epoch */
296 list_for_each_safe(le
, tle
, &b
->requests
) {
297 r
= list_entry(le
, struct drbd_request
, tl_requests
);
298 _req_mod(r
, barrier_acked
);
300 /* There could be requests on the list waiting for completion
301 of the write to the local disk. To avoid corruptions of
302 slab's data structures we have to remove the lists head.
304 Also there could have been a barrier ack out of sequence, overtaking
305 the write acks - which would be a bug and violating write ordering.
306 To not deadlock in case we lose connection while such requests are
307 still pending, we need some way to find them for the
308 _req_mode(connection_lost_while_pending).
310 These have been list_move'd to the out_of_sequence_requests list in
311 _req_mod(, barrier_acked) above.
313 list_del_init(&b
->requests
);
316 if (test_and_clear_bit(CREATE_BARRIER
, &mdev
->flags
)) {
317 _tl_add_barrier(mdev
, b
);
319 mdev
->oldest_tle
= nob
;
320 /* if nob == NULL b was the only barrier, and becomes the new
321 barrier. Therefore mdev->oldest_tle points already to b */
323 D_ASSERT(nob
!= NULL
);
324 mdev
->oldest_tle
= nob
;
328 spin_unlock_irq(&mdev
->req_lock
);
329 dec_ap_pending(mdev
);
334 spin_unlock_irq(&mdev
->req_lock
);
335 drbd_force_state(mdev
, NS(conn
, C_PROTOCOL_ERROR
));
339 * _tl_restart() - Walks the transfer log, and applies an action to all requests
340 * @mdev: DRBD device.
341 * @what: The action/event to perform with all request objects
343 * @what might be one of connection_lost_while_pending, resend, fail_frozen_disk_io,
344 * restart_frozen_disk_io.
346 static void _tl_restart(struct drbd_conf
*mdev
, enum drbd_req_event what
)
348 struct drbd_tl_epoch
*b
, *tmp
, **pn
;
349 struct list_head
*le
, *tle
, carry_reads
;
350 struct drbd_request
*req
;
351 int rv
, n_writes
, n_reads
;
353 b
= mdev
->oldest_tle
;
354 pn
= &mdev
->oldest_tle
;
358 INIT_LIST_HEAD(&carry_reads
);
359 list_for_each_safe(le
, tle
, &b
->requests
) {
360 req
= list_entry(le
, struct drbd_request
, tl_requests
);
361 rv
= _req_mod(req
, what
);
363 n_writes
+= (rv
& MR_WRITE
) >> MR_WRITE_SHIFT
;
364 n_reads
+= (rv
& MR_READ
) >> MR_READ_SHIFT
;
369 if (what
== resend
) {
370 b
->n_writes
= n_writes
;
371 if (b
->w
.cb
== NULL
) {
372 b
->w
.cb
= w_send_barrier
;
373 inc_ap_pending(mdev
);
374 set_bit(CREATE_BARRIER
, &mdev
->flags
);
377 drbd_queue_work(&mdev
->data
.work
, &b
->w
);
382 list_add(&carry_reads
, &b
->requests
);
383 /* there could still be requests on that ring list,
384 * in case local io is still pending */
385 list_del(&b
->requests
);
387 /* dec_ap_pending corresponding to queue_barrier.
388 * the newest barrier may not have been queued yet,
389 * in which case w.cb is still NULL. */
391 dec_ap_pending(mdev
);
393 if (b
== mdev
->newest_tle
) {
394 /* recycle, but reinit! */
395 D_ASSERT(tmp
== NULL
);
396 INIT_LIST_HEAD(&b
->requests
);
397 list_splice(&carry_reads
, &b
->requests
);
398 INIT_LIST_HEAD(&b
->w
.list
);
400 b
->br_number
= net_random();
410 list_splice(&carry_reads
, &b
->requests
);
416 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
417 * @mdev: DRBD device.
419 * This is called after the connection to the peer was lost. The storage covered
420 * by the requests on the transfer gets marked as our of sync. Called from the
421 * receiver thread and the worker thread.
423 void tl_clear(struct drbd_conf
*mdev
)
425 struct list_head
*le
, *tle
;
426 struct drbd_request
*r
;
428 spin_lock_irq(&mdev
->req_lock
);
430 _tl_restart(mdev
, connection_lost_while_pending
);
432 /* we expect this list to be empty. */
433 D_ASSERT(list_empty(&mdev
->out_of_sequence_requests
));
435 /* but just in case, clean it up anyways! */
436 list_for_each_safe(le
, tle
, &mdev
->out_of_sequence_requests
) {
437 r
= list_entry(le
, struct drbd_request
, tl_requests
);
438 /* It would be nice to complete outside of spinlock.
439 * But this is easier for now. */
440 _req_mod(r
, connection_lost_while_pending
);
443 /* ensure bit indicating barrier is required is clear */
444 clear_bit(CREATE_BARRIER
, &mdev
->flags
);
446 memset(mdev
->app_reads_hash
, 0, APP_R_HSIZE
*sizeof(void *));
448 spin_unlock_irq(&mdev
->req_lock
);
451 void tl_restart(struct drbd_conf
*mdev
, enum drbd_req_event what
)
453 spin_lock_irq(&mdev
->req_lock
);
454 _tl_restart(mdev
, what
);
455 spin_unlock_irq(&mdev
->req_lock
);
459 * cl_wide_st_chg() - true if the state change is a cluster wide one
460 * @mdev: DRBD device.
461 * @os: old (current) state.
462 * @ns: new (wanted) state.
464 static int cl_wide_st_chg(struct drbd_conf
*mdev
,
465 union drbd_state os
, union drbd_state ns
)
467 return (os
.conn
>= C_CONNECTED
&& ns
.conn
>= C_CONNECTED
&&
468 ((os
.role
!= R_PRIMARY
&& ns
.role
== R_PRIMARY
) ||
469 (os
.conn
!= C_STARTING_SYNC_T
&& ns
.conn
== C_STARTING_SYNC_T
) ||
470 (os
.conn
!= C_STARTING_SYNC_S
&& ns
.conn
== C_STARTING_SYNC_S
) ||
471 (os
.disk
!= D_DISKLESS
&& ns
.disk
== D_DISKLESS
))) ||
472 (os
.conn
>= C_CONNECTED
&& ns
.conn
== C_DISCONNECTING
) ||
473 (os
.conn
== C_CONNECTED
&& ns
.conn
== C_VERIFY_S
);
477 drbd_change_state(struct drbd_conf
*mdev
, enum chg_state_flags f
,
478 union drbd_state mask
, union drbd_state val
)
481 union drbd_state os
, ns
;
482 enum drbd_state_rv rv
;
484 spin_lock_irqsave(&mdev
->req_lock
, flags
);
486 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
487 rv
= _drbd_set_state(mdev
, ns
, f
, NULL
);
489 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
495 * drbd_force_state() - Impose a change which happens outside our control on our state
496 * @mdev: DRBD device.
497 * @mask: mask of state bits to change.
498 * @val: value of new state bits.
500 void drbd_force_state(struct drbd_conf
*mdev
,
501 union drbd_state mask
, union drbd_state val
)
503 drbd_change_state(mdev
, CS_HARD
, mask
, val
);
506 static enum drbd_state_rv
is_valid_state(struct drbd_conf
*, union drbd_state
);
507 static enum drbd_state_rv
is_valid_state_transition(struct drbd_conf
*,
510 static union drbd_state
sanitize_state(struct drbd_conf
*mdev
, union drbd_state os
,
511 union drbd_state ns
, const char **warn_sync_abort
);
512 int drbd_send_state_req(struct drbd_conf
*,
513 union drbd_state
, union drbd_state
);
515 static enum drbd_state_rv
516 _req_st_cond(struct drbd_conf
*mdev
, union drbd_state mask
,
517 union drbd_state val
)
519 union drbd_state os
, ns
;
521 enum drbd_state_rv rv
;
523 if (test_and_clear_bit(CL_ST_CHG_SUCCESS
, &mdev
->flags
))
524 return SS_CW_SUCCESS
;
526 if (test_and_clear_bit(CL_ST_CHG_FAIL
, &mdev
->flags
))
527 return SS_CW_FAILED_BY_PEER
;
530 spin_lock_irqsave(&mdev
->req_lock
, flags
);
532 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
533 ns
= sanitize_state(mdev
, os
, ns
, NULL
);
535 if (!cl_wide_st_chg(mdev
, os
, ns
))
538 rv
= is_valid_state(mdev
, ns
);
539 if (rv
== SS_SUCCESS
) {
540 rv
= is_valid_state_transition(mdev
, ns
, os
);
541 if (rv
== SS_SUCCESS
)
542 rv
= SS_UNKNOWN_ERROR
; /* cont waiting, otherwise fail. */
545 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
551 * drbd_req_state() - Perform an eventually cluster wide state change
552 * @mdev: DRBD device.
553 * @mask: mask of state bits to change.
554 * @val: value of new state bits.
557 * Should not be called directly, use drbd_request_state() or
558 * _drbd_request_state().
560 static enum drbd_state_rv
561 drbd_req_state(struct drbd_conf
*mdev
, union drbd_state mask
,
562 union drbd_state val
, enum chg_state_flags f
)
564 struct completion done
;
566 union drbd_state os
, ns
;
567 enum drbd_state_rv rv
;
569 init_completion(&done
);
571 if (f
& CS_SERIALIZE
)
572 mutex_lock(&mdev
->state_mutex
);
574 spin_lock_irqsave(&mdev
->req_lock
, flags
);
576 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
577 ns
= sanitize_state(mdev
, os
, ns
, NULL
);
579 if (cl_wide_st_chg(mdev
, os
, ns
)) {
580 rv
= is_valid_state(mdev
, ns
);
581 if (rv
== SS_SUCCESS
)
582 rv
= is_valid_state_transition(mdev
, ns
, os
);
583 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
585 if (rv
< SS_SUCCESS
) {
587 print_st_err(mdev
, os
, ns
, rv
);
591 drbd_state_lock(mdev
);
592 if (!drbd_send_state_req(mdev
, mask
, val
)) {
593 drbd_state_unlock(mdev
);
594 rv
= SS_CW_FAILED_BY_PEER
;
596 print_st_err(mdev
, os
, ns
, rv
);
600 wait_event(mdev
->state_wait
,
601 (rv
= _req_st_cond(mdev
, mask
, val
)));
603 if (rv
< SS_SUCCESS
) {
604 drbd_state_unlock(mdev
);
606 print_st_err(mdev
, os
, ns
, rv
);
609 spin_lock_irqsave(&mdev
->req_lock
, flags
);
611 ns
.i
= (os
.i
& ~mask
.i
) | val
.i
;
612 rv
= _drbd_set_state(mdev
, ns
, f
, &done
);
613 drbd_state_unlock(mdev
);
615 rv
= _drbd_set_state(mdev
, ns
, f
, &done
);
618 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
620 if (f
& CS_WAIT_COMPLETE
&& rv
== SS_SUCCESS
) {
621 D_ASSERT(current
!= mdev
->worker
.task
);
622 wait_for_completion(&done
);
626 if (f
& CS_SERIALIZE
)
627 mutex_unlock(&mdev
->state_mutex
);
633 * _drbd_request_state() - Request a state change (with flags)
634 * @mdev: DRBD device.
635 * @mask: mask of state bits to change.
636 * @val: value of new state bits.
639 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE
640 * flag, or when logging of failed state change requests is not desired.
643 _drbd_request_state(struct drbd_conf
*mdev
, union drbd_state mask
,
644 union drbd_state val
, enum chg_state_flags f
)
646 enum drbd_state_rv rv
;
648 wait_event(mdev
->state_wait
,
649 (rv
= drbd_req_state(mdev
, mask
, val
, f
)) != SS_IN_TRANSIENT_STATE
);
654 static void print_st(struct drbd_conf
*mdev
, char *name
, union drbd_state ns
)
656 dev_err(DEV
, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c }\n",
658 drbd_conn_str(ns
.conn
),
659 drbd_role_str(ns
.role
),
660 drbd_role_str(ns
.peer
),
661 drbd_disk_str(ns
.disk
),
662 drbd_disk_str(ns
.pdsk
),
663 is_susp(ns
) ? 's' : 'r',
664 ns
.aftr_isp
? 'a' : '-',
665 ns
.peer_isp
? 'p' : '-',
666 ns
.user_isp
? 'u' : '-'
670 void print_st_err(struct drbd_conf
*mdev
, union drbd_state os
,
671 union drbd_state ns
, enum drbd_state_rv err
)
673 if (err
== SS_IN_TRANSIENT_STATE
)
675 dev_err(DEV
, "State change failed: %s\n", drbd_set_st_err_str(err
));
676 print_st(mdev
, " state", os
);
677 print_st(mdev
, "wanted", ns
);
682 * is_valid_state() - Returns an SS_ error code if ns is not valid
683 * @mdev: DRBD device.
684 * @ns: State to consider.
686 static enum drbd_state_rv
687 is_valid_state(struct drbd_conf
*mdev
, union drbd_state ns
)
689 /* See drbd_state_sw_errors in drbd_strings.c */
691 enum drbd_fencing_p fp
;
692 enum drbd_state_rv rv
= SS_SUCCESS
;
695 if (get_ldev(mdev
)) {
696 fp
= mdev
->ldev
->dc
.fencing
;
700 if (get_net_conf(mdev
)) {
701 if (!mdev
->net_conf
->two_primaries
&&
702 ns
.role
== R_PRIMARY
&& ns
.peer
== R_PRIMARY
)
703 rv
= SS_TWO_PRIMARIES
;
708 /* already found a reason to abort */;
709 else if (ns
.role
== R_SECONDARY
&& mdev
->open_cnt
)
710 rv
= SS_DEVICE_IN_USE
;
712 else if (ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.disk
< D_UP_TO_DATE
)
713 rv
= SS_NO_UP_TO_DATE_DISK
;
715 else if (fp
>= FP_RESOURCE
&&
716 ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.pdsk
>= D_UNKNOWN
)
719 else if (ns
.role
== R_PRIMARY
&& ns
.disk
<= D_INCONSISTENT
&& ns
.pdsk
<= D_INCONSISTENT
)
720 rv
= SS_NO_UP_TO_DATE_DISK
;
722 else if (ns
.conn
> C_CONNECTED
&& ns
.disk
< D_INCONSISTENT
)
723 rv
= SS_NO_LOCAL_DISK
;
725 else if (ns
.conn
> C_CONNECTED
&& ns
.pdsk
< D_INCONSISTENT
)
726 rv
= SS_NO_REMOTE_DISK
;
728 else if (ns
.conn
> C_CONNECTED
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
)
729 rv
= SS_NO_UP_TO_DATE_DISK
;
731 else if ((ns
.conn
== C_CONNECTED
||
732 ns
.conn
== C_WF_BITMAP_S
||
733 ns
.conn
== C_SYNC_SOURCE
||
734 ns
.conn
== C_PAUSED_SYNC_S
) &&
735 ns
.disk
== D_OUTDATED
)
736 rv
= SS_CONNECTED_OUTDATES
;
738 else if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
739 (mdev
->sync_conf
.verify_alg
[0] == 0))
740 rv
= SS_NO_VERIFY_ALG
;
742 else if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
743 mdev
->agreed_pro_version
< 88)
744 rv
= SS_NOT_SUPPORTED
;
750 * is_valid_state_transition() - Returns an SS_ error code if the state transition is not possible
751 * @mdev: DRBD device.
755 static enum drbd_state_rv
756 is_valid_state_transition(struct drbd_conf
*mdev
, union drbd_state ns
,
759 enum drbd_state_rv rv
= SS_SUCCESS
;
761 if ((ns
.conn
== C_STARTING_SYNC_T
|| ns
.conn
== C_STARTING_SYNC_S
) &&
762 os
.conn
> C_CONNECTED
)
763 rv
= SS_RESYNC_RUNNING
;
765 if (ns
.conn
== C_DISCONNECTING
&& os
.conn
== C_STANDALONE
)
766 rv
= SS_ALREADY_STANDALONE
;
768 if (ns
.disk
> D_ATTACHING
&& os
.disk
== D_DISKLESS
)
771 if (ns
.conn
== C_WF_CONNECTION
&& os
.conn
< C_UNCONNECTED
)
772 rv
= SS_NO_NET_CONFIG
;
774 if (ns
.disk
== D_OUTDATED
&& os
.disk
< D_OUTDATED
&& os
.disk
!= D_ATTACHING
)
775 rv
= SS_LOWER_THAN_OUTDATED
;
777 if (ns
.conn
== C_DISCONNECTING
&& os
.conn
== C_UNCONNECTED
)
778 rv
= SS_IN_TRANSIENT_STATE
;
780 if (ns
.conn
== os
.conn
&& ns
.conn
== C_WF_REPORT_PARAMS
)
781 rv
= SS_IN_TRANSIENT_STATE
;
783 if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) && os
.conn
< C_CONNECTED
)
784 rv
= SS_NEED_CONNECTION
;
786 if ((ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
) &&
787 ns
.conn
!= os
.conn
&& os
.conn
> C_CONNECTED
)
788 rv
= SS_RESYNC_RUNNING
;
790 if ((ns
.conn
== C_STARTING_SYNC_S
|| ns
.conn
== C_STARTING_SYNC_T
) &&
791 os
.conn
< C_CONNECTED
)
792 rv
= SS_NEED_CONNECTION
;
794 if ((ns
.conn
== C_SYNC_TARGET
|| ns
.conn
== C_SYNC_SOURCE
)
795 && os
.conn
< C_WF_REPORT_PARAMS
)
796 rv
= SS_NEED_CONNECTION
; /* No NetworkFailure -> SyncTarget etc... */
802 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition
803 * @mdev: DRBD device.
808 * When we loose connection, we have to set the state of the peers disk (pdsk)
809 * to D_UNKNOWN. This rule and many more along those lines are in this function.
811 static union drbd_state
sanitize_state(struct drbd_conf
*mdev
, union drbd_state os
,
812 union drbd_state ns
, const char **warn_sync_abort
)
814 enum drbd_fencing_p fp
;
815 enum drbd_disk_state disk_min
, disk_max
, pdsk_min
, pdsk_max
;
818 if (get_ldev(mdev
)) {
819 fp
= mdev
->ldev
->dc
.fencing
;
823 /* Disallow Network errors to configure a device's network part */
824 if ((ns
.conn
>= C_TIMEOUT
&& ns
.conn
<= C_TEAR_DOWN
) &&
825 os
.conn
<= C_DISCONNECTING
)
828 /* After a network error (+C_TEAR_DOWN) only C_UNCONNECTED or C_DISCONNECTING can follow.
829 * If you try to go into some Sync* state, that shall fail (elsewhere). */
830 if (os
.conn
>= C_TIMEOUT
&& os
.conn
<= C_TEAR_DOWN
&&
831 ns
.conn
!= C_UNCONNECTED
&& ns
.conn
!= C_DISCONNECTING
&& ns
.conn
<= C_TEAR_DOWN
)
834 /* we cannot fail (again) if we already detached */
835 if (ns
.disk
== D_FAILED
&& os
.disk
== D_DISKLESS
)
836 ns
.disk
= D_DISKLESS
;
838 /* if we are only D_ATTACHING yet,
839 * we can (and should) go directly to D_DISKLESS. */
840 if (ns
.disk
== D_FAILED
&& os
.disk
== D_ATTACHING
)
841 ns
.disk
= D_DISKLESS
;
843 /* After C_DISCONNECTING only C_STANDALONE may follow */
844 if (os
.conn
== C_DISCONNECTING
&& ns
.conn
!= C_STANDALONE
)
847 if (ns
.conn
< C_CONNECTED
) {
850 if (ns
.pdsk
> D_UNKNOWN
|| ns
.pdsk
< D_INCONSISTENT
)
854 /* Clear the aftr_isp when becoming unconfigured */
855 if (ns
.conn
== C_STANDALONE
&& ns
.disk
== D_DISKLESS
&& ns
.role
== R_SECONDARY
)
858 /* Abort resync if a disk fails/detaches */
859 if (os
.conn
> C_CONNECTED
&& ns
.conn
> C_CONNECTED
&&
860 (ns
.disk
<= D_FAILED
|| ns
.pdsk
<= D_FAILED
)) {
863 os
.conn
== C_VERIFY_S
|| os
.conn
== C_VERIFY_T
?
864 "Online-verify" : "Resync";
865 ns
.conn
= C_CONNECTED
;
868 /* Connection breaks down before we finished "Negotiating" */
869 if (ns
.conn
< C_CONNECTED
&& ns
.disk
== D_NEGOTIATING
&&
870 get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
871 if (mdev
->ed_uuid
== mdev
->ldev
->md
.uuid
[UI_CURRENT
]) {
872 ns
.disk
= mdev
->new_state_tmp
.disk
;
873 ns
.pdsk
= mdev
->new_state_tmp
.pdsk
;
875 dev_alert(DEV
, "Connection lost while negotiating, no data!\n");
876 ns
.disk
= D_DISKLESS
;
882 /* D_CONSISTENT and D_OUTDATED vanish when we get connected */
883 if (ns
.conn
>= C_CONNECTED
&& ns
.conn
< C_AHEAD
) {
884 if (ns
.disk
== D_CONSISTENT
|| ns
.disk
== D_OUTDATED
)
885 ns
.disk
= D_UP_TO_DATE
;
886 if (ns
.pdsk
== D_CONSISTENT
|| ns
.pdsk
== D_OUTDATED
)
887 ns
.pdsk
= D_UP_TO_DATE
;
890 /* Implications of the connection stat on the disk states */
891 disk_min
= D_DISKLESS
;
892 disk_max
= D_UP_TO_DATE
;
893 pdsk_min
= D_INCONSISTENT
;
894 pdsk_max
= D_UNKNOWN
;
895 switch ((enum drbd_conns
)ns
.conn
) {
897 case C_PAUSED_SYNC_T
:
898 case C_STARTING_SYNC_T
:
901 disk_min
= D_INCONSISTENT
;
902 disk_max
= D_OUTDATED
;
903 pdsk_min
= D_UP_TO_DATE
;
904 pdsk_max
= D_UP_TO_DATE
;
908 disk_min
= D_UP_TO_DATE
;
909 disk_max
= D_UP_TO_DATE
;
910 pdsk_min
= D_UP_TO_DATE
;
911 pdsk_max
= D_UP_TO_DATE
;
914 disk_min
= D_DISKLESS
;
915 disk_max
= D_UP_TO_DATE
;
916 pdsk_min
= D_DISKLESS
;
917 pdsk_max
= D_UP_TO_DATE
;
920 case C_PAUSED_SYNC_S
:
921 case C_STARTING_SYNC_S
:
923 disk_min
= D_UP_TO_DATE
;
924 disk_max
= D_UP_TO_DATE
;
925 pdsk_min
= D_INCONSISTENT
;
926 pdsk_max
= D_CONSISTENT
; /* D_OUTDATED would be nice. But explicit outdate necessary*/
929 disk_min
= D_INCONSISTENT
;
930 disk_max
= D_INCONSISTENT
;
931 pdsk_min
= D_UP_TO_DATE
;
932 pdsk_max
= D_UP_TO_DATE
;
935 disk_min
= D_UP_TO_DATE
;
936 disk_max
= D_UP_TO_DATE
;
937 pdsk_min
= D_INCONSISTENT
;
938 pdsk_max
= D_INCONSISTENT
;
941 case C_DISCONNECTING
:
945 case C_NETWORK_FAILURE
:
946 case C_PROTOCOL_ERROR
:
948 case C_WF_CONNECTION
:
949 case C_WF_REPORT_PARAMS
:
953 if (ns
.disk
> disk_max
)
956 if (ns
.disk
< disk_min
) {
957 dev_warn(DEV
, "Implicitly set disk from %s to %s\n",
958 drbd_disk_str(ns
.disk
), drbd_disk_str(disk_min
));
961 if (ns
.pdsk
> pdsk_max
)
964 if (ns
.pdsk
< pdsk_min
) {
965 dev_warn(DEV
, "Implicitly set pdsk from %s to %s\n",
966 drbd_disk_str(ns
.pdsk
), drbd_disk_str(pdsk_min
));
970 if (fp
== FP_STONITH
&&
971 (ns
.role
== R_PRIMARY
&& ns
.conn
< C_CONNECTED
&& ns
.pdsk
> D_OUTDATED
) &&
972 !(os
.role
== R_PRIMARY
&& os
.conn
< C_CONNECTED
&& os
.pdsk
> D_OUTDATED
))
973 ns
.susp_fen
= 1; /* Suspend IO while fence-peer handler runs (peer lost) */
975 if (mdev
->sync_conf
.on_no_data
== OND_SUSPEND_IO
&&
976 (ns
.role
== R_PRIMARY
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
) &&
977 !(os
.role
== R_PRIMARY
&& os
.disk
< D_UP_TO_DATE
&& os
.pdsk
< D_UP_TO_DATE
))
978 ns
.susp_nod
= 1; /* Suspend IO while no data available (no accessible data available) */
980 if (ns
.aftr_isp
|| ns
.peer_isp
|| ns
.user_isp
) {
981 if (ns
.conn
== C_SYNC_SOURCE
)
982 ns
.conn
= C_PAUSED_SYNC_S
;
983 if (ns
.conn
== C_SYNC_TARGET
)
984 ns
.conn
= C_PAUSED_SYNC_T
;
986 if (ns
.conn
== C_PAUSED_SYNC_S
)
987 ns
.conn
= C_SYNC_SOURCE
;
988 if (ns
.conn
== C_PAUSED_SYNC_T
)
989 ns
.conn
= C_SYNC_TARGET
;
995 /* helper for __drbd_set_state */
996 static void set_ov_position(struct drbd_conf
*mdev
, enum drbd_conns cs
)
998 if (mdev
->agreed_pro_version
< 90)
999 mdev
->ov_start_sector
= 0;
1000 mdev
->rs_total
= drbd_bm_bits(mdev
);
1001 mdev
->ov_position
= 0;
1002 if (cs
== C_VERIFY_T
) {
1003 /* starting online verify from an arbitrary position
1004 * does not fit well into the existing protocol.
1005 * on C_VERIFY_T, we initialize ov_left and friends
1006 * implicitly in receive_DataRequest once the
1007 * first P_OV_REQUEST is received */
1008 mdev
->ov_start_sector
= ~(sector_t
)0;
1010 unsigned long bit
= BM_SECT_TO_BIT(mdev
->ov_start_sector
);
1011 if (bit
>= mdev
->rs_total
) {
1012 mdev
->ov_start_sector
=
1013 BM_BIT_TO_SECT(mdev
->rs_total
- 1);
1016 mdev
->rs_total
-= bit
;
1017 mdev
->ov_position
= mdev
->ov_start_sector
;
1019 mdev
->ov_left
= mdev
->rs_total
;
1022 static void drbd_resume_al(struct drbd_conf
*mdev
)
1024 if (test_and_clear_bit(AL_SUSPENDED
, &mdev
->flags
))
1025 dev_info(DEV
, "Resumed AL updates\n");
1029 * __drbd_set_state() - Set a new DRBD state
1030 * @mdev: DRBD device.
1033 * @done: Optional completion, that will get completed after the after_state_ch() finished
1035 * Caller needs to hold req_lock, and global_state_lock. Do not call directly.
1038 __drbd_set_state(struct drbd_conf
*mdev
, union drbd_state ns
,
1039 enum chg_state_flags flags
, struct completion
*done
)
1041 union drbd_state os
;
1042 enum drbd_state_rv rv
= SS_SUCCESS
;
1043 const char *warn_sync_abort
= NULL
;
1044 struct after_state_chg_work
*ascw
;
1048 ns
= sanitize_state(mdev
, os
, ns
, &warn_sync_abort
);
1051 return SS_NOTHING_TO_DO
;
1053 if (!(flags
& CS_HARD
)) {
1054 /* pre-state-change checks ; only look at ns */
1055 /* See drbd_state_sw_errors in drbd_strings.c */
1057 rv
= is_valid_state(mdev
, ns
);
1058 if (rv
< SS_SUCCESS
) {
1059 /* If the old state was illegal as well, then let
1062 if (is_valid_state(mdev
, os
) == rv
)
1063 rv
= is_valid_state_transition(mdev
, ns
, os
);
1065 rv
= is_valid_state_transition(mdev
, ns
, os
);
1068 if (rv
< SS_SUCCESS
) {
1069 if (flags
& CS_VERBOSE
)
1070 print_st_err(mdev
, os
, ns
, rv
);
1074 if (warn_sync_abort
)
1075 dev_warn(DEV
, "%s aborted.\n", warn_sync_abort
);
1081 if (ns
.role
!= os
.role
)
1082 pbp
+= sprintf(pbp
, "role( %s -> %s ) ",
1083 drbd_role_str(os
.role
),
1084 drbd_role_str(ns
.role
));
1085 if (ns
.peer
!= os
.peer
)
1086 pbp
+= sprintf(pbp
, "peer( %s -> %s ) ",
1087 drbd_role_str(os
.peer
),
1088 drbd_role_str(ns
.peer
));
1089 if (ns
.conn
!= os
.conn
)
1090 pbp
+= sprintf(pbp
, "conn( %s -> %s ) ",
1091 drbd_conn_str(os
.conn
),
1092 drbd_conn_str(ns
.conn
));
1093 if (ns
.disk
!= os
.disk
)
1094 pbp
+= sprintf(pbp
, "disk( %s -> %s ) ",
1095 drbd_disk_str(os
.disk
),
1096 drbd_disk_str(ns
.disk
));
1097 if (ns
.pdsk
!= os
.pdsk
)
1098 pbp
+= sprintf(pbp
, "pdsk( %s -> %s ) ",
1099 drbd_disk_str(os
.pdsk
),
1100 drbd_disk_str(ns
.pdsk
));
1101 if (is_susp(ns
) != is_susp(os
))
1102 pbp
+= sprintf(pbp
, "susp( %d -> %d ) ",
1105 if (ns
.aftr_isp
!= os
.aftr_isp
)
1106 pbp
+= sprintf(pbp
, "aftr_isp( %d -> %d ) ",
1109 if (ns
.peer_isp
!= os
.peer_isp
)
1110 pbp
+= sprintf(pbp
, "peer_isp( %d -> %d ) ",
1113 if (ns
.user_isp
!= os
.user_isp
)
1114 pbp
+= sprintf(pbp
, "user_isp( %d -> %d ) ",
1117 dev_info(DEV
, "%s\n", pb
);
1120 /* solve the race between becoming unconfigured,
1121 * worker doing the cleanup, and
1122 * admin reconfiguring us:
1123 * on (re)configure, first set CONFIG_PENDING,
1124 * then wait for a potentially exiting worker,
1125 * start the worker, and schedule one no_op.
1126 * then proceed with configuration.
1128 if (ns
.disk
== D_DISKLESS
&&
1129 ns
.conn
== C_STANDALONE
&&
1130 ns
.role
== R_SECONDARY
&&
1131 !test_and_set_bit(CONFIG_PENDING
, &mdev
->flags
))
1132 set_bit(DEVICE_DYING
, &mdev
->flags
);
1134 /* if we are going -> D_FAILED or D_DISKLESS, grab one extra reference
1135 * on the ldev here, to be sure the transition -> D_DISKLESS resp.
1136 * drbd_ldev_destroy() won't happen before our corresponding
1137 * after_state_ch works run, where we put_ldev again. */
1138 if ((os
.disk
!= D_FAILED
&& ns
.disk
== D_FAILED
) ||
1139 (os
.disk
!= D_DISKLESS
&& ns
.disk
== D_DISKLESS
))
1140 atomic_inc(&mdev
->local_cnt
);
1143 wake_up(&mdev
->misc_wait
);
1144 wake_up(&mdev
->state_wait
);
1146 /* aborted verify run. log the last position */
1147 if ((os
.conn
== C_VERIFY_S
|| os
.conn
== C_VERIFY_T
) &&
1148 ns
.conn
< C_CONNECTED
) {
1149 mdev
->ov_start_sector
=
1150 BM_BIT_TO_SECT(drbd_bm_bits(mdev
) - mdev
->ov_left
);
1151 dev_info(DEV
, "Online Verify reached sector %llu\n",
1152 (unsigned long long)mdev
->ov_start_sector
);
1155 if ((os
.conn
== C_PAUSED_SYNC_T
|| os
.conn
== C_PAUSED_SYNC_S
) &&
1156 (ns
.conn
== C_SYNC_TARGET
|| ns
.conn
== C_SYNC_SOURCE
)) {
1157 dev_info(DEV
, "Syncer continues.\n");
1158 mdev
->rs_paused
+= (long)jiffies
1159 -(long)mdev
->rs_mark_time
[mdev
->rs_last_mark
];
1160 if (ns
.conn
== C_SYNC_TARGET
)
1161 mod_timer(&mdev
->resync_timer
, jiffies
);
1164 if ((os
.conn
== C_SYNC_TARGET
|| os
.conn
== C_SYNC_SOURCE
) &&
1165 (ns
.conn
== C_PAUSED_SYNC_T
|| ns
.conn
== C_PAUSED_SYNC_S
)) {
1166 dev_info(DEV
, "Resync suspended\n");
1167 mdev
->rs_mark_time
[mdev
->rs_last_mark
] = jiffies
;
1170 if (os
.conn
== C_CONNECTED
&&
1171 (ns
.conn
== C_VERIFY_S
|| ns
.conn
== C_VERIFY_T
)) {
1172 unsigned long now
= jiffies
;
1175 set_ov_position(mdev
, ns
.conn
);
1176 mdev
->rs_start
= now
;
1177 mdev
->rs_last_events
= 0;
1178 mdev
->rs_last_sect_ev
= 0;
1179 mdev
->ov_last_oos_size
= 0;
1180 mdev
->ov_last_oos_start
= 0;
1182 for (i
= 0; i
< DRBD_SYNC_MARKS
; i
++) {
1183 mdev
->rs_mark_left
[i
] = mdev
->ov_left
;
1184 mdev
->rs_mark_time
[i
] = now
;
1187 drbd_rs_controller_reset(mdev
);
1189 if (ns
.conn
== C_VERIFY_S
) {
1190 dev_info(DEV
, "Starting Online Verify from sector %llu\n",
1191 (unsigned long long)mdev
->ov_position
);
1192 mod_timer(&mdev
->resync_timer
, jiffies
);
1196 if (get_ldev(mdev
)) {
1197 u32 mdf
= mdev
->ldev
->md
.flags
& ~(MDF_CONSISTENT
|MDF_PRIMARY_IND
|
1198 MDF_CONNECTED_IND
|MDF_WAS_UP_TO_DATE
|
1199 MDF_PEER_OUT_DATED
|MDF_CRASHED_PRIMARY
);
1201 if (test_bit(CRASHED_PRIMARY
, &mdev
->flags
))
1202 mdf
|= MDF_CRASHED_PRIMARY
;
1203 if (mdev
->state
.role
== R_PRIMARY
||
1204 (mdev
->state
.pdsk
< D_INCONSISTENT
&& mdev
->state
.peer
== R_PRIMARY
))
1205 mdf
|= MDF_PRIMARY_IND
;
1206 if (mdev
->state
.conn
> C_WF_REPORT_PARAMS
)
1207 mdf
|= MDF_CONNECTED_IND
;
1208 if (mdev
->state
.disk
> D_INCONSISTENT
)
1209 mdf
|= MDF_CONSISTENT
;
1210 if (mdev
->state
.disk
> D_OUTDATED
)
1211 mdf
|= MDF_WAS_UP_TO_DATE
;
1212 if (mdev
->state
.pdsk
<= D_OUTDATED
&& mdev
->state
.pdsk
>= D_INCONSISTENT
)
1213 mdf
|= MDF_PEER_OUT_DATED
;
1214 if (mdf
!= mdev
->ldev
->md
.flags
) {
1215 mdev
->ldev
->md
.flags
= mdf
;
1216 drbd_md_mark_dirty(mdev
);
1218 if (os
.disk
< D_CONSISTENT
&& ns
.disk
>= D_CONSISTENT
)
1219 drbd_set_ed_uuid(mdev
, mdev
->ldev
->md
.uuid
[UI_CURRENT
]);
1223 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */
1224 if (os
.disk
== D_INCONSISTENT
&& os
.pdsk
== D_INCONSISTENT
&&
1225 os
.peer
== R_SECONDARY
&& ns
.peer
== R_PRIMARY
)
1226 set_bit(CONSIDER_RESYNC
, &mdev
->flags
);
1228 /* Receiver should clean up itself */
1229 if (os
.conn
!= C_DISCONNECTING
&& ns
.conn
== C_DISCONNECTING
)
1230 drbd_thread_stop_nowait(&mdev
->receiver
);
1232 /* Now the receiver finished cleaning up itself, it should die */
1233 if (os
.conn
!= C_STANDALONE
&& ns
.conn
== C_STANDALONE
)
1234 drbd_thread_stop_nowait(&mdev
->receiver
);
1236 /* Upon network failure, we need to restart the receiver. */
1237 if (os
.conn
> C_TEAR_DOWN
&&
1238 ns
.conn
<= C_TEAR_DOWN
&& ns
.conn
>= C_TIMEOUT
)
1239 drbd_thread_restart_nowait(&mdev
->receiver
);
1241 /* Resume AL writing if we get a connection */
1242 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
)
1243 drbd_resume_al(mdev
);
1245 ascw
= kmalloc(sizeof(*ascw
), GFP_ATOMIC
);
1249 ascw
->flags
= flags
;
1250 ascw
->w
.cb
= w_after_state_ch
;
1252 drbd_queue_work(&mdev
->data
.work
, &ascw
->w
);
1254 dev_warn(DEV
, "Could not kmalloc an ascw\n");
1260 static int w_after_state_ch(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
1262 struct after_state_chg_work
*ascw
=
1263 container_of(w
, struct after_state_chg_work
, w
);
1264 after_state_ch(mdev
, ascw
->os
, ascw
->ns
, ascw
->flags
);
1265 if (ascw
->flags
& CS_WAIT_COMPLETE
) {
1266 D_ASSERT(ascw
->done
!= NULL
);
1267 complete(ascw
->done
);
1274 static void abw_start_sync(struct drbd_conf
*mdev
, int rv
)
1277 dev_err(DEV
, "Writing the bitmap failed not starting resync.\n");
1278 _drbd_request_state(mdev
, NS(conn
, C_CONNECTED
), CS_VERBOSE
);
1282 switch (mdev
->state
.conn
) {
1283 case C_STARTING_SYNC_T
:
1284 _drbd_request_state(mdev
, NS(conn
, C_WF_SYNC_UUID
), CS_VERBOSE
);
1286 case C_STARTING_SYNC_S
:
1287 drbd_start_resync(mdev
, C_SYNC_SOURCE
);
1292 int drbd_bitmap_io_from_worker(struct drbd_conf
*mdev
, int (*io_fn
)(struct drbd_conf
*), char *why
)
1296 D_ASSERT(current
== mdev
->worker
.task
);
1298 /* open coded non-blocking drbd_suspend_io(mdev); */
1299 set_bit(SUSPEND_IO
, &mdev
->flags
);
1300 if (!is_susp(mdev
->state
))
1301 D_ASSERT(atomic_read(&mdev
->ap_bio_cnt
) == 0);
1303 drbd_bm_lock(mdev
, why
);
1305 drbd_bm_unlock(mdev
);
1307 drbd_resume_io(mdev
);
1313 * after_state_ch() - Perform after state change actions that may sleep
1314 * @mdev: DRBD device.
1319 static void after_state_ch(struct drbd_conf
*mdev
, union drbd_state os
,
1320 union drbd_state ns
, enum chg_state_flags flags
)
1322 enum drbd_fencing_p fp
;
1323 enum drbd_req_event what
= nothing
;
1324 union drbd_state nsm
= (union drbd_state
){ .i
= -1 };
1326 if (os
.conn
!= C_CONNECTED
&& ns
.conn
== C_CONNECTED
) {
1327 clear_bit(CRASHED_PRIMARY
, &mdev
->flags
);
1329 mdev
->p_uuid
[UI_FLAGS
] &= ~((u64
)2);
1333 if (get_ldev(mdev
)) {
1334 fp
= mdev
->ldev
->dc
.fencing
;
1338 /* Inform userspace about the change... */
1339 drbd_bcast_state(mdev
, ns
);
1341 if (!(os
.role
== R_PRIMARY
&& os
.disk
< D_UP_TO_DATE
&& os
.pdsk
< D_UP_TO_DATE
) &&
1342 (ns
.role
== R_PRIMARY
&& ns
.disk
< D_UP_TO_DATE
&& ns
.pdsk
< D_UP_TO_DATE
))
1343 drbd_khelper(mdev
, "pri-on-incon-degr");
1345 /* Here we have the actions that are performed after a
1346 state change. This function might sleep */
1350 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
) {
1351 if (ns
.conn
== C_CONNECTED
)
1352 what
= resend
, nsm
.susp_nod
= 0;
1353 else /* ns.conn > C_CONNECTED */
1354 dev_err(DEV
, "Unexpected Resync going on!\n");
1357 if (os
.disk
== D_ATTACHING
&& ns
.disk
> D_ATTACHING
)
1358 what
= restart_frozen_disk_io
, nsm
.susp_nod
= 0;
1363 /* case1: The outdate peer handler is successful: */
1364 if (os
.pdsk
> D_OUTDATED
&& ns
.pdsk
<= D_OUTDATED
) {
1366 if (test_bit(NEW_CUR_UUID
, &mdev
->flags
)) {
1367 drbd_uuid_new_current(mdev
);
1368 clear_bit(NEW_CUR_UUID
, &mdev
->flags
);
1370 spin_lock_irq(&mdev
->req_lock
);
1371 _drbd_set_state(_NS(mdev
, susp_fen
, 0), CS_VERBOSE
, NULL
);
1372 spin_unlock_irq(&mdev
->req_lock
);
1374 /* case2: The connection was established again: */
1375 if (os
.conn
< C_CONNECTED
&& ns
.conn
>= C_CONNECTED
) {
1376 clear_bit(NEW_CUR_UUID
, &mdev
->flags
);
1382 if (what
!= nothing
) {
1383 spin_lock_irq(&mdev
->req_lock
);
1384 _tl_restart(mdev
, what
);
1385 nsm
.i
&= mdev
->state
.i
;
1386 _drbd_set_state(mdev
, nsm
, CS_VERBOSE
, NULL
);
1387 spin_unlock_irq(&mdev
->req_lock
);
1390 /* Became sync source. With protocol >= 96, we still need to send out
1391 * the sync uuid now. Need to do that before any drbd_send_state, or
1392 * the other side may go "paused sync" before receiving the sync uuids,
1393 * which is unexpected. */
1394 if ((os
.conn
!= C_SYNC_SOURCE
&& os
.conn
!= C_PAUSED_SYNC_S
) &&
1395 (ns
.conn
== C_SYNC_SOURCE
|| ns
.conn
== C_PAUSED_SYNC_S
) &&
1396 mdev
->agreed_pro_version
>= 96 && get_ldev(mdev
)) {
1397 drbd_gen_and_send_sync_uuid(mdev
);
1401 /* Do not change the order of the if above and the two below... */
1402 if (os
.pdsk
== D_DISKLESS
&& ns
.pdsk
> D_DISKLESS
) { /* attach on the peer */
1403 drbd_send_uuids(mdev
);
1404 drbd_send_state(mdev
);
1406 if (os
.conn
!= C_WF_BITMAP_S
&& ns
.conn
== C_WF_BITMAP_S
)
1407 drbd_queue_bitmap_io(mdev
, &drbd_send_bitmap
, NULL
, "send_bitmap (WFBitMapS)");
1409 /* Lost contact to peer's copy of the data */
1410 if ((os
.pdsk
>= D_INCONSISTENT
&&
1411 os
.pdsk
!= D_UNKNOWN
&&
1412 os
.pdsk
!= D_OUTDATED
)
1413 && (ns
.pdsk
< D_INCONSISTENT
||
1414 ns
.pdsk
== D_UNKNOWN
||
1415 ns
.pdsk
== D_OUTDATED
)) {
1416 if (get_ldev(mdev
)) {
1417 if ((ns
.role
== R_PRIMARY
|| ns
.peer
== R_PRIMARY
) &&
1418 mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && ns
.disk
>= D_UP_TO_DATE
) {
1419 if (is_susp(mdev
->state
)) {
1420 set_bit(NEW_CUR_UUID
, &mdev
->flags
);
1422 drbd_uuid_new_current(mdev
);
1423 drbd_send_uuids(mdev
);
1430 if (ns
.pdsk
< D_INCONSISTENT
&& get_ldev(mdev
)) {
1431 if (ns
.peer
== R_PRIMARY
&& mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0) {
1432 drbd_uuid_new_current(mdev
);
1433 drbd_send_uuids(mdev
);
1436 /* D_DISKLESS Peer becomes secondary */
1437 if (os
.peer
== R_PRIMARY
&& ns
.peer
== R_SECONDARY
)
1438 drbd_bitmap_io_from_worker(mdev
, &drbd_bm_write
, "demote diskless peer");
1442 /* Write out all changed bits on demote.
1443 * Though, no need to da that just yet
1444 * if there is a resync going on still */
1445 if (os
.role
== R_PRIMARY
&& ns
.role
== R_SECONDARY
&&
1446 mdev
->state
.conn
<= C_CONNECTED
&& get_ldev(mdev
)) {
1447 drbd_bitmap_io_from_worker(mdev
, &drbd_bm_write
, "demote");
1451 /* Last part of the attaching process ... */
1452 if (ns
.conn
>= C_CONNECTED
&&
1453 os
.disk
== D_ATTACHING
&& ns
.disk
== D_NEGOTIATING
) {
1454 drbd_send_sizes(mdev
, 0, 0); /* to start sync... */
1455 drbd_send_uuids(mdev
);
1456 drbd_send_state(mdev
);
1459 /* We want to pause/continue resync, tell peer. */
1460 if (ns
.conn
>= C_CONNECTED
&&
1461 ((os
.aftr_isp
!= ns
.aftr_isp
) ||
1462 (os
.user_isp
!= ns
.user_isp
)))
1463 drbd_send_state(mdev
);
1465 /* In case one of the isp bits got set, suspend other devices. */
1466 if ((!os
.aftr_isp
&& !os
.peer_isp
&& !os
.user_isp
) &&
1467 (ns
.aftr_isp
|| ns
.peer_isp
|| ns
.user_isp
))
1468 suspend_other_sg(mdev
);
1470 /* Make sure the peer gets informed about eventual state
1471 changes (ISP bits) while we were in WFReportParams. */
1472 if (os
.conn
== C_WF_REPORT_PARAMS
&& ns
.conn
>= C_CONNECTED
)
1473 drbd_send_state(mdev
);
1475 if (os
.conn
!= C_AHEAD
&& ns
.conn
== C_AHEAD
)
1476 drbd_send_state(mdev
);
1478 /* We are in the progress to start a full sync... */
1479 if ((os
.conn
!= C_STARTING_SYNC_T
&& ns
.conn
== C_STARTING_SYNC_T
) ||
1480 (os
.conn
!= C_STARTING_SYNC_S
&& ns
.conn
== C_STARTING_SYNC_S
))
1481 drbd_queue_bitmap_io(mdev
, &drbd_bmio_set_n_write
, &abw_start_sync
, "set_n_write from StartingSync");
1483 /* We are invalidating our self... */
1484 if (os
.conn
< C_CONNECTED
&& ns
.conn
< C_CONNECTED
&&
1485 os
.disk
> D_INCONSISTENT
&& ns
.disk
== D_INCONSISTENT
)
1486 drbd_queue_bitmap_io(mdev
, &drbd_bmio_set_n_write
, NULL
, "set_n_write from invalidate");
1488 /* first half of local IO error, failure to attach,
1489 * or administrative detach */
1490 if (os
.disk
!= D_FAILED
&& ns
.disk
== D_FAILED
) {
1491 enum drbd_io_error_p eh
;
1493 /* corresponding get_ldev was in __drbd_set_state, to serialize
1494 * our cleanup here with the transition to D_DISKLESS,
1495 * so it is safe to dreference ldev here. */
1496 eh
= mdev
->ldev
->dc
.on_io_error
;
1497 was_io_error
= test_and_clear_bit(WAS_IO_ERROR
, &mdev
->flags
);
1499 /* current state still has to be D_FAILED,
1500 * there is only one way out: to D_DISKLESS,
1501 * and that may only happen after our put_ldev below. */
1502 if (mdev
->state
.disk
!= D_FAILED
)
1504 "ASSERT FAILED: disk is %s during detach\n",
1505 drbd_disk_str(mdev
->state
.disk
));
1507 if (drbd_send_state(mdev
))
1508 dev_warn(DEV
, "Notified peer that I am detaching my disk\n");
1510 dev_err(DEV
, "Sending state for detaching disk failed\n");
1512 drbd_rs_cancel_all(mdev
);
1514 /* In case we want to get something to stable storage still,
1515 * this may be the last chance.
1516 * Following put_ldev may transition to D_DISKLESS. */
1520 if (was_io_error
&& eh
== EP_CALL_HELPER
)
1521 drbd_khelper(mdev
, "local-io-error");
1524 /* second half of local IO error, failure to attach,
1525 * or administrative detach,
1526 * after local_cnt references have reached zero again */
1527 if (os
.disk
!= D_DISKLESS
&& ns
.disk
== D_DISKLESS
) {
1528 /* We must still be diskless,
1529 * re-attach has to be serialized with this! */
1530 if (mdev
->state
.disk
!= D_DISKLESS
)
1532 "ASSERT FAILED: disk is %s while going diskless\n",
1533 drbd_disk_str(mdev
->state
.disk
));
1536 mdev
->rs_failed
= 0;
1537 atomic_set(&mdev
->rs_pending_cnt
, 0);
1539 if (drbd_send_state(mdev
))
1540 dev_warn(DEV
, "Notified peer that I'm now diskless.\n");
1542 dev_err(DEV
, "Sending state for being diskless failed\n");
1543 /* corresponding get_ldev in __drbd_set_state
1544 * this may finaly trigger drbd_ldev_destroy. */
1548 /* Disks got bigger while they were detached */
1549 if (ns
.disk
> D_NEGOTIATING
&& ns
.pdsk
> D_NEGOTIATING
&&
1550 test_and_clear_bit(RESYNC_AFTER_NEG
, &mdev
->flags
)) {
1551 if (ns
.conn
== C_CONNECTED
)
1552 resync_after_online_grow(mdev
);
1555 /* A resync finished or aborted, wake paused devices... */
1556 if ((os
.conn
> C_CONNECTED
&& ns
.conn
<= C_CONNECTED
) ||
1557 (os
.peer_isp
&& !ns
.peer_isp
) ||
1558 (os
.user_isp
&& !ns
.user_isp
))
1559 resume_next_sg(mdev
);
1561 /* sync target done with resync. Explicitly notify peer, even though
1562 * it should (at least for non-empty resyncs) already know itself. */
1563 if (os
.disk
< D_UP_TO_DATE
&& os
.conn
>= C_SYNC_SOURCE
&& ns
.conn
== C_CONNECTED
)
1564 drbd_send_state(mdev
);
1566 if (os
.conn
> C_CONNECTED
&& ns
.conn
<= C_CONNECTED
)
1567 drbd_queue_bitmap_io(mdev
, &drbd_bm_write
, NULL
, "write from resync_finished");
1569 /* free tl_hash if we Got thawed and are C_STANDALONE */
1570 if (ns
.conn
== C_STANDALONE
&& !is_susp(ns
) && mdev
->tl_hash
)
1571 drbd_free_tl_hash(mdev
);
1573 /* Upon network connection, we need to start the receiver */
1574 if (os
.conn
== C_STANDALONE
&& ns
.conn
== C_UNCONNECTED
)
1575 drbd_thread_start(&mdev
->receiver
);
1577 /* Terminate worker thread if we are unconfigured - it will be
1578 restarted as needed... */
1579 if (ns
.disk
== D_DISKLESS
&&
1580 ns
.conn
== C_STANDALONE
&&
1581 ns
.role
== R_SECONDARY
) {
1582 if (os
.aftr_isp
!= ns
.aftr_isp
)
1583 resume_next_sg(mdev
);
1584 /* set in __drbd_set_state, unless CONFIG_PENDING was set */
1585 if (test_bit(DEVICE_DYING
, &mdev
->flags
))
1586 drbd_thread_stop_nowait(&mdev
->worker
);
1593 static int drbd_thread_setup(void *arg
)
1595 struct drbd_thread
*thi
= (struct drbd_thread
*) arg
;
1596 struct drbd_conf
*mdev
= thi
->mdev
;
1597 unsigned long flags
;
1601 retval
= thi
->function(thi
);
1603 spin_lock_irqsave(&thi
->t_lock
, flags
);
1605 /* if the receiver has been "Exiting", the last thing it did
1606 * was set the conn state to "StandAlone",
1607 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
1608 * and receiver thread will be "started".
1609 * drbd_thread_start needs to set "Restarting" in that case.
1610 * t_state check and assignment needs to be within the same spinlock,
1611 * so either thread_start sees Exiting, and can remap to Restarting,
1612 * or thread_start see None, and can proceed as normal.
1615 if (thi
->t_state
== Restarting
) {
1616 dev_info(DEV
, "Restarting %s\n", current
->comm
);
1617 thi
->t_state
= Running
;
1618 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1623 thi
->t_state
= None
;
1625 complete(&thi
->stop
);
1626 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1628 dev_info(DEV
, "Terminating %s\n", current
->comm
);
1630 /* Release mod reference taken when thread was started */
1631 module_put(THIS_MODULE
);
1635 static void drbd_thread_init(struct drbd_conf
*mdev
, struct drbd_thread
*thi
,
1636 int (*func
) (struct drbd_thread
*))
1638 spin_lock_init(&thi
->t_lock
);
1640 thi
->t_state
= None
;
1641 thi
->function
= func
;
1645 int drbd_thread_start(struct drbd_thread
*thi
)
1647 struct drbd_conf
*mdev
= thi
->mdev
;
1648 struct task_struct
*nt
;
1649 unsigned long flags
;
1652 thi
== &mdev
->receiver
? "receiver" :
1653 thi
== &mdev
->asender
? "asender" :
1654 thi
== &mdev
->worker
? "worker" : "NONSENSE";
1656 /* is used from state engine doing drbd_thread_stop_nowait,
1657 * while holding the req lock irqsave */
1658 spin_lock_irqsave(&thi
->t_lock
, flags
);
1660 switch (thi
->t_state
) {
1662 dev_info(DEV
, "Starting %s thread (from %s [%d])\n",
1663 me
, current
->comm
, current
->pid
);
1665 /* Get ref on module for thread - this is released when thread exits */
1666 if (!try_module_get(THIS_MODULE
)) {
1667 dev_err(DEV
, "Failed to get module reference in drbd_thread_start\n");
1668 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1672 init_completion(&thi
->stop
);
1673 D_ASSERT(thi
->task
== NULL
);
1674 thi
->reset_cpu_mask
= 1;
1675 thi
->t_state
= Running
;
1676 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1677 flush_signals(current
); /* otherw. may get -ERESTARTNOINTR */
1679 nt
= kthread_create(drbd_thread_setup
, (void *) thi
,
1680 "drbd%d_%s", mdev_to_minor(mdev
), me
);
1683 dev_err(DEV
, "Couldn't start thread\n");
1685 module_put(THIS_MODULE
);
1688 spin_lock_irqsave(&thi
->t_lock
, flags
);
1690 thi
->t_state
= Running
;
1691 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1692 wake_up_process(nt
);
1695 thi
->t_state
= Restarting
;
1696 dev_info(DEV
, "Restarting %s thread (from %s [%d])\n",
1697 me
, current
->comm
, current
->pid
);
1702 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1710 void _drbd_thread_stop(struct drbd_thread
*thi
, int restart
, int wait
)
1712 unsigned long flags
;
1714 enum drbd_thread_state ns
= restart
? Restarting
: Exiting
;
1716 /* may be called from state engine, holding the req lock irqsave */
1717 spin_lock_irqsave(&thi
->t_lock
, flags
);
1719 if (thi
->t_state
== None
) {
1720 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1722 drbd_thread_start(thi
);
1726 if (thi
->t_state
!= ns
) {
1727 if (thi
->task
== NULL
) {
1728 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1734 init_completion(&thi
->stop
);
1735 if (thi
->task
!= current
)
1736 force_sig(DRBD_SIGKILL
, thi
->task
);
1740 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
1743 wait_for_completion(&thi
->stop
);
1748 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
1749 * @mdev: DRBD device.
1751 * Forces all threads of a device onto the same CPU. This is beneficial for
1752 * DRBD's performance. May be overwritten by user's configuration.
1754 void drbd_calc_cpu_mask(struct drbd_conf
*mdev
)
1758 /* user override. */
1759 if (cpumask_weight(mdev
->cpu_mask
))
1762 ord
= mdev_to_minor(mdev
) % cpumask_weight(cpu_online_mask
);
1763 for_each_online_cpu(cpu
) {
1765 cpumask_set_cpu(cpu
, mdev
->cpu_mask
);
1769 /* should not be reached */
1770 cpumask_setall(mdev
->cpu_mask
);
1774 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
1775 * @mdev: DRBD device.
1777 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
1780 void drbd_thread_current_set_cpu(struct drbd_conf
*mdev
)
1782 struct task_struct
*p
= current
;
1783 struct drbd_thread
*thi
=
1784 p
== mdev
->asender
.task
? &mdev
->asender
:
1785 p
== mdev
->receiver
.task
? &mdev
->receiver
:
1786 p
== mdev
->worker
.task
? &mdev
->worker
:
1790 if (!thi
->reset_cpu_mask
)
1792 thi
->reset_cpu_mask
= 0;
1793 set_cpus_allowed_ptr(p
, mdev
->cpu_mask
);
1797 /* the appropriate socket mutex must be held already */
1798 int _drbd_send_cmd(struct drbd_conf
*mdev
, struct socket
*sock
,
1799 enum drbd_packets cmd
, struct p_header80
*h
,
1800 size_t size
, unsigned msg_flags
)
1804 ERR_IF(!h
) return false;
1805 ERR_IF(!size
) return false;
1807 h
->magic
= BE_DRBD_MAGIC
;
1808 h
->command
= cpu_to_be16(cmd
);
1809 h
->length
= cpu_to_be16(size
-sizeof(struct p_header80
));
1811 sent
= drbd_send(mdev
, sock
, h
, size
, msg_flags
);
1813 ok
= (sent
== size
);
1815 dev_err(DEV
, "short sent %s size=%d sent=%d\n",
1816 cmdname(cmd
), (int)size
, sent
);
1820 /* don't pass the socket. we may only look at it
1821 * when we hold the appropriate socket mutex.
1823 int drbd_send_cmd(struct drbd_conf
*mdev
, int use_data_socket
,
1824 enum drbd_packets cmd
, struct p_header80
*h
, size_t size
)
1827 struct socket
*sock
;
1829 if (use_data_socket
) {
1830 mutex_lock(&mdev
->data
.mutex
);
1831 sock
= mdev
->data
.socket
;
1833 mutex_lock(&mdev
->meta
.mutex
);
1834 sock
= mdev
->meta
.socket
;
1837 /* drbd_disconnect() could have called drbd_free_sock()
1838 * while we were waiting in down()... */
1839 if (likely(sock
!= NULL
))
1840 ok
= _drbd_send_cmd(mdev
, sock
, cmd
, h
, size
, 0);
1842 if (use_data_socket
)
1843 mutex_unlock(&mdev
->data
.mutex
);
1845 mutex_unlock(&mdev
->meta
.mutex
);
1849 int drbd_send_cmd2(struct drbd_conf
*mdev
, enum drbd_packets cmd
, char *data
,
1852 struct p_header80 h
;
1855 h
.magic
= BE_DRBD_MAGIC
;
1856 h
.command
= cpu_to_be16(cmd
);
1857 h
.length
= cpu_to_be16(size
);
1859 if (!drbd_get_data_sock(mdev
))
1863 drbd_send(mdev
, mdev
->data
.socket
, &h
, sizeof(h
), 0));
1865 drbd_send(mdev
, mdev
->data
.socket
, data
, size
, 0));
1867 drbd_put_data_sock(mdev
);
1872 int drbd_send_sync_param(struct drbd_conf
*mdev
, struct syncer_conf
*sc
)
1874 struct p_rs_param_95
*p
;
1875 struct socket
*sock
;
1877 const int apv
= mdev
->agreed_pro_version
;
1879 size
= apv
<= 87 ? sizeof(struct p_rs_param
)
1880 : apv
== 88 ? sizeof(struct p_rs_param
)
1881 + strlen(mdev
->sync_conf
.verify_alg
) + 1
1882 : apv
<= 94 ? sizeof(struct p_rs_param_89
)
1883 : /* apv >= 95 */ sizeof(struct p_rs_param_95
);
1885 /* used from admin command context and receiver/worker context.
1886 * to avoid kmalloc, grab the socket right here,
1887 * then use the pre-allocated sbuf there */
1888 mutex_lock(&mdev
->data
.mutex
);
1889 sock
= mdev
->data
.socket
;
1891 if (likely(sock
!= NULL
)) {
1892 enum drbd_packets cmd
= apv
>= 89 ? P_SYNC_PARAM89
: P_SYNC_PARAM
;
1894 p
= &mdev
->data
.sbuf
.rs_param_95
;
1896 /* initialize verify_alg and csums_alg */
1897 memset(p
->verify_alg
, 0, 2 * SHARED_SECRET_MAX
);
1899 p
->rate
= cpu_to_be32(sc
->rate
);
1900 p
->c_plan_ahead
= cpu_to_be32(sc
->c_plan_ahead
);
1901 p
->c_delay_target
= cpu_to_be32(sc
->c_delay_target
);
1902 p
->c_fill_target
= cpu_to_be32(sc
->c_fill_target
);
1903 p
->c_max_rate
= cpu_to_be32(sc
->c_max_rate
);
1906 strcpy(p
->verify_alg
, mdev
->sync_conf
.verify_alg
);
1908 strcpy(p
->csums_alg
, mdev
->sync_conf
.csums_alg
);
1910 rv
= _drbd_send_cmd(mdev
, sock
, cmd
, &p
->head
, size
, 0);
1912 rv
= 0; /* not ok */
1914 mutex_unlock(&mdev
->data
.mutex
);
1919 int drbd_send_protocol(struct drbd_conf
*mdev
)
1921 struct p_protocol
*p
;
1924 size
= sizeof(struct p_protocol
);
1926 if (mdev
->agreed_pro_version
>= 87)
1927 size
+= strlen(mdev
->net_conf
->integrity_alg
) + 1;
1929 /* we must not recurse into our own queue,
1930 * as that is blocked during handshake */
1931 p
= kmalloc(size
, GFP_NOIO
);
1935 p
->protocol
= cpu_to_be32(mdev
->net_conf
->wire_protocol
);
1936 p
->after_sb_0p
= cpu_to_be32(mdev
->net_conf
->after_sb_0p
);
1937 p
->after_sb_1p
= cpu_to_be32(mdev
->net_conf
->after_sb_1p
);
1938 p
->after_sb_2p
= cpu_to_be32(mdev
->net_conf
->after_sb_2p
);
1939 p
->two_primaries
= cpu_to_be32(mdev
->net_conf
->two_primaries
);
1942 if (mdev
->net_conf
->want_lose
)
1944 if (mdev
->net_conf
->dry_run
) {
1945 if (mdev
->agreed_pro_version
>= 92)
1948 dev_err(DEV
, "--dry-run is not supported by peer");
1953 p
->conn_flags
= cpu_to_be32(cf
);
1955 if (mdev
->agreed_pro_version
>= 87)
1956 strcpy(p
->integrity_alg
, mdev
->net_conf
->integrity_alg
);
1958 rv
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_PROTOCOL
,
1959 (struct p_header80
*)p
, size
);
1964 int _drbd_send_uuids(struct drbd_conf
*mdev
, u64 uuid_flags
)
1969 if (!get_ldev_if_state(mdev
, D_NEGOTIATING
))
1972 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
1973 p
.uuid
[i
] = mdev
->ldev
? cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]) : 0;
1975 mdev
->comm_bm_set
= drbd_bm_total_weight(mdev
);
1976 p
.uuid
[UI_SIZE
] = cpu_to_be64(mdev
->comm_bm_set
);
1977 uuid_flags
|= mdev
->net_conf
->want_lose
? 1 : 0;
1978 uuid_flags
|= test_bit(CRASHED_PRIMARY
, &mdev
->flags
) ? 2 : 0;
1979 uuid_flags
|= mdev
->new_state_tmp
.disk
== D_INCONSISTENT
? 4 : 0;
1980 p
.uuid
[UI_FLAGS
] = cpu_to_be64(uuid_flags
);
1984 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_UUIDS
,
1985 (struct p_header80
*)&p
, sizeof(p
));
1988 int drbd_send_uuids(struct drbd_conf
*mdev
)
1990 return _drbd_send_uuids(mdev
, 0);
1993 int drbd_send_uuids_skip_initial_sync(struct drbd_conf
*mdev
)
1995 return _drbd_send_uuids(mdev
, 8);
1998 int drbd_gen_and_send_sync_uuid(struct drbd_conf
*mdev
)
2003 D_ASSERT(mdev
->state
.disk
== D_UP_TO_DATE
);
2005 get_random_bytes(&uuid
, sizeof(u64
));
2006 drbd_uuid_set(mdev
, UI_BITMAP
, uuid
);
2008 p
.uuid
= cpu_to_be64(uuid
);
2010 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_SYNC_UUID
,
2011 (struct p_header80
*)&p
, sizeof(p
));
2014 int drbd_send_sizes(struct drbd_conf
*mdev
, int trigger_reply
, enum dds_flags flags
)
2017 sector_t d_size
, u_size
;
2021 if (get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
2022 D_ASSERT(mdev
->ldev
->backing_bdev
);
2023 d_size
= drbd_get_max_capacity(mdev
->ldev
);
2024 u_size
= mdev
->ldev
->dc
.disk_size
;
2025 q_order_type
= drbd_queue_order_type(mdev
);
2030 q_order_type
= QUEUE_ORDERED_NONE
;
2033 p
.d_size
= cpu_to_be64(d_size
);
2034 p
.u_size
= cpu_to_be64(u_size
);
2035 p
.c_size
= cpu_to_be64(trigger_reply
? 0 : drbd_get_capacity(mdev
->this_bdev
));
2036 p
.max_bio_size
= cpu_to_be32(queue_max_hw_sectors(mdev
->rq_queue
) << 9);
2037 p
.queue_order_type
= cpu_to_be16(q_order_type
);
2038 p
.dds_flags
= cpu_to_be16(flags
);
2040 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_SIZES
,
2041 (struct p_header80
*)&p
, sizeof(p
));
2046 * drbd_send_state() - Sends the drbd state to the peer
2047 * @mdev: DRBD device.
2049 int drbd_send_state(struct drbd_conf
*mdev
)
2051 struct socket
*sock
;
2055 /* Grab state lock so we wont send state if we're in the middle
2056 * of a cluster wide state change on another thread */
2057 drbd_state_lock(mdev
);
2059 mutex_lock(&mdev
->data
.mutex
);
2061 p
.state
= cpu_to_be32(mdev
->state
.i
); /* Within the send mutex */
2062 sock
= mdev
->data
.socket
;
2064 if (likely(sock
!= NULL
)) {
2065 ok
= _drbd_send_cmd(mdev
, sock
, P_STATE
,
2066 (struct p_header80
*)&p
, sizeof(p
), 0);
2069 mutex_unlock(&mdev
->data
.mutex
);
2071 drbd_state_unlock(mdev
);
2075 int drbd_send_state_req(struct drbd_conf
*mdev
,
2076 union drbd_state mask
, union drbd_state val
)
2078 struct p_req_state p
;
2080 p
.mask
= cpu_to_be32(mask
.i
);
2081 p
.val
= cpu_to_be32(val
.i
);
2083 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_STATE_CHG_REQ
,
2084 (struct p_header80
*)&p
, sizeof(p
));
2087 int drbd_send_sr_reply(struct drbd_conf
*mdev
, enum drbd_state_rv retcode
)
2089 struct p_req_state_reply p
;
2091 p
.retcode
= cpu_to_be32(retcode
);
2093 return drbd_send_cmd(mdev
, USE_META_SOCKET
, P_STATE_CHG_REPLY
,
2094 (struct p_header80
*)&p
, sizeof(p
));
2097 int fill_bitmap_rle_bits(struct drbd_conf
*mdev
,
2098 struct p_compressed_bm
*p
,
2099 struct bm_xfer_ctx
*c
)
2101 struct bitstream bs
;
2102 unsigned long plain_bits
;
2109 /* may we use this feature? */
2110 if ((mdev
->sync_conf
.use_rle
== 0) ||
2111 (mdev
->agreed_pro_version
< 90))
2114 if (c
->bit_offset
>= c
->bm_bits
)
2115 return 0; /* nothing to do. */
2117 /* use at most thus many bytes */
2118 bitstream_init(&bs
, p
->code
, BM_PACKET_VLI_BYTES_MAX
, 0);
2119 memset(p
->code
, 0, BM_PACKET_VLI_BYTES_MAX
);
2120 /* plain bits covered in this code string */
2123 /* p->encoding & 0x80 stores whether the first run length is set.
2124 * bit offset is implicit.
2125 * start with toggle == 2 to be able to tell the first iteration */
2128 /* see how much plain bits we can stuff into one packet
2129 * using RLE and VLI. */
2131 tmp
= (toggle
== 0) ? _drbd_bm_find_next_zero(mdev
, c
->bit_offset
)
2132 : _drbd_bm_find_next(mdev
, c
->bit_offset
);
2135 rl
= tmp
- c
->bit_offset
;
2137 if (toggle
== 2) { /* first iteration */
2139 /* the first checked bit was set,
2140 * store start value, */
2141 DCBP_set_start(p
, 1);
2142 /* but skip encoding of zero run length */
2146 DCBP_set_start(p
, 0);
2149 /* paranoia: catch zero runlength.
2150 * can only happen if bitmap is modified while we scan it. */
2152 dev_err(DEV
, "unexpected zero runlength while encoding bitmap "
2153 "t:%u bo:%lu\n", toggle
, c
->bit_offset
);
2157 bits
= vli_encode_bits(&bs
, rl
);
2158 if (bits
== -ENOBUFS
) /* buffer full */
2161 dev_err(DEV
, "error while encoding bitmap: %d\n", bits
);
2167 c
->bit_offset
= tmp
;
2168 } while (c
->bit_offset
< c
->bm_bits
);
2170 len
= bs
.cur
.b
- p
->code
+ !!bs
.cur
.bit
;
2172 if (plain_bits
< (len
<< 3)) {
2173 /* incompressible with this method.
2174 * we need to rewind both word and bit position. */
2175 c
->bit_offset
-= plain_bits
;
2176 bm_xfer_ctx_bit_to_word_offset(c
);
2177 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
2181 /* RLE + VLI was able to compress it just fine.
2182 * update c->word_offset. */
2183 bm_xfer_ctx_bit_to_word_offset(c
);
2185 /* store pad_bits */
2186 DCBP_set_pad_bits(p
, (8 - bs
.cur
.bit
) & 0x7);
2192 * send_bitmap_rle_or_plain
2194 * Return 0 when done, 1 when another iteration is needed, and a negative error
2195 * code upon failure.
2198 send_bitmap_rle_or_plain(struct drbd_conf
*mdev
,
2199 struct p_header80
*h
, struct bm_xfer_ctx
*c
)
2201 struct p_compressed_bm
*p
= (void*)h
;
2202 unsigned long num_words
;
2206 len
= fill_bitmap_rle_bits(mdev
, p
, c
);
2212 DCBP_set_code(p
, RLE_VLI_Bits
);
2213 ok
= _drbd_send_cmd(mdev
, mdev
->data
.socket
, P_COMPRESSED_BITMAP
, h
,
2214 sizeof(*p
) + len
, 0);
2217 c
->bytes
[0] += sizeof(*p
) + len
;
2219 if (c
->bit_offset
>= c
->bm_bits
)
2222 /* was not compressible.
2223 * send a buffer full of plain text bits instead. */
2224 num_words
= min_t(size_t, BM_PACKET_WORDS
, c
->bm_words
- c
->word_offset
);
2225 len
= num_words
* sizeof(long);
2227 drbd_bm_get_lel(mdev
, c
->word_offset
, num_words
, (unsigned long*)h
->payload
);
2228 ok
= _drbd_send_cmd(mdev
, mdev
->data
.socket
, P_BITMAP
,
2229 h
, sizeof(struct p_header80
) + len
, 0);
2230 c
->word_offset
+= num_words
;
2231 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
2234 c
->bytes
[1] += sizeof(struct p_header80
) + len
;
2236 if (c
->bit_offset
> c
->bm_bits
)
2237 c
->bit_offset
= c
->bm_bits
;
2241 INFO_bm_xfer_stats(mdev
, "send", c
);
2249 /* See the comment at receive_bitmap() */
2250 int _drbd_send_bitmap(struct drbd_conf
*mdev
)
2252 struct bm_xfer_ctx c
;
2253 struct p_header80
*p
;
2256 ERR_IF(!mdev
->bitmap
) return false;
2258 /* maybe we should use some per thread scratch page,
2259 * and allocate that during initial device creation? */
2260 p
= (struct p_header80
*) __get_free_page(GFP_NOIO
);
2262 dev_err(DEV
, "failed to allocate one page buffer in %s\n", __func__
);
2266 if (get_ldev(mdev
)) {
2267 if (drbd_md_test_flag(mdev
->ldev
, MDF_FULL_SYNC
)) {
2268 dev_info(DEV
, "Writing the whole bitmap, MDF_FullSync was set.\n");
2269 drbd_bm_set_all(mdev
);
2270 if (drbd_bm_write(mdev
)) {
2271 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
2272 * but otherwise process as per normal - need to tell other
2273 * side that a full resync is required! */
2274 dev_err(DEV
, "Failed to write bitmap to disk!\n");
2276 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
2283 c
= (struct bm_xfer_ctx
) {
2284 .bm_bits
= drbd_bm_bits(mdev
),
2285 .bm_words
= drbd_bm_words(mdev
),
2289 err
= send_bitmap_rle_or_plain(mdev
, p
, &c
);
2292 free_page((unsigned long) p
);
2296 int drbd_send_bitmap(struct drbd_conf
*mdev
)
2300 if (!drbd_get_data_sock(mdev
))
2302 err
= !_drbd_send_bitmap(mdev
);
2303 drbd_put_data_sock(mdev
);
2307 int drbd_send_b_ack(struct drbd_conf
*mdev
, u32 barrier_nr
, u32 set_size
)
2310 struct p_barrier_ack p
;
2312 p
.barrier
= barrier_nr
;
2313 p
.set_size
= cpu_to_be32(set_size
);
2315 if (mdev
->state
.conn
< C_CONNECTED
)
2317 ok
= drbd_send_cmd(mdev
, USE_META_SOCKET
, P_BARRIER_ACK
,
2318 (struct p_header80
*)&p
, sizeof(p
));
2323 * _drbd_send_ack() - Sends an ack packet
2324 * @mdev: DRBD device.
2325 * @cmd: Packet command code.
2326 * @sector: sector, needs to be in big endian byte order
2327 * @blksize: size in byte, needs to be in big endian byte order
2328 * @block_id: Id, big endian byte order
2330 static int _drbd_send_ack(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2336 struct p_block_ack p
;
2339 p
.block_id
= block_id
;
2340 p
.blksize
= blksize
;
2341 p
.seq_num
= cpu_to_be32(atomic_add_return(1, &mdev
->packet_seq
));
2343 if (!mdev
->meta
.socket
|| mdev
->state
.conn
< C_CONNECTED
)
2345 ok
= drbd_send_cmd(mdev
, USE_META_SOCKET
, cmd
,
2346 (struct p_header80
*)&p
, sizeof(p
));
2350 /* dp->sector and dp->block_id already/still in network byte order,
2351 * data_size is payload size according to dp->head,
2352 * and may need to be corrected for digest size. */
2353 int drbd_send_ack_dp(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2354 struct p_data
*dp
, int data_size
)
2356 data_size
-= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_r_tfm
) ?
2357 crypto_hash_digestsize(mdev
->integrity_r_tfm
) : 0;
2358 return _drbd_send_ack(mdev
, cmd
, dp
->sector
, cpu_to_be32(data_size
),
2362 int drbd_send_ack_rp(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2363 struct p_block_req
*rp
)
2365 return _drbd_send_ack(mdev
, cmd
, rp
->sector
, rp
->blksize
, rp
->block_id
);
2369 * drbd_send_ack() - Sends an ack packet
2370 * @mdev: DRBD device.
2371 * @cmd: Packet command code.
2374 int drbd_send_ack(struct drbd_conf
*mdev
,
2375 enum drbd_packets cmd
, struct drbd_epoch_entry
*e
)
2377 return _drbd_send_ack(mdev
, cmd
,
2378 cpu_to_be64(e
->sector
),
2379 cpu_to_be32(e
->size
),
2383 /* This function misuses the block_id field to signal if the blocks
2384 * are is sync or not. */
2385 int drbd_send_ack_ex(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2386 sector_t sector
, int blksize
, u64 block_id
)
2388 return _drbd_send_ack(mdev
, cmd
,
2389 cpu_to_be64(sector
),
2390 cpu_to_be32(blksize
),
2391 cpu_to_be64(block_id
));
2394 int drbd_send_drequest(struct drbd_conf
*mdev
, int cmd
,
2395 sector_t sector
, int size
, u64 block_id
)
2398 struct p_block_req p
;
2400 p
.sector
= cpu_to_be64(sector
);
2401 p
.block_id
= block_id
;
2402 p
.blksize
= cpu_to_be32(size
);
2404 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, cmd
,
2405 (struct p_header80
*)&p
, sizeof(p
));
2409 int drbd_send_drequest_csum(struct drbd_conf
*mdev
,
2410 sector_t sector
, int size
,
2411 void *digest
, int digest_size
,
2412 enum drbd_packets cmd
)
2415 struct p_block_req p
;
2417 p
.sector
= cpu_to_be64(sector
);
2418 p
.block_id
= BE_DRBD_MAGIC
+ 0xbeef;
2419 p
.blksize
= cpu_to_be32(size
);
2421 p
.head
.magic
= BE_DRBD_MAGIC
;
2422 p
.head
.command
= cpu_to_be16(cmd
);
2423 p
.head
.length
= cpu_to_be16(sizeof(p
) - sizeof(struct p_header80
) + digest_size
);
2425 mutex_lock(&mdev
->data
.mutex
);
2427 ok
= (sizeof(p
) == drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), 0));
2428 ok
= ok
&& (digest_size
== drbd_send(mdev
, mdev
->data
.socket
, digest
, digest_size
, 0));
2430 mutex_unlock(&mdev
->data
.mutex
);
2435 int drbd_send_ov_request(struct drbd_conf
*mdev
, sector_t sector
, int size
)
2438 struct p_block_req p
;
2440 p
.sector
= cpu_to_be64(sector
);
2441 p
.block_id
= BE_DRBD_MAGIC
+ 0xbabe;
2442 p
.blksize
= cpu_to_be32(size
);
2444 ok
= drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_OV_REQUEST
,
2445 (struct p_header80
*)&p
, sizeof(p
));
2449 /* called on sndtimeo
2450 * returns false if we should retry,
2451 * true if we think connection is dead
2453 static int we_should_drop_the_connection(struct drbd_conf
*mdev
, struct socket
*sock
)
2456 /* long elapsed = (long)(jiffies - mdev->last_received); */
2458 drop_it
= mdev
->meta
.socket
== sock
2459 || !mdev
->asender
.task
2460 || get_t_state(&mdev
->asender
) != Running
2461 || mdev
->state
.conn
< C_CONNECTED
;
2466 drop_it
= !--mdev
->ko_count
;
2468 dev_err(DEV
, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
2469 current
->comm
, current
->pid
, mdev
->ko_count
);
2473 return drop_it
; /* && (mdev->state == R_PRIMARY) */;
2476 /* The idea of sendpage seems to be to put some kind of reference
2477 * to the page into the skb, and to hand it over to the NIC. In
2478 * this process get_page() gets called.
2480 * As soon as the page was really sent over the network put_page()
2481 * gets called by some part of the network layer. [ NIC driver? ]
2483 * [ get_page() / put_page() increment/decrement the count. If count
2484 * reaches 0 the page will be freed. ]
2486 * This works nicely with pages from FSs.
2487 * But this means that in protocol A we might signal IO completion too early!
2489 * In order not to corrupt data during a resync we must make sure
2490 * that we do not reuse our own buffer pages (EEs) to early, therefore
2491 * we have the net_ee list.
2493 * XFS seems to have problems, still, it submits pages with page_count == 0!
2494 * As a workaround, we disable sendpage on pages
2495 * with page_count == 0 or PageSlab.
2497 static int _drbd_no_send_page(struct drbd_conf
*mdev
, struct page
*page
,
2498 int offset
, size_t size
, unsigned msg_flags
)
2500 int sent
= drbd_send(mdev
, mdev
->data
.socket
, kmap(page
) + offset
, size
, msg_flags
);
2503 mdev
->send_cnt
+= size
>>9;
2504 return sent
== size
;
2507 static int _drbd_send_page(struct drbd_conf
*mdev
, struct page
*page
,
2508 int offset
, size_t size
, unsigned msg_flags
)
2510 mm_segment_t oldfs
= get_fs();
2514 /* e.g. XFS meta- & log-data is in slab pages, which have a
2515 * page_count of 0 and/or have PageSlab() set.
2516 * we cannot use send_page for those, as that does get_page();
2517 * put_page(); and would cause either a VM_BUG directly, or
2518 * __page_cache_release a page that would actually still be referenced
2519 * by someone, leading to some obscure delayed Oops somewhere else. */
2520 if (disable_sendpage
|| (page_count(page
) < 1) || PageSlab(page
))
2521 return _drbd_no_send_page(mdev
, page
, offset
, size
, msg_flags
);
2523 msg_flags
|= MSG_NOSIGNAL
;
2524 drbd_update_congested(mdev
);
2527 sent
= mdev
->data
.socket
->ops
->sendpage(mdev
->data
.socket
, page
,
2530 if (sent
== -EAGAIN
) {
2531 if (we_should_drop_the_connection(mdev
,
2538 dev_warn(DEV
, "%s: size=%d len=%d sent=%d\n",
2539 __func__
, (int)size
, len
, sent
);
2544 } while (len
> 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
2546 clear_bit(NET_CONGESTED
, &mdev
->flags
);
2550 mdev
->send_cnt
+= size
>>9;
2554 static int _drbd_send_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
2556 struct bio_vec
*bvec
;
2558 /* hint all but last page with MSG_MORE */
2559 __bio_for_each_segment(bvec
, bio
, i
, 0) {
2560 if (!_drbd_no_send_page(mdev
, bvec
->bv_page
,
2561 bvec
->bv_offset
, bvec
->bv_len
,
2562 i
== bio
->bi_vcnt
-1 ? 0 : MSG_MORE
))
2568 static int _drbd_send_zc_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
2570 struct bio_vec
*bvec
;
2572 /* hint all but last page with MSG_MORE */
2573 __bio_for_each_segment(bvec
, bio
, i
, 0) {
2574 if (!_drbd_send_page(mdev
, bvec
->bv_page
,
2575 bvec
->bv_offset
, bvec
->bv_len
,
2576 i
== bio
->bi_vcnt
-1 ? 0 : MSG_MORE
))
2582 static int _drbd_send_zc_ee(struct drbd_conf
*mdev
, struct drbd_epoch_entry
*e
)
2584 struct page
*page
= e
->pages
;
2585 unsigned len
= e
->size
;
2586 /* hint all but last page with MSG_MORE */
2587 page_chain_for_each(page
) {
2588 unsigned l
= min_t(unsigned, len
, PAGE_SIZE
);
2589 if (!_drbd_send_page(mdev
, page
, 0, l
,
2590 page_chain_next(page
) ? MSG_MORE
: 0))
2597 static u32
bio_flags_to_wire(struct drbd_conf
*mdev
, unsigned long bi_rw
)
2599 if (mdev
->agreed_pro_version
>= 95)
2600 return (bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0) |
2601 (bi_rw
& REQ_FUA
? DP_FUA
: 0) |
2602 (bi_rw
& REQ_FLUSH
? DP_FLUSH
: 0) |
2603 (bi_rw
& REQ_DISCARD
? DP_DISCARD
: 0);
2605 return bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0;
2608 /* Used to send write requests
2609 * R_PRIMARY -> Peer (P_DATA)
2611 int drbd_send_dblock(struct drbd_conf
*mdev
, struct drbd_request
*req
)
2615 unsigned int dp_flags
= 0;
2619 if (!drbd_get_data_sock(mdev
))
2622 dgs
= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_w_tfm
) ?
2623 crypto_hash_digestsize(mdev
->integrity_w_tfm
) : 0;
2625 if (req
->size
<= DRBD_MAX_SIZE_H80_PACKET
) {
2626 p
.head
.h80
.magic
= BE_DRBD_MAGIC
;
2627 p
.head
.h80
.command
= cpu_to_be16(P_DATA
);
2629 cpu_to_be16(sizeof(p
) - sizeof(union p_header
) + dgs
+ req
->size
);
2631 p
.head
.h95
.magic
= BE_DRBD_MAGIC_BIG
;
2632 p
.head
.h95
.command
= cpu_to_be16(P_DATA
);
2634 cpu_to_be32(sizeof(p
) - sizeof(union p_header
) + dgs
+ req
->size
);
2637 p
.sector
= cpu_to_be64(req
->sector
);
2638 p
.block_id
= (unsigned long)req
;
2639 p
.seq_num
= cpu_to_be32(req
->seq_num
=
2640 atomic_add_return(1, &mdev
->packet_seq
));
2642 dp_flags
= bio_flags_to_wire(mdev
, req
->master_bio
->bi_rw
);
2644 if (mdev
->state
.conn
>= C_SYNC_SOURCE
&&
2645 mdev
->state
.conn
<= C_PAUSED_SYNC_T
)
2646 dp_flags
|= DP_MAY_SET_IN_SYNC
;
2648 p
.dp_flags
= cpu_to_be32(dp_flags
);
2649 set_bit(UNPLUG_REMOTE
, &mdev
->flags
);
2651 drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), dgs
? MSG_MORE
: 0));
2653 dgb
= mdev
->int_dig_out
;
2654 drbd_csum_bio(mdev
, mdev
->integrity_w_tfm
, req
->master_bio
, dgb
);
2655 ok
= dgs
== drbd_send(mdev
, mdev
->data
.socket
, dgb
, dgs
, 0);
2658 /* For protocol A, we have to memcpy the payload into
2659 * socket buffers, as we may complete right away
2660 * as soon as we handed it over to tcp, at which point the data
2661 * pages may become invalid.
2663 * For data-integrity enabled, we copy it as well, so we can be
2664 * sure that even if the bio pages may still be modified, it
2665 * won't change the data on the wire, thus if the digest checks
2666 * out ok after sending on this side, but does not fit on the
2667 * receiving side, we sure have detected corruption elsewhere.
2669 if (mdev
->net_conf
->wire_protocol
== DRBD_PROT_A
|| dgs
)
2670 ok
= _drbd_send_bio(mdev
, req
->master_bio
);
2672 ok
= _drbd_send_zc_bio(mdev
, req
->master_bio
);
2674 /* double check digest, sometimes buffers have been modified in flight. */
2675 if (dgs
> 0 && dgs
<= 64) {
2676 /* 64 byte, 512 bit, is the larges digest size
2677 * currently supported in kernel crypto. */
2678 unsigned char digest
[64];
2679 drbd_csum_bio(mdev
, mdev
->integrity_w_tfm
, req
->master_bio
, digest
);
2680 if (memcmp(mdev
->int_dig_out
, digest
, dgs
)) {
2682 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
2683 (unsigned long long)req
->sector
, req
->size
);
2685 } /* else if (dgs > 64) {
2686 ... Be noisy about digest too large ...
2690 drbd_put_data_sock(mdev
);
2695 /* answer packet, used to send data back for read requests:
2696 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
2697 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
2699 int drbd_send_block(struct drbd_conf
*mdev
, enum drbd_packets cmd
,
2700 struct drbd_epoch_entry
*e
)
2707 dgs
= (mdev
->agreed_pro_version
>= 87 && mdev
->integrity_w_tfm
) ?
2708 crypto_hash_digestsize(mdev
->integrity_w_tfm
) : 0;
2710 if (e
->size
<= DRBD_MAX_SIZE_H80_PACKET
) {
2711 p
.head
.h80
.magic
= BE_DRBD_MAGIC
;
2712 p
.head
.h80
.command
= cpu_to_be16(cmd
);
2714 cpu_to_be16(sizeof(p
) - sizeof(struct p_header80
) + dgs
+ e
->size
);
2716 p
.head
.h95
.magic
= BE_DRBD_MAGIC_BIG
;
2717 p
.head
.h95
.command
= cpu_to_be16(cmd
);
2719 cpu_to_be32(sizeof(p
) - sizeof(struct p_header80
) + dgs
+ e
->size
);
2722 p
.sector
= cpu_to_be64(e
->sector
);
2723 p
.block_id
= e
->block_id
;
2724 /* p.seq_num = 0; No sequence numbers here.. */
2726 /* Only called by our kernel thread.
2727 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
2728 * in response to admin command or module unload.
2730 if (!drbd_get_data_sock(mdev
))
2733 ok
= sizeof(p
) == drbd_send(mdev
, mdev
->data
.socket
, &p
, sizeof(p
), dgs
? MSG_MORE
: 0);
2735 dgb
= mdev
->int_dig_out
;
2736 drbd_csum_ee(mdev
, mdev
->integrity_w_tfm
, e
, dgb
);
2737 ok
= dgs
== drbd_send(mdev
, mdev
->data
.socket
, dgb
, dgs
, 0);
2740 ok
= _drbd_send_zc_ee(mdev
, e
);
2742 drbd_put_data_sock(mdev
);
2747 int drbd_send_oos(struct drbd_conf
*mdev
, struct drbd_request
*req
)
2749 struct p_block_desc p
;
2751 p
.sector
= cpu_to_be64(req
->sector
);
2752 p
.blksize
= cpu_to_be32(req
->size
);
2754 return drbd_send_cmd(mdev
, USE_DATA_SOCKET
, P_OUT_OF_SYNC
, &p
.head
, sizeof(p
));
2758 drbd_send distinguishes two cases:
2760 Packets sent via the data socket "sock"
2761 and packets sent via the meta data socket "msock"
2764 -----------------+-------------------------+------------------------------
2765 timeout conf.timeout / 2 conf.timeout / 2
2766 timeout action send a ping via msock Abort communication
2767 and close all sockets
2771 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
2773 int drbd_send(struct drbd_conf
*mdev
, struct socket
*sock
,
2774 void *buf
, size_t size
, unsigned msg_flags
)
2783 /* THINK if (signal_pending) return ... ? */
2788 msg
.msg_name
= NULL
;
2789 msg
.msg_namelen
= 0;
2790 msg
.msg_control
= NULL
;
2791 msg
.msg_controllen
= 0;
2792 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
2794 if (sock
== mdev
->data
.socket
) {
2795 mdev
->ko_count
= mdev
->net_conf
->ko_count
;
2796 drbd_update_congested(mdev
);
2800 * tcp_sendmsg does _not_ use its size parameter at all ?
2802 * -EAGAIN on timeout, -EINTR on signal.
2805 * do we need to block DRBD_SIG if sock == &meta.socket ??
2806 * otherwise wake_asender() might interrupt some send_*Ack !
2808 rv
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
2809 if (rv
== -EAGAIN
) {
2810 if (we_should_drop_the_connection(mdev
, sock
))
2817 flush_signals(current
);
2825 } while (sent
< size
);
2827 if (sock
== mdev
->data
.socket
)
2828 clear_bit(NET_CONGESTED
, &mdev
->flags
);
2831 if (rv
!= -EAGAIN
) {
2832 dev_err(DEV
, "%s_sendmsg returned %d\n",
2833 sock
== mdev
->meta
.socket
? "msock" : "sock",
2835 drbd_force_state(mdev
, NS(conn
, C_BROKEN_PIPE
));
2837 drbd_force_state(mdev
, NS(conn
, C_TIMEOUT
));
2843 static int drbd_open(struct block_device
*bdev
, fmode_t mode
)
2845 struct drbd_conf
*mdev
= bdev
->bd_disk
->private_data
;
2846 unsigned long flags
;
2849 mutex_lock(&drbd_main_mutex
);
2850 spin_lock_irqsave(&mdev
->req_lock
, flags
);
2851 /* to have a stable mdev->state.role
2852 * and no race with updating open_cnt */
2854 if (mdev
->state
.role
!= R_PRIMARY
) {
2855 if (mode
& FMODE_WRITE
)
2857 else if (!allow_oos
)
2863 spin_unlock_irqrestore(&mdev
->req_lock
, flags
);
2864 mutex_unlock(&drbd_main_mutex
);
2869 static int drbd_release(struct gendisk
*gd
, fmode_t mode
)
2871 struct drbd_conf
*mdev
= gd
->private_data
;
2872 mutex_lock(&drbd_main_mutex
);
2874 mutex_unlock(&drbd_main_mutex
);
2878 static void drbd_set_defaults(struct drbd_conf
*mdev
)
2880 /* This way we get a compile error when sync_conf grows,
2881 and we forgot to initialize it here */
2882 mdev
->sync_conf
= (struct syncer_conf
) {
2883 /* .rate = */ DRBD_RATE_DEF
,
2884 /* .after = */ DRBD_AFTER_DEF
,
2885 /* .al_extents = */ DRBD_AL_EXTENTS_DEF
,
2886 /* .verify_alg = */ {}, 0,
2887 /* .cpu_mask = */ {}, 0,
2888 /* .csums_alg = */ {}, 0,
2890 /* .on_no_data = */ DRBD_ON_NO_DATA_DEF
,
2891 /* .c_plan_ahead = */ DRBD_C_PLAN_AHEAD_DEF
,
2892 /* .c_delay_target = */ DRBD_C_DELAY_TARGET_DEF
,
2893 /* .c_fill_target = */ DRBD_C_FILL_TARGET_DEF
,
2894 /* .c_max_rate = */ DRBD_C_MAX_RATE_DEF
,
2895 /* .c_min_rate = */ DRBD_C_MIN_RATE_DEF
2898 /* Have to use that way, because the layout differs between
2899 big endian and little endian */
2900 mdev
->state
= (union drbd_state
) {
2901 { .role
= R_SECONDARY
,
2903 .conn
= C_STANDALONE
,
2912 void drbd_init_set_defaults(struct drbd_conf
*mdev
)
2914 /* the memset(,0,) did most of this.
2915 * note: only assignments, no allocation in here */
2917 drbd_set_defaults(mdev
);
2919 atomic_set(&mdev
->ap_bio_cnt
, 0);
2920 atomic_set(&mdev
->ap_pending_cnt
, 0);
2921 atomic_set(&mdev
->rs_pending_cnt
, 0);
2922 atomic_set(&mdev
->unacked_cnt
, 0);
2923 atomic_set(&mdev
->local_cnt
, 0);
2924 atomic_set(&mdev
->net_cnt
, 0);
2925 atomic_set(&mdev
->packet_seq
, 0);
2926 atomic_set(&mdev
->pp_in_use
, 0);
2927 atomic_set(&mdev
->pp_in_use_by_net
, 0);
2928 atomic_set(&mdev
->rs_sect_in
, 0);
2929 atomic_set(&mdev
->rs_sect_ev
, 0);
2930 atomic_set(&mdev
->ap_in_flight
, 0);
2932 mutex_init(&mdev
->md_io_mutex
);
2933 mutex_init(&mdev
->data
.mutex
);
2934 mutex_init(&mdev
->meta
.mutex
);
2935 sema_init(&mdev
->data
.work
.s
, 0);
2936 sema_init(&mdev
->meta
.work
.s
, 0);
2937 mutex_init(&mdev
->state_mutex
);
2939 spin_lock_init(&mdev
->data
.work
.q_lock
);
2940 spin_lock_init(&mdev
->meta
.work
.q_lock
);
2942 spin_lock_init(&mdev
->al_lock
);
2943 spin_lock_init(&mdev
->req_lock
);
2944 spin_lock_init(&mdev
->peer_seq_lock
);
2945 spin_lock_init(&mdev
->epoch_lock
);
2947 INIT_LIST_HEAD(&mdev
->active_ee
);
2948 INIT_LIST_HEAD(&mdev
->sync_ee
);
2949 INIT_LIST_HEAD(&mdev
->done_ee
);
2950 INIT_LIST_HEAD(&mdev
->read_ee
);
2951 INIT_LIST_HEAD(&mdev
->net_ee
);
2952 INIT_LIST_HEAD(&mdev
->resync_reads
);
2953 INIT_LIST_HEAD(&mdev
->data
.work
.q
);
2954 INIT_LIST_HEAD(&mdev
->meta
.work
.q
);
2955 INIT_LIST_HEAD(&mdev
->resync_work
.list
);
2956 INIT_LIST_HEAD(&mdev
->unplug_work
.list
);
2957 INIT_LIST_HEAD(&mdev
->go_diskless
.list
);
2958 INIT_LIST_HEAD(&mdev
->md_sync_work
.list
);
2959 INIT_LIST_HEAD(&mdev
->start_resync_work
.list
);
2960 INIT_LIST_HEAD(&mdev
->bm_io_work
.w
.list
);
2962 mdev
->resync_work
.cb
= w_resync_inactive
;
2963 mdev
->unplug_work
.cb
= w_send_write_hint
;
2964 mdev
->go_diskless
.cb
= w_go_diskless
;
2965 mdev
->md_sync_work
.cb
= w_md_sync
;
2966 mdev
->bm_io_work
.w
.cb
= w_bitmap_io
;
2967 init_timer(&mdev
->resync_timer
);
2968 init_timer(&mdev
->md_sync_timer
);
2969 mdev
->resync_timer
.function
= resync_timer_fn
;
2970 mdev
->resync_timer
.data
= (unsigned long) mdev
;
2971 mdev
->md_sync_timer
.function
= md_sync_timer_fn
;
2972 mdev
->md_sync_timer
.data
= (unsigned long) mdev
;
2974 init_waitqueue_head(&mdev
->misc_wait
);
2975 init_waitqueue_head(&mdev
->state_wait
);
2976 init_waitqueue_head(&mdev
->net_cnt_wait
);
2977 init_waitqueue_head(&mdev
->ee_wait
);
2978 init_waitqueue_head(&mdev
->al_wait
);
2979 init_waitqueue_head(&mdev
->seq_wait
);
2981 drbd_thread_init(mdev
, &mdev
->receiver
, drbdd_init
);
2982 drbd_thread_init(mdev
, &mdev
->worker
, drbd_worker
);
2983 drbd_thread_init(mdev
, &mdev
->asender
, drbd_asender
);
2985 mdev
->agreed_pro_version
= PRO_VERSION_MAX
;
2986 mdev
->write_ordering
= WO_bdev_flush
;
2987 mdev
->resync_wenr
= LC_FREE
;
2990 void drbd_mdev_cleanup(struct drbd_conf
*mdev
)
2993 if (mdev
->receiver
.t_state
!= None
)
2994 dev_err(DEV
, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
2995 mdev
->receiver
.t_state
);
2997 /* no need to lock it, I'm the only thread alive */
2998 if (atomic_read(&mdev
->current_epoch
->epoch_size
) != 0)
2999 dev_err(DEV
, "epoch_size:%d\n", atomic_read(&mdev
->current_epoch
->epoch_size
));
3009 mdev
->rs_failed
= 0;
3010 mdev
->rs_last_events
= 0;
3011 mdev
->rs_last_sect_ev
= 0;
3012 for (i
= 0; i
< DRBD_SYNC_MARKS
; i
++) {
3013 mdev
->rs_mark_left
[i
] = 0;
3014 mdev
->rs_mark_time
[i
] = 0;
3016 D_ASSERT(mdev
->net_conf
== NULL
);
3018 drbd_set_my_capacity(mdev
, 0);
3020 /* maybe never allocated. */
3021 drbd_bm_resize(mdev
, 0, 1);
3022 drbd_bm_cleanup(mdev
);
3025 drbd_free_resources(mdev
);
3026 clear_bit(AL_SUSPENDED
, &mdev
->flags
);
3029 * currently we drbd_init_ee only on module load, so
3030 * we may do drbd_release_ee only on module unload!
3032 D_ASSERT(list_empty(&mdev
->active_ee
));
3033 D_ASSERT(list_empty(&mdev
->sync_ee
));
3034 D_ASSERT(list_empty(&mdev
->done_ee
));
3035 D_ASSERT(list_empty(&mdev
->read_ee
));
3036 D_ASSERT(list_empty(&mdev
->net_ee
));
3037 D_ASSERT(list_empty(&mdev
->resync_reads
));
3038 D_ASSERT(list_empty(&mdev
->data
.work
.q
));
3039 D_ASSERT(list_empty(&mdev
->meta
.work
.q
));
3040 D_ASSERT(list_empty(&mdev
->resync_work
.list
));
3041 D_ASSERT(list_empty(&mdev
->unplug_work
.list
));
3042 D_ASSERT(list_empty(&mdev
->go_diskless
.list
));
3044 drbd_set_defaults(mdev
);
3048 static void drbd_destroy_mempools(void)
3052 while (drbd_pp_pool
) {
3053 page
= drbd_pp_pool
;
3054 drbd_pp_pool
= (struct page
*)page_private(page
);
3059 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
3061 if (drbd_ee_mempool
)
3062 mempool_destroy(drbd_ee_mempool
);
3063 if (drbd_request_mempool
)
3064 mempool_destroy(drbd_request_mempool
);
3066 kmem_cache_destroy(drbd_ee_cache
);
3067 if (drbd_request_cache
)
3068 kmem_cache_destroy(drbd_request_cache
);
3069 if (drbd_bm_ext_cache
)
3070 kmem_cache_destroy(drbd_bm_ext_cache
);
3071 if (drbd_al_ext_cache
)
3072 kmem_cache_destroy(drbd_al_ext_cache
);
3074 drbd_ee_mempool
= NULL
;
3075 drbd_request_mempool
= NULL
;
3076 drbd_ee_cache
= NULL
;
3077 drbd_request_cache
= NULL
;
3078 drbd_bm_ext_cache
= NULL
;
3079 drbd_al_ext_cache
= NULL
;
3084 static int drbd_create_mempools(void)
3087 const int number
= (DRBD_MAX_BIO_SIZE
/PAGE_SIZE
) * minor_count
;
3090 /* prepare our caches and mempools */
3091 drbd_request_mempool
= NULL
;
3092 drbd_ee_cache
= NULL
;
3093 drbd_request_cache
= NULL
;
3094 drbd_bm_ext_cache
= NULL
;
3095 drbd_al_ext_cache
= NULL
;
3096 drbd_pp_pool
= NULL
;
3099 drbd_request_cache
= kmem_cache_create(
3100 "drbd_req", sizeof(struct drbd_request
), 0, 0, NULL
);
3101 if (drbd_request_cache
== NULL
)
3104 drbd_ee_cache
= kmem_cache_create(
3105 "drbd_ee", sizeof(struct drbd_epoch_entry
), 0, 0, NULL
);
3106 if (drbd_ee_cache
== NULL
)
3109 drbd_bm_ext_cache
= kmem_cache_create(
3110 "drbd_bm", sizeof(struct bm_extent
), 0, 0, NULL
);
3111 if (drbd_bm_ext_cache
== NULL
)
3114 drbd_al_ext_cache
= kmem_cache_create(
3115 "drbd_al", sizeof(struct lc_element
), 0, 0, NULL
);
3116 if (drbd_al_ext_cache
== NULL
)
3120 drbd_request_mempool
= mempool_create(number
,
3121 mempool_alloc_slab
, mempool_free_slab
, drbd_request_cache
);
3122 if (drbd_request_mempool
== NULL
)
3125 drbd_ee_mempool
= mempool_create(number
,
3126 mempool_alloc_slab
, mempool_free_slab
, drbd_ee_cache
);
3127 if (drbd_ee_mempool
== NULL
)
3130 /* drbd's page pool */
3131 spin_lock_init(&drbd_pp_lock
);
3133 for (i
= 0; i
< number
; i
++) {
3134 page
= alloc_page(GFP_HIGHUSER
);
3137 set_page_private(page
, (unsigned long)drbd_pp_pool
);
3138 drbd_pp_pool
= page
;
3140 drbd_pp_vacant
= number
;
3145 drbd_destroy_mempools(); /* in case we allocated some */
3149 static int drbd_notify_sys(struct notifier_block
*this, unsigned long code
,
3152 /* just so we have it. you never know what interesting things we
3153 * might want to do here some day...
3159 static struct notifier_block drbd_notifier
= {
3160 .notifier_call
= drbd_notify_sys
,
3163 static void drbd_release_ee_lists(struct drbd_conf
*mdev
)
3167 rr
= drbd_release_ee(mdev
, &mdev
->active_ee
);
3169 dev_err(DEV
, "%d EEs in active list found!\n", rr
);
3171 rr
= drbd_release_ee(mdev
, &mdev
->sync_ee
);
3173 dev_err(DEV
, "%d EEs in sync list found!\n", rr
);
3175 rr
= drbd_release_ee(mdev
, &mdev
->read_ee
);
3177 dev_err(DEV
, "%d EEs in read list found!\n", rr
);
3179 rr
= drbd_release_ee(mdev
, &mdev
->done_ee
);
3181 dev_err(DEV
, "%d EEs in done list found!\n", rr
);
3183 rr
= drbd_release_ee(mdev
, &mdev
->net_ee
);
3185 dev_err(DEV
, "%d EEs in net list found!\n", rr
);
3188 /* caution. no locking.
3189 * currently only used from module cleanup code. */
3190 static void drbd_delete_device(unsigned int minor
)
3192 struct drbd_conf
*mdev
= minor_to_mdev(minor
);
3197 /* paranoia asserts */
3198 if (mdev
->open_cnt
!= 0)
3199 dev_err(DEV
, "open_cnt = %d in %s:%u", mdev
->open_cnt
,
3200 __FILE__
, __LINE__
);
3202 ERR_IF (!list_empty(&mdev
->data
.work
.q
)) {
3203 struct list_head
*lp
;
3204 list_for_each(lp
, &mdev
->data
.work
.q
) {
3205 dev_err(DEV
, "lp = %p\n", lp
);
3208 /* end paranoia asserts */
3210 del_gendisk(mdev
->vdisk
);
3212 /* cleanup stuff that may have been allocated during
3213 * device (re-)configuration or state changes */
3215 if (mdev
->this_bdev
)
3216 bdput(mdev
->this_bdev
);
3218 drbd_free_resources(mdev
);
3220 drbd_release_ee_lists(mdev
);
3222 /* should be free'd on disconnect? */
3223 kfree(mdev
->ee_hash
);
3225 mdev->ee_hash_s = 0;
3226 mdev->ee_hash = NULL;
3229 lc_destroy(mdev
->act_log
);
3230 lc_destroy(mdev
->resync
);
3232 kfree(mdev
->p_uuid
);
3233 /* mdev->p_uuid = NULL; */
3235 kfree(mdev
->int_dig_out
);
3236 kfree(mdev
->int_dig_in
);
3237 kfree(mdev
->int_dig_vv
);
3239 /* cleanup the rest that has been
3240 * allocated from drbd_new_device
3241 * and actually free the mdev itself */
3242 drbd_free_mdev(mdev
);
3245 static void drbd_cleanup(void)
3249 unregister_reboot_notifier(&drbd_notifier
);
3251 /* first remove proc,
3252 * drbdsetup uses it's presence to detect
3253 * whether DRBD is loaded.
3254 * If we would get stuck in proc removal,
3255 * but have netlink already deregistered,
3256 * some drbdsetup commands may wait forever
3260 remove_proc_entry("drbd", NULL
);
3267 drbd_delete_device(i
);
3268 drbd_destroy_mempools();
3273 unregister_blkdev(DRBD_MAJOR
, "drbd");
3275 printk(KERN_INFO
"drbd: module cleanup done.\n");
3279 * drbd_congested() - Callback for pdflush
3280 * @congested_data: User data
3281 * @bdi_bits: Bits pdflush is currently interested in
3283 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
3285 static int drbd_congested(void *congested_data
, int bdi_bits
)
3287 struct drbd_conf
*mdev
= congested_data
;
3288 struct request_queue
*q
;
3292 if (!may_inc_ap_bio(mdev
)) {
3293 /* DRBD has frozen IO */
3299 if (get_ldev(mdev
)) {
3300 q
= bdev_get_queue(mdev
->ldev
->backing_bdev
);
3301 r
= bdi_congested(&q
->backing_dev_info
, bdi_bits
);
3307 if (bdi_bits
& (1 << BDI_async_congested
) && test_bit(NET_CONGESTED
, &mdev
->flags
)) {
3308 r
|= (1 << BDI_async_congested
);
3309 reason
= reason
== 'b' ? 'a' : 'n';
3313 mdev
->congestion_reason
= reason
;
3317 struct drbd_conf
*drbd_new_device(unsigned int minor
)
3319 struct drbd_conf
*mdev
;
3320 struct gendisk
*disk
;
3321 struct request_queue
*q
;
3323 /* GFP_KERNEL, we are outside of all write-out paths */
3324 mdev
= kzalloc(sizeof(struct drbd_conf
), GFP_KERNEL
);
3327 if (!zalloc_cpumask_var(&mdev
->cpu_mask
, GFP_KERNEL
))
3328 goto out_no_cpumask
;
3330 mdev
->minor
= minor
;
3332 drbd_init_set_defaults(mdev
);
3334 q
= blk_alloc_queue(GFP_KERNEL
);
3338 q
->queuedata
= mdev
;
3340 disk
= alloc_disk(1);
3345 set_disk_ro(disk
, true);
3348 disk
->major
= DRBD_MAJOR
;
3349 disk
->first_minor
= minor
;
3350 disk
->fops
= &drbd_ops
;
3351 sprintf(disk
->disk_name
, "drbd%d", minor
);
3352 disk
->private_data
= mdev
;
3354 mdev
->this_bdev
= bdget(MKDEV(DRBD_MAJOR
, minor
));
3355 /* we have no partitions. we contain only ourselves. */
3356 mdev
->this_bdev
->bd_contains
= mdev
->this_bdev
;
3358 q
->backing_dev_info
.congested_fn
= drbd_congested
;
3359 q
->backing_dev_info
.congested_data
= mdev
;
3361 blk_queue_make_request(q
, drbd_make_request
);
3362 blk_queue_max_hw_sectors(q
, DRBD_MAX_BIO_SIZE
>> 9);
3363 blk_queue_bounce_limit(q
, BLK_BOUNCE_ANY
);
3364 blk_queue_merge_bvec(q
, drbd_merge_bvec
);
3365 q
->queue_lock
= &mdev
->req_lock
;
3367 mdev
->md_io_page
= alloc_page(GFP_KERNEL
);
3368 if (!mdev
->md_io_page
)
3369 goto out_no_io_page
;
3371 if (drbd_bm_init(mdev
))
3373 /* no need to lock access, we are still initializing this minor device. */
3377 mdev
->app_reads_hash
= kzalloc(APP_R_HSIZE
*sizeof(void *), GFP_KERNEL
);
3378 if (!mdev
->app_reads_hash
)
3379 goto out_no_app_reads
;
3381 mdev
->current_epoch
= kzalloc(sizeof(struct drbd_epoch
), GFP_KERNEL
);
3382 if (!mdev
->current_epoch
)
3385 INIT_LIST_HEAD(&mdev
->current_epoch
->list
);
3390 /* out_whatever_else:
3391 kfree(mdev->current_epoch); */
3393 kfree(mdev
->app_reads_hash
);
3397 drbd_bm_cleanup(mdev
);
3399 __free_page(mdev
->md_io_page
);
3403 blk_cleanup_queue(q
);
3405 free_cpumask_var(mdev
->cpu_mask
);
3411 /* counterpart of drbd_new_device.
3412 * last part of drbd_delete_device. */
3413 void drbd_free_mdev(struct drbd_conf
*mdev
)
3415 kfree(mdev
->current_epoch
);
3416 kfree(mdev
->app_reads_hash
);
3418 if (mdev
->bitmap
) /* should no longer be there. */
3419 drbd_bm_cleanup(mdev
);
3420 __free_page(mdev
->md_io_page
);
3421 put_disk(mdev
->vdisk
);
3422 blk_cleanup_queue(mdev
->rq_queue
);
3423 free_cpumask_var(mdev
->cpu_mask
);
3424 drbd_free_tl_hash(mdev
);
3429 int __init
drbd_init(void)
3433 if (sizeof(struct p_handshake
) != 80) {
3435 "drbd: never change the size or layout "
3436 "of the HandShake packet.\n");
3440 if (1 > minor_count
|| minor_count
> 255) {
3442 "drbd: invalid minor_count (%d)\n", minor_count
);
3450 err
= drbd_nl_init();
3454 err
= register_blkdev(DRBD_MAJOR
, "drbd");
3457 "drbd: unable to register block device major %d\n",
3462 register_reboot_notifier(&drbd_notifier
);
3465 * allocate all necessary structs
3469 init_waitqueue_head(&drbd_pp_wait
);
3471 drbd_proc
= NULL
; /* play safe for drbd_cleanup */
3472 minor_table
= kzalloc(sizeof(struct drbd_conf
*)*minor_count
,
3477 err
= drbd_create_mempools();
3481 drbd_proc
= proc_create_data("drbd", S_IFREG
| S_IRUGO
, NULL
, &drbd_proc_fops
, NULL
);
3483 printk(KERN_ERR
"drbd: unable to register proc file\n");
3487 rwlock_init(&global_state_lock
);
3489 printk(KERN_INFO
"drbd: initialized. "
3490 "Version: " REL_VERSION
" (api:%d/proto:%d-%d)\n",
3491 API_VERSION
, PRO_VERSION_MIN
, PRO_VERSION_MAX
);
3492 printk(KERN_INFO
"drbd: %s\n", drbd_buildtag());
3493 printk(KERN_INFO
"drbd: registered as block device major %d\n",
3495 printk(KERN_INFO
"drbd: minor_table @ 0x%p\n", minor_table
);
3497 return 0; /* Success! */
3502 /* currently always the case */
3503 printk(KERN_ERR
"drbd: ran out of memory\n");
3505 printk(KERN_ERR
"drbd: initialization failure\n");
3509 void drbd_free_bc(struct drbd_backing_dev
*ldev
)
3514 blkdev_put(ldev
->backing_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
3515 blkdev_put(ldev
->md_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
3520 void drbd_free_sock(struct drbd_conf
*mdev
)
3522 if (mdev
->data
.socket
) {
3523 mutex_lock(&mdev
->data
.mutex
);
3524 kernel_sock_shutdown(mdev
->data
.socket
, SHUT_RDWR
);
3525 sock_release(mdev
->data
.socket
);
3526 mdev
->data
.socket
= NULL
;
3527 mutex_unlock(&mdev
->data
.mutex
);
3529 if (mdev
->meta
.socket
) {
3530 mutex_lock(&mdev
->meta
.mutex
);
3531 kernel_sock_shutdown(mdev
->meta
.socket
, SHUT_RDWR
);
3532 sock_release(mdev
->meta
.socket
);
3533 mdev
->meta
.socket
= NULL
;
3534 mutex_unlock(&mdev
->meta
.mutex
);
3539 void drbd_free_resources(struct drbd_conf
*mdev
)
3541 crypto_free_hash(mdev
->csums_tfm
);
3542 mdev
->csums_tfm
= NULL
;
3543 crypto_free_hash(mdev
->verify_tfm
);
3544 mdev
->verify_tfm
= NULL
;
3545 crypto_free_hash(mdev
->cram_hmac_tfm
);
3546 mdev
->cram_hmac_tfm
= NULL
;
3547 crypto_free_hash(mdev
->integrity_w_tfm
);
3548 mdev
->integrity_w_tfm
= NULL
;
3549 crypto_free_hash(mdev
->integrity_r_tfm
);
3550 mdev
->integrity_r_tfm
= NULL
;
3552 drbd_free_sock(mdev
);
3555 drbd_free_bc(mdev
->ldev
);
3556 mdev
->ldev
= NULL
;);
3559 /* meta data management */
3561 struct meta_data_on_disk
{
3562 u64 la_size
; /* last agreed size. */
3563 u64 uuid
[UI_SIZE
]; /* UUIDs. */
3566 u32 flags
; /* MDF */
3569 u32 al_offset
; /* offset to this block */
3570 u32 al_nr_extents
; /* important for restoring the AL */
3571 /* `-- act_log->nr_elements <-- sync_conf.al_extents */
3572 u32 bm_offset
; /* offset to the bitmap, from here */
3573 u32 bm_bytes_per_bit
; /* BM_BLOCK_SIZE */
3574 u32 reserved_u32
[4];
3579 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
3580 * @mdev: DRBD device.
3582 void drbd_md_sync(struct drbd_conf
*mdev
)
3584 struct meta_data_on_disk
*buffer
;
3588 del_timer(&mdev
->md_sync_timer
);
3589 /* timer may be rearmed by drbd_md_mark_dirty() now. */
3590 if (!test_and_clear_bit(MD_DIRTY
, &mdev
->flags
))
3593 /* We use here D_FAILED and not D_ATTACHING because we try to write
3594 * metadata even if we detach due to a disk failure! */
3595 if (!get_ldev_if_state(mdev
, D_FAILED
))
3598 mutex_lock(&mdev
->md_io_mutex
);
3599 buffer
= (struct meta_data_on_disk
*)page_address(mdev
->md_io_page
);
3600 memset(buffer
, 0, 512);
3602 buffer
->la_size
= cpu_to_be64(drbd_get_capacity(mdev
->this_bdev
));
3603 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
3604 buffer
->uuid
[i
] = cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]);
3605 buffer
->flags
= cpu_to_be32(mdev
->ldev
->md
.flags
);
3606 buffer
->magic
= cpu_to_be32(DRBD_MD_MAGIC
);
3608 buffer
->md_size_sect
= cpu_to_be32(mdev
->ldev
->md
.md_size_sect
);
3609 buffer
->al_offset
= cpu_to_be32(mdev
->ldev
->md
.al_offset
);
3610 buffer
->al_nr_extents
= cpu_to_be32(mdev
->act_log
->nr_elements
);
3611 buffer
->bm_bytes_per_bit
= cpu_to_be32(BM_BLOCK_SIZE
);
3612 buffer
->device_uuid
= cpu_to_be64(mdev
->ldev
->md
.device_uuid
);
3614 buffer
->bm_offset
= cpu_to_be32(mdev
->ldev
->md
.bm_offset
);
3616 D_ASSERT(drbd_md_ss__(mdev
, mdev
->ldev
) == mdev
->ldev
->md
.md_offset
);
3617 sector
= mdev
->ldev
->md
.md_offset
;
3619 if (!drbd_md_sync_page_io(mdev
, mdev
->ldev
, sector
, WRITE
)) {
3620 /* this was a try anyways ... */
3621 dev_err(DEV
, "meta data update failed!\n");
3622 drbd_chk_io_error(mdev
, 1, true);
3625 /* Update mdev->ldev->md.la_size_sect,
3626 * since we updated it on metadata. */
3627 mdev
->ldev
->md
.la_size_sect
= drbd_get_capacity(mdev
->this_bdev
);
3629 mutex_unlock(&mdev
->md_io_mutex
);
3634 * drbd_md_read() - Reads in the meta data super block
3635 * @mdev: DRBD device.
3636 * @bdev: Device from which the meta data should be read in.
3638 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
3639 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
3641 int drbd_md_read(struct drbd_conf
*mdev
, struct drbd_backing_dev
*bdev
)
3643 struct meta_data_on_disk
*buffer
;
3644 int i
, rv
= NO_ERROR
;
3646 if (!get_ldev_if_state(mdev
, D_ATTACHING
))
3647 return ERR_IO_MD_DISK
;
3649 mutex_lock(&mdev
->md_io_mutex
);
3650 buffer
= (struct meta_data_on_disk
*)page_address(mdev
->md_io_page
);
3652 if (!drbd_md_sync_page_io(mdev
, bdev
, bdev
->md
.md_offset
, READ
)) {
3653 /* NOTE: cant do normal error processing here as this is
3654 called BEFORE disk is attached */
3655 dev_err(DEV
, "Error while reading metadata.\n");
3656 rv
= ERR_IO_MD_DISK
;
3660 if (be32_to_cpu(buffer
->magic
) != DRBD_MD_MAGIC
) {
3661 dev_err(DEV
, "Error while reading metadata, magic not found.\n");
3662 rv
= ERR_MD_INVALID
;
3665 if (be32_to_cpu(buffer
->al_offset
) != bdev
->md
.al_offset
) {
3666 dev_err(DEV
, "unexpected al_offset: %d (expected %d)\n",
3667 be32_to_cpu(buffer
->al_offset
), bdev
->md
.al_offset
);
3668 rv
= ERR_MD_INVALID
;
3671 if (be32_to_cpu(buffer
->bm_offset
) != bdev
->md
.bm_offset
) {
3672 dev_err(DEV
, "unexpected bm_offset: %d (expected %d)\n",
3673 be32_to_cpu(buffer
->bm_offset
), bdev
->md
.bm_offset
);
3674 rv
= ERR_MD_INVALID
;
3677 if (be32_to_cpu(buffer
->md_size_sect
) != bdev
->md
.md_size_sect
) {
3678 dev_err(DEV
, "unexpected md_size: %u (expected %u)\n",
3679 be32_to_cpu(buffer
->md_size_sect
), bdev
->md
.md_size_sect
);
3680 rv
= ERR_MD_INVALID
;
3684 if (be32_to_cpu(buffer
->bm_bytes_per_bit
) != BM_BLOCK_SIZE
) {
3685 dev_err(DEV
, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3686 be32_to_cpu(buffer
->bm_bytes_per_bit
), BM_BLOCK_SIZE
);
3687 rv
= ERR_MD_INVALID
;
3691 bdev
->md
.la_size_sect
= be64_to_cpu(buffer
->la_size
);
3692 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
3693 bdev
->md
.uuid
[i
] = be64_to_cpu(buffer
->uuid
[i
]);
3694 bdev
->md
.flags
= be32_to_cpu(buffer
->flags
);
3695 mdev
->sync_conf
.al_extents
= be32_to_cpu(buffer
->al_nr_extents
);
3696 bdev
->md
.device_uuid
= be64_to_cpu(buffer
->device_uuid
);
3698 if (mdev
->sync_conf
.al_extents
< 7)
3699 mdev
->sync_conf
.al_extents
= 127;
3702 mutex_unlock(&mdev
->md_io_mutex
);
3708 static void debug_drbd_uuid(struct drbd_conf
*mdev
, enum drbd_uuid_index index
)
3710 static char *uuid_str
[UI_EXTENDED_SIZE
] = {
3711 [UI_CURRENT
] = "CURRENT",
3712 [UI_BITMAP
] = "BITMAP",
3713 [UI_HISTORY_START
] = "HISTORY_START",
3714 [UI_HISTORY_END
] = "HISTORY_END",
3716 [UI_FLAGS
] = "FLAGS",
3719 if (index
>= UI_EXTENDED_SIZE
) {
3720 dev_warn(DEV
, " uuid_index >= EXTENDED_SIZE\n");
3724 dynamic_dev_dbg(DEV
, " uuid[%s] now %016llX\n",
3726 (unsigned long long)mdev
->ldev
->md
.uuid
[index
]);
3731 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3732 * @mdev: DRBD device.
3734 * Call this function if you change anything that should be written to
3735 * the meta-data super block. This function sets MD_DIRTY, and starts a
3736 * timer that ensures that within five seconds you have to call drbd_md_sync().
3739 void drbd_md_mark_dirty_(struct drbd_conf
*mdev
, unsigned int line
, const char *func
)
3741 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
)) {
3742 mod_timer(&mdev
->md_sync_timer
, jiffies
+ HZ
);
3743 mdev
->last_md_mark_dirty
.line
= line
;
3744 mdev
->last_md_mark_dirty
.func
= func
;
3748 void drbd_md_mark_dirty(struct drbd_conf
*mdev
)
3750 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
))
3751 mod_timer(&mdev
->md_sync_timer
, jiffies
+ 5*HZ
);
3755 static void drbd_uuid_move_history(struct drbd_conf
*mdev
) __must_hold(local
)
3759 for (i
= UI_HISTORY_START
; i
< UI_HISTORY_END
; i
++) {
3760 mdev
->ldev
->md
.uuid
[i
+1] = mdev
->ldev
->md
.uuid
[i
];
3761 debug_drbd_uuid(mdev
, i
+1);
3765 void _drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3767 if (idx
== UI_CURRENT
) {
3768 if (mdev
->state
.role
== R_PRIMARY
)
3773 drbd_set_ed_uuid(mdev
, val
);
3776 mdev
->ldev
->md
.uuid
[idx
] = val
;
3777 debug_drbd_uuid(mdev
, idx
);
3778 drbd_md_mark_dirty(mdev
);
3782 void drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3784 if (mdev
->ldev
->md
.uuid
[idx
]) {
3785 drbd_uuid_move_history(mdev
);
3786 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[idx
];
3787 debug_drbd_uuid(mdev
, UI_HISTORY_START
);
3789 _drbd_uuid_set(mdev
, idx
, val
);
3793 * drbd_uuid_new_current() - Creates a new current UUID
3794 * @mdev: DRBD device.
3796 * Creates a new current UUID, and rotates the old current UUID into
3797 * the bitmap slot. Causes an incremental resync upon next connect.
3799 void drbd_uuid_new_current(struct drbd_conf
*mdev
) __must_hold(local
)
3803 dev_info(DEV
, "Creating new current UUID\n");
3804 D_ASSERT(mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0);
3805 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = mdev
->ldev
->md
.uuid
[UI_CURRENT
];
3806 debug_drbd_uuid(mdev
, UI_BITMAP
);
3808 get_random_bytes(&val
, sizeof(u64
));
3809 _drbd_uuid_set(mdev
, UI_CURRENT
, val
);
3810 /* get it to stable storage _now_ */
3814 void drbd_uuid_set_bm(struct drbd_conf
*mdev
, u64 val
) __must_hold(local
)
3816 if (mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && val
== 0)
3820 drbd_uuid_move_history(mdev
);
3821 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3822 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = 0;
3823 debug_drbd_uuid(mdev
, UI_HISTORY_START
);
3824 debug_drbd_uuid(mdev
, UI_BITMAP
);
3826 if (mdev
->ldev
->md
.uuid
[UI_BITMAP
])
3827 dev_warn(DEV
, "bm UUID already set");
3829 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = val
;
3830 mdev
->ldev
->md
.uuid
[UI_BITMAP
] &= ~((u64
)1);
3832 debug_drbd_uuid(mdev
, UI_BITMAP
);
3834 drbd_md_mark_dirty(mdev
);
3838 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3839 * @mdev: DRBD device.
3841 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3843 int drbd_bmio_set_n_write(struct drbd_conf
*mdev
)
3847 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
3848 drbd_md_set_flag(mdev
, MDF_FULL_SYNC
);
3850 drbd_bm_set_all(mdev
);
3852 rv
= drbd_bm_write(mdev
);
3855 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
3866 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3867 * @mdev: DRBD device.
3869 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3871 int drbd_bmio_clear_n_write(struct drbd_conf
*mdev
)
3875 drbd_resume_al(mdev
);
3876 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
3877 drbd_bm_clear_all(mdev
);
3878 rv
= drbd_bm_write(mdev
);
3885 static int w_bitmap_io(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
3887 struct bm_io_work
*work
= container_of(w
, struct bm_io_work
, w
);
3890 D_ASSERT(atomic_read(&mdev
->ap_bio_cnt
) == 0);
3892 if (get_ldev(mdev
)) {
3893 drbd_bm_lock(mdev
, work
->why
);
3894 rv
= work
->io_fn(mdev
);
3895 drbd_bm_unlock(mdev
);
3899 clear_bit(BITMAP_IO
, &mdev
->flags
);
3900 smp_mb__after_clear_bit();
3901 wake_up(&mdev
->misc_wait
);
3904 work
->done(mdev
, rv
);
3906 clear_bit(BITMAP_IO_QUEUED
, &mdev
->flags
);
3912 void drbd_ldev_destroy(struct drbd_conf
*mdev
)
3914 lc_destroy(mdev
->resync
);
3915 mdev
->resync
= NULL
;
3916 lc_destroy(mdev
->act_log
);
3917 mdev
->act_log
= NULL
;
3919 drbd_free_bc(mdev
->ldev
);
3920 mdev
->ldev
= NULL
;);
3922 if (mdev
->md_io_tmpp
) {
3923 __free_page(mdev
->md_io_tmpp
);
3924 mdev
->md_io_tmpp
= NULL
;
3926 clear_bit(GO_DISKLESS
, &mdev
->flags
);
3929 static int w_go_diskless(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
3931 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
3932 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
3933 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
3934 * the protected members anymore, though, so once put_ldev reaches zero
3935 * again, it will be safe to free them. */
3936 drbd_force_state(mdev
, NS(disk
, D_DISKLESS
));
3940 void drbd_go_diskless(struct drbd_conf
*mdev
)
3942 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
3943 if (!test_and_set_bit(GO_DISKLESS
, &mdev
->flags
))
3944 drbd_queue_work(&mdev
->data
.work
, &mdev
->go_diskless
);
3948 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3949 * @mdev: DRBD device.
3950 * @io_fn: IO callback to be called when bitmap IO is possible
3951 * @done: callback to be called after the bitmap IO was performed
3952 * @why: Descriptive text of the reason for doing the IO
3954 * While IO on the bitmap happens we freeze application IO thus we ensure
3955 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3956 * called from worker context. It MUST NOT be used while a previous such
3957 * work is still pending!
3959 void drbd_queue_bitmap_io(struct drbd_conf
*mdev
,
3960 int (*io_fn
)(struct drbd_conf
*),
3961 void (*done
)(struct drbd_conf
*, int),
3964 D_ASSERT(current
== mdev
->worker
.task
);
3966 D_ASSERT(!test_bit(BITMAP_IO_QUEUED
, &mdev
->flags
));
3967 D_ASSERT(!test_bit(BITMAP_IO
, &mdev
->flags
));
3968 D_ASSERT(list_empty(&mdev
->bm_io_work
.w
.list
));
3969 if (mdev
->bm_io_work
.why
)
3970 dev_err(DEV
, "FIXME going to queue '%s' but '%s' still pending?\n",
3971 why
, mdev
->bm_io_work
.why
);
3973 mdev
->bm_io_work
.io_fn
= io_fn
;
3974 mdev
->bm_io_work
.done
= done
;
3975 mdev
->bm_io_work
.why
= why
;
3977 spin_lock_irq(&mdev
->req_lock
);
3978 set_bit(BITMAP_IO
, &mdev
->flags
);
3979 if (atomic_read(&mdev
->ap_bio_cnt
) == 0) {
3980 if (!test_and_set_bit(BITMAP_IO_QUEUED
, &mdev
->flags
))
3981 drbd_queue_work(&mdev
->data
.work
, &mdev
->bm_io_work
.w
);
3983 spin_unlock_irq(&mdev
->req_lock
);
3987 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3988 * @mdev: DRBD device.
3989 * @io_fn: IO callback to be called when bitmap IO is possible
3990 * @why: Descriptive text of the reason for doing the IO
3992 * freezes application IO while that the actual IO operations runs. This
3993 * functions MAY NOT be called from worker context.
3995 int drbd_bitmap_io(struct drbd_conf
*mdev
, int (*io_fn
)(struct drbd_conf
*), char *why
)
3999 D_ASSERT(current
!= mdev
->worker
.task
);
4001 drbd_suspend_io(mdev
);
4003 drbd_bm_lock(mdev
, why
);
4005 drbd_bm_unlock(mdev
);
4007 drbd_resume_io(mdev
);
4012 void drbd_md_set_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
4014 if ((mdev
->ldev
->md
.flags
& flag
) != flag
) {
4015 drbd_md_mark_dirty(mdev
);
4016 mdev
->ldev
->md
.flags
|= flag
;
4020 void drbd_md_clear_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
4022 if ((mdev
->ldev
->md
.flags
& flag
) != 0) {
4023 drbd_md_mark_dirty(mdev
);
4024 mdev
->ldev
->md
.flags
&= ~flag
;
4027 int drbd_md_test_flag(struct drbd_backing_dev
*bdev
, int flag
)
4029 return (bdev
->md
.flags
& flag
) != 0;
4032 static void md_sync_timer_fn(unsigned long data
)
4034 struct drbd_conf
*mdev
= (struct drbd_conf
*) data
;
4036 drbd_queue_work_front(&mdev
->data
.work
, &mdev
->md_sync_work
);
4039 static int w_md_sync(struct drbd_conf
*mdev
, struct drbd_work
*w
, int unused
)
4041 dev_warn(DEV
, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
4043 dev_warn(DEV
, "last md_mark_dirty: %s:%u\n",
4044 mdev
->last_md_mark_dirty
.func
, mdev
->last_md_mark_dirty
.line
);
4050 #ifdef CONFIG_DRBD_FAULT_INJECTION
4051 /* Fault insertion support including random number generator shamelessly
4052 * stolen from kernel/rcutorture.c */
4053 struct fault_random_state
{
4054 unsigned long state
;
4055 unsigned long count
;
4058 #define FAULT_RANDOM_MULT 39916801 /* prime */
4059 #define FAULT_RANDOM_ADD 479001701 /* prime */
4060 #define FAULT_RANDOM_REFRESH 10000
4063 * Crude but fast random-number generator. Uses a linear congruential
4064 * generator, with occasional help from get_random_bytes().
4066 static unsigned long
4067 _drbd_fault_random(struct fault_random_state
*rsp
)
4071 if (!rsp
->count
--) {
4072 get_random_bytes(&refresh
, sizeof(refresh
));
4073 rsp
->state
+= refresh
;
4074 rsp
->count
= FAULT_RANDOM_REFRESH
;
4076 rsp
->state
= rsp
->state
* FAULT_RANDOM_MULT
+ FAULT_RANDOM_ADD
;
4077 return swahw32(rsp
->state
);
4081 _drbd_fault_str(unsigned int type
) {
4082 static char *_faults
[] = {
4083 [DRBD_FAULT_MD_WR
] = "Meta-data write",
4084 [DRBD_FAULT_MD_RD
] = "Meta-data read",
4085 [DRBD_FAULT_RS_WR
] = "Resync write",
4086 [DRBD_FAULT_RS_RD
] = "Resync read",
4087 [DRBD_FAULT_DT_WR
] = "Data write",
4088 [DRBD_FAULT_DT_RD
] = "Data read",
4089 [DRBD_FAULT_DT_RA
] = "Data read ahead",
4090 [DRBD_FAULT_BM_ALLOC
] = "BM allocation",
4091 [DRBD_FAULT_AL_EE
] = "EE allocation",
4092 [DRBD_FAULT_RECEIVE
] = "receive data corruption",
4095 return (type
< DRBD_FAULT_MAX
) ? _faults
[type
] : "**Unknown**";
4099 _drbd_insert_fault(struct drbd_conf
*mdev
, unsigned int type
)
4101 static struct fault_random_state rrs
= {0, 0};
4103 unsigned int ret
= (
4105 ((1 << mdev_to_minor(mdev
)) & fault_devs
) != 0) &&
4106 (((_drbd_fault_random(&rrs
) % 100) + 1) <= fault_rate
));
4111 if (__ratelimit(&drbd_ratelimit_state
))
4112 dev_warn(DEV
, "***Simulating %s failure\n",
4113 _drbd_fault_str(type
));
4120 const char *drbd_buildtag(void)
4122 /* DRBD built from external sources has here a reference to the
4123 git hash of the source code. */
4125 static char buildtag
[38] = "\0uilt-in";
4127 if (buildtag
[0] == 0) {
4128 #ifdef CONFIG_MODULES
4129 if (THIS_MODULE
!= NULL
)
4130 sprintf(buildtag
, "srcversion: %-24s", THIS_MODULE
->srcversion
);
4139 module_init(drbd_init
)
4140 module_exit(drbd_cleanup
)
4142 EXPORT_SYMBOL(drbd_conn_str
);
4143 EXPORT_SYMBOL(drbd_role_str
);
4144 EXPORT_SYMBOL(drbd_disk_str
);
4145 EXPORT_SYMBOL(drbd_set_st_err_str
);