]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/block/drbd/drbd_main.c
drbd: drbd_send_b_ack(): Return void: the result is never used
[mirror_ubuntu-artful-kernel.git] / drivers / block / drbd / drbd_main.c
CommitLineData
b411b363
PR
1/*
2 drbd.c
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 Thanks to Carter Burden, Bart Grantham and Gennadiy Nerubayev
11 from Logicworks, Inc. for making SDP replication support possible.
12
13 drbd is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
16 any later version.
17
18 drbd is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with drbd; see the file COPYING. If not, write to
25 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26
27 */
28
b411b363 29#include <linux/module.h>
b411b363
PR
30#include <linux/drbd.h>
31#include <asm/uaccess.h>
32#include <asm/types.h>
33#include <net/sock.h>
34#include <linux/ctype.h>
2a48fc0a 35#include <linux/mutex.h>
b411b363
PR
36#include <linux/fs.h>
37#include <linux/file.h>
38#include <linux/proc_fs.h>
39#include <linux/init.h>
40#include <linux/mm.h>
41#include <linux/memcontrol.h>
42#include <linux/mm_inline.h>
43#include <linux/slab.h>
44#include <linux/random.h>
45#include <linux/reboot.h>
46#include <linux/notifier.h>
47#include <linux/kthread.h>
48
49#define __KERNEL_SYSCALLS__
50#include <linux/unistd.h>
51#include <linux/vmalloc.h>
52
53#include <linux/drbd_limits.h>
54#include "drbd_int.h"
b411b363
PR
55#include "drbd_req.h" /* only for _req_mod in tl_release and tl_clear */
56
57#include "drbd_vli.h"
58
2a48fc0a 59static DEFINE_MUTEX(drbd_main_mutex);
b411b363
PR
60int drbdd_init(struct drbd_thread *);
61int drbd_worker(struct drbd_thread *);
62int drbd_asender(struct drbd_thread *);
63
64int drbd_init(void);
65static int drbd_open(struct block_device *bdev, fmode_t mode);
66static int drbd_release(struct gendisk *gd, fmode_t mode);
00d56944 67static int w_md_sync(struct drbd_work *w, int unused);
b411b363 68static void md_sync_timer_fn(unsigned long data);
00d56944
PR
69static int w_bitmap_io(struct drbd_work *w, int unused);
70static int w_go_diskless(struct drbd_work *w, int unused);
b411b363 71
b411b363
PR
72MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
73 "Lars Ellenberg <lars@linbit.com>");
74MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
75MODULE_VERSION(REL_VERSION);
76MODULE_LICENSE("GPL");
81a5d60e 77MODULE_PARM_DESC(minor_count, "Approximate number of drbd devices ("
2b8a90b5 78 __stringify(DRBD_MINOR_COUNT_MIN) "-" __stringify(DRBD_MINOR_COUNT_MAX) ")");
b411b363
PR
79MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
80
81#include <linux/moduleparam.h>
82/* allow_open_on_secondary */
83MODULE_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 */
86module_param(minor_count, uint, 0444);
87module_param(disable_sendpage, bool, 0644);
88module_param(allow_oos, bool, 0);
b411b363
PR
89module_param(proc_details, int, 0644);
90
91#ifdef CONFIG_DRBD_FAULT_INJECTION
92int enable_faults;
93int fault_rate;
94static int fault_count;
95int fault_devs;
96/* bitmap of enabled faults */
97module_param(enable_faults, int, 0664);
98/* fault rate % value - applies to all enabled faults */
99module_param(fault_rate, int, 0664);
100/* count of faults inserted */
101module_param(fault_count, int, 0664);
102/* bitmap of devices to insert faults on */
103module_param(fault_devs, int, 0644);
104#endif
105
106/* module parameter, defined */
2b8a90b5 107unsigned int minor_count = DRBD_MINOR_COUNT_DEF;
b411b363
PR
108int disable_sendpage;
109int allow_oos;
b411b363
PR
110int proc_details; /* Detail level in proc drbd*/
111
112/* Module parameter for setting the user mode helper program
113 * to run. Default is /sbin/drbdadm */
114char usermode_helper[80] = "/sbin/drbdadm";
115
116module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
117
118/* in 2.6.x, our device mapping and config info contains our virtual gendisks
119 * as member "struct gendisk *vdisk;"
120 */
81a5d60e 121struct idr minors;
2111438b 122struct list_head drbd_tconns; /* list of struct drbd_tconn */
543cc10b 123DEFINE_MUTEX(drbd_cfg_mutex);
b411b363
PR
124
125struct kmem_cache *drbd_request_cache;
6c852bec 126struct kmem_cache *drbd_ee_cache; /* peer requests */
b411b363
PR
127struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
128struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
129mempool_t *drbd_request_mempool;
130mempool_t *drbd_ee_mempool;
35abf594 131mempool_t *drbd_md_io_page_pool;
da4a75d2 132struct bio_set *drbd_md_io_bio_set;
b411b363
PR
133
134/* I do not use a standard mempool, because:
135 1) I want to hand out the pre-allocated objects first.
136 2) I want to be able to interrupt sleeping allocation with a signal.
137 Note: This is a single linked list, the next pointer is the private
138 member of struct page.
139 */
140struct page *drbd_pp_pool;
141spinlock_t drbd_pp_lock;
142int drbd_pp_vacant;
143wait_queue_head_t drbd_pp_wait;
144
145DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
146
7d4e9d09 147static const struct block_device_operations drbd_ops = {
b411b363
PR
148 .owner = THIS_MODULE,
149 .open = drbd_open,
150 .release = drbd_release,
151};
152
da4a75d2
LE
153static void bio_destructor_drbd(struct bio *bio)
154{
155 bio_free(bio, drbd_md_io_bio_set);
156}
157
158struct bio *bio_alloc_drbd(gfp_t gfp_mask)
159{
160 struct bio *bio;
161
162 if (!drbd_md_io_bio_set)
163 return bio_alloc(gfp_mask, 1);
164
165 bio = bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
166 if (!bio)
167 return NULL;
168 bio->bi_destructor = bio_destructor_drbd;
169 return bio;
170}
171
b411b363
PR
172#ifdef __CHECKER__
173/* When checking with sparse, and this is an inline function, sparse will
174 give tons of false positives. When this is a real functions sparse works.
175 */
176int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
177{
178 int io_allowed;
179
180 atomic_inc(&mdev->local_cnt);
181 io_allowed = (mdev->state.disk >= mins);
182 if (!io_allowed) {
183 if (atomic_dec_and_test(&mdev->local_cnt))
184 wake_up(&mdev->misc_wait);
185 }
186 return io_allowed;
187}
188
189#endif
190
191/**
192 * DOC: The transfer log
193 *
194 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
87eeee41 195 * mdev->tconn->newest_tle points to the head, mdev->tconn->oldest_tle points to the tail
b411b363
PR
196 * of the list. There is always at least one &struct drbd_tl_epoch object.
197 *
198 * Each &struct drbd_tl_epoch has a circular double linked list of requests
199 * attached.
200 */
2f5cdd0b 201static int tl_init(struct drbd_tconn *tconn)
b411b363
PR
202{
203 struct drbd_tl_epoch *b;
204
205 /* during device minor initialization, we may well use GFP_KERNEL */
206 b = kmalloc(sizeof(struct drbd_tl_epoch), GFP_KERNEL);
207 if (!b)
208 return 0;
209 INIT_LIST_HEAD(&b->requests);
210 INIT_LIST_HEAD(&b->w.list);
211 b->next = NULL;
212 b->br_number = 4711;
7e602c0a 213 b->n_writes = 0;
b411b363
PR
214 b->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
215
2f5cdd0b
PR
216 tconn->oldest_tle = b;
217 tconn->newest_tle = b;
218 INIT_LIST_HEAD(&tconn->out_of_sequence_requests);
b411b363 219
b411b363
PR
220 return 1;
221}
222
2f5cdd0b 223static void tl_cleanup(struct drbd_tconn *tconn)
b411b363 224{
2f5cdd0b
PR
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;
d628769b
AG
233}
234
b411b363
PR
235/**
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.
239 *
240 * The caller must hold the req_lock.
241 */
2f5cdd0b 242void _tl_add_barrier(struct drbd_tconn *tconn, struct drbd_tl_epoch *new)
b411b363
PR
243{
244 struct drbd_tl_epoch *newest_before;
245
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 */
249 new->next = NULL;
7e602c0a 250 new->n_writes = 0;
b411b363 251
2f5cdd0b 252 newest_before = tconn->newest_tle;
b411b363
PR
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;
2f5cdd0b
PR
256 if (tconn->newest_tle != new) {
257 tconn->newest_tle->next = new;
258 tconn->newest_tle = new;
b411b363
PR
259 }
260}
261
262/**
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.
267 *
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
270 * of the connection.
271 */
2f5cdd0b
PR
272void tl_release(struct drbd_tconn *tconn, unsigned int barrier_nr,
273 unsigned int set_size)
b411b363 274{
2f5cdd0b 275 struct drbd_conf *mdev;
b411b363
PR
276 struct drbd_tl_epoch *b, *nob; /* next old barrier */
277 struct list_head *le, *tle;
278 struct drbd_request *r;
279
2f5cdd0b 280 spin_lock_irq(&tconn->req_lock);
b411b363 281
2f5cdd0b 282 b = tconn->oldest_tle;
b411b363
PR
283
284 /* first some paranoia code */
285 if (b == NULL) {
2f5cdd0b
PR
286 conn_err(tconn, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
287 barrier_nr);
b411b363
PR
288 goto bail;
289 }
290 if (b->br_number != barrier_nr) {
2f5cdd0b
PR
291 conn_err(tconn, "BAD! BarrierAck #%u received, expected #%u!\n",
292 barrier_nr, b->br_number);
b411b363
PR
293 goto bail;
294 }
7e602c0a 295 if (b->n_writes != set_size) {
2f5cdd0b
PR
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);
b411b363
PR
298 goto bail;
299 }
300
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);
8554df1c 304 _req_mod(r, BARRIER_ACKED);
b411b363
PR
305 }
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.
309
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
8554df1c 314 _req_mode(CONNECTION_LOST_WHILE_PENDING).
b411b363
PR
315
316 These have been list_move'd to the out_of_sequence_requests list in
8554df1c 317 _req_mod(, BARRIER_ACKED) above.
b411b363
PR
318 */
319 list_del_init(&b->requests);
2f5cdd0b 320 mdev = b->w.mdev;
b411b363
PR
321
322 nob = b->next;
323 if (test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) {
2f5cdd0b 324 _tl_add_barrier(tconn, b);
b411b363 325 if (nob)
2f5cdd0b 326 tconn->oldest_tle = nob;
b411b363 327 /* if nob == NULL b was the only barrier, and becomes the new
2f5cdd0b 328 barrier. Therefore tconn->oldest_tle points already to b */
b411b363
PR
329 } else {
330 D_ASSERT(nob != NULL);
2f5cdd0b 331 tconn->oldest_tle = nob;
b411b363
PR
332 kfree(b);
333 }
334
2f5cdd0b 335 spin_unlock_irq(&tconn->req_lock);
b411b363
PR
336 dec_ap_pending(mdev);
337
338 return;
339
340bail:
2f5cdd0b
PR
341 spin_unlock_irq(&tconn->req_lock);
342 conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
b411b363
PR
343}
344
617049aa 345
b411b363 346/**
11b58e73 347 * _tl_restart() - Walks the transfer log, and applies an action to all requests
b411b363 348 * @mdev: DRBD device.
11b58e73 349 * @what: The action/event to perform with all request objects
b411b363 350 *
8554df1c
AG
351 * @what might be one of CONNECTION_LOST_WHILE_PENDING, RESEND, FAIL_FROZEN_DISK_IO,
352 * RESTART_FROZEN_DISK_IO.
b411b363 353 */
2f5cdd0b 354void _tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
b411b363 355{
11b58e73 356 struct drbd_tl_epoch *b, *tmp, **pn;
b9b98716 357 struct list_head *le, *tle, carry_reads;
11b58e73
PR
358 struct drbd_request *req;
359 int rv, n_writes, n_reads;
b411b363 360
2f5cdd0b
PR
361 b = tconn->oldest_tle;
362 pn = &tconn->oldest_tle;
b411b363 363 while (b) {
11b58e73
PR
364 n_writes = 0;
365 n_reads = 0;
b9b98716 366 INIT_LIST_HEAD(&carry_reads);
b411b363 367 list_for_each_safe(le, tle, &b->requests) {
11b58e73
PR
368 req = list_entry(le, struct drbd_request, tl_requests);
369 rv = _req_mod(req, what);
370
371 n_writes += (rv & MR_WRITE) >> MR_WRITE_SHIFT;
372 n_reads += (rv & MR_READ) >> MR_READ_SHIFT;
b411b363
PR
373 }
374 tmp = b->next;
375
b9b98716 376 if (n_writes) {
8554df1c 377 if (what == RESEND) {
11b58e73
PR
378 b->n_writes = n_writes;
379 if (b->w.cb == NULL) {
380 b->w.cb = w_send_barrier;
2f5cdd0b
PR
381 inc_ap_pending(b->w.mdev);
382 set_bit(CREATE_BARRIER, &b->w.mdev->flags);
11b58e73
PR
383 }
384
2f5cdd0b 385 drbd_queue_work(&tconn->data.work, &b->w);
11b58e73
PR
386 }
387 pn = &b->next;
388 } else {
b9b98716
PR
389 if (n_reads)
390 list_add(&carry_reads, &b->requests);
11b58e73
PR
391 /* there could still be requests on that ring list,
392 * in case local io is still pending */
393 list_del(&b->requests);
394
395 /* dec_ap_pending corresponding to queue_barrier.
396 * the newest barrier may not have been queued yet,
397 * in which case w.cb is still NULL. */
398 if (b->w.cb != NULL)
2f5cdd0b 399 dec_ap_pending(b->w.mdev);
11b58e73 400
2f5cdd0b 401 if (b == tconn->newest_tle) {
11b58e73 402 /* recycle, but reinit! */
2f5cdd0b
PR
403 if (tmp != NULL)
404 conn_err(tconn, "ASSERT FAILED tmp == NULL");
11b58e73 405 INIT_LIST_HEAD(&b->requests);
b9b98716 406 list_splice(&carry_reads, &b->requests);
11b58e73
PR
407 INIT_LIST_HEAD(&b->w.list);
408 b->w.cb = NULL;
409 b->br_number = net_random();
410 b->n_writes = 0;
411
412 *pn = b;
413 break;
414 }
415 *pn = tmp;
416 kfree(b);
b411b363 417 }
b411b363 418 b = tmp;
b9b98716 419 list_splice(&carry_reads, &b->requests);
b411b363 420 }
11b58e73
PR
421}
422
b411b363
PR
423
424/**
425 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
426 * @mdev: DRBD device.
427 *
428 * This is called after the connection to the peer was lost. The storage covered
429 * by the requests on the transfer gets marked as our of sync. Called from the
430 * receiver thread and the worker thread.
431 */
2f5cdd0b 432void tl_clear(struct drbd_tconn *tconn)
b411b363 433{
2f5cdd0b 434 struct drbd_conf *mdev;
b411b363
PR
435 struct list_head *le, *tle;
436 struct drbd_request *r;
e90285e0 437 int vnr;
b411b363 438
2f5cdd0b 439 spin_lock_irq(&tconn->req_lock);
b411b363 440
2f5cdd0b 441 _tl_restart(tconn, CONNECTION_LOST_WHILE_PENDING);
b411b363
PR
442
443 /* we expect this list to be empty. */
2f5cdd0b
PR
444 if (!list_empty(&tconn->out_of_sequence_requests))
445 conn_err(tconn, "ASSERT FAILED list_empty(&out_of_sequence_requests)\n");
b411b363
PR
446
447 /* but just in case, clean it up anyways! */
2f5cdd0b 448 list_for_each_safe(le, tle, &tconn->out_of_sequence_requests) {
b411b363
PR
449 r = list_entry(le, struct drbd_request, tl_requests);
450 /* It would be nice to complete outside of spinlock.
451 * But this is easier for now. */
8554df1c 452 _req_mod(r, CONNECTION_LOST_WHILE_PENDING);
b411b363
PR
453 }
454
455 /* ensure bit indicating barrier is required is clear */
e90285e0 456 idr_for_each_entry(&tconn->volumes, mdev, vnr)
2f5cdd0b 457 clear_bit(CREATE_BARRIER, &mdev->flags);
b411b363 458
2f5cdd0b 459 spin_unlock_irq(&tconn->req_lock);
b411b363
PR
460}
461
2f5cdd0b 462void tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
11b58e73 463{
2f5cdd0b
PR
464 spin_lock_irq(&tconn->req_lock);
465 _tl_restart(tconn, what);
466 spin_unlock_irq(&tconn->req_lock);
b411b363
PR
467}
468
b411b363
PR
469static int drbd_thread_setup(void *arg)
470{
471 struct drbd_thread *thi = (struct drbd_thread *) arg;
392c8801 472 struct drbd_tconn *tconn = thi->tconn;
b411b363
PR
473 unsigned long flags;
474 int retval;
475
f1b3a6ec 476 snprintf(current->comm, sizeof(current->comm), "drbd_%c_%s",
392c8801 477 thi->name[0], thi->tconn->name);
f1b3a6ec 478
b411b363
PR
479restart:
480 retval = thi->function(thi);
481
482 spin_lock_irqsave(&thi->t_lock, flags);
483
e77a0a5c 484 /* if the receiver has been "EXITING", the last thing it did
b411b363
PR
485 * was set the conn state to "StandAlone",
486 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
487 * and receiver thread will be "started".
e77a0a5c 488 * drbd_thread_start needs to set "RESTARTING" in that case.
b411b363 489 * t_state check and assignment needs to be within the same spinlock,
e77a0a5c
AG
490 * so either thread_start sees EXITING, and can remap to RESTARTING,
491 * or thread_start see NONE, and can proceed as normal.
b411b363
PR
492 */
493
e77a0a5c 494 if (thi->t_state == RESTARTING) {
392c8801 495 conn_info(tconn, "Restarting %s thread\n", thi->name);
e77a0a5c 496 thi->t_state = RUNNING;
b411b363
PR
497 spin_unlock_irqrestore(&thi->t_lock, flags);
498 goto restart;
499 }
500
501 thi->task = NULL;
e77a0a5c 502 thi->t_state = NONE;
b411b363
PR
503 smp_mb();
504 complete(&thi->stop);
505 spin_unlock_irqrestore(&thi->t_lock, flags);
506
392c8801 507 conn_info(tconn, "Terminating %s\n", current->comm);
b411b363
PR
508
509 /* Release mod reference taken when thread was started */
510 module_put(THIS_MODULE);
511 return retval;
512}
513
392c8801 514static void drbd_thread_init(struct drbd_tconn *tconn, struct drbd_thread *thi,
bed879ae 515 int (*func) (struct drbd_thread *), char *name)
b411b363
PR
516{
517 spin_lock_init(&thi->t_lock);
518 thi->task = NULL;
e77a0a5c 519 thi->t_state = NONE;
b411b363 520 thi->function = func;
392c8801 521 thi->tconn = tconn;
bed879ae 522 strncpy(thi->name, name, ARRAY_SIZE(thi->name));
b411b363
PR
523}
524
525int drbd_thread_start(struct drbd_thread *thi)
526{
392c8801 527 struct drbd_tconn *tconn = thi->tconn;
b411b363
PR
528 struct task_struct *nt;
529 unsigned long flags;
530
b411b363
PR
531 /* is used from state engine doing drbd_thread_stop_nowait,
532 * while holding the req lock irqsave */
533 spin_lock_irqsave(&thi->t_lock, flags);
534
535 switch (thi->t_state) {
e77a0a5c 536 case NONE:
392c8801 537 conn_info(tconn, "Starting %s thread (from %s [%d])\n",
bed879ae 538 thi->name, current->comm, current->pid);
b411b363
PR
539
540 /* Get ref on module for thread - this is released when thread exits */
541 if (!try_module_get(THIS_MODULE)) {
392c8801 542 conn_err(tconn, "Failed to get module reference in drbd_thread_start\n");
b411b363 543 spin_unlock_irqrestore(&thi->t_lock, flags);
81e84650 544 return false;
b411b363
PR
545 }
546
547 init_completion(&thi->stop);
b411b363 548 thi->reset_cpu_mask = 1;
e77a0a5c 549 thi->t_state = RUNNING;
b411b363
PR
550 spin_unlock_irqrestore(&thi->t_lock, flags);
551 flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
552
553 nt = kthread_create(drbd_thread_setup, (void *) thi,
392c8801 554 "drbd_%c_%s", thi->name[0], thi->tconn->name);
b411b363
PR
555
556 if (IS_ERR(nt)) {
392c8801 557 conn_err(tconn, "Couldn't start thread\n");
b411b363
PR
558
559 module_put(THIS_MODULE);
81e84650 560 return false;
b411b363
PR
561 }
562 spin_lock_irqsave(&thi->t_lock, flags);
563 thi->task = nt;
e77a0a5c 564 thi->t_state = RUNNING;
b411b363
PR
565 spin_unlock_irqrestore(&thi->t_lock, flags);
566 wake_up_process(nt);
567 break;
e77a0a5c
AG
568 case EXITING:
569 thi->t_state = RESTARTING;
392c8801 570 conn_info(tconn, "Restarting %s thread (from %s [%d])\n",
bed879ae 571 thi->name, current->comm, current->pid);
b411b363 572 /* fall through */
e77a0a5c
AG
573 case RUNNING:
574 case RESTARTING:
b411b363
PR
575 default:
576 spin_unlock_irqrestore(&thi->t_lock, flags);
577 break;
578 }
579
81e84650 580 return true;
b411b363
PR
581}
582
583
584void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
585{
586 unsigned long flags;
587
e77a0a5c 588 enum drbd_thread_state ns = restart ? RESTARTING : EXITING;
b411b363
PR
589
590 /* may be called from state engine, holding the req lock irqsave */
591 spin_lock_irqsave(&thi->t_lock, flags);
592
e77a0a5c 593 if (thi->t_state == NONE) {
b411b363
PR
594 spin_unlock_irqrestore(&thi->t_lock, flags);
595 if (restart)
596 drbd_thread_start(thi);
597 return;
598 }
599
600 if (thi->t_state != ns) {
601 if (thi->task == NULL) {
602 spin_unlock_irqrestore(&thi->t_lock, flags);
603 return;
604 }
605
606 thi->t_state = ns;
607 smp_mb();
608 init_completion(&thi->stop);
609 if (thi->task != current)
610 force_sig(DRBD_SIGKILL, thi->task);
b411b363
PR
611 }
612
613 spin_unlock_irqrestore(&thi->t_lock, flags);
614
615 if (wait)
616 wait_for_completion(&thi->stop);
617}
618
392c8801 619static struct drbd_thread *drbd_task_to_thread(struct drbd_tconn *tconn, struct task_struct *task)
bed879ae 620{
bed879ae
PR
621 struct drbd_thread *thi =
622 task == tconn->receiver.task ? &tconn->receiver :
623 task == tconn->asender.task ? &tconn->asender :
624 task == tconn->worker.task ? &tconn->worker : NULL;
625
626 return thi;
627}
628
392c8801 629char *drbd_task_to_thread_name(struct drbd_tconn *tconn, struct task_struct *task)
bed879ae 630{
392c8801 631 struct drbd_thread *thi = drbd_task_to_thread(tconn, task);
bed879ae
PR
632 return thi ? thi->name : task->comm;
633}
634
80883197 635int conn_lowest_minor(struct drbd_tconn *tconn)
80822284 636{
e90285e0
PR
637 int vnr = 0;
638 struct drbd_conf *mdev;
774b3055 639
e90285e0
PR
640 mdev = idr_get_next(&tconn->volumes, &vnr);
641 if (!mdev)
774b3055 642 return -1;
e90285e0 643 return mdev_to_minor(mdev);
80822284 644}
774b3055
PR
645
646#ifdef CONFIG_SMP
b411b363
PR
647/**
648 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
649 * @mdev: DRBD device.
650 *
651 * Forces all threads of a device onto the same CPU. This is beneficial for
652 * DRBD's performance. May be overwritten by user's configuration.
653 */
80822284 654void drbd_calc_cpu_mask(struct drbd_tconn *tconn)
b411b363
PR
655{
656 int ord, cpu;
657
658 /* user override. */
80822284 659 if (cpumask_weight(tconn->cpu_mask))
b411b363
PR
660 return;
661
80822284 662 ord = conn_lowest_minor(tconn) % cpumask_weight(cpu_online_mask);
b411b363
PR
663 for_each_online_cpu(cpu) {
664 if (ord-- == 0) {
80822284 665 cpumask_set_cpu(cpu, tconn->cpu_mask);
b411b363
PR
666 return;
667 }
668 }
669 /* should not be reached */
80822284 670 cpumask_setall(tconn->cpu_mask);
b411b363
PR
671}
672
673/**
674 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
675 * @mdev: DRBD device.
bc31fe33 676 * @thi: drbd_thread object
b411b363
PR
677 *
678 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
679 * prematurely.
680 */
80822284 681void drbd_thread_current_set_cpu(struct drbd_thread *thi)
b411b363
PR
682{
683 struct task_struct *p = current;
bed879ae 684
b411b363
PR
685 if (!thi->reset_cpu_mask)
686 return;
687 thi->reset_cpu_mask = 0;
392c8801 688 set_cpus_allowed_ptr(p, thi->tconn->cpu_mask);
b411b363
PR
689}
690#endif
691
d38e787e 692static void prepare_header80(struct p_header80 *h, enum drbd_packet cmd, int size)
fd340c12
PR
693{
694 h->magic = cpu_to_be32(DRBD_MAGIC);
695 h->command = cpu_to_be16(cmd);
696 h->length = cpu_to_be16(size);
697}
698
d38e787e 699static void prepare_header95(struct p_header95 *h, enum drbd_packet cmd, int size)
fd340c12
PR
700{
701 h->magic = cpu_to_be16(DRBD_MAGIC_BIG);
702 h->command = cpu_to_be16(cmd);
703 h->length = cpu_to_be32(size);
704}
705
d38e787e
PR
706static void _prepare_header(struct drbd_tconn *tconn, int vnr, struct p_header *h,
707 enum drbd_packet cmd, int size)
708{
709 if (tconn->agreed_pro_version >= 100 || size > DRBD_MAX_SIZE_H80_PACKET)
710 prepare_header95(&h->h95, cmd, size);
711 else
712 prepare_header80(&h->h80, cmd, size);
713}
714
fd340c12 715static void prepare_header(struct drbd_conf *mdev, struct p_header *h,
d8763023 716 enum drbd_packet cmd, int size)
fd340c12 717{
d38e787e 718 _prepare_header(mdev->tconn, mdev->vnr, h, cmd, size);
fd340c12
PR
719}
720
b411b363 721/* the appropriate socket mutex must be held already */
d38e787e 722int _conn_send_cmd(struct drbd_tconn *tconn, int vnr, struct socket *sock,
d8763023
AG
723 enum drbd_packet cmd, struct p_header *h, size_t size,
724 unsigned msg_flags)
b411b363 725{
ecf2363c 726 int err;
b411b363 727
d38e787e 728 _prepare_header(tconn, vnr, h, cmd, size - sizeof(struct p_header));
ecf2363c
AG
729 err = drbd_send_all(tconn, sock, h, size, msg_flags);
730 if (err && !signal_pending(current))
731 conn_warn(tconn, "short send %s size=%d\n",
732 cmdname(cmd), (int)size);
733 return err;
b411b363
PR
734}
735
736/* don't pass the socket. we may only look at it
737 * when we hold the appropriate socket mutex.
738 */
7d168ed3 739int conn_send_cmd(struct drbd_tconn *tconn, int vnr, struct drbd_socket *sock,
d8763023 740 enum drbd_packet cmd, struct p_header *h, size_t size)
b411b363 741{
596a37f9 742 int err = -EIO;
b411b363 743
7d168ed3
AG
744 mutex_lock(&sock->mutex);
745 if (sock->socket)
746 err = _conn_send_cmd(tconn, vnr, sock->socket, cmd, h, size, 0);
747 mutex_unlock(&sock->mutex);
596a37f9 748 return err;
b411b363
PR
749}
750
61120870 751int conn_send_cmd2(struct drbd_tconn *tconn, enum drbd_packet cmd, char *data,
b411b363
PR
752 size_t size)
753{
61120870 754 struct p_header80 h;
ce9879cb 755 int err;
b411b363 756
61120870 757 prepare_header80(&h, cmd, size);
ce9879cb
AG
758 err = drbd_get_data_sock(tconn);
759 if (!err) {
760 err = drbd_send_all(tconn, tconn->data.socket, &h, sizeof(h), 0);
761 if (!err)
762 err = drbd_send_all(tconn, tconn->data.socket, data, size, 0);
763 drbd_put_data_sock(tconn);
764 }
765 return err;
b411b363
PR
766}
767
f399002e 768int drbd_send_sync_param(struct drbd_conf *mdev)
b411b363 769{
8e26f9cc 770 struct p_rs_param_95 *p;
b411b363 771 struct socket *sock;
103ea275 772 int size, err;
31890f4a 773 const int apv = mdev->tconn->agreed_pro_version;
b411b363
PR
774
775 size = apv <= 87 ? sizeof(struct p_rs_param)
776 : apv == 88 ? sizeof(struct p_rs_param)
f399002e 777 + strlen(mdev->tconn->net_conf->verify_alg) + 1
8e26f9cc
PR
778 : apv <= 94 ? sizeof(struct p_rs_param_89)
779 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
b411b363
PR
780
781 /* used from admin command context and receiver/worker context.
782 * to avoid kmalloc, grab the socket right here,
783 * then use the pre-allocated sbuf there */
e42325a5
PR
784 mutex_lock(&mdev->tconn->data.mutex);
785 sock = mdev->tconn->data.socket;
b411b363
PR
786
787 if (likely(sock != NULL)) {
d8763023
AG
788 enum drbd_packet cmd =
789 apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
b411b363 790
e42325a5 791 p = &mdev->tconn->data.sbuf.rs_param_95;
b411b363
PR
792
793 /* initialize verify_alg and csums_alg */
794 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
795
f399002e
LE
796 if (get_ldev(mdev)) {
797 p->rate = cpu_to_be32(mdev->ldev->dc.resync_rate);
798 p->c_plan_ahead = cpu_to_be32(mdev->ldev->dc.c_plan_ahead);
799 p->c_delay_target = cpu_to_be32(mdev->ldev->dc.c_delay_target);
800 p->c_fill_target = cpu_to_be32(mdev->ldev->dc.c_fill_target);
801 p->c_max_rate = cpu_to_be32(mdev->ldev->dc.c_max_rate);
802 put_ldev(mdev);
803 } else {
804 p->rate = cpu_to_be32(DRBD_RATE_DEF);
805 p->c_plan_ahead = cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF);
806 p->c_delay_target = cpu_to_be32(DRBD_C_DELAY_TARGET_DEF);
807 p->c_fill_target = cpu_to_be32(DRBD_C_FILL_TARGET_DEF);
808 p->c_max_rate = cpu_to_be32(DRBD_C_MAX_RATE_DEF);
809 }
b411b363
PR
810
811 if (apv >= 88)
f399002e 812 strcpy(p->verify_alg, mdev->tconn->net_conf->verify_alg);
b411b363 813 if (apv >= 89)
f399002e 814 strcpy(p->csums_alg, mdev->tconn->net_conf->csums_alg);
b411b363 815
103ea275 816 err = _drbd_send_cmd(mdev, sock, cmd, &p->head, size, 0);
b411b363 817 } else
103ea275 818 err = -EIO;
b411b363 819
e42325a5 820 mutex_unlock(&mdev->tconn->data.mutex);
b411b363 821
103ea275 822 return err;
b411b363
PR
823}
824
dc8228d1 825int drbd_send_protocol(struct drbd_tconn *tconn)
b411b363
PR
826{
827 struct p_protocol *p;
387eb308 828 int size, cf, err;
b411b363
PR
829
830 size = sizeof(struct p_protocol);
831
dc8228d1
PR
832 if (tconn->agreed_pro_version >= 87)
833 size += strlen(tconn->net_conf->integrity_alg) + 1;
b411b363
PR
834
835 /* we must not recurse into our own queue,
836 * as that is blocked during handshake */
837 p = kmalloc(size, GFP_NOIO);
838 if (p == NULL)
387eb308 839 return -ENOMEM;
b411b363 840
dc8228d1
PR
841 p->protocol = cpu_to_be32(tconn->net_conf->wire_protocol);
842 p->after_sb_0p = cpu_to_be32(tconn->net_conf->after_sb_0p);
843 p->after_sb_1p = cpu_to_be32(tconn->net_conf->after_sb_1p);
844 p->after_sb_2p = cpu_to_be32(tconn->net_conf->after_sb_2p);
845 p->two_primaries = cpu_to_be32(tconn->net_conf->two_primaries);
b411b363 846
cf14c2e9 847 cf = 0;
dc8228d1 848 if (tconn->net_conf->want_lose)
cf14c2e9 849 cf |= CF_WANT_LOSE;
dc8228d1
PR
850 if (tconn->net_conf->dry_run) {
851 if (tconn->agreed_pro_version >= 92)
cf14c2e9
PR
852 cf |= CF_DRY_RUN;
853 else {
dc8228d1 854 conn_err(tconn, "--dry-run is not supported by peer");
7ac314c8 855 kfree(p);
387eb308 856 return -EOPNOTSUPP;
cf14c2e9
PR
857 }
858 }
859 p->conn_flags = cpu_to_be32(cf);
860
dc8228d1
PR
861 if (tconn->agreed_pro_version >= 87)
862 strcpy(p->integrity_alg, tconn->net_conf->integrity_alg);
b411b363 863
387eb308 864 err = conn_send_cmd2(tconn, P_PROTOCOL, p->head.payload, size - sizeof(struct p_header));
b411b363 865 kfree(p);
387eb308 866 return err;
b411b363
PR
867}
868
869int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
870{
871 struct p_uuids p;
872 int i;
873
874 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
2ae5f95b 875 return 0;
b411b363
PR
876
877 for (i = UI_CURRENT; i < UI_SIZE; i++)
878 p.uuid[i] = mdev->ldev ? cpu_to_be64(mdev->ldev->md.uuid[i]) : 0;
879
880 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
881 p.uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
89e58e75 882 uuid_flags |= mdev->tconn->net_conf->want_lose ? 1 : 0;
b411b363
PR
883 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
884 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
885 p.uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
886
887 put_ldev(mdev);
888
2ae5f95b 889 return drbd_send_cmd(mdev, &mdev->tconn->data, P_UUIDS, &p.head, sizeof(p));
b411b363
PR
890}
891
892int drbd_send_uuids(struct drbd_conf *mdev)
893{
894 return _drbd_send_uuids(mdev, 0);
895}
896
897int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
898{
899 return _drbd_send_uuids(mdev, 8);
900}
901
62b0da3a
LE
902void drbd_print_uuids(struct drbd_conf *mdev, const char *text)
903{
904 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
905 u64 *uuid = mdev->ldev->md.uuid;
906 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX\n",
907 text,
908 (unsigned long long)uuid[UI_CURRENT],
909 (unsigned long long)uuid[UI_BITMAP],
910 (unsigned long long)uuid[UI_HISTORY_START],
911 (unsigned long long)uuid[UI_HISTORY_END]);
912 put_ldev(mdev);
913 } else {
914 dev_info(DEV, "%s effective data uuid: %016llX\n",
915 text,
916 (unsigned long long)mdev->ed_uuid);
917 }
918}
919
9c1b7f72 920void drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev)
b411b363
PR
921{
922 struct p_rs_uuid p;
5a22db89
LE
923 u64 uuid;
924
925 D_ASSERT(mdev->state.disk == D_UP_TO_DATE);
b411b363 926
4a23f264 927 uuid = mdev->ldev->md.uuid[UI_BITMAP] + UUID_NEW_BM_OFFSET;
5a22db89 928 drbd_uuid_set(mdev, UI_BITMAP, uuid);
62b0da3a 929 drbd_print_uuids(mdev, "updated sync UUID");
5a22db89
LE
930 drbd_md_sync(mdev);
931 p.uuid = cpu_to_be64(uuid);
b411b363 932
9c1b7f72 933 drbd_send_cmd(mdev, &mdev->tconn->data, P_SYNC_UUID, &p.head, sizeof(p));
b411b363
PR
934}
935
e89b591c 936int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
b411b363
PR
937{
938 struct p_sizes p;
939 sector_t d_size, u_size;
99432fcc 940 int q_order_type, max_bio_size;
b411b363
PR
941
942 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
943 D_ASSERT(mdev->ldev->backing_bdev);
944 d_size = drbd_get_max_capacity(mdev->ldev);
945 u_size = mdev->ldev->dc.disk_size;
946 q_order_type = drbd_queue_order_type(mdev);
99432fcc
PR
947 max_bio_size = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
948 max_bio_size = min_t(int, max_bio_size, DRBD_MAX_BIO_SIZE);
b411b363
PR
949 put_ldev(mdev);
950 } else {
951 d_size = 0;
952 u_size = 0;
953 q_order_type = QUEUE_ORDERED_NONE;
99432fcc 954 max_bio_size = DRBD_MAX_BIO_SIZE; /* ... multiple BIOs per peer_request */
b411b363
PR
955 }
956
957 p.d_size = cpu_to_be64(d_size);
958 p.u_size = cpu_to_be64(u_size);
959 p.c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
99432fcc 960 p.max_bio_size = cpu_to_be32(max_bio_size);
e89b591c
PR
961 p.queue_order_type = cpu_to_be16(q_order_type);
962 p.dds_flags = cpu_to_be16(flags);
b411b363 963
f02d4d0a 964 return drbd_send_cmd(mdev, &mdev->tconn->data, P_SIZES, &p.head, sizeof(p));
b411b363
PR
965}
966
967/**
968 * drbd_send_state() - Sends the drbd state to the peer
969 * @mdev: DRBD device.
970 */
971int drbd_send_state(struct drbd_conf *mdev)
972{
973 struct socket *sock;
974 struct p_state p;
927036f9 975 int err = -EIO;
b411b363 976
e42325a5 977 mutex_lock(&mdev->tconn->data.mutex);
b411b363
PR
978
979 p.state = cpu_to_be32(mdev->state.i); /* Within the send mutex */
e42325a5 980 sock = mdev->tconn->data.socket;
b411b363 981
04dfa137 982 if (likely(sock != NULL))
927036f9 983 err = _drbd_send_cmd(mdev, sock, P_STATE, &p.head, sizeof(p), 0);
b411b363 984
e42325a5 985 mutex_unlock(&mdev->tconn->data.mutex);
b411b363 986
927036f9 987 return err;
b411b363
PR
988}
989
cf29c9d8
PR
990int _conn_send_state_req(struct drbd_tconn *tconn, int vnr, enum drbd_packet cmd,
991 union drbd_state mask, union drbd_state val)
b411b363
PR
992{
993 struct p_req_state p;
994
995 p.mask = cpu_to_be32(mask.i);
996 p.val = cpu_to_be32(val.i);
997
758970c8 998 return conn_send_cmd(tconn, vnr, &tconn->data, cmd, &p.head, sizeof(p));
b411b363
PR
999}
1000
2f4e7abe 1001void drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode)
b411b363
PR
1002{
1003 struct p_req_state_reply p;
1004
1005 p.retcode = cpu_to_be32(retcode);
1006
2f4e7abe 1007 drbd_send_cmd(mdev, &mdev->tconn->meta, P_STATE_CHG_REPLY, &p.head, sizeof(p));
b411b363
PR
1008}
1009
047cd4a6
PR
1010int conn_send_sr_reply(struct drbd_tconn *tconn, enum drbd_state_rv retcode)
1011{
1012 struct p_req_state_reply p;
1013 enum drbd_packet cmd = tconn->agreed_pro_version < 100 ? P_STATE_CHG_REPLY : P_CONN_ST_CHG_REPLY;
1014
1015 p.retcode = cpu_to_be32(retcode);
1016
7d168ed3 1017 return !conn_send_cmd(tconn, 0, &tconn->meta, cmd, &p.head, sizeof(p));
047cd4a6
PR
1018}
1019
b411b363
PR
1020int fill_bitmap_rle_bits(struct drbd_conf *mdev,
1021 struct p_compressed_bm *p,
1022 struct bm_xfer_ctx *c)
1023{
1024 struct bitstream bs;
1025 unsigned long plain_bits;
1026 unsigned long tmp;
1027 unsigned long rl;
1028 unsigned len;
1029 unsigned toggle;
1030 int bits;
1031
1032 /* may we use this feature? */
f399002e 1033 if ((mdev->tconn->net_conf->use_rle == 0) ||
31890f4a 1034 (mdev->tconn->agreed_pro_version < 90))
b411b363
PR
1035 return 0;
1036
1037 if (c->bit_offset >= c->bm_bits)
1038 return 0; /* nothing to do. */
1039
1040 /* use at most thus many bytes */
1041 bitstream_init(&bs, p->code, BM_PACKET_VLI_BYTES_MAX, 0);
1042 memset(p->code, 0, BM_PACKET_VLI_BYTES_MAX);
1043 /* plain bits covered in this code string */
1044 plain_bits = 0;
1045
1046 /* p->encoding & 0x80 stores whether the first run length is set.
1047 * bit offset is implicit.
1048 * start with toggle == 2 to be able to tell the first iteration */
1049 toggle = 2;
1050
1051 /* see how much plain bits we can stuff into one packet
1052 * using RLE and VLI. */
1053 do {
1054 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1055 : _drbd_bm_find_next(mdev, c->bit_offset);
1056 if (tmp == -1UL)
1057 tmp = c->bm_bits;
1058 rl = tmp - c->bit_offset;
1059
1060 if (toggle == 2) { /* first iteration */
1061 if (rl == 0) {
1062 /* the first checked bit was set,
1063 * store start value, */
1064 DCBP_set_start(p, 1);
1065 /* but skip encoding of zero run length */
1066 toggle = !toggle;
1067 continue;
1068 }
1069 DCBP_set_start(p, 0);
1070 }
1071
1072 /* paranoia: catch zero runlength.
1073 * can only happen if bitmap is modified while we scan it. */
1074 if (rl == 0) {
1075 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1076 "t:%u bo:%lu\n", toggle, c->bit_offset);
1077 return -1;
1078 }
1079
1080 bits = vli_encode_bits(&bs, rl);
1081 if (bits == -ENOBUFS) /* buffer full */
1082 break;
1083 if (bits <= 0) {
1084 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
1085 return 0;
1086 }
1087
1088 toggle = !toggle;
1089 plain_bits += rl;
1090 c->bit_offset = tmp;
1091 } while (c->bit_offset < c->bm_bits);
1092
1093 len = bs.cur.b - p->code + !!bs.cur.bit;
1094
1095 if (plain_bits < (len << 3)) {
1096 /* incompressible with this method.
1097 * we need to rewind both word and bit position. */
1098 c->bit_offset -= plain_bits;
1099 bm_xfer_ctx_bit_to_word_offset(c);
1100 c->bit_offset = c->word_offset * BITS_PER_LONG;
1101 return 0;
1102 }
1103
1104 /* RLE + VLI was able to compress it just fine.
1105 * update c->word_offset. */
1106 bm_xfer_ctx_bit_to_word_offset(c);
1107
1108 /* store pad_bits */
1109 DCBP_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
1110
1111 return len;
1112}
1113
f70af118
AG
1114/**
1115 * send_bitmap_rle_or_plain
1116 *
1117 * Return 0 when done, 1 when another iteration is needed, and a negative error
1118 * code upon failure.
1119 */
1120static int
b411b363 1121send_bitmap_rle_or_plain(struct drbd_conf *mdev,
c012949a 1122 struct p_header *h, struct bm_xfer_ctx *c)
b411b363
PR
1123{
1124 struct p_compressed_bm *p = (void*)h;
1125 unsigned long num_words;
1126 int len;
1127 int ok;
1128
1129 len = fill_bitmap_rle_bits(mdev, p, c);
1130
1131 if (len < 0)
f70af118 1132 return -EIO;
b411b363
PR
1133
1134 if (len) {
1135 DCBP_set_code(p, RLE_VLI_Bits);
04dfa137
AG
1136 ok = !_drbd_send_cmd(mdev, mdev->tconn->data.socket, P_COMPRESSED_BITMAP, h,
1137 sizeof(*p) + len, 0);
b411b363
PR
1138
1139 c->packets[0]++;
1140 c->bytes[0] += sizeof(*p) + len;
1141
1142 if (c->bit_offset >= c->bm_bits)
1143 len = 0; /* DONE */
1144 } else {
1145 /* was not compressible.
1146 * send a buffer full of plain text bits instead. */
1147 num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
1148 len = num_words * sizeof(long);
1149 if (len)
1150 drbd_bm_get_lel(mdev, c->word_offset, num_words, (unsigned long*)h->payload);
04dfa137
AG
1151 ok = !_drbd_send_cmd(mdev, mdev->tconn->data.socket, P_BITMAP,
1152 h, sizeof(struct p_header80) + len, 0);
b411b363
PR
1153 c->word_offset += num_words;
1154 c->bit_offset = c->word_offset * BITS_PER_LONG;
1155
1156 c->packets[1]++;
0b70a13d 1157 c->bytes[1] += sizeof(struct p_header80) + len;
b411b363
PR
1158
1159 if (c->bit_offset > c->bm_bits)
1160 c->bit_offset = c->bm_bits;
1161 }
f70af118
AG
1162 if (ok) {
1163 if (len == 0) {
1164 INFO_bm_xfer_stats(mdev, "send", c);
1165 return 0;
1166 } else
1167 return 1;
1168 }
1169 return -EIO;
b411b363
PR
1170}
1171
1172/* See the comment at receive_bitmap() */
1173int _drbd_send_bitmap(struct drbd_conf *mdev)
1174{
1175 struct bm_xfer_ctx c;
c012949a 1176 struct p_header *p;
f70af118 1177 int err;
b411b363 1178
841ce241
AG
1179 if (!expect(mdev->bitmap))
1180 return false;
b411b363
PR
1181
1182 /* maybe we should use some per thread scratch page,
1183 * and allocate that during initial device creation? */
c012949a 1184 p = (struct p_header *) __get_free_page(GFP_NOIO);
b411b363
PR
1185 if (!p) {
1186 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
81e84650 1187 return false;
b411b363
PR
1188 }
1189
1190 if (get_ldev(mdev)) {
1191 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1192 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
1193 drbd_bm_set_all(mdev);
1194 if (drbd_bm_write(mdev)) {
1195 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
1196 * but otherwise process as per normal - need to tell other
1197 * side that a full resync is required! */
1198 dev_err(DEV, "Failed to write bitmap to disk!\n");
1199 } else {
1200 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
1201 drbd_md_sync(mdev);
1202 }
1203 }
1204 put_ldev(mdev);
1205 }
1206
1207 c = (struct bm_xfer_ctx) {
1208 .bm_bits = drbd_bm_bits(mdev),
1209 .bm_words = drbd_bm_words(mdev),
1210 };
1211
1212 do {
f70af118
AG
1213 err = send_bitmap_rle_or_plain(mdev, p, &c);
1214 } while (err > 0);
b411b363
PR
1215
1216 free_page((unsigned long) p);
f70af118 1217 return err == 0;
b411b363
PR
1218}
1219
1220int drbd_send_bitmap(struct drbd_conf *mdev)
1221{
1222 int err;
1223
11b0be28 1224 if (drbd_get_data_sock(mdev->tconn))
b411b363
PR
1225 return -1;
1226 err = !_drbd_send_bitmap(mdev);
61120870 1227 drbd_put_data_sock(mdev->tconn);
b411b363
PR
1228 return err;
1229}
d4e67d7c 1230void drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, u32 set_size)
b411b363 1231{
b411b363
PR
1232 struct p_barrier_ack p;
1233
1234 p.barrier = barrier_nr;
1235 p.set_size = cpu_to_be32(set_size);
1236
d4e67d7c
AG
1237 if (mdev->state.conn >= C_CONNECTED)
1238 drbd_send_cmd(mdev, &mdev->tconn->meta, P_BARRIER_ACK, &p.head, sizeof(p));
b411b363
PR
1239}
1240
1241/**
1242 * _drbd_send_ack() - Sends an ack packet
1243 * @mdev: DRBD device.
1244 * @cmd: Packet command code.
1245 * @sector: sector, needs to be in big endian byte order
1246 * @blksize: size in byte, needs to be in big endian byte order
1247 * @block_id: Id, big endian byte order
1248 */
d8763023
AG
1249static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
1250 u64 sector, u32 blksize, u64 block_id)
b411b363
PR
1251{
1252 int ok;
1253 struct p_block_ack p;
1254
1255 p.sector = sector;
1256 p.block_id = block_id;
1257 p.blksize = blksize;
8ccf218e 1258 p.seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
b411b363 1259
e42325a5 1260 if (!mdev->tconn->meta.socket || mdev->state.conn < C_CONNECTED)
81e84650 1261 return false;
f7254463 1262 ok = !drbd_send_cmd(mdev, &mdev->tconn->meta, cmd, &p.head, sizeof(p));
b411b363
PR
1263 return ok;
1264}
1265
2b2bf214
LE
1266/* dp->sector and dp->block_id already/still in network byte order,
1267 * data_size is payload size according to dp->head,
1268 * and may need to be corrected for digest size. */
d8763023 1269int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
2b2bf214 1270 struct p_data *dp, int data_size)
b411b363 1271{
a0638456
PR
1272 data_size -= (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
1273 crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
b411b363
PR
1274 return _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
1275 dp->block_id);
1276}
1277
d8763023 1278int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
b411b363
PR
1279 struct p_block_req *rp)
1280{
1281 return _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
1282}
1283
1284/**
1285 * drbd_send_ack() - Sends an ack packet
db830c46
AG
1286 * @mdev: DRBD device
1287 * @cmd: packet command code
1288 * @peer_req: peer request
b411b363 1289 */
d8763023 1290int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
db830c46 1291 struct drbd_peer_request *peer_req)
b411b363
PR
1292{
1293 return _drbd_send_ack(mdev, cmd,
db830c46
AG
1294 cpu_to_be64(peer_req->i.sector),
1295 cpu_to_be32(peer_req->i.size),
1296 peer_req->block_id);
b411b363
PR
1297}
1298
1299/* This function misuses the block_id field to signal if the blocks
1300 * are is sync or not. */
d8763023 1301int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
b411b363
PR
1302 sector_t sector, int blksize, u64 block_id)
1303{
1304 return _drbd_send_ack(mdev, cmd,
1305 cpu_to_be64(sector),
1306 cpu_to_be32(blksize),
1307 cpu_to_be64(block_id));
1308}
1309
1310int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1311 sector_t sector, int size, u64 block_id)
1312{
1313 int ok;
1314 struct p_block_req p;
1315
1316 p.sector = cpu_to_be64(sector);
1317 p.block_id = block_id;
1318 p.blksize = cpu_to_be32(size);
1319
f7254463 1320 ok = !drbd_send_cmd(mdev, &mdev->tconn->data, cmd, &p.head, sizeof(p));
b411b363
PR
1321 return ok;
1322}
1323
d8763023
AG
1324int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector, int size,
1325 void *digest, int digest_size, enum drbd_packet cmd)
b411b363
PR
1326{
1327 int ok;
1328 struct p_block_req p;
1329
fd340c12 1330 prepare_header(mdev, &p.head, cmd, sizeof(p) - sizeof(struct p_header) + digest_size);
b411b363 1331 p.sector = cpu_to_be64(sector);
9a8e7753 1332 p.block_id = ID_SYNCER /* unused */;
b411b363
PR
1333 p.blksize = cpu_to_be32(size);
1334
e42325a5 1335 mutex_lock(&mdev->tconn->data.mutex);
b411b363 1336
bedbd2a5
PR
1337 ok = (sizeof(p) == drbd_send(mdev->tconn, mdev->tconn->data.socket, &p, sizeof(p), 0));
1338 ok = ok && (digest_size == drbd_send(mdev->tconn, mdev->tconn->data.socket, digest, digest_size, 0));
b411b363 1339
e42325a5 1340 mutex_unlock(&mdev->tconn->data.mutex);
b411b363
PR
1341
1342 return ok;
1343}
1344
1345int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
1346{
1347 int ok;
1348 struct p_block_req p;
1349
1350 p.sector = cpu_to_be64(sector);
9a8e7753 1351 p.block_id = ID_SYNCER /* unused */;
b411b363
PR
1352 p.blksize = cpu_to_be32(size);
1353
f7254463 1354 ok = !drbd_send_cmd(mdev, &mdev->tconn->data, P_OV_REQUEST, &p.head, sizeof(p));
b411b363
PR
1355 return ok;
1356}
1357
1358/* called on sndtimeo
81e84650
AG
1359 * returns false if we should retry,
1360 * true if we think connection is dead
b411b363 1361 */
1a7ba646 1362static int we_should_drop_the_connection(struct drbd_tconn *tconn, struct socket *sock)
b411b363
PR
1363{
1364 int drop_it;
1365 /* long elapsed = (long)(jiffies - mdev->last_received); */
1366
1a7ba646
PR
1367 drop_it = tconn->meta.socket == sock
1368 || !tconn->asender.task
1369 || get_t_state(&tconn->asender) != RUNNING
bbeb641c 1370 || tconn->cstate < C_WF_REPORT_PARAMS;
b411b363
PR
1371
1372 if (drop_it)
81e84650 1373 return true;
b411b363 1374
1a7ba646 1375 drop_it = !--tconn->ko_count;
b411b363 1376 if (!drop_it) {
1a7ba646
PR
1377 conn_err(tconn, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1378 current->comm, current->pid, tconn->ko_count);
1379 request_ping(tconn);
b411b363
PR
1380 }
1381
1382 return drop_it; /* && (mdev->state == R_PRIMARY) */;
1383}
1384
1a7ba646 1385static void drbd_update_congested(struct drbd_tconn *tconn)
9e204cdd 1386{
1a7ba646 1387 struct sock *sk = tconn->data.socket->sk;
9e204cdd 1388 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5)
1a7ba646 1389 set_bit(NET_CONGESTED, &tconn->flags);
9e204cdd
AG
1390}
1391
b411b363
PR
1392/* The idea of sendpage seems to be to put some kind of reference
1393 * to the page into the skb, and to hand it over to the NIC. In
1394 * this process get_page() gets called.
1395 *
1396 * As soon as the page was really sent over the network put_page()
1397 * gets called by some part of the network layer. [ NIC driver? ]
1398 *
1399 * [ get_page() / put_page() increment/decrement the count. If count
1400 * reaches 0 the page will be freed. ]
1401 *
1402 * This works nicely with pages from FSs.
1403 * But this means that in protocol A we might signal IO completion too early!
1404 *
1405 * In order not to corrupt data during a resync we must make sure
1406 * that we do not reuse our own buffer pages (EEs) to early, therefore
1407 * we have the net_ee list.
1408 *
1409 * XFS seems to have problems, still, it submits pages with page_count == 0!
1410 * As a workaround, we disable sendpage on pages
1411 * with page_count == 0 or PageSlab.
1412 */
1413static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 1414 int offset, size_t size, unsigned msg_flags)
b411b363 1415{
bedbd2a5 1416 int sent = drbd_send(mdev->tconn, mdev->tconn->data.socket, kmap(page) + offset, size, msg_flags);
b411b363
PR
1417 kunmap(page);
1418 if (sent == size)
1419 mdev->send_cnt += size>>9;
1420 return sent == size;
1421}
1422
1423static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 1424 int offset, size_t size, unsigned msg_flags)
b411b363
PR
1425{
1426 mm_segment_t oldfs = get_fs();
1427 int sent, ok;
1428 int len = size;
1429
1430 /* e.g. XFS meta- & log-data is in slab pages, which have a
1431 * page_count of 0 and/or have PageSlab() set.
1432 * we cannot use send_page for those, as that does get_page();
1433 * put_page(); and would cause either a VM_BUG directly, or
1434 * __page_cache_release a page that would actually still be referenced
1435 * by someone, leading to some obscure delayed Oops somewhere else. */
1436 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
ba11ad9a 1437 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
b411b363 1438
ba11ad9a 1439 msg_flags |= MSG_NOSIGNAL;
1a7ba646 1440 drbd_update_congested(mdev->tconn);
b411b363
PR
1441 set_fs(KERNEL_DS);
1442 do {
e42325a5 1443 sent = mdev->tconn->data.socket->ops->sendpage(mdev->tconn->data.socket, page,
b411b363 1444 offset, len,
ba11ad9a 1445 msg_flags);
b411b363 1446 if (sent == -EAGAIN) {
1a7ba646 1447 if (we_should_drop_the_connection(mdev->tconn,
e42325a5 1448 mdev->tconn->data.socket))
b411b363
PR
1449 break;
1450 else
1451 continue;
1452 }
1453 if (sent <= 0) {
1454 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
1455 __func__, (int)size, len, sent);
1456 break;
1457 }
1458 len -= sent;
1459 offset += sent;
1460 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
1461 set_fs(oldfs);
01a311a5 1462 clear_bit(NET_CONGESTED, &mdev->tconn->flags);
b411b363
PR
1463
1464 ok = (len == 0);
1465 if (likely(ok))
1466 mdev->send_cnt += size>>9;
1467 return ok;
1468}
1469
1470static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
1471{
1472 struct bio_vec *bvec;
1473 int i;
ba11ad9a 1474 /* hint all but last page with MSG_MORE */
b411b363
PR
1475 __bio_for_each_segment(bvec, bio, i, 0) {
1476 if (!_drbd_no_send_page(mdev, bvec->bv_page,
ba11ad9a
LE
1477 bvec->bv_offset, bvec->bv_len,
1478 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR
1479 return 0;
1480 }
1481 return 1;
1482}
1483
1484static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
1485{
1486 struct bio_vec *bvec;
1487 int i;
ba11ad9a 1488 /* hint all but last page with MSG_MORE */
b411b363
PR
1489 __bio_for_each_segment(bvec, bio, i, 0) {
1490 if (!_drbd_send_page(mdev, bvec->bv_page,
ba11ad9a
LE
1491 bvec->bv_offset, bvec->bv_len,
1492 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR
1493 return 0;
1494 }
b411b363
PR
1495 return 1;
1496}
1497
db830c46
AG
1498static int _drbd_send_zc_ee(struct drbd_conf *mdev,
1499 struct drbd_peer_request *peer_req)
45bb912b 1500{
db830c46
AG
1501 struct page *page = peer_req->pages;
1502 unsigned len = peer_req->i.size;
1503
ba11ad9a 1504 /* hint all but last page with MSG_MORE */
45bb912b
LE
1505 page_chain_for_each(page) {
1506 unsigned l = min_t(unsigned, len, PAGE_SIZE);
ba11ad9a
LE
1507 if (!_drbd_send_page(mdev, page, 0, l,
1508 page_chain_next(page) ? MSG_MORE : 0))
45bb912b
LE
1509 return 0;
1510 len -= l;
1511 }
1512 return 1;
1513}
1514
76d2e7ec
PR
1515static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
1516{
31890f4a 1517 if (mdev->tconn->agreed_pro_version >= 95)
76d2e7ec 1518 return (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
76d2e7ec
PR
1519 (bi_rw & REQ_FUA ? DP_FUA : 0) |
1520 (bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
1521 (bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
1522 else
721a9602 1523 return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
76d2e7ec
PR
1524}
1525
b411b363
PR
1526/* Used to send write requests
1527 * R_PRIMARY -> Peer (P_DATA)
1528 */
1529int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
1530{
1531 int ok = 1;
1532 struct p_data p;
1533 unsigned int dp_flags = 0;
1534 void *dgb;
1535 int dgs;
1536
11b0be28 1537 if (drbd_get_data_sock(mdev->tconn))
b411b363
PR
1538 return 0;
1539
a0638456
PR
1540 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_w_tfm) ?
1541 crypto_hash_digestsize(mdev->tconn->integrity_w_tfm) : 0;
b411b363 1542
fd340c12 1543 prepare_header(mdev, &p.head, P_DATA, sizeof(p) - sizeof(struct p_header) + dgs + req->i.size);
ace652ac 1544 p.sector = cpu_to_be64(req->i.sector);
b411b363 1545 p.block_id = (unsigned long)req;
8ccf218e 1546 p.seq_num = cpu_to_be32(req->seq_num = atomic_inc_return(&mdev->packet_seq));
b411b363 1547
76d2e7ec
PR
1548 dp_flags = bio_flags_to_wire(mdev, req->master_bio->bi_rw);
1549
b411b363
PR
1550 if (mdev->state.conn >= C_SYNC_SOURCE &&
1551 mdev->state.conn <= C_PAUSED_SYNC_T)
1552 dp_flags |= DP_MAY_SET_IN_SYNC;
1553
1554 p.dp_flags = cpu_to_be32(dp_flags);
b411b363
PR
1555 set_bit(UNPLUG_REMOTE, &mdev->flags);
1556 ok = (sizeof(p) ==
bedbd2a5 1557 drbd_send(mdev->tconn, mdev->tconn->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0));
b411b363 1558 if (ok && dgs) {
a0638456
PR
1559 dgb = mdev->tconn->int_dig_out;
1560 drbd_csum_bio(mdev, mdev->tconn->integrity_w_tfm, req->master_bio, dgb);
bedbd2a5 1561 ok = dgs == drbd_send(mdev->tconn, mdev->tconn->data.socket, dgb, dgs, 0);
b411b363
PR
1562 }
1563 if (ok) {
470be44a
LE
1564 /* For protocol A, we have to memcpy the payload into
1565 * socket buffers, as we may complete right away
1566 * as soon as we handed it over to tcp, at which point the data
1567 * pages may become invalid.
1568 *
1569 * For data-integrity enabled, we copy it as well, so we can be
1570 * sure that even if the bio pages may still be modified, it
1571 * won't change the data on the wire, thus if the digest checks
1572 * out ok after sending on this side, but does not fit on the
1573 * receiving side, we sure have detected corruption elsewhere.
1574 */
89e58e75 1575 if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || dgs)
b411b363
PR
1576 ok = _drbd_send_bio(mdev, req->master_bio);
1577 else
1578 ok = _drbd_send_zc_bio(mdev, req->master_bio);
470be44a
LE
1579
1580 /* double check digest, sometimes buffers have been modified in flight. */
1581 if (dgs > 0 && dgs <= 64) {
24c4830c 1582 /* 64 byte, 512 bit, is the largest digest size
470be44a
LE
1583 * currently supported in kernel crypto. */
1584 unsigned char digest[64];
a0638456
PR
1585 drbd_csum_bio(mdev, mdev->tconn->integrity_w_tfm, req->master_bio, digest);
1586 if (memcmp(mdev->tconn->int_dig_out, digest, dgs)) {
470be44a
LE
1587 dev_warn(DEV,
1588 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
ace652ac 1589 (unsigned long long)req->i.sector, req->i.size);
470be44a
LE
1590 }
1591 } /* else if (dgs > 64) {
1592 ... Be noisy about digest too large ...
1593 } */
b411b363
PR
1594 }
1595
61120870 1596 drbd_put_data_sock(mdev->tconn);
bd26bfc5 1597
b411b363
PR
1598 return ok;
1599}
1600
1601/* answer packet, used to send data back for read requests:
1602 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
1603 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
1604 */
d8763023 1605int drbd_send_block(struct drbd_conf *mdev, enum drbd_packet cmd,
db830c46 1606 struct drbd_peer_request *peer_req)
b411b363
PR
1607{
1608 int ok;
1609 struct p_data p;
1610 void *dgb;
1611 int dgs;
1612
a0638456
PR
1613 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_w_tfm) ?
1614 crypto_hash_digestsize(mdev->tconn->integrity_w_tfm) : 0;
b411b363 1615
db830c46
AG
1616 prepare_header(mdev, &p.head, cmd, sizeof(p) -
1617 sizeof(struct p_header80) +
1618 dgs + peer_req->i.size);
1619 p.sector = cpu_to_be64(peer_req->i.sector);
1620 p.block_id = peer_req->block_id;
cc378270 1621 p.seq_num = 0; /* unused */
b411b363
PR
1622
1623 /* Only called by our kernel thread.
1624 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
1625 * in response to admin command or module unload.
1626 */
11b0be28 1627 if (drbd_get_data_sock(mdev->tconn))
b411b363
PR
1628 return 0;
1629
bedbd2a5 1630 ok = sizeof(p) == drbd_send(mdev->tconn, mdev->tconn->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0);
b411b363 1631 if (ok && dgs) {
a0638456 1632 dgb = mdev->tconn->int_dig_out;
db830c46 1633 drbd_csum_ee(mdev, mdev->tconn->integrity_w_tfm, peer_req, dgb);
bedbd2a5 1634 ok = dgs == drbd_send(mdev->tconn, mdev->tconn->data.socket, dgb, dgs, 0);
b411b363
PR
1635 }
1636 if (ok)
db830c46 1637 ok = _drbd_send_zc_ee(mdev, peer_req);
b411b363 1638
61120870 1639 drbd_put_data_sock(mdev->tconn);
bd26bfc5 1640
b411b363
PR
1641 return ok;
1642}
1643
73a01a18
PR
1644int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req)
1645{
1646 struct p_block_desc p;
1647
ace652ac
AG
1648 p.sector = cpu_to_be64(req->i.sector);
1649 p.blksize = cpu_to_be32(req->i.size);
73a01a18 1650
f7254463 1651 return !drbd_send_cmd(mdev, &mdev->tconn->data, P_OUT_OF_SYNC, &p.head, sizeof(p));
73a01a18
PR
1652}
1653
b411b363
PR
1654/*
1655 drbd_send distinguishes two cases:
1656
1657 Packets sent via the data socket "sock"
1658 and packets sent via the meta data socket "msock"
1659
1660 sock msock
1661 -----------------+-------------------------+------------------------------
1662 timeout conf.timeout / 2 conf.timeout / 2
1663 timeout action send a ping via msock Abort communication
1664 and close all sockets
1665*/
1666
1667/*
1668 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
1669 */
bedbd2a5 1670int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
b411b363
PR
1671 void *buf, size_t size, unsigned msg_flags)
1672{
1673 struct kvec iov;
1674 struct msghdr msg;
1675 int rv, sent = 0;
1676
1677 if (!sock)
c0d42c8e 1678 return -EBADR;
b411b363
PR
1679
1680 /* THINK if (signal_pending) return ... ? */
1681
1682 iov.iov_base = buf;
1683 iov.iov_len = size;
1684
1685 msg.msg_name = NULL;
1686 msg.msg_namelen = 0;
1687 msg.msg_control = NULL;
1688 msg.msg_controllen = 0;
1689 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
1690
bedbd2a5
PR
1691 if (sock == tconn->data.socket) {
1692 tconn->ko_count = tconn->net_conf->ko_count;
1693 drbd_update_congested(tconn);
b411b363
PR
1694 }
1695 do {
1696 /* STRANGE
1697 * tcp_sendmsg does _not_ use its size parameter at all ?
1698 *
1699 * -EAGAIN on timeout, -EINTR on signal.
1700 */
1701/* THINK
1702 * do we need to block DRBD_SIG if sock == &meta.socket ??
1703 * otherwise wake_asender() might interrupt some send_*Ack !
1704 */
1705 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
1706 if (rv == -EAGAIN) {
bedbd2a5 1707 if (we_should_drop_the_connection(tconn, sock))
b411b363
PR
1708 break;
1709 else
1710 continue;
1711 }
b411b363
PR
1712 if (rv == -EINTR) {
1713 flush_signals(current);
1714 rv = 0;
1715 }
1716 if (rv < 0)
1717 break;
1718 sent += rv;
1719 iov.iov_base += rv;
1720 iov.iov_len -= rv;
1721 } while (sent < size);
1722
bedbd2a5
PR
1723 if (sock == tconn->data.socket)
1724 clear_bit(NET_CONGESTED, &tconn->flags);
b411b363
PR
1725
1726 if (rv <= 0) {
1727 if (rv != -EAGAIN) {
bedbd2a5
PR
1728 conn_err(tconn, "%s_sendmsg returned %d\n",
1729 sock == tconn->meta.socket ? "msock" : "sock",
1730 rv);
bbeb641c 1731 conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
b411b363 1732 } else
bbeb641c 1733 conn_request_state(tconn, NS(conn, C_TIMEOUT), CS_HARD);
b411b363
PR
1734 }
1735
1736 return sent;
1737}
1738
fb708e40
AG
1739/**
1740 * drbd_send_all - Send an entire buffer
1741 *
1742 * Returns 0 upon success and a negative error value otherwise.
1743 */
1744int drbd_send_all(struct drbd_tconn *tconn, struct socket *sock, void *buffer,
1745 size_t size, unsigned msg_flags)
1746{
1747 int err;
1748
1749 err = drbd_send(tconn, sock, buffer, size, msg_flags);
1750 if (err < 0)
1751 return err;
1752 if (err != size)
1753 return -EIO;
1754 return 0;
1755}
1756
b411b363
PR
1757static int drbd_open(struct block_device *bdev, fmode_t mode)
1758{
1759 struct drbd_conf *mdev = bdev->bd_disk->private_data;
1760 unsigned long flags;
1761 int rv = 0;
1762
2a48fc0a 1763 mutex_lock(&drbd_main_mutex);
87eeee41 1764 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
b411b363
PR
1765 /* to have a stable mdev->state.role
1766 * and no race with updating open_cnt */
1767
1768 if (mdev->state.role != R_PRIMARY) {
1769 if (mode & FMODE_WRITE)
1770 rv = -EROFS;
1771 else if (!allow_oos)
1772 rv = -EMEDIUMTYPE;
1773 }
1774
1775 if (!rv)
1776 mdev->open_cnt++;
87eeee41 1777 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
2a48fc0a 1778 mutex_unlock(&drbd_main_mutex);
b411b363
PR
1779
1780 return rv;
1781}
1782
1783static int drbd_release(struct gendisk *gd, fmode_t mode)
1784{
1785 struct drbd_conf *mdev = gd->private_data;
2a48fc0a 1786 mutex_lock(&drbd_main_mutex);
b411b363 1787 mdev->open_cnt--;
2a48fc0a 1788 mutex_unlock(&drbd_main_mutex);
b411b363
PR
1789 return 0;
1790}
1791
b411b363
PR
1792static void drbd_set_defaults(struct drbd_conf *mdev)
1793{
f399002e
LE
1794 /* Beware! The actual layout differs
1795 * between big endian and little endian */
b411b363
PR
1796 mdev->state = (union drbd_state) {
1797 { .role = R_SECONDARY,
1798 .peer = R_UNKNOWN,
1799 .conn = C_STANDALONE,
1800 .disk = D_DISKLESS,
1801 .pdsk = D_UNKNOWN,
fb22c402
PR
1802 .susp = 0,
1803 .susp_nod = 0,
1804 .susp_fen = 0
b411b363
PR
1805 } };
1806}
1807
1808void drbd_init_set_defaults(struct drbd_conf *mdev)
1809{
1810 /* the memset(,0,) did most of this.
1811 * note: only assignments, no allocation in here */
1812
1813 drbd_set_defaults(mdev);
1814
b411b363
PR
1815 atomic_set(&mdev->ap_bio_cnt, 0);
1816 atomic_set(&mdev->ap_pending_cnt, 0);
1817 atomic_set(&mdev->rs_pending_cnt, 0);
1818 atomic_set(&mdev->unacked_cnt, 0);
1819 atomic_set(&mdev->local_cnt, 0);
b411b363 1820 atomic_set(&mdev->pp_in_use, 0);
435f0740 1821 atomic_set(&mdev->pp_in_use_by_net, 0);
778f271d 1822 atomic_set(&mdev->rs_sect_in, 0);
0f0601f4 1823 atomic_set(&mdev->rs_sect_ev, 0);
759fbdfb 1824 atomic_set(&mdev->ap_in_flight, 0);
b411b363
PR
1825
1826 mutex_init(&mdev->md_io_mutex);
8410da8f
PR
1827 mutex_init(&mdev->own_state_mutex);
1828 mdev->state_mutex = &mdev->own_state_mutex;
b411b363 1829
b411b363 1830 spin_lock_init(&mdev->al_lock);
b411b363
PR
1831 spin_lock_init(&mdev->peer_seq_lock);
1832 spin_lock_init(&mdev->epoch_lock);
1833
1834 INIT_LIST_HEAD(&mdev->active_ee);
1835 INIT_LIST_HEAD(&mdev->sync_ee);
1836 INIT_LIST_HEAD(&mdev->done_ee);
1837 INIT_LIST_HEAD(&mdev->read_ee);
1838 INIT_LIST_HEAD(&mdev->net_ee);
1839 INIT_LIST_HEAD(&mdev->resync_reads);
b411b363
PR
1840 INIT_LIST_HEAD(&mdev->resync_work.list);
1841 INIT_LIST_HEAD(&mdev->unplug_work.list);
e9e6f3ec 1842 INIT_LIST_HEAD(&mdev->go_diskless.list);
b411b363 1843 INIT_LIST_HEAD(&mdev->md_sync_work.list);
c4752ef1 1844 INIT_LIST_HEAD(&mdev->start_resync_work.list);
b411b363 1845 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
0ced55a3 1846
794abb75 1847 mdev->resync_work.cb = w_resync_timer;
b411b363 1848 mdev->unplug_work.cb = w_send_write_hint;
e9e6f3ec 1849 mdev->go_diskless.cb = w_go_diskless;
b411b363
PR
1850 mdev->md_sync_work.cb = w_md_sync;
1851 mdev->bm_io_work.w.cb = w_bitmap_io;
370a43e7 1852 mdev->start_resync_work.cb = w_start_resync;
a21e9298
PR
1853
1854 mdev->resync_work.mdev = mdev;
1855 mdev->unplug_work.mdev = mdev;
1856 mdev->go_diskless.mdev = mdev;
1857 mdev->md_sync_work.mdev = mdev;
1858 mdev->bm_io_work.w.mdev = mdev;
1859 mdev->start_resync_work.mdev = mdev;
1860
b411b363
PR
1861 init_timer(&mdev->resync_timer);
1862 init_timer(&mdev->md_sync_timer);
370a43e7 1863 init_timer(&mdev->start_resync_timer);
7fde2be9 1864 init_timer(&mdev->request_timer);
b411b363
PR
1865 mdev->resync_timer.function = resync_timer_fn;
1866 mdev->resync_timer.data = (unsigned long) mdev;
1867 mdev->md_sync_timer.function = md_sync_timer_fn;
1868 mdev->md_sync_timer.data = (unsigned long) mdev;
370a43e7
PR
1869 mdev->start_resync_timer.function = start_resync_timer_fn;
1870 mdev->start_resync_timer.data = (unsigned long) mdev;
7fde2be9
PR
1871 mdev->request_timer.function = request_timer_fn;
1872 mdev->request_timer.data = (unsigned long) mdev;
b411b363
PR
1873
1874 init_waitqueue_head(&mdev->misc_wait);
1875 init_waitqueue_head(&mdev->state_wait);
1876 init_waitqueue_head(&mdev->ee_wait);
1877 init_waitqueue_head(&mdev->al_wait);
1878 init_waitqueue_head(&mdev->seq_wait);
1879
fd340c12 1880 /* mdev->tconn->agreed_pro_version gets initialized in drbd_connect() */
2451fc3b 1881 mdev->write_ordering = WO_bdev_flush;
b411b363 1882 mdev->resync_wenr = LC_FREE;
99432fcc
PR
1883 mdev->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
1884 mdev->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
b411b363
PR
1885}
1886
1887void drbd_mdev_cleanup(struct drbd_conf *mdev)
1888{
1d7734a0 1889 int i;
e6b3ea83 1890 if (mdev->tconn->receiver.t_state != NONE)
b411b363 1891 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
e6b3ea83 1892 mdev->tconn->receiver.t_state);
b411b363
PR
1893
1894 /* no need to lock it, I'm the only thread alive */
1895 if (atomic_read(&mdev->current_epoch->epoch_size) != 0)
1896 dev_err(DEV, "epoch_size:%d\n", atomic_read(&mdev->current_epoch->epoch_size));
1897 mdev->al_writ_cnt =
1898 mdev->bm_writ_cnt =
1899 mdev->read_cnt =
1900 mdev->recv_cnt =
1901 mdev->send_cnt =
1902 mdev->writ_cnt =
1903 mdev->p_size =
1904 mdev->rs_start =
1905 mdev->rs_total =
1d7734a0
LE
1906 mdev->rs_failed = 0;
1907 mdev->rs_last_events = 0;
0f0601f4 1908 mdev->rs_last_sect_ev = 0;
1d7734a0
LE
1909 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
1910 mdev->rs_mark_left[i] = 0;
1911 mdev->rs_mark_time[i] = 0;
1912 }
89e58e75 1913 D_ASSERT(mdev->tconn->net_conf == NULL);
b411b363
PR
1914
1915 drbd_set_my_capacity(mdev, 0);
1916 if (mdev->bitmap) {
1917 /* maybe never allocated. */
02d9a94b 1918 drbd_bm_resize(mdev, 0, 1);
b411b363
PR
1919 drbd_bm_cleanup(mdev);
1920 }
1921
1922 drbd_free_resources(mdev);
0778286a 1923 clear_bit(AL_SUSPENDED, &mdev->flags);
b411b363
PR
1924
1925 /*
1926 * currently we drbd_init_ee only on module load, so
1927 * we may do drbd_release_ee only on module unload!
1928 */
1929 D_ASSERT(list_empty(&mdev->active_ee));
1930 D_ASSERT(list_empty(&mdev->sync_ee));
1931 D_ASSERT(list_empty(&mdev->done_ee));
1932 D_ASSERT(list_empty(&mdev->read_ee));
1933 D_ASSERT(list_empty(&mdev->net_ee));
1934 D_ASSERT(list_empty(&mdev->resync_reads));
e42325a5
PR
1935 D_ASSERT(list_empty(&mdev->tconn->data.work.q));
1936 D_ASSERT(list_empty(&mdev->tconn->meta.work.q));
b411b363
PR
1937 D_ASSERT(list_empty(&mdev->resync_work.list));
1938 D_ASSERT(list_empty(&mdev->unplug_work.list));
e9e6f3ec 1939 D_ASSERT(list_empty(&mdev->go_diskless.list));
2265b473
LE
1940
1941 drbd_set_defaults(mdev);
b411b363
PR
1942}
1943
1944
1945static void drbd_destroy_mempools(void)
1946{
1947 struct page *page;
1948
1949 while (drbd_pp_pool) {
1950 page = drbd_pp_pool;
1951 drbd_pp_pool = (struct page *)page_private(page);
1952 __free_page(page);
1953 drbd_pp_vacant--;
1954 }
1955
1956 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
1957
da4a75d2
LE
1958 if (drbd_md_io_bio_set)
1959 bioset_free(drbd_md_io_bio_set);
35abf594
LE
1960 if (drbd_md_io_page_pool)
1961 mempool_destroy(drbd_md_io_page_pool);
b411b363
PR
1962 if (drbd_ee_mempool)
1963 mempool_destroy(drbd_ee_mempool);
1964 if (drbd_request_mempool)
1965 mempool_destroy(drbd_request_mempool);
1966 if (drbd_ee_cache)
1967 kmem_cache_destroy(drbd_ee_cache);
1968 if (drbd_request_cache)
1969 kmem_cache_destroy(drbd_request_cache);
1970 if (drbd_bm_ext_cache)
1971 kmem_cache_destroy(drbd_bm_ext_cache);
1972 if (drbd_al_ext_cache)
1973 kmem_cache_destroy(drbd_al_ext_cache);
1974
da4a75d2 1975 drbd_md_io_bio_set = NULL;
35abf594 1976 drbd_md_io_page_pool = NULL;
b411b363
PR
1977 drbd_ee_mempool = NULL;
1978 drbd_request_mempool = NULL;
1979 drbd_ee_cache = NULL;
1980 drbd_request_cache = NULL;
1981 drbd_bm_ext_cache = NULL;
1982 drbd_al_ext_cache = NULL;
1983
1984 return;
1985}
1986
1987static int drbd_create_mempools(void)
1988{
1989 struct page *page;
1816a2b4 1990 const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;
b411b363
PR
1991 int i;
1992
1993 /* prepare our caches and mempools */
1994 drbd_request_mempool = NULL;
1995 drbd_ee_cache = NULL;
1996 drbd_request_cache = NULL;
1997 drbd_bm_ext_cache = NULL;
1998 drbd_al_ext_cache = NULL;
1999 drbd_pp_pool = NULL;
35abf594 2000 drbd_md_io_page_pool = NULL;
da4a75d2 2001 drbd_md_io_bio_set = NULL;
b411b363
PR
2002
2003 /* caches */
2004 drbd_request_cache = kmem_cache_create(
2005 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2006 if (drbd_request_cache == NULL)
2007 goto Enomem;
2008
2009 drbd_ee_cache = kmem_cache_create(
f6ffca9f 2010 "drbd_ee", sizeof(struct drbd_peer_request), 0, 0, NULL);
b411b363
PR
2011 if (drbd_ee_cache == NULL)
2012 goto Enomem;
2013
2014 drbd_bm_ext_cache = kmem_cache_create(
2015 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2016 if (drbd_bm_ext_cache == NULL)
2017 goto Enomem;
2018
2019 drbd_al_ext_cache = kmem_cache_create(
2020 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2021 if (drbd_al_ext_cache == NULL)
2022 goto Enomem;
2023
2024 /* mempools */
da4a75d2
LE
2025 drbd_md_io_bio_set = bioset_create(DRBD_MIN_POOL_PAGES, 0);
2026 if (drbd_md_io_bio_set == NULL)
2027 goto Enomem;
2028
35abf594
LE
2029 drbd_md_io_page_pool = mempool_create_page_pool(DRBD_MIN_POOL_PAGES, 0);
2030 if (drbd_md_io_page_pool == NULL)
2031 goto Enomem;
2032
b411b363
PR
2033 drbd_request_mempool = mempool_create(number,
2034 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2035 if (drbd_request_mempool == NULL)
2036 goto Enomem;
2037
2038 drbd_ee_mempool = mempool_create(number,
2039 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2027ae1f 2040 if (drbd_ee_mempool == NULL)
b411b363
PR
2041 goto Enomem;
2042
2043 /* drbd's page pool */
2044 spin_lock_init(&drbd_pp_lock);
2045
2046 for (i = 0; i < number; i++) {
2047 page = alloc_page(GFP_HIGHUSER);
2048 if (!page)
2049 goto Enomem;
2050 set_page_private(page, (unsigned long)drbd_pp_pool);
2051 drbd_pp_pool = page;
2052 }
2053 drbd_pp_vacant = number;
2054
2055 return 0;
2056
2057Enomem:
2058 drbd_destroy_mempools(); /* in case we allocated some */
2059 return -ENOMEM;
2060}
2061
2062static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2063 void *unused)
2064{
2065 /* just so we have it. you never know what interesting things we
2066 * might want to do here some day...
2067 */
2068
2069 return NOTIFY_DONE;
2070}
2071
2072static struct notifier_block drbd_notifier = {
2073 .notifier_call = drbd_notify_sys,
2074};
2075
2076static void drbd_release_ee_lists(struct drbd_conf *mdev)
2077{
2078 int rr;
2079
2080 rr = drbd_release_ee(mdev, &mdev->active_ee);
2081 if (rr)
2082 dev_err(DEV, "%d EEs in active list found!\n", rr);
2083
2084 rr = drbd_release_ee(mdev, &mdev->sync_ee);
2085 if (rr)
2086 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2087
2088 rr = drbd_release_ee(mdev, &mdev->read_ee);
2089 if (rr)
2090 dev_err(DEV, "%d EEs in read list found!\n", rr);
2091
2092 rr = drbd_release_ee(mdev, &mdev->done_ee);
2093 if (rr)
2094 dev_err(DEV, "%d EEs in done list found!\n", rr);
2095
2096 rr = drbd_release_ee(mdev, &mdev->net_ee);
2097 if (rr)
2098 dev_err(DEV, "%d EEs in net list found!\n", rr);
2099}
2100
774b3055
PR
2101/* caution. no locking. */
2102void drbd_delete_device(unsigned int minor)
b411b363
PR
2103{
2104 struct drbd_conf *mdev = minor_to_mdev(minor);
2105
2106 if (!mdev)
2107 return;
2108
569083c0
LE
2109 idr_remove(&mdev->tconn->volumes, mdev->vnr);
2110 idr_remove(&minors, minor);
2111 synchronize_rcu();
774b3055 2112
b411b363 2113 /* paranoia asserts */
70dc65e1 2114 D_ASSERT(mdev->open_cnt == 0);
e42325a5 2115 D_ASSERT(list_empty(&mdev->tconn->data.work.q));
b411b363
PR
2116 /* end paranoia asserts */
2117
2118 del_gendisk(mdev->vdisk);
2119
2120 /* cleanup stuff that may have been allocated during
2121 * device (re-)configuration or state changes */
2122
2123 if (mdev->this_bdev)
2124 bdput(mdev->this_bdev);
2125
2126 drbd_free_resources(mdev);
2127
2128 drbd_release_ee_lists(mdev);
2129
b411b363
PR
2130 lc_destroy(mdev->act_log);
2131 lc_destroy(mdev->resync);
2132
2133 kfree(mdev->p_uuid);
2134 /* mdev->p_uuid = NULL; */
2135
b411b363
PR
2136 /* cleanup the rest that has been
2137 * allocated from drbd_new_device
2138 * and actually free the mdev itself */
2139 drbd_free_mdev(mdev);
2140}
2141
2142static void drbd_cleanup(void)
2143{
2144 unsigned int i;
81a5d60e 2145 struct drbd_conf *mdev;
b411b363
PR
2146
2147 unregister_reboot_notifier(&drbd_notifier);
2148
17a93f30
LE
2149 /* first remove proc,
2150 * drbdsetup uses it's presence to detect
2151 * whether DRBD is loaded.
2152 * If we would get stuck in proc removal,
2153 * but have netlink already deregistered,
2154 * some drbdsetup commands may wait forever
2155 * for an answer.
2156 */
2157 if (drbd_proc)
2158 remove_proc_entry("drbd", NULL);
2159
3b98c0c2 2160 drbd_genl_unregister();
b411b363 2161
81a5d60e
PR
2162 idr_for_each_entry(&minors, mdev, i)
2163 drbd_delete_device(i);
2164 drbd_destroy_mempools();
b411b363
PR
2165 unregister_blkdev(DRBD_MAJOR, "drbd");
2166
81a5d60e
PR
2167 idr_destroy(&minors);
2168
b411b363
PR
2169 printk(KERN_INFO "drbd: module cleanup done.\n");
2170}
2171
2172/**
2173 * drbd_congested() - Callback for pdflush
2174 * @congested_data: User data
2175 * @bdi_bits: Bits pdflush is currently interested in
2176 *
2177 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
2178 */
2179static int drbd_congested(void *congested_data, int bdi_bits)
2180{
2181 struct drbd_conf *mdev = congested_data;
2182 struct request_queue *q;
2183 char reason = '-';
2184 int r = 0;
2185
1b881ef7 2186 if (!may_inc_ap_bio(mdev)) {
b411b363
PR
2187 /* DRBD has frozen IO */
2188 r = bdi_bits;
2189 reason = 'd';
2190 goto out;
2191 }
2192
2193 if (get_ldev(mdev)) {
2194 q = bdev_get_queue(mdev->ldev->backing_bdev);
2195 r = bdi_congested(&q->backing_dev_info, bdi_bits);
2196 put_ldev(mdev);
2197 if (r)
2198 reason = 'b';
2199 }
2200
01a311a5 2201 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->tconn->flags)) {
b411b363
PR
2202 r |= (1 << BDI_async_congested);
2203 reason = reason == 'b' ? 'a' : 'n';
2204 }
2205
2206out:
2207 mdev->congestion_reason = reason;
2208 return r;
2209}
2210
6699b655
PR
2211static void drbd_init_workqueue(struct drbd_work_queue* wq)
2212{
2213 sema_init(&wq->s, 0);
2214 spin_lock_init(&wq->q_lock);
2215 INIT_LIST_HEAD(&wq->q);
2216}
2217
1aba4d7f
PR
2218struct drbd_tconn *conn_by_name(const char *name)
2219{
2220 struct drbd_tconn *tconn;
2221
3b98c0c2
LE
2222 if (!name || !name[0])
2223 return NULL;
2224
543cc10b 2225 mutex_lock(&drbd_cfg_mutex);
1aba4d7f
PR
2226 list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
2227 if (!strcmp(tconn->name, name))
2228 goto found;
2229 }
2230 tconn = NULL;
2231found:
543cc10b 2232 mutex_unlock(&drbd_cfg_mutex);
1aba4d7f
PR
2233 return tconn;
2234}
2235
3b98c0c2 2236struct drbd_tconn *drbd_new_tconn(const char *name)
2111438b
PR
2237{
2238 struct drbd_tconn *tconn;
2239
2240 tconn = kzalloc(sizeof(struct drbd_tconn), GFP_KERNEL);
2241 if (!tconn)
2242 return NULL;
2243
2244 tconn->name = kstrdup(name, GFP_KERNEL);
2245 if (!tconn->name)
2246 goto fail;
2247
774b3055
PR
2248 if (!zalloc_cpumask_var(&tconn->cpu_mask, GFP_KERNEL))
2249 goto fail;
2250
2f5cdd0b
PR
2251 if (!tl_init(tconn))
2252 goto fail;
2253
bbeb641c 2254 tconn->cstate = C_STANDALONE;
8410da8f 2255 mutex_init(&tconn->cstate_mutex);
6699b655 2256 spin_lock_init(&tconn->req_lock);
b2fb6dbe
PR
2257 atomic_set(&tconn->net_cnt, 0);
2258 init_waitqueue_head(&tconn->net_cnt_wait);
2a67d8b9 2259 init_waitqueue_head(&tconn->ping_wait);
062e879c 2260 idr_init(&tconn->volumes);
b2fb6dbe 2261
6699b655
PR
2262 drbd_init_workqueue(&tconn->data.work);
2263 mutex_init(&tconn->data.mutex);
2264
2265 drbd_init_workqueue(&tconn->meta.work);
2266 mutex_init(&tconn->meta.mutex);
2267
392c8801
PR
2268 drbd_thread_init(tconn, &tconn->receiver, drbdd_init, "receiver");
2269 drbd_thread_init(tconn, &tconn->worker, drbd_worker, "worker");
2270 drbd_thread_init(tconn, &tconn->asender, drbd_asender, "asender");
2271
f399002e
LE
2272 tconn->res_opts = (struct res_opts) {
2273 {}, 0, /* cpu_mask */
2274 DRBD_ON_NO_DATA_DEF, /* on_no_data */
2275 };
2276
543cc10b
LE
2277 mutex_lock(&drbd_cfg_mutex);
2278 list_add_tail(&tconn->all_tconn, &drbd_tconns);
2279 mutex_unlock(&drbd_cfg_mutex);
2111438b
PR
2280
2281 return tconn;
2282
2283fail:
2f5cdd0b 2284 tl_cleanup(tconn);
774b3055 2285 free_cpumask_var(tconn->cpu_mask);
2111438b
PR
2286 kfree(tconn->name);
2287 kfree(tconn);
2288
2289 return NULL;
2290}
2291
2292void drbd_free_tconn(struct drbd_tconn *tconn)
2293{
2111438b 2294 list_del(&tconn->all_tconn);
062e879c 2295 idr_destroy(&tconn->volumes);
2111438b 2296
774b3055 2297 free_cpumask_var(tconn->cpu_mask);
2111438b 2298 kfree(tconn->name);
b42a70ad
PR
2299 kfree(tconn->int_dig_out);
2300 kfree(tconn->int_dig_in);
2301 kfree(tconn->int_dig_vv);
2111438b
PR
2302 kfree(tconn);
2303}
2304
774b3055 2305enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr)
b411b363
PR
2306{
2307 struct drbd_conf *mdev;
2308 struct gendisk *disk;
2309 struct request_queue *q;
774b3055 2310 int vnr_got = vnr;
81a5d60e 2311 int minor_got = minor;
8432b314 2312 enum drbd_ret_code err = ERR_NOMEM;
774b3055
PR
2313
2314 mdev = minor_to_mdev(minor);
2315 if (mdev)
2316 return ERR_MINOR_EXISTS;
b411b363
PR
2317
2318 /* GFP_KERNEL, we are outside of all write-out paths */
2319 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
2320 if (!mdev)
774b3055
PR
2321 return ERR_NOMEM;
2322
2323 mdev->tconn = tconn;
b411b363 2324 mdev->minor = minor;
3b98c0c2 2325 mdev->vnr = vnr;
b411b363
PR
2326
2327 drbd_init_set_defaults(mdev);
2328
2329 q = blk_alloc_queue(GFP_KERNEL);
2330 if (!q)
2331 goto out_no_q;
2332 mdev->rq_queue = q;
2333 q->queuedata = mdev;
b411b363
PR
2334
2335 disk = alloc_disk(1);
2336 if (!disk)
2337 goto out_no_disk;
2338 mdev->vdisk = disk;
2339
81e84650 2340 set_disk_ro(disk, true);
b411b363
PR
2341
2342 disk->queue = q;
2343 disk->major = DRBD_MAJOR;
2344 disk->first_minor = minor;
2345 disk->fops = &drbd_ops;
2346 sprintf(disk->disk_name, "drbd%d", minor);
2347 disk->private_data = mdev;
2348
2349 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
2350 /* we have no partitions. we contain only ourselves. */
2351 mdev->this_bdev->bd_contains = mdev->this_bdev;
2352
2353 q->backing_dev_info.congested_fn = drbd_congested;
2354 q->backing_dev_info.congested_data = mdev;
2355
2f58dcfc 2356 blk_queue_make_request(q, drbd_make_request);
99432fcc
PR
2357 /* Setting the max_hw_sectors to an odd value of 8kibyte here
2358 This triggers a max_bio_size message upon first attach or connect */
2359 blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
b411b363
PR
2360 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
2361 blk_queue_merge_bvec(q, drbd_merge_bvec);
87eeee41 2362 q->queue_lock = &mdev->tconn->req_lock; /* needed since we use */
b411b363
PR
2363
2364 mdev->md_io_page = alloc_page(GFP_KERNEL);
2365 if (!mdev->md_io_page)
2366 goto out_no_io_page;
2367
2368 if (drbd_bm_init(mdev))
2369 goto out_no_bitmap;
dac1389c 2370 mdev->read_requests = RB_ROOT;
de696716 2371 mdev->write_requests = RB_ROOT;
b411b363 2372
b411b363
PR
2373 mdev->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
2374 if (!mdev->current_epoch)
2375 goto out_no_epoch;
2376
2377 INIT_LIST_HEAD(&mdev->current_epoch->list);
2378 mdev->epochs = 1;
2379
81a5d60e 2380 if (!idr_pre_get(&minors, GFP_KERNEL))
8432b314
LE
2381 goto out_no_minor_idr;
2382 if (idr_get_new_above(&minors, mdev, minor, &minor_got))
2383 goto out_no_minor_idr;
81a5d60e 2384 if (minor_got != minor) {
8432b314
LE
2385 err = ERR_MINOR_EXISTS;
2386 drbd_msg_put_info("requested minor exists already");
569083c0 2387 goto out_idr_remove_minor;
81a5d60e 2388 }
8432b314
LE
2389
2390 if (!idr_pre_get(&tconn->volumes, GFP_KERNEL))
2391 goto out_idr_remove_minor;
2392 if (idr_get_new_above(&tconn->volumes, mdev, vnr, &vnr_got))
2393 goto out_idr_remove_minor;
2394 if (vnr_got != vnr) {
2395 err = ERR_INVALID_REQUEST;
2396 drbd_msg_put_info("requested volume exists already");
2397 goto out_idr_remove_vol;
2398 }
774b3055
PR
2399 add_disk(disk);
2400
2325eb66
PR
2401 /* inherit the connection state */
2402 mdev->state.conn = tconn->cstate;
2403 if (mdev->state.conn == C_WF_REPORT_PARAMS)
2404 drbd_connected(vnr, mdev, tconn);
2405
774b3055 2406 return NO_ERROR;
b411b363 2407
569083c0
LE
2408out_idr_remove_vol:
2409 idr_remove(&tconn->volumes, vnr_got);
8432b314
LE
2410out_idr_remove_minor:
2411 idr_remove(&minors, minor_got);
569083c0 2412 synchronize_rcu();
8432b314 2413out_no_minor_idr:
81a5d60e 2414 kfree(mdev->current_epoch);
b411b363 2415out_no_epoch:
b411b363
PR
2416 drbd_bm_cleanup(mdev);
2417out_no_bitmap:
2418 __free_page(mdev->md_io_page);
2419out_no_io_page:
2420 put_disk(disk);
2421out_no_disk:
2422 blk_cleanup_queue(q);
2423out_no_q:
b411b363 2424 kfree(mdev);
8432b314 2425 return err;
b411b363
PR
2426}
2427
2428/* counterpart of drbd_new_device.
2429 * last part of drbd_delete_device. */
2430void drbd_free_mdev(struct drbd_conf *mdev)
2431{
2432 kfree(mdev->current_epoch);
b411b363
PR
2433 if (mdev->bitmap) /* should no longer be there. */
2434 drbd_bm_cleanup(mdev);
2435 __free_page(mdev->md_io_page);
2436 put_disk(mdev->vdisk);
2437 blk_cleanup_queue(mdev->rq_queue);
b411b363
PR
2438 kfree(mdev);
2439}
2440
2441
2442int __init drbd_init(void)
2443{
2444 int err;
2445
fd340c12
PR
2446 BUILD_BUG_ON(sizeof(struct p_header80) != sizeof(struct p_header95));
2447 BUILD_BUG_ON(sizeof(struct p_handshake) != 80);
b411b363 2448
2b8a90b5 2449 if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {
b411b363 2450 printk(KERN_ERR
81a5d60e 2451 "drbd: invalid minor_count (%d)\n", minor_count);
b411b363
PR
2452#ifdef MODULE
2453 return -EINVAL;
2454#else
2455 minor_count = 8;
2456#endif
2457 }
2458
b411b363
PR
2459 err = register_blkdev(DRBD_MAJOR, "drbd");
2460 if (err) {
2461 printk(KERN_ERR
2462 "drbd: unable to register block device major %d\n",
2463 DRBD_MAJOR);
2464 return err;
2465 }
2466
3b98c0c2
LE
2467 err = drbd_genl_register();
2468 if (err) {
2469 printk(KERN_ERR "drbd: unable to register generic netlink family\n");
2470 goto fail;
2471 }
2472
2473
b411b363
PR
2474 register_reboot_notifier(&drbd_notifier);
2475
2476 /*
2477 * allocate all necessary structs
2478 */
2479 err = -ENOMEM;
2480
2481 init_waitqueue_head(&drbd_pp_wait);
2482
2483 drbd_proc = NULL; /* play safe for drbd_cleanup */
81a5d60e 2484 idr_init(&minors);
b411b363
PR
2485
2486 err = drbd_create_mempools();
2487 if (err)
3b98c0c2 2488 goto fail;
b411b363 2489
8c484ee4 2490 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
b411b363
PR
2491 if (!drbd_proc) {
2492 printk(KERN_ERR "drbd: unable to register proc file\n");
3b98c0c2 2493 goto fail;
b411b363
PR
2494 }
2495
2496 rwlock_init(&global_state_lock);
2111438b 2497 INIT_LIST_HEAD(&drbd_tconns);
b411b363
PR
2498
2499 printk(KERN_INFO "drbd: initialized. "
2500 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
2501 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
2502 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
2503 printk(KERN_INFO "drbd: registered as block device major %d\n",
2504 DRBD_MAJOR);
b411b363
PR
2505
2506 return 0; /* Success! */
2507
3b98c0c2 2508fail:
b411b363
PR
2509 drbd_cleanup();
2510 if (err == -ENOMEM)
2511 /* currently always the case */
2512 printk(KERN_ERR "drbd: ran out of memory\n");
2513 else
2514 printk(KERN_ERR "drbd: initialization failure\n");
2515 return err;
2516}
2517
2518void drbd_free_bc(struct drbd_backing_dev *ldev)
2519{
2520 if (ldev == NULL)
2521 return;
2522
e525fd89
TH
2523 blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2524 blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
b411b363
PR
2525
2526 kfree(ldev);
2527}
2528
360cc740
PR
2529void drbd_free_sock(struct drbd_tconn *tconn)
2530{
2531 if (tconn->data.socket) {
2532 mutex_lock(&tconn->data.mutex);
2533 kernel_sock_shutdown(tconn->data.socket, SHUT_RDWR);
2534 sock_release(tconn->data.socket);
2535 tconn->data.socket = NULL;
2536 mutex_unlock(&tconn->data.mutex);
b411b363 2537 }
360cc740
PR
2538 if (tconn->meta.socket) {
2539 mutex_lock(&tconn->meta.mutex);
2540 kernel_sock_shutdown(tconn->meta.socket, SHUT_RDWR);
2541 sock_release(tconn->meta.socket);
2542 tconn->meta.socket = NULL;
2543 mutex_unlock(&tconn->meta.mutex);
b411b363
PR
2544 }
2545}
2546
2547
2548void drbd_free_resources(struct drbd_conf *mdev)
2549{
f399002e
LE
2550 crypto_free_hash(mdev->tconn->csums_tfm);
2551 mdev->tconn->csums_tfm = NULL;
2552 crypto_free_hash(mdev->tconn->verify_tfm);
2553 mdev->tconn->verify_tfm = NULL;
a0638456
PR
2554 crypto_free_hash(mdev->tconn->cram_hmac_tfm);
2555 mdev->tconn->cram_hmac_tfm = NULL;
2556 crypto_free_hash(mdev->tconn->integrity_w_tfm);
2557 mdev->tconn->integrity_w_tfm = NULL;
2558 crypto_free_hash(mdev->tconn->integrity_r_tfm);
2559 mdev->tconn->integrity_r_tfm = NULL;
b411b363 2560
360cc740 2561 drbd_free_sock(mdev->tconn);
b411b363
PR
2562
2563 __no_warn(local,
2564 drbd_free_bc(mdev->ldev);
2565 mdev->ldev = NULL;);
2566}
2567
2568/* meta data management */
2569
2570struct meta_data_on_disk {
2571 u64 la_size; /* last agreed size. */
2572 u64 uuid[UI_SIZE]; /* UUIDs. */
2573 u64 device_uuid;
2574 u64 reserved_u64_1;
2575 u32 flags; /* MDF */
2576 u32 magic;
2577 u32 md_size_sect;
2578 u32 al_offset; /* offset to this block */
2579 u32 al_nr_extents; /* important for restoring the AL */
f399002e 2580 /* `-- act_log->nr_elements <-- ldev->dc.al_extents */
b411b363
PR
2581 u32 bm_offset; /* offset to the bitmap, from here */
2582 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
99432fcc
PR
2583 u32 la_peer_max_bio_size; /* last peer max_bio_size */
2584 u32 reserved_u32[3];
b411b363
PR
2585
2586} __packed;
2587
2588/**
2589 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
2590 * @mdev: DRBD device.
2591 */
2592void drbd_md_sync(struct drbd_conf *mdev)
2593{
2594 struct meta_data_on_disk *buffer;
2595 sector_t sector;
2596 int i;
2597
ee15b038
LE
2598 del_timer(&mdev->md_sync_timer);
2599 /* timer may be rearmed by drbd_md_mark_dirty() now. */
b411b363
PR
2600 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
2601 return;
b411b363
PR
2602
2603 /* We use here D_FAILED and not D_ATTACHING because we try to write
2604 * metadata even if we detach due to a disk failure! */
2605 if (!get_ldev_if_state(mdev, D_FAILED))
2606 return;
2607
b411b363
PR
2608 mutex_lock(&mdev->md_io_mutex);
2609 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
2610 memset(buffer, 0, 512);
2611
2612 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
2613 for (i = UI_CURRENT; i < UI_SIZE; i++)
2614 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
2615 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
2616 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC);
2617
2618 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
2619 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
2620 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
2621 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
2622 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
2623
2624 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
99432fcc 2625 buffer->la_peer_max_bio_size = cpu_to_be32(mdev->peer_max_bio_size);
b411b363
PR
2626
2627 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
2628 sector = mdev->ldev->md.md_offset;
2629
3f3a9b84 2630 if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
b411b363
PR
2631 /* this was a try anyways ... */
2632 dev_err(DEV, "meta data update failed!\n");
81e84650 2633 drbd_chk_io_error(mdev, 1, true);
b411b363
PR
2634 }
2635
2636 /* Update mdev->ldev->md.la_size_sect,
2637 * since we updated it on metadata. */
2638 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
2639
2640 mutex_unlock(&mdev->md_io_mutex);
2641 put_ldev(mdev);
2642}
2643
2644/**
2645 * drbd_md_read() - Reads in the meta data super block
2646 * @mdev: DRBD device.
2647 * @bdev: Device from which the meta data should be read in.
2648 *
116676ca 2649 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
b411b363
PR
2650 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
2651 */
2652int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
2653{
2654 struct meta_data_on_disk *buffer;
2655 int i, rv = NO_ERROR;
2656
2657 if (!get_ldev_if_state(mdev, D_ATTACHING))
2658 return ERR_IO_MD_DISK;
2659
b411b363
PR
2660 mutex_lock(&mdev->md_io_mutex);
2661 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
2662
2663 if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
25985edc 2664 /* NOTE: can't do normal error processing here as this is
b411b363
PR
2665 called BEFORE disk is attached */
2666 dev_err(DEV, "Error while reading metadata.\n");
2667 rv = ERR_IO_MD_DISK;
2668 goto err;
2669 }
2670
e7fad8af 2671 if (buffer->magic != cpu_to_be32(DRBD_MD_MAGIC)) {
b411b363
PR
2672 dev_err(DEV, "Error while reading metadata, magic not found.\n");
2673 rv = ERR_MD_INVALID;
2674 goto err;
2675 }
2676 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
2677 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
2678 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
2679 rv = ERR_MD_INVALID;
2680 goto err;
2681 }
2682 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
2683 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
2684 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
2685 rv = ERR_MD_INVALID;
2686 goto err;
2687 }
2688 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
2689 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
2690 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
2691 rv = ERR_MD_INVALID;
2692 goto err;
2693 }
2694
2695 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
2696 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
2697 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
2698 rv = ERR_MD_INVALID;
2699 goto err;
2700 }
2701
2702 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
2703 for (i = UI_CURRENT; i < UI_SIZE; i++)
2704 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
2705 bdev->md.flags = be32_to_cpu(buffer->flags);
f399002e 2706 bdev->dc.al_extents = be32_to_cpu(buffer->al_nr_extents);
b411b363
PR
2707 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
2708
87eeee41 2709 spin_lock_irq(&mdev->tconn->req_lock);
99432fcc
PR
2710 if (mdev->state.conn < C_CONNECTED) {
2711 int peer;
2712 peer = be32_to_cpu(buffer->la_peer_max_bio_size);
2713 peer = max_t(int, peer, DRBD_MAX_BIO_SIZE_SAFE);
2714 mdev->peer_max_bio_size = peer;
2715 }
87eeee41 2716 spin_unlock_irq(&mdev->tconn->req_lock);
99432fcc 2717
f399002e
LE
2718 if (bdev->dc.al_extents < 7)
2719 bdev->dc.al_extents = 127;
b411b363
PR
2720
2721 err:
2722 mutex_unlock(&mdev->md_io_mutex);
2723 put_ldev(mdev);
2724
2725 return rv;
2726}
2727
2728/**
2729 * drbd_md_mark_dirty() - Mark meta data super block as dirty
2730 * @mdev: DRBD device.
2731 *
2732 * Call this function if you change anything that should be written to
2733 * the meta-data super block. This function sets MD_DIRTY, and starts a
2734 * timer that ensures that within five seconds you have to call drbd_md_sync().
2735 */
ca0e6098 2736#ifdef DEBUG
ee15b038
LE
2737void drbd_md_mark_dirty_(struct drbd_conf *mdev, unsigned int line, const char *func)
2738{
2739 if (!test_and_set_bit(MD_DIRTY, &mdev->flags)) {
2740 mod_timer(&mdev->md_sync_timer, jiffies + HZ);
2741 mdev->last_md_mark_dirty.line = line;
2742 mdev->last_md_mark_dirty.func = func;
2743 }
2744}
2745#else
b411b363
PR
2746void drbd_md_mark_dirty(struct drbd_conf *mdev)
2747{
ee15b038 2748 if (!test_and_set_bit(MD_DIRTY, &mdev->flags))
ca0e6098 2749 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
b411b363 2750}
ee15b038 2751#endif
b411b363
PR
2752
2753static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
2754{
2755 int i;
2756
62b0da3a 2757 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
b411b363 2758 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
b411b363
PR
2759}
2760
2761void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
2762{
2763 if (idx == UI_CURRENT) {
2764 if (mdev->state.role == R_PRIMARY)
2765 val |= 1;
2766 else
2767 val &= ~((u64)1);
2768
2769 drbd_set_ed_uuid(mdev, val);
2770 }
2771
2772 mdev->ldev->md.uuid[idx] = val;
b411b363
PR
2773 drbd_md_mark_dirty(mdev);
2774}
2775
2776
2777void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
2778{
2779 if (mdev->ldev->md.uuid[idx]) {
2780 drbd_uuid_move_history(mdev);
2781 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
b411b363
PR
2782 }
2783 _drbd_uuid_set(mdev, idx, val);
2784}
2785
2786/**
2787 * drbd_uuid_new_current() - Creates a new current UUID
2788 * @mdev: DRBD device.
2789 *
2790 * Creates a new current UUID, and rotates the old current UUID into
2791 * the bitmap slot. Causes an incremental resync upon next connect.
2792 */
2793void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
2794{
2795 u64 val;
62b0da3a
LE
2796 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
2797
2798 if (bm_uuid)
2799 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
b411b363 2800
b411b363 2801 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
b411b363
PR
2802
2803 get_random_bytes(&val, sizeof(u64));
2804 _drbd_uuid_set(mdev, UI_CURRENT, val);
62b0da3a 2805 drbd_print_uuids(mdev, "new current UUID");
aaa8e2b3
LE
2806 /* get it to stable storage _now_ */
2807 drbd_md_sync(mdev);
b411b363
PR
2808}
2809
2810void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
2811{
2812 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
2813 return;
2814
2815 if (val == 0) {
2816 drbd_uuid_move_history(mdev);
2817 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
2818 mdev->ldev->md.uuid[UI_BITMAP] = 0;
b411b363 2819 } else {
62b0da3a
LE
2820 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
2821 if (bm_uuid)
2822 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
b411b363 2823
62b0da3a 2824 mdev->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);
b411b363
PR
2825 }
2826 drbd_md_mark_dirty(mdev);
2827}
2828
2829/**
2830 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
2831 * @mdev: DRBD device.
2832 *
2833 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
2834 */
2835int drbd_bmio_set_n_write(struct drbd_conf *mdev)
2836{
2837 int rv = -EIO;
2838
2839 if (get_ldev_if_state(mdev, D_ATTACHING)) {
2840 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
2841 drbd_md_sync(mdev);
2842 drbd_bm_set_all(mdev);
2843
2844 rv = drbd_bm_write(mdev);
2845
2846 if (!rv) {
2847 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
2848 drbd_md_sync(mdev);
2849 }
2850
2851 put_ldev(mdev);
2852 }
2853
2854 return rv;
2855}
2856
2857/**
2858 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
2859 * @mdev: DRBD device.
2860 *
2861 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
2862 */
2863int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
2864{
2865 int rv = -EIO;
2866
0778286a 2867 drbd_resume_al(mdev);
b411b363
PR
2868 if (get_ldev_if_state(mdev, D_ATTACHING)) {
2869 drbd_bm_clear_all(mdev);
2870 rv = drbd_bm_write(mdev);
2871 put_ldev(mdev);
2872 }
2873
2874 return rv;
2875}
2876
00d56944 2877static int w_bitmap_io(struct drbd_work *w, int unused)
b411b363
PR
2878{
2879 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
00d56944 2880 struct drbd_conf *mdev = w->mdev;
02851e9f 2881 int rv = -EIO;
b411b363
PR
2882
2883 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
2884
02851e9f 2885 if (get_ldev(mdev)) {
20ceb2b2 2886 drbd_bm_lock(mdev, work->why, work->flags);
02851e9f
LE
2887 rv = work->io_fn(mdev);
2888 drbd_bm_unlock(mdev);
2889 put_ldev(mdev);
2890 }
b411b363 2891
4738fa16 2892 clear_bit_unlock(BITMAP_IO, &mdev->flags);
b411b363
PR
2893 wake_up(&mdev->misc_wait);
2894
2895 if (work->done)
2896 work->done(mdev, rv);
2897
2898 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
2899 work->why = NULL;
20ceb2b2 2900 work->flags = 0;
b411b363
PR
2901
2902 return 1;
2903}
2904
82f59cc6
LE
2905void drbd_ldev_destroy(struct drbd_conf *mdev)
2906{
2907 lc_destroy(mdev->resync);
2908 mdev->resync = NULL;
2909 lc_destroy(mdev->act_log);
2910 mdev->act_log = NULL;
2911 __no_warn(local,
2912 drbd_free_bc(mdev->ldev);
2913 mdev->ldev = NULL;);
2914
82f59cc6
LE
2915 clear_bit(GO_DISKLESS, &mdev->flags);
2916}
2917
00d56944 2918static int w_go_diskless(struct drbd_work *w, int unused)
e9e6f3ec 2919{
00d56944
PR
2920 struct drbd_conf *mdev = w->mdev;
2921
e9e6f3ec 2922 D_ASSERT(mdev->state.disk == D_FAILED);
9d282875
LE
2923 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
2924 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
82f59cc6
LE
2925 * the protected members anymore, though, so once put_ldev reaches zero
2926 * again, it will be safe to free them. */
e9e6f3ec 2927 drbd_force_state(mdev, NS(disk, D_DISKLESS));
e9e6f3ec
LE
2928 return 1;
2929}
2930
2931void drbd_go_diskless(struct drbd_conf *mdev)
2932{
2933 D_ASSERT(mdev->state.disk == D_FAILED);
2934 if (!test_and_set_bit(GO_DISKLESS, &mdev->flags))
e42325a5 2935 drbd_queue_work(&mdev->tconn->data.work, &mdev->go_diskless);
e9e6f3ec
LE
2936}
2937
b411b363
PR
2938/**
2939 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
2940 * @mdev: DRBD device.
2941 * @io_fn: IO callback to be called when bitmap IO is possible
2942 * @done: callback to be called after the bitmap IO was performed
2943 * @why: Descriptive text of the reason for doing the IO
2944 *
2945 * While IO on the bitmap happens we freeze application IO thus we ensure
2946 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
2947 * called from worker context. It MUST NOT be used while a previous such
2948 * work is still pending!
2949 */
2950void drbd_queue_bitmap_io(struct drbd_conf *mdev,
2951 int (*io_fn)(struct drbd_conf *),
2952 void (*done)(struct drbd_conf *, int),
20ceb2b2 2953 char *why, enum bm_flag flags)
b411b363 2954{
e6b3ea83 2955 D_ASSERT(current == mdev->tconn->worker.task);
b411b363
PR
2956
2957 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
2958 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
2959 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
2960 if (mdev->bm_io_work.why)
2961 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
2962 why, mdev->bm_io_work.why);
2963
2964 mdev->bm_io_work.io_fn = io_fn;
2965 mdev->bm_io_work.done = done;
2966 mdev->bm_io_work.why = why;
20ceb2b2 2967 mdev->bm_io_work.flags = flags;
b411b363 2968
87eeee41 2969 spin_lock_irq(&mdev->tconn->req_lock);
b411b363
PR
2970 set_bit(BITMAP_IO, &mdev->flags);
2971 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
127b3178 2972 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
e42325a5 2973 drbd_queue_work(&mdev->tconn->data.work, &mdev->bm_io_work.w);
b411b363 2974 }
87eeee41 2975 spin_unlock_irq(&mdev->tconn->req_lock);
b411b363
PR
2976}
2977
2978/**
2979 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
2980 * @mdev: DRBD device.
2981 * @io_fn: IO callback to be called when bitmap IO is possible
2982 * @why: Descriptive text of the reason for doing the IO
2983 *
2984 * freezes application IO while that the actual IO operations runs. This
2985 * functions MAY NOT be called from worker context.
2986 */
20ceb2b2
LE
2987int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *),
2988 char *why, enum bm_flag flags)
b411b363
PR
2989{
2990 int rv;
2991
e6b3ea83 2992 D_ASSERT(current != mdev->tconn->worker.task);
b411b363 2993
20ceb2b2
LE
2994 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
2995 drbd_suspend_io(mdev);
b411b363 2996
20ceb2b2 2997 drbd_bm_lock(mdev, why, flags);
b411b363
PR
2998 rv = io_fn(mdev);
2999 drbd_bm_unlock(mdev);
3000
20ceb2b2
LE
3001 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3002 drbd_resume_io(mdev);
b411b363
PR
3003
3004 return rv;
3005}
3006
3007void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3008{
3009 if ((mdev->ldev->md.flags & flag) != flag) {
3010 drbd_md_mark_dirty(mdev);
3011 mdev->ldev->md.flags |= flag;
3012 }
3013}
3014
3015void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3016{
3017 if ((mdev->ldev->md.flags & flag) != 0) {
3018 drbd_md_mark_dirty(mdev);
3019 mdev->ldev->md.flags &= ~flag;
3020 }
3021}
3022int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3023{
3024 return (bdev->md.flags & flag) != 0;
3025}
3026
3027static void md_sync_timer_fn(unsigned long data)
3028{
3029 struct drbd_conf *mdev = (struct drbd_conf *) data;
3030
e42325a5 3031 drbd_queue_work_front(&mdev->tconn->data.work, &mdev->md_sync_work);
b411b363
PR
3032}
3033
00d56944 3034static int w_md_sync(struct drbd_work *w, int unused)
b411b363 3035{
00d56944
PR
3036 struct drbd_conf *mdev = w->mdev;
3037
b411b363 3038 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
ee15b038
LE
3039#ifdef DEBUG
3040 dev_warn(DEV, "last md_mark_dirty: %s:%u\n",
3041 mdev->last_md_mark_dirty.func, mdev->last_md_mark_dirty.line);
3042#endif
b411b363 3043 drbd_md_sync(mdev);
b411b363
PR
3044 return 1;
3045}
3046
d8763023 3047const char *cmdname(enum drbd_packet cmd)
f2ad9063
AG
3048{
3049 /* THINK may need to become several global tables
3050 * when we want to support more than
3051 * one PRO_VERSION */
3052 static const char *cmdnames[] = {
3053 [P_DATA] = "Data",
3054 [P_DATA_REPLY] = "DataReply",
3055 [P_RS_DATA_REPLY] = "RSDataReply",
3056 [P_BARRIER] = "Barrier",
3057 [P_BITMAP] = "ReportBitMap",
3058 [P_BECOME_SYNC_TARGET] = "BecomeSyncTarget",
3059 [P_BECOME_SYNC_SOURCE] = "BecomeSyncSource",
3060 [P_UNPLUG_REMOTE] = "UnplugRemote",
3061 [P_DATA_REQUEST] = "DataRequest",
3062 [P_RS_DATA_REQUEST] = "RSDataRequest",
3063 [P_SYNC_PARAM] = "SyncParam",
3064 [P_SYNC_PARAM89] = "SyncParam89",
3065 [P_PROTOCOL] = "ReportProtocol",
3066 [P_UUIDS] = "ReportUUIDs",
3067 [P_SIZES] = "ReportSizes",
3068 [P_STATE] = "ReportState",
3069 [P_SYNC_UUID] = "ReportSyncUUID",
3070 [P_AUTH_CHALLENGE] = "AuthChallenge",
3071 [P_AUTH_RESPONSE] = "AuthResponse",
3072 [P_PING] = "Ping",
3073 [P_PING_ACK] = "PingAck",
3074 [P_RECV_ACK] = "RecvAck",
3075 [P_WRITE_ACK] = "WriteAck",
3076 [P_RS_WRITE_ACK] = "RSWriteAck",
7be8da07 3077 [P_DISCARD_WRITE] = "DiscardWrite",
f2ad9063
AG
3078 [P_NEG_ACK] = "NegAck",
3079 [P_NEG_DREPLY] = "NegDReply",
3080 [P_NEG_RS_DREPLY] = "NegRSDReply",
3081 [P_BARRIER_ACK] = "BarrierAck",
3082 [P_STATE_CHG_REQ] = "StateChgRequest",
3083 [P_STATE_CHG_REPLY] = "StateChgReply",
3084 [P_OV_REQUEST] = "OVRequest",
3085 [P_OV_REPLY] = "OVReply",
3086 [P_OV_RESULT] = "OVResult",
3087 [P_CSUM_RS_REQUEST] = "CsumRSRequest",
3088 [P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
3089 [P_COMPRESSED_BITMAP] = "CBitmap",
3090 [P_DELAY_PROBE] = "DelayProbe",
3091 [P_OUT_OF_SYNC] = "OutOfSync",
7be8da07 3092 [P_RETRY_WRITE] = "RetryWrite",
f2ad9063
AG
3093 };
3094
3095 if (cmd == P_HAND_SHAKE_M)
3096 return "HandShakeM";
3097 if (cmd == P_HAND_SHAKE_S)
3098 return "HandShakeS";
3099 if (cmd == P_HAND_SHAKE)
3100 return "HandShake";
6e849ce8 3101 if (cmd >= ARRAY_SIZE(cmdnames))
f2ad9063
AG
3102 return "Unknown";
3103 return cmdnames[cmd];
3104}
3105
7be8da07
AG
3106/**
3107 * drbd_wait_misc - wait for a request to make progress
3108 * @mdev: device associated with the request
3109 * @i: the struct drbd_interval embedded in struct drbd_request or
3110 * struct drbd_peer_request
3111 */
3112int drbd_wait_misc(struct drbd_conf *mdev, struct drbd_interval *i)
3113{
3114 struct net_conf *net_conf = mdev->tconn->net_conf;
3115 DEFINE_WAIT(wait);
3116 long timeout;
3117
3118 if (!net_conf)
3119 return -ETIMEDOUT;
3120 timeout = MAX_SCHEDULE_TIMEOUT;
3121 if (net_conf->ko_count)
3122 timeout = net_conf->timeout * HZ / 10 * net_conf->ko_count;
3123
3124 /* Indicate to wake up mdev->misc_wait on progress. */
3125 i->waiting = true;
3126 prepare_to_wait(&mdev->misc_wait, &wait, TASK_INTERRUPTIBLE);
3127 spin_unlock_irq(&mdev->tconn->req_lock);
3128 timeout = schedule_timeout(timeout);
3129 finish_wait(&mdev->misc_wait, &wait);
3130 spin_lock_irq(&mdev->tconn->req_lock);
3131 if (!timeout || mdev->state.conn < C_CONNECTED)
3132 return -ETIMEDOUT;
3133 if (signal_pending(current))
3134 return -ERESTARTSYS;
3135 return 0;
3136}
3137
b411b363
PR
3138#ifdef CONFIG_DRBD_FAULT_INJECTION
3139/* Fault insertion support including random number generator shamelessly
3140 * stolen from kernel/rcutorture.c */
3141struct fault_random_state {
3142 unsigned long state;
3143 unsigned long count;
3144};
3145
3146#define FAULT_RANDOM_MULT 39916801 /* prime */
3147#define FAULT_RANDOM_ADD 479001701 /* prime */
3148#define FAULT_RANDOM_REFRESH 10000
3149
3150/*
3151 * Crude but fast random-number generator. Uses a linear congruential
3152 * generator, with occasional help from get_random_bytes().
3153 */
3154static unsigned long
3155_drbd_fault_random(struct fault_random_state *rsp)
3156{
3157 long refresh;
3158
49829ea7 3159 if (!rsp->count--) {
b411b363
PR
3160 get_random_bytes(&refresh, sizeof(refresh));
3161 rsp->state += refresh;
3162 rsp->count = FAULT_RANDOM_REFRESH;
3163 }
3164 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3165 return swahw32(rsp->state);
3166}
3167
3168static char *
3169_drbd_fault_str(unsigned int type) {
3170 static char *_faults[] = {
3171 [DRBD_FAULT_MD_WR] = "Meta-data write",
3172 [DRBD_FAULT_MD_RD] = "Meta-data read",
3173 [DRBD_FAULT_RS_WR] = "Resync write",
3174 [DRBD_FAULT_RS_RD] = "Resync read",
3175 [DRBD_FAULT_DT_WR] = "Data write",
3176 [DRBD_FAULT_DT_RD] = "Data read",
3177 [DRBD_FAULT_DT_RA] = "Data read ahead",
3178 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
6b4388ac
PR
3179 [DRBD_FAULT_AL_EE] = "EE allocation",
3180 [DRBD_FAULT_RECEIVE] = "receive data corruption",
b411b363
PR
3181 };
3182
3183 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3184}
3185
3186unsigned int
3187_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3188{
3189 static struct fault_random_state rrs = {0, 0};
3190
3191 unsigned int ret = (
3192 (fault_devs == 0 ||
3193 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3194 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3195
3196 if (ret) {
3197 fault_count++;
3198
7383506c 3199 if (__ratelimit(&drbd_ratelimit_state))
b411b363
PR
3200 dev_warn(DEV, "***Simulating %s failure\n",
3201 _drbd_fault_str(type));
3202 }
3203
3204 return ret;
3205}
3206#endif
3207
3208const char *drbd_buildtag(void)
3209{
3210 /* DRBD built from external sources has here a reference to the
3211 git hash of the source code. */
3212
3213 static char buildtag[38] = "\0uilt-in";
3214
3215 if (buildtag[0] == 0) {
3216#ifdef CONFIG_MODULES
3217 if (THIS_MODULE != NULL)
3218 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3219 else
3220#endif
3221 buildtag[0] = 'b';
3222 }
3223
3224 return buildtag;
3225}
3226
3227module_init(drbd_init)
3228module_exit(drbd_cleanup)
3229
b411b363
PR
3230EXPORT_SYMBOL(drbd_conn_str);
3231EXPORT_SYMBOL(drbd_role_str);
3232EXPORT_SYMBOL(drbd_disk_str);
3233EXPORT_SYMBOL(drbd_set_st_err_str);