projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drbd: drbd_send_block(): Return 0 upon success and an error code otherwise
[deliverable/linux.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 1251{
b411b363
PR		 1252 struct p_block_ack p;
1253
1254 p.sector = sector;
1255 p.block_id = block_id;
1256 p.blksize = blksize;
8ccf218e 1257 p.seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
b411b363 1258
e42325a5 1259 if (!mdev->tconn->meta.socket || mdev->state.conn < C_CONNECTED)
a8c32aa8
AG		 1260 return -EIO;
1261 return drbd_send_cmd(mdev, &mdev->tconn->meta, cmd, &p.head, sizeof(p));
b411b363
PR		 1262}
1263
2b2bf214
LE		 1264/* dp->sector and dp->block_id already/still in network byte order,
1265 * data_size is payload size according to dp->head,
1266 * and may need to be corrected for digest size. */
a9a9994d
AG		 1267void drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
1268 struct p_data *dp, int data_size)
b411b363 1269{
a0638456
PR		 1270 data_size -= (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
1271 crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
a9a9994d
AG		 1272 _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
1273 dp->block_id);
b411b363
PR		 1274}
1275
a9a9994d
AG		 1276void drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
1277 struct p_block_req *rp)
b411b363 1278{
a9a9994d 1279 _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
b411b363
PR		 1280}
1281
1282/**
1283 * drbd_send_ack() - Sends an ack packet
db830c46
AG		 1284 * @mdev: DRBD device
1285 * @cmd: packet command code
1286 * @peer_req: peer request
b411b363 1287 */
d8763023 1288int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
db830c46 1289 struct drbd_peer_request *peer_req)
b411b363 1290{
dd516121
AG		 1291 return _drbd_send_ack(mdev, cmd,
1292 cpu_to_be64(peer_req->i.sector),
1293 cpu_to_be32(peer_req->i.size),
1294 peer_req->block_id);
b411b363
PR		 1295}
1296
1297/* This function misuses the block_id field to signal if the blocks
1298 * are is sync or not. */
d8763023 1299int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
b411b363
PR		 1300 sector_t sector, int blksize, u64 block_id)
1301{
fa79abd8
AG		 1302 return _drbd_send_ack(mdev, cmd,
1303 cpu_to_be64(sector),
1304 cpu_to_be32(blksize),
1305 cpu_to_be64(block_id));
b411b363
PR		 1306}
1307
1308int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1309 sector_t sector, int size, u64 block_id)
1310{
b411b363
PR		 1311 struct p_block_req p;
1312
1313 p.sector = cpu_to_be64(sector);
1314 p.block_id = block_id;
1315 p.blksize = cpu_to_be32(size);
1316
6c1005e7 1317 return drbd_send_cmd(mdev, &mdev->tconn->data, cmd, &p.head, sizeof(p));
b411b363
PR		 1318}
1319
d8763023
AG		 1320int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector, int size,
1321 void *digest, int digest_size, enum drbd_packet cmd)
b411b363 1322{
db1b0b72 1323 int err;
b411b363
PR		 1324 struct p_block_req p;
1325
fd340c12 1326 prepare_header(mdev, &p.head, cmd, sizeof(p) - sizeof(struct p_header) + digest_size);
b411b363 1327 p.sector = cpu_to_be64(sector);
9a8e7753 1328 p.block_id = ID_SYNCER /* unused */;
b411b363
PR		 1329 p.blksize = cpu_to_be32(size);
1330
e42325a5 1331 mutex_lock(&mdev->tconn->data.mutex);
db1b0b72
AG		 1332 err = drbd_send_all(mdev->tconn, mdev->tconn->data.socket, &p, sizeof(p), 0);
1333 if (!err)
1334 err = drbd_send_all(mdev->tconn, mdev->tconn->data.socket, digest, digest_size, 0);
e42325a5 1335 mutex_unlock(&mdev->tconn->data.mutex);
db1b0b72 1336 return err;
b411b363
PR		 1337}
1338
1339int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
1340{
b411b363
PR		 1341 struct p_block_req p;
1342
1343 p.sector = cpu_to_be64(sector);
9a8e7753 1344 p.block_id = ID_SYNCER /* unused */;
b411b363
PR		 1345 p.blksize = cpu_to_be32(size);
1346
5b9f499c 1347 return drbd_send_cmd(mdev, &mdev->tconn->data, P_OV_REQUEST, &p.head, sizeof(p));
b411b363
PR		 1348}
1349
1350/* called on sndtimeo
81e84650
AG		 1351 * returns false if we should retry,
1352 * true if we think connection is dead
b411b363 1353 */
1a7ba646 1354static int we_should_drop_the_connection(struct drbd_tconn *tconn, struct socket *sock)
b411b363
PR		 1355{
1356 int drop_it;
1357 /* long elapsed = (long)(jiffies - mdev->last_received); */
1358
1a7ba646
PR		 1359 drop_it = tconn->meta.socket == sock
1360 || !tconn->asender.task
1361 || get_t_state(&tconn->asender) != RUNNING
bbeb641c 1362 || tconn->cstate < C_WF_REPORT_PARAMS;
b411b363
PR		 1363
1364 if (drop_it)
81e84650 1365 return true;
b411b363 1366
1a7ba646 1367 drop_it = !--tconn->ko_count;
b411b363 1368 if (!drop_it) {
1a7ba646
PR		 1369 conn_err(tconn, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1370 current->comm, current->pid, tconn->ko_count);
1371 request_ping(tconn);
b411b363
PR		 1372 }
1373
1374 return drop_it; /* && (mdev->state == R_PRIMARY) */;
1375}
1376
1a7ba646 1377static void drbd_update_congested(struct drbd_tconn *tconn)
9e204cdd 1378{
1a7ba646 1379 struct sock *sk = tconn->data.socket->sk;
9e204cdd 1380 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5)
1a7ba646 1381 set_bit(NET_CONGESTED, &tconn->flags);
9e204cdd
AG		 1382}
1383
b411b363
PR		 1384/* The idea of sendpage seems to be to put some kind of reference
1385 * to the page into the skb, and to hand it over to the NIC. In
1386 * this process get_page() gets called.
1387 *
1388 * As soon as the page was really sent over the network put_page()
1389 * gets called by some part of the network layer. [ NIC driver? ]
1390 *
1391 * [ get_page() / put_page() increment/decrement the count. If count
1392 * reaches 0 the page will be freed. ]
1393 *
1394 * This works nicely with pages from FSs.
1395 * But this means that in protocol A we might signal IO completion too early!
1396 *
1397 * In order not to corrupt data during a resync we must make sure
1398 * that we do not reuse our own buffer pages (EEs) to early, therefore
1399 * we have the net_ee list.
1400 *
1401 * XFS seems to have problems, still, it submits pages with page_count == 0!
1402 * As a workaround, we disable sendpage on pages
1403 * with page_count == 0 or PageSlab.
1404 */
1405static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
b987427b 1406 int offset, size_t size, unsigned msg_flags)
b411b363 1407{
b987427b
AG		 1408 struct socket *socket;
1409 void *addr;
1410 int err;
1411
1412 socket = mdev->tconn->data.socket;
1413 addr = kmap(page) + offset;
1414 err = drbd_send_all(mdev->tconn, socket, addr, size, msg_flags);
b411b363 1415 kunmap(page);
b987427b
AG		 1416 if (!err)
1417 mdev->send_cnt += size >> 9;
1418 return err;
b411b363
PR		 1419}
1420
1421static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 1422 int offset, size_t size, unsigned msg_flags)
b411b363 1423{
88b390ff 1424 struct socket *socket = mdev->tconn->data.socket;
b411b363 1425 mm_segment_t oldfs = get_fs();
b411b363 1426 int len = size;
88b390ff 1427 int err = -EIO;
b411b363
PR		 1428
1429 /* e.g. XFS meta- & log-data is in slab pages, which have a
1430 * page_count of 0 and/or have PageSlab() set.
1431 * we cannot use send_page for those, as that does get_page();
1432 * put_page(); and would cause either a VM_BUG directly, or
1433 * __page_cache_release a page that would actually still be referenced
1434 * by someone, leading to some obscure delayed Oops somewhere else. */
1435 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
88b390ff 1436 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
b411b363 1437
ba11ad9a 1438 msg_flags |= MSG_NOSIGNAL;
1a7ba646 1439 drbd_update_congested(mdev->tconn);
b411b363
PR		 1440 set_fs(KERNEL_DS);
1441 do {
88b390ff
AG		 1442 int sent;
1443
1444 sent = socket->ops->sendpage(socket, page, offset, len, msg_flags);
b411b363 1445 if (sent <= 0) {
88b390ff
AG		 1446 if (sent == -EAGAIN) {
1447 if (we_should_drop_the_connection(mdev->tconn, socket))
1448 break;
1449 continue;
1450 }
b411b363
PR		 1451 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
1452 __func__, (int)size, len, sent);
88b390ff
AG		 1453 if (sent < 0)
1454 err = sent;
b411b363
PR		 1455 break;
1456 }
1457 len -= sent;
1458 offset += sent;
1459 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
1460 set_fs(oldfs);
01a311a5 1461 clear_bit(NET_CONGESTED, &mdev->tconn->flags);
b411b363 1462
88b390ff
AG		 1463 if (len == 0) {
1464 err = 0;
1465 mdev->send_cnt += size >> 9;
1466 }
1467 return err;
b411b363
PR		 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 1475 __bio_for_each_segment(bvec, bio, i, 0) {
b987427b
AG		 1476 if (_drbd_no_send_page(mdev, bvec->bv_page,
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 1489 __bio_for_each_segment(bvec, bio, i, 0) {
88b390ff
AG		 1490 if (_drbd_send_page(mdev, bvec->bv_page,
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;
9f69230c 1503 int err;
db830c46 1504
ba11ad9a 1505 /* hint all but last page with MSG_MORE */
45bb912b
LE		 1506 page_chain_for_each(page) {
1507 unsigned l = min_t(unsigned, len, PAGE_SIZE);
9f69230c
AG		 1508
1509 err = _drbd_send_page(mdev, page, 0, l,
1510 page_chain_next(page) ? MSG_MORE : 0);
1511 if (err)
1512 return err;
45bb912b
LE		 1513 len -= l;
1514 }
9f69230c 1515 return 0;
45bb912b
LE		 1516}
1517
76d2e7ec
PR		 1518static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
1519{
31890f4a 1520 if (mdev->tconn->agreed_pro_version >= 95)
76d2e7ec 1521 return (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
76d2e7ec
PR		 1522 (bi_rw & REQ_FUA ? DP_FUA : 0) |
1523 (bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
1524 (bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
1525 else
721a9602 1526 return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
76d2e7ec
PR		 1527}
1528
b411b363
PR		 1529/* Used to send write requests
1530 * R_PRIMARY -> Peer (P_DATA)
1531 */
1532int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
1533{
1534 int ok = 1;
1535 struct p_data p;
1536 unsigned int dp_flags = 0;
1537 void *dgb;
1538 int dgs;
1539
11b0be28 1540 if (drbd_get_data_sock(mdev->tconn))
b411b363
PR		 1541 return 0;
1542
a0638456
PR		 1543 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_w_tfm) ?
1544 crypto_hash_digestsize(mdev->tconn->integrity_w_tfm) : 0;
b411b363 1545
fd340c12 1546 prepare_header(mdev, &p.head, P_DATA, sizeof(p) - sizeof(struct p_header) + dgs + req->i.size);
ace652ac 1547 p.sector = cpu_to_be64(req->i.sector);
b411b363 1548 p.block_id = (unsigned long)req;
8ccf218e 1549 p.seq_num = cpu_to_be32(req->seq_num = atomic_inc_return(&mdev->packet_seq));
b411b363 1550
76d2e7ec
PR		 1551 dp_flags = bio_flags_to_wire(mdev, req->master_bio->bi_rw);
1552
b411b363
PR		 1553 if (mdev->state.conn >= C_SYNC_SOURCE &&
1554 mdev->state.conn <= C_PAUSED_SYNC_T)
1555 dp_flags |= DP_MAY_SET_IN_SYNC;
1556
1557 p.dp_flags = cpu_to_be32(dp_flags);
b411b363
PR		 1558 set_bit(UNPLUG_REMOTE, &mdev->flags);
1559 ok = (sizeof(p) ==
bedbd2a5 1560 drbd_send(mdev->tconn, mdev->tconn->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0));
b411b363 1561 if (ok && dgs) {
a0638456
PR		 1562 dgb = mdev->tconn->int_dig_out;
1563 drbd_csum_bio(mdev, mdev->tconn->integrity_w_tfm, req->master_bio, dgb);
bedbd2a5 1564 ok = dgs == drbd_send(mdev->tconn, mdev->tconn->data.socket, dgb, dgs, 0);
b411b363
PR		 1565 }
1566 if (ok) {
470be44a
LE		 1567 /* For protocol A, we have to memcpy the payload into
1568 * socket buffers, as we may complete right away
1569 * as soon as we handed it over to tcp, at which point the data
1570 * pages may become invalid.
1571 *
1572 * For data-integrity enabled, we copy it as well, so we can be
1573 * sure that even if the bio pages may still be modified, it
1574 * won't change the data on the wire, thus if the digest checks
1575 * out ok after sending on this side, but does not fit on the
1576 * receiving side, we sure have detected corruption elsewhere.
1577 */
89e58e75 1578 if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || dgs)
b411b363
PR		 1579 ok = _drbd_send_bio(mdev, req->master_bio);
1580 else
1581 ok = _drbd_send_zc_bio(mdev, req->master_bio);
470be44a
LE		 1582
1583 /* double check digest, sometimes buffers have been modified in flight. */
1584 if (dgs > 0 && dgs <= 64) {
24c4830c 1585 /* 64 byte, 512 bit, is the largest digest size
470be44a
LE		 1586 * currently supported in kernel crypto. */
1587 unsigned char digest[64];
a0638456
PR		 1588 drbd_csum_bio(mdev, mdev->tconn->integrity_w_tfm, req->master_bio, digest);
1589 if (memcmp(mdev->tconn->int_dig_out, digest, dgs)) {
470be44a
LE		 1590 dev_warn(DEV,
1591 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
ace652ac 1592 (unsigned long long)req->i.sector, req->i.size);
470be44a
LE		 1593 }
1594 } /* else if (dgs > 64) {
1595 ... Be noisy about digest too large ...
1596 } */
b411b363
PR		 1597 }
1598
61120870 1599 drbd_put_data_sock(mdev->tconn);
bd26bfc5 1600
b411b363
PR		 1601 return ok;
1602}
1603
1604/* answer packet, used to send data back for read requests:
1605 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
1606 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
1607 */
d8763023 1608int drbd_send_block(struct drbd_conf *mdev, enum drbd_packet cmd,
db830c46 1609 struct drbd_peer_request *peer_req)
b411b363 1610{
7b57b89d 1611 int err;
b411b363
PR		 1612 struct p_data p;
1613 void *dgb;
1614 int dgs;
1615
a0638456
PR		 1616 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_w_tfm) ?
1617 crypto_hash_digestsize(mdev->tconn->integrity_w_tfm) : 0;
b411b363 1618
db830c46
AG		 1619 prepare_header(mdev, &p.head, cmd, sizeof(p) -
1620 sizeof(struct p_header80) +
1621 dgs + peer_req->i.size);
1622 p.sector = cpu_to_be64(peer_req->i.sector);
1623 p.block_id = peer_req->block_id;
cc378270 1624 p.seq_num = 0; /* unused */
b411b363
PR		 1625
1626 /* Only called by our kernel thread.
1627 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
1628 * in response to admin command or module unload.
1629 */
7b57b89d
AG		 1630 err = drbd_get_data_sock(mdev->tconn);
1631 if (err)
1632 return err;
1633 err = drbd_send_all(mdev->tconn, mdev->tconn->data.socket, &p,
1634 sizeof(p), dgs ? MSG_MORE : 0);
1635 if (!err && dgs) {
a0638456 1636 dgb = mdev->tconn->int_dig_out;
db830c46 1637 drbd_csum_ee(mdev, mdev->tconn->integrity_w_tfm, peer_req, dgb);
7b57b89d
AG		 1638 err = drbd_send_all(mdev->tconn, mdev->tconn->data.socket, dgb,
1639 dgs, 0);
b411b363 1640 }
7b57b89d
AG		 1641 if (!err)
1642 err = _drbd_send_zc_ee(mdev, peer_req);
61120870 1643 drbd_put_data_sock(mdev->tconn);
bd26bfc5 1644
7b57b89d 1645 return err;
b411b363
PR		 1646}
1647
73a01a18
PR		 1648int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req)
1649{
1650 struct p_block_desc p;
1651
ace652ac
AG		 1652 p.sector = cpu_to_be64(req->i.sector);
1653 p.blksize = cpu_to_be32(req->i.size);
73a01a18 1654
73218a3c 1655 return drbd_send_cmd(mdev, &mdev->tconn->data, P_OUT_OF_SYNC, &p.head, sizeof(p));
73a01a18
PR		 1656}
1657
b411b363
PR		 1658/*
1659 drbd_send distinguishes two cases:
1660
1661 Packets sent via the data socket "sock"
1662 and packets sent via the meta data socket "msock"
1663
1664 sock msock
1665 -----------------+-------------------------+------------------------------
1666 timeout conf.timeout / 2 conf.timeout / 2
1667 timeout action send a ping via msock Abort communication
1668 and close all sockets
1669*/
1670
1671/*
1672 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
1673 */
bedbd2a5 1674int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
b411b363
PR		 1675 void *buf, size_t size, unsigned msg_flags)
1676{
1677 struct kvec iov;
1678 struct msghdr msg;
1679 int rv, sent = 0;
1680
1681 if (!sock)
c0d42c8e 1682 return -EBADR;
b411b363
PR		 1683
1684 /* THINK if (signal_pending) return ... ? */
1685
1686 iov.iov_base = buf;
1687 iov.iov_len = size;
1688
1689 msg.msg_name = NULL;
1690 msg.msg_namelen = 0;
1691 msg.msg_control = NULL;
1692 msg.msg_controllen = 0;
1693 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
1694
bedbd2a5
PR		 1695 if (sock == tconn->data.socket) {
1696 tconn->ko_count = tconn->net_conf->ko_count;
1697 drbd_update_congested(tconn);
b411b363
PR		 1698 }
1699 do {
1700 /* STRANGE
1701 * tcp_sendmsg does _not_ use its size parameter at all ?
1702 *
1703 * -EAGAIN on timeout, -EINTR on signal.
1704 */
1705/* THINK
1706 * do we need to block DRBD_SIG if sock == &meta.socket ??
1707 * otherwise wake_asender() might interrupt some send_*Ack !
1708 */
1709 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
1710 if (rv == -EAGAIN) {
bedbd2a5 1711 if (we_should_drop_the_connection(tconn, sock))
b411b363
PR		 1712 break;
1713 else
1714 continue;
1715 }
b411b363
PR		 1716 if (rv == -EINTR) {
1717 flush_signals(current);
1718 rv = 0;
1719 }
1720 if (rv < 0)
1721 break;
1722 sent += rv;
1723 iov.iov_base += rv;
1724 iov.iov_len -= rv;
1725 } while (sent < size);
1726
bedbd2a5
PR		 1727 if (sock == tconn->data.socket)
1728 clear_bit(NET_CONGESTED, &tconn->flags);
b411b363
PR		 1729
1730 if (rv <= 0) {
1731 if (rv != -EAGAIN) {
bedbd2a5
PR		 1732 conn_err(tconn, "%s_sendmsg returned %d\n",
1733 sock == tconn->meta.socket ? "msock" : "sock",
1734 rv);
bbeb641c 1735 conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
b411b363 1736 } else
bbeb641c 1737 conn_request_state(tconn, NS(conn, C_TIMEOUT), CS_HARD);
b411b363
PR		 1738 }
1739
1740 return sent;
1741}
1742
fb708e40
AG		 1743/**
1744 * drbd_send_all - Send an entire buffer
1745 *
1746 * Returns 0 upon success and a negative error value otherwise.
1747 */
1748int drbd_send_all(struct drbd_tconn *tconn, struct socket *sock, void *buffer,
1749 size_t size, unsigned msg_flags)
1750{
1751 int err;
1752
1753 err = drbd_send(tconn, sock, buffer, size, msg_flags);
1754 if (err < 0)
1755 return err;
1756 if (err != size)
1757 return -EIO;
1758 return 0;
1759}
1760
b411b363
PR		 1761static int drbd_open(struct block_device *bdev, fmode_t mode)
1762{
1763 struct drbd_conf *mdev = bdev->bd_disk->private_data;
1764 unsigned long flags;
1765 int rv = 0;
1766
2a48fc0a 1767 mutex_lock(&drbd_main_mutex);
87eeee41 1768 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
b411b363
PR		 1769 /* to have a stable mdev->state.role
1770 * and no race with updating open_cnt */
1771
1772 if (mdev->state.role != R_PRIMARY) {
1773 if (mode & FMODE_WRITE)
1774 rv = -EROFS;
1775 else if (!allow_oos)
1776 rv = -EMEDIUMTYPE;
1777 }
1778
1779 if (!rv)
1780 mdev->open_cnt++;
87eeee41 1781 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
2a48fc0a 1782 mutex_unlock(&drbd_main_mutex);
b411b363
PR		 1783
1784 return rv;
1785}
1786
1787static int drbd_release(struct gendisk *gd, fmode_t mode)
1788{
1789 struct drbd_conf *mdev = gd->private_data;
2a48fc0a 1790 mutex_lock(&drbd_main_mutex);
b411b363 1791 mdev->open_cnt--;
2a48fc0a 1792 mutex_unlock(&drbd_main_mutex);
b411b363
PR		 1793 return 0;
1794}
1795
b411b363
PR		 1796static void drbd_set_defaults(struct drbd_conf *mdev)
1797{
f399002e
LE		 1798 /* Beware! The actual layout differs
1799 * between big endian and little endian */
b411b363
PR		 1800 mdev->state = (union drbd_state) {
1801 { .role = R_SECONDARY,
1802 .peer = R_UNKNOWN,
1803 .conn = C_STANDALONE,
1804 .disk = D_DISKLESS,
1805 .pdsk = D_UNKNOWN,
fb22c402
PR		 1806 .susp = 0,
1807 .susp_nod = 0,
1808 .susp_fen = 0
b411b363
PR		 1809 } };
1810}
1811
1812void drbd_init_set_defaults(struct drbd_conf *mdev)
1813{
1814 /* the memset(,0,) did most of this.
1815 * note: only assignments, no allocation in here */
1816
1817 drbd_set_defaults(mdev);
1818
b411b363
PR		 1819 atomic_set(&mdev->ap_bio_cnt, 0);
1820 atomic_set(&mdev->ap_pending_cnt, 0);
1821 atomic_set(&mdev->rs_pending_cnt, 0);
1822 atomic_set(&mdev->unacked_cnt, 0);
1823 atomic_set(&mdev->local_cnt, 0);
b411b363 1824 atomic_set(&mdev->pp_in_use, 0);
435f0740 1825 atomic_set(&mdev->pp_in_use_by_net, 0);
778f271d 1826 atomic_set(&mdev->rs_sect_in, 0);
0f0601f4 1827 atomic_set(&mdev->rs_sect_ev, 0);
759fbdfb 1828 atomic_set(&mdev->ap_in_flight, 0);
b411b363
PR		 1829
1830 mutex_init(&mdev->md_io_mutex);
8410da8f
PR		 1831 mutex_init(&mdev->own_state_mutex);
1832 mdev->state_mutex = &mdev->own_state_mutex;
b411b363 1833
b411b363 1834 spin_lock_init(&mdev->al_lock);
b411b363
PR		 1835 spin_lock_init(&mdev->peer_seq_lock);
1836 spin_lock_init(&mdev->epoch_lock);
1837
1838 INIT_LIST_HEAD(&mdev->active_ee);
1839 INIT_LIST_HEAD(&mdev->sync_ee);
1840 INIT_LIST_HEAD(&mdev->done_ee);
1841 INIT_LIST_HEAD(&mdev->read_ee);
1842 INIT_LIST_HEAD(&mdev->net_ee);
1843 INIT_LIST_HEAD(&mdev->resync_reads);
b411b363
PR		 1844 INIT_LIST_HEAD(&mdev->resync_work.list);
1845 INIT_LIST_HEAD(&mdev->unplug_work.list);
e9e6f3ec 1846 INIT_LIST_HEAD(&mdev->go_diskless.list);
b411b363 1847 INIT_LIST_HEAD(&mdev->md_sync_work.list);
c4752ef1 1848 INIT_LIST_HEAD(&mdev->start_resync_work.list);
b411b363 1849 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
0ced55a3 1850
794abb75 1851 mdev->resync_work.cb = w_resync_timer;
b411b363 1852 mdev->unplug_work.cb = w_send_write_hint;
e9e6f3ec 1853 mdev->go_diskless.cb = w_go_diskless;
b411b363
PR		 1854 mdev->md_sync_work.cb = w_md_sync;
1855 mdev->bm_io_work.w.cb = w_bitmap_io;
370a43e7 1856 mdev->start_resync_work.cb = w_start_resync;
a21e9298
PR		 1857
1858 mdev->resync_work.mdev = mdev;
1859 mdev->unplug_work.mdev = mdev;
1860 mdev->go_diskless.mdev = mdev;
1861 mdev->md_sync_work.mdev = mdev;
1862 mdev->bm_io_work.w.mdev = mdev;
1863 mdev->start_resync_work.mdev = mdev;
1864
b411b363
PR		 1865 init_timer(&mdev->resync_timer);
1866 init_timer(&mdev->md_sync_timer);
370a43e7 1867 init_timer(&mdev->start_resync_timer);
7fde2be9 1868 init_timer(&mdev->request_timer);
b411b363
PR		 1869 mdev->resync_timer.function = resync_timer_fn;
1870 mdev->resync_timer.data = (unsigned long) mdev;
1871 mdev->md_sync_timer.function = md_sync_timer_fn;
1872 mdev->md_sync_timer.data = (unsigned long) mdev;
370a43e7
PR		 1873 mdev->start_resync_timer.function = start_resync_timer_fn;
1874 mdev->start_resync_timer.data = (unsigned long) mdev;
7fde2be9
PR		 1875 mdev->request_timer.function = request_timer_fn;
1876 mdev->request_timer.data = (unsigned long) mdev;
b411b363
PR		 1877
1878 init_waitqueue_head(&mdev->misc_wait);
1879 init_waitqueue_head(&mdev->state_wait);
1880 init_waitqueue_head(&mdev->ee_wait);
1881 init_waitqueue_head(&mdev->al_wait);
1882 init_waitqueue_head(&mdev->seq_wait);
1883
fd340c12 1884 /* mdev->tconn->agreed_pro_version gets initialized in drbd_connect() */
2451fc3b 1885 mdev->write_ordering = WO_bdev_flush;
b411b363 1886 mdev->resync_wenr = LC_FREE;
99432fcc
PR		 1887 mdev->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
1888 mdev->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
b411b363
PR		 1889}
1890
1891void drbd_mdev_cleanup(struct drbd_conf *mdev)
1892{
1d7734a0 1893 int i;
e6b3ea83 1894 if (mdev->tconn->receiver.t_state != NONE)
b411b363 1895 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
e6b3ea83 1896 mdev->tconn->receiver.t_state);
b411b363
PR		 1897
1898 /* no need to lock it, I'm the only thread alive */
1899 if (atomic_read(&mdev->current_epoch->epoch_size) != 0)
1900 dev_err(DEV, "epoch_size:%d\n", atomic_read(&mdev->current_epoch->epoch_size));
1901 mdev->al_writ_cnt =
1902 mdev->bm_writ_cnt =
1903 mdev->read_cnt =
1904 mdev->recv_cnt =
1905 mdev->send_cnt =
1906 mdev->writ_cnt =
1907 mdev->p_size =
1908 mdev->rs_start =
1909 mdev->rs_total =
1d7734a0
LE		 1910 mdev->rs_failed = 0;
1911 mdev->rs_last_events = 0;
0f0601f4 1912 mdev->rs_last_sect_ev = 0;
1d7734a0
LE		 1913 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
1914 mdev->rs_mark_left[i] = 0;
1915 mdev->rs_mark_time[i] = 0;
1916 }
89e58e75 1917 D_ASSERT(mdev->tconn->net_conf == NULL);
b411b363
PR		 1918
1919 drbd_set_my_capacity(mdev, 0);
1920 if (mdev->bitmap) {
1921 /* maybe never allocated. */
02d9a94b 1922 drbd_bm_resize(mdev, 0, 1);
b411b363
PR		 1923 drbd_bm_cleanup(mdev);
1924 }
1925
1926 drbd_free_resources(mdev);
0778286a 1927 clear_bit(AL_SUSPENDED, &mdev->flags);
b411b363
PR		 1928
1929 /*
1930 * currently we drbd_init_ee only on module load, so
1931 * we may do drbd_release_ee only on module unload!
1932 */
1933 D_ASSERT(list_empty(&mdev->active_ee));
1934 D_ASSERT(list_empty(&mdev->sync_ee));
1935 D_ASSERT(list_empty(&mdev->done_ee));
1936 D_ASSERT(list_empty(&mdev->read_ee));
1937 D_ASSERT(list_empty(&mdev->net_ee));
1938 D_ASSERT(list_empty(&mdev->resync_reads));
e42325a5
PR		 1939 D_ASSERT(list_empty(&mdev->tconn->data.work.q));
1940 D_ASSERT(list_empty(&mdev->tconn->meta.work.q));
b411b363
PR		 1941 D_ASSERT(list_empty(&mdev->resync_work.list));
1942 D_ASSERT(list_empty(&mdev->unplug_work.list));
e9e6f3ec 1943 D_ASSERT(list_empty(&mdev->go_diskless.list));
2265b473
LE		 1944
1945 drbd_set_defaults(mdev);
b411b363
PR		 1946}
1947
1948
1949static void drbd_destroy_mempools(void)
1950{
1951 struct page *page;
1952
1953 while (drbd_pp_pool) {
1954 page = drbd_pp_pool;
1955 drbd_pp_pool = (struct page *)page_private(page);
1956 __free_page(page);
1957 drbd_pp_vacant--;
1958 }
1959
1960 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
1961
da4a75d2
LE		 1962 if (drbd_md_io_bio_set)
1963 bioset_free(drbd_md_io_bio_set);
35abf594
LE		 1964 if (drbd_md_io_page_pool)
1965 mempool_destroy(drbd_md_io_page_pool);
b411b363
PR		 1966 if (drbd_ee_mempool)
1967 mempool_destroy(drbd_ee_mempool);
1968 if (drbd_request_mempool)
1969 mempool_destroy(drbd_request_mempool);
1970 if (drbd_ee_cache)
1971 kmem_cache_destroy(drbd_ee_cache);
1972 if (drbd_request_cache)
1973 kmem_cache_destroy(drbd_request_cache);
1974 if (drbd_bm_ext_cache)
1975 kmem_cache_destroy(drbd_bm_ext_cache);
1976 if (drbd_al_ext_cache)
1977 kmem_cache_destroy(drbd_al_ext_cache);
1978
da4a75d2 1979 drbd_md_io_bio_set = NULL;
35abf594 1980 drbd_md_io_page_pool = NULL;
b411b363
PR		 1981 drbd_ee_mempool = NULL;
1982 drbd_request_mempool = NULL;
1983 drbd_ee_cache = NULL;
1984 drbd_request_cache = NULL;
1985 drbd_bm_ext_cache = NULL;
1986 drbd_al_ext_cache = NULL;
1987
1988 return;
1989}
1990
1991static int drbd_create_mempools(void)
1992{
1993 struct page *page;
1816a2b4 1994 const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;
b411b363
PR		 1995 int i;
1996
1997 /* prepare our caches and mempools */
1998 drbd_request_mempool = NULL;
1999 drbd_ee_cache = NULL;
2000 drbd_request_cache = NULL;
2001 drbd_bm_ext_cache = NULL;
2002 drbd_al_ext_cache = NULL;
2003 drbd_pp_pool = NULL;
35abf594 2004 drbd_md_io_page_pool = NULL;
da4a75d2 2005 drbd_md_io_bio_set = NULL;
b411b363
PR		 2006
2007 /* caches */
2008 drbd_request_cache = kmem_cache_create(
2009 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2010 if (drbd_request_cache == NULL)
2011 goto Enomem;
2012
2013 drbd_ee_cache = kmem_cache_create(
f6ffca9f 2014 "drbd_ee", sizeof(struct drbd_peer_request), 0, 0, NULL);
b411b363
PR		 2015 if (drbd_ee_cache == NULL)
2016 goto Enomem;
2017
2018 drbd_bm_ext_cache = kmem_cache_create(
2019 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2020 if (drbd_bm_ext_cache == NULL)
2021 goto Enomem;
2022
2023 drbd_al_ext_cache = kmem_cache_create(
2024 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2025 if (drbd_al_ext_cache == NULL)
2026 goto Enomem;
2027
2028 /* mempools */
da4a75d2
LE		 2029 drbd_md_io_bio_set = bioset_create(DRBD_MIN_POOL_PAGES, 0);
2030 if (drbd_md_io_bio_set == NULL)
2031 goto Enomem;
2032
35abf594
LE		 2033 drbd_md_io_page_pool = mempool_create_page_pool(DRBD_MIN_POOL_PAGES, 0);
2034 if (drbd_md_io_page_pool == NULL)
2035 goto Enomem;
2036
b411b363
PR		 2037 drbd_request_mempool = mempool_create(number,
2038 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2039 if (drbd_request_mempool == NULL)
2040 goto Enomem;
2041
2042 drbd_ee_mempool = mempool_create(number,
2043 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2027ae1f 2044 if (drbd_ee_mempool == NULL)
b411b363
PR		 2045 goto Enomem;
2046
2047 /* drbd's page pool */
2048 spin_lock_init(&drbd_pp_lock);
2049
2050 for (i = 0; i < number; i++) {
2051 page = alloc_page(GFP_HIGHUSER);
2052 if (!page)
2053 goto Enomem;
2054 set_page_private(page, (unsigned long)drbd_pp_pool);
2055 drbd_pp_pool = page;
2056 }
2057 drbd_pp_vacant = number;
2058
2059 return 0;
2060
2061Enomem:
2062 drbd_destroy_mempools(); /* in case we allocated some */
2063 return -ENOMEM;
2064}
2065
2066static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2067 void *unused)
2068{
2069 /* just so we have it. you never know what interesting things we
2070 * might want to do here some day...
2071 */
2072
2073 return NOTIFY_DONE;
2074}
2075
2076static struct notifier_block drbd_notifier = {
2077 .notifier_call = drbd_notify_sys,
2078};
2079
2080static void drbd_release_ee_lists(struct drbd_conf *mdev)
2081{
2082 int rr;
2083
2084 rr = drbd_release_ee(mdev, &mdev->active_ee);
2085 if (rr)
2086 dev_err(DEV, "%d EEs in active list found!\n", rr);
2087
2088 rr = drbd_release_ee(mdev, &mdev->sync_ee);
2089 if (rr)
2090 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2091
2092 rr = drbd_release_ee(mdev, &mdev->read_ee);
2093 if (rr)
2094 dev_err(DEV, "%d EEs in read list found!\n", rr);
2095
2096 rr = drbd_release_ee(mdev, &mdev->done_ee);
2097 if (rr)
2098 dev_err(DEV, "%d EEs in done list found!\n", rr);
2099
2100 rr = drbd_release_ee(mdev, &mdev->net_ee);
2101 if (rr)
2102 dev_err(DEV, "%d EEs in net list found!\n", rr);
2103}
2104
774b3055
PR		 2105/* caution. no locking. */
2106void drbd_delete_device(unsigned int minor)
b411b363
PR		 2107{
2108 struct drbd_conf *mdev = minor_to_mdev(minor);
2109
2110 if (!mdev)
2111 return;
2112
569083c0
LE		 2113 idr_remove(&mdev->tconn->volumes, mdev->vnr);
2114 idr_remove(&minors, minor);
2115 synchronize_rcu();
774b3055 2116
b411b363 2117 /* paranoia asserts */
70dc65e1 2118 D_ASSERT(mdev->open_cnt == 0);
e42325a5 2119 D_ASSERT(list_empty(&mdev->tconn->data.work.q));
b411b363
PR		 2120 /* end paranoia asserts */
2121
2122 del_gendisk(mdev->vdisk);
2123
2124 /* cleanup stuff that may have been allocated during
2125 * device (re-)configuration or state changes */
2126
2127 if (mdev->this_bdev)
2128 bdput(mdev->this_bdev);
2129
2130 drbd_free_resources(mdev);
2131
2132 drbd_release_ee_lists(mdev);
2133
b411b363
PR		 2134 lc_destroy(mdev->act_log);
2135 lc_destroy(mdev->resync);
2136
2137 kfree(mdev->p_uuid);
2138 /* mdev->p_uuid = NULL; */
2139
b411b363
PR		 2140 /* cleanup the rest that has been
2141 * allocated from drbd_new_device
2142 * and actually free the mdev itself */
2143 drbd_free_mdev(mdev);
2144}
2145
2146static void drbd_cleanup(void)
2147{
2148 unsigned int i;
81a5d60e 2149 struct drbd_conf *mdev;
b411b363
PR		 2150
2151 unregister_reboot_notifier(&drbd_notifier);
2152
17a93f30
LE		 2153 /* first remove proc,
2154 * drbdsetup uses it's presence to detect
2155 * whether DRBD is loaded.
2156 * If we would get stuck in proc removal,
2157 * but have netlink already deregistered,
2158 * some drbdsetup commands may wait forever
2159 * for an answer.
2160 */
2161 if (drbd_proc)
2162 remove_proc_entry("drbd", NULL);
2163
3b98c0c2 2164 drbd_genl_unregister();
b411b363 2165
81a5d60e
PR		 2166 idr_for_each_entry(&minors, mdev, i)
2167 drbd_delete_device(i);
2168 drbd_destroy_mempools();
b411b363
PR		 2169 unregister_blkdev(DRBD_MAJOR, "drbd");
2170
81a5d60e
PR		 2171 idr_destroy(&minors);
2172
b411b363
PR		 2173 printk(KERN_INFO "drbd: module cleanup done.\n");
2174}
2175
2176/**
2177 * drbd_congested() - Callback for pdflush
2178 * @congested_data: User data
2179 * @bdi_bits: Bits pdflush is currently interested in
2180 *
2181 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
2182 */
2183static int drbd_congested(void *congested_data, int bdi_bits)
2184{
2185 struct drbd_conf *mdev = congested_data;
2186 struct request_queue *q;
2187 char reason = '-';
2188 int r = 0;
2189
1b881ef7 2190 if (!may_inc_ap_bio(mdev)) {
b411b363
PR		 2191 /* DRBD has frozen IO */
2192 r = bdi_bits;
2193 reason = 'd';
2194 goto out;
2195 }
2196
2197 if (get_ldev(mdev)) {
2198 q = bdev_get_queue(mdev->ldev->backing_bdev);
2199 r = bdi_congested(&q->backing_dev_info, bdi_bits);
2200 put_ldev(mdev);
2201 if (r)
2202 reason = 'b';
2203 }
2204
01a311a5 2205 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->tconn->flags)) {
b411b363
PR		 2206 r |= (1 << BDI_async_congested);
2207 reason = reason == 'b' ? 'a' : 'n';
2208 }
2209
2210out:
2211 mdev->congestion_reason = reason;
2212 return r;
2213}
2214
6699b655
PR		 2215static void drbd_init_workqueue(struct drbd_work_queue* wq)
2216{
2217 sema_init(&wq->s, 0);
2218 spin_lock_init(&wq->q_lock);
2219 INIT_LIST_HEAD(&wq->q);
2220}
2221
1aba4d7f
PR		 2222struct drbd_tconn *conn_by_name(const char *name)
2223{
2224 struct drbd_tconn *tconn;
2225
3b98c0c2
LE		 2226 if (!name || !name[0])
2227 return NULL;
2228
543cc10b 2229 mutex_lock(&drbd_cfg_mutex);
1aba4d7f
PR		 2230 list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
2231 if (!strcmp(tconn->name, name))
2232 goto found;
2233 }
2234 tconn = NULL;
2235found:
543cc10b 2236 mutex_unlock(&drbd_cfg_mutex);
1aba4d7f
PR		 2237 return tconn;
2238}
2239
3b98c0c2 2240struct drbd_tconn *drbd_new_tconn(const char *name)
2111438b
PR		 2241{
2242 struct drbd_tconn *tconn;
2243
2244 tconn = kzalloc(sizeof(struct drbd_tconn), GFP_KERNEL);
2245 if (!tconn)
2246 return NULL;
2247
2248 tconn->name = kstrdup(name, GFP_KERNEL);
2249 if (!tconn->name)
2250 goto fail;
2251
774b3055
PR		 2252 if (!zalloc_cpumask_var(&tconn->cpu_mask, GFP_KERNEL))
2253 goto fail;
2254
2f5cdd0b
PR		 2255 if (!tl_init(tconn))
2256 goto fail;
2257
bbeb641c 2258 tconn->cstate = C_STANDALONE;
8410da8f 2259 mutex_init(&tconn->cstate_mutex);
6699b655 2260 spin_lock_init(&tconn->req_lock);
b2fb6dbe
PR		 2261 atomic_set(&tconn->net_cnt, 0);
2262 init_waitqueue_head(&tconn->net_cnt_wait);
2a67d8b9 2263 init_waitqueue_head(&tconn->ping_wait);
062e879c 2264 idr_init(&tconn->volumes);
b2fb6dbe 2265
6699b655
PR		 2266 drbd_init_workqueue(&tconn->data.work);
2267 mutex_init(&tconn->data.mutex);
2268
2269 drbd_init_workqueue(&tconn->meta.work);
2270 mutex_init(&tconn->meta.mutex);
2271
392c8801
PR		 2272 drbd_thread_init(tconn, &tconn->receiver, drbdd_init, "receiver");
2273 drbd_thread_init(tconn, &tconn->worker, drbd_worker, "worker");
2274 drbd_thread_init(tconn, &tconn->asender, drbd_asender, "asender");
2275
f399002e
LE		 2276 tconn->res_opts = (struct res_opts) {
2277 {}, 0, /* cpu_mask */
2278 DRBD_ON_NO_DATA_DEF, /* on_no_data */
2279 };
2280
543cc10b
LE		 2281 mutex_lock(&drbd_cfg_mutex);
2282 list_add_tail(&tconn->all_tconn, &drbd_tconns);
2283 mutex_unlock(&drbd_cfg_mutex);
2111438b
PR		 2284
2285 return tconn;
2286
2287fail:
2f5cdd0b 2288 tl_cleanup(tconn);
774b3055 2289 free_cpumask_var(tconn->cpu_mask);
2111438b
PR		 2290 kfree(tconn->name);
2291 kfree(tconn);
2292
2293 return NULL;
2294}
2295
2296void drbd_free_tconn(struct drbd_tconn *tconn)
2297{
2111438b 2298 list_del(&tconn->all_tconn);
062e879c 2299 idr_destroy(&tconn->volumes);
2111438b 2300
774b3055 2301 free_cpumask_var(tconn->cpu_mask);
2111438b 2302 kfree(tconn->name);
b42a70ad
PR		 2303 kfree(tconn->int_dig_out);
2304 kfree(tconn->int_dig_in);
2305 kfree(tconn->int_dig_vv);
2111438b
PR		 2306 kfree(tconn);
2307}
2308
774b3055 2309enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr)
b411b363
PR		 2310{
2311 struct drbd_conf *mdev;
2312 struct gendisk *disk;
2313 struct request_queue *q;
774b3055 2314 int vnr_got = vnr;
81a5d60e 2315 int minor_got = minor;
8432b314 2316 enum drbd_ret_code err = ERR_NOMEM;
774b3055
PR		 2317
2318 mdev = minor_to_mdev(minor);
2319 if (mdev)
2320 return ERR_MINOR_EXISTS;
b411b363
PR		 2321
2322 /* GFP_KERNEL, we are outside of all write-out paths */
2323 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
2324 if (!mdev)
774b3055
PR		 2325 return ERR_NOMEM;
2326
2327 mdev->tconn = tconn;
b411b363 2328 mdev->minor = minor;
3b98c0c2 2329 mdev->vnr = vnr;
b411b363
PR		 2330
2331 drbd_init_set_defaults(mdev);
2332
2333 q = blk_alloc_queue(GFP_KERNEL);
2334 if (!q)
2335 goto out_no_q;
2336 mdev->rq_queue = q;
2337 q->queuedata = mdev;
b411b363
PR		 2338
2339 disk = alloc_disk(1);
2340 if (!disk)
2341 goto out_no_disk;
2342 mdev->vdisk = disk;
2343
81e84650 2344 set_disk_ro(disk, true);
b411b363
PR		 2345
2346 disk->queue = q;
2347 disk->major = DRBD_MAJOR;
2348 disk->first_minor = minor;
2349 disk->fops = &drbd_ops;
2350 sprintf(disk->disk_name, "drbd%d", minor);
2351 disk->private_data = mdev;
2352
2353 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
2354 /* we have no partitions. we contain only ourselves. */
2355 mdev->this_bdev->bd_contains = mdev->this_bdev;
2356
2357 q->backing_dev_info.congested_fn = drbd_congested;
2358 q->backing_dev_info.congested_data = mdev;
2359
2f58dcfc 2360 blk_queue_make_request(q, drbd_make_request);
99432fcc
PR		 2361 /* Setting the max_hw_sectors to an odd value of 8kibyte here
2362 This triggers a max_bio_size message upon first attach or connect */
2363 blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
b411b363
PR		 2364 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
2365 blk_queue_merge_bvec(q, drbd_merge_bvec);
87eeee41 2366 q->queue_lock = &mdev->tconn->req_lock; /* needed since we use */
b411b363
PR		 2367
2368 mdev->md_io_page = alloc_page(GFP_KERNEL);
2369 if (!mdev->md_io_page)
2370 goto out_no_io_page;
2371
2372 if (drbd_bm_init(mdev))
2373 goto out_no_bitmap;
dac1389c 2374 mdev->read_requests = RB_ROOT;
de696716 2375 mdev->write_requests = RB_ROOT;
b411b363 2376
b411b363
PR		 2377 mdev->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
2378 if (!mdev->current_epoch)
2379 goto out_no_epoch;
2380
2381 INIT_LIST_HEAD(&mdev->current_epoch->list);
2382 mdev->epochs = 1;
2383
81a5d60e 2384 if (!idr_pre_get(&minors, GFP_KERNEL))
8432b314
LE		 2385 goto out_no_minor_idr;
2386 if (idr_get_new_above(&minors, mdev, minor, &minor_got))
2387 goto out_no_minor_idr;
81a5d60e 2388 if (minor_got != minor) {
8432b314
LE		 2389 err = ERR_MINOR_EXISTS;
2390 drbd_msg_put_info("requested minor exists already");
569083c0 2391 goto out_idr_remove_minor;
81a5d60e 2392 }
8432b314
LE		 2393
2394 if (!idr_pre_get(&tconn->volumes, GFP_KERNEL))
2395 goto out_idr_remove_minor;
2396 if (idr_get_new_above(&tconn->volumes, mdev, vnr, &vnr_got))
2397 goto out_idr_remove_minor;
2398 if (vnr_got != vnr) {
2399 err = ERR_INVALID_REQUEST;
2400 drbd_msg_put_info("requested volume exists already");
2401 goto out_idr_remove_vol;
2402 }
774b3055
PR		 2403 add_disk(disk);
2404
2325eb66
PR		 2405 /* inherit the connection state */
2406 mdev->state.conn = tconn->cstate;
2407 if (mdev->state.conn == C_WF_REPORT_PARAMS)
2408 drbd_connected(vnr, mdev, tconn);
2409
774b3055 2410 return NO_ERROR;
b411b363 2411
569083c0
LE		 2412out_idr_remove_vol:
2413 idr_remove(&tconn->volumes, vnr_got);
8432b314
LE		 2414out_idr_remove_minor:
2415 idr_remove(&minors, minor_got);
569083c0 2416 synchronize_rcu();
8432b314 2417out_no_minor_idr:
81a5d60e 2418 kfree(mdev->current_epoch);
b411b363 2419out_no_epoch:
b411b363
PR		 2420 drbd_bm_cleanup(mdev);
2421out_no_bitmap:
2422 __free_page(mdev->md_io_page);
2423out_no_io_page:
2424 put_disk(disk);
2425out_no_disk:
2426 blk_cleanup_queue(q);
2427out_no_q:
b411b363 2428 kfree(mdev);
8432b314 2429 return err;
b411b363
PR		 2430}
2431
2432/* counterpart of drbd_new_device.
2433 * last part of drbd_delete_device. */
2434void drbd_free_mdev(struct drbd_conf *mdev)
2435{
2436 kfree(mdev->current_epoch);
b411b363
PR		 2437 if (mdev->bitmap) /* should no longer be there. */
2438 drbd_bm_cleanup(mdev);
2439 __free_page(mdev->md_io_page);
2440 put_disk(mdev->vdisk);
2441 blk_cleanup_queue(mdev->rq_queue);
b411b363
PR		 2442 kfree(mdev);
2443}
2444
2445
2446int __init drbd_init(void)
2447{
2448 int err;
2449
fd340c12
PR		 2450 BUILD_BUG_ON(sizeof(struct p_header80) != sizeof(struct p_header95));
2451 BUILD_BUG_ON(sizeof(struct p_handshake) != 80);
b411b363 2452
2b8a90b5 2453 if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {
b411b363 2454 printk(KERN_ERR
81a5d60e 2455 "drbd: invalid minor_count (%d)\n", minor_count);
b411b363
PR		 2456#ifdef MODULE
2457 return -EINVAL;
2458#else
2459 minor_count = 8;
2460#endif
2461 }
2462
b411b363
PR		 2463 err = register_blkdev(DRBD_MAJOR, "drbd");
2464 if (err) {
2465 printk(KERN_ERR
2466 "drbd: unable to register block device major %d\n",
2467 DRBD_MAJOR);
2468 return err;
2469 }
2470
3b98c0c2
LE		 2471 err = drbd_genl_register();
2472 if (err) {
2473 printk(KERN_ERR "drbd: unable to register generic netlink family\n");
2474 goto fail;
2475 }
2476
2477
b411b363
PR		 2478 register_reboot_notifier(&drbd_notifier);
2479
2480 /*
2481 * allocate all necessary structs
2482 */
2483 err = -ENOMEM;
2484
2485 init_waitqueue_head(&drbd_pp_wait);
2486
2487 drbd_proc = NULL; /* play safe for drbd_cleanup */
81a5d60e 2488 idr_init(&minors);
b411b363
PR		 2489
2490 err = drbd_create_mempools();
2491 if (err)
3b98c0c2 2492 goto fail;
b411b363 2493
8c484ee4 2494 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
b411b363
PR		 2495 if (!drbd_proc) {
2496 printk(KERN_ERR "drbd: unable to register proc file\n");
3b98c0c2 2497 goto fail;
b411b363
PR		 2498 }
2499
2500 rwlock_init(&global_state_lock);
2111438b 2501 INIT_LIST_HEAD(&drbd_tconns);
b411b363
PR		 2502
2503 printk(KERN_INFO "drbd: initialized. "
2504 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
2505 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
2506 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
2507 printk(KERN_INFO "drbd: registered as block device major %d\n",
2508 DRBD_MAJOR);
b411b363
PR		 2509
2510 return 0; /* Success! */
2511
3b98c0c2 2512fail:
b411b363
PR		 2513 drbd_cleanup();
2514 if (err == -ENOMEM)
2515 /* currently always the case */
2516 printk(KERN_ERR "drbd: ran out of memory\n");
2517 else
2518 printk(KERN_ERR "drbd: initialization failure\n");
2519 return err;
2520}
2521
2522void drbd_free_bc(struct drbd_backing_dev *ldev)
2523{
2524 if (ldev == NULL)
2525 return;
2526
e525fd89
TH		 2527 blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2528 blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
b411b363
PR		 2529
2530 kfree(ldev);
2531}
2532
360cc740
PR		 2533void drbd_free_sock(struct drbd_tconn *tconn)
2534{
2535 if (tconn->data.socket) {
2536 mutex_lock(&tconn->data.mutex);
2537 kernel_sock_shutdown(tconn->data.socket, SHUT_RDWR);
2538 sock_release(tconn->data.socket);
2539 tconn->data.socket = NULL;
2540 mutex_unlock(&tconn->data.mutex);
b411b363 2541 }
360cc740
PR		 2542 if (tconn->meta.socket) {
2543 mutex_lock(&tconn->meta.mutex);
2544 kernel_sock_shutdown(tconn->meta.socket, SHUT_RDWR);
2545 sock_release(tconn->meta.socket);
2546 tconn->meta.socket = NULL;
2547 mutex_unlock(&tconn->meta.mutex);
b411b363
PR		 2548 }
2549}
2550
2551
2552void drbd_free_resources(struct drbd_conf *mdev)
2553{
f399002e
LE		 2554 crypto_free_hash(mdev->tconn->csums_tfm);
2555 mdev->tconn->csums_tfm = NULL;
2556 crypto_free_hash(mdev->tconn->verify_tfm);
2557 mdev->tconn->verify_tfm = NULL;
a0638456
PR		 2558 crypto_free_hash(mdev->tconn->cram_hmac_tfm);
2559 mdev->tconn->cram_hmac_tfm = NULL;
2560 crypto_free_hash(mdev->tconn->integrity_w_tfm);
2561 mdev->tconn->integrity_w_tfm = NULL;
2562 crypto_free_hash(mdev->tconn->integrity_r_tfm);
2563 mdev->tconn->integrity_r_tfm = NULL;
b411b363 2564
360cc740 2565 drbd_free_sock(mdev->tconn);
b411b363
PR		 2566
2567 __no_warn(local,
2568 drbd_free_bc(mdev->ldev);
2569 mdev->ldev = NULL;);
2570}
2571
2572/* meta data management */
2573
2574struct meta_data_on_disk {
2575 u64 la_size; /* last agreed size. */
2576 u64 uuid[UI_SIZE]; /* UUIDs. */
2577 u64 device_uuid;
2578 u64 reserved_u64_1;
2579 u32 flags; /* MDF */
2580 u32 magic;
2581 u32 md_size_sect;
2582 u32 al_offset; /* offset to this block */
2583 u32 al_nr_extents; /* important for restoring the AL */
f399002e 2584 /* `-- act_log->nr_elements <-- ldev->dc.al_extents */
b411b363
PR		 2585 u32 bm_offset; /* offset to the bitmap, from here */
2586 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
99432fcc
PR		 2587 u32 la_peer_max_bio_size; /* last peer max_bio_size */
2588 u32 reserved_u32[3];
b411b363
PR		 2589
2590} __packed;
2591
2592/**
2593 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
2594 * @mdev: DRBD device.
2595 */
2596void drbd_md_sync(struct drbd_conf *mdev)
2597{
2598 struct meta_data_on_disk *buffer;
2599 sector_t sector;
2600 int i;
2601
ee15b038
LE		 2602 del_timer(&mdev->md_sync_timer);
2603 /* timer may be rearmed by drbd_md_mark_dirty() now. */
b411b363
PR		 2604 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
2605 return;
b411b363
PR		 2606
2607 /* We use here D_FAILED and not D_ATTACHING because we try to write
2608 * metadata even if we detach due to a disk failure! */
2609 if (!get_ldev_if_state(mdev, D_FAILED))
2610 return;
2611
b411b363
PR		 2612 mutex_lock(&mdev->md_io_mutex);
2613 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
2614 memset(buffer, 0, 512);
2615
2616 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
2617 for (i = UI_CURRENT; i < UI_SIZE; i++)
2618 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
2619 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
2620 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC);
2621
2622 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
2623 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
2624 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
2625 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
2626 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
2627
2628 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
99432fcc 2629 buffer->la_peer_max_bio_size = cpu_to_be32(mdev->peer_max_bio_size);
b411b363
PR		 2630
2631 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
2632 sector = mdev->ldev->md.md_offset;
2633
3f3a9b84 2634 if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
b411b363
PR		 2635 /* this was a try anyways ... */
2636 dev_err(DEV, "meta data update failed!\n");
81e84650 2637 drbd_chk_io_error(mdev, 1, true);
b411b363
PR		 2638 }
2639
2640 /* Update mdev->ldev->md.la_size_sect,
2641 * since we updated it on metadata. */
2642 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
2643
2644 mutex_unlock(&mdev->md_io_mutex);
2645 put_ldev(mdev);
2646}
2647
2648/**
2649 * drbd_md_read() - Reads in the meta data super block
2650 * @mdev: DRBD device.
2651 * @bdev: Device from which the meta data should be read in.
2652 *
116676ca 2653 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
b411b363
PR		 2654 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
2655 */
2656int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
2657{
2658 struct meta_data_on_disk *buffer;
2659 int i, rv = NO_ERROR;
2660
2661 if (!get_ldev_if_state(mdev, D_ATTACHING))
2662 return ERR_IO_MD_DISK;
2663
b411b363
PR		 2664 mutex_lock(&mdev->md_io_mutex);
2665 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
2666
2667 if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
25985edc 2668 /* NOTE: can't do normal error processing here as this is
b411b363
PR		 2669 called BEFORE disk is attached */
2670 dev_err(DEV, "Error while reading metadata.\n");
2671 rv = ERR_IO_MD_DISK;
2672 goto err;
2673 }
2674
e7fad8af 2675 if (buffer->magic != cpu_to_be32(DRBD_MD_MAGIC)) {
b411b363
PR		 2676 dev_err(DEV, "Error while reading metadata, magic not found.\n");
2677 rv = ERR_MD_INVALID;
2678 goto err;
2679 }
2680 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
2681 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
2682 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
2683 rv = ERR_MD_INVALID;
2684 goto err;
2685 }
2686 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
2687 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
2688 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
2689 rv = ERR_MD_INVALID;
2690 goto err;
2691 }
2692 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
2693 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
2694 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
2695 rv = ERR_MD_INVALID;
2696 goto err;
2697 }
2698
2699 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
2700 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
2701 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
2702 rv = ERR_MD_INVALID;
2703 goto err;
2704 }
2705
2706 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
2707 for (i = UI_CURRENT; i < UI_SIZE; i++)
2708 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
2709 bdev->md.flags = be32_to_cpu(buffer->flags);
f399002e 2710 bdev->dc.al_extents = be32_to_cpu(buffer->al_nr_extents);
b411b363
PR		 2711 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
2712
87eeee41 2713 spin_lock_irq(&mdev->tconn->req_lock);
99432fcc
PR		 2714 if (mdev->state.conn < C_CONNECTED) {
2715 int peer;
2716 peer = be32_to_cpu(buffer->la_peer_max_bio_size);
2717 peer = max_t(int, peer, DRBD_MAX_BIO_SIZE_SAFE);
2718 mdev->peer_max_bio_size = peer;
2719 }
87eeee41 2720 spin_unlock_irq(&mdev->tconn->req_lock);
99432fcc 2721
f399002e
LE		 2722 if (bdev->dc.al_extents < 7)
2723 bdev->dc.al_extents = 127;
b411b363
PR		 2724
2725 err:
2726 mutex_unlock(&mdev->md_io_mutex);
2727 put_ldev(mdev);
2728
2729 return rv;
2730}
2731
2732/**
2733 * drbd_md_mark_dirty() - Mark meta data super block as dirty
2734 * @mdev: DRBD device.
2735 *
2736 * Call this function if you change anything that should be written to
2737 * the meta-data super block. This function sets MD_DIRTY, and starts a
2738 * timer that ensures that within five seconds you have to call drbd_md_sync().
2739 */
ca0e6098 2740#ifdef DEBUG
ee15b038
LE		 2741void drbd_md_mark_dirty_(struct drbd_conf *mdev, unsigned int line, const char *func)
2742{
2743 if (!test_and_set_bit(MD_DIRTY, &mdev->flags)) {
2744 mod_timer(&mdev->md_sync_timer, jiffies + HZ);
2745 mdev->last_md_mark_dirty.line = line;
2746 mdev->last_md_mark_dirty.func = func;
2747 }
2748}
2749#else
b411b363
PR		 2750void drbd_md_mark_dirty(struct drbd_conf *mdev)
2751{
ee15b038 2752 if (!test_and_set_bit(MD_DIRTY, &mdev->flags))
ca0e6098 2753 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
b411b363 2754}
ee15b038 2755#endif
b411b363
PR		 2756
2757static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
2758{
2759 int i;
2760
62b0da3a 2761 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
b411b363 2762 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
b411b363
PR		 2763}
2764
2765void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
2766{
2767 if (idx == UI_CURRENT) {
2768 if (mdev->state.role == R_PRIMARY)
2769 val |= 1;
2770 else
2771 val &= ~((u64)1);
2772
2773 drbd_set_ed_uuid(mdev, val);
2774 }
2775
2776 mdev->ldev->md.uuid[idx] = val;
b411b363
PR		 2777 drbd_md_mark_dirty(mdev);
2778}
2779
2780
2781void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
2782{
2783 if (mdev->ldev->md.uuid[idx]) {
2784 drbd_uuid_move_history(mdev);
2785 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
b411b363
PR		 2786 }
2787 _drbd_uuid_set(mdev, idx, val);
2788}
2789
2790/**
2791 * drbd_uuid_new_current() - Creates a new current UUID
2792 * @mdev: DRBD device.
2793 *
2794 * Creates a new current UUID, and rotates the old current UUID into
2795 * the bitmap slot. Causes an incremental resync upon next connect.
2796 */
2797void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
2798{
2799 u64 val;
62b0da3a
LE		 2800 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
2801
2802 if (bm_uuid)
2803 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
b411b363 2804
b411b363 2805 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
b411b363
PR		 2806
2807 get_random_bytes(&val, sizeof(u64));
2808 _drbd_uuid_set(mdev, UI_CURRENT, val);
62b0da3a 2809 drbd_print_uuids(mdev, "new current UUID");
aaa8e2b3
LE		 2810 /* get it to stable storage _now_ */
2811 drbd_md_sync(mdev);
b411b363
PR		 2812}
2813
2814void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
2815{
2816 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
2817 return;
2818
2819 if (val == 0) {
2820 drbd_uuid_move_history(mdev);
2821 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
2822 mdev->ldev->md.uuid[UI_BITMAP] = 0;
b411b363 2823 } else {
62b0da3a
LE		 2824 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
2825 if (bm_uuid)
2826 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
b411b363 2827
62b0da3a 2828 mdev->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);
b411b363
PR		 2829 }
2830 drbd_md_mark_dirty(mdev);
2831}
2832
2833/**
2834 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
2835 * @mdev: DRBD device.
2836 *
2837 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
2838 */
2839int drbd_bmio_set_n_write(struct drbd_conf *mdev)
2840{
2841 int rv = -EIO;
2842
2843 if (get_ldev_if_state(mdev, D_ATTACHING)) {
2844 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
2845 drbd_md_sync(mdev);
2846 drbd_bm_set_all(mdev);
2847
2848 rv = drbd_bm_write(mdev);
2849
2850 if (!rv) {
2851 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
2852 drbd_md_sync(mdev);
2853 }
2854
2855 put_ldev(mdev);
2856 }
2857
2858 return rv;
2859}
2860
2861/**
2862 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
2863 * @mdev: DRBD device.
2864 *
2865 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
2866 */
2867int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
2868{
2869 int rv = -EIO;
2870
0778286a 2871 drbd_resume_al(mdev);
b411b363
PR		 2872 if (get_ldev_if_state(mdev, D_ATTACHING)) {
2873 drbd_bm_clear_all(mdev);
2874 rv = drbd_bm_write(mdev);
2875 put_ldev(mdev);
2876 }
2877
2878 return rv;
2879}
2880
00d56944 2881static int w_bitmap_io(struct drbd_work *w, int unused)
b411b363
PR		 2882{
2883 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
00d56944 2884 struct drbd_conf *mdev = w->mdev;
02851e9f 2885 int rv = -EIO;
b411b363
PR		 2886
2887 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
2888
02851e9f 2889 if (get_ldev(mdev)) {
20ceb2b2 2890 drbd_bm_lock(mdev, work->why, work->flags);
02851e9f
LE		 2891 rv = work->io_fn(mdev);
2892 drbd_bm_unlock(mdev);
2893 put_ldev(mdev);
2894 }
b411b363 2895
4738fa16 2896 clear_bit_unlock(BITMAP_IO, &mdev->flags);
b411b363
PR		 2897 wake_up(&mdev->misc_wait);
2898
2899 if (work->done)
2900 work->done(mdev, rv);
2901
2902 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
2903 work->why = NULL;
20ceb2b2 2904 work->flags = 0;
b411b363
PR		 2905
2906 return 1;
2907}
2908
82f59cc6
LE		 2909void drbd_ldev_destroy(struct drbd_conf *mdev)
2910{
2911 lc_destroy(mdev->resync);
2912 mdev->resync = NULL;
2913 lc_destroy(mdev->act_log);
2914 mdev->act_log = NULL;
2915 __no_warn(local,
2916 drbd_free_bc(mdev->ldev);
2917 mdev->ldev = NULL;);
2918
82f59cc6
LE		 2919 clear_bit(GO_DISKLESS, &mdev->flags);
2920}
2921
00d56944 2922static int w_go_diskless(struct drbd_work *w, int unused)
e9e6f3ec 2923{
00d56944
PR		 2924 struct drbd_conf *mdev = w->mdev;
2925
e9e6f3ec 2926 D_ASSERT(mdev->state.disk == D_FAILED);
9d282875
LE		 2927 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
2928 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
82f59cc6
LE		 2929 * the protected members anymore, though, so once put_ldev reaches zero
2930 * again, it will be safe to free them. */
e9e6f3ec 2931 drbd_force_state(mdev, NS(disk, D_DISKLESS));
e9e6f3ec
LE		 2932 return 1;
2933}
2934
2935void drbd_go_diskless(struct drbd_conf *mdev)
2936{
2937 D_ASSERT(mdev->state.disk == D_FAILED);
2938 if (!test_and_set_bit(GO_DISKLESS, &mdev->flags))
e42325a5 2939 drbd_queue_work(&mdev->tconn->data.work, &mdev->go_diskless);
e9e6f3ec
LE		 2940}
2941
b411b363
PR		 2942/**
2943 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
2944 * @mdev: DRBD device.
2945 * @io_fn: IO callback to be called when bitmap IO is possible
2946 * @done: callback to be called after the bitmap IO was performed
2947 * @why: Descriptive text of the reason for doing the IO
2948 *
2949 * While IO on the bitmap happens we freeze application IO thus we ensure
2950 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
2951 * called from worker context. It MUST NOT be used while a previous such
2952 * work is still pending!
2953 */
2954void drbd_queue_bitmap_io(struct drbd_conf *mdev,
2955 int (*io_fn)(struct drbd_conf *),
2956 void (*done)(struct drbd_conf *, int),
20ceb2b2 2957 char *why, enum bm_flag flags)
b411b363 2958{
e6b3ea83 2959 D_ASSERT(current == mdev->tconn->worker.task);
b411b363
PR		 2960
2961 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
2962 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
2963 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
2964 if (mdev->bm_io_work.why)
2965 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
2966 why, mdev->bm_io_work.why);
2967
2968 mdev->bm_io_work.io_fn = io_fn;
2969 mdev->bm_io_work.done = done;
2970 mdev->bm_io_work.why = why;
20ceb2b2 2971 mdev->bm_io_work.flags = flags;
b411b363 2972
87eeee41 2973 spin_lock_irq(&mdev->tconn->req_lock);
b411b363
PR		 2974 set_bit(BITMAP_IO, &mdev->flags);
2975 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
127b3178 2976 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
e42325a5 2977 drbd_queue_work(&mdev->tconn->data.work, &mdev->bm_io_work.w);
b411b363 2978 }
87eeee41 2979 spin_unlock_irq(&mdev->tconn->req_lock);
b411b363
PR		 2980}
2981
2982/**
2983 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
2984 * @mdev: DRBD device.
2985 * @io_fn: IO callback to be called when bitmap IO is possible
2986 * @why: Descriptive text of the reason for doing the IO
2987 *
2988 * freezes application IO while that the actual IO operations runs. This
2989 * functions MAY NOT be called from worker context.
2990 */
20ceb2b2
LE		 2991int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *),
2992 char *why, enum bm_flag flags)
b411b363
PR		 2993{
2994 int rv;
2995
e6b3ea83 2996 D_ASSERT(current != mdev->tconn->worker.task);
b411b363 2997
20ceb2b2
LE		 2998 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
2999 drbd_suspend_io(mdev);
b411b363 3000
20ceb2b2 3001 drbd_bm_lock(mdev, why, flags);
b411b363
PR		 3002 rv = io_fn(mdev);
3003 drbd_bm_unlock(mdev);
3004
20ceb2b2
LE		 3005 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3006 drbd_resume_io(mdev);
b411b363
PR		 3007
3008 return rv;
3009}
3010
3011void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3012{
3013 if ((mdev->ldev->md.flags & flag) != flag) {
3014 drbd_md_mark_dirty(mdev);
3015 mdev->ldev->md.flags |= flag;
3016 }
3017}
3018
3019void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3020{
3021 if ((mdev->ldev->md.flags & flag) != 0) {
3022 drbd_md_mark_dirty(mdev);
3023 mdev->ldev->md.flags &= ~flag;
3024 }
3025}
3026int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3027{
3028 return (bdev->md.flags & flag) != 0;
3029}
3030
3031static void md_sync_timer_fn(unsigned long data)
3032{
3033 struct drbd_conf *mdev = (struct drbd_conf *) data;
3034
e42325a5 3035 drbd_queue_work_front(&mdev->tconn->data.work, &mdev->md_sync_work);
b411b363
PR		 3036}
3037
00d56944 3038static int w_md_sync(struct drbd_work *w, int unused)
b411b363 3039{
00d56944
PR		 3040 struct drbd_conf *mdev = w->mdev;
3041
b411b363 3042 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
ee15b038
LE		 3043#ifdef DEBUG
3044 dev_warn(DEV, "last md_mark_dirty: %s:%u\n",
3045 mdev->last_md_mark_dirty.func, mdev->last_md_mark_dirty.line);
3046#endif
b411b363 3047 drbd_md_sync(mdev);
b411b363
PR		 3048 return 1;
3049}
3050
d8763023 3051const char *cmdname(enum drbd_packet cmd)
f2ad9063
AG		 3052{
3053 /* THINK may need to become several global tables
3054 * when we want to support more than
3055 * one PRO_VERSION */
3056 static const char *cmdnames[] = {
3057 [P_DATA] = "Data",
3058 [P_DATA_REPLY] = "DataReply",
3059 [P_RS_DATA_REPLY] = "RSDataReply",
3060 [P_BARRIER] = "Barrier",
3061 [P_BITMAP] = "ReportBitMap",
3062 [P_BECOME_SYNC_TARGET] = "BecomeSyncTarget",
3063 [P_BECOME_SYNC_SOURCE] = "BecomeSyncSource",
3064 [P_UNPLUG_REMOTE] = "UnplugRemote",
3065 [P_DATA_REQUEST] = "DataRequest",
3066 [P_RS_DATA_REQUEST] = "RSDataRequest",
3067 [P_SYNC_PARAM] = "SyncParam",
3068 [P_SYNC_PARAM89] = "SyncParam89",
3069 [P_PROTOCOL] = "ReportProtocol",
3070 [P_UUIDS] = "ReportUUIDs",
3071 [P_SIZES] = "ReportSizes",
3072 [P_STATE] = "ReportState",
3073 [P_SYNC_UUID] = "ReportSyncUUID",
3074 [P_AUTH_CHALLENGE] = "AuthChallenge",
3075 [P_AUTH_RESPONSE] = "AuthResponse",
3076 [P_PING] = "Ping",
3077 [P_PING_ACK] = "PingAck",
3078 [P_RECV_ACK] = "RecvAck",
3079 [P_WRITE_ACK] = "WriteAck",
3080 [P_RS_WRITE_ACK] = "RSWriteAck",
7be8da07 3081 [P_DISCARD_WRITE] = "DiscardWrite",
f2ad9063
AG		 3082 [P_NEG_ACK] = "NegAck",
3083 [P_NEG_DREPLY] = "NegDReply",
3084 [P_NEG_RS_DREPLY] = "NegRSDReply",
3085 [P_BARRIER_ACK] = "BarrierAck",
3086 [P_STATE_CHG_REQ] = "StateChgRequest",
3087 [P_STATE_CHG_REPLY] = "StateChgReply",
3088 [P_OV_REQUEST] = "OVRequest",
3089 [P_OV_REPLY] = "OVReply",
3090 [P_OV_RESULT] = "OVResult",
3091 [P_CSUM_RS_REQUEST] = "CsumRSRequest",
3092 [P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
3093 [P_COMPRESSED_BITMAP] = "CBitmap",
3094 [P_DELAY_PROBE] = "DelayProbe",
3095 [P_OUT_OF_SYNC] = "OutOfSync",
7be8da07 3096 [P_RETRY_WRITE] = "RetryWrite",
f2ad9063
AG		 3097 };
3098
3099 if (cmd == P_HAND_SHAKE_M)
3100 return "HandShakeM";
3101 if (cmd == P_HAND_SHAKE_S)
3102 return "HandShakeS";
3103 if (cmd == P_HAND_SHAKE)
3104 return "HandShake";
6e849ce8 3105 if (cmd >= ARRAY_SIZE(cmdnames))
f2ad9063
AG		 3106 return "Unknown";
3107 return cmdnames[cmd];
3108}
3109
7be8da07
AG		 3110/**
3111 * drbd_wait_misc - wait for a request to make progress
3112 * @mdev: device associated with the request
3113 * @i: the struct drbd_interval embedded in struct drbd_request or
3114 * struct drbd_peer_request
3115 */
3116int drbd_wait_misc(struct drbd_conf *mdev, struct drbd_interval *i)
3117{
3118 struct net_conf *net_conf = mdev->tconn->net_conf;
3119 DEFINE_WAIT(wait);
3120 long timeout;
3121
3122 if (!net_conf)
3123 return -ETIMEDOUT;
3124 timeout = MAX_SCHEDULE_TIMEOUT;
3125 if (net_conf->ko_count)
3126 timeout = net_conf->timeout * HZ / 10 * net_conf->ko_count;
3127
3128 /* Indicate to wake up mdev->misc_wait on progress. */
3129 i->waiting = true;
3130 prepare_to_wait(&mdev->misc_wait, &wait, TASK_INTERRUPTIBLE);
3131 spin_unlock_irq(&mdev->tconn->req_lock);
3132 timeout = schedule_timeout(timeout);
3133 finish_wait(&mdev->misc_wait, &wait);
3134 spin_lock_irq(&mdev->tconn->req_lock);
3135 if (!timeout || mdev->state.conn < C_CONNECTED)
3136 return -ETIMEDOUT;
3137 if (signal_pending(current))
3138 return -ERESTARTSYS;
3139 return 0;
3140}
3141
b411b363
PR		 3142#ifdef CONFIG_DRBD_FAULT_INJECTION
3143/* Fault insertion support including random number generator shamelessly
3144 * stolen from kernel/rcutorture.c */
3145struct fault_random_state {
3146 unsigned long state;
3147 unsigned long count;
3148};
3149
3150#define FAULT_RANDOM_MULT 39916801 /* prime */
3151#define FAULT_RANDOM_ADD 479001701 /* prime */
3152#define FAULT_RANDOM_REFRESH 10000
3153
3154/*
3155 * Crude but fast random-number generator. Uses a linear congruential
3156 * generator, with occasional help from get_random_bytes().
3157 */
3158static unsigned long
3159_drbd_fault_random(struct fault_random_state *rsp)
3160{
3161 long refresh;
3162
49829ea7 3163 if (!rsp->count--) {
b411b363
PR		 3164 get_random_bytes(&refresh, sizeof(refresh));
3165 rsp->state += refresh;
3166 rsp->count = FAULT_RANDOM_REFRESH;
3167 }
3168 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3169 return swahw32(rsp->state);
3170}
3171
3172static char *
3173_drbd_fault_str(unsigned int type) {
3174 static char *_faults[] = {
3175 [DRBD_FAULT_MD_WR] = "Meta-data write",
3176 [DRBD_FAULT_MD_RD] = "Meta-data read",
3177 [DRBD_FAULT_RS_WR] = "Resync write",
3178 [DRBD_FAULT_RS_RD] = "Resync read",
3179 [DRBD_FAULT_DT_WR] = "Data write",
3180 [DRBD_FAULT_DT_RD] = "Data read",
3181 [DRBD_FAULT_DT_RA] = "Data read ahead",
3182 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
6b4388ac
PR		 3183 [DRBD_FAULT_AL_EE] = "EE allocation",
3184 [DRBD_FAULT_RECEIVE] = "receive data corruption",
b411b363
PR		 3185 };
3186
3187 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3188}
3189
3190unsigned int
3191_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3192{
3193 static struct fault_random_state rrs = {0, 0};
3194
3195 unsigned int ret = (
3196 (fault_devs == 0 ||
3197 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3198 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3199
3200 if (ret) {
3201 fault_count++;
3202
7383506c 3203 if (__ratelimit(&drbd_ratelimit_state))
b411b363
PR		 3204 dev_warn(DEV, "***Simulating %s failure\n",
3205 _drbd_fault_str(type));
3206 }
3207
3208 return ret;
3209}
3210#endif
3211
3212const char *drbd_buildtag(void)
3213{
3214 /* DRBD built from external sources has here a reference to the
3215 git hash of the source code. */
3216
3217 static char buildtag[38] = "\0uilt-in";
3218
3219 if (buildtag[0] == 0) {
3220#ifdef CONFIG_MODULES
3221 if (THIS_MODULE != NULL)
3222 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3223 else
3224#endif
3225 buildtag[0] = 'b';
3226 }
3227
3228 return buildtag;
3229}
3230
3231module_init(drbd_init)
3232module_exit(drbd_cleanup)
3233
b411b363
PR		 3234EXPORT_SYMBOL(drbd_conn_str);
3235EXPORT_SYMBOL(drbd_role_str);
3236EXPORT_SYMBOL(drbd_disk_str);
3237EXPORT_SYMBOL(drbd_set_st_err_str);
Linux kernel - Deliverables
This page took 0.3297 seconds and 5 git commands to generate.