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 static DEFINE_MUTEX(drbd_main_mutex
);
60 int drbdd_init(struct drbd_thread
*);
61 int drbd_worker(struct drbd_thread
*);
62 int drbd_asender(struct drbd_thread
*);
65 static int drbd_open(struct block_device
*bdev
, fmode_t mode
);
66 static int drbd_release(struct gendisk
*gd
, fmode_t mode
);
67 static int w_md_sync(struct drbd_work
*w
, int unused
);
68 static void md_sync_timer_fn(unsigned long data
);
69 static int w_bitmap_io(struct drbd_work
*w
, int unused
);
70 static int w_go_diskless(struct drbd_work
*w
, int unused
);
72 MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
73 "Lars Ellenberg <lars@linbit.com>");
74 MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION
);
75 MODULE_VERSION(REL_VERSION
);
76 MODULE_LICENSE("GPL");
77 MODULE_PARM_DESC(minor_count
, "Approximate number of drbd devices ("
78 __stringify(DRBD_MINOR_COUNT_MIN
) "-" __stringify(DRBD_MINOR_COUNT_MAX
) ")");
79 MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR
);
81 #include <linux/moduleparam.h>
82 /* allow_open_on_secondary */
83 MODULE_PARM_DESC(allow_oos
, "DONT USE!");
84 /* thanks to these macros, if compiled into the kernel (not-module),
85 * this becomes the boot parameter drbd.minor_count */
86 module_param(minor_count
, uint
, 0444);
87 module_param(disable_sendpage
, bool, 0644);
88 module_param(allow_oos
, bool, 0);
89 module_param(proc_details
, int, 0644);
91 #ifdef CONFIG_DRBD_FAULT_INJECTION
94 static int fault_count
;
96 /* bitmap of enabled faults */
97 module_param(enable_faults
, int, 0664);
98 /* fault rate % value - applies to all enabled faults */
99 module_param(fault_rate
, int, 0664);
100 /* count of faults inserted */
101 module_param(fault_count
, int, 0664);
102 /* bitmap of devices to insert faults on */
103 module_param(fault_devs
, int, 0644);
106 /* module parameter, defined */
107 unsigned int minor_count
= DRBD_MINOR_COUNT_DEF
;
108 int disable_sendpage
;
110 int proc_details
; /* Detail level in proc drbd*/
112 /* Module parameter for setting the user mode helper program
113 * to run. Default is /sbin/drbdadm */
114 char usermode_helper
[80] = "/sbin/drbdadm";
116 module_param_string(usermode_helper
, usermode_helper
, sizeof(usermode_helper
), 0644);
118 /* in 2.6.x, our device mapping and config info contains our virtual gendisks
119 * as member "struct gendisk *vdisk;"
122 struct list_head drbd_tconns
; /* list of struct drbd_tconn */
124 struct kmem_cache
*drbd_request_cache
;
125 struct kmem_cache
*drbd_ee_cache
; /* peer requests */
126 struct kmem_cache
*drbd_bm_ext_cache
; /* bitmap extents */
127 struct kmem_cache
*drbd_al_ext_cache
; /* activity log extents */
128 mempool_t
*drbd_request_mempool
;
129 mempool_t
*drbd_ee_mempool
;
130 mempool_t
*drbd_md_io_page_pool
;
131 struct bio_set
*drbd_md_io_bio_set
;
133 /* I do not use a standard mempool, because:
134 1) I want to hand out the pre-allocated objects first.
135 2) I want to be able to interrupt sleeping allocation with a signal.
136 Note: This is a single linked list, the next pointer is the private
137 member of struct page.
139 struct page
*drbd_pp_pool
;
140 spinlock_t drbd_pp_lock
;
142 wait_queue_head_t drbd_pp_wait
;
144 DEFINE_RATELIMIT_STATE(drbd_ratelimit_state
, 5 * HZ
, 5);
146 static const struct block_device_operations drbd_ops
= {
147 .owner
= THIS_MODULE
,
149 .release
= drbd_release
,
152 static void bio_destructor_drbd(struct bio
*bio
)
154 bio_free(bio
, drbd_md_io_bio_set
);
157 struct bio
*bio_alloc_drbd(gfp_t gfp_mask
)
161 if (!drbd_md_io_bio_set
)
162 return bio_alloc(gfp_mask
, 1);
164 bio
= bio_alloc_bioset(gfp_mask
, 1, drbd_md_io_bio_set
);
167 bio
->bi_destructor
= bio_destructor_drbd
;
172 /* When checking with sparse, and this is an inline function, sparse will
173 give tons of false positives. When this is a real functions sparse works.
175 int _get_ldev_if_state(struct drbd_conf
*mdev
, enum drbd_disk_state mins
)
179 atomic_inc(&mdev
->local_cnt
);
180 io_allowed
= (mdev
->state
.disk
>= mins
);
182 if (atomic_dec_and_test(&mdev
->local_cnt
))
183 wake_up(&mdev
->misc_wait
);
191 * DOC: The transfer log
193 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
194 * mdev->tconn->newest_tle points to the head, mdev->tconn->oldest_tle points to the tail
195 * of the list. There is always at least one &struct drbd_tl_epoch object.
197 * Each &struct drbd_tl_epoch has a circular double linked list of requests
200 static int tl_init(struct drbd_tconn
*tconn
)
202 struct drbd_tl_epoch
*b
;
204 /* during device minor initialization, we may well use GFP_KERNEL */
205 b
= kmalloc(sizeof(struct drbd_tl_epoch
), GFP_KERNEL
);
208 INIT_LIST_HEAD(&b
->requests
);
209 INIT_LIST_HEAD(&b
->w
.list
);
213 b
->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
215 tconn
->oldest_tle
= b
;
216 tconn
->newest_tle
= b
;
217 INIT_LIST_HEAD(&tconn
->out_of_sequence_requests
);
218 INIT_LIST_HEAD(&tconn
->barrier_acked_requests
);
223 static void tl_cleanup(struct drbd_tconn
*tconn
)
225 if (tconn
->oldest_tle
!= tconn
->newest_tle
)
226 conn_err(tconn
, "ASSERT FAILED: oldest_tle == newest_tle\n");
227 if (!list_empty(&tconn
->out_of_sequence_requests
))
228 conn_err(tconn
, "ASSERT FAILED: list_empty(out_of_sequence_requests)\n");
229 kfree(tconn
->oldest_tle
);
230 tconn
->oldest_tle
= NULL
;
231 kfree(tconn
->unused_spare_tle
);
232 tconn
->unused_spare_tle
= NULL
;
236 * _tl_add_barrier() - Adds a barrier to the transfer log
237 * @mdev: DRBD device.
238 * @new: Barrier to be added before the current head of the TL.
240 * The caller must hold the req_lock.
242 void _tl_add_barrier(struct drbd_tconn
*tconn
, struct drbd_tl_epoch
*new)
244 struct drbd_tl_epoch
*newest_before
;
246 INIT_LIST_HEAD(&new->requests
);
247 INIT_LIST_HEAD(&new->w
.list
);
248 new->w
.cb
= NULL
; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
252 newest_before
= tconn
->newest_tle
;
253 /* never send a barrier number == 0, because that is special-cased
254 * when using TCQ for our write ordering code */
255 new->br_number
= (newest_before
->br_number
+1) ?: 1;
256 if (tconn
->newest_tle
!= new) {
257 tconn
->newest_tle
->next
= new;
258 tconn
->newest_tle
= new;
263 * tl_release() - Free or recycle the oldest &struct drbd_tl_epoch object of the TL
264 * @mdev: DRBD device.
265 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
266 * @set_size: Expected number of requests before that barrier.
268 * In case the passed barrier_nr or set_size does not match the oldest
269 * &struct drbd_tl_epoch objects this function will cause a termination
272 void tl_release(struct drbd_tconn
*tconn
, unsigned int barrier_nr
,
273 unsigned int set_size
)
275 struct drbd_conf
*mdev
;
276 struct drbd_tl_epoch
*b
, *nob
; /* next old barrier */
277 struct list_head
*le
, *tle
;
278 struct drbd_request
*r
;
280 spin_lock_irq(&tconn
->req_lock
);
282 b
= tconn
->oldest_tle
;
284 /* first some paranoia code */
286 conn_err(tconn
, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
290 if (b
->br_number
!= barrier_nr
) {
291 conn_err(tconn
, "BAD! BarrierAck #%u received, expected #%u!\n",
292 barrier_nr
, b
->br_number
);
295 if (b
->n_writes
!= set_size
) {
296 conn_err(tconn
, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
297 barrier_nr
, set_size
, b
->n_writes
);
301 /* Clean up list of requests processed during current epoch */
302 list_for_each_safe(le
, tle
, &b
->requests
) {
303 r
= list_entry(le
, struct drbd_request
, tl_requests
);
304 _req_mod(r
, BARRIER_ACKED
);
306 /* There could be requests on the list waiting for completion
307 of the write to the local disk. To avoid corruptions of
308 slab's data structures we have to remove the lists head.
310 Also there could have been a barrier ack out of sequence, overtaking
311 the write acks - which would be a bug and violating write ordering.
312 To not deadlock in case we lose connection while such requests are
313 still pending, we need some way to find them for the
314 _req_mode(CONNECTION_LOST_WHILE_PENDING).
316 These have been list_move'd to the out_of_sequence_requests list in
317 _req_mod(, BARRIER_ACKED) above.
319 list_splice_init(&b
->requests
, &tconn
->barrier_acked_requests
);
323 if (test_and_clear_bit(CREATE_BARRIER
, &tconn
->flags
)) {
324 _tl_add_barrier(tconn
, b
);
326 tconn
->oldest_tle
= nob
;
327 /* if nob == NULL b was the only barrier, and becomes the new
328 barrier. Therefore tconn->oldest_tle points already to b */
330 D_ASSERT(nob
!= NULL
);
331 tconn
->oldest_tle
= nob
;
335 spin_unlock_irq(&tconn
->req_lock
);
336 dec_ap_pending(mdev
);
341 spin_unlock_irq(&tconn
->req_lock
);
342 conn_request_state(tconn
, NS(conn
, C_PROTOCOL_ERROR
), CS_HARD
);
347 * _tl_restart() - Walks the transfer log, and applies an action to all requests
348 * @mdev: DRBD device.
349 * @what: The action/event to perform with all request objects
351 * @what might be one of CONNECTION_LOST_WHILE_PENDING, RESEND, FAIL_FROZEN_DISK_IO,
352 * RESTART_FROZEN_DISK_IO.
354 void _tl_restart(struct drbd_tconn
*tconn
, enum drbd_req_event what
)
356 struct drbd_tl_epoch
*b
, *tmp
, **pn
;
357 struct list_head
*le
, *tle
, carry_reads
;
358 struct drbd_request
*req
;
359 int rv
, n_writes
, n_reads
;
361 b
= tconn
->oldest_tle
;
362 pn
= &tconn
->oldest_tle
;
366 INIT_LIST_HEAD(&carry_reads
);
367 list_for_each_safe(le
, tle
, &b
->requests
) {
368 req
= list_entry(le
, struct drbd_request
, tl_requests
);
369 rv
= _req_mod(req
, what
);
379 if (what
== RESEND
) {
380 b
->n_writes
= n_writes
;
381 if (b
->w
.cb
== NULL
) {
382 b
->w
.cb
= w_send_barrier
;
383 inc_ap_pending(b
->w
.mdev
);
384 set_bit(CREATE_BARRIER
, &tconn
->flags
);
387 drbd_queue_work(&tconn
->data
.work
, &b
->w
);
392 list_add(&carry_reads
, &b
->requests
);
393 /* there could still be requests on that ring list,
394 * in case local io is still pending */
395 list_del(&b
->requests
);
397 /* dec_ap_pending corresponding to queue_barrier.
398 * the newest barrier may not have been queued yet,
399 * in which case w.cb is still NULL. */
401 dec_ap_pending(b
->w
.mdev
);
403 if (b
== tconn
->newest_tle
) {
404 /* recycle, but reinit! */
406 conn_err(tconn
, "ASSERT FAILED tmp == NULL");
407 INIT_LIST_HEAD(&b
->requests
);
408 list_splice(&carry_reads
, &b
->requests
);
409 INIT_LIST_HEAD(&b
->w
.list
);
411 b
->br_number
= net_random();
421 list_splice(&carry_reads
, &b
->requests
);
424 /* Actions operating on the disk state, also want to work on
425 requests that got barrier acked. */
427 case FAIL_FROZEN_DISK_IO
:
428 case RESTART_FROZEN_DISK_IO
:
429 list_for_each_safe(le
, tle
, &tconn
->barrier_acked_requests
) {
430 req
= list_entry(le
, struct drbd_request
, tl_requests
);
433 case CONNECTION_LOST_WHILE_PENDING
:
437 conn_err(tconn
, "what = %d in _tl_restart()\n", what
);
442 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
443 * @mdev: DRBD device.
445 * This is called after the connection to the peer was lost. The storage covered
446 * by the requests on the transfer gets marked as our of sync. Called from the
447 * receiver thread and the worker thread.
449 void tl_clear(struct drbd_tconn
*tconn
)
451 struct list_head
*le
, *tle
;
452 struct drbd_request
*r
;
454 spin_lock_irq(&tconn
->req_lock
);
456 _tl_restart(tconn
, CONNECTION_LOST_WHILE_PENDING
);
458 /* we expect this list to be empty. */
459 if (!list_empty(&tconn
->out_of_sequence_requests
))
460 conn_err(tconn
, "ASSERT FAILED list_empty(&out_of_sequence_requests)\n");
462 /* but just in case, clean it up anyways! */
463 list_for_each_safe(le
, tle
, &tconn
->out_of_sequence_requests
) {
464 r
= list_entry(le
, struct drbd_request
, tl_requests
);
465 /* It would be nice to complete outside of spinlock.
466 * But this is easier for now. */
467 _req_mod(r
, CONNECTION_LOST_WHILE_PENDING
);
470 /* ensure bit indicating barrier is required is clear */
471 clear_bit(CREATE_BARRIER
, &tconn
->flags
);
473 spin_unlock_irq(&tconn
->req_lock
);
476 void tl_restart(struct drbd_tconn
*tconn
, enum drbd_req_event what
)
478 spin_lock_irq(&tconn
->req_lock
);
479 _tl_restart(tconn
, what
);
480 spin_unlock_irq(&tconn
->req_lock
);
484 * tl_abort_disk_io() - Abort disk I/O for all requests for a certain mdev in the TL
485 * @mdev: DRBD device.
487 void tl_abort_disk_io(struct drbd_conf
*mdev
)
489 struct drbd_tconn
*tconn
= mdev
->tconn
;
490 struct drbd_tl_epoch
*b
;
491 struct list_head
*le
, *tle
;
492 struct drbd_request
*req
;
494 spin_lock_irq(&tconn
->req_lock
);
495 b
= tconn
->oldest_tle
;
497 list_for_each_safe(le
, tle
, &b
->requests
) {
498 req
= list_entry(le
, struct drbd_request
, tl_requests
);
499 if (!(req
->rq_state
& RQ_LOCAL_PENDING
))
501 if (req
->w
.mdev
== mdev
)
502 _req_mod(req
, ABORT_DISK_IO
);
507 list_for_each_safe(le
, tle
, &tconn
->barrier_acked_requests
) {
508 req
= list_entry(le
, struct drbd_request
, tl_requests
);
509 if (!(req
->rq_state
& RQ_LOCAL_PENDING
))
511 if (req
->w
.mdev
== mdev
)
512 _req_mod(req
, ABORT_DISK_IO
);
515 spin_unlock_irq(&tconn
->req_lock
);
518 static int drbd_thread_setup(void *arg
)
520 struct drbd_thread
*thi
= (struct drbd_thread
*) arg
;
521 struct drbd_tconn
*tconn
= thi
->tconn
;
525 snprintf(current
->comm
, sizeof(current
->comm
), "drbd_%c_%s",
526 thi
->name
[0], thi
->tconn
->name
);
529 retval
= thi
->function(thi
);
531 spin_lock_irqsave(&thi
->t_lock
, flags
);
533 /* if the receiver has been "EXITING", the last thing it did
534 * was set the conn state to "StandAlone",
535 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
536 * and receiver thread will be "started".
537 * drbd_thread_start needs to set "RESTARTING" in that case.
538 * t_state check and assignment needs to be within the same spinlock,
539 * so either thread_start sees EXITING, and can remap to RESTARTING,
540 * or thread_start see NONE, and can proceed as normal.
543 if (thi
->t_state
== RESTARTING
) {
544 conn_info(tconn
, "Restarting %s thread\n", thi
->name
);
545 thi
->t_state
= RUNNING
;
546 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
553 complete_all(&thi
->stop
);
554 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
556 conn_info(tconn
, "Terminating %s\n", current
->comm
);
558 /* Release mod reference taken when thread was started */
560 kref_put(&tconn
->kref
, &conn_destroy
);
561 module_put(THIS_MODULE
);
565 static void drbd_thread_init(struct drbd_tconn
*tconn
, struct drbd_thread
*thi
,
566 int (*func
) (struct drbd_thread
*), char *name
)
568 spin_lock_init(&thi
->t_lock
);
571 thi
->function
= func
;
573 strncpy(thi
->name
, name
, ARRAY_SIZE(thi
->name
));
576 int drbd_thread_start(struct drbd_thread
*thi
)
578 struct drbd_tconn
*tconn
= thi
->tconn
;
579 struct task_struct
*nt
;
582 /* is used from state engine doing drbd_thread_stop_nowait,
583 * while holding the req lock irqsave */
584 spin_lock_irqsave(&thi
->t_lock
, flags
);
586 switch (thi
->t_state
) {
588 conn_info(tconn
, "Starting %s thread (from %s [%d])\n",
589 thi
->name
, current
->comm
, current
->pid
);
591 /* Get ref on module for thread - this is released when thread exits */
592 if (!try_module_get(THIS_MODULE
)) {
593 conn_err(tconn
, "Failed to get module reference in drbd_thread_start\n");
594 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
598 kref_get(&thi
->tconn
->kref
);
600 init_completion(&thi
->stop
);
601 thi
->reset_cpu_mask
= 1;
602 thi
->t_state
= RUNNING
;
603 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
604 flush_signals(current
); /* otherw. may get -ERESTARTNOINTR */
606 nt
= kthread_create(drbd_thread_setup
, (void *) thi
,
607 "drbd_%c_%s", thi
->name
[0], thi
->tconn
->name
);
610 conn_err(tconn
, "Couldn't start thread\n");
612 kref_put(&tconn
->kref
, &conn_destroy
);
613 module_put(THIS_MODULE
);
616 spin_lock_irqsave(&thi
->t_lock
, flags
);
618 thi
->t_state
= RUNNING
;
619 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
623 thi
->t_state
= RESTARTING
;
624 conn_info(tconn
, "Restarting %s thread (from %s [%d])\n",
625 thi
->name
, current
->comm
, current
->pid
);
630 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
638 void _drbd_thread_stop(struct drbd_thread
*thi
, int restart
, int wait
)
642 enum drbd_thread_state ns
= restart
? RESTARTING
: EXITING
;
644 /* may be called from state engine, holding the req lock irqsave */
645 spin_lock_irqsave(&thi
->t_lock
, flags
);
647 if (thi
->t_state
== NONE
) {
648 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
650 drbd_thread_start(thi
);
654 if (thi
->t_state
!= ns
) {
655 if (thi
->task
== NULL
) {
656 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
662 init_completion(&thi
->stop
);
663 if (thi
->task
!= current
)
664 force_sig(DRBD_SIGKILL
, thi
->task
);
667 spin_unlock_irqrestore(&thi
->t_lock
, flags
);
670 wait_for_completion(&thi
->stop
);
673 static struct drbd_thread
*drbd_task_to_thread(struct drbd_tconn
*tconn
, struct task_struct
*task
)
675 struct drbd_thread
*thi
=
676 task
== tconn
->receiver
.task
? &tconn
->receiver
:
677 task
== tconn
->asender
.task
? &tconn
->asender
:
678 task
== tconn
->worker
.task
? &tconn
->worker
: NULL
;
683 char *drbd_task_to_thread_name(struct drbd_tconn
*tconn
, struct task_struct
*task
)
685 struct drbd_thread
*thi
= drbd_task_to_thread(tconn
, task
);
686 return thi
? thi
->name
: task
->comm
;
689 int conn_lowest_minor(struct drbd_tconn
*tconn
)
691 struct drbd_conf
*mdev
;
695 mdev
= idr_get_next(&tconn
->volumes
, &vnr
);
696 m
= mdev
? mdev_to_minor(mdev
) : -1;
704 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
705 * @mdev: DRBD device.
707 * Forces all threads of a device onto the same CPU. This is beneficial for
708 * DRBD's performance. May be overwritten by user's configuration.
710 void drbd_calc_cpu_mask(struct drbd_tconn
*tconn
)
715 if (cpumask_weight(tconn
->cpu_mask
))
718 ord
= conn_lowest_minor(tconn
) % cpumask_weight(cpu_online_mask
);
719 for_each_online_cpu(cpu
) {
721 cpumask_set_cpu(cpu
, tconn
->cpu_mask
);
725 /* should not be reached */
726 cpumask_setall(tconn
->cpu_mask
);
730 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
731 * @mdev: DRBD device.
732 * @thi: drbd_thread object
734 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
737 void drbd_thread_current_set_cpu(struct drbd_thread
*thi
)
739 struct task_struct
*p
= current
;
741 if (!thi
->reset_cpu_mask
)
743 thi
->reset_cpu_mask
= 0;
744 set_cpus_allowed_ptr(p
, thi
->tconn
->cpu_mask
);
749 * drbd_header_size - size of a packet header
751 * The header size is a multiple of 8, so any payload following the header is
752 * word aligned on 64-bit architectures. (The bitmap send and receive code
755 unsigned int drbd_header_size(struct drbd_tconn
*tconn
)
757 if (tconn
->agreed_pro_version
>= 100) {
758 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header100
), 8));
759 return sizeof(struct p_header100
);
761 BUILD_BUG_ON(sizeof(struct p_header80
) !=
762 sizeof(struct p_header95
));
763 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header80
), 8));
764 return sizeof(struct p_header80
);
768 static unsigned int prepare_header80(struct p_header80
*h
, enum drbd_packet cmd
, int size
)
770 h
->magic
= cpu_to_be32(DRBD_MAGIC
);
771 h
->command
= cpu_to_be16(cmd
);
772 h
->length
= cpu_to_be16(size
);
773 return sizeof(struct p_header80
);
776 static unsigned int prepare_header95(struct p_header95
*h
, enum drbd_packet cmd
, int size
)
778 h
->magic
= cpu_to_be16(DRBD_MAGIC_BIG
);
779 h
->command
= cpu_to_be16(cmd
);
780 h
->length
= cpu_to_be32(size
);
781 return sizeof(struct p_header95
);
784 static unsigned int prepare_header100(struct p_header100
*h
, enum drbd_packet cmd
,
787 h
->magic
= cpu_to_be32(DRBD_MAGIC_100
);
788 h
->volume
= cpu_to_be16(vnr
);
789 h
->command
= cpu_to_be16(cmd
);
790 h
->length
= cpu_to_be32(size
);
792 return sizeof(struct p_header100
);
795 static unsigned int prepare_header(struct drbd_tconn
*tconn
, int vnr
,
796 void *buffer
, enum drbd_packet cmd
, int size
)
798 if (tconn
->agreed_pro_version
>= 100)
799 return prepare_header100(buffer
, cmd
, size
, vnr
);
800 else if (tconn
->agreed_pro_version
>= 95 &&
801 size
> DRBD_MAX_SIZE_H80_PACKET
)
802 return prepare_header95(buffer
, cmd
, size
);
804 return prepare_header80(buffer
, cmd
, size
);
807 static void *__conn_prepare_command(struct drbd_tconn
*tconn
,
808 struct drbd_socket
*sock
)
812 return sock
->sbuf
+ drbd_header_size(tconn
);
815 void *conn_prepare_command(struct drbd_tconn
*tconn
, struct drbd_socket
*sock
)
819 mutex_lock(&sock
->mutex
);
820 p
= __conn_prepare_command(tconn
, sock
);
822 mutex_unlock(&sock
->mutex
);
827 void *drbd_prepare_command(struct drbd_conf
*mdev
, struct drbd_socket
*sock
)
829 return conn_prepare_command(mdev
->tconn
, sock
);
832 static int __send_command(struct drbd_tconn
*tconn
, int vnr
,
833 struct drbd_socket
*sock
, enum drbd_packet cmd
,
834 unsigned int header_size
, void *data
,
841 * Called with @data == NULL and the size of the data blocks in @size
842 * for commands that send data blocks. For those commands, omit the
843 * MSG_MORE flag: this will increase the likelihood that data blocks
844 * which are page aligned on the sender will end up page aligned on the
847 msg_flags
= data
? MSG_MORE
: 0;
849 header_size
+= prepare_header(tconn
, vnr
, sock
->sbuf
, cmd
,
851 err
= drbd_send_all(tconn
, sock
->socket
, sock
->sbuf
, header_size
,
854 err
= drbd_send_all(tconn
, sock
->socket
, data
, size
, 0);
858 static int __conn_send_command(struct drbd_tconn
*tconn
, struct drbd_socket
*sock
,
859 enum drbd_packet cmd
, unsigned int header_size
,
860 void *data
, unsigned int size
)
862 return __send_command(tconn
, 0, sock
, cmd
, header_size
, data
, size
);
865 int conn_send_command(struct drbd_tconn
*tconn
, struct drbd_socket
*sock
,
866 enum drbd_packet cmd
, unsigned int header_size
,
867 void *data
, unsigned int size
)
871 err
= __conn_send_command(tconn
, sock
, cmd
, header_size
, data
, size
);
872 mutex_unlock(&sock
->mutex
);
876 int drbd_send_command(struct drbd_conf
*mdev
, struct drbd_socket
*sock
,
877 enum drbd_packet cmd
, unsigned int header_size
,
878 void *data
, unsigned int size
)
882 err
= __send_command(mdev
->tconn
, mdev
->vnr
, sock
, cmd
, header_size
,
884 mutex_unlock(&sock
->mutex
);
888 int drbd_send_ping(struct drbd_tconn
*tconn
)
890 struct drbd_socket
*sock
;
893 if (!conn_prepare_command(tconn
, sock
))
895 return conn_send_command(tconn
, sock
, P_PING
, 0, NULL
, 0);
898 int drbd_send_ping_ack(struct drbd_tconn
*tconn
)
900 struct drbd_socket
*sock
;
903 if (!conn_prepare_command(tconn
, sock
))
905 return conn_send_command(tconn
, sock
, P_PING_ACK
, 0, NULL
, 0);
908 int drbd_send_sync_param(struct drbd_conf
*mdev
)
910 struct drbd_socket
*sock
;
911 struct p_rs_param_95
*p
;
913 const int apv
= mdev
->tconn
->agreed_pro_version
;
914 enum drbd_packet cmd
;
916 struct disk_conf
*dc
;
918 sock
= &mdev
->tconn
->data
;
919 p
= drbd_prepare_command(mdev
, sock
);
924 nc
= rcu_dereference(mdev
->tconn
->net_conf
);
926 size
= apv
<= 87 ? sizeof(struct p_rs_param
)
927 : apv
== 88 ? sizeof(struct p_rs_param
)
928 + strlen(nc
->verify_alg
) + 1
929 : apv
<= 94 ? sizeof(struct p_rs_param_89
)
930 : /* apv >= 95 */ sizeof(struct p_rs_param_95
);
932 cmd
= apv
>= 89 ? P_SYNC_PARAM89
: P_SYNC_PARAM
;
934 /* initialize verify_alg and csums_alg */
935 memset(p
->verify_alg
, 0, 2 * SHARED_SECRET_MAX
);
937 if (get_ldev(mdev
)) {
938 dc
= rcu_dereference(mdev
->ldev
->disk_conf
);
939 p
->resync_rate
= cpu_to_be32(dc
->resync_rate
);
940 p
->c_plan_ahead
= cpu_to_be32(dc
->c_plan_ahead
);
941 p
->c_delay_target
= cpu_to_be32(dc
->c_delay_target
);
942 p
->c_fill_target
= cpu_to_be32(dc
->c_fill_target
);
943 p
->c_max_rate
= cpu_to_be32(dc
->c_max_rate
);
946 p
->resync_rate
= cpu_to_be32(DRBD_RESYNC_RATE_DEF
);
947 p
->c_plan_ahead
= cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF
);
948 p
->c_delay_target
= cpu_to_be32(DRBD_C_DELAY_TARGET_DEF
);
949 p
->c_fill_target
= cpu_to_be32(DRBD_C_FILL_TARGET_DEF
);
950 p
->c_max_rate
= cpu_to_be32(DRBD_C_MAX_RATE_DEF
);
954 strcpy(p
->verify_alg
, nc
->verify_alg
);
956 strcpy(p
->csums_alg
, nc
->csums_alg
);
959 return drbd_send_command(mdev
, sock
, cmd
, size
, NULL
, 0);
962 int __drbd_send_protocol(struct drbd_tconn
*tconn
, enum drbd_packet cmd
)
964 struct drbd_socket
*sock
;
965 struct p_protocol
*p
;
970 p
= __conn_prepare_command(tconn
, sock
);
975 nc
= rcu_dereference(tconn
->net_conf
);
977 if (nc
->tentative
&& tconn
->agreed_pro_version
< 92) {
979 mutex_unlock(&sock
->mutex
);
980 conn_err(tconn
, "--dry-run is not supported by peer");
985 if (tconn
->agreed_pro_version
>= 87)
986 size
+= strlen(nc
->integrity_alg
) + 1;
988 p
->protocol
= cpu_to_be32(nc
->wire_protocol
);
989 p
->after_sb_0p
= cpu_to_be32(nc
->after_sb_0p
);
990 p
->after_sb_1p
= cpu_to_be32(nc
->after_sb_1p
);
991 p
->after_sb_2p
= cpu_to_be32(nc
->after_sb_2p
);
992 p
->two_primaries
= cpu_to_be32(nc
->two_primaries
);
994 if (nc
->discard_my_data
)
995 cf
|= CF_DISCARD_MY_DATA
;
998 p
->conn_flags
= cpu_to_be32(cf
);
1000 if (tconn
->agreed_pro_version
>= 87)
1001 strcpy(p
->integrity_alg
, nc
->integrity_alg
);
1004 return __conn_send_command(tconn
, sock
, cmd
, size
, NULL
, 0);
1007 int drbd_send_protocol(struct drbd_tconn
*tconn
)
1011 mutex_lock(&tconn
->data
.mutex
);
1012 err
= __drbd_send_protocol(tconn
, P_PROTOCOL
);
1013 mutex_unlock(&tconn
->data
.mutex
);
1018 int _drbd_send_uuids(struct drbd_conf
*mdev
, u64 uuid_flags
)
1020 struct drbd_socket
*sock
;
1024 if (!get_ldev_if_state(mdev
, D_NEGOTIATING
))
1027 sock
= &mdev
->tconn
->data
;
1028 p
= drbd_prepare_command(mdev
, sock
);
1033 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
1034 p
->uuid
[i
] = mdev
->ldev
? cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]) : 0;
1036 mdev
->comm_bm_set
= drbd_bm_total_weight(mdev
);
1037 p
->uuid
[UI_SIZE
] = cpu_to_be64(mdev
->comm_bm_set
);
1039 uuid_flags
|= rcu_dereference(mdev
->tconn
->net_conf
)->discard_my_data
? 1 : 0;
1041 uuid_flags
|= test_bit(CRASHED_PRIMARY
, &mdev
->flags
) ? 2 : 0;
1042 uuid_flags
|= mdev
->new_state_tmp
.disk
== D_INCONSISTENT
? 4 : 0;
1043 p
->uuid
[UI_FLAGS
] = cpu_to_be64(uuid_flags
);
1046 return drbd_send_command(mdev
, sock
, P_UUIDS
, sizeof(*p
), NULL
, 0);
1049 int drbd_send_uuids(struct drbd_conf
*mdev
)
1051 return _drbd_send_uuids(mdev
, 0);
1054 int drbd_send_uuids_skip_initial_sync(struct drbd_conf
*mdev
)
1056 return _drbd_send_uuids(mdev
, 8);
1059 void drbd_print_uuids(struct drbd_conf
*mdev
, const char *text
)
1061 if (get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
1062 u64
*uuid
= mdev
->ldev
->md
.uuid
;
1063 dev_info(DEV
, "%s %016llX:%016llX:%016llX:%016llX\n",
1065 (unsigned long long)uuid
[UI_CURRENT
],
1066 (unsigned long long)uuid
[UI_BITMAP
],
1067 (unsigned long long)uuid
[UI_HISTORY_START
],
1068 (unsigned long long)uuid
[UI_HISTORY_END
]);
1071 dev_info(DEV
, "%s effective data uuid: %016llX\n",
1073 (unsigned long long)mdev
->ed_uuid
);
1077 void drbd_gen_and_send_sync_uuid(struct drbd_conf
*mdev
)
1079 struct drbd_socket
*sock
;
1080 struct p_rs_uuid
*p
;
1083 D_ASSERT(mdev
->state
.disk
== D_UP_TO_DATE
);
1085 uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
];
1086 if (uuid
&& uuid
!= UUID_JUST_CREATED
)
1087 uuid
= uuid
+ UUID_NEW_BM_OFFSET
;
1089 get_random_bytes(&uuid
, sizeof(u64
));
1090 drbd_uuid_set(mdev
, UI_BITMAP
, uuid
);
1091 drbd_print_uuids(mdev
, "updated sync UUID");
1094 sock
= &mdev
->tconn
->data
;
1095 p
= drbd_prepare_command(mdev
, sock
);
1097 p
->uuid
= cpu_to_be64(uuid
);
1098 drbd_send_command(mdev
, sock
, P_SYNC_UUID
, sizeof(*p
), NULL
, 0);
1102 int drbd_send_sizes(struct drbd_conf
*mdev
, int trigger_reply
, enum dds_flags flags
)
1104 struct drbd_socket
*sock
;
1106 sector_t d_size
, u_size
;
1107 int q_order_type
, max_bio_size
;
1109 if (get_ldev_if_state(mdev
, D_NEGOTIATING
)) {
1110 D_ASSERT(mdev
->ldev
->backing_bdev
);
1111 d_size
= drbd_get_max_capacity(mdev
->ldev
);
1113 u_size
= rcu_dereference(mdev
->ldev
->disk_conf
)->disk_size
;
1115 q_order_type
= drbd_queue_order_type(mdev
);
1116 max_bio_size
= queue_max_hw_sectors(mdev
->ldev
->backing_bdev
->bd_disk
->queue
) << 9;
1117 max_bio_size
= min_t(int, max_bio_size
, DRBD_MAX_BIO_SIZE
);
1122 q_order_type
= QUEUE_ORDERED_NONE
;
1123 max_bio_size
= DRBD_MAX_BIO_SIZE
; /* ... multiple BIOs per peer_request */
1126 sock
= &mdev
->tconn
->data
;
1127 p
= drbd_prepare_command(mdev
, sock
);
1131 if (mdev
->tconn
->agreed_pro_version
<= 94)
1132 max_bio_size
= min_t(int, max_bio_size
, DRBD_MAX_SIZE_H80_PACKET
);
1133 else if (mdev
->tconn
->agreed_pro_version
< 100)
1134 max_bio_size
= min_t(int, max_bio_size
, DRBD_MAX_BIO_SIZE_P95
);
1136 p
->d_size
= cpu_to_be64(d_size
);
1137 p
->u_size
= cpu_to_be64(u_size
);
1138 p
->c_size
= cpu_to_be64(trigger_reply
? 0 : drbd_get_capacity(mdev
->this_bdev
));
1139 p
->max_bio_size
= cpu_to_be32(max_bio_size
);
1140 p
->queue_order_type
= cpu_to_be16(q_order_type
);
1141 p
->dds_flags
= cpu_to_be16(flags
);
1142 return drbd_send_command(mdev
, sock
, P_SIZES
, sizeof(*p
), NULL
, 0);
1146 * drbd_send_current_state() - Sends the drbd state to the peer
1147 * @mdev: DRBD device.
1149 int drbd_send_current_state(struct drbd_conf
*mdev
)
1151 struct drbd_socket
*sock
;
1154 sock
= &mdev
->tconn
->data
;
1155 p
= drbd_prepare_command(mdev
, sock
);
1158 p
->state
= cpu_to_be32(mdev
->state
.i
); /* Within the send mutex */
1159 return drbd_send_command(mdev
, sock
, P_STATE
, sizeof(*p
), NULL
, 0);
1163 * drbd_send_state() - After a state change, sends the new state to the peer
1164 * @mdev: DRBD device.
1165 * @state: the state to send, not necessarily the current state.
1167 * Each state change queues an "after_state_ch" work, which will eventually
1168 * send the resulting new state to the peer. If more state changes happen
1169 * between queuing and processing of the after_state_ch work, we still
1170 * want to send each intermediary state in the order it occurred.
1172 int drbd_send_state(struct drbd_conf
*mdev
, union drbd_state state
)
1174 struct drbd_socket
*sock
;
1177 sock
= &mdev
->tconn
->data
;
1178 p
= drbd_prepare_command(mdev
, sock
);
1181 p
->state
= cpu_to_be32(state
.i
); /* Within the send mutex */
1182 return drbd_send_command(mdev
, sock
, P_STATE
, sizeof(*p
), NULL
, 0);
1185 int drbd_send_state_req(struct drbd_conf
*mdev
, union drbd_state mask
, union drbd_state val
)
1187 struct drbd_socket
*sock
;
1188 struct p_req_state
*p
;
1190 sock
= &mdev
->tconn
->data
;
1191 p
= drbd_prepare_command(mdev
, sock
);
1194 p
->mask
= cpu_to_be32(mask
.i
);
1195 p
->val
= cpu_to_be32(val
.i
);
1196 return drbd_send_command(mdev
, sock
, P_STATE_CHG_REQ
, sizeof(*p
), NULL
, 0);
1199 int conn_send_state_req(struct drbd_tconn
*tconn
, union drbd_state mask
, union drbd_state val
)
1201 enum drbd_packet cmd
;
1202 struct drbd_socket
*sock
;
1203 struct p_req_state
*p
;
1205 cmd
= tconn
->agreed_pro_version
< 100 ? P_STATE_CHG_REQ
: P_CONN_ST_CHG_REQ
;
1206 sock
= &tconn
->data
;
1207 p
= conn_prepare_command(tconn
, sock
);
1210 p
->mask
= cpu_to_be32(mask
.i
);
1211 p
->val
= cpu_to_be32(val
.i
);
1212 return conn_send_command(tconn
, sock
, cmd
, sizeof(*p
), NULL
, 0);
1215 void drbd_send_sr_reply(struct drbd_conf
*mdev
, enum drbd_state_rv retcode
)
1217 struct drbd_socket
*sock
;
1218 struct p_req_state_reply
*p
;
1220 sock
= &mdev
->tconn
->meta
;
1221 p
= drbd_prepare_command(mdev
, sock
);
1223 p
->retcode
= cpu_to_be32(retcode
);
1224 drbd_send_command(mdev
, sock
, P_STATE_CHG_REPLY
, sizeof(*p
), NULL
, 0);
1228 void conn_send_sr_reply(struct drbd_tconn
*tconn
, enum drbd_state_rv retcode
)
1230 struct drbd_socket
*sock
;
1231 struct p_req_state_reply
*p
;
1232 enum drbd_packet cmd
= tconn
->agreed_pro_version
< 100 ? P_STATE_CHG_REPLY
: P_CONN_ST_CHG_REPLY
;
1234 sock
= &tconn
->meta
;
1235 p
= conn_prepare_command(tconn
, sock
);
1237 p
->retcode
= cpu_to_be32(retcode
);
1238 conn_send_command(tconn
, sock
, cmd
, sizeof(*p
), NULL
, 0);
1242 static void dcbp_set_code(struct p_compressed_bm
*p
, enum drbd_bitmap_code code
)
1244 BUG_ON(code
& ~0xf);
1245 p
->encoding
= (p
->encoding
& ~0xf) | code
;
1248 static void dcbp_set_start(struct p_compressed_bm
*p
, int set
)
1250 p
->encoding
= (p
->encoding
& ~0x80) | (set
? 0x80 : 0);
1253 static void dcbp_set_pad_bits(struct p_compressed_bm
*p
, int n
)
1256 p
->encoding
= (p
->encoding
& (~0x7 << 4)) | (n
<< 4);
1259 int fill_bitmap_rle_bits(struct drbd_conf
*mdev
,
1260 struct p_compressed_bm
*p
,
1262 struct bm_xfer_ctx
*c
)
1264 struct bitstream bs
;
1265 unsigned long plain_bits
;
1272 /* may we use this feature? */
1274 use_rle
= rcu_dereference(mdev
->tconn
->net_conf
)->use_rle
;
1276 if (!use_rle
|| mdev
->tconn
->agreed_pro_version
< 90)
1279 if (c
->bit_offset
>= c
->bm_bits
)
1280 return 0; /* nothing to do. */
1282 /* use at most thus many bytes */
1283 bitstream_init(&bs
, p
->code
, size
, 0);
1284 memset(p
->code
, 0, size
);
1285 /* plain bits covered in this code string */
1288 /* p->encoding & 0x80 stores whether the first run length is set.
1289 * bit offset is implicit.
1290 * start with toggle == 2 to be able to tell the first iteration */
1293 /* see how much plain bits we can stuff into one packet
1294 * using RLE and VLI. */
1296 tmp
= (toggle
== 0) ? _drbd_bm_find_next_zero(mdev
, c
->bit_offset
)
1297 : _drbd_bm_find_next(mdev
, c
->bit_offset
);
1300 rl
= tmp
- c
->bit_offset
;
1302 if (toggle
== 2) { /* first iteration */
1304 /* the first checked bit was set,
1305 * store start value, */
1306 dcbp_set_start(p
, 1);
1307 /* but skip encoding of zero run length */
1311 dcbp_set_start(p
, 0);
1314 /* paranoia: catch zero runlength.
1315 * can only happen if bitmap is modified while we scan it. */
1317 dev_err(DEV
, "unexpected zero runlength while encoding bitmap "
1318 "t:%u bo:%lu\n", toggle
, c
->bit_offset
);
1322 bits
= vli_encode_bits(&bs
, rl
);
1323 if (bits
== -ENOBUFS
) /* buffer full */
1326 dev_err(DEV
, "error while encoding bitmap: %d\n", bits
);
1332 c
->bit_offset
= tmp
;
1333 } while (c
->bit_offset
< c
->bm_bits
);
1335 len
= bs
.cur
.b
- p
->code
+ !!bs
.cur
.bit
;
1337 if (plain_bits
< (len
<< 3)) {
1338 /* incompressible with this method.
1339 * we need to rewind both word and bit position. */
1340 c
->bit_offset
-= plain_bits
;
1341 bm_xfer_ctx_bit_to_word_offset(c
);
1342 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
1346 /* RLE + VLI was able to compress it just fine.
1347 * update c->word_offset. */
1348 bm_xfer_ctx_bit_to_word_offset(c
);
1350 /* store pad_bits */
1351 dcbp_set_pad_bits(p
, (8 - bs
.cur
.bit
) & 0x7);
1357 * send_bitmap_rle_or_plain
1359 * Return 0 when done, 1 when another iteration is needed, and a negative error
1360 * code upon failure.
1363 send_bitmap_rle_or_plain(struct drbd_conf
*mdev
, struct bm_xfer_ctx
*c
)
1365 struct drbd_socket
*sock
= &mdev
->tconn
->data
;
1366 unsigned int header_size
= drbd_header_size(mdev
->tconn
);
1367 struct p_compressed_bm
*p
= sock
->sbuf
+ header_size
;
1370 len
= fill_bitmap_rle_bits(mdev
, p
,
1371 DRBD_SOCKET_BUFFER_SIZE
- header_size
- sizeof(*p
), c
);
1376 dcbp_set_code(p
, RLE_VLI_Bits
);
1377 err
= __send_command(mdev
->tconn
, mdev
->vnr
, sock
,
1378 P_COMPRESSED_BITMAP
, sizeof(*p
) + len
,
1381 c
->bytes
[0] += header_size
+ sizeof(*p
) + len
;
1383 if (c
->bit_offset
>= c
->bm_bits
)
1386 /* was not compressible.
1387 * send a buffer full of plain text bits instead. */
1388 unsigned int data_size
;
1389 unsigned long num_words
;
1390 unsigned long *p
= sock
->sbuf
+ header_size
;
1392 data_size
= DRBD_SOCKET_BUFFER_SIZE
- header_size
;
1393 num_words
= min_t(size_t, data_size
/ sizeof(*p
),
1394 c
->bm_words
- c
->word_offset
);
1395 len
= num_words
* sizeof(*p
);
1397 drbd_bm_get_lel(mdev
, c
->word_offset
, num_words
, p
);
1398 err
= __send_command(mdev
->tconn
, mdev
->vnr
, sock
, P_BITMAP
, len
, NULL
, 0);
1399 c
->word_offset
+= num_words
;
1400 c
->bit_offset
= c
->word_offset
* BITS_PER_LONG
;
1403 c
->bytes
[1] += header_size
+ len
;
1405 if (c
->bit_offset
> c
->bm_bits
)
1406 c
->bit_offset
= c
->bm_bits
;
1410 INFO_bm_xfer_stats(mdev
, "send", c
);
1418 /* See the comment at receive_bitmap() */
1419 static int _drbd_send_bitmap(struct drbd_conf
*mdev
)
1421 struct bm_xfer_ctx c
;
1424 if (!expect(mdev
->bitmap
))
1427 if (get_ldev(mdev
)) {
1428 if (drbd_md_test_flag(mdev
->ldev
, MDF_FULL_SYNC
)) {
1429 dev_info(DEV
, "Writing the whole bitmap, MDF_FullSync was set.\n");
1430 drbd_bm_set_all(mdev
);
1431 if (drbd_bm_write(mdev
)) {
1432 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
1433 * but otherwise process as per normal - need to tell other
1434 * side that a full resync is required! */
1435 dev_err(DEV
, "Failed to write bitmap to disk!\n");
1437 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
1444 c
= (struct bm_xfer_ctx
) {
1445 .bm_bits
= drbd_bm_bits(mdev
),
1446 .bm_words
= drbd_bm_words(mdev
),
1450 err
= send_bitmap_rle_or_plain(mdev
, &c
);
1456 int drbd_send_bitmap(struct drbd_conf
*mdev
)
1458 struct drbd_socket
*sock
= &mdev
->tconn
->data
;
1461 mutex_lock(&sock
->mutex
);
1463 err
= !_drbd_send_bitmap(mdev
);
1464 mutex_unlock(&sock
->mutex
);
1468 void drbd_send_b_ack(struct drbd_conf
*mdev
, u32 barrier_nr
, u32 set_size
)
1470 struct drbd_socket
*sock
;
1471 struct p_barrier_ack
*p
;
1473 if (mdev
->state
.conn
< C_CONNECTED
)
1476 sock
= &mdev
->tconn
->meta
;
1477 p
= drbd_prepare_command(mdev
, sock
);
1480 p
->barrier
= barrier_nr
;
1481 p
->set_size
= cpu_to_be32(set_size
);
1482 drbd_send_command(mdev
, sock
, P_BARRIER_ACK
, sizeof(*p
), NULL
, 0);
1486 * _drbd_send_ack() - Sends an ack packet
1487 * @mdev: DRBD device.
1488 * @cmd: Packet command code.
1489 * @sector: sector, needs to be in big endian byte order
1490 * @blksize: size in byte, needs to be in big endian byte order
1491 * @block_id: Id, big endian byte order
1493 static int _drbd_send_ack(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1494 u64 sector
, u32 blksize
, u64 block_id
)
1496 struct drbd_socket
*sock
;
1497 struct p_block_ack
*p
;
1499 if (mdev
->state
.conn
< C_CONNECTED
)
1502 sock
= &mdev
->tconn
->meta
;
1503 p
= drbd_prepare_command(mdev
, sock
);
1507 p
->block_id
= block_id
;
1508 p
->blksize
= blksize
;
1509 p
->seq_num
= cpu_to_be32(atomic_inc_return(&mdev
->packet_seq
));
1510 return drbd_send_command(mdev
, sock
, cmd
, sizeof(*p
), NULL
, 0);
1513 /* dp->sector and dp->block_id already/still in network byte order,
1514 * data_size is payload size according to dp->head,
1515 * and may need to be corrected for digest size. */
1516 void drbd_send_ack_dp(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1517 struct p_data
*dp
, int data_size
)
1519 if (mdev
->tconn
->peer_integrity_tfm
)
1520 data_size
-= crypto_hash_digestsize(mdev
->tconn
->peer_integrity_tfm
);
1521 _drbd_send_ack(mdev
, cmd
, dp
->sector
, cpu_to_be32(data_size
),
1525 void drbd_send_ack_rp(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1526 struct p_block_req
*rp
)
1528 _drbd_send_ack(mdev
, cmd
, rp
->sector
, rp
->blksize
, rp
->block_id
);
1532 * drbd_send_ack() - Sends an ack packet
1533 * @mdev: DRBD device
1534 * @cmd: packet command code
1535 * @peer_req: peer request
1537 int drbd_send_ack(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1538 struct drbd_peer_request
*peer_req
)
1540 return _drbd_send_ack(mdev
, cmd
,
1541 cpu_to_be64(peer_req
->i
.sector
),
1542 cpu_to_be32(peer_req
->i
.size
),
1543 peer_req
->block_id
);
1546 /* This function misuses the block_id field to signal if the blocks
1547 * are is sync or not. */
1548 int drbd_send_ack_ex(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1549 sector_t sector
, int blksize
, u64 block_id
)
1551 return _drbd_send_ack(mdev
, cmd
,
1552 cpu_to_be64(sector
),
1553 cpu_to_be32(blksize
),
1554 cpu_to_be64(block_id
));
1557 int drbd_send_drequest(struct drbd_conf
*mdev
, int cmd
,
1558 sector_t sector
, int size
, u64 block_id
)
1560 struct drbd_socket
*sock
;
1561 struct p_block_req
*p
;
1563 sock
= &mdev
->tconn
->data
;
1564 p
= drbd_prepare_command(mdev
, sock
);
1567 p
->sector
= cpu_to_be64(sector
);
1568 p
->block_id
= block_id
;
1569 p
->blksize
= cpu_to_be32(size
);
1570 return drbd_send_command(mdev
, sock
, cmd
, sizeof(*p
), NULL
, 0);
1573 int drbd_send_drequest_csum(struct drbd_conf
*mdev
, sector_t sector
, int size
,
1574 void *digest
, int digest_size
, enum drbd_packet cmd
)
1576 struct drbd_socket
*sock
;
1577 struct p_block_req
*p
;
1579 /* FIXME: Put the digest into the preallocated socket buffer. */
1581 sock
= &mdev
->tconn
->data
;
1582 p
= drbd_prepare_command(mdev
, sock
);
1585 p
->sector
= cpu_to_be64(sector
);
1586 p
->block_id
= ID_SYNCER
/* unused */;
1587 p
->blksize
= cpu_to_be32(size
);
1588 return drbd_send_command(mdev
, sock
, cmd
, sizeof(*p
),
1589 digest
, digest_size
);
1592 int drbd_send_ov_request(struct drbd_conf
*mdev
, sector_t sector
, int size
)
1594 struct drbd_socket
*sock
;
1595 struct p_block_req
*p
;
1597 sock
= &mdev
->tconn
->data
;
1598 p
= drbd_prepare_command(mdev
, sock
);
1601 p
->sector
= cpu_to_be64(sector
);
1602 p
->block_id
= ID_SYNCER
/* unused */;
1603 p
->blksize
= cpu_to_be32(size
);
1604 return drbd_send_command(mdev
, sock
, P_OV_REQUEST
, sizeof(*p
), NULL
, 0);
1607 /* called on sndtimeo
1608 * returns false if we should retry,
1609 * true if we think connection is dead
1611 static int we_should_drop_the_connection(struct drbd_tconn
*tconn
, struct socket
*sock
)
1614 /* long elapsed = (long)(jiffies - mdev->last_received); */
1616 drop_it
= tconn
->meta
.socket
== sock
1617 || !tconn
->asender
.task
1618 || get_t_state(&tconn
->asender
) != RUNNING
1619 || tconn
->cstate
< C_WF_REPORT_PARAMS
;
1624 drop_it
= !--tconn
->ko_count
;
1626 conn_err(tconn
, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1627 current
->comm
, current
->pid
, tconn
->ko_count
);
1628 request_ping(tconn
);
1631 return drop_it
; /* && (mdev->state == R_PRIMARY) */;
1634 static void drbd_update_congested(struct drbd_tconn
*tconn
)
1636 struct sock
*sk
= tconn
->data
.socket
->sk
;
1637 if (sk
->sk_wmem_queued
> sk
->sk_sndbuf
* 4 / 5)
1638 set_bit(NET_CONGESTED
, &tconn
->flags
);
1641 /* The idea of sendpage seems to be to put some kind of reference
1642 * to the page into the skb, and to hand it over to the NIC. In
1643 * this process get_page() gets called.
1645 * As soon as the page was really sent over the network put_page()
1646 * gets called by some part of the network layer. [ NIC driver? ]
1648 * [ get_page() / put_page() increment/decrement the count. If count
1649 * reaches 0 the page will be freed. ]
1651 * This works nicely with pages from FSs.
1652 * But this means that in protocol A we might signal IO completion too early!
1654 * In order not to corrupt data during a resync we must make sure
1655 * that we do not reuse our own buffer pages (EEs) to early, therefore
1656 * we have the net_ee list.
1658 * XFS seems to have problems, still, it submits pages with page_count == 0!
1659 * As a workaround, we disable sendpage on pages
1660 * with page_count == 0 or PageSlab.
1662 static int _drbd_no_send_page(struct drbd_conf
*mdev
, struct page
*page
,
1663 int offset
, size_t size
, unsigned msg_flags
)
1665 struct socket
*socket
;
1669 socket
= mdev
->tconn
->data
.socket
;
1670 addr
= kmap(page
) + offset
;
1671 err
= drbd_send_all(mdev
->tconn
, socket
, addr
, size
, msg_flags
);
1674 mdev
->send_cnt
+= size
>> 9;
1678 static int _drbd_send_page(struct drbd_conf
*mdev
, struct page
*page
,
1679 int offset
, size_t size
, unsigned msg_flags
)
1681 struct socket
*socket
= mdev
->tconn
->data
.socket
;
1682 mm_segment_t oldfs
= get_fs();
1686 /* e.g. XFS meta- & log-data is in slab pages, which have a
1687 * page_count of 0 and/or have PageSlab() set.
1688 * we cannot use send_page for those, as that does get_page();
1689 * put_page(); and would cause either a VM_BUG directly, or
1690 * __page_cache_release a page that would actually still be referenced
1691 * by someone, leading to some obscure delayed Oops somewhere else. */
1692 if (disable_sendpage
|| (page_count(page
) < 1) || PageSlab(page
))
1693 return _drbd_no_send_page(mdev
, page
, offset
, size
, msg_flags
);
1695 msg_flags
|= MSG_NOSIGNAL
;
1696 drbd_update_congested(mdev
->tconn
);
1701 sent
= socket
->ops
->sendpage(socket
, page
, offset
, len
, msg_flags
);
1703 if (sent
== -EAGAIN
) {
1704 if (we_should_drop_the_connection(mdev
->tconn
, socket
))
1708 dev_warn(DEV
, "%s: size=%d len=%d sent=%d\n",
1709 __func__
, (int)size
, len
, sent
);
1716 } while (len
> 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
1718 clear_bit(NET_CONGESTED
, &mdev
->tconn
->flags
);
1722 mdev
->send_cnt
+= size
>> 9;
1727 static int _drbd_send_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
1729 struct bio_vec
*bvec
;
1731 /* hint all but last page with MSG_MORE */
1732 __bio_for_each_segment(bvec
, bio
, i
, 0) {
1735 err
= _drbd_no_send_page(mdev
, bvec
->bv_page
,
1736 bvec
->bv_offset
, bvec
->bv_len
,
1737 i
== bio
->bi_vcnt
- 1 ? 0 : MSG_MORE
);
1744 static int _drbd_send_zc_bio(struct drbd_conf
*mdev
, struct bio
*bio
)
1746 struct bio_vec
*bvec
;
1748 /* hint all but last page with MSG_MORE */
1749 __bio_for_each_segment(bvec
, bio
, i
, 0) {
1752 err
= _drbd_send_page(mdev
, bvec
->bv_page
,
1753 bvec
->bv_offset
, bvec
->bv_len
,
1754 i
== bio
->bi_vcnt
- 1 ? 0 : MSG_MORE
);
1761 static int _drbd_send_zc_ee(struct drbd_conf
*mdev
,
1762 struct drbd_peer_request
*peer_req
)
1764 struct page
*page
= peer_req
->pages
;
1765 unsigned len
= peer_req
->i
.size
;
1768 /* hint all but last page with MSG_MORE */
1769 page_chain_for_each(page
) {
1770 unsigned l
= min_t(unsigned, len
, PAGE_SIZE
);
1772 err
= _drbd_send_page(mdev
, page
, 0, l
,
1773 page_chain_next(page
) ? MSG_MORE
: 0);
1781 static u32
bio_flags_to_wire(struct drbd_conf
*mdev
, unsigned long bi_rw
)
1783 if (mdev
->tconn
->agreed_pro_version
>= 95)
1784 return (bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0) |
1785 (bi_rw
& REQ_FUA
? DP_FUA
: 0) |
1786 (bi_rw
& REQ_FLUSH
? DP_FLUSH
: 0) |
1787 (bi_rw
& REQ_DISCARD
? DP_DISCARD
: 0);
1789 return bi_rw
& REQ_SYNC
? DP_RW_SYNC
: 0;
1792 /* Used to send write requests
1793 * R_PRIMARY -> Peer (P_DATA)
1795 int drbd_send_dblock(struct drbd_conf
*mdev
, struct drbd_request
*req
)
1797 struct drbd_socket
*sock
;
1799 unsigned int dp_flags
= 0;
1803 sock
= &mdev
->tconn
->data
;
1804 p
= drbd_prepare_command(mdev
, sock
);
1805 dgs
= mdev
->tconn
->integrity_tfm
? crypto_hash_digestsize(mdev
->tconn
->integrity_tfm
) : 0;
1809 p
->sector
= cpu_to_be64(req
->i
.sector
);
1810 p
->block_id
= (unsigned long)req
;
1811 p
->seq_num
= cpu_to_be32(req
->seq_num
= atomic_inc_return(&mdev
->packet_seq
));
1812 dp_flags
= bio_flags_to_wire(mdev
, req
->master_bio
->bi_rw
);
1813 if (mdev
->state
.conn
>= C_SYNC_SOURCE
&&
1814 mdev
->state
.conn
<= C_PAUSED_SYNC_T
)
1815 dp_flags
|= DP_MAY_SET_IN_SYNC
;
1816 if (mdev
->tconn
->agreed_pro_version
>= 100) {
1817 if (req
->rq_state
& RQ_EXP_RECEIVE_ACK
)
1818 dp_flags
|= DP_SEND_RECEIVE_ACK
;
1819 if (req
->rq_state
& RQ_EXP_WRITE_ACK
)
1820 dp_flags
|= DP_SEND_WRITE_ACK
;
1822 p
->dp_flags
= cpu_to_be32(dp_flags
);
1824 drbd_csum_bio(mdev
, mdev
->tconn
->integrity_tfm
, req
->master_bio
, p
+ 1);
1825 err
= __send_command(mdev
->tconn
, mdev
->vnr
, sock
, P_DATA
, sizeof(*p
) + dgs
, NULL
, req
->i
.size
);
1827 /* For protocol A, we have to memcpy the payload into
1828 * socket buffers, as we may complete right away
1829 * as soon as we handed it over to tcp, at which point the data
1830 * pages may become invalid.
1832 * For data-integrity enabled, we copy it as well, so we can be
1833 * sure that even if the bio pages may still be modified, it
1834 * won't change the data on the wire, thus if the digest checks
1835 * out ok after sending on this side, but does not fit on the
1836 * receiving side, we sure have detected corruption elsewhere.
1838 if (!(req
->rq_state
& (RQ_EXP_RECEIVE_ACK
| RQ_EXP_WRITE_ACK
)) || dgs
)
1839 err
= _drbd_send_bio(mdev
, req
->master_bio
);
1841 err
= _drbd_send_zc_bio(mdev
, req
->master_bio
);
1843 /* double check digest, sometimes buffers have been modified in flight. */
1844 if (dgs
> 0 && dgs
<= 64) {
1845 /* 64 byte, 512 bit, is the largest digest size
1846 * currently supported in kernel crypto. */
1847 unsigned char digest
[64];
1848 drbd_csum_bio(mdev
, mdev
->tconn
->integrity_tfm
, req
->master_bio
, digest
);
1849 if (memcmp(p
+ 1, digest
, dgs
)) {
1851 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
1852 (unsigned long long)req
->i
.sector
, req
->i
.size
);
1854 } /* else if (dgs > 64) {
1855 ... Be noisy about digest too large ...
1858 mutex_unlock(&sock
->mutex
); /* locked by drbd_prepare_command() */
1863 /* answer packet, used to send data back for read requests:
1864 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
1865 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
1867 int drbd_send_block(struct drbd_conf
*mdev
, enum drbd_packet cmd
,
1868 struct drbd_peer_request
*peer_req
)
1870 struct drbd_socket
*sock
;
1875 sock
= &mdev
->tconn
->data
;
1876 p
= drbd_prepare_command(mdev
, sock
);
1878 dgs
= mdev
->tconn
->integrity_tfm
? crypto_hash_digestsize(mdev
->tconn
->integrity_tfm
) : 0;
1882 p
->sector
= cpu_to_be64(peer_req
->i
.sector
);
1883 p
->block_id
= peer_req
->block_id
;
1884 p
->seq_num
= 0; /* unused */
1886 drbd_csum_ee(mdev
, mdev
->tconn
->integrity_tfm
, peer_req
, p
+ 1);
1887 err
= __send_command(mdev
->tconn
, mdev
->vnr
, sock
, cmd
, sizeof(*p
) + dgs
, NULL
, peer_req
->i
.size
);
1889 err
= _drbd_send_zc_ee(mdev
, peer_req
);
1890 mutex_unlock(&sock
->mutex
); /* locked by drbd_prepare_command() */
1895 int drbd_send_out_of_sync(struct drbd_conf
*mdev
, struct drbd_request
*req
)
1897 struct drbd_socket
*sock
;
1898 struct p_block_desc
*p
;
1900 sock
= &mdev
->tconn
->data
;
1901 p
= drbd_prepare_command(mdev
, sock
);
1904 p
->sector
= cpu_to_be64(req
->i
.sector
);
1905 p
->blksize
= cpu_to_be32(req
->i
.size
);
1906 return drbd_send_command(mdev
, sock
, P_OUT_OF_SYNC
, sizeof(*p
), NULL
, 0);
1910 drbd_send distinguishes two cases:
1912 Packets sent via the data socket "sock"
1913 and packets sent via the meta data socket "msock"
1916 -----------------+-------------------------+------------------------------
1917 timeout conf.timeout / 2 conf.timeout / 2
1918 timeout action send a ping via msock Abort communication
1919 and close all sockets
1923 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
1925 int drbd_send(struct drbd_tconn
*tconn
, struct socket
*sock
,
1926 void *buf
, size_t size
, unsigned msg_flags
)
1935 /* THINK if (signal_pending) return ... ? */
1940 msg
.msg_name
= NULL
;
1941 msg
.msg_namelen
= 0;
1942 msg
.msg_control
= NULL
;
1943 msg
.msg_controllen
= 0;
1944 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
1946 if (sock
== tconn
->data
.socket
) {
1948 tconn
->ko_count
= rcu_dereference(tconn
->net_conf
)->ko_count
;
1950 drbd_update_congested(tconn
);
1954 * tcp_sendmsg does _not_ use its size parameter at all ?
1956 * -EAGAIN on timeout, -EINTR on signal.
1959 * do we need to block DRBD_SIG if sock == &meta.socket ??
1960 * otherwise wake_asender() might interrupt some send_*Ack !
1962 rv
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
1963 if (rv
== -EAGAIN
) {
1964 if (we_should_drop_the_connection(tconn
, sock
))
1970 flush_signals(current
);
1978 } while (sent
< size
);
1980 if (sock
== tconn
->data
.socket
)
1981 clear_bit(NET_CONGESTED
, &tconn
->flags
);
1984 if (rv
!= -EAGAIN
) {
1985 conn_err(tconn
, "%s_sendmsg returned %d\n",
1986 sock
== tconn
->meta
.socket
? "msock" : "sock",
1988 conn_request_state(tconn
, NS(conn
, C_BROKEN_PIPE
), CS_HARD
);
1990 conn_request_state(tconn
, NS(conn
, C_TIMEOUT
), CS_HARD
);
1997 * drbd_send_all - Send an entire buffer
1999 * Returns 0 upon success and a negative error value otherwise.
2001 int drbd_send_all(struct drbd_tconn
*tconn
, struct socket
*sock
, void *buffer
,
2002 size_t size
, unsigned msg_flags
)
2006 err
= drbd_send(tconn
, sock
, buffer
, size
, msg_flags
);
2014 static int drbd_open(struct block_device
*bdev
, fmode_t mode
)
2016 struct drbd_conf
*mdev
= bdev
->bd_disk
->private_data
;
2017 unsigned long flags
;
2020 mutex_lock(&drbd_main_mutex
);
2021 spin_lock_irqsave(&mdev
->tconn
->req_lock
, flags
);
2022 /* to have a stable mdev->state.role
2023 * and no race with updating open_cnt */
2025 if (mdev
->state
.role
!= R_PRIMARY
) {
2026 if (mode
& FMODE_WRITE
)
2028 else if (!allow_oos
)
2034 spin_unlock_irqrestore(&mdev
->tconn
->req_lock
, flags
);
2035 mutex_unlock(&drbd_main_mutex
);
2040 static int drbd_release(struct gendisk
*gd
, fmode_t mode
)
2042 struct drbd_conf
*mdev
= gd
->private_data
;
2043 mutex_lock(&drbd_main_mutex
);
2045 mutex_unlock(&drbd_main_mutex
);
2049 static void drbd_set_defaults(struct drbd_conf
*mdev
)
2051 /* Beware! The actual layout differs
2052 * between big endian and little endian */
2053 mdev
->state
= (union drbd_dev_state
) {
2054 { .role
= R_SECONDARY
,
2056 .conn
= C_STANDALONE
,
2062 void drbd_init_set_defaults(struct drbd_conf
*mdev
)
2064 /* the memset(,0,) did most of this.
2065 * note: only assignments, no allocation in here */
2067 drbd_set_defaults(mdev
);
2069 atomic_set(&mdev
->ap_bio_cnt
, 0);
2070 atomic_set(&mdev
->ap_pending_cnt
, 0);
2071 atomic_set(&mdev
->rs_pending_cnt
, 0);
2072 atomic_set(&mdev
->unacked_cnt
, 0);
2073 atomic_set(&mdev
->local_cnt
, 0);
2074 atomic_set(&mdev
->pp_in_use_by_net
, 0);
2075 atomic_set(&mdev
->rs_sect_in
, 0);
2076 atomic_set(&mdev
->rs_sect_ev
, 0);
2077 atomic_set(&mdev
->ap_in_flight
, 0);
2078 atomic_set(&mdev
->md_io_in_use
, 0);
2080 mutex_init(&mdev
->own_state_mutex
);
2081 mdev
->state_mutex
= &mdev
->own_state_mutex
;
2083 spin_lock_init(&mdev
->al_lock
);
2084 spin_lock_init(&mdev
->peer_seq_lock
);
2085 spin_lock_init(&mdev
->epoch_lock
);
2087 INIT_LIST_HEAD(&mdev
->active_ee
);
2088 INIT_LIST_HEAD(&mdev
->sync_ee
);
2089 INIT_LIST_HEAD(&mdev
->done_ee
);
2090 INIT_LIST_HEAD(&mdev
->read_ee
);
2091 INIT_LIST_HEAD(&mdev
->net_ee
);
2092 INIT_LIST_HEAD(&mdev
->resync_reads
);
2093 INIT_LIST_HEAD(&mdev
->resync_work
.list
);
2094 INIT_LIST_HEAD(&mdev
->unplug_work
.list
);
2095 INIT_LIST_HEAD(&mdev
->go_diskless
.list
);
2096 INIT_LIST_HEAD(&mdev
->md_sync_work
.list
);
2097 INIT_LIST_HEAD(&mdev
->start_resync_work
.list
);
2098 INIT_LIST_HEAD(&mdev
->bm_io_work
.w
.list
);
2100 mdev
->resync_work
.cb
= w_resync_timer
;
2101 mdev
->unplug_work
.cb
= w_send_write_hint
;
2102 mdev
->go_diskless
.cb
= w_go_diskless
;
2103 mdev
->md_sync_work
.cb
= w_md_sync
;
2104 mdev
->bm_io_work
.w
.cb
= w_bitmap_io
;
2105 mdev
->start_resync_work
.cb
= w_start_resync
;
2107 mdev
->resync_work
.mdev
= mdev
;
2108 mdev
->unplug_work
.mdev
= mdev
;
2109 mdev
->go_diskless
.mdev
= mdev
;
2110 mdev
->md_sync_work
.mdev
= mdev
;
2111 mdev
->bm_io_work
.w
.mdev
= mdev
;
2112 mdev
->start_resync_work
.mdev
= mdev
;
2114 init_timer(&mdev
->resync_timer
);
2115 init_timer(&mdev
->md_sync_timer
);
2116 init_timer(&mdev
->start_resync_timer
);
2117 init_timer(&mdev
->request_timer
);
2118 mdev
->resync_timer
.function
= resync_timer_fn
;
2119 mdev
->resync_timer
.data
= (unsigned long) mdev
;
2120 mdev
->md_sync_timer
.function
= md_sync_timer_fn
;
2121 mdev
->md_sync_timer
.data
= (unsigned long) mdev
;
2122 mdev
->start_resync_timer
.function
= start_resync_timer_fn
;
2123 mdev
->start_resync_timer
.data
= (unsigned long) mdev
;
2124 mdev
->request_timer
.function
= request_timer_fn
;
2125 mdev
->request_timer
.data
= (unsigned long) mdev
;
2127 init_waitqueue_head(&mdev
->misc_wait
);
2128 init_waitqueue_head(&mdev
->state_wait
);
2129 init_waitqueue_head(&mdev
->ee_wait
);
2130 init_waitqueue_head(&mdev
->al_wait
);
2131 init_waitqueue_head(&mdev
->seq_wait
);
2133 mdev
->resync_wenr
= LC_FREE
;
2134 mdev
->peer_max_bio_size
= DRBD_MAX_BIO_SIZE_SAFE
;
2135 mdev
->local_max_bio_size
= DRBD_MAX_BIO_SIZE_SAFE
;
2138 void drbd_mdev_cleanup(struct drbd_conf
*mdev
)
2141 if (mdev
->tconn
->receiver
.t_state
!= NONE
)
2142 dev_err(DEV
, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
2143 mdev
->tconn
->receiver
.t_state
);
2145 /* no need to lock it, I'm the only thread alive */
2146 if (atomic_read(&mdev
->current_epoch
->epoch_size
) != 0)
2147 dev_err(DEV
, "epoch_size:%d\n", atomic_read(&mdev
->current_epoch
->epoch_size
));
2157 mdev
->rs_failed
= 0;
2158 mdev
->rs_last_events
= 0;
2159 mdev
->rs_last_sect_ev
= 0;
2160 for (i
= 0; i
< DRBD_SYNC_MARKS
; i
++) {
2161 mdev
->rs_mark_left
[i
] = 0;
2162 mdev
->rs_mark_time
[i
] = 0;
2164 D_ASSERT(mdev
->tconn
->net_conf
== NULL
);
2166 drbd_set_my_capacity(mdev
, 0);
2168 /* maybe never allocated. */
2169 drbd_bm_resize(mdev
, 0, 1);
2170 drbd_bm_cleanup(mdev
);
2173 drbd_free_bc(mdev
->ldev
);
2176 clear_bit(AL_SUSPENDED
, &mdev
->flags
);
2178 D_ASSERT(list_empty(&mdev
->active_ee
));
2179 D_ASSERT(list_empty(&mdev
->sync_ee
));
2180 D_ASSERT(list_empty(&mdev
->done_ee
));
2181 D_ASSERT(list_empty(&mdev
->read_ee
));
2182 D_ASSERT(list_empty(&mdev
->net_ee
));
2183 D_ASSERT(list_empty(&mdev
->resync_reads
));
2184 D_ASSERT(list_empty(&mdev
->tconn
->data
.work
.q
));
2185 D_ASSERT(list_empty(&mdev
->tconn
->meta
.work
.q
));
2186 D_ASSERT(list_empty(&mdev
->resync_work
.list
));
2187 D_ASSERT(list_empty(&mdev
->unplug_work
.list
));
2188 D_ASSERT(list_empty(&mdev
->go_diskless
.list
));
2190 drbd_set_defaults(mdev
);
2194 static void drbd_destroy_mempools(void)
2198 while (drbd_pp_pool
) {
2199 page
= drbd_pp_pool
;
2200 drbd_pp_pool
= (struct page
*)page_private(page
);
2205 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
2207 if (drbd_md_io_bio_set
)
2208 bioset_free(drbd_md_io_bio_set
);
2209 if (drbd_md_io_page_pool
)
2210 mempool_destroy(drbd_md_io_page_pool
);
2211 if (drbd_ee_mempool
)
2212 mempool_destroy(drbd_ee_mempool
);
2213 if (drbd_request_mempool
)
2214 mempool_destroy(drbd_request_mempool
);
2216 kmem_cache_destroy(drbd_ee_cache
);
2217 if (drbd_request_cache
)
2218 kmem_cache_destroy(drbd_request_cache
);
2219 if (drbd_bm_ext_cache
)
2220 kmem_cache_destroy(drbd_bm_ext_cache
);
2221 if (drbd_al_ext_cache
)
2222 kmem_cache_destroy(drbd_al_ext_cache
);
2224 drbd_md_io_bio_set
= NULL
;
2225 drbd_md_io_page_pool
= NULL
;
2226 drbd_ee_mempool
= NULL
;
2227 drbd_request_mempool
= NULL
;
2228 drbd_ee_cache
= NULL
;
2229 drbd_request_cache
= NULL
;
2230 drbd_bm_ext_cache
= NULL
;
2231 drbd_al_ext_cache
= NULL
;
2236 static int drbd_create_mempools(void)
2239 const int number
= (DRBD_MAX_BIO_SIZE
/PAGE_SIZE
) * minor_count
;
2242 /* prepare our caches and mempools */
2243 drbd_request_mempool
= NULL
;
2244 drbd_ee_cache
= NULL
;
2245 drbd_request_cache
= NULL
;
2246 drbd_bm_ext_cache
= NULL
;
2247 drbd_al_ext_cache
= NULL
;
2248 drbd_pp_pool
= NULL
;
2249 drbd_md_io_page_pool
= NULL
;
2250 drbd_md_io_bio_set
= NULL
;
2253 drbd_request_cache
= kmem_cache_create(
2254 "drbd_req", sizeof(struct drbd_request
), 0, 0, NULL
);
2255 if (drbd_request_cache
== NULL
)
2258 drbd_ee_cache
= kmem_cache_create(
2259 "drbd_ee", sizeof(struct drbd_peer_request
), 0, 0, NULL
);
2260 if (drbd_ee_cache
== NULL
)
2263 drbd_bm_ext_cache
= kmem_cache_create(
2264 "drbd_bm", sizeof(struct bm_extent
), 0, 0, NULL
);
2265 if (drbd_bm_ext_cache
== NULL
)
2268 drbd_al_ext_cache
= kmem_cache_create(
2269 "drbd_al", sizeof(struct lc_element
), 0, 0, NULL
);
2270 if (drbd_al_ext_cache
== NULL
)
2274 drbd_md_io_bio_set
= bioset_create(DRBD_MIN_POOL_PAGES
, 0);
2275 if (drbd_md_io_bio_set
== NULL
)
2278 drbd_md_io_page_pool
= mempool_create_page_pool(DRBD_MIN_POOL_PAGES
, 0);
2279 if (drbd_md_io_page_pool
== NULL
)
2282 drbd_request_mempool
= mempool_create(number
,
2283 mempool_alloc_slab
, mempool_free_slab
, drbd_request_cache
);
2284 if (drbd_request_mempool
== NULL
)
2287 drbd_ee_mempool
= mempool_create(number
,
2288 mempool_alloc_slab
, mempool_free_slab
, drbd_ee_cache
);
2289 if (drbd_ee_mempool
== NULL
)
2292 /* drbd's page pool */
2293 spin_lock_init(&drbd_pp_lock
);
2295 for (i
= 0; i
< number
; i
++) {
2296 page
= alloc_page(GFP_HIGHUSER
);
2299 set_page_private(page
, (unsigned long)drbd_pp_pool
);
2300 drbd_pp_pool
= page
;
2302 drbd_pp_vacant
= number
;
2307 drbd_destroy_mempools(); /* in case we allocated some */
2311 static int drbd_notify_sys(struct notifier_block
*this, unsigned long code
,
2314 /* just so we have it. you never know what interesting things we
2315 * might want to do here some day...
2321 static struct notifier_block drbd_notifier
= {
2322 .notifier_call
= drbd_notify_sys
,
2325 static void drbd_release_all_peer_reqs(struct drbd_conf
*mdev
)
2329 rr
= drbd_free_peer_reqs(mdev
, &mdev
->active_ee
);
2331 dev_err(DEV
, "%d EEs in active list found!\n", rr
);
2333 rr
= drbd_free_peer_reqs(mdev
, &mdev
->sync_ee
);
2335 dev_err(DEV
, "%d EEs in sync list found!\n", rr
);
2337 rr
= drbd_free_peer_reqs(mdev
, &mdev
->read_ee
);
2339 dev_err(DEV
, "%d EEs in read list found!\n", rr
);
2341 rr
= drbd_free_peer_reqs(mdev
, &mdev
->done_ee
);
2343 dev_err(DEV
, "%d EEs in done list found!\n", rr
);
2345 rr
= drbd_free_peer_reqs(mdev
, &mdev
->net_ee
);
2347 dev_err(DEV
, "%d EEs in net list found!\n", rr
);
2350 /* caution. no locking. */
2351 void drbd_minor_destroy(struct kref
*kref
)
2353 struct drbd_conf
*mdev
= container_of(kref
, struct drbd_conf
, kref
);
2354 struct drbd_tconn
*tconn
= mdev
->tconn
;
2356 del_timer_sync(&mdev
->request_timer
);
2358 /* paranoia asserts */
2359 D_ASSERT(mdev
->open_cnt
== 0);
2360 D_ASSERT(list_empty(&mdev
->tconn
->data
.work
.q
));
2361 /* end paranoia asserts */
2363 /* cleanup stuff that may have been allocated during
2364 * device (re-)configuration or state changes */
2366 if (mdev
->this_bdev
)
2367 bdput(mdev
->this_bdev
);
2369 drbd_free_bc(mdev
->ldev
);
2372 drbd_release_all_peer_reqs(mdev
);
2374 lc_destroy(mdev
->act_log
);
2375 lc_destroy(mdev
->resync
);
2377 kfree(mdev
->p_uuid
);
2378 /* mdev->p_uuid = NULL; */
2380 kfree(mdev
->current_epoch
);
2381 if (mdev
->bitmap
) /* should no longer be there. */
2382 drbd_bm_cleanup(mdev
);
2383 __free_page(mdev
->md_io_page
);
2384 put_disk(mdev
->vdisk
);
2385 blk_cleanup_queue(mdev
->rq_queue
);
2386 kfree(mdev
->rs_plan_s
);
2389 kref_put(&tconn
->kref
, &conn_destroy
);
2392 static void drbd_cleanup(void)
2395 struct drbd_conf
*mdev
;
2396 struct drbd_tconn
*tconn
, *tmp
;
2398 unregister_reboot_notifier(&drbd_notifier
);
2400 /* first remove proc,
2401 * drbdsetup uses it's presence to detect
2402 * whether DRBD is loaded.
2403 * If we would get stuck in proc removal,
2404 * but have netlink already deregistered,
2405 * some drbdsetup commands may wait forever
2409 remove_proc_entry("drbd", NULL
);
2411 drbd_genl_unregister();
2413 idr_for_each_entry(&minors
, mdev
, i
) {
2414 idr_remove(&minors
, mdev_to_minor(mdev
));
2415 idr_remove(&mdev
->tconn
->volumes
, mdev
->vnr
);
2416 del_gendisk(mdev
->vdisk
);
2417 /* synchronize_rcu(); No other threads running at this point */
2418 kref_put(&mdev
->kref
, &drbd_minor_destroy
);
2421 /* not _rcu since, no other updater anymore. Genl already unregistered */
2422 list_for_each_entry_safe(tconn
, tmp
, &drbd_tconns
, all_tconn
) {
2423 list_del(&tconn
->all_tconn
); /* not _rcu no proc, not other threads */
2424 /* synchronize_rcu(); */
2425 kref_put(&tconn
->kref
, &conn_destroy
);
2428 drbd_destroy_mempools();
2429 unregister_blkdev(DRBD_MAJOR
, "drbd");
2431 idr_destroy(&minors
);
2433 printk(KERN_INFO
"drbd: module cleanup done.\n");
2437 * drbd_congested() - Callback for pdflush
2438 * @congested_data: User data
2439 * @bdi_bits: Bits pdflush is currently interested in
2441 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
2443 static int drbd_congested(void *congested_data
, int bdi_bits
)
2445 struct drbd_conf
*mdev
= congested_data
;
2446 struct request_queue
*q
;
2450 if (!may_inc_ap_bio(mdev
)) {
2451 /* DRBD has frozen IO */
2457 if (get_ldev(mdev
)) {
2458 q
= bdev_get_queue(mdev
->ldev
->backing_bdev
);
2459 r
= bdi_congested(&q
->backing_dev_info
, bdi_bits
);
2465 if (bdi_bits
& (1 << BDI_async_congested
) && test_bit(NET_CONGESTED
, &mdev
->tconn
->flags
)) {
2466 r
|= (1 << BDI_async_congested
);
2467 reason
= reason
== 'b' ? 'a' : 'n';
2471 mdev
->congestion_reason
= reason
;
2475 static void drbd_init_workqueue(struct drbd_work_queue
* wq
)
2477 sema_init(&wq
->s
, 0);
2478 spin_lock_init(&wq
->q_lock
);
2479 INIT_LIST_HEAD(&wq
->q
);
2482 struct drbd_tconn
*conn_get_by_name(const char *name
)
2484 struct drbd_tconn
*tconn
;
2486 if (!name
|| !name
[0])
2490 list_for_each_entry_rcu(tconn
, &drbd_tconns
, all_tconn
) {
2491 if (!strcmp(tconn
->name
, name
)) {
2492 kref_get(&tconn
->kref
);
2502 struct drbd_tconn
*conn_get_by_addrs(void *my_addr
, int my_addr_len
,
2503 void *peer_addr
, int peer_addr_len
)
2505 struct drbd_tconn
*tconn
;
2508 list_for_each_entry_rcu(tconn
, &drbd_tconns
, all_tconn
) {
2509 if (tconn
->my_addr_len
== my_addr_len
&&
2510 tconn
->peer_addr_len
== peer_addr_len
&&
2511 !memcmp(&tconn
->my_addr
, my_addr
, my_addr_len
) &&
2512 !memcmp(&tconn
->peer_addr
, peer_addr
, peer_addr_len
)) {
2513 kref_get(&tconn
->kref
);
2523 static int drbd_alloc_socket(struct drbd_socket
*socket
)
2525 socket
->rbuf
= (void *) __get_free_page(GFP_KERNEL
);
2528 socket
->sbuf
= (void *) __get_free_page(GFP_KERNEL
);
2534 static void drbd_free_socket(struct drbd_socket
*socket
)
2536 free_page((unsigned long) socket
->sbuf
);
2537 free_page((unsigned long) socket
->rbuf
);
2540 void conn_free_crypto(struct drbd_tconn
*tconn
)
2542 drbd_free_sock(tconn
);
2544 crypto_free_hash(tconn
->csums_tfm
);
2545 crypto_free_hash(tconn
->verify_tfm
);
2546 crypto_free_hash(tconn
->cram_hmac_tfm
);
2547 crypto_free_hash(tconn
->integrity_tfm
);
2548 crypto_free_hash(tconn
->peer_integrity_tfm
);
2549 kfree(tconn
->int_dig_in
);
2550 kfree(tconn
->int_dig_vv
);
2552 tconn
->csums_tfm
= NULL
;
2553 tconn
->verify_tfm
= NULL
;
2554 tconn
->cram_hmac_tfm
= NULL
;
2555 tconn
->integrity_tfm
= NULL
;
2556 tconn
->peer_integrity_tfm
= NULL
;
2557 tconn
->int_dig_in
= NULL
;
2558 tconn
->int_dig_vv
= NULL
;
2561 int set_resource_options(struct drbd_tconn
*tconn
, struct res_opts
*res_opts
)
2563 cpumask_var_t new_cpu_mask
;
2566 if (!zalloc_cpumask_var(&new_cpu_mask
, GFP_KERNEL
))
2569 retcode = ERR_NOMEM;
2570 drbd_msg_put_info("unable to allocate cpumask");
2573 /* silently ignore cpu mask on UP kernel */
2574 if (nr_cpu_ids
> 1 && res_opts
->cpu_mask
[0] != 0) {
2575 /* FIXME: Get rid of constant 32 here */
2576 err
= __bitmap_parse(res_opts
->cpu_mask
, 32, 0,
2577 cpumask_bits(new_cpu_mask
), nr_cpu_ids
);
2579 conn_warn(tconn
, "__bitmap_parse() failed with %d\n", err
);
2580 /* retcode = ERR_CPU_MASK_PARSE; */
2584 tconn
->res_opts
= *res_opts
;
2585 if (!cpumask_equal(tconn
->cpu_mask
, new_cpu_mask
)) {
2586 cpumask_copy(tconn
->cpu_mask
, new_cpu_mask
);
2587 drbd_calc_cpu_mask(tconn
);
2588 tconn
->receiver
.reset_cpu_mask
= 1;
2589 tconn
->asender
.reset_cpu_mask
= 1;
2590 tconn
->worker
.reset_cpu_mask
= 1;
2595 free_cpumask_var(new_cpu_mask
);
2600 /* caller must be under genl_lock() */
2601 struct drbd_tconn
*conn_create(const char *name
, struct res_opts
*res_opts
)
2603 struct drbd_tconn
*tconn
;
2605 tconn
= kzalloc(sizeof(struct drbd_tconn
), GFP_KERNEL
);
2609 tconn
->name
= kstrdup(name
, GFP_KERNEL
);
2613 if (drbd_alloc_socket(&tconn
->data
))
2615 if (drbd_alloc_socket(&tconn
->meta
))
2618 if (!zalloc_cpumask_var(&tconn
->cpu_mask
, GFP_KERNEL
))
2621 if (set_resource_options(tconn
, res_opts
))
2624 if (!tl_init(tconn
))
2627 tconn
->write_ordering
= WO_bdev_flush
;
2629 tconn
->cstate
= C_STANDALONE
;
2630 mutex_init(&tconn
->cstate_mutex
);
2631 spin_lock_init(&tconn
->req_lock
);
2632 mutex_init(&tconn
->conf_update
);
2633 init_waitqueue_head(&tconn
->ping_wait
);
2634 idr_init(&tconn
->volumes
);
2636 drbd_init_workqueue(&tconn
->data
.work
);
2637 mutex_init(&tconn
->data
.mutex
);
2639 drbd_init_workqueue(&tconn
->meta
.work
);
2640 mutex_init(&tconn
->meta
.mutex
);
2642 drbd_thread_init(tconn
, &tconn
->receiver
, drbdd_init
, "receiver");
2643 drbd_thread_init(tconn
, &tconn
->worker
, drbd_worker
, "worker");
2644 drbd_thread_init(tconn
, &tconn
->asender
, drbd_asender
, "asender");
2646 kref_init(&tconn
->kref
);
2647 list_add_tail_rcu(&tconn
->all_tconn
, &drbd_tconns
);
2653 free_cpumask_var(tconn
->cpu_mask
);
2654 drbd_free_socket(&tconn
->meta
);
2655 drbd_free_socket(&tconn
->data
);
2662 void conn_destroy(struct kref
*kref
)
2664 struct drbd_tconn
*tconn
= container_of(kref
, struct drbd_tconn
, kref
);
2666 idr_destroy(&tconn
->volumes
);
2668 free_cpumask_var(tconn
->cpu_mask
);
2669 drbd_free_socket(&tconn
->meta
);
2670 drbd_free_socket(&tconn
->data
);
2672 kfree(tconn
->int_dig_in
);
2673 kfree(tconn
->int_dig_vv
);
2677 enum drbd_ret_code
conn_new_minor(struct drbd_tconn
*tconn
, unsigned int minor
, int vnr
)
2679 struct drbd_conf
*mdev
;
2680 struct gendisk
*disk
;
2681 struct request_queue
*q
;
2683 int minor_got
= minor
;
2684 enum drbd_ret_code err
= ERR_NOMEM
;
2686 mdev
= minor_to_mdev(minor
);
2688 return ERR_MINOR_EXISTS
;
2690 /* GFP_KERNEL, we are outside of all write-out paths */
2691 mdev
= kzalloc(sizeof(struct drbd_conf
), GFP_KERNEL
);
2695 kref_get(&tconn
->kref
);
2696 mdev
->tconn
= tconn
;
2698 mdev
->minor
= minor
;
2701 drbd_init_set_defaults(mdev
);
2703 q
= blk_alloc_queue(GFP_KERNEL
);
2707 q
->queuedata
= mdev
;
2709 disk
= alloc_disk(1);
2714 set_disk_ro(disk
, true);
2717 disk
->major
= DRBD_MAJOR
;
2718 disk
->first_minor
= minor
;
2719 disk
->fops
= &drbd_ops
;
2720 sprintf(disk
->disk_name
, "drbd%d", minor
);
2721 disk
->private_data
= mdev
;
2723 mdev
->this_bdev
= bdget(MKDEV(DRBD_MAJOR
, minor
));
2724 /* we have no partitions. we contain only ourselves. */
2725 mdev
->this_bdev
->bd_contains
= mdev
->this_bdev
;
2727 q
->backing_dev_info
.congested_fn
= drbd_congested
;
2728 q
->backing_dev_info
.congested_data
= mdev
;
2730 blk_queue_make_request(q
, drbd_make_request
);
2731 /* Setting the max_hw_sectors to an odd value of 8kibyte here
2732 This triggers a max_bio_size message upon first attach or connect */
2733 blk_queue_max_hw_sectors(q
, DRBD_MAX_BIO_SIZE_SAFE
>> 8);
2734 blk_queue_bounce_limit(q
, BLK_BOUNCE_ANY
);
2735 blk_queue_merge_bvec(q
, drbd_merge_bvec
);
2736 q
->queue_lock
= &mdev
->tconn
->req_lock
; /* needed since we use */
2738 mdev
->md_io_page
= alloc_page(GFP_KERNEL
);
2739 if (!mdev
->md_io_page
)
2740 goto out_no_io_page
;
2742 if (drbd_bm_init(mdev
))
2744 mdev
->read_requests
= RB_ROOT
;
2745 mdev
->write_requests
= RB_ROOT
;
2747 mdev
->current_epoch
= kzalloc(sizeof(struct drbd_epoch
), GFP_KERNEL
);
2748 if (!mdev
->current_epoch
)
2751 INIT_LIST_HEAD(&mdev
->current_epoch
->list
);
2754 if (!idr_pre_get(&minors
, GFP_KERNEL
))
2755 goto out_no_minor_idr
;
2756 if (idr_get_new_above(&minors
, mdev
, minor
, &minor_got
))
2757 goto out_no_minor_idr
;
2758 if (minor_got
!= minor
) {
2759 err
= ERR_MINOR_EXISTS
;
2760 drbd_msg_put_info("requested minor exists already");
2761 goto out_idr_remove_minor
;
2764 if (!idr_pre_get(&tconn
->volumes
, GFP_KERNEL
))
2765 goto out_idr_remove_minor
;
2766 if (idr_get_new_above(&tconn
->volumes
, mdev
, vnr
, &vnr_got
))
2767 goto out_idr_remove_minor
;
2768 if (vnr_got
!= vnr
) {
2769 err
= ERR_INVALID_REQUEST
;
2770 drbd_msg_put_info("requested volume exists already");
2771 goto out_idr_remove_vol
;
2774 kref_init(&mdev
->kref
); /* one ref for both idrs and the the add_disk */
2776 /* inherit the connection state */
2777 mdev
->state
.conn
= tconn
->cstate
;
2778 if (mdev
->state
.conn
== C_WF_REPORT_PARAMS
)
2779 drbd_connected(mdev
);
2784 idr_remove(&tconn
->volumes
, vnr_got
);
2785 out_idr_remove_minor
:
2786 idr_remove(&minors
, minor_got
);
2789 kfree(mdev
->current_epoch
);
2791 drbd_bm_cleanup(mdev
);
2793 __free_page(mdev
->md_io_page
);
2797 blk_cleanup_queue(q
);
2800 kref_put(&tconn
->kref
, &conn_destroy
);
2804 int __init
drbd_init(void)
2808 if (minor_count
< DRBD_MINOR_COUNT_MIN
|| minor_count
> DRBD_MINOR_COUNT_MAX
) {
2810 "drbd: invalid minor_count (%d)\n", minor_count
);
2814 minor_count
= DRBD_MINOR_COUNT_DEF
;
2818 err
= register_blkdev(DRBD_MAJOR
, "drbd");
2821 "drbd: unable to register block device major %d\n",
2826 err
= drbd_genl_register();
2828 printk(KERN_ERR
"drbd: unable to register generic netlink family\n");
2833 register_reboot_notifier(&drbd_notifier
);
2836 * allocate all necessary structs
2840 init_waitqueue_head(&drbd_pp_wait
);
2842 drbd_proc
= NULL
; /* play safe for drbd_cleanup */
2845 err
= drbd_create_mempools();
2849 drbd_proc
= proc_create_data("drbd", S_IFREG
| S_IRUGO
, NULL
, &drbd_proc_fops
, NULL
);
2851 printk(KERN_ERR
"drbd: unable to register proc file\n");
2855 rwlock_init(&global_state_lock
);
2856 INIT_LIST_HEAD(&drbd_tconns
);
2858 printk(KERN_INFO
"drbd: initialized. "
2859 "Version: " REL_VERSION
" (api:%d/proto:%d-%d)\n",
2860 API_VERSION
, PRO_VERSION_MIN
, PRO_VERSION_MAX
);
2861 printk(KERN_INFO
"drbd: %s\n", drbd_buildtag());
2862 printk(KERN_INFO
"drbd: registered as block device major %d\n",
2865 return 0; /* Success! */
2870 /* currently always the case */
2871 printk(KERN_ERR
"drbd: ran out of memory\n");
2873 printk(KERN_ERR
"drbd: initialization failure\n");
2877 void drbd_free_bc(struct drbd_backing_dev
*ldev
)
2882 blkdev_put(ldev
->backing_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
2883 blkdev_put(ldev
->md_bdev
, FMODE_READ
| FMODE_WRITE
| FMODE_EXCL
);
2888 void drbd_free_sock(struct drbd_tconn
*tconn
)
2890 if (tconn
->data
.socket
) {
2891 mutex_lock(&tconn
->data
.mutex
);
2892 kernel_sock_shutdown(tconn
->data
.socket
, SHUT_RDWR
);
2893 sock_release(tconn
->data
.socket
);
2894 tconn
->data
.socket
= NULL
;
2895 mutex_unlock(&tconn
->data
.mutex
);
2897 if (tconn
->meta
.socket
) {
2898 mutex_lock(&tconn
->meta
.mutex
);
2899 kernel_sock_shutdown(tconn
->meta
.socket
, SHUT_RDWR
);
2900 sock_release(tconn
->meta
.socket
);
2901 tconn
->meta
.socket
= NULL
;
2902 mutex_unlock(&tconn
->meta
.mutex
);
2906 /* meta data management */
2908 struct meta_data_on_disk
{
2909 u64 la_size
; /* last agreed size. */
2910 u64 uuid
[UI_SIZE
]; /* UUIDs. */
2913 u32 flags
; /* MDF */
2916 u32 al_offset
; /* offset to this block */
2917 u32 al_nr_extents
; /* important for restoring the AL */
2918 /* `-- act_log->nr_elements <-- ldev->dc.al_extents */
2919 u32 bm_offset
; /* offset to the bitmap, from here */
2920 u32 bm_bytes_per_bit
; /* BM_BLOCK_SIZE */
2921 u32 la_peer_max_bio_size
; /* last peer max_bio_size */
2922 u32 reserved_u32
[3];
2927 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
2928 * @mdev: DRBD device.
2930 void drbd_md_sync(struct drbd_conf
*mdev
)
2932 struct meta_data_on_disk
*buffer
;
2936 del_timer(&mdev
->md_sync_timer
);
2937 /* timer may be rearmed by drbd_md_mark_dirty() now. */
2938 if (!test_and_clear_bit(MD_DIRTY
, &mdev
->flags
))
2941 /* We use here D_FAILED and not D_ATTACHING because we try to write
2942 * metadata even if we detach due to a disk failure! */
2943 if (!get_ldev_if_state(mdev
, D_FAILED
))
2946 buffer
= drbd_md_get_buffer(mdev
);
2950 memset(buffer
, 0, 512);
2952 buffer
->la_size
= cpu_to_be64(drbd_get_capacity(mdev
->this_bdev
));
2953 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
2954 buffer
->uuid
[i
] = cpu_to_be64(mdev
->ldev
->md
.uuid
[i
]);
2955 buffer
->flags
= cpu_to_be32(mdev
->ldev
->md
.flags
);
2956 buffer
->magic
= cpu_to_be32(DRBD_MD_MAGIC_84_UNCLEAN
);
2958 buffer
->md_size_sect
= cpu_to_be32(mdev
->ldev
->md
.md_size_sect
);
2959 buffer
->al_offset
= cpu_to_be32(mdev
->ldev
->md
.al_offset
);
2960 buffer
->al_nr_extents
= cpu_to_be32(mdev
->act_log
->nr_elements
);
2961 buffer
->bm_bytes_per_bit
= cpu_to_be32(BM_BLOCK_SIZE
);
2962 buffer
->device_uuid
= cpu_to_be64(mdev
->ldev
->md
.device_uuid
);
2964 buffer
->bm_offset
= cpu_to_be32(mdev
->ldev
->md
.bm_offset
);
2965 buffer
->la_peer_max_bio_size
= cpu_to_be32(mdev
->peer_max_bio_size
);
2967 D_ASSERT(drbd_md_ss__(mdev
, mdev
->ldev
) == mdev
->ldev
->md
.md_offset
);
2968 sector
= mdev
->ldev
->md
.md_offset
;
2970 if (drbd_md_sync_page_io(mdev
, mdev
->ldev
, sector
, WRITE
)) {
2971 /* this was a try anyways ... */
2972 dev_err(DEV
, "meta data update failed!\n");
2973 drbd_chk_io_error(mdev
, 1, true);
2976 /* Update mdev->ldev->md.la_size_sect,
2977 * since we updated it on metadata. */
2978 mdev
->ldev
->md
.la_size_sect
= drbd_get_capacity(mdev
->this_bdev
);
2980 drbd_md_put_buffer(mdev
);
2986 * drbd_md_read() - Reads in the meta data super block
2987 * @mdev: DRBD device.
2988 * @bdev: Device from which the meta data should be read in.
2990 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
2991 * something goes wrong.
2993 int drbd_md_read(struct drbd_conf
*mdev
, struct drbd_backing_dev
*bdev
)
2995 struct meta_data_on_disk
*buffer
;
2997 int i
, rv
= NO_ERROR
;
2999 if (!get_ldev_if_state(mdev
, D_ATTACHING
))
3000 return ERR_IO_MD_DISK
;
3002 buffer
= drbd_md_get_buffer(mdev
);
3006 if (drbd_md_sync_page_io(mdev
, bdev
, bdev
->md
.md_offset
, READ
)) {
3007 /* NOTE: can't do normal error processing here as this is
3008 called BEFORE disk is attached */
3009 dev_err(DEV
, "Error while reading metadata.\n");
3010 rv
= ERR_IO_MD_DISK
;
3014 magic
= be32_to_cpu(buffer
->magic
);
3015 flags
= be32_to_cpu(buffer
->flags
);
3016 if (magic
== DRBD_MD_MAGIC_84_UNCLEAN
||
3017 (magic
== DRBD_MD_MAGIC_08
&& !(flags
& MDF_AL_CLEAN
))) {
3018 /* btw: that's Activity Log clean, not "all" clean. */
3019 dev_err(DEV
, "Found unclean meta data. Did you \"drbdadm apply-al\"?\n");
3020 rv
= ERR_MD_UNCLEAN
;
3023 if (magic
!= DRBD_MD_MAGIC_08
) {
3024 if (magic
== DRBD_MD_MAGIC_07
)
3025 dev_err(DEV
, "Found old (0.7) meta data magic. Did you \"drbdadm create-md\"?\n");
3027 dev_err(DEV
, "Meta data magic not found. Did you \"drbdadm create-md\"?\n");
3028 rv
= ERR_MD_INVALID
;
3031 if (be32_to_cpu(buffer
->al_offset
) != bdev
->md
.al_offset
) {
3032 dev_err(DEV
, "unexpected al_offset: %d (expected %d)\n",
3033 be32_to_cpu(buffer
->al_offset
), bdev
->md
.al_offset
);
3034 rv
= ERR_MD_INVALID
;
3037 if (be32_to_cpu(buffer
->bm_offset
) != bdev
->md
.bm_offset
) {
3038 dev_err(DEV
, "unexpected bm_offset: %d (expected %d)\n",
3039 be32_to_cpu(buffer
->bm_offset
), bdev
->md
.bm_offset
);
3040 rv
= ERR_MD_INVALID
;
3043 if (be32_to_cpu(buffer
->md_size_sect
) != bdev
->md
.md_size_sect
) {
3044 dev_err(DEV
, "unexpected md_size: %u (expected %u)\n",
3045 be32_to_cpu(buffer
->md_size_sect
), bdev
->md
.md_size_sect
);
3046 rv
= ERR_MD_INVALID
;
3050 if (be32_to_cpu(buffer
->bm_bytes_per_bit
) != BM_BLOCK_SIZE
) {
3051 dev_err(DEV
, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3052 be32_to_cpu(buffer
->bm_bytes_per_bit
), BM_BLOCK_SIZE
);
3053 rv
= ERR_MD_INVALID
;
3057 bdev
->md
.la_size_sect
= be64_to_cpu(buffer
->la_size
);
3058 for (i
= UI_CURRENT
; i
< UI_SIZE
; i
++)
3059 bdev
->md
.uuid
[i
] = be64_to_cpu(buffer
->uuid
[i
]);
3060 bdev
->md
.flags
= be32_to_cpu(buffer
->flags
);
3061 bdev
->md
.device_uuid
= be64_to_cpu(buffer
->device_uuid
);
3063 spin_lock_irq(&mdev
->tconn
->req_lock
);
3064 if (mdev
->state
.conn
< C_CONNECTED
) {
3066 peer
= be32_to_cpu(buffer
->la_peer_max_bio_size
);
3067 peer
= max_t(int, peer
, DRBD_MAX_BIO_SIZE_SAFE
);
3068 mdev
->peer_max_bio_size
= peer
;
3070 spin_unlock_irq(&mdev
->tconn
->req_lock
);
3073 drbd_md_put_buffer(mdev
);
3081 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3082 * @mdev: DRBD device.
3084 * Call this function if you change anything that should be written to
3085 * the meta-data super block. This function sets MD_DIRTY, and starts a
3086 * timer that ensures that within five seconds you have to call drbd_md_sync().
3089 void drbd_md_mark_dirty_(struct drbd_conf
*mdev
, unsigned int line
, const char *func
)
3091 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
)) {
3092 mod_timer(&mdev
->md_sync_timer
, jiffies
+ HZ
);
3093 mdev
->last_md_mark_dirty
.line
= line
;
3094 mdev
->last_md_mark_dirty
.func
= func
;
3098 void drbd_md_mark_dirty(struct drbd_conf
*mdev
)
3100 if (!test_and_set_bit(MD_DIRTY
, &mdev
->flags
))
3101 mod_timer(&mdev
->md_sync_timer
, jiffies
+ 5*HZ
);
3105 static void drbd_uuid_move_history(struct drbd_conf
*mdev
) __must_hold(local
)
3109 for (i
= UI_HISTORY_START
; i
< UI_HISTORY_END
; i
++)
3110 mdev
->ldev
->md
.uuid
[i
+1] = mdev
->ldev
->md
.uuid
[i
];
3113 void _drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3115 if (idx
== UI_CURRENT
) {
3116 if (mdev
->state
.role
== R_PRIMARY
)
3121 drbd_set_ed_uuid(mdev
, val
);
3124 mdev
->ldev
->md
.uuid
[idx
] = val
;
3125 drbd_md_mark_dirty(mdev
);
3129 void drbd_uuid_set(struct drbd_conf
*mdev
, int idx
, u64 val
) __must_hold(local
)
3131 if (mdev
->ldev
->md
.uuid
[idx
]) {
3132 drbd_uuid_move_history(mdev
);
3133 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[idx
];
3135 _drbd_uuid_set(mdev
, idx
, val
);
3139 * drbd_uuid_new_current() - Creates a new current UUID
3140 * @mdev: DRBD device.
3142 * Creates a new current UUID, and rotates the old current UUID into
3143 * the bitmap slot. Causes an incremental resync upon next connect.
3145 void drbd_uuid_new_current(struct drbd_conf
*mdev
) __must_hold(local
)
3148 unsigned long long bm_uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3151 dev_warn(DEV
, "bm UUID was already set: %llX\n", bm_uuid
);
3153 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = mdev
->ldev
->md
.uuid
[UI_CURRENT
];
3155 get_random_bytes(&val
, sizeof(u64
));
3156 _drbd_uuid_set(mdev
, UI_CURRENT
, val
);
3157 drbd_print_uuids(mdev
, "new current UUID");
3158 /* get it to stable storage _now_ */
3162 void drbd_uuid_set_bm(struct drbd_conf
*mdev
, u64 val
) __must_hold(local
)
3164 if (mdev
->ldev
->md
.uuid
[UI_BITMAP
] == 0 && val
== 0)
3168 drbd_uuid_move_history(mdev
);
3169 mdev
->ldev
->md
.uuid
[UI_HISTORY_START
] = mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3170 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = 0;
3172 unsigned long long bm_uuid
= mdev
->ldev
->md
.uuid
[UI_BITMAP
];
3174 dev_warn(DEV
, "bm UUID was already set: %llX\n", bm_uuid
);
3176 mdev
->ldev
->md
.uuid
[UI_BITMAP
] = val
& ~((u64
)1);
3178 drbd_md_mark_dirty(mdev
);
3182 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3183 * @mdev: DRBD device.
3185 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3187 int drbd_bmio_set_n_write(struct drbd_conf
*mdev
)
3191 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
3192 drbd_md_set_flag(mdev
, MDF_FULL_SYNC
);
3194 drbd_bm_set_all(mdev
);
3196 rv
= drbd_bm_write(mdev
);
3199 drbd_md_clear_flag(mdev
, MDF_FULL_SYNC
);
3210 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3211 * @mdev: DRBD device.
3213 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3215 int drbd_bmio_clear_n_write(struct drbd_conf
*mdev
)
3219 drbd_resume_al(mdev
);
3220 if (get_ldev_if_state(mdev
, D_ATTACHING
)) {
3221 drbd_bm_clear_all(mdev
);
3222 rv
= drbd_bm_write(mdev
);
3229 static int w_bitmap_io(struct drbd_work
*w
, int unused
)
3231 struct bm_io_work
*work
= container_of(w
, struct bm_io_work
, w
);
3232 struct drbd_conf
*mdev
= w
->mdev
;
3235 D_ASSERT(atomic_read(&mdev
->ap_bio_cnt
) == 0);
3237 if (get_ldev(mdev
)) {
3238 drbd_bm_lock(mdev
, work
->why
, work
->flags
);
3239 rv
= work
->io_fn(mdev
);
3240 drbd_bm_unlock(mdev
);
3244 clear_bit_unlock(BITMAP_IO
, &mdev
->flags
);
3245 wake_up(&mdev
->misc_wait
);
3248 work
->done(mdev
, rv
);
3250 clear_bit(BITMAP_IO_QUEUED
, &mdev
->flags
);
3257 void drbd_ldev_destroy(struct drbd_conf
*mdev
)
3259 lc_destroy(mdev
->resync
);
3260 mdev
->resync
= NULL
;
3261 lc_destroy(mdev
->act_log
);
3262 mdev
->act_log
= NULL
;
3264 drbd_free_bc(mdev
->ldev
);
3265 mdev
->ldev
= NULL
;);
3267 clear_bit(GO_DISKLESS
, &mdev
->flags
);
3270 static int w_go_diskless(struct drbd_work
*w
, int unused
)
3272 struct drbd_conf
*mdev
= w
->mdev
;
3274 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
3275 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
3276 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
3277 * the protected members anymore, though, so once put_ldev reaches zero
3278 * again, it will be safe to free them. */
3279 drbd_force_state(mdev
, NS(disk
, D_DISKLESS
));
3283 void drbd_go_diskless(struct drbd_conf
*mdev
)
3285 D_ASSERT(mdev
->state
.disk
== D_FAILED
);
3286 if (!test_and_set_bit(GO_DISKLESS
, &mdev
->flags
))
3287 drbd_queue_work(&mdev
->tconn
->data
.work
, &mdev
->go_diskless
);
3291 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3292 * @mdev: DRBD device.
3293 * @io_fn: IO callback to be called when bitmap IO is possible
3294 * @done: callback to be called after the bitmap IO was performed
3295 * @why: Descriptive text of the reason for doing the IO
3297 * While IO on the bitmap happens we freeze application IO thus we ensure
3298 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3299 * called from worker context. It MUST NOT be used while a previous such
3300 * work is still pending!
3302 void drbd_queue_bitmap_io(struct drbd_conf
*mdev
,
3303 int (*io_fn
)(struct drbd_conf
*),
3304 void (*done
)(struct drbd_conf
*, int),
3305 char *why
, enum bm_flag flags
)
3307 D_ASSERT(current
== mdev
->tconn
->worker
.task
);
3309 D_ASSERT(!test_bit(BITMAP_IO_QUEUED
, &mdev
->flags
));
3310 D_ASSERT(!test_bit(BITMAP_IO
, &mdev
->flags
));
3311 D_ASSERT(list_empty(&mdev
->bm_io_work
.w
.list
));
3312 if (mdev
->bm_io_work
.why
)
3313 dev_err(DEV
, "FIXME going to queue '%s' but '%s' still pending?\n",
3314 why
, mdev
->bm_io_work
.why
);
3316 mdev
->bm_io_work
.io_fn
= io_fn
;
3317 mdev
->bm_io_work
.done
= done
;
3318 mdev
->bm_io_work
.why
= why
;
3319 mdev
->bm_io_work
.flags
= flags
;
3321 spin_lock_irq(&mdev
->tconn
->req_lock
);
3322 set_bit(BITMAP_IO
, &mdev
->flags
);
3323 if (atomic_read(&mdev
->ap_bio_cnt
) == 0) {
3324 if (!test_and_set_bit(BITMAP_IO_QUEUED
, &mdev
->flags
))
3325 drbd_queue_work(&mdev
->tconn
->data
.work
, &mdev
->bm_io_work
.w
);
3327 spin_unlock_irq(&mdev
->tconn
->req_lock
);
3331 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3332 * @mdev: DRBD device.
3333 * @io_fn: IO callback to be called when bitmap IO is possible
3334 * @why: Descriptive text of the reason for doing the IO
3336 * freezes application IO while that the actual IO operations runs. This
3337 * functions MAY NOT be called from worker context.
3339 int drbd_bitmap_io(struct drbd_conf
*mdev
, int (*io_fn
)(struct drbd_conf
*),
3340 char *why
, enum bm_flag flags
)
3344 D_ASSERT(current
!= mdev
->tconn
->worker
.task
);
3346 if ((flags
& BM_LOCKED_SET_ALLOWED
) == 0)
3347 drbd_suspend_io(mdev
);
3349 drbd_bm_lock(mdev
, why
, flags
);
3351 drbd_bm_unlock(mdev
);
3353 if ((flags
& BM_LOCKED_SET_ALLOWED
) == 0)
3354 drbd_resume_io(mdev
);
3359 void drbd_md_set_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
3361 if ((mdev
->ldev
->md
.flags
& flag
) != flag
) {
3362 drbd_md_mark_dirty(mdev
);
3363 mdev
->ldev
->md
.flags
|= flag
;
3367 void drbd_md_clear_flag(struct drbd_conf
*mdev
, int flag
) __must_hold(local
)
3369 if ((mdev
->ldev
->md
.flags
& flag
) != 0) {
3370 drbd_md_mark_dirty(mdev
);
3371 mdev
->ldev
->md
.flags
&= ~flag
;
3374 int drbd_md_test_flag(struct drbd_backing_dev
*bdev
, int flag
)
3376 return (bdev
->md
.flags
& flag
) != 0;
3379 static void md_sync_timer_fn(unsigned long data
)
3381 struct drbd_conf
*mdev
= (struct drbd_conf
*) data
;
3383 drbd_queue_work_front(&mdev
->tconn
->data
.work
, &mdev
->md_sync_work
);
3386 static int w_md_sync(struct drbd_work
*w
, int unused
)
3388 struct drbd_conf
*mdev
= w
->mdev
;
3390 dev_warn(DEV
, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
3392 dev_warn(DEV
, "last md_mark_dirty: %s:%u\n",
3393 mdev
->last_md_mark_dirty
.func
, mdev
->last_md_mark_dirty
.line
);
3399 const char *cmdname(enum drbd_packet cmd
)
3401 /* THINK may need to become several global tables
3402 * when we want to support more than
3403 * one PRO_VERSION */
3404 static const char *cmdnames
[] = {
3406 [P_DATA_REPLY
] = "DataReply",
3407 [P_RS_DATA_REPLY
] = "RSDataReply",
3408 [P_BARRIER
] = "Barrier",
3409 [P_BITMAP
] = "ReportBitMap",
3410 [P_BECOME_SYNC_TARGET
] = "BecomeSyncTarget",
3411 [P_BECOME_SYNC_SOURCE
] = "BecomeSyncSource",
3412 [P_UNPLUG_REMOTE
] = "UnplugRemote",
3413 [P_DATA_REQUEST
] = "DataRequest",
3414 [P_RS_DATA_REQUEST
] = "RSDataRequest",
3415 [P_SYNC_PARAM
] = "SyncParam",
3416 [P_SYNC_PARAM89
] = "SyncParam89",
3417 [P_PROTOCOL
] = "ReportProtocol",
3418 [P_UUIDS
] = "ReportUUIDs",
3419 [P_SIZES
] = "ReportSizes",
3420 [P_STATE
] = "ReportState",
3421 [P_SYNC_UUID
] = "ReportSyncUUID",
3422 [P_AUTH_CHALLENGE
] = "AuthChallenge",
3423 [P_AUTH_RESPONSE
] = "AuthResponse",
3425 [P_PING_ACK
] = "PingAck",
3426 [P_RECV_ACK
] = "RecvAck",
3427 [P_WRITE_ACK
] = "WriteAck",
3428 [P_RS_WRITE_ACK
] = "RSWriteAck",
3429 [P_DISCARD_WRITE
] = "DiscardWrite",
3430 [P_NEG_ACK
] = "NegAck",
3431 [P_NEG_DREPLY
] = "NegDReply",
3432 [P_NEG_RS_DREPLY
] = "NegRSDReply",
3433 [P_BARRIER_ACK
] = "BarrierAck",
3434 [P_STATE_CHG_REQ
] = "StateChgRequest",
3435 [P_STATE_CHG_REPLY
] = "StateChgReply",
3436 [P_OV_REQUEST
] = "OVRequest",
3437 [P_OV_REPLY
] = "OVReply",
3438 [P_OV_RESULT
] = "OVResult",
3439 [P_CSUM_RS_REQUEST
] = "CsumRSRequest",
3440 [P_RS_IS_IN_SYNC
] = "CsumRSIsInSync",
3441 [P_COMPRESSED_BITMAP
] = "CBitmap",
3442 [P_DELAY_PROBE
] = "DelayProbe",
3443 [P_OUT_OF_SYNC
] = "OutOfSync",
3444 [P_RETRY_WRITE
] = "RetryWrite",
3445 [P_RS_CANCEL
] = "RSCancel",
3446 [P_CONN_ST_CHG_REQ
] = "conn_st_chg_req",
3447 [P_CONN_ST_CHG_REPLY
] = "conn_st_chg_reply",
3448 [P_RETRY_WRITE
] = "retry_write",
3449 [P_PROTOCOL_UPDATE
] = "protocol_update",
3451 /* enum drbd_packet, but not commands - obsoleted flags:
3457 /* too big for the array: 0xfffX */
3458 if (cmd
== P_INITIAL_META
)
3459 return "InitialMeta";
3460 if (cmd
== P_INITIAL_DATA
)
3461 return "InitialData";
3462 if (cmd
== P_CONNECTION_FEATURES
)
3463 return "ConnectionFeatures";
3464 if (cmd
>= ARRAY_SIZE(cmdnames
))
3466 return cmdnames
[cmd
];
3470 * drbd_wait_misc - wait for a request to make progress
3471 * @mdev: device associated with the request
3472 * @i: the struct drbd_interval embedded in struct drbd_request or
3473 * struct drbd_peer_request
3475 int drbd_wait_misc(struct drbd_conf
*mdev
, struct drbd_interval
*i
)
3477 struct net_conf
*nc
;
3482 nc
= rcu_dereference(mdev
->tconn
->net_conf
);
3487 timeout
= nc
->ko_count
? nc
->timeout
* HZ
/ 10 * nc
->ko_count
: MAX_SCHEDULE_TIMEOUT
;
3490 /* Indicate to wake up mdev->misc_wait on progress. */
3492 prepare_to_wait(&mdev
->misc_wait
, &wait
, TASK_INTERRUPTIBLE
);
3493 spin_unlock_irq(&mdev
->tconn
->req_lock
);
3494 timeout
= schedule_timeout(timeout
);
3495 finish_wait(&mdev
->misc_wait
, &wait
);
3496 spin_lock_irq(&mdev
->tconn
->req_lock
);
3497 if (!timeout
|| mdev
->state
.conn
< C_CONNECTED
)
3499 if (signal_pending(current
))
3500 return -ERESTARTSYS
;
3504 #ifdef CONFIG_DRBD_FAULT_INJECTION
3505 /* Fault insertion support including random number generator shamelessly
3506 * stolen from kernel/rcutorture.c */
3507 struct fault_random_state
{
3508 unsigned long state
;
3509 unsigned long count
;
3512 #define FAULT_RANDOM_MULT 39916801 /* prime */
3513 #define FAULT_RANDOM_ADD 479001701 /* prime */
3514 #define FAULT_RANDOM_REFRESH 10000
3517 * Crude but fast random-number generator. Uses a linear congruential
3518 * generator, with occasional help from get_random_bytes().
3520 static unsigned long
3521 _drbd_fault_random(struct fault_random_state
*rsp
)
3525 if (!rsp
->count
--) {
3526 get_random_bytes(&refresh
, sizeof(refresh
));
3527 rsp
->state
+= refresh
;
3528 rsp
->count
= FAULT_RANDOM_REFRESH
;
3530 rsp
->state
= rsp
->state
* FAULT_RANDOM_MULT
+ FAULT_RANDOM_ADD
;
3531 return swahw32(rsp
->state
);
3535 _drbd_fault_str(unsigned int type
) {
3536 static char *_faults
[] = {
3537 [DRBD_FAULT_MD_WR
] = "Meta-data write",
3538 [DRBD_FAULT_MD_RD
] = "Meta-data read",
3539 [DRBD_FAULT_RS_WR
] = "Resync write",
3540 [DRBD_FAULT_RS_RD
] = "Resync read",
3541 [DRBD_FAULT_DT_WR
] = "Data write",
3542 [DRBD_FAULT_DT_RD
] = "Data read",
3543 [DRBD_FAULT_DT_RA
] = "Data read ahead",
3544 [DRBD_FAULT_BM_ALLOC
] = "BM allocation",
3545 [DRBD_FAULT_AL_EE
] = "EE allocation",
3546 [DRBD_FAULT_RECEIVE
] = "receive data corruption",
3549 return (type
< DRBD_FAULT_MAX
) ? _faults
[type
] : "**Unknown**";
3553 _drbd_insert_fault(struct drbd_conf
*mdev
, unsigned int type
)
3555 static struct fault_random_state rrs
= {0, 0};
3557 unsigned int ret
= (
3559 ((1 << mdev_to_minor(mdev
)) & fault_devs
) != 0) &&
3560 (((_drbd_fault_random(&rrs
) % 100) + 1) <= fault_rate
));
3565 if (__ratelimit(&drbd_ratelimit_state
))
3566 dev_warn(DEV
, "***Simulating %s failure\n",
3567 _drbd_fault_str(type
));
3574 const char *drbd_buildtag(void)
3576 /* DRBD built from external sources has here a reference to the
3577 git hash of the source code. */
3579 static char buildtag
[38] = "\0uilt-in";
3581 if (buildtag
[0] == 0) {
3582 #ifdef CONFIG_MODULES
3583 if (THIS_MODULE
!= NULL
)
3584 sprintf(buildtag
, "srcversion: %-24s", THIS_MODULE
->srcversion
);
3593 module_init(drbd_init
)
3594 module_exit(drbd_cleanup
)
3596 EXPORT_SYMBOL(drbd_conn_str
);
3597 EXPORT_SYMBOL(drbd_role_str
);
3598 EXPORT_SYMBOL(drbd_disk_str
);
3599 EXPORT_SYMBOL(drbd_set_st_err_str
);