projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drbd: Removing a by now obsolete clause in the state sanitizing
[linux-2.6-block.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>
35#include <linux/smp_lock.h>
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
59struct after_state_chg_work {
60 struct drbd_work w;
61 union drbd_state os;
62 union drbd_state ns;
63 enum chg_state_flags flags;
64 struct completion *done;
65};
66
67int drbdd_init(struct drbd_thread *);
68int drbd_worker(struct drbd_thread *);
69int drbd_asender(struct drbd_thread *);
70
71int drbd_init(void);
72static int drbd_open(struct block_device *bdev, fmode_t mode);
73static int drbd_release(struct gendisk *gd, fmode_t mode);
74static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused);
75static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
76 union drbd_state ns, enum chg_state_flags flags);
77static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused);
78static void md_sync_timer_fn(unsigned long data);
79static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused);
80
b411b363
PR		 81MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
82 "Lars Ellenberg <lars@linbit.com>");
83MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
84MODULE_VERSION(REL_VERSION);
85MODULE_LICENSE("GPL");
86MODULE_PARM_DESC(minor_count, "Maximum number of drbd devices (1-255)");
87MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
88
89#include <linux/moduleparam.h>
90/* allow_open_on_secondary */
91MODULE_PARM_DESC(allow_oos, "DONT USE!");
92/* thanks to these macros, if compiled into the kernel (not-module),
93 * this becomes the boot parameter drbd.minor_count */
94module_param(minor_count, uint, 0444);
95module_param(disable_sendpage, bool, 0644);
96module_param(allow_oos, bool, 0);
97module_param(cn_idx, uint, 0444);
98module_param(proc_details, int, 0644);
99
100#ifdef CONFIG_DRBD_FAULT_INJECTION
101int enable_faults;
102int fault_rate;
103static int fault_count;
104int fault_devs;
105/* bitmap of enabled faults */
106module_param(enable_faults, int, 0664);
107/* fault rate % value - applies to all enabled faults */
108module_param(fault_rate, int, 0664);
109/* count of faults inserted */
110module_param(fault_count, int, 0664);
111/* bitmap of devices to insert faults on */
112module_param(fault_devs, int, 0644);
113#endif
114
115/* module parameter, defined */
116unsigned int minor_count = 32;
117int disable_sendpage;
118int allow_oos;
119unsigned int cn_idx = CN_IDX_DRBD;
120int proc_details; /* Detail level in proc drbd*/
121
122/* Module parameter for setting the user mode helper program
123 * to run. Default is /sbin/drbdadm */
124char usermode_helper[80] = "/sbin/drbdadm";
125
126module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
127
128/* in 2.6.x, our device mapping and config info contains our virtual gendisks
129 * as member "struct gendisk *vdisk;"
130 */
131struct drbd_conf **minor_table;
132
133struct kmem_cache *drbd_request_cache;
134struct kmem_cache *drbd_ee_cache; /* epoch entries */
135struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
136struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
137mempool_t *drbd_request_mempool;
138mempool_t *drbd_ee_mempool;
139
140/* I do not use a standard mempool, because:
141 1) I want to hand out the pre-allocated objects first.
142 2) I want to be able to interrupt sleeping allocation with a signal.
143 Note: This is a single linked list, the next pointer is the private
144 member of struct page.
145 */
146struct page *drbd_pp_pool;
147spinlock_t drbd_pp_lock;
148int drbd_pp_vacant;
149wait_queue_head_t drbd_pp_wait;
150
151DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
152
7d4e9d09 153static const struct block_device_operations drbd_ops = {
b411b363
PR		 154 .owner = THIS_MODULE,
155 .open = drbd_open,
156 .release = drbd_release,
157};
158
159#define ARRY_SIZE(A) (sizeof(A)/sizeof(A[0]))
160
161#ifdef __CHECKER__
162/* When checking with sparse, and this is an inline function, sparse will
163 give tons of false positives. When this is a real functions sparse works.
164 */
165int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
166{
167 int io_allowed;
168
169 atomic_inc(&mdev->local_cnt);
170 io_allowed = (mdev->state.disk >= mins);
171 if (!io_allowed) {
172 if (atomic_dec_and_test(&mdev->local_cnt))
173 wake_up(&mdev->misc_wait);
174 }
175 return io_allowed;
176}
177
178#endif
179
180/**
181 * DOC: The transfer log
182 *
183 * The transfer log is a single linked list of &struct drbd_tl_epoch objects.
184 * mdev->newest_tle points to the head, mdev->oldest_tle points to the tail
185 * of the list. There is always at least one &struct drbd_tl_epoch object.
186 *
187 * Each &struct drbd_tl_epoch has a circular double linked list of requests
188 * attached.
189 */
190static int tl_init(struct drbd_conf *mdev)
191{
192 struct drbd_tl_epoch *b;
193
194 /* during device minor initialization, we may well use GFP_KERNEL */
195 b = kmalloc(sizeof(struct drbd_tl_epoch), GFP_KERNEL);
196 if (!b)
197 return 0;
198 INIT_LIST_HEAD(&b->requests);
199 INIT_LIST_HEAD(&b->w.list);
200 b->next = NULL;
201 b->br_number = 4711;
7e602c0a 202 b->n_writes = 0;
b411b363
PR		 203 b->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
204
205 mdev->oldest_tle = b;
206 mdev->newest_tle = b;
207 INIT_LIST_HEAD(&mdev->out_of_sequence_requests);
208
209 mdev->tl_hash = NULL;
210 mdev->tl_hash_s = 0;
211
212 return 1;
213}
214
215static void tl_cleanup(struct drbd_conf *mdev)
216{
217 D_ASSERT(mdev->oldest_tle == mdev->newest_tle);
218 D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
219 kfree(mdev->oldest_tle);
220 mdev->oldest_tle = NULL;
221 kfree(mdev->unused_spare_tle);
222 mdev->unused_spare_tle = NULL;
223 kfree(mdev->tl_hash);
224 mdev->tl_hash = NULL;
225 mdev->tl_hash_s = 0;
226}
227
228/**
229 * _tl_add_barrier() - Adds a barrier to the transfer log
230 * @mdev: DRBD device.
231 * @new: Barrier to be added before the current head of the TL.
232 *
233 * The caller must hold the req_lock.
234 */
235void _tl_add_barrier(struct drbd_conf *mdev, struct drbd_tl_epoch *new)
236{
237 struct drbd_tl_epoch *newest_before;
238
239 INIT_LIST_HEAD(&new->requests);
240 INIT_LIST_HEAD(&new->w.list);
241 new->w.cb = NULL; /* if this is != NULL, we need to dec_ap_pending in tl_clear */
242 new->next = NULL;
7e602c0a 243 new->n_writes = 0;
b411b363
PR		 244
245 newest_before = mdev->newest_tle;
246 /* never send a barrier number == 0, because that is special-cased
247 * when using TCQ for our write ordering code */
248 new->br_number = (newest_before->br_number+1) ?: 1;
249 if (mdev->newest_tle != new) {
250 mdev->newest_tle->next = new;
251 mdev->newest_tle = new;
252 }
253}
254
255/**
256 * tl_release() - Free or recycle the oldest &struct drbd_tl_epoch object of the TL
257 * @mdev: DRBD device.
258 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
259 * @set_size: Expected number of requests before that barrier.
260 *
261 * In case the passed barrier_nr or set_size does not match the oldest
262 * &struct drbd_tl_epoch objects this function will cause a termination
263 * of the connection.
264 */
265void tl_release(struct drbd_conf *mdev, unsigned int barrier_nr,
266 unsigned int set_size)
267{
268 struct drbd_tl_epoch *b, *nob; /* next old barrier */
269 struct list_head *le, *tle;
270 struct drbd_request *r;
271
272 spin_lock_irq(&mdev->req_lock);
273
274 b = mdev->oldest_tle;
275
276 /* first some paranoia code */
277 if (b == NULL) {
278 dev_err(DEV, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
279 barrier_nr);
280 goto bail;
281 }
282 if (b->br_number != barrier_nr) {
283 dev_err(DEV, "BAD! BarrierAck #%u received, expected #%u!\n",
284 barrier_nr, b->br_number);
285 goto bail;
286 }
7e602c0a
PR		 287 if (b->n_writes != set_size) {
288 dev_err(DEV, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
289 barrier_nr, set_size, b->n_writes);
b411b363
PR		 290 goto bail;
291 }
292
293 /* Clean up list of requests processed during current epoch */
294 list_for_each_safe(le, tle, &b->requests) {
295 r = list_entry(le, struct drbd_request, tl_requests);
296 _req_mod(r, barrier_acked);
297 }
298 /* There could be requests on the list waiting for completion
299 of the write to the local disk. To avoid corruptions of
300 slab's data structures we have to remove the lists head.
301
302 Also there could have been a barrier ack out of sequence, overtaking
303 the write acks - which would be a bug and violating write ordering.
304 To not deadlock in case we lose connection while such requests are
305 still pending, we need some way to find them for the
306 _req_mode(connection_lost_while_pending).
307
308 These have been list_move'd to the out_of_sequence_requests list in
309 _req_mod(, barrier_acked) above.
310 */
311 list_del_init(&b->requests);
312
313 nob = b->next;
314 if (test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) {
315 _tl_add_barrier(mdev, b);
316 if (nob)
317 mdev->oldest_tle = nob;
318 /* if nob == NULL b was the only barrier, and becomes the new
319 barrier. Therefore mdev->oldest_tle points already to b */
320 } else {
321 D_ASSERT(nob != NULL);
322 mdev->oldest_tle = nob;
323 kfree(b);
324 }
325
326 spin_unlock_irq(&mdev->req_lock);
327 dec_ap_pending(mdev);
328
329 return;
330
331bail:
332 spin_unlock_irq(&mdev->req_lock);
333 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
334}
335
b411b363 336/**
11b58e73 337 * _tl_restart() - Walks the transfer log, and applies an action to all requests
b411b363 338 * @mdev: DRBD device.
11b58e73 339 * @what: The action/event to perform with all request objects
b411b363 340 *
11b58e73
PR		 341 * @what might be one of connection_lost_while_pending, resend, fail_frozen_disk_io,
342 * restart_frozen_disk_io.
b411b363 343 */
11b58e73 344static void _tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
b411b363 345{
11b58e73 346 struct drbd_tl_epoch *b, *tmp, **pn;
b9b98716 347 struct list_head *le, *tle, carry_reads;
11b58e73
PR		 348 struct drbd_request *req;
349 int rv, n_writes, n_reads;
b411b363
PR		 350
351 b = mdev->oldest_tle;
11b58e73 352 pn = &mdev->oldest_tle;
b411b363 353 while (b) {
11b58e73
PR		 354 n_writes = 0;
355 n_reads = 0;
b9b98716 356 INIT_LIST_HEAD(&carry_reads);
b411b363 357 list_for_each_safe(le, tle, &b->requests) {
11b58e73
PR		 358 req = list_entry(le, struct drbd_request, tl_requests);
359 rv = _req_mod(req, what);
360
361 n_writes += (rv & MR_WRITE) >> MR_WRITE_SHIFT;
362 n_reads += (rv & MR_READ) >> MR_READ_SHIFT;
b411b363
PR		 363 }
364 tmp = b->next;
365
b9b98716 366 if (n_writes) {
11b58e73
PR		 367 if (what == resend) {
368 b->n_writes = n_writes;
369 if (b->w.cb == NULL) {
370 b->w.cb = w_send_barrier;
371 inc_ap_pending(mdev);
372 set_bit(CREATE_BARRIER, &mdev->flags);
373 }
374
375 drbd_queue_work(&mdev->data.work, &b->w);
376 }
377 pn = &b->next;
378 } else {
b9b98716
PR		 379 if (n_reads)
380 list_add(&carry_reads, &b->requests);
11b58e73
PR		 381 /* there could still be requests on that ring list,
382 * in case local io is still pending */
383 list_del(&b->requests);
384
385 /* dec_ap_pending corresponding to queue_barrier.
386 * the newest barrier may not have been queued yet,
387 * in which case w.cb is still NULL. */
388 if (b->w.cb != NULL)
389 dec_ap_pending(mdev);
390
391 if (b == mdev->newest_tle) {
392 /* recycle, but reinit! */
393 D_ASSERT(tmp == NULL);
394 INIT_LIST_HEAD(&b->requests);
b9b98716 395 list_splice(&carry_reads, &b->requests);
11b58e73
PR		 396 INIT_LIST_HEAD(&b->w.list);
397 b->w.cb = NULL;
398 b->br_number = net_random();
399 b->n_writes = 0;
400
401 *pn = b;
402 break;
403 }
404 *pn = tmp;
405 kfree(b);
b411b363 406 }
b411b363 407 b = tmp;
b9b98716 408 list_splice(&carry_reads, &b->requests);
b411b363 409 }
11b58e73
PR		 410}
411
412
413/**
414 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
415 * @mdev: DRBD device.
416 *
417 * This is called after the connection to the peer was lost. The storage covered
418 * by the requests on the transfer gets marked as our of sync. Called from the
419 * receiver thread and the worker thread.
420 */
421void tl_clear(struct drbd_conf *mdev)
422{
423 struct list_head *le, *tle;
424 struct drbd_request *r;
425
426 spin_lock_irq(&mdev->req_lock);
427
428 _tl_restart(mdev, connection_lost_while_pending);
b411b363
PR		 429
430 /* we expect this list to be empty. */
431 D_ASSERT(list_empty(&mdev->out_of_sequence_requests));
432
433 /* but just in case, clean it up anyways! */
434 list_for_each_safe(le, tle, &mdev->out_of_sequence_requests) {
435 r = list_entry(le, struct drbd_request, tl_requests);
436 /* It would be nice to complete outside of spinlock.
437 * But this is easier for now. */
438 _req_mod(r, connection_lost_while_pending);
439 }
440
441 /* ensure bit indicating barrier is required is clear */
442 clear_bit(CREATE_BARRIER, &mdev->flags);
443
288f422e
PR		 444 memset(mdev->app_reads_hash, 0, APP_R_HSIZE*sizeof(void *));
445
b411b363
PR		 446 spin_unlock_irq(&mdev->req_lock);
447}
448
11b58e73
PR		 449void tl_restart(struct drbd_conf *mdev, enum drbd_req_event what)
450{
451 spin_lock_irq(&mdev->req_lock);
452 _tl_restart(mdev, what);
453 spin_unlock_irq(&mdev->req_lock);
454}
455
b411b363
PR		 456/**
457 * cl_wide_st_chg() - TRUE if the state change is a cluster wide one
458 * @mdev: DRBD device.
459 * @os: old (current) state.
460 * @ns: new (wanted) state.
461 */
462static int cl_wide_st_chg(struct drbd_conf *mdev,
463 union drbd_state os, union drbd_state ns)
464{
465 return (os.conn >= C_CONNECTED && ns.conn >= C_CONNECTED &&
466 ((os.role != R_PRIMARY && ns.role == R_PRIMARY) ||
467 (os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
468 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S) ||
469 (os.disk != D_DISKLESS && ns.disk == D_DISKLESS))) ||
470 (os.conn >= C_CONNECTED && ns.conn == C_DISCONNECTING) ||
471 (os.conn == C_CONNECTED && ns.conn == C_VERIFY_S);
472}
473
474int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f,
475 union drbd_state mask, union drbd_state val)
476{
477 unsigned long flags;
478 union drbd_state os, ns;
479 int rv;
480
481 spin_lock_irqsave(&mdev->req_lock, flags);
482 os = mdev->state;
483 ns.i = (os.i & ~mask.i) | val.i;
484 rv = _drbd_set_state(mdev, ns, f, NULL);
485 ns = mdev->state;
486 spin_unlock_irqrestore(&mdev->req_lock, flags);
487
488 return rv;
489}
490
491/**
492 * drbd_force_state() - Impose a change which happens outside our control on our state
493 * @mdev: DRBD device.
494 * @mask: mask of state bits to change.
495 * @val: value of new state bits.
496 */
497void drbd_force_state(struct drbd_conf *mdev,
498 union drbd_state mask, union drbd_state val)
499{
500 drbd_change_state(mdev, CS_HARD, mask, val);
501}
502
503static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns);
504static int is_valid_state_transition(struct drbd_conf *,
505 union drbd_state, union drbd_state);
506static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
507 union drbd_state ns, int *warn_sync_abort);
508int drbd_send_state_req(struct drbd_conf *,
509 union drbd_state, union drbd_state);
510
511static enum drbd_state_ret_codes _req_st_cond(struct drbd_conf *mdev,
512 union drbd_state mask, union drbd_state val)
513{
514 union drbd_state os, ns;
515 unsigned long flags;
516 int rv;
517
518 if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &mdev->flags))
519 return SS_CW_SUCCESS;
520
521 if (test_and_clear_bit(CL_ST_CHG_FAIL, &mdev->flags))
522 return SS_CW_FAILED_BY_PEER;
523
524 rv = 0;
525 spin_lock_irqsave(&mdev->req_lock, flags);
526 os = mdev->state;
527 ns.i = (os.i & ~mask.i) | val.i;
528 ns = sanitize_state(mdev, os, ns, NULL);
529
530 if (!cl_wide_st_chg(mdev, os, ns))
531 rv = SS_CW_NO_NEED;
532 if (!rv) {
533 rv = is_valid_state(mdev, ns);
534 if (rv == SS_SUCCESS) {
535 rv = is_valid_state_transition(mdev, ns, os);
536 if (rv == SS_SUCCESS)
537 rv = 0; /* cont waiting, otherwise fail. */
538 }
539 }
540 spin_unlock_irqrestore(&mdev->req_lock, flags);
541
542 return rv;
543}
544
545/**
546 * drbd_req_state() - Perform an eventually cluster wide state change
547 * @mdev: DRBD device.
548 * @mask: mask of state bits to change.
549 * @val: value of new state bits.
550 * @f: flags
551 *
552 * Should not be called directly, use drbd_request_state() or
553 * _drbd_request_state().
554 */
555static int drbd_req_state(struct drbd_conf *mdev,
556 union drbd_state mask, union drbd_state val,
557 enum chg_state_flags f)
558{
559 struct completion done;
560 unsigned long flags;
561 union drbd_state os, ns;
562 int rv;
563
564 init_completion(&done);
565
566 if (f & CS_SERIALIZE)
567 mutex_lock(&mdev->state_mutex);
568
569 spin_lock_irqsave(&mdev->req_lock, flags);
570 os = mdev->state;
571 ns.i = (os.i & ~mask.i) | val.i;
572 ns = sanitize_state(mdev, os, ns, NULL);
573
574 if (cl_wide_st_chg(mdev, os, ns)) {
575 rv = is_valid_state(mdev, ns);
576 if (rv == SS_SUCCESS)
577 rv = is_valid_state_transition(mdev, ns, os);
578 spin_unlock_irqrestore(&mdev->req_lock, flags);
579
580 if (rv < SS_SUCCESS) {
581 if (f & CS_VERBOSE)
582 print_st_err(mdev, os, ns, rv);
583 goto abort;
584 }
585
586 drbd_state_lock(mdev);
587 if (!drbd_send_state_req(mdev, mask, val)) {
588 drbd_state_unlock(mdev);
589 rv = SS_CW_FAILED_BY_PEER;
590 if (f & CS_VERBOSE)
591 print_st_err(mdev, os, ns, rv);
592 goto abort;
593 }
594
595 wait_event(mdev->state_wait,
596 (rv = _req_st_cond(mdev, mask, val)));
597
598 if (rv < SS_SUCCESS) {
599 drbd_state_unlock(mdev);
600 if (f & CS_VERBOSE)
601 print_st_err(mdev, os, ns, rv);
602 goto abort;
603 }
604 spin_lock_irqsave(&mdev->req_lock, flags);
605 os = mdev->state;
606 ns.i = (os.i & ~mask.i) | val.i;
607 rv = _drbd_set_state(mdev, ns, f, &done);
608 drbd_state_unlock(mdev);
609 } else {
610 rv = _drbd_set_state(mdev, ns, f, &done);
611 }
612
613 spin_unlock_irqrestore(&mdev->req_lock, flags);
614
615 if (f & CS_WAIT_COMPLETE && rv == SS_SUCCESS) {
616 D_ASSERT(current != mdev->worker.task);
617 wait_for_completion(&done);
618 }
619
620abort:
621 if (f & CS_SERIALIZE)
622 mutex_unlock(&mdev->state_mutex);
623
624 return rv;
625}
626
627/**
628 * _drbd_request_state() - Request a state change (with flags)
629 * @mdev: DRBD device.
630 * @mask: mask of state bits to change.
631 * @val: value of new state bits.
632 * @f: flags
633 *
634 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE
635 * flag, or when logging of failed state change requests is not desired.
636 */
637int _drbd_request_state(struct drbd_conf *mdev, union drbd_state mask,
638 union drbd_state val, enum chg_state_flags f)
639{
640 int rv;
641
642 wait_event(mdev->state_wait,
643 (rv = drbd_req_state(mdev, mask, val, f)) != SS_IN_TRANSIENT_STATE);
644
645 return rv;
646}
647
648static void print_st(struct drbd_conf *mdev, char *name, union drbd_state ns)
649{
650 dev_err(DEV, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c }\n",
651 name,
652 drbd_conn_str(ns.conn),
653 drbd_role_str(ns.role),
654 drbd_role_str(ns.peer),
655 drbd_disk_str(ns.disk),
656 drbd_disk_str(ns.pdsk),
657 ns.susp ? 's' : 'r',
658 ns.aftr_isp ? 'a' : '-',
659 ns.peer_isp ? 'p' : '-',
660 ns.user_isp ? 'u' : '-'
661 );
662}
663
664void print_st_err(struct drbd_conf *mdev,
665 union drbd_state os, union drbd_state ns, int err)
666{
667 if (err == SS_IN_TRANSIENT_STATE)
668 return;
669 dev_err(DEV, "State change failed: %s\n", drbd_set_st_err_str(err));
670 print_st(mdev, " state", os);
671 print_st(mdev, "wanted", ns);
672}
673
674
675#define drbd_peer_str drbd_role_str
676#define drbd_pdsk_str drbd_disk_str
677
678#define drbd_susp_str(A) ((A) ? "1" : "0")
679#define drbd_aftr_isp_str(A) ((A) ? "1" : "0")
680#define drbd_peer_isp_str(A) ((A) ? "1" : "0")
681#define drbd_user_isp_str(A) ((A) ? "1" : "0")
682
683#define PSC(A) \
684 ({ if (ns.A != os.A) { \
685 pbp += sprintf(pbp, #A "( %s -> %s ) ", \
686 drbd_##A##_str(os.A), \
687 drbd_##A##_str(ns.A)); \
688 } })
689
690/**
691 * is_valid_state() - Returns an SS_ error code if ns is not valid
692 * @mdev: DRBD device.
693 * @ns: State to consider.
694 */
695static int is_valid_state(struct drbd_conf *mdev, union drbd_state ns)
696{
697 /* See drbd_state_sw_errors in drbd_strings.c */
698
699 enum drbd_fencing_p fp;
700 int rv = SS_SUCCESS;
701
702 fp = FP_DONT_CARE;
703 if (get_ldev(mdev)) {
704 fp = mdev->ldev->dc.fencing;
705 put_ldev(mdev);
706 }
707
708 if (get_net_conf(mdev)) {
709 if (!mdev->net_conf->two_primaries &&
710 ns.role == R_PRIMARY && ns.peer == R_PRIMARY)
711 rv = SS_TWO_PRIMARIES;
712 put_net_conf(mdev);
713 }
714
715 if (rv <= 0)
716 /* already found a reason to abort */;
717 else if (ns.role == R_SECONDARY && mdev->open_cnt)
718 rv = SS_DEVICE_IN_USE;
719
720 else if (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.disk < D_UP_TO_DATE)
721 rv = SS_NO_UP_TO_DATE_DISK;
722
723 else if (fp >= FP_RESOURCE &&
724 ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk >= D_UNKNOWN)
725 rv = SS_PRIMARY_NOP;
726
727 else if (ns.role == R_PRIMARY && ns.disk <= D_INCONSISTENT && ns.pdsk <= D_INCONSISTENT)
728 rv = SS_NO_UP_TO_DATE_DISK;
729
730 else if (ns.conn > C_CONNECTED && ns.disk < D_INCONSISTENT)
731 rv = SS_NO_LOCAL_DISK;
732
733 else if (ns.conn > C_CONNECTED && ns.pdsk < D_INCONSISTENT)
734 rv = SS_NO_REMOTE_DISK;
735
8d4ce82b
LE		 736 else if (ns.conn > C_CONNECTED && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE)
737 rv = SS_NO_UP_TO_DATE_DISK;
738
b411b363
PR		 739 else if ((ns.conn == C_CONNECTED ||
740 ns.conn == C_WF_BITMAP_S ||
741 ns.conn == C_SYNC_SOURCE ||
742 ns.conn == C_PAUSED_SYNC_S) &&
743 ns.disk == D_OUTDATED)
744 rv = SS_CONNECTED_OUTDATES;
745
746 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
747 (mdev->sync_conf.verify_alg[0] == 0))
748 rv = SS_NO_VERIFY_ALG;
749
750 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
751 mdev->agreed_pro_version < 88)
752 rv = SS_NOT_SUPPORTED;
753
754 return rv;
755}
756
757/**
758 * is_valid_state_transition() - Returns an SS_ error code if the state transition is not possible
759 * @mdev: DRBD device.
760 * @ns: new state.
761 * @os: old state.
762 */
763static int is_valid_state_transition(struct drbd_conf *mdev,
764 union drbd_state ns, union drbd_state os)
765{
766 int rv = SS_SUCCESS;
767
768 if ((ns.conn == C_STARTING_SYNC_T || ns.conn == C_STARTING_SYNC_S) &&
769 os.conn > C_CONNECTED)
770 rv = SS_RESYNC_RUNNING;
771
772 if (ns.conn == C_DISCONNECTING && os.conn == C_STANDALONE)
773 rv = SS_ALREADY_STANDALONE;
774
775 if (ns.disk > D_ATTACHING && os.disk == D_DISKLESS)
776 rv = SS_IS_DISKLESS;
777
778 if (ns.conn == C_WF_CONNECTION && os.conn < C_UNCONNECTED)
779 rv = SS_NO_NET_CONFIG;
780
781 if (ns.disk == D_OUTDATED && os.disk < D_OUTDATED && os.disk != D_ATTACHING)
782 rv = SS_LOWER_THAN_OUTDATED;
783
784 if (ns.conn == C_DISCONNECTING && os.conn == C_UNCONNECTED)
785 rv = SS_IN_TRANSIENT_STATE;
786
787 if (ns.conn == os.conn && ns.conn == C_WF_REPORT_PARAMS)
788 rv = SS_IN_TRANSIENT_STATE;
789
790 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && os.conn < C_CONNECTED)
791 rv = SS_NEED_CONNECTION;
792
793 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) &&
794 ns.conn != os.conn && os.conn > C_CONNECTED)
795 rv = SS_RESYNC_RUNNING;
796
797 if ((ns.conn == C_STARTING_SYNC_S || ns.conn == C_STARTING_SYNC_T) &&
798 os.conn < C_CONNECTED)
799 rv = SS_NEED_CONNECTION;
800
801 return rv;
802}
803
804/**
805 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition
806 * @mdev: DRBD device.
807 * @os: old state.
808 * @ns: new state.
809 * @warn_sync_abort:
810 *
811 * When we loose connection, we have to set the state of the peers disk (pdsk)
812 * to D_UNKNOWN. This rule and many more along those lines are in this function.
813 */
814static union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,
815 union drbd_state ns, int *warn_sync_abort)
816{
817 enum drbd_fencing_p fp;
818
819 fp = FP_DONT_CARE;
820 if (get_ldev(mdev)) {
821 fp = mdev->ldev->dc.fencing;
822 put_ldev(mdev);
823 }
824
825 /* Disallow Network errors to configure a device's network part */
826 if ((ns.conn >= C_TIMEOUT && ns.conn <= C_TEAR_DOWN) &&
827 os.conn <= C_DISCONNECTING)
828 ns.conn = os.conn;
829
830 /* After a network error (+C_TEAR_DOWN) only C_UNCONNECTED or C_DISCONNECTING can follow */
831 if (os.conn >= C_TIMEOUT && os.conn <= C_TEAR_DOWN &&
832 ns.conn != C_UNCONNECTED && ns.conn != C_DISCONNECTING)
833 ns.conn = os.conn;
834
835 /* After C_DISCONNECTING only C_STANDALONE may follow */
836 if (os.conn == C_DISCONNECTING && ns.conn != C_STANDALONE)
837 ns.conn = os.conn;
838
839 if (ns.conn < C_CONNECTED) {
840 ns.peer_isp = 0;
841 ns.peer = R_UNKNOWN;
842 if (ns.pdsk > D_UNKNOWN || ns.pdsk < D_INCONSISTENT)
843 ns.pdsk = D_UNKNOWN;
844 }
845
846 /* Clear the aftr_isp when becoming unconfigured */
847 if (ns.conn == C_STANDALONE && ns.disk == D_DISKLESS && ns.role == R_SECONDARY)
848 ns.aftr_isp = 0;
849
b411b363
PR		 850 /* Abort resync if a disk fails/detaches */
851 if (os.conn > C_CONNECTED && ns.conn > C_CONNECTED &&
852 (ns.disk <= D_FAILED || ns.pdsk <= D_FAILED)) {
853 if (warn_sync_abort)
854 *warn_sync_abort = 1;
855 ns.conn = C_CONNECTED;
856 }
857
858 if (ns.conn >= C_CONNECTED &&
859 ((ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED) ||
860 (ns.disk == D_NEGOTIATING && ns.conn == C_WF_BITMAP_T))) {
861 switch (ns.conn) {
862 case C_WF_BITMAP_T:
863 case C_PAUSED_SYNC_T:
864 ns.disk = D_OUTDATED;
865 break;
866 case C_CONNECTED:
867 case C_WF_BITMAP_S:
868 case C_SYNC_SOURCE:
869 case C_PAUSED_SYNC_S:
870 ns.disk = D_UP_TO_DATE;
871 break;
872 case C_SYNC_TARGET:
873 ns.disk = D_INCONSISTENT;
874 dev_warn(DEV, "Implicitly set disk state Inconsistent!\n");
875 break;
876 }
877 if (os.disk == D_OUTDATED && ns.disk == D_UP_TO_DATE)
878 dev_warn(DEV, "Implicitly set disk from Outdated to UpToDate\n");
879 }
880
881 if (ns.conn >= C_CONNECTED &&
882 (ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED)) {
883 switch (ns.conn) {
884 case C_CONNECTED:
885 case C_WF_BITMAP_T:
886 case C_PAUSED_SYNC_T:
887 case C_SYNC_TARGET:
888 ns.pdsk = D_UP_TO_DATE;
889 break;
890 case C_WF_BITMAP_S:
891 case C_PAUSED_SYNC_S:
e0f83012
LE		 892 /* remap any consistent state to D_OUTDATED,
893 * but disallow "upgrade" of not even consistent states.
894 */
895 ns.pdsk =
896 (D_DISKLESS < os.pdsk && os.pdsk < D_OUTDATED)
897 ? os.pdsk : D_OUTDATED;
b411b363
PR		 898 break;
899 case C_SYNC_SOURCE:
900 ns.pdsk = D_INCONSISTENT;
901 dev_warn(DEV, "Implicitly set pdsk Inconsistent!\n");
902 break;
903 }
904 if (os.pdsk == D_OUTDATED && ns.pdsk == D_UP_TO_DATE)
905 dev_warn(DEV, "Implicitly set pdsk from Outdated to UpToDate\n");
906 }
907
908 /* Connection breaks down before we finished "Negotiating" */
909 if (ns.conn < C_CONNECTED && ns.disk == D_NEGOTIATING &&
910 get_ldev_if_state(mdev, D_NEGOTIATING)) {
911 if (mdev->ed_uuid == mdev->ldev->md.uuid[UI_CURRENT]) {
912 ns.disk = mdev->new_state_tmp.disk;
913 ns.pdsk = mdev->new_state_tmp.pdsk;
914 } else {
915 dev_alert(DEV, "Connection lost while negotiating, no data!\n");
916 ns.disk = D_DISKLESS;
917 ns.pdsk = D_UNKNOWN;
918 }
919 put_ldev(mdev);
920 }
921
922 if (fp == FP_STONITH &&
0a492166
PR		 923 (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk > D_OUTDATED) &&
924 !(os.role == R_PRIMARY && os.conn < C_CONNECTED && os.pdsk > D_OUTDATED))
265be2d0
PR		 925 ns.susp = 1; /* Suspend IO while fence-peer handler runs (peer lost) */
926
927 if (mdev->sync_conf.on_no_data == OND_SUSPEND_IO &&
928 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE) &&
929 !(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE))
930 ns.susp = 1; /* Suspend IO while no data available (no accessible data available) */
b411b363
PR		 931
932 if (ns.aftr_isp || ns.peer_isp || ns.user_isp) {
933 if (ns.conn == C_SYNC_SOURCE)
934 ns.conn = C_PAUSED_SYNC_S;
935 if (ns.conn == C_SYNC_TARGET)
936 ns.conn = C_PAUSED_SYNC_T;
937 } else {
938 if (ns.conn == C_PAUSED_SYNC_S)
939 ns.conn = C_SYNC_SOURCE;
940 if (ns.conn == C_PAUSED_SYNC_T)
941 ns.conn = C_SYNC_TARGET;
942 }
943
944 return ns;
945}
946
947/* helper for __drbd_set_state */
948static void set_ov_position(struct drbd_conf *mdev, enum drbd_conns cs)
949{
950 if (cs == C_VERIFY_T) {
951 /* starting online verify from an arbitrary position
952 * does not fit well into the existing protocol.
953 * on C_VERIFY_T, we initialize ov_left and friends
954 * implicitly in receive_DataRequest once the
955 * first P_OV_REQUEST is received */
956 mdev->ov_start_sector = ~(sector_t)0;
957 } else {
958 unsigned long bit = BM_SECT_TO_BIT(mdev->ov_start_sector);
959 if (bit >= mdev->rs_total)
960 mdev->ov_start_sector =
961 BM_BIT_TO_SECT(mdev->rs_total - 1);
962 mdev->ov_position = mdev->ov_start_sector;
963 }
964}
965
966/**
967 * __drbd_set_state() - Set a new DRBD state
968 * @mdev: DRBD device.
969 * @ns: new state.
970 * @flags: Flags
971 * @done: Optional completion, that will get completed after the after_state_ch() finished
972 *
973 * Caller needs to hold req_lock, and global_state_lock. Do not call directly.
974 */
975int __drbd_set_state(struct drbd_conf *mdev,
976 union drbd_state ns, enum chg_state_flags flags,
977 struct completion *done)
978{
979 union drbd_state os;
980 int rv = SS_SUCCESS;
981 int warn_sync_abort = 0;
982 struct after_state_chg_work *ascw;
983
984 os = mdev->state;
985
986 ns = sanitize_state(mdev, os, ns, &warn_sync_abort);
987
988 if (ns.i == os.i)
989 return SS_NOTHING_TO_DO;
990
991 if (!(flags & CS_HARD)) {
992 /* pre-state-change checks ; only look at ns */
993 /* See drbd_state_sw_errors in drbd_strings.c */
994
995 rv = is_valid_state(mdev, ns);
996 if (rv < SS_SUCCESS) {
997 /* If the old state was illegal as well, then let
998 this happen...*/
999
1000 if (is_valid_state(mdev, os) == rv) {
1001 dev_err(DEV, "Considering state change from bad state. "
1002 "Error would be: '%s'\n",
1003 drbd_set_st_err_str(rv));
1004 print_st(mdev, "old", os);
1005 print_st(mdev, "new", ns);
1006 rv = is_valid_state_transition(mdev, ns, os);
1007 }
1008 } else
1009 rv = is_valid_state_transition(mdev, ns, os);
1010 }
1011
1012 if (rv < SS_SUCCESS) {
1013 if (flags & CS_VERBOSE)
1014 print_st_err(mdev, os, ns, rv);
1015 return rv;
1016 }
1017
1018 if (warn_sync_abort)
1019 dev_warn(DEV, "Resync aborted.\n");
1020
1021 {
1022 char *pbp, pb[300];
1023 pbp = pb;
1024 *pbp = 0;
1025 PSC(role);
1026 PSC(peer);
1027 PSC(conn);
1028 PSC(disk);
1029 PSC(pdsk);
1030 PSC(susp);
1031 PSC(aftr_isp);
1032 PSC(peer_isp);
1033 PSC(user_isp);
1034 dev_info(DEV, "%s\n", pb);
1035 }
1036
1037 /* solve the race between becoming unconfigured,
1038 * worker doing the cleanup, and
1039 * admin reconfiguring us:
1040 * on (re)configure, first set CONFIG_PENDING,
1041 * then wait for a potentially exiting worker,
1042 * start the worker, and schedule one no_op.
1043 * then proceed with configuration.
1044 */
1045 if (ns.disk == D_DISKLESS &&
1046 ns.conn == C_STANDALONE &&
1047 ns.role == R_SECONDARY &&
1048 !test_and_set_bit(CONFIG_PENDING, &mdev->flags))
1049 set_bit(DEVICE_DYING, &mdev->flags);
1050
1051 mdev->state.i = ns.i;
1052 wake_up(&mdev->misc_wait);
1053 wake_up(&mdev->state_wait);
1054
1055 /* post-state-change actions */
1056 if (os.conn >= C_SYNC_SOURCE && ns.conn <= C_CONNECTED) {
1057 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1058 mod_timer(&mdev->resync_timer, jiffies);
1059 }
1060
1061 /* aborted verify run. log the last position */
1062 if ((os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) &&
1063 ns.conn < C_CONNECTED) {
1064 mdev->ov_start_sector =
1065 BM_BIT_TO_SECT(mdev->rs_total - mdev->ov_left);
1066 dev_info(DEV, "Online Verify reached sector %llu\n",
1067 (unsigned long long)mdev->ov_start_sector);
1068 }
1069
1070 if ((os.conn == C_PAUSED_SYNC_T || os.conn == C_PAUSED_SYNC_S) &&
1071 (ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE)) {
1072 dev_info(DEV, "Syncer continues.\n");
1073 mdev->rs_paused += (long)jiffies-(long)mdev->rs_mark_time;
1074 if (ns.conn == C_SYNC_TARGET) {
1075 if (!test_and_clear_bit(STOP_SYNC_TIMER, &mdev->flags))
1076 mod_timer(&mdev->resync_timer, jiffies);
1077 /* This if (!test_bit) is only needed for the case
1078 that a device that has ceased to used its timer,
1079 i.e. it is already in drbd_resync_finished() gets
1080 paused and resumed. */
1081 }
1082 }
1083
1084 if ((os.conn == C_SYNC_TARGET || os.conn == C_SYNC_SOURCE) &&
1085 (ns.conn == C_PAUSED_SYNC_T || ns.conn == C_PAUSED_SYNC_S)) {
1086 dev_info(DEV, "Resync suspended\n");
1087 mdev->rs_mark_time = jiffies;
1088 if (ns.conn == C_PAUSED_SYNC_T)
1089 set_bit(STOP_SYNC_TIMER, &mdev->flags);
1090 }
1091
1092 if (os.conn == C_CONNECTED &&
1093 (ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T)) {
1094 mdev->ov_position = 0;
1095 mdev->rs_total =
1096 mdev->rs_mark_left = drbd_bm_bits(mdev);
1097 if (mdev->agreed_pro_version >= 90)
1098 set_ov_position(mdev, ns.conn);
1099 else
1100 mdev->ov_start_sector = 0;
1101 mdev->ov_left = mdev->rs_total
1102 - BM_SECT_TO_BIT(mdev->ov_position);
1103 mdev->rs_start =
1104 mdev->rs_mark_time = jiffies;
1105 mdev->ov_last_oos_size = 0;
1106 mdev->ov_last_oos_start = 0;
1107
1108 if (ns.conn == C_VERIFY_S) {
1109 dev_info(DEV, "Starting Online Verify from sector %llu\n",
1110 (unsigned long long)mdev->ov_position);
1111 mod_timer(&mdev->resync_timer, jiffies);
1112 }
1113 }
1114
1115 if (get_ldev(mdev)) {
1116 u32 mdf = mdev->ldev->md.flags & ~(MDF_CONSISTENT|MDF_PRIMARY_IND|
1117 MDF_CONNECTED_IND|MDF_WAS_UP_TO_DATE|
1118 MDF_PEER_OUT_DATED|MDF_CRASHED_PRIMARY);
1119
1120 if (test_bit(CRASHED_PRIMARY, &mdev->flags))
1121 mdf |= MDF_CRASHED_PRIMARY;
1122 if (mdev->state.role == R_PRIMARY ||
1123 (mdev->state.pdsk < D_INCONSISTENT && mdev->state.peer == R_PRIMARY))
1124 mdf |= MDF_PRIMARY_IND;
1125 if (mdev->state.conn > C_WF_REPORT_PARAMS)
1126 mdf |= MDF_CONNECTED_IND;
1127 if (mdev->state.disk > D_INCONSISTENT)
1128 mdf |= MDF_CONSISTENT;
1129 if (mdev->state.disk > D_OUTDATED)
1130 mdf |= MDF_WAS_UP_TO_DATE;
1131 if (mdev->state.pdsk <= D_OUTDATED && mdev->state.pdsk >= D_INCONSISTENT)
1132 mdf |= MDF_PEER_OUT_DATED;
1133 if (mdf != mdev->ldev->md.flags) {
1134 mdev->ldev->md.flags = mdf;
1135 drbd_md_mark_dirty(mdev);
1136 }
1137 if (os.disk < D_CONSISTENT && ns.disk >= D_CONSISTENT)
1138 drbd_set_ed_uuid(mdev, mdev->ldev->md.uuid[UI_CURRENT]);
1139 put_ldev(mdev);
1140 }
1141
1142 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */
1143 if (os.disk == D_INCONSISTENT && os.pdsk == D_INCONSISTENT &&
1144 os.peer == R_SECONDARY && ns.peer == R_PRIMARY)
1145 set_bit(CONSIDER_RESYNC, &mdev->flags);
1146
1147 /* Receiver should clean up itself */
1148 if (os.conn != C_DISCONNECTING && ns.conn == C_DISCONNECTING)
1149 drbd_thread_stop_nowait(&mdev->receiver);
1150
1151 /* Now the receiver finished cleaning up itself, it should die */
1152 if (os.conn != C_STANDALONE && ns.conn == C_STANDALONE)
1153 drbd_thread_stop_nowait(&mdev->receiver);
1154
1155 /* Upon network failure, we need to restart the receiver. */
1156 if (os.conn > C_TEAR_DOWN &&
1157 ns.conn <= C_TEAR_DOWN && ns.conn >= C_TIMEOUT)
1158 drbd_thread_restart_nowait(&mdev->receiver);
1159
1160 ascw = kmalloc(sizeof(*ascw), GFP_ATOMIC);
1161 if (ascw) {
1162 ascw->os = os;
1163 ascw->ns = ns;
1164 ascw->flags = flags;
1165 ascw->w.cb = w_after_state_ch;
1166 ascw->done = done;
1167 drbd_queue_work(&mdev->data.work, &ascw->w);
1168 } else {
1169 dev_warn(DEV, "Could not kmalloc an ascw\n");
1170 }
1171
1172 return rv;
1173}
1174
1175static int w_after_state_ch(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1176{
1177 struct after_state_chg_work *ascw =
1178 container_of(w, struct after_state_chg_work, w);
1179 after_state_ch(mdev, ascw->os, ascw->ns, ascw->flags);
1180 if (ascw->flags & CS_WAIT_COMPLETE) {
1181 D_ASSERT(ascw->done != NULL);
1182 complete(ascw->done);
1183 }
1184 kfree(ascw);
1185
1186 return 1;
1187}
1188
1189static void abw_start_sync(struct drbd_conf *mdev, int rv)
1190{
1191 if (rv) {
1192 dev_err(DEV, "Writing the bitmap failed not starting resync.\n");
1193 _drbd_request_state(mdev, NS(conn, C_CONNECTED), CS_VERBOSE);
1194 return;
1195 }
1196
1197 switch (mdev->state.conn) {
1198 case C_STARTING_SYNC_T:
1199 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
1200 break;
1201 case C_STARTING_SYNC_S:
1202 drbd_start_resync(mdev, C_SYNC_SOURCE);
1203 break;
1204 }
1205}
1206
1207/**
1208 * after_state_ch() - Perform after state change actions that may sleep
1209 * @mdev: DRBD device.
1210 * @os: old state.
1211 * @ns: new state.
1212 * @flags: Flags
1213 */
1214static void after_state_ch(struct drbd_conf *mdev, union drbd_state os,
1215 union drbd_state ns, enum chg_state_flags flags)
1216{
1217 enum drbd_fencing_p fp;
1218
1219 if (os.conn != C_CONNECTED && ns.conn == C_CONNECTED) {
1220 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1221 if (mdev->p_uuid)
1222 mdev->p_uuid[UI_FLAGS] &= ~((u64)2);
1223 }
1224
1225 fp = FP_DONT_CARE;
1226 if (get_ldev(mdev)) {
1227 fp = mdev->ldev->dc.fencing;
1228 put_ldev(mdev);
1229 }
1230
1231 /* Inform userspace about the change... */
1232 drbd_bcast_state(mdev, ns);
1233
1234 if (!(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE) &&
1235 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE))
1236 drbd_khelper(mdev, "pri-on-incon-degr");
1237
1238 /* Here we have the actions that are performed after a
1239 state change. This function might sleep */
1240
265be2d0
PR		 1241 if (os.susp && ns.susp && mdev->sync_conf.on_no_data == OND_SUSPEND_IO) {
1242 if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED) {
1243 if (ns.conn == C_CONNECTED) {
1244 spin_lock_irq(&mdev->req_lock);
1245 _tl_restart(mdev, resend);
1246 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1247 spin_unlock_irq(&mdev->req_lock);
1248 } else /* ns.conn > C_CONNECTED */
1249 dev_err(DEV, "Unexpected Resynd going on!\n");
1250 }
1251
1252 if (os.disk == D_ATTACHING && ns.disk > D_ATTACHING) {
1253 spin_lock_irq(&mdev->req_lock);
1254 _tl_restart(mdev, restart_frozen_disk_io);
1255 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1256 spin_unlock_irq(&mdev->req_lock);
1257 }
1258 }
1259
b411b363
PR		 1260 if (fp == FP_STONITH && ns.susp) {
1261 /* case1: The outdate peer handler is successful:
1262 * case2: The connection was established again: */
1263 if ((os.pdsk > D_OUTDATED && ns.pdsk <= D_OUTDATED) ||
1264 (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED)) {
1265 tl_clear(mdev);
1266 spin_lock_irq(&mdev->req_lock);
1267 _drbd_set_state(_NS(mdev, susp, 0), CS_VERBOSE, NULL);
1268 spin_unlock_irq(&mdev->req_lock);
1269 }
1270 }
1271 /* Do not change the order of the if above and the two below... */
1272 if (os.pdsk == D_DISKLESS && ns.pdsk > D_DISKLESS) { /* attach on the peer */
1273 drbd_send_uuids(mdev);
1274 drbd_send_state(mdev);
1275 }
1276 if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S)
1277 drbd_queue_bitmap_io(mdev, &drbd_send_bitmap, NULL, "send_bitmap (WFBitMapS)");
1278
1279 /* Lost contact to peer's copy of the data */
1280 if ((os.pdsk >= D_INCONSISTENT &&
1281 os.pdsk != D_UNKNOWN &&
1282 os.pdsk != D_OUTDATED)
1283 && (ns.pdsk < D_INCONSISTENT ||
1284 ns.pdsk == D_UNKNOWN ||
1285 ns.pdsk == D_OUTDATED)) {
b411b363
PR		 1286 if (get_ldev(mdev)) {
1287 if ((ns.role == R_PRIMARY || ns.peer == R_PRIMARY) &&
2c8d1967
PR		 1288 mdev->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) {
1289 drbd_uuid_new_current(mdev);
1290 drbd_send_uuids(mdev);
1291 }
b411b363
PR		 1292 put_ldev(mdev);
1293 }
1294 }
1295
1296 if (ns.pdsk < D_INCONSISTENT && get_ldev(mdev)) {
18a50fa2 1297 if (ns.peer == R_PRIMARY && mdev->ldev->md.uuid[UI_BITMAP] == 0) {
2c8d1967 1298 drbd_uuid_new_current(mdev);
18a50fa2
PR		 1299 drbd_send_uuids(mdev);
1300 }
b411b363
PR		 1301
1302 /* D_DISKLESS Peer becomes secondary */
1303 if (os.peer == R_PRIMARY && ns.peer == R_SECONDARY)
1304 drbd_al_to_on_disk_bm(mdev);
1305 put_ldev(mdev);
1306 }
1307
1308 /* Last part of the attaching process ... */
1309 if (ns.conn >= C_CONNECTED &&
1310 os.disk == D_ATTACHING && ns.disk == D_NEGOTIATING) {
e89b591c 1311 drbd_send_sizes(mdev, 0, 0); /* to start sync... */
b411b363
PR		 1312 drbd_send_uuids(mdev);
1313 drbd_send_state(mdev);
1314 }
1315
1316 /* We want to pause/continue resync, tell peer. */
1317 if (ns.conn >= C_CONNECTED &&
1318 ((os.aftr_isp != ns.aftr_isp) ||
1319 (os.user_isp != ns.user_isp)))
1320 drbd_send_state(mdev);
1321
1322 /* In case one of the isp bits got set, suspend other devices. */
1323 if ((!os.aftr_isp && !os.peer_isp && !os.user_isp) &&
1324 (ns.aftr_isp || ns.peer_isp || ns.user_isp))
1325 suspend_other_sg(mdev);
1326
1327 /* Make sure the peer gets informed about eventual state
1328 changes (ISP bits) while we were in WFReportParams. */
1329 if (os.conn == C_WF_REPORT_PARAMS && ns.conn >= C_CONNECTED)
1330 drbd_send_state(mdev);
1331
1332 /* We are in the progress to start a full sync... */
1333 if ((os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||
1334 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S))
1335 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, &abw_start_sync, "set_n_write from StartingSync");
1336
1337 /* We are invalidating our self... */
1338 if (os.conn < C_CONNECTED && ns.conn < C_CONNECTED &&
1339 os.disk > D_INCONSISTENT && ns.disk == D_INCONSISTENT)
1340 drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL, "set_n_write from invalidate");
1341
1342 if (os.disk > D_FAILED && ns.disk == D_FAILED) {
1343 enum drbd_io_error_p eh;
1344
1345 eh = EP_PASS_ON;
1346 if (get_ldev_if_state(mdev, D_FAILED)) {
1347 eh = mdev->ldev->dc.on_io_error;
1348 put_ldev(mdev);
1349 }
1350
1351 drbd_rs_cancel_all(mdev);
1352 /* since get_ldev() only works as long as disk>=D_INCONSISTENT,
1353 and it is D_DISKLESS here, local_cnt can only go down, it can
1354 not increase... It will reach zero */
1355 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
1356 mdev->rs_total = 0;
1357 mdev->rs_failed = 0;
1358 atomic_set(&mdev->rs_pending_cnt, 0);
1359
1360 spin_lock_irq(&mdev->req_lock);
1361 _drbd_set_state(_NS(mdev, disk, D_DISKLESS), CS_HARD, NULL);
1362 spin_unlock_irq(&mdev->req_lock);
1363
1364 if (eh == EP_CALL_HELPER)
1365 drbd_khelper(mdev, "local-io-error");
1366 }
1367
1368 if (os.disk > D_DISKLESS && ns.disk == D_DISKLESS) {
1369
1370 if (os.disk == D_FAILED) /* && ns.disk == D_DISKLESS*/ {
1371 if (drbd_send_state(mdev))
1372 dev_warn(DEV, "Notified peer that my disk is broken.\n");
1373 else
1374 dev_err(DEV, "Sending state in drbd_io_error() failed\n");
1375 }
1376
0a6dbf2b 1377 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
b411b363
PR		 1378 lc_destroy(mdev->resync);
1379 mdev->resync = NULL;
1380 lc_destroy(mdev->act_log);
1381 mdev->act_log = NULL;
1382 __no_warn(local,
1383 drbd_free_bc(mdev->ldev);
1384 mdev->ldev = NULL;);
1385
1386 if (mdev->md_io_tmpp)
1387 __free_page(mdev->md_io_tmpp);
1388 }
1389
1390 /* Disks got bigger while they were detached */
1391 if (ns.disk > D_NEGOTIATING && ns.pdsk > D_NEGOTIATING &&
1392 test_and_clear_bit(RESYNC_AFTER_NEG, &mdev->flags)) {
1393 if (ns.conn == C_CONNECTED)
1394 resync_after_online_grow(mdev);
1395 }
1396
1397 /* A resync finished or aborted, wake paused devices... */
1398 if ((os.conn > C_CONNECTED && ns.conn <= C_CONNECTED) ||
1399 (os.peer_isp && !ns.peer_isp) ||
1400 (os.user_isp && !ns.user_isp))
1401 resume_next_sg(mdev);
1402
1403 /* Upon network connection, we need to start the receiver */
1404 if (os.conn == C_STANDALONE && ns.conn == C_UNCONNECTED)
1405 drbd_thread_start(&mdev->receiver);
1406
1407 /* Terminate worker thread if we are unconfigured - it will be
1408 restarted as needed... */
1409 if (ns.disk == D_DISKLESS &&
1410 ns.conn == C_STANDALONE &&
1411 ns.role == R_SECONDARY) {
1412 if (os.aftr_isp != ns.aftr_isp)
1413 resume_next_sg(mdev);
1414 /* set in __drbd_set_state, unless CONFIG_PENDING was set */
1415 if (test_bit(DEVICE_DYING, &mdev->flags))
1416 drbd_thread_stop_nowait(&mdev->worker);
1417 }
1418
1419 drbd_md_sync(mdev);
1420}
1421
1422
1423static int drbd_thread_setup(void *arg)
1424{
1425 struct drbd_thread *thi = (struct drbd_thread *) arg;
1426 struct drbd_conf *mdev = thi->mdev;
1427 unsigned long flags;
1428 int retval;
1429
1430restart:
1431 retval = thi->function(thi);
1432
1433 spin_lock_irqsave(&thi->t_lock, flags);
1434
1435 /* if the receiver has been "Exiting", the last thing it did
1436 * was set the conn state to "StandAlone",
1437 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
1438 * and receiver thread will be "started".
1439 * drbd_thread_start needs to set "Restarting" in that case.
1440 * t_state check and assignment needs to be within the same spinlock,
1441 * so either thread_start sees Exiting, and can remap to Restarting,
1442 * or thread_start see None, and can proceed as normal.
1443 */
1444
1445 if (thi->t_state == Restarting) {
1446 dev_info(DEV, "Restarting %s\n", current->comm);
1447 thi->t_state = Running;
1448 spin_unlock_irqrestore(&thi->t_lock, flags);
1449 goto restart;
1450 }
1451
1452 thi->task = NULL;
1453 thi->t_state = None;
1454 smp_mb();
1455 complete(&thi->stop);
1456 spin_unlock_irqrestore(&thi->t_lock, flags);
1457
1458 dev_info(DEV, "Terminating %s\n", current->comm);
1459
1460 /* Release mod reference taken when thread was started */
1461 module_put(THIS_MODULE);
1462 return retval;
1463}
1464
1465static void drbd_thread_init(struct drbd_conf *mdev, struct drbd_thread *thi,
1466 int (*func) (struct drbd_thread *))
1467{
1468 spin_lock_init(&thi->t_lock);
1469 thi->task = NULL;
1470 thi->t_state = None;
1471 thi->function = func;
1472 thi->mdev = mdev;
1473}
1474
1475int drbd_thread_start(struct drbd_thread *thi)
1476{
1477 struct drbd_conf *mdev = thi->mdev;
1478 struct task_struct *nt;
1479 unsigned long flags;
1480
1481 const char *me =
1482 thi == &mdev->receiver ? "receiver" :
1483 thi == &mdev->asender ? "asender" :
1484 thi == &mdev->worker ? "worker" : "NONSENSE";
1485
1486 /* is used from state engine doing drbd_thread_stop_nowait,
1487 * while holding the req lock irqsave */
1488 spin_lock_irqsave(&thi->t_lock, flags);
1489
1490 switch (thi->t_state) {
1491 case None:
1492 dev_info(DEV, "Starting %s thread (from %s [%d])\n",
1493 me, current->comm, current->pid);
1494
1495 /* Get ref on module for thread - this is released when thread exits */
1496 if (!try_module_get(THIS_MODULE)) {
1497 dev_err(DEV, "Failed to get module reference in drbd_thread_start\n");
1498 spin_unlock_irqrestore(&thi->t_lock, flags);
1499 return FALSE;
1500 }
1501
1502 init_completion(&thi->stop);
1503 D_ASSERT(thi->task == NULL);
1504 thi->reset_cpu_mask = 1;
1505 thi->t_state = Running;
1506 spin_unlock_irqrestore(&thi->t_lock, flags);
1507 flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
1508
1509 nt = kthread_create(drbd_thread_setup, (void *) thi,
1510 "drbd%d_%s", mdev_to_minor(mdev), me);
1511
1512 if (IS_ERR(nt)) {
1513 dev_err(DEV, "Couldn't start thread\n");
1514
1515 module_put(THIS_MODULE);
1516 return FALSE;
1517 }
1518 spin_lock_irqsave(&thi->t_lock, flags);
1519 thi->task = nt;
1520 thi->t_state = Running;
1521 spin_unlock_irqrestore(&thi->t_lock, flags);
1522 wake_up_process(nt);
1523 break;
1524 case Exiting:
1525 thi->t_state = Restarting;
1526 dev_info(DEV, "Restarting %s thread (from %s [%d])\n",
1527 me, current->comm, current->pid);
1528 /* fall through */
1529 case Running:
1530 case Restarting:
1531 default:
1532 spin_unlock_irqrestore(&thi->t_lock, flags);
1533 break;
1534 }
1535
1536 return TRUE;
1537}
1538
1539
1540void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
1541{
1542 unsigned long flags;
1543
1544 enum drbd_thread_state ns = restart ? Restarting : Exiting;
1545
1546 /* may be called from state engine, holding the req lock irqsave */
1547 spin_lock_irqsave(&thi->t_lock, flags);
1548
1549 if (thi->t_state == None) {
1550 spin_unlock_irqrestore(&thi->t_lock, flags);
1551 if (restart)
1552 drbd_thread_start(thi);
1553 return;
1554 }
1555
1556 if (thi->t_state != ns) {
1557 if (thi->task == NULL) {
1558 spin_unlock_irqrestore(&thi->t_lock, flags);
1559 return;
1560 }
1561
1562 thi->t_state = ns;
1563 smp_mb();
1564 init_completion(&thi->stop);
1565 if (thi->task != current)
1566 force_sig(DRBD_SIGKILL, thi->task);
1567
1568 }
1569
1570 spin_unlock_irqrestore(&thi->t_lock, flags);
1571
1572 if (wait)
1573 wait_for_completion(&thi->stop);
1574}
1575
1576#ifdef CONFIG_SMP
1577/**
1578 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
1579 * @mdev: DRBD device.
1580 *
1581 * Forces all threads of a device onto the same CPU. This is beneficial for
1582 * DRBD's performance. May be overwritten by user's configuration.
1583 */
1584void drbd_calc_cpu_mask(struct drbd_conf *mdev)
1585{
1586 int ord, cpu;
1587
1588 /* user override. */
1589 if (cpumask_weight(mdev->cpu_mask))
1590 return;
1591
1592 ord = mdev_to_minor(mdev) % cpumask_weight(cpu_online_mask);
1593 for_each_online_cpu(cpu) {
1594 if (ord-- == 0) {
1595 cpumask_set_cpu(cpu, mdev->cpu_mask);
1596 return;
1597 }
1598 }
1599 /* should not be reached */
1600 cpumask_setall(mdev->cpu_mask);
1601}
1602
1603/**
1604 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
1605 * @mdev: DRBD device.
1606 *
1607 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
1608 * prematurely.
1609 */
1610void drbd_thread_current_set_cpu(struct drbd_conf *mdev)
1611{
1612 struct task_struct *p = current;
1613 struct drbd_thread *thi =
1614 p == mdev->asender.task ? &mdev->asender :
1615 p == mdev->receiver.task ? &mdev->receiver :
1616 p == mdev->worker.task ? &mdev->worker :
1617 NULL;
1618 ERR_IF(thi == NULL)
1619 return;
1620 if (!thi->reset_cpu_mask)
1621 return;
1622 thi->reset_cpu_mask = 0;
1623 set_cpus_allowed_ptr(p, mdev->cpu_mask);
1624}
1625#endif
1626
1627/* the appropriate socket mutex must be held already */
1628int _drbd_send_cmd(struct drbd_conf *mdev, struct socket *sock,
1629 enum drbd_packets cmd, struct p_header *h,
1630 size_t size, unsigned msg_flags)
1631{
1632 int sent, ok;
1633
1634 ERR_IF(!h) return FALSE;
1635 ERR_IF(!size) return FALSE;
1636
1637 h->magic = BE_DRBD_MAGIC;
1638 h->command = cpu_to_be16(cmd);
1639 h->length = cpu_to_be16(size-sizeof(struct p_header));
1640
b411b363
PR		 1641 sent = drbd_send(mdev, sock, h, size, msg_flags);
1642
1643 ok = (sent == size);
1644 if (!ok)
1645 dev_err(DEV, "short sent %s size=%d sent=%d\n",
1646 cmdname(cmd), (int)size, sent);
1647 return ok;
1648}
1649
1650/* don't pass the socket. we may only look at it
1651 * when we hold the appropriate socket mutex.
1652 */
1653int drbd_send_cmd(struct drbd_conf *mdev, int use_data_socket,
1654 enum drbd_packets cmd, struct p_header *h, size_t size)
1655{
1656 int ok = 0;
1657 struct socket *sock;
1658
1659 if (use_data_socket) {
1660 mutex_lock(&mdev->data.mutex);
1661 sock = mdev->data.socket;
1662 } else {
1663 mutex_lock(&mdev->meta.mutex);
1664 sock = mdev->meta.socket;
1665 }
1666
1667 /* drbd_disconnect() could have called drbd_free_sock()
1668 * while we were waiting in down()... */
1669 if (likely(sock != NULL))
1670 ok = _drbd_send_cmd(mdev, sock, cmd, h, size, 0);
1671
1672 if (use_data_socket)
1673 mutex_unlock(&mdev->data.mutex);
1674 else
1675 mutex_unlock(&mdev->meta.mutex);
1676 return ok;
1677}
1678
1679int drbd_send_cmd2(struct drbd_conf *mdev, enum drbd_packets cmd, char *data,
1680 size_t size)
1681{
1682 struct p_header h;
1683 int ok;
1684
1685 h.magic = BE_DRBD_MAGIC;
1686 h.command = cpu_to_be16(cmd);
1687 h.length = cpu_to_be16(size);
1688
1689 if (!drbd_get_data_sock(mdev))
1690 return 0;
1691
b411b363
PR		 1692 ok = (sizeof(h) ==
1693 drbd_send(mdev, mdev->data.socket, &h, sizeof(h), 0));
1694 ok = ok && (size ==
1695 drbd_send(mdev, mdev->data.socket, data, size, 0));
1696
1697 drbd_put_data_sock(mdev);
1698
1699 return ok;
1700}
1701
1702int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc)
1703{
1704 struct p_rs_param_89 *p;
1705 struct socket *sock;
1706 int size, rv;
1707 const int apv = mdev->agreed_pro_version;
1708
1709 size = apv <= 87 ? sizeof(struct p_rs_param)
1710 : apv == 88 ? sizeof(struct p_rs_param)
1711 + strlen(mdev->sync_conf.verify_alg) + 1
1712 : /* 89 */ sizeof(struct p_rs_param_89);
1713
1714 /* used from admin command context and receiver/worker context.
1715 * to avoid kmalloc, grab the socket right here,
1716 * then use the pre-allocated sbuf there */
1717 mutex_lock(&mdev->data.mutex);
1718 sock = mdev->data.socket;
1719
1720 if (likely(sock != NULL)) {
1721 enum drbd_packets cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
1722
1723 p = &mdev->data.sbuf.rs_param_89;
1724
1725 /* initialize verify_alg and csums_alg */
1726 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
1727
1728 p->rate = cpu_to_be32(sc->rate);
1729
1730 if (apv >= 88)
1731 strcpy(p->verify_alg, mdev->sync_conf.verify_alg);
1732 if (apv >= 89)
1733 strcpy(p->csums_alg, mdev->sync_conf.csums_alg);
1734
1735 rv = _drbd_send_cmd(mdev, sock, cmd, &p->head, size, 0);
1736 } else
1737 rv = 0; /* not ok */
1738
1739 mutex_unlock(&mdev->data.mutex);
1740
1741 return rv;
1742}
1743
1744int drbd_send_protocol(struct drbd_conf *mdev)
1745{
1746 struct p_protocol *p;
cf14c2e9 1747 int size, cf, rv;
b411b363
PR		 1748
1749 size = sizeof(struct p_protocol);
1750
1751 if (mdev->agreed_pro_version >= 87)
1752 size += strlen(mdev->net_conf->integrity_alg) + 1;
1753
1754 /* we must not recurse into our own queue,
1755 * as that is blocked during handshake */
1756 p = kmalloc(size, GFP_NOIO);
1757 if (p == NULL)
1758 return 0;
1759
1760 p->protocol = cpu_to_be32(mdev->net_conf->wire_protocol);
1761 p->after_sb_0p = cpu_to_be32(mdev->net_conf->after_sb_0p);
1762 p->after_sb_1p = cpu_to_be32(mdev->net_conf->after_sb_1p);
1763 p->after_sb_2p = cpu_to_be32(mdev->net_conf->after_sb_2p);
b411b363
PR		 1764 p->two_primaries = cpu_to_be32(mdev->net_conf->two_primaries);
1765
cf14c2e9
PR		 1766 cf = 0;
1767 if (mdev->net_conf->want_lose)
1768 cf |= CF_WANT_LOSE;
1769 if (mdev->net_conf->dry_run) {
1770 if (mdev->agreed_pro_version >= 92)
1771 cf |= CF_DRY_RUN;
1772 else {
1773 dev_err(DEV, "--dry-run is not supported by peer");
7ac314c8 1774 kfree(p);
cf14c2e9
PR		 1775 return 0;
1776 }
1777 }
1778 p->conn_flags = cpu_to_be32(cf);
1779
b411b363
PR		 1780 if (mdev->agreed_pro_version >= 87)
1781 strcpy(p->integrity_alg, mdev->net_conf->integrity_alg);
1782
1783 rv = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_PROTOCOL,
1784 (struct p_header *)p, size);
1785 kfree(p);
1786 return rv;
1787}
1788
1789int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
1790{
1791 struct p_uuids p;
1792 int i;
1793
1794 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
1795 return 1;
1796
1797 for (i = UI_CURRENT; i < UI_SIZE; i++)
1798 p.uuid[i] = mdev->ldev ? cpu_to_be64(mdev->ldev->md.uuid[i]) : 0;
1799
1800 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
1801 p.uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
1802 uuid_flags |= mdev->net_conf->want_lose ? 1 : 0;
1803 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
1804 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
1805 p.uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
1806
1807 put_ldev(mdev);
1808
1809 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_UUIDS,
1810 (struct p_header *)&p, sizeof(p));
1811}
1812
1813int drbd_send_uuids(struct drbd_conf *mdev)
1814{
1815 return _drbd_send_uuids(mdev, 0);
1816}
1817
1818int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
1819{
1820 return _drbd_send_uuids(mdev, 8);
1821}
1822
1823
1824int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val)
1825{
1826 struct p_rs_uuid p;
1827
1828 p.uuid = cpu_to_be64(val);
1829
1830 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SYNC_UUID,
1831 (struct p_header *)&p, sizeof(p));
1832}
1833
e89b591c 1834int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
b411b363
PR		 1835{
1836 struct p_sizes p;
1837 sector_t d_size, u_size;
1838 int q_order_type;
1839 int ok;
1840
1841 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
1842 D_ASSERT(mdev->ldev->backing_bdev);
1843 d_size = drbd_get_max_capacity(mdev->ldev);
1844 u_size = mdev->ldev->dc.disk_size;
1845 q_order_type = drbd_queue_order_type(mdev);
b411b363
PR		 1846 put_ldev(mdev);
1847 } else {
1848 d_size = 0;
1849 u_size = 0;
1850 q_order_type = QUEUE_ORDERED_NONE;
1851 }
1852
1853 p.d_size = cpu_to_be64(d_size);
1854 p.u_size = cpu_to_be64(u_size);
1855 p.c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
1856 p.max_segment_size = cpu_to_be32(queue_max_segment_size(mdev->rq_queue));
e89b591c
PR		 1857 p.queue_order_type = cpu_to_be16(q_order_type);
1858 p.dds_flags = cpu_to_be16(flags);
b411b363
PR		 1859
1860 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SIZES,
1861 (struct p_header *)&p, sizeof(p));
1862 return ok;
1863}
1864
1865/**
1866 * drbd_send_state() - Sends the drbd state to the peer
1867 * @mdev: DRBD device.
1868 */
1869int drbd_send_state(struct drbd_conf *mdev)
1870{
1871 struct socket *sock;
1872 struct p_state p;
1873 int ok = 0;
1874
1875 /* Grab state lock so we wont send state if we're in the middle
1876 * of a cluster wide state change on another thread */
1877 drbd_state_lock(mdev);
1878
1879 mutex_lock(&mdev->data.mutex);
1880
1881 p.state = cpu_to_be32(mdev->state.i); /* Within the send mutex */
1882 sock = mdev->data.socket;
1883
1884 if (likely(sock != NULL)) {
1885 ok = _drbd_send_cmd(mdev, sock, P_STATE,
1886 (struct p_header *)&p, sizeof(p), 0);
1887 }
1888
1889 mutex_unlock(&mdev->data.mutex);
1890
1891 drbd_state_unlock(mdev);
1892 return ok;
1893}
1894
1895int drbd_send_state_req(struct drbd_conf *mdev,
1896 union drbd_state mask, union drbd_state val)
1897{
1898 struct p_req_state p;
1899
1900 p.mask = cpu_to_be32(mask.i);
1901 p.val = cpu_to_be32(val.i);
1902
1903 return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_STATE_CHG_REQ,
1904 (struct p_header *)&p, sizeof(p));
1905}
1906
1907int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode)
1908{
1909 struct p_req_state_reply p;
1910
1911 p.retcode = cpu_to_be32(retcode);
1912
1913 return drbd_send_cmd(mdev, USE_META_SOCKET, P_STATE_CHG_REPLY,
1914 (struct p_header *)&p, sizeof(p));
1915}
1916
1917int fill_bitmap_rle_bits(struct drbd_conf *mdev,
1918 struct p_compressed_bm *p,
1919 struct bm_xfer_ctx *c)
1920{
1921 struct bitstream bs;
1922 unsigned long plain_bits;
1923 unsigned long tmp;
1924 unsigned long rl;
1925 unsigned len;
1926 unsigned toggle;
1927 int bits;
1928
1929 /* may we use this feature? */
1930 if ((mdev->sync_conf.use_rle == 0) ||
1931 (mdev->agreed_pro_version < 90))
1932 return 0;
1933
1934 if (c->bit_offset >= c->bm_bits)
1935 return 0; /* nothing to do. */
1936
1937 /* use at most thus many bytes */
1938 bitstream_init(&bs, p->code, BM_PACKET_VLI_BYTES_MAX, 0);
1939 memset(p->code, 0, BM_PACKET_VLI_BYTES_MAX);
1940 /* plain bits covered in this code string */
1941 plain_bits = 0;
1942
1943 /* p->encoding & 0x80 stores whether the first run length is set.
1944 * bit offset is implicit.
1945 * start with toggle == 2 to be able to tell the first iteration */
1946 toggle = 2;
1947
1948 /* see how much plain bits we can stuff into one packet
1949 * using RLE and VLI. */
1950 do {
1951 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1952 : _drbd_bm_find_next(mdev, c->bit_offset);
1953 if (tmp == -1UL)
1954 tmp = c->bm_bits;
1955 rl = tmp - c->bit_offset;
1956
1957 if (toggle == 2) { /* first iteration */
1958 if (rl == 0) {
1959 /* the first checked bit was set,
1960 * store start value, */
1961 DCBP_set_start(p, 1);
1962 /* but skip encoding of zero run length */
1963 toggle = !toggle;
1964 continue;
1965 }
1966 DCBP_set_start(p, 0);
1967 }
1968
1969 /* paranoia: catch zero runlength.
1970 * can only happen if bitmap is modified while we scan it. */
1971 if (rl == 0) {
1972 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1973 "t:%u bo:%lu\n", toggle, c->bit_offset);
1974 return -1;
1975 }
1976
1977 bits = vli_encode_bits(&bs, rl);
1978 if (bits == -ENOBUFS) /* buffer full */
1979 break;
1980 if (bits <= 0) {
1981 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
1982 return 0;
1983 }
1984
1985 toggle = !toggle;
1986 plain_bits += rl;
1987 c->bit_offset = tmp;
1988 } while (c->bit_offset < c->bm_bits);
1989
1990 len = bs.cur.b - p->code + !!bs.cur.bit;
1991
1992 if (plain_bits < (len << 3)) {
1993 /* incompressible with this method.
1994 * we need to rewind both word and bit position. */
1995 c->bit_offset -= plain_bits;
1996 bm_xfer_ctx_bit_to_word_offset(c);
1997 c->bit_offset = c->word_offset * BITS_PER_LONG;
1998 return 0;
1999 }
2000
2001 /* RLE + VLI was able to compress it just fine.
2002 * update c->word_offset. */
2003 bm_xfer_ctx_bit_to_word_offset(c);
2004
2005 /* store pad_bits */
2006 DCBP_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
2007
2008 return len;
2009}
2010
2011enum { OK, FAILED, DONE }
2012send_bitmap_rle_or_plain(struct drbd_conf *mdev,
2013 struct p_header *h, struct bm_xfer_ctx *c)
2014{
2015 struct p_compressed_bm *p = (void*)h;
2016 unsigned long num_words;
2017 int len;
2018 int ok;
2019
2020 len = fill_bitmap_rle_bits(mdev, p, c);
2021
2022 if (len < 0)
2023 return FAILED;
2024
2025 if (len) {
2026 DCBP_set_code(p, RLE_VLI_Bits);
2027 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_COMPRESSED_BITMAP, h,
2028 sizeof(*p) + len, 0);
2029
2030 c->packets[0]++;
2031 c->bytes[0] += sizeof(*p) + len;
2032
2033 if (c->bit_offset >= c->bm_bits)
2034 len = 0; /* DONE */
2035 } else {
2036 /* was not compressible.
2037 * send a buffer full of plain text bits instead. */
2038 num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
2039 len = num_words * sizeof(long);
2040 if (len)
2041 drbd_bm_get_lel(mdev, c->word_offset, num_words, (unsigned long*)h->payload);
2042 ok = _drbd_send_cmd(mdev, mdev->data.socket, P_BITMAP,
2043 h, sizeof(struct p_header) + len, 0);
2044 c->word_offset += num_words;
2045 c->bit_offset = c->word_offset * BITS_PER_LONG;
2046
2047 c->packets[1]++;
2048 c->bytes[1] += sizeof(struct p_header) + len;
2049
2050 if (c->bit_offset > c->bm_bits)
2051 c->bit_offset = c->bm_bits;
2052 }
2053 ok = ok ? ((len == 0) ? DONE : OK) : FAILED;
2054
2055 if (ok == DONE)
2056 INFO_bm_xfer_stats(mdev, "send", c);
2057 return ok;
2058}
2059
2060/* See the comment at receive_bitmap() */
2061int _drbd_send_bitmap(struct drbd_conf *mdev)
2062{
2063 struct bm_xfer_ctx c;
2064 struct p_header *p;
2065 int ret;
2066
2067 ERR_IF(!mdev->bitmap) return FALSE;
2068
2069 /* maybe we should use some per thread scratch page,
2070 * and allocate that during initial device creation? */
2071 p = (struct p_header *) __get_free_page(GFP_NOIO);
2072 if (!p) {
2073 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
2074 return FALSE;
2075 }
2076
2077 if (get_ldev(mdev)) {
2078 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
2079 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
2080 drbd_bm_set_all(mdev);
2081 if (drbd_bm_write(mdev)) {
2082 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
2083 * but otherwise process as per normal - need to tell other
2084 * side that a full resync is required! */
2085 dev_err(DEV, "Failed to write bitmap to disk!\n");
2086 } else {
2087 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
2088 drbd_md_sync(mdev);
2089 }
2090 }
2091 put_ldev(mdev);
2092 }
2093
2094 c = (struct bm_xfer_ctx) {
2095 .bm_bits = drbd_bm_bits(mdev),
2096 .bm_words = drbd_bm_words(mdev),
2097 };
2098
2099 do {
2100 ret = send_bitmap_rle_or_plain(mdev, p, &c);
2101 } while (ret == OK);
2102
2103 free_page((unsigned long) p);
2104 return (ret == DONE);
2105}
2106
2107int drbd_send_bitmap(struct drbd_conf *mdev)
2108{
2109 int err;
2110
2111 if (!drbd_get_data_sock(mdev))
2112 return -1;
2113 err = !_drbd_send_bitmap(mdev);
2114 drbd_put_data_sock(mdev);
2115 return err;
2116}
2117
2118int drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, u32 set_size)
2119{
2120 int ok;
2121 struct p_barrier_ack p;
2122
2123 p.barrier = barrier_nr;
2124 p.set_size = cpu_to_be32(set_size);
2125
2126 if (mdev->state.conn < C_CONNECTED)
2127 return FALSE;
2128 ok = drbd_send_cmd(mdev, USE_META_SOCKET, P_BARRIER_ACK,
2129 (struct p_header *)&p, sizeof(p));
2130 return ok;
2131}
2132
2133/**
2134 * _drbd_send_ack() - Sends an ack packet
2135 * @mdev: DRBD device.
2136 * @cmd: Packet command code.
2137 * @sector: sector, needs to be in big endian byte order
2138 * @blksize: size in byte, needs to be in big endian byte order
2139 * @block_id: Id, big endian byte order
2140 */
2141static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packets cmd,
2142 u64 sector,
2143 u32 blksize,
2144 u64 block_id)
2145{
2146 int ok;
2147 struct p_block_ack p;
2148
2149 p.sector = sector;
2150 p.block_id = block_id;
2151 p.blksize = blksize;
2152 p.seq_num = cpu_to_be32(atomic_add_return(1, &mdev->packet_seq));
2153
2154 if (!mdev->meta.socket || mdev->state.conn < C_CONNECTED)
2155 return FALSE;
2156 ok = drbd_send_cmd(mdev, USE_META_SOCKET, cmd,
2157 (struct p_header *)&p, sizeof(p));
2158 return ok;
2159}
2160
2161int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packets cmd,
2162 struct p_data *dp)
2163{
2164 const int header_size = sizeof(struct p_data)
2165 - sizeof(struct p_header);
2166 int data_size = ((struct p_header *)dp)->length - header_size;
2167
2168 return _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
2169 dp->block_id);
2170}
2171
2172int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packets cmd,
2173 struct p_block_req *rp)
2174{
2175 return _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
2176}
2177
2178/**
2179 * drbd_send_ack() - Sends an ack packet
2180 * @mdev: DRBD device.
2181 * @cmd: Packet command code.
2182 * @e: Epoch entry.
2183 */
2184int drbd_send_ack(struct drbd_conf *mdev,
2185 enum drbd_packets cmd, struct drbd_epoch_entry *e)
2186{
2187 return _drbd_send_ack(mdev, cmd,
2188 cpu_to_be64(e->sector),
2189 cpu_to_be32(e->size),
2190 e->block_id);
2191}
2192
2193/* This function misuses the block_id field to signal if the blocks
2194 * are is sync or not. */
2195int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packets cmd,
2196 sector_t sector, int blksize, u64 block_id)
2197{
2198 return _drbd_send_ack(mdev, cmd,
2199 cpu_to_be64(sector),
2200 cpu_to_be32(blksize),
2201 cpu_to_be64(block_id));
2202}
2203
2204int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
2205 sector_t sector, int size, u64 block_id)
2206{
2207 int ok;
2208 struct p_block_req p;
2209
2210 p.sector = cpu_to_be64(sector);
2211 p.block_id = block_id;
2212 p.blksize = cpu_to_be32(size);
2213
2214 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, cmd,
2215 (struct p_header *)&p, sizeof(p));
2216 return ok;
2217}
2218
2219int drbd_send_drequest_csum(struct drbd_conf *mdev,
2220 sector_t sector, int size,
2221 void *digest, int digest_size,
2222 enum drbd_packets cmd)
2223{
2224 int ok;
2225 struct p_block_req p;
2226
2227 p.sector = cpu_to_be64(sector);
2228 p.block_id = BE_DRBD_MAGIC + 0xbeef;
2229 p.blksize = cpu_to_be32(size);
2230
2231 p.head.magic = BE_DRBD_MAGIC;
2232 p.head.command = cpu_to_be16(cmd);
2233 p.head.length = cpu_to_be16(sizeof(p) - sizeof(struct p_header) + digest_size);
2234
2235 mutex_lock(&mdev->data.mutex);
2236
2237 ok = (sizeof(p) == drbd_send(mdev, mdev->data.socket, &p, sizeof(p), 0));
2238 ok = ok && (digest_size == drbd_send(mdev, mdev->data.socket, digest, digest_size, 0));
2239
2240 mutex_unlock(&mdev->data.mutex);
2241
2242 return ok;
2243}
2244
2245int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
2246{
2247 int ok;
2248 struct p_block_req p;
2249
2250 p.sector = cpu_to_be64(sector);
2251 p.block_id = BE_DRBD_MAGIC + 0xbabe;
2252 p.blksize = cpu_to_be32(size);
2253
2254 ok = drbd_send_cmd(mdev, USE_DATA_SOCKET, P_OV_REQUEST,
2255 (struct p_header *)&p, sizeof(p));
2256 return ok;
2257}
2258
2259/* called on sndtimeo
2260 * returns FALSE if we should retry,
2261 * TRUE if we think connection is dead
2262 */
2263static int we_should_drop_the_connection(struct drbd_conf *mdev, struct socket *sock)
2264{
2265 int drop_it;
2266 /* long elapsed = (long)(jiffies - mdev->last_received); */
2267
2268 drop_it = mdev->meta.socket == sock
2269 || !mdev->asender.task
2270 || get_t_state(&mdev->asender) != Running
2271 || mdev->state.conn < C_CONNECTED;
2272
2273 if (drop_it)
2274 return TRUE;
2275
2276 drop_it = !--mdev->ko_count;
2277 if (!drop_it) {
2278 dev_err(DEV, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
2279 current->comm, current->pid, mdev->ko_count);
2280 request_ping(mdev);
2281 }
2282
2283 return drop_it; /* && (mdev->state == R_PRIMARY) */;
2284}
2285
2286/* The idea of sendpage seems to be to put some kind of reference
2287 * to the page into the skb, and to hand it over to the NIC. In
2288 * this process get_page() gets called.
2289 *
2290 * As soon as the page was really sent over the network put_page()
2291 * gets called by some part of the network layer. [ NIC driver? ]
2292 *
2293 * [ get_page() / put_page() increment/decrement the count. If count
2294 * reaches 0 the page will be freed. ]
2295 *
2296 * This works nicely with pages from FSs.
2297 * But this means that in protocol A we might signal IO completion too early!
2298 *
2299 * In order not to corrupt data during a resync we must make sure
2300 * that we do not reuse our own buffer pages (EEs) to early, therefore
2301 * we have the net_ee list.
2302 *
2303 * XFS seems to have problems, still, it submits pages with page_count == 0!
2304 * As a workaround, we disable sendpage on pages
2305 * with page_count == 0 or PageSlab.
2306 */
2307static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 2308 int offset, size_t size, unsigned msg_flags)
b411b363 2309{
ba11ad9a 2310 int sent = drbd_send(mdev, mdev->data.socket, kmap(page) + offset, size, msg_flags);
b411b363
PR		 2311 kunmap(page);
2312 if (sent == size)
2313 mdev->send_cnt += size>>9;
2314 return sent == size;
2315}
2316
2317static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
ba11ad9a 2318 int offset, size_t size, unsigned msg_flags)
b411b363
PR		 2319{
2320 mm_segment_t oldfs = get_fs();
2321 int sent, ok;
2322 int len = size;
2323
2324 /* e.g. XFS meta- & log-data is in slab pages, which have a
2325 * page_count of 0 and/or have PageSlab() set.
2326 * we cannot use send_page for those, as that does get_page();
2327 * put_page(); and would cause either a VM_BUG directly, or
2328 * __page_cache_release a page that would actually still be referenced
2329 * by someone, leading to some obscure delayed Oops somewhere else. */
2330 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
ba11ad9a 2331 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
b411b363 2332
ba11ad9a 2333 msg_flags |= MSG_NOSIGNAL;
b411b363
PR		 2334 drbd_update_congested(mdev);
2335 set_fs(KERNEL_DS);
2336 do {
2337 sent = mdev->data.socket->ops->sendpage(mdev->data.socket, page,
2338 offset, len,
ba11ad9a 2339 msg_flags);
b411b363
PR		 2340 if (sent == -EAGAIN) {
2341 if (we_should_drop_the_connection(mdev,
2342 mdev->data.socket))
2343 break;
2344 else
2345 continue;
2346 }
2347 if (sent <= 0) {
2348 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
2349 __func__, (int)size, len, sent);
2350 break;
2351 }
2352 len -= sent;
2353 offset += sent;
2354 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
2355 set_fs(oldfs);
2356 clear_bit(NET_CONGESTED, &mdev->flags);
2357
2358 ok = (len == 0);
2359 if (likely(ok))
2360 mdev->send_cnt += size>>9;
2361 return ok;
2362}
2363
2364static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
2365{
2366 struct bio_vec *bvec;
2367 int i;
ba11ad9a 2368 /* hint all but last page with MSG_MORE */
b411b363
PR		 2369 __bio_for_each_segment(bvec, bio, i, 0) {
2370 if (!_drbd_no_send_page(mdev, bvec->bv_page,
ba11ad9a
LE		 2371 bvec->bv_offset, bvec->bv_len,
2372 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR		 2373 return 0;
2374 }
2375 return 1;
2376}
2377
2378static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
2379{
2380 struct bio_vec *bvec;
2381 int i;
ba11ad9a 2382 /* hint all but last page with MSG_MORE */
b411b363
PR		 2383 __bio_for_each_segment(bvec, bio, i, 0) {
2384 if (!_drbd_send_page(mdev, bvec->bv_page,
ba11ad9a
LE		 2385 bvec->bv_offset, bvec->bv_len,
2386 i == bio->bi_vcnt -1 ? 0 : MSG_MORE))
b411b363
PR		 2387 return 0;
2388 }
b411b363
PR		 2389 return 1;
2390}
2391
45bb912b
LE		 2392static int _drbd_send_zc_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e)
2393{
2394 struct page *page = e->pages;
2395 unsigned len = e->size;
ba11ad9a 2396 /* hint all but last page with MSG_MORE */
45bb912b
LE		 2397 page_chain_for_each(page) {
2398 unsigned l = min_t(unsigned, len, PAGE_SIZE);
ba11ad9a
LE		 2399 if (!_drbd_send_page(mdev, page, 0, l,
2400 page_chain_next(page) ? MSG_MORE : 0))
45bb912b
LE		 2401 return 0;
2402 len -= l;
2403 }
2404 return 1;
2405}
2406
b411b363
PR		 2407/* Used to send write requests
2408 * R_PRIMARY -> Peer (P_DATA)
2409 */
2410int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
2411{
2412 int ok = 1;
2413 struct p_data p;
2414 unsigned int dp_flags = 0;
2415 void *dgb;
2416 int dgs;
2417
2418 if (!drbd_get_data_sock(mdev))
2419 return 0;
2420
2421 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2422 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2423
2424 p.head.magic = BE_DRBD_MAGIC;
2425 p.head.command = cpu_to_be16(P_DATA);
2426 p.head.length =
2427 cpu_to_be16(sizeof(p) - sizeof(struct p_header) + dgs + req->size);
2428
2429 p.sector = cpu_to_be64(req->sector);
2430 p.block_id = (unsigned long)req;
2431 p.seq_num = cpu_to_be32(req->seq_num =
2432 atomic_add_return(1, &mdev->packet_seq));
2433 dp_flags = 0;
2434
2435 /* NOTE: no need to check if barriers supported here as we would
2436 * not pass the test in make_request_common in that case
2437 */
7b6d91da 2438 if (req->master_bio->bi_rw & REQ_HARDBARRIER) {
b411b363
PR		 2439 dev_err(DEV, "ASSERT FAILED would have set DP_HARDBARRIER\n");
2440 /* dp_flags |= DP_HARDBARRIER; */
2441 }
7b6d91da 2442 if (req->master_bio->bi_rw & REQ_SYNC)
b411b363
PR		 2443 dp_flags |= DP_RW_SYNC;
2444 /* for now handle SYNCIO and UNPLUG
2445 * as if they still were one and the same flag */
7b6d91da 2446 if (req->master_bio->bi_rw & REQ_UNPLUG)
b411b363
PR		 2447 dp_flags |= DP_RW_SYNC;
2448 if (mdev->state.conn >= C_SYNC_SOURCE &&
2449 mdev->state.conn <= C_PAUSED_SYNC_T)
2450 dp_flags |= DP_MAY_SET_IN_SYNC;
2451
2452 p.dp_flags = cpu_to_be32(dp_flags);
b411b363
PR		 2453 set_bit(UNPLUG_REMOTE, &mdev->flags);
2454 ok = (sizeof(p) ==
ba11ad9a 2455 drbd_send(mdev, mdev->data.socket, &p, sizeof(p), dgs ? MSG_MORE : 0));
b411b363
PR		 2456 if (ok && dgs) {
2457 dgb = mdev->int_dig_out;
45bb912b 2458 drbd_csum_bio(mdev, mdev->integrity_w_tfm, req->master_bio, dgb);
ba11ad9a 2459 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
b411b363
PR		 2460 }
2461 if (ok) {
2462 if (mdev->net_conf->wire_protocol == DRBD_PROT_A)
2463 ok = _drbd_send_bio(mdev, req->master_bio);
2464 else
2465 ok = _drbd_send_zc_bio(mdev, req->master_bio);
2466 }
2467
2468 drbd_put_data_sock(mdev);
bd26bfc5 2469
b411b363
PR		 2470 return ok;
2471}
2472
2473/* answer packet, used to send data back for read requests:
2474 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
2475 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
2476 */
2477int drbd_send_block(struct drbd_conf *mdev, enum drbd_packets cmd,
2478 struct drbd_epoch_entry *e)
2479{
2480 int ok;
2481 struct p_data p;
2482 void *dgb;
2483 int dgs;
2484
2485 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_w_tfm) ?
2486 crypto_hash_digestsize(mdev->integrity_w_tfm) : 0;
2487
2488 p.head.magic = BE_DRBD_MAGIC;
2489 p.head.command = cpu_to_be16(cmd);
2490 p.head.length =
2491 cpu_to_be16(sizeof(p) - sizeof(struct p_header) + dgs + e->size);
2492
2493 p.sector = cpu_to_be64(e->sector);
2494 p.block_id = e->block_id;
2495 /* p.seq_num = 0; No sequence numbers here.. */
2496
2497 /* Only called by our kernel thread.
2498 * This one may be interrupted by DRBD_SIG and/or DRBD_SIGKILL
2499 * in response to admin command or module unload.
2500 */
2501 if (!drbd_get_data_sock(mdev))
2502 return 0;
2503
b411b363 2504 ok = sizeof(p) == drbd_send(mdev, mdev->data.socket, &p,
ba11ad9a 2505 sizeof(p), dgs ? MSG_MORE : 0);
b411b363
PR		 2506 if (ok && dgs) {
2507 dgb = mdev->int_dig_out;
45bb912b 2508 drbd_csum_ee(mdev, mdev->integrity_w_tfm, e, dgb);
ba11ad9a 2509 ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);
b411b363
PR		 2510 }
2511 if (ok)
45bb912b 2512 ok = _drbd_send_zc_ee(mdev, e);
b411b363
PR		 2513
2514 drbd_put_data_sock(mdev);
bd26bfc5 2515
b411b363
PR		 2516 return ok;
2517}
2518
2519/*
2520 drbd_send distinguishes two cases:
2521
2522 Packets sent via the data socket "sock"
2523 and packets sent via the meta data socket "msock"
2524
2525 sock msock
2526 -----------------+-------------------------+------------------------------
2527 timeout conf.timeout / 2 conf.timeout / 2
2528 timeout action send a ping via msock Abort communication
2529 and close all sockets
2530*/
2531
2532/*
2533 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
2534 */
2535int drbd_send(struct drbd_conf *mdev, struct socket *sock,
2536 void *buf, size_t size, unsigned msg_flags)
2537{
2538 struct kvec iov;
2539 struct msghdr msg;
2540 int rv, sent = 0;
2541
2542 if (!sock)
2543 return -1000;
2544
2545 /* THINK if (signal_pending) return ... ? */
2546
2547 iov.iov_base = buf;
2548 iov.iov_len = size;
2549
2550 msg.msg_name = NULL;
2551 msg.msg_namelen = 0;
2552 msg.msg_control = NULL;
2553 msg.msg_controllen = 0;
2554 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
2555
2556 if (sock == mdev->data.socket) {
2557 mdev->ko_count = mdev->net_conf->ko_count;
2558 drbd_update_congested(mdev);
2559 }
2560 do {
2561 /* STRANGE
2562 * tcp_sendmsg does _not_ use its size parameter at all ?
2563 *
2564 * -EAGAIN on timeout, -EINTR on signal.
2565 */
2566/* THINK
2567 * do we need to block DRBD_SIG if sock == &meta.socket ??
2568 * otherwise wake_asender() might interrupt some send_*Ack !
2569 */
2570 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
2571 if (rv == -EAGAIN) {
2572 if (we_should_drop_the_connection(mdev, sock))
2573 break;
2574 else
2575 continue;
2576 }
2577 D_ASSERT(rv != 0);
2578 if (rv == -EINTR) {
2579 flush_signals(current);
2580 rv = 0;
2581 }
2582 if (rv < 0)
2583 break;
2584 sent += rv;
2585 iov.iov_base += rv;
2586 iov.iov_len -= rv;
2587 } while (sent < size);
2588
2589 if (sock == mdev->data.socket)
2590 clear_bit(NET_CONGESTED, &mdev->flags);
2591
2592 if (rv <= 0) {
2593 if (rv != -EAGAIN) {
2594 dev_err(DEV, "%s_sendmsg returned %d\n",
2595 sock == mdev->meta.socket ? "msock" : "sock",
2596 rv);
2597 drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE));
2598 } else
2599 drbd_force_state(mdev, NS(conn, C_TIMEOUT));
2600 }
2601
2602 return sent;
2603}
2604
2605static int drbd_open(struct block_device *bdev, fmode_t mode)
2606{
2607 struct drbd_conf *mdev = bdev->bd_disk->private_data;
2608 unsigned long flags;
2609 int rv = 0;
2610
6e9624b8 2611 lock_kernel();
b411b363
PR		 2612 spin_lock_irqsave(&mdev->req_lock, flags);
2613 /* to have a stable mdev->state.role
2614 * and no race with updating open_cnt */
2615
2616 if (mdev->state.role != R_PRIMARY) {
2617 if (mode & FMODE_WRITE)
2618 rv = -EROFS;
2619 else if (!allow_oos)
2620 rv = -EMEDIUMTYPE;
2621 }
2622
2623 if (!rv)
2624 mdev->open_cnt++;
2625 spin_unlock_irqrestore(&mdev->req_lock, flags);
6e9624b8 2626 unlock_kernel();
b411b363
PR		 2627
2628 return rv;
2629}
2630
2631static int drbd_release(struct gendisk *gd, fmode_t mode)
2632{
2633 struct drbd_conf *mdev = gd->private_data;
6e9624b8 2634 lock_kernel();
b411b363 2635 mdev->open_cnt--;
6e9624b8 2636 unlock_kernel();
b411b363
PR		 2637 return 0;
2638}
2639
2640static void drbd_unplug_fn(struct request_queue *q)
2641{
2642 struct drbd_conf *mdev = q->queuedata;
2643
b411b363
PR		 2644 /* unplug FIRST */
2645 spin_lock_irq(q->queue_lock);
2646 blk_remove_plug(q);
2647 spin_unlock_irq(q->queue_lock);
2648
2649 /* only if connected */
2650 spin_lock_irq(&mdev->req_lock);
2651 if (mdev->state.pdsk >= D_INCONSISTENT && mdev->state.conn >= C_CONNECTED) {
2652 D_ASSERT(mdev->state.role == R_PRIMARY);
2653 if (test_and_clear_bit(UNPLUG_REMOTE, &mdev->flags)) {
2654 /* add to the data.work queue,
2655 * unless already queued.
2656 * XXX this might be a good addition to drbd_queue_work
2657 * anyways, to detect "double queuing" ... */
2658 if (list_empty(&mdev->unplug_work.list))
2659 drbd_queue_work(&mdev->data.work,
2660 &mdev->unplug_work);
2661 }
2662 }
2663 spin_unlock_irq(&mdev->req_lock);
2664
2665 if (mdev->state.disk >= D_INCONSISTENT)
2666 drbd_kick_lo(mdev);
2667}
2668
2669static void drbd_set_defaults(struct drbd_conf *mdev)
2670{
85f4cc17
PR		 2671 /* This way we get a compile error when sync_conf grows,
2672 and we forgot to initialize it here */
2673 mdev->sync_conf = (struct syncer_conf) {
2674 /* .rate = */ DRBD_RATE_DEF,
2675 /* .after = */ DRBD_AFTER_DEF,
2676 /* .al_extents = */ DRBD_AL_EXTENTS_DEF,
85f4cc17
PR		 2677 /* .verify_alg = */ {}, 0,
2678 /* .cpu_mask = */ {}, 0,
2679 /* .csums_alg = */ {}, 0,
2680 /* .use_rle = */ 0
2681 };
2682
2683 /* Have to use that way, because the layout differs between
2684 big endian and little endian */
b411b363
PR		 2685 mdev->state = (union drbd_state) {
2686 { .role = R_SECONDARY,
2687 .peer = R_UNKNOWN,
2688 .conn = C_STANDALONE,
2689 .disk = D_DISKLESS,
2690 .pdsk = D_UNKNOWN,
2691 .susp = 0
2692 } };
2693}
2694
2695void drbd_init_set_defaults(struct drbd_conf *mdev)
2696{
2697 /* the memset(,0,) did most of this.
2698 * note: only assignments, no allocation in here */
2699
2700 drbd_set_defaults(mdev);
2701
2702 /* for now, we do NOT yet support it,
2703 * even though we start some framework
2704 * to eventually support barriers */
2705 set_bit(NO_BARRIER_SUPP, &mdev->flags);
2706
2707 atomic_set(&mdev->ap_bio_cnt, 0);
2708 atomic_set(&mdev->ap_pending_cnt, 0);
2709 atomic_set(&mdev->rs_pending_cnt, 0);
2710 atomic_set(&mdev->unacked_cnt, 0);
2711 atomic_set(&mdev->local_cnt, 0);
2712 atomic_set(&mdev->net_cnt, 0);
2713 atomic_set(&mdev->packet_seq, 0);
2714 atomic_set(&mdev->pp_in_use, 0);
2715
2716 mutex_init(&mdev->md_io_mutex);
2717 mutex_init(&mdev->data.mutex);
2718 mutex_init(&mdev->meta.mutex);
2719 sema_init(&mdev->data.work.s, 0);
2720 sema_init(&mdev->meta.work.s, 0);
2721 mutex_init(&mdev->state_mutex);
2722
2723 spin_lock_init(&mdev->data.work.q_lock);
2724 spin_lock_init(&mdev->meta.work.q_lock);
2725
2726 spin_lock_init(&mdev->al_lock);
2727 spin_lock_init(&mdev->req_lock);
2728 spin_lock_init(&mdev->peer_seq_lock);
2729 spin_lock_init(&mdev->epoch_lock);
2730
2731 INIT_LIST_HEAD(&mdev->active_ee);
2732 INIT_LIST_HEAD(&mdev->sync_ee);
2733 INIT_LIST_HEAD(&mdev->done_ee);
2734 INIT_LIST_HEAD(&mdev->read_ee);
2735 INIT_LIST_HEAD(&mdev->net_ee);
2736 INIT_LIST_HEAD(&mdev->resync_reads);
2737 INIT_LIST_HEAD(&mdev->data.work.q);
2738 INIT_LIST_HEAD(&mdev->meta.work.q);
2739 INIT_LIST_HEAD(&mdev->resync_work.list);
2740 INIT_LIST_HEAD(&mdev->unplug_work.list);
2741 INIT_LIST_HEAD(&mdev->md_sync_work.list);
2742 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
0ced55a3 2743
b411b363
PR		 2744 mdev->resync_work.cb = w_resync_inactive;
2745 mdev->unplug_work.cb = w_send_write_hint;
2746 mdev->md_sync_work.cb = w_md_sync;
2747 mdev->bm_io_work.w.cb = w_bitmap_io;
2748 init_timer(&mdev->resync_timer);
2749 init_timer(&mdev->md_sync_timer);
2750 mdev->resync_timer.function = resync_timer_fn;
2751 mdev->resync_timer.data = (unsigned long) mdev;
2752 mdev->md_sync_timer.function = md_sync_timer_fn;
2753 mdev->md_sync_timer.data = (unsigned long) mdev;
2754
2755 init_waitqueue_head(&mdev->misc_wait);
2756 init_waitqueue_head(&mdev->state_wait);
2757 init_waitqueue_head(&mdev->ee_wait);
2758 init_waitqueue_head(&mdev->al_wait);
2759 init_waitqueue_head(&mdev->seq_wait);
2760
2761 drbd_thread_init(mdev, &mdev->receiver, drbdd_init);
2762 drbd_thread_init(mdev, &mdev->worker, drbd_worker);
2763 drbd_thread_init(mdev, &mdev->asender, drbd_asender);
2764
2765 mdev->agreed_pro_version = PRO_VERSION_MAX;
2766 mdev->write_ordering = WO_bio_barrier;
2767 mdev->resync_wenr = LC_FREE;
2768}
2769
2770void drbd_mdev_cleanup(struct drbd_conf *mdev)
2771{
2772 if (mdev->receiver.t_state != None)
2773 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
2774 mdev->receiver.t_state);
2775
2776 /* no need to lock it, I'm the only thread alive */
2777 if (atomic_read(&mdev->current_epoch->epoch_size) != 0)
2778 dev_err(DEV, "epoch_size:%d\n", atomic_read(&mdev->current_epoch->epoch_size));
2779 mdev->al_writ_cnt =
2780 mdev->bm_writ_cnt =
2781 mdev->read_cnt =
2782 mdev->recv_cnt =
2783 mdev->send_cnt =
2784 mdev->writ_cnt =
2785 mdev->p_size =
2786 mdev->rs_start =
2787 mdev->rs_total =
2788 mdev->rs_failed =
2789 mdev->rs_mark_left =
2790 mdev->rs_mark_time = 0;
2791 D_ASSERT(mdev->net_conf == NULL);
2792
2793 drbd_set_my_capacity(mdev, 0);
2794 if (mdev->bitmap) {
2795 /* maybe never allocated. */
02d9a94b 2796 drbd_bm_resize(mdev, 0, 1);
b411b363
PR		 2797 drbd_bm_cleanup(mdev);
2798 }
2799
2800 drbd_free_resources(mdev);
2801
2802 /*
2803 * currently we drbd_init_ee only on module load, so
2804 * we may do drbd_release_ee only on module unload!
2805 */
2806 D_ASSERT(list_empty(&mdev->active_ee));
2807 D_ASSERT(list_empty(&mdev->sync_ee));
2808 D_ASSERT(list_empty(&mdev->done_ee));
2809 D_ASSERT(list_empty(&mdev->read_ee));
2810 D_ASSERT(list_empty(&mdev->net_ee));
2811 D_ASSERT(list_empty(&mdev->resync_reads));
2812 D_ASSERT(list_empty(&mdev->data.work.q));
2813 D_ASSERT(list_empty(&mdev->meta.work.q));
2814 D_ASSERT(list_empty(&mdev->resync_work.list));
2815 D_ASSERT(list_empty(&mdev->unplug_work.list));
2816
2817}
2818
2819
2820static void drbd_destroy_mempools(void)
2821{
2822 struct page *page;
2823
2824 while (drbd_pp_pool) {
2825 page = drbd_pp_pool;
2826 drbd_pp_pool = (struct page *)page_private(page);
2827 __free_page(page);
2828 drbd_pp_vacant--;
2829 }
2830
2831 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
2832
2833 if (drbd_ee_mempool)
2834 mempool_destroy(drbd_ee_mempool);
2835 if (drbd_request_mempool)
2836 mempool_destroy(drbd_request_mempool);
2837 if (drbd_ee_cache)
2838 kmem_cache_destroy(drbd_ee_cache);
2839 if (drbd_request_cache)
2840 kmem_cache_destroy(drbd_request_cache);
2841 if (drbd_bm_ext_cache)
2842 kmem_cache_destroy(drbd_bm_ext_cache);
2843 if (drbd_al_ext_cache)
2844 kmem_cache_destroy(drbd_al_ext_cache);
2845
2846 drbd_ee_mempool = NULL;
2847 drbd_request_mempool = NULL;
2848 drbd_ee_cache = NULL;
2849 drbd_request_cache = NULL;
2850 drbd_bm_ext_cache = NULL;
2851 drbd_al_ext_cache = NULL;
2852
2853 return;
2854}
2855
2856static int drbd_create_mempools(void)
2857{
2858 struct page *page;
2859 const int number = (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE) * minor_count;
2860 int i;
2861
2862 /* prepare our caches and mempools */
2863 drbd_request_mempool = NULL;
2864 drbd_ee_cache = NULL;
2865 drbd_request_cache = NULL;
2866 drbd_bm_ext_cache = NULL;
2867 drbd_al_ext_cache = NULL;
2868 drbd_pp_pool = NULL;
2869
2870 /* caches */
2871 drbd_request_cache = kmem_cache_create(
2872 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2873 if (drbd_request_cache == NULL)
2874 goto Enomem;
2875
2876 drbd_ee_cache = kmem_cache_create(
2877 "drbd_ee", sizeof(struct drbd_epoch_entry), 0, 0, NULL);
2878 if (drbd_ee_cache == NULL)
2879 goto Enomem;
2880
2881 drbd_bm_ext_cache = kmem_cache_create(
2882 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2883 if (drbd_bm_ext_cache == NULL)
2884 goto Enomem;
2885
2886 drbd_al_ext_cache = kmem_cache_create(
2887 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2888 if (drbd_al_ext_cache == NULL)
2889 goto Enomem;
2890
2891 /* mempools */
2892 drbd_request_mempool = mempool_create(number,
2893 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2894 if (drbd_request_mempool == NULL)
2895 goto Enomem;
2896
2897 drbd_ee_mempool = mempool_create(number,
2898 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2899 if (drbd_request_mempool == NULL)
2900 goto Enomem;
2901
2902 /* drbd's page pool */
2903 spin_lock_init(&drbd_pp_lock);
2904
2905 for (i = 0; i < number; i++) {
2906 page = alloc_page(GFP_HIGHUSER);
2907 if (!page)
2908 goto Enomem;
2909 set_page_private(page, (unsigned long)drbd_pp_pool);
2910 drbd_pp_pool = page;
2911 }
2912 drbd_pp_vacant = number;
2913
2914 return 0;
2915
2916Enomem:
2917 drbd_destroy_mempools(); /* in case we allocated some */
2918 return -ENOMEM;
2919}
2920
2921static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2922 void *unused)
2923{
2924 /* just so we have it. you never know what interesting things we
2925 * might want to do here some day...
2926 */
2927
2928 return NOTIFY_DONE;
2929}
2930
2931static struct notifier_block drbd_notifier = {
2932 .notifier_call = drbd_notify_sys,
2933};
2934
2935static void drbd_release_ee_lists(struct drbd_conf *mdev)
2936{
2937 int rr;
2938
2939 rr = drbd_release_ee(mdev, &mdev->active_ee);
2940 if (rr)
2941 dev_err(DEV, "%d EEs in active list found!\n", rr);
2942
2943 rr = drbd_release_ee(mdev, &mdev->sync_ee);
2944 if (rr)
2945 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2946
2947 rr = drbd_release_ee(mdev, &mdev->read_ee);
2948 if (rr)
2949 dev_err(DEV, "%d EEs in read list found!\n", rr);
2950
2951 rr = drbd_release_ee(mdev, &mdev->done_ee);
2952 if (rr)
2953 dev_err(DEV, "%d EEs in done list found!\n", rr);
2954
2955 rr = drbd_release_ee(mdev, &mdev->net_ee);
2956 if (rr)
2957 dev_err(DEV, "%d EEs in net list found!\n", rr);
2958}
2959
2960/* caution. no locking.
2961 * currently only used from module cleanup code. */
2962static void drbd_delete_device(unsigned int minor)
2963{
2964 struct drbd_conf *mdev = minor_to_mdev(minor);
2965
2966 if (!mdev)
2967 return;
2968
2969 /* paranoia asserts */
2970 if (mdev->open_cnt != 0)
2971 dev_err(DEV, "open_cnt = %d in %s:%u", mdev->open_cnt,
2972 __FILE__ , __LINE__);
2973
2974 ERR_IF (!list_empty(&mdev->data.work.q)) {
2975 struct list_head *lp;
2976 list_for_each(lp, &mdev->data.work.q) {
2977 dev_err(DEV, "lp = %p\n", lp);
2978 }
2979 };
2980 /* end paranoia asserts */
2981
2982 del_gendisk(mdev->vdisk);
2983
2984 /* cleanup stuff that may have been allocated during
2985 * device (re-)configuration or state changes */
2986
2987 if (mdev->this_bdev)
2988 bdput(mdev->this_bdev);
2989
2990 drbd_free_resources(mdev);
2991
2992 drbd_release_ee_lists(mdev);
2993
2994 /* should be free'd on disconnect? */
2995 kfree(mdev->ee_hash);
2996 /*
2997 mdev->ee_hash_s = 0;
2998 mdev->ee_hash = NULL;
2999 */
3000
3001 lc_destroy(mdev->act_log);
3002 lc_destroy(mdev->resync);
3003
3004 kfree(mdev->p_uuid);
3005 /* mdev->p_uuid = NULL; */
3006
3007 kfree(mdev->int_dig_out);
3008 kfree(mdev->int_dig_in);
3009 kfree(mdev->int_dig_vv);
3010
3011 /* cleanup the rest that has been
3012 * allocated from drbd_new_device
3013 * and actually free the mdev itself */
3014 drbd_free_mdev(mdev);
3015}
3016
3017static void drbd_cleanup(void)
3018{
3019 unsigned int i;
3020
3021 unregister_reboot_notifier(&drbd_notifier);
3022
3023 drbd_nl_cleanup();
3024
3025 if (minor_table) {
3026 if (drbd_proc)
3027 remove_proc_entry("drbd", NULL);
3028 i = minor_count;
3029 while (i--)
3030 drbd_delete_device(i);
3031 drbd_destroy_mempools();
3032 }
3033
3034 kfree(minor_table);
3035
3036 unregister_blkdev(DRBD_MAJOR, "drbd");
3037
3038 printk(KERN_INFO "drbd: module cleanup done.\n");
3039}
3040
3041/**
3042 * drbd_congested() - Callback for pdflush
3043 * @congested_data: User data
3044 * @bdi_bits: Bits pdflush is currently interested in
3045 *
3046 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
3047 */
3048static int drbd_congested(void *congested_data, int bdi_bits)
3049{
3050 struct drbd_conf *mdev = congested_data;
3051 struct request_queue *q;
3052 char reason = '-';
3053 int r = 0;
3054
3055 if (!__inc_ap_bio_cond(mdev)) {
3056 /* DRBD has frozen IO */
3057 r = bdi_bits;
3058 reason = 'd';
3059 goto out;
3060 }
3061
3062 if (get_ldev(mdev)) {
3063 q = bdev_get_queue(mdev->ldev->backing_bdev);
3064 r = bdi_congested(&q->backing_dev_info, bdi_bits);
3065 put_ldev(mdev);
3066 if (r)
3067 reason = 'b';
3068 }
3069
3070 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->flags)) {
3071 r |= (1 << BDI_async_congested);
3072 reason = reason == 'b' ? 'a' : 'n';
3073 }
3074
3075out:
3076 mdev->congestion_reason = reason;
3077 return r;
3078}
3079
3080struct drbd_conf *drbd_new_device(unsigned int minor)
3081{
3082 struct drbd_conf *mdev;
3083 struct gendisk *disk;
3084 struct request_queue *q;
3085
3086 /* GFP_KERNEL, we are outside of all write-out paths */
3087 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
3088 if (!mdev)
3089 return NULL;
3090 if (!zalloc_cpumask_var(&mdev->cpu_mask, GFP_KERNEL))
3091 goto out_no_cpumask;
3092
3093 mdev->minor = minor;
3094
3095 drbd_init_set_defaults(mdev);
3096
3097 q = blk_alloc_queue(GFP_KERNEL);
3098 if (!q)
3099 goto out_no_q;
3100 mdev->rq_queue = q;
3101 q->queuedata = mdev;
b411b363
PR		 3102
3103 disk = alloc_disk(1);
3104 if (!disk)
3105 goto out_no_disk;
3106 mdev->vdisk = disk;
3107
3108 set_disk_ro(disk, TRUE);
3109
3110 disk->queue = q;
3111 disk->major = DRBD_MAJOR;
3112 disk->first_minor = minor;
3113 disk->fops = &drbd_ops;
3114 sprintf(disk->disk_name, "drbd%d", minor);
3115 disk->private_data = mdev;
3116
3117 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
3118 /* we have no partitions. we contain only ourselves. */
3119 mdev->this_bdev->bd_contains = mdev->this_bdev;
3120
3121 q->backing_dev_info.congested_fn = drbd_congested;
3122 q->backing_dev_info.congested_data = mdev;
3123
3124 blk_queue_make_request(q, drbd_make_request_26);
98ec286e 3125 blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
b411b363
PR		 3126 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
3127 blk_queue_merge_bvec(q, drbd_merge_bvec);
3128 q->queue_lock = &mdev->req_lock; /* needed since we use */
3129 /* plugging on a queue, that actually has no requests! */
3130 q->unplug_fn = drbd_unplug_fn;
3131
3132 mdev->md_io_page = alloc_page(GFP_KERNEL);
3133 if (!mdev->md_io_page)
3134 goto out_no_io_page;
3135
3136 if (drbd_bm_init(mdev))
3137 goto out_no_bitmap;
3138 /* no need to lock access, we are still initializing this minor device. */
3139 if (!tl_init(mdev))
3140 goto out_no_tl;
3141
3142 mdev->app_reads_hash = kzalloc(APP_R_HSIZE*sizeof(void *), GFP_KERNEL);
3143 if (!mdev->app_reads_hash)
3144 goto out_no_app_reads;
3145
3146 mdev->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
3147 if (!mdev->current_epoch)
3148 goto out_no_epoch;
3149
3150 INIT_LIST_HEAD(&mdev->current_epoch->list);
3151 mdev->epochs = 1;
3152
3153 return mdev;
3154
3155/* out_whatever_else:
3156 kfree(mdev->current_epoch); */
3157out_no_epoch:
3158 kfree(mdev->app_reads_hash);
3159out_no_app_reads:
3160 tl_cleanup(mdev);
3161out_no_tl:
3162 drbd_bm_cleanup(mdev);
3163out_no_bitmap:
3164 __free_page(mdev->md_io_page);
3165out_no_io_page:
3166 put_disk(disk);
3167out_no_disk:
3168 blk_cleanup_queue(q);
3169out_no_q:
3170 free_cpumask_var(mdev->cpu_mask);
3171out_no_cpumask:
3172 kfree(mdev);
3173 return NULL;
3174}
3175
3176/* counterpart of drbd_new_device.
3177 * last part of drbd_delete_device. */
3178void drbd_free_mdev(struct drbd_conf *mdev)
3179{
3180 kfree(mdev->current_epoch);
3181 kfree(mdev->app_reads_hash);
3182 tl_cleanup(mdev);
3183 if (mdev->bitmap) /* should no longer be there. */
3184 drbd_bm_cleanup(mdev);
3185 __free_page(mdev->md_io_page);
3186 put_disk(mdev->vdisk);
3187 blk_cleanup_queue(mdev->rq_queue);
3188 free_cpumask_var(mdev->cpu_mask);
3189 kfree(mdev);
3190}
3191
3192
3193int __init drbd_init(void)
3194{
3195 int err;
3196
3197 if (sizeof(struct p_handshake) != 80) {
3198 printk(KERN_ERR
3199 "drbd: never change the size or layout "
3200 "of the HandShake packet.\n");
3201 return -EINVAL;
3202 }
3203
3204 if (1 > minor_count || minor_count > 255) {
3205 printk(KERN_ERR
3206 "drbd: invalid minor_count (%d)\n", minor_count);
3207#ifdef MODULE
3208 return -EINVAL;
3209#else
3210 minor_count = 8;
3211#endif
3212 }
3213
3214 err = drbd_nl_init();
3215 if (err)
3216 return err;
3217
3218 err = register_blkdev(DRBD_MAJOR, "drbd");
3219 if (err) {
3220 printk(KERN_ERR
3221 "drbd: unable to register block device major %d\n",
3222 DRBD_MAJOR);
3223 return err;
3224 }
3225
3226 register_reboot_notifier(&drbd_notifier);
3227
3228 /*
3229 * allocate all necessary structs
3230 */
3231 err = -ENOMEM;
3232
3233 init_waitqueue_head(&drbd_pp_wait);
3234
3235 drbd_proc = NULL; /* play safe for drbd_cleanup */
3236 minor_table = kzalloc(sizeof(struct drbd_conf *)*minor_count,
3237 GFP_KERNEL);
3238 if (!minor_table)
3239 goto Enomem;
3240
3241 err = drbd_create_mempools();
3242 if (err)
3243 goto Enomem;
3244
8c484ee4 3245 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
b411b363
PR		 3246 if (!drbd_proc) {
3247 printk(KERN_ERR "drbd: unable to register proc file\n");
3248 goto Enomem;
3249 }
3250
3251 rwlock_init(&global_state_lock);
3252
3253 printk(KERN_INFO "drbd: initialized. "
3254 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
3255 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
3256 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
3257 printk(KERN_INFO "drbd: registered as block device major %d\n",
3258 DRBD_MAJOR);
3259 printk(KERN_INFO "drbd: minor_table @ 0x%p\n", minor_table);
3260
3261 return 0; /* Success! */
3262
3263Enomem:
3264 drbd_cleanup();
3265 if (err == -ENOMEM)
3266 /* currently always the case */
3267 printk(KERN_ERR "drbd: ran out of memory\n");
3268 else
3269 printk(KERN_ERR "drbd: initialization failure\n");
3270 return err;
3271}
3272
3273void drbd_free_bc(struct drbd_backing_dev *ldev)
3274{
3275 if (ldev == NULL)
3276 return;
3277
3278 bd_release(ldev->backing_bdev);
3279 bd_release(ldev->md_bdev);
3280
3281 fput(ldev->lo_file);
3282 fput(ldev->md_file);
3283
3284 kfree(ldev);
3285}
3286
3287void drbd_free_sock(struct drbd_conf *mdev)
3288{
3289 if (mdev->data.socket) {
4589d7f8 3290 mutex_lock(&mdev->data.mutex);
b411b363
PR		 3291 kernel_sock_shutdown(mdev->data.socket, SHUT_RDWR);
3292 sock_release(mdev->data.socket);
3293 mdev->data.socket = NULL;
4589d7f8 3294 mutex_unlock(&mdev->data.mutex);
b411b363
PR		 3295 }
3296 if (mdev->meta.socket) {
4589d7f8 3297 mutex_lock(&mdev->meta.mutex);
b411b363
PR		 3298 kernel_sock_shutdown(mdev->meta.socket, SHUT_RDWR);
3299 sock_release(mdev->meta.socket);
3300 mdev->meta.socket = NULL;
4589d7f8 3301 mutex_unlock(&mdev->meta.mutex);
b411b363
PR		 3302 }
3303}
3304
3305
3306void drbd_free_resources(struct drbd_conf *mdev)
3307{
3308 crypto_free_hash(mdev->csums_tfm);
3309 mdev->csums_tfm = NULL;
3310 crypto_free_hash(mdev->verify_tfm);
3311 mdev->verify_tfm = NULL;
3312 crypto_free_hash(mdev->cram_hmac_tfm);
3313 mdev->cram_hmac_tfm = NULL;
3314 crypto_free_hash(mdev->integrity_w_tfm);
3315 mdev->integrity_w_tfm = NULL;
3316 crypto_free_hash(mdev->integrity_r_tfm);
3317 mdev->integrity_r_tfm = NULL;
3318
3319 drbd_free_sock(mdev);
3320
3321 __no_warn(local,
3322 drbd_free_bc(mdev->ldev);
3323 mdev->ldev = NULL;);
3324}
3325
3326/* meta data management */
3327
3328struct meta_data_on_disk {
3329 u64 la_size; /* last agreed size. */
3330 u64 uuid[UI_SIZE]; /* UUIDs. */
3331 u64 device_uuid;
3332 u64 reserved_u64_1;
3333 u32 flags; /* MDF */
3334 u32 magic;
3335 u32 md_size_sect;
3336 u32 al_offset; /* offset to this block */
3337 u32 al_nr_extents; /* important for restoring the AL */
3338 /* `-- act_log->nr_elements <-- sync_conf.al_extents */
3339 u32 bm_offset; /* offset to the bitmap, from here */
3340 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
3341 u32 reserved_u32[4];
3342
3343} __packed;
3344
3345/**
3346 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
3347 * @mdev: DRBD device.
3348 */
3349void drbd_md_sync(struct drbd_conf *mdev)
3350{
3351 struct meta_data_on_disk *buffer;
3352 sector_t sector;
3353 int i;
3354
3355 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
3356 return;
3357 del_timer(&mdev->md_sync_timer);
3358
3359 /* We use here D_FAILED and not D_ATTACHING because we try to write
3360 * metadata even if we detach due to a disk failure! */
3361 if (!get_ldev_if_state(mdev, D_FAILED))
3362 return;
3363
b411b363
PR		 3364 mutex_lock(&mdev->md_io_mutex);
3365 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3366 memset(buffer, 0, 512);
3367
3368 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
3369 for (i = UI_CURRENT; i < UI_SIZE; i++)
3370 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
3371 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
3372 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC);
3373
3374 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
3375 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
3376 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
3377 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
3378 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
3379
3380 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
3381
3382 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
3383 sector = mdev->ldev->md.md_offset;
3384
3385 if (drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
3386 clear_bit(MD_DIRTY, &mdev->flags);
3387 } else {
3388 /* this was a try anyways ... */
3389 dev_err(DEV, "meta data update failed!\n");
3390
3391 drbd_chk_io_error(mdev, 1, TRUE);
3392 }
3393
3394 /* Update mdev->ldev->md.la_size_sect,
3395 * since we updated it on metadata. */
3396 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
3397
3398 mutex_unlock(&mdev->md_io_mutex);
3399 put_ldev(mdev);
3400}
3401
3402/**
3403 * drbd_md_read() - Reads in the meta data super block
3404 * @mdev: DRBD device.
3405 * @bdev: Device from which the meta data should be read in.
3406 *
3407 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_codes in case
3408 * something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.
3409 */
3410int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
3411{
3412 struct meta_data_on_disk *buffer;
3413 int i, rv = NO_ERROR;
3414
3415 if (!get_ldev_if_state(mdev, D_ATTACHING))
3416 return ERR_IO_MD_DISK;
3417
b411b363
PR		 3418 mutex_lock(&mdev->md_io_mutex);
3419 buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);
3420
3421 if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
3422 /* NOTE: cant do normal error processing here as this is
3423 called BEFORE disk is attached */
3424 dev_err(DEV, "Error while reading metadata.\n");
3425 rv = ERR_IO_MD_DISK;
3426 goto err;
3427 }
3428
3429 if (be32_to_cpu(buffer->magic) != DRBD_MD_MAGIC) {
3430 dev_err(DEV, "Error while reading metadata, magic not found.\n");
3431 rv = ERR_MD_INVALID;
3432 goto err;
3433 }
3434 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
3435 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
3436 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
3437 rv = ERR_MD_INVALID;
3438 goto err;
3439 }
3440 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
3441 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
3442 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
3443 rv = ERR_MD_INVALID;
3444 goto err;
3445 }
3446 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
3447 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
3448 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
3449 rv = ERR_MD_INVALID;
3450 goto err;
3451 }
3452
3453 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
3454 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3455 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
3456 rv = ERR_MD_INVALID;
3457 goto err;
3458 }
3459
3460 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
3461 for (i = UI_CURRENT; i < UI_SIZE; i++)
3462 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
3463 bdev->md.flags = be32_to_cpu(buffer->flags);
3464 mdev->sync_conf.al_extents = be32_to_cpu(buffer->al_nr_extents);
3465 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
3466
3467 if (mdev->sync_conf.al_extents < 7)
3468 mdev->sync_conf.al_extents = 127;
3469
3470 err:
3471 mutex_unlock(&mdev->md_io_mutex);
3472 put_ldev(mdev);
3473
3474 return rv;
3475}
3476
3477/**
3478 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3479 * @mdev: DRBD device.
3480 *
3481 * Call this function if you change anything that should be written to
3482 * the meta-data super block. This function sets MD_DIRTY, and starts a
3483 * timer that ensures that within five seconds you have to call drbd_md_sync().
3484 */
3485void drbd_md_mark_dirty(struct drbd_conf *mdev)
3486{
3487 set_bit(MD_DIRTY, &mdev->flags);
3488 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
3489}
3490
3491
3492static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
3493{
3494 int i;
3495
6a0afdf5 3496 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
b411b363 3497 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
b411b363
PR		 3498}
3499
3500void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3501{
3502 if (idx == UI_CURRENT) {
3503 if (mdev->state.role == R_PRIMARY)
3504 val |= 1;
3505 else
3506 val &= ~((u64)1);
3507
3508 drbd_set_ed_uuid(mdev, val);
3509 }
3510
3511 mdev->ldev->md.uuid[idx] = val;
b411b363
PR		 3512 drbd_md_mark_dirty(mdev);
3513}
3514
3515
3516void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3517{
3518 if (mdev->ldev->md.uuid[idx]) {
3519 drbd_uuid_move_history(mdev);
3520 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
b411b363
PR		 3521 }
3522 _drbd_uuid_set(mdev, idx, val);
3523}
3524
3525/**
3526 * drbd_uuid_new_current() - Creates a new current UUID
3527 * @mdev: DRBD device.
3528 *
3529 * Creates a new current UUID, and rotates the old current UUID into
3530 * the bitmap slot. Causes an incremental resync upon next connect.
3531 */
3532void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
3533{
3534 u64 val;
3535
3536 dev_info(DEV, "Creating new current UUID\n");
3537 D_ASSERT(mdev->ldev->md.uuid[UI_BITMAP] == 0);
3538 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
b411b363
PR		 3539
3540 get_random_bytes(&val, sizeof(u64));
3541 _drbd_uuid_set(mdev, UI_CURRENT, val);
3542}
3543
3544void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
3545{
3546 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
3547 return;
3548
3549 if (val == 0) {
3550 drbd_uuid_move_history(mdev);
3551 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
3552 mdev->ldev->md.uuid[UI_BITMAP] = 0;
b411b363
PR		 3553 } else {
3554 if (mdev->ldev->md.uuid[UI_BITMAP])
3555 dev_warn(DEV, "bm UUID already set");
3556
3557 mdev->ldev->md.uuid[UI_BITMAP] = val;
3558 mdev->ldev->md.uuid[UI_BITMAP] &= ~((u64)1);
3559
b411b363
PR		 3560 }
3561 drbd_md_mark_dirty(mdev);
3562}
3563
3564/**
3565 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3566 * @mdev: DRBD device.
3567 *
3568 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3569 */
3570int drbd_bmio_set_n_write(struct drbd_conf *mdev)
3571{
3572 int rv = -EIO;
3573
3574 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3575 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3576 drbd_md_sync(mdev);
3577 drbd_bm_set_all(mdev);
3578
3579 rv = drbd_bm_write(mdev);
3580
3581 if (!rv) {
3582 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
3583 drbd_md_sync(mdev);
3584 }
3585
3586 put_ldev(mdev);
3587 }
3588
3589 return rv;
3590}
3591
3592/**
3593 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3594 * @mdev: DRBD device.
3595 *
3596 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3597 */
3598int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
3599{
3600 int rv = -EIO;
3601
3602 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3603 drbd_bm_clear_all(mdev);
3604 rv = drbd_bm_write(mdev);
3605 put_ldev(mdev);
3606 }
3607
3608 return rv;
3609}
3610
3611static int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3612{
3613 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
3614 int rv;
3615
3616 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
3617
3618 drbd_bm_lock(mdev, work->why);
3619 rv = work->io_fn(mdev);
3620 drbd_bm_unlock(mdev);
3621
3622 clear_bit(BITMAP_IO, &mdev->flags);
3623 wake_up(&mdev->misc_wait);
3624
3625 if (work->done)
3626 work->done(mdev, rv);
3627
3628 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
3629 work->why = NULL;
3630
3631 return 1;
3632}
3633
3634/**
3635 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3636 * @mdev: DRBD device.
3637 * @io_fn: IO callback to be called when bitmap IO is possible
3638 * @done: callback to be called after the bitmap IO was performed
3639 * @why: Descriptive text of the reason for doing the IO
3640 *
3641 * While IO on the bitmap happens we freeze application IO thus we ensure
3642 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3643 * called from worker context. It MUST NOT be used while a previous such
3644 * work is still pending!
3645 */
3646void drbd_queue_bitmap_io(struct drbd_conf *mdev,
3647 int (*io_fn)(struct drbd_conf *),
3648 void (*done)(struct drbd_conf *, int),
3649 char *why)
3650{
3651 D_ASSERT(current == mdev->worker.task);
3652
3653 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
3654 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
3655 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
3656 if (mdev->bm_io_work.why)
3657 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
3658 why, mdev->bm_io_work.why);
3659
3660 mdev->bm_io_work.io_fn = io_fn;
3661 mdev->bm_io_work.done = done;
3662 mdev->bm_io_work.why = why;
3663
3664 set_bit(BITMAP_IO, &mdev->flags);
3665 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
3666 if (list_empty(&mdev->bm_io_work.w.list)) {
3667 set_bit(BITMAP_IO_QUEUED, &mdev->flags);
3668 drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);
3669 } else
3670 dev_err(DEV, "FIXME avoided double queuing bm_io_work\n");
3671 }
3672}
3673
3674/**
3675 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3676 * @mdev: DRBD device.
3677 * @io_fn: IO callback to be called when bitmap IO is possible
3678 * @why: Descriptive text of the reason for doing the IO
3679 *
3680 * freezes application IO while that the actual IO operations runs. This
3681 * functions MAY NOT be called from worker context.
3682 */
3683int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *), char *why)
3684{
3685 int rv;
3686
3687 D_ASSERT(current != mdev->worker.task);
3688
3689 drbd_suspend_io(mdev);
3690
3691 drbd_bm_lock(mdev, why);
3692 rv = io_fn(mdev);
3693 drbd_bm_unlock(mdev);
3694
3695 drbd_resume_io(mdev);
3696
3697 return rv;
3698}
3699
3700void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3701{
3702 if ((mdev->ldev->md.flags & flag) != flag) {
3703 drbd_md_mark_dirty(mdev);
3704 mdev->ldev->md.flags |= flag;
3705 }
3706}
3707
3708void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3709{
3710 if ((mdev->ldev->md.flags & flag) != 0) {
3711 drbd_md_mark_dirty(mdev);
3712 mdev->ldev->md.flags &= ~flag;
3713 }
3714}
3715int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3716{
3717 return (bdev->md.flags & flag) != 0;
3718}
3719
3720static void md_sync_timer_fn(unsigned long data)
3721{
3722 struct drbd_conf *mdev = (struct drbd_conf *) data;
3723
3724 drbd_queue_work_front(&mdev->data.work, &mdev->md_sync_work);
3725}
3726
3727static int w_md_sync(struct drbd_conf *mdev, struct drbd_work *w, int unused)
3728{
3729 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
3730 drbd_md_sync(mdev);
3731
3732 return 1;
3733}
3734
3735#ifdef CONFIG_DRBD_FAULT_INJECTION
3736/* Fault insertion support including random number generator shamelessly
3737 * stolen from kernel/rcutorture.c */
3738struct fault_random_state {
3739 unsigned long state;
3740 unsigned long count;
3741};
3742
3743#define FAULT_RANDOM_MULT 39916801 /* prime */
3744#define FAULT_RANDOM_ADD 479001701 /* prime */
3745#define FAULT_RANDOM_REFRESH 10000
3746
3747/*
3748 * Crude but fast random-number generator. Uses a linear congruential
3749 * generator, with occasional help from get_random_bytes().
3750 */
3751static unsigned long
3752_drbd_fault_random(struct fault_random_state *rsp)
3753{
3754 long refresh;
3755
49829ea7 3756 if (!rsp->count--) {
b411b363
PR		 3757 get_random_bytes(&refresh, sizeof(refresh));
3758 rsp->state += refresh;
3759 rsp->count = FAULT_RANDOM_REFRESH;
3760 }
3761 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3762 return swahw32(rsp->state);
3763}
3764
3765static char *
3766_drbd_fault_str(unsigned int type) {
3767 static char *_faults[] = {
3768 [DRBD_FAULT_MD_WR] = "Meta-data write",
3769 [DRBD_FAULT_MD_RD] = "Meta-data read",
3770 [DRBD_FAULT_RS_WR] = "Resync write",
3771 [DRBD_FAULT_RS_RD] = "Resync read",
3772 [DRBD_FAULT_DT_WR] = "Data write",
3773 [DRBD_FAULT_DT_RD] = "Data read",
3774 [DRBD_FAULT_DT_RA] = "Data read ahead",
3775 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
6b4388ac
PR		 3776 [DRBD_FAULT_AL_EE] = "EE allocation",
3777 [DRBD_FAULT_RECEIVE] = "receive data corruption",
b411b363
PR		 3778 };
3779
3780 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3781}
3782
3783unsigned int
3784_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3785{
3786 static struct fault_random_state rrs = {0, 0};
3787
3788 unsigned int ret = (
3789 (fault_devs == 0 ||
3790 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3791 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3792
3793 if (ret) {
3794 fault_count++;
3795
7383506c 3796 if (__ratelimit(&drbd_ratelimit_state))
b411b363
PR		 3797 dev_warn(DEV, "***Simulating %s failure\n",
3798 _drbd_fault_str(type));
3799 }
3800
3801 return ret;
3802}
3803#endif
3804
3805const char *drbd_buildtag(void)
3806{
3807 /* DRBD built from external sources has here a reference to the
3808 git hash of the source code. */
3809
3810 static char buildtag[38] = "\0uilt-in";
3811
3812 if (buildtag[0] == 0) {
3813#ifdef CONFIG_MODULES
3814 if (THIS_MODULE != NULL)
3815 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3816 else
3817#endif
3818 buildtag[0] = 'b';
3819 }
3820
3821 return buildtag;
3822}
3823
3824module_init(drbd_init)
3825module_exit(drbd_cleanup)
3826
b411b363
PR		 3827EXPORT_SYMBOL(drbd_conn_str);
3828EXPORT_SYMBOL(drbd_role_str);
3829EXPORT_SYMBOL(drbd_disk_str);
3830EXPORT_SYMBOL(drbd_set_st_err_str);
Linux 6.x block layer and io_uring tree(s)