1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/module.h>
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/mutex.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#include <linux/workqueue.h>
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"
55#include "drbd_req.h"
56
57#include "drbd_vli.h"
58
59static DEFINE_MUTEX(drbd_main_mutex);
60int drbdd_init(struct drbd_thread *);
61int drbd_worker(struct drbd_thread *);
62int drbd_asender(struct drbd_thread *);
63
64int drbd_init(void);
65static int drbd_open(struct block_device *bdev, fmode_t mode);
66static void drbd_release(struct gendisk *gd, fmode_t mode);
67static int w_md_sync(struct drbd_work *w, int unused);
68static void md_sync_timer_fn(unsigned long data);
69static int w_bitmap_io(struct drbd_work *w, int unused);
70static int w_go_diskless(struct drbd_work *w, int unused);
71
72MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
73 "Lars Ellenberg <lars@linbit.com>");
74MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
75MODULE_VERSION(REL_VERSION);
76MODULE_LICENSE("GPL");
77MODULE_PARM_DESC(minor_count, "Approximate number of drbd devices ("
78 __stringify(DRBD_MINOR_COUNT_MIN) "-" __stringify(DRBD_MINOR_COUNT_MAX) ")");
79MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
80
81#include <linux/moduleparam.h>
82
83MODULE_PARM_DESC(allow_oos, "DONT USE!");
84
85
86module_param(minor_count, uint, 0444);
87module_param(disable_sendpage, bool, 0644);
88module_param(allow_oos, bool, 0);
89module_param(proc_details, int, 0644);
90
91#ifdef CONFIG_DRBD_FAULT_INJECTION
92int enable_faults;
93int fault_rate;
94static int fault_count;
95int fault_devs;
96
97module_param(enable_faults, int, 0664);
98
99module_param(fault_rate, int, 0664);
100
101module_param(fault_count, int, 0664);
102
103module_param(fault_devs, int, 0644);
104#endif
105
106
107unsigned int minor_count = DRBD_MINOR_COUNT_DEF;
108bool disable_sendpage;
109bool allow_oos;
110int proc_details;
111
112
113
114char usermode_helper[80] = "/sbin/drbdadm";
115
116module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
117
118
119
120
121struct idr minors;
122struct list_head drbd_tconns;
123
124struct kmem_cache *drbd_request_cache;
125struct kmem_cache *drbd_ee_cache;
126struct kmem_cache *drbd_bm_ext_cache;
127struct kmem_cache *drbd_al_ext_cache;
128mempool_t *drbd_request_mempool;
129mempool_t *drbd_ee_mempool;
130mempool_t *drbd_md_io_page_pool;
131struct bio_set *drbd_md_io_bio_set;
132
133
134
135
136
137
138
139struct page *drbd_pp_pool;
140spinlock_t drbd_pp_lock;
141int drbd_pp_vacant;
142wait_queue_head_t drbd_pp_wait;
143
144DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
145
146static const struct block_device_operations drbd_ops = {
147 .owner = THIS_MODULE,
148 .open = drbd_open,
149 .release = drbd_release,
150};
151
152struct bio *bio_alloc_drbd(gfp_t gfp_mask)
153{
154 struct bio *bio;
155
156 if (!drbd_md_io_bio_set)
157 return bio_alloc(gfp_mask, 1);
158
159 bio = bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
160 if (!bio)
161 return NULL;
162 return bio;
163}
164
165#ifdef __CHECKER__
166
167
168
169int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
170{
171 int io_allowed;
172
173 atomic_inc(&mdev->local_cnt);
174 io_allowed = (mdev->state.disk >= mins);
175 if (!io_allowed) {
176 if (atomic_dec_and_test(&mdev->local_cnt))
177 wake_up(&mdev->misc_wait);
178 }
179 return io_allowed;
180}
181
182#endif
183
184
185
186
187
188
189
190
191
192
193
194void tl_release(struct drbd_tconn *tconn, unsigned int barrier_nr,
195 unsigned int set_size)
196{
197 struct drbd_request *r;
198 struct drbd_request *req = NULL;
199 int expect_epoch = 0;
200 int expect_size = 0;
201
202 spin_lock_irq(&tconn->req_lock);
203
204
205
206 list_for_each_entry(r, &tconn->transfer_log, tl_requests) {
207 const unsigned s = r->rq_state;
208 if (!req) {
209 if (!(s & RQ_WRITE))
210 continue;
211 if (!(s & RQ_NET_MASK))
212 continue;
213 if (s & RQ_NET_DONE)
214 continue;
215 req = r;
216 expect_epoch = req->epoch;
217 expect_size ++;
218 } else {
219 if (r->epoch != expect_epoch)
220 break;
221 if (!(s & RQ_WRITE))
222 continue;
223
224
225 expect_size++;
226 }
227 }
228
229
230 if (req == NULL) {
231 conn_err(tconn, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
232 barrier_nr);
233 goto bail;
234 }
235 if (expect_epoch != barrier_nr) {
236 conn_err(tconn, "BAD! BarrierAck #%u received, expected #%u!\n",
237 barrier_nr, expect_epoch);
238 goto bail;
239 }
240
241 if (expect_size != set_size) {
242 conn_err(tconn, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
243 barrier_nr, set_size, expect_size);
244 goto bail;
245 }
246
247
248
249
250
251 list_for_each_entry(req, &tconn->transfer_log, tl_requests)
252 if (req->epoch == expect_epoch)
253 break;
254 list_for_each_entry_safe_from(req, r, &tconn->transfer_log, tl_requests) {
255 if (req->epoch != expect_epoch)
256 break;
257 _req_mod(req, BARRIER_ACKED);
258 }
259 spin_unlock_irq(&tconn->req_lock);
260
261 return;
262
263bail:
264 spin_unlock_irq(&tconn->req_lock);
265 conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
266}
267
268
269
270
271
272
273
274
275
276
277
278void _tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
279{
280 struct drbd_request *req, *r;
281
282 list_for_each_entry_safe(req, r, &tconn->transfer_log, tl_requests)
283 _req_mod(req, what);
284}
285
286void tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
287{
288 spin_lock_irq(&tconn->req_lock);
289 _tl_restart(tconn, what);
290 spin_unlock_irq(&tconn->req_lock);
291}
292
293
294
295
296
297
298
299
300
301void tl_clear(struct drbd_tconn *tconn)
302{
303 tl_restart(tconn, CONNECTION_LOST_WHILE_PENDING);
304}
305
306
307
308
309
310void tl_abort_disk_io(struct drbd_conf *mdev)
311{
312 struct drbd_tconn *tconn = mdev->tconn;
313 struct drbd_request *req, *r;
314
315 spin_lock_irq(&tconn->req_lock);
316 list_for_each_entry_safe(req, r, &tconn->transfer_log, tl_requests) {
317 if (!(req->rq_state & RQ_LOCAL_PENDING))
318 continue;
319 if (req->w.mdev != mdev)
320 continue;
321 _req_mod(req, ABORT_DISK_IO);
322 }
323 spin_unlock_irq(&tconn->req_lock);
324}
325
326static int drbd_thread_setup(void *arg)
327{
328 struct drbd_thread *thi = (struct drbd_thread *) arg;
329 struct drbd_tconn *tconn = thi->tconn;
330 unsigned long flags;
331 int retval;
332
333 snprintf(current->comm, sizeof(current->comm), "drbd_%c_%s",
334 thi->name[0], thi->tconn->name);
335
336restart:
337 retval = thi->function(thi);
338
339 spin_lock_irqsave(&thi->t_lock, flags);
340
341
342
343
344
345
346
347
348
349
350
351 if (thi->t_state == RESTARTING) {
352 conn_info(tconn, "Restarting %s thread\n", thi->name);
353 thi->t_state = RUNNING;
354 spin_unlock_irqrestore(&thi->t_lock, flags);
355 goto restart;
356 }
357
358 thi->task = NULL;
359 thi->t_state = NONE;
360 smp_mb();
361 complete_all(&thi->stop);
362 spin_unlock_irqrestore(&thi->t_lock, flags);
363
364 conn_info(tconn, "Terminating %s\n", current->comm);
365
366
367
368 kref_put(&tconn->kref, &conn_destroy);
369 module_put(THIS_MODULE);
370 return retval;
371}
372
373static void drbd_thread_init(struct drbd_tconn *tconn, struct drbd_thread *thi,
374 int (*func) (struct drbd_thread *), char *name)
375{
376 spin_lock_init(&thi->t_lock);
377 thi->task = NULL;
378 thi->t_state = NONE;
379 thi->function = func;
380 thi->tconn = tconn;
381 strncpy(thi->name, name, ARRAY_SIZE(thi->name));
382}
383
384int drbd_thread_start(struct drbd_thread *thi)
385{
386 struct drbd_tconn *tconn = thi->tconn;
387 struct task_struct *nt;
388 unsigned long flags;
389
390
391
392 spin_lock_irqsave(&thi->t_lock, flags);
393
394 switch (thi->t_state) {
395 case NONE:
396 conn_info(tconn, "Starting %s thread (from %s [%d])\n",
397 thi->name, current->comm, current->pid);
398
399
400 if (!try_module_get(THIS_MODULE)) {
401 conn_err(tconn, "Failed to get module reference in drbd_thread_start\n");
402 spin_unlock_irqrestore(&thi->t_lock, flags);
403 return false;
404 }
405
406 kref_get(&thi->tconn->kref);
407
408 init_completion(&thi->stop);
409 thi->reset_cpu_mask = 1;
410 thi->t_state = RUNNING;
411 spin_unlock_irqrestore(&thi->t_lock, flags);
412 flush_signals(current);
413
414 nt = kthread_create(drbd_thread_setup, (void *) thi,
415 "drbd_%c_%s", thi->name[0], thi->tconn->name);
416
417 if (IS_ERR(nt)) {
418 conn_err(tconn, "Couldn't start thread\n");
419
420 kref_put(&tconn->kref, &conn_destroy);
421 module_put(THIS_MODULE);
422 return false;
423 }
424 spin_lock_irqsave(&thi->t_lock, flags);
425 thi->task = nt;
426 thi->t_state = RUNNING;
427 spin_unlock_irqrestore(&thi->t_lock, flags);
428 wake_up_process(nt);
429 break;
430 case EXITING:
431 thi->t_state = RESTARTING;
432 conn_info(tconn, "Restarting %s thread (from %s [%d])\n",
433 thi->name, current->comm, current->pid);
434
435 case RUNNING:
436 case RESTARTING:
437 default:
438 spin_unlock_irqrestore(&thi->t_lock, flags);
439 break;
440 }
441
442 return true;
443}
444
445
446void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
447{
448 unsigned long flags;
449
450 enum drbd_thread_state ns = restart ? RESTARTING : EXITING;
451
452
453 spin_lock_irqsave(&thi->t_lock, flags);
454
455 if (thi->t_state == NONE) {
456 spin_unlock_irqrestore(&thi->t_lock, flags);
457 if (restart)
458 drbd_thread_start(thi);
459 return;
460 }
461
462 if (thi->t_state != ns) {
463 if (thi->task == NULL) {
464 spin_unlock_irqrestore(&thi->t_lock, flags);
465 return;
466 }
467
468 thi->t_state = ns;
469 smp_mb();
470 init_completion(&thi->stop);
471 if (thi->task != current)
472 force_sig(DRBD_SIGKILL, thi->task);
473 }
474
475 spin_unlock_irqrestore(&thi->t_lock, flags);
476
477 if (wait)
478 wait_for_completion(&thi->stop);
479}
480
481static struct drbd_thread *drbd_task_to_thread(struct drbd_tconn *tconn, struct task_struct *task)
482{
483 struct drbd_thread *thi =
484 task == tconn->receiver.task ? &tconn->receiver :
485 task == tconn->asender.task ? &tconn->asender :
486 task == tconn->worker.task ? &tconn->worker : NULL;
487
488 return thi;
489}
490
491char *drbd_task_to_thread_name(struct drbd_tconn *tconn, struct task_struct *task)
492{
493 struct drbd_thread *thi = drbd_task_to_thread(tconn, task);
494 return thi ? thi->name : task->comm;
495}
496
497int conn_lowest_minor(struct drbd_tconn *tconn)
498{
499 struct drbd_conf *mdev;
500 int vnr = 0, m;
501
502 rcu_read_lock();
503 mdev = idr_get_next(&tconn->volumes, &vnr);
504 m = mdev ? mdev_to_minor(mdev) : -1;
505 rcu_read_unlock();
506
507 return m;
508}
509
510#ifdef CONFIG_SMP
511
512
513
514
515
516
517
518void drbd_calc_cpu_mask(struct drbd_tconn *tconn)
519{
520 int ord, cpu;
521
522
523 if (cpumask_weight(tconn->cpu_mask))
524 return;
525
526 ord = conn_lowest_minor(tconn) % cpumask_weight(cpu_online_mask);
527 for_each_online_cpu(cpu) {
528 if (ord-- == 0) {
529 cpumask_set_cpu(cpu, tconn->cpu_mask);
530 return;
531 }
532 }
533
534 cpumask_setall(tconn->cpu_mask);
535}
536
537
538
539
540
541
542
543
544
545void drbd_thread_current_set_cpu(struct drbd_thread *thi)
546{
547 struct task_struct *p = current;
548
549 if (!thi->reset_cpu_mask)
550 return;
551 thi->reset_cpu_mask = 0;
552 set_cpus_allowed_ptr(p, thi->tconn->cpu_mask);
553}
554#endif
555
556
557
558
559
560
561
562
563unsigned int drbd_header_size(struct drbd_tconn *tconn)
564{
565 if (tconn->agreed_pro_version >= 100) {
566 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header100), 8));
567 return sizeof(struct p_header100);
568 } else {
569 BUILD_BUG_ON(sizeof(struct p_header80) !=
570 sizeof(struct p_header95));
571 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header80), 8));
572 return sizeof(struct p_header80);
573 }
574}
575
576static unsigned int prepare_header80(struct p_header80 *h, enum drbd_packet cmd, int size)
577{
578 h->magic = cpu_to_be32(DRBD_MAGIC);
579 h->command = cpu_to_be16(cmd);
580 h->length = cpu_to_be16(size);
581 return sizeof(struct p_header80);
582}
583
584static unsigned int prepare_header95(struct p_header95 *h, enum drbd_packet cmd, int size)
585{
586 h->magic = cpu_to_be16(DRBD_MAGIC_BIG);
587 h->command = cpu_to_be16(cmd);
588 h->length = cpu_to_be32(size);
589 return sizeof(struct p_header95);
590}
591
592static unsigned int prepare_header100(struct p_header100 *h, enum drbd_packet cmd,
593 int size, int vnr)
594{
595 h->magic = cpu_to_be32(DRBD_MAGIC_100);
596 h->volume = cpu_to_be16(vnr);
597 h->command = cpu_to_be16(cmd);
598 h->length = cpu_to_be32(size);
599 h->pad = 0;
600 return sizeof(struct p_header100);
601}
602
603static unsigned int prepare_header(struct drbd_tconn *tconn, int vnr,
604 void *buffer, enum drbd_packet cmd, int size)
605{
606 if (tconn->agreed_pro_version >= 100)
607 return prepare_header100(buffer, cmd, size, vnr);
608 else if (tconn->agreed_pro_version >= 95 &&
609 size > DRBD_MAX_SIZE_H80_PACKET)
610 return prepare_header95(buffer, cmd, size);
611 else
612 return prepare_header80(buffer, cmd, size);
613}
614
615static void *__conn_prepare_command(struct drbd_tconn *tconn,
616 struct drbd_socket *sock)
617{
618 if (!sock->socket)
619 return NULL;
620 return sock->sbuf + drbd_header_size(tconn);
621}
622
623void *conn_prepare_command(struct drbd_tconn *tconn, struct drbd_socket *sock)
624{
625 void *p;
626
627 mutex_lock(&sock->mutex);
628 p = __conn_prepare_command(tconn, sock);
629 if (!p)
630 mutex_unlock(&sock->mutex);
631
632 return p;
633}
634
635void *drbd_prepare_command(struct drbd_conf *mdev, struct drbd_socket *sock)
636{
637 return conn_prepare_command(mdev->tconn, sock);
638}
639
640static int __send_command(struct drbd_tconn *tconn, int vnr,
641 struct drbd_socket *sock, enum drbd_packet cmd,
642 unsigned int header_size, void *data,
643 unsigned int size)
644{
645 int msg_flags;
646 int err;
647
648
649
650
651
652
653
654
655 msg_flags = data ? MSG_MORE : 0;
656
657 header_size += prepare_header(tconn, vnr, sock->sbuf, cmd,
658 header_size + size);
659 err = drbd_send_all(tconn, sock->socket, sock->sbuf, header_size,
660 msg_flags);
661 if (data && !err)
662 err = drbd_send_all(tconn, sock->socket, data, size, 0);
663 return err;
664}
665
666static int __conn_send_command(struct drbd_tconn *tconn, struct drbd_socket *sock,
667 enum drbd_packet cmd, unsigned int header_size,
668 void *data, unsigned int size)
669{
670 return __send_command(tconn, 0, sock, cmd, header_size, data, size);
671}
672
673int conn_send_command(struct drbd_tconn *tconn, struct drbd_socket *sock,
674 enum drbd_packet cmd, unsigned int header_size,
675 void *data, unsigned int size)
676{
677 int err;
678
679 err = __conn_send_command(tconn, sock, cmd, header_size, data, size);
680 mutex_unlock(&sock->mutex);
681 return err;
682}
683
684int drbd_send_command(struct drbd_conf *mdev, struct drbd_socket *sock,
685 enum drbd_packet cmd, unsigned int header_size,
686 void *data, unsigned int size)
687{
688 int err;
689
690 err = __send_command(mdev->tconn, mdev->vnr, sock, cmd, header_size,
691 data, size);
692 mutex_unlock(&sock->mutex);
693 return err;
694}
695
696int drbd_send_ping(struct drbd_tconn *tconn)
697{
698 struct drbd_socket *sock;
699
700 sock = &tconn->meta;
701 if (!conn_prepare_command(tconn, sock))
702 return -EIO;
703 return conn_send_command(tconn, sock, P_PING, 0, NULL, 0);
704}
705
706int drbd_send_ping_ack(struct drbd_tconn *tconn)
707{
708 struct drbd_socket *sock;
709
710 sock = &tconn->meta;
711 if (!conn_prepare_command(tconn, sock))
712 return -EIO;
713 return conn_send_command(tconn, sock, P_PING_ACK, 0, NULL, 0);
714}
715
716int drbd_send_sync_param(struct drbd_conf *mdev)
717{
718 struct drbd_socket *sock;
719 struct p_rs_param_95 *p;
720 int size;
721 const int apv = mdev->tconn->agreed_pro_version;
722 enum drbd_packet cmd;
723 struct net_conf *nc;
724 struct disk_conf *dc;
725
726 sock = &mdev->tconn->data;
727 p = drbd_prepare_command(mdev, sock);
728 if (!p)
729 return -EIO;
730
731 rcu_read_lock();
732 nc = rcu_dereference(mdev->tconn->net_conf);
733
734 size = apv <= 87 ? sizeof(struct p_rs_param)
735 : apv == 88 ? sizeof(struct p_rs_param)
736 + strlen(nc->verify_alg) + 1
737 : apv <= 94 ? sizeof(struct p_rs_param_89)
738 : sizeof(struct p_rs_param_95);
739
740 cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
741
742
743 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
744
745 if (get_ldev(mdev)) {
746 dc = rcu_dereference(mdev->ldev->disk_conf);
747 p->resync_rate = cpu_to_be32(dc->resync_rate);
748 p->c_plan_ahead = cpu_to_be32(dc->c_plan_ahead);
749 p->c_delay_target = cpu_to_be32(dc->c_delay_target);
750 p->c_fill_target = cpu_to_be32(dc->c_fill_target);
751 p->c_max_rate = cpu_to_be32(dc->c_max_rate);
752 put_ldev(mdev);
753 } else {
754 p->resync_rate = cpu_to_be32(DRBD_RESYNC_RATE_DEF);
755 p->c_plan_ahead = cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF);
756 p->c_delay_target = cpu_to_be32(DRBD_C_DELAY_TARGET_DEF);
757 p->c_fill_target = cpu_to_be32(DRBD_C_FILL_TARGET_DEF);
758 p->c_max_rate = cpu_to_be32(DRBD_C_MAX_RATE_DEF);
759 }
760
761 if (apv >= 88)
762 strcpy(p->verify_alg, nc->verify_alg);
763 if (apv >= 89)
764 strcpy(p->csums_alg, nc->csums_alg);
765 rcu_read_unlock();
766
767 return drbd_send_command(mdev, sock, cmd, size, NULL, 0);
768}
769
770int __drbd_send_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd)
771{
772 struct drbd_socket *sock;
773 struct p_protocol *p;
774 struct net_conf *nc;
775 int size, cf;
776
777 sock = &tconn->data;
778 p = __conn_prepare_command(tconn, sock);
779 if (!p)
780 return -EIO;
781
782 rcu_read_lock();
783 nc = rcu_dereference(tconn->net_conf);
784
785 if (nc->tentative && tconn->agreed_pro_version < 92) {
786 rcu_read_unlock();
787 mutex_unlock(&sock->mutex);
788 conn_err(tconn, "--dry-run is not supported by peer");
789 return -EOPNOTSUPP;
790 }
791
792 size = sizeof(*p);
793 if (tconn->agreed_pro_version >= 87)
794 size += strlen(nc->integrity_alg) + 1;
795
796 p->protocol = cpu_to_be32(nc->wire_protocol);
797 p->after_sb_0p = cpu_to_be32(nc->after_sb_0p);
798 p->after_sb_1p = cpu_to_be32(nc->after_sb_1p);
799 p->after_sb_2p = cpu_to_be32(nc->after_sb_2p);
800 p->two_primaries = cpu_to_be32(nc->two_primaries);
801 cf = 0;
802 if (nc->discard_my_data)
803 cf |= CF_DISCARD_MY_DATA;
804 if (nc->tentative)
805 cf |= CF_DRY_RUN;
806 p->conn_flags = cpu_to_be32(cf);
807
808 if (tconn->agreed_pro_version >= 87)
809 strcpy(p->integrity_alg, nc->integrity_alg);
810 rcu_read_unlock();
811
812 return __conn_send_command(tconn, sock, cmd, size, NULL, 0);
813}
814
815int drbd_send_protocol(struct drbd_tconn *tconn)
816{
817 int err;
818
819 mutex_lock(&tconn->data.mutex);
820 err = __drbd_send_protocol(tconn, P_PROTOCOL);
821 mutex_unlock(&tconn->data.mutex);
822
823 return err;
824}
825
826int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
827{
828 struct drbd_socket *sock;
829 struct p_uuids *p;
830 int i;
831
832 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
833 return 0;
834
835 sock = &mdev->tconn->data;
836 p = drbd_prepare_command(mdev, sock);
837 if (!p) {
838 put_ldev(mdev);
839 return -EIO;
840 }
841 spin_lock_irq(&mdev->ldev->md.uuid_lock);
842 for (i = UI_CURRENT; i < UI_SIZE; i++)
843 p->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
844 spin_unlock_irq(&mdev->ldev->md.uuid_lock);
845
846 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
847 p->uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
848 rcu_read_lock();
849 uuid_flags |= rcu_dereference(mdev->tconn->net_conf)->discard_my_data ? 1 : 0;
850 rcu_read_unlock();
851 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
852 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
853 p->uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
854
855 put_ldev(mdev);
856 return drbd_send_command(mdev, sock, P_UUIDS, sizeof(*p), NULL, 0);
857}
858
859int drbd_send_uuids(struct drbd_conf *mdev)
860{
861 return _drbd_send_uuids(mdev, 0);
862}
863
864int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
865{
866 return _drbd_send_uuids(mdev, 8);
867}
868
869void drbd_print_uuids(struct drbd_conf *mdev, const char *text)
870{
871 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
872 u64 *uuid = mdev->ldev->md.uuid;
873 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX\n",
874 text,
875 (unsigned long long)uuid[UI_CURRENT],
876 (unsigned long long)uuid[UI_BITMAP],
877 (unsigned long long)uuid[UI_HISTORY_START],
878 (unsigned long long)uuid[UI_HISTORY_END]);
879 put_ldev(mdev);
880 } else {
881 dev_info(DEV, "%s effective data uuid: %016llX\n",
882 text,
883 (unsigned long long)mdev->ed_uuid);
884 }
885}
886
887void drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev)
888{
889 struct drbd_socket *sock;
890 struct p_rs_uuid *p;
891 u64 uuid;
892
893 D_ASSERT(mdev->state.disk == D_UP_TO_DATE);
894
895 uuid = mdev->ldev->md.uuid[UI_BITMAP];
896 if (uuid && uuid != UUID_JUST_CREATED)
897 uuid = uuid + UUID_NEW_BM_OFFSET;
898 else
899 get_random_bytes(&uuid, sizeof(u64));
900 drbd_uuid_set(mdev, UI_BITMAP, uuid);
901 drbd_print_uuids(mdev, "updated sync UUID");
902 drbd_md_sync(mdev);
903
904 sock = &mdev->tconn->data;
905 p = drbd_prepare_command(mdev, sock);
906 if (p) {
907 p->uuid = cpu_to_be64(uuid);
908 drbd_send_command(mdev, sock, P_SYNC_UUID, sizeof(*p), NULL, 0);
909 }
910}
911
912int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
913{
914 struct drbd_socket *sock;
915 struct p_sizes *p;
916 sector_t d_size, u_size;
917 int q_order_type;
918 unsigned int max_bio_size;
919
920 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
921 D_ASSERT(mdev->ldev->backing_bdev);
922 d_size = drbd_get_max_capacity(mdev->ldev);
923 rcu_read_lock();
924 u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
925 rcu_read_unlock();
926 q_order_type = drbd_queue_order_type(mdev);
927 max_bio_size = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
928 max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE);
929 put_ldev(mdev);
930 } else {
931 d_size = 0;
932 u_size = 0;
933 q_order_type = QUEUE_ORDERED_NONE;
934 max_bio_size = DRBD_MAX_BIO_SIZE;
935 }
936
937 sock = &mdev->tconn->data;
938 p = drbd_prepare_command(mdev, sock);
939 if (!p)
940 return -EIO;
941
942 if (mdev->tconn->agreed_pro_version <= 94)
943 max_bio_size = min(max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
944 else if (mdev->tconn->agreed_pro_version < 100)
945 max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE_P95);
946
947 p->d_size = cpu_to_be64(d_size);
948 p->u_size = cpu_to_be64(u_size);
949 p->c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
950 p->max_bio_size = cpu_to_be32(max_bio_size);
951 p->queue_order_type = cpu_to_be16(q_order_type);
952 p->dds_flags = cpu_to_be16(flags);
953 return drbd_send_command(mdev, sock, P_SIZES, sizeof(*p), NULL, 0);
954}
955
956
957
958
959
960int drbd_send_current_state(struct drbd_conf *mdev)
961{
962 struct drbd_socket *sock;
963 struct p_state *p;
964
965 sock = &mdev->tconn->data;
966 p = drbd_prepare_command(mdev, sock);
967 if (!p)
968 return -EIO;
969 p->state = cpu_to_be32(mdev->state.i);
970 return drbd_send_command(mdev, sock, P_STATE, sizeof(*p), NULL, 0);
971}
972
973
974
975
976
977
978
979
980
981
982
983int drbd_send_state(struct drbd_conf *mdev, union drbd_state state)
984{
985 struct drbd_socket *sock;
986 struct p_state *p;
987
988 sock = &mdev->tconn->data;
989 p = drbd_prepare_command(mdev, sock);
990 if (!p)
991 return -EIO;
992 p->state = cpu_to_be32(state.i);
993 return drbd_send_command(mdev, sock, P_STATE, sizeof(*p), NULL, 0);
994}
995
996int drbd_send_state_req(struct drbd_conf *mdev, union drbd_state mask, union drbd_state val)
997{
998 struct drbd_socket *sock;
999 struct p_req_state *p;
1000
1001 sock = &mdev->tconn->data;
1002 p = drbd_prepare_command(mdev, sock);
1003 if (!p)
1004 return -EIO;
1005 p->mask = cpu_to_be32(mask.i);
1006 p->val = cpu_to_be32(val.i);
1007 return drbd_send_command(mdev, sock, P_STATE_CHG_REQ, sizeof(*p), NULL, 0);
1008}
1009
1010int conn_send_state_req(struct drbd_tconn *tconn, union drbd_state mask, union drbd_state val)
1011{
1012 enum drbd_packet cmd;
1013 struct drbd_socket *sock;
1014 struct p_req_state *p;
1015
1016 cmd = tconn->agreed_pro_version < 100 ? P_STATE_CHG_REQ : P_CONN_ST_CHG_REQ;
1017 sock = &tconn->data;
1018 p = conn_prepare_command(tconn, sock);
1019 if (!p)
1020 return -EIO;
1021 p->mask = cpu_to_be32(mask.i);
1022 p->val = cpu_to_be32(val.i);
1023 return conn_send_command(tconn, sock, cmd, sizeof(*p), NULL, 0);
1024}
1025
1026void drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode)
1027{
1028 struct drbd_socket *sock;
1029 struct p_req_state_reply *p;
1030
1031 sock = &mdev->tconn->meta;
1032 p = drbd_prepare_command(mdev, sock);
1033 if (p) {
1034 p->retcode = cpu_to_be32(retcode);
1035 drbd_send_command(mdev, sock, P_STATE_CHG_REPLY, sizeof(*p), NULL, 0);
1036 }
1037}
1038
1039void conn_send_sr_reply(struct drbd_tconn *tconn, enum drbd_state_rv retcode)
1040{
1041 struct drbd_socket *sock;
1042 struct p_req_state_reply *p;
1043 enum drbd_packet cmd = tconn->agreed_pro_version < 100 ? P_STATE_CHG_REPLY : P_CONN_ST_CHG_REPLY;
1044
1045 sock = &tconn->meta;
1046 p = conn_prepare_command(tconn, sock);
1047 if (p) {
1048 p->retcode = cpu_to_be32(retcode);
1049 conn_send_command(tconn, sock, cmd, sizeof(*p), NULL, 0);
1050 }
1051}
1052
1053static void dcbp_set_code(struct p_compressed_bm *p, enum drbd_bitmap_code code)
1054{
1055 BUG_ON(code & ~0xf);
1056 p->encoding = (p->encoding & ~0xf) | code;
1057}
1058
1059static void dcbp_set_start(struct p_compressed_bm *p, int set)
1060{
1061 p->encoding = (p->encoding & ~0x80) | (set ? 0x80 : 0);
1062}
1063
1064static void dcbp_set_pad_bits(struct p_compressed_bm *p, int n)
1065{
1066 BUG_ON(n & ~0x7);
1067 p->encoding = (p->encoding & (~0x7 << 4)) | (n << 4);
1068}
1069
1070int fill_bitmap_rle_bits(struct drbd_conf *mdev,
1071 struct p_compressed_bm *p,
1072 unsigned int size,
1073 struct bm_xfer_ctx *c)
1074{
1075 struct bitstream bs;
1076 unsigned long plain_bits;
1077 unsigned long tmp;
1078 unsigned long rl;
1079 unsigned len;
1080 unsigned toggle;
1081 int bits, use_rle;
1082
1083
1084 rcu_read_lock();
1085 use_rle = rcu_dereference(mdev->tconn->net_conf)->use_rle;
1086 rcu_read_unlock();
1087 if (!use_rle || mdev->tconn->agreed_pro_version < 90)
1088 return 0;
1089
1090 if (c->bit_offset >= c->bm_bits)
1091 return 0;
1092
1093
1094 bitstream_init(&bs, p->code, size, 0);
1095 memset(p->code, 0, size);
1096
1097 plain_bits = 0;
1098
1099
1100
1101
1102 toggle = 2;
1103
1104
1105
1106 do {
1107 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1108 : _drbd_bm_find_next(mdev, c->bit_offset);
1109 if (tmp == -1UL)
1110 tmp = c->bm_bits;
1111 rl = tmp - c->bit_offset;
1112
1113 if (toggle == 2) {
1114 if (rl == 0) {
1115
1116
1117 dcbp_set_start(p, 1);
1118
1119 toggle = !toggle;
1120 continue;
1121 }
1122 dcbp_set_start(p, 0);
1123 }
1124
1125
1126
1127 if (rl == 0) {
1128 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1129 "t:%u bo:%lu\n", toggle, c->bit_offset);
1130 return -1;
1131 }
1132
1133 bits = vli_encode_bits(&bs, rl);
1134 if (bits == -ENOBUFS)
1135 break;
1136 if (bits <= 0) {
1137 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
1138 return 0;
1139 }
1140
1141 toggle = !toggle;
1142 plain_bits += rl;
1143 c->bit_offset = tmp;
1144 } while (c->bit_offset < c->bm_bits);
1145
1146 len = bs.cur.b - p->code + !!bs.cur.bit;
1147
1148 if (plain_bits < (len << 3)) {
1149
1150
1151 c->bit_offset -= plain_bits;
1152 bm_xfer_ctx_bit_to_word_offset(c);
1153 c->bit_offset = c->word_offset * BITS_PER_LONG;
1154 return 0;
1155 }
1156
1157
1158
1159 bm_xfer_ctx_bit_to_word_offset(c);
1160
1161
1162 dcbp_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
1163
1164 return len;
1165}
1166
1167
1168
1169
1170
1171
1172
1173static int
1174send_bitmap_rle_or_plain(struct drbd_conf *mdev, struct bm_xfer_ctx *c)
1175{
1176 struct drbd_socket *sock = &mdev->tconn->data;
1177 unsigned int header_size = drbd_header_size(mdev->tconn);
1178 struct p_compressed_bm *p = sock->sbuf + header_size;
1179 int len, err;
1180
1181 len = fill_bitmap_rle_bits(mdev, p,
1182 DRBD_SOCKET_BUFFER_SIZE - header_size - sizeof(*p), c);
1183 if (len < 0)
1184 return -EIO;
1185
1186 if (len) {
1187 dcbp_set_code(p, RLE_VLI_Bits);
1188 err = __send_command(mdev->tconn, mdev->vnr, sock,
1189 P_COMPRESSED_BITMAP, sizeof(*p) + len,
1190 NULL, 0);
1191 c->packets[0]++;
1192 c->bytes[0] += header_size + sizeof(*p) + len;
1193
1194 if (c->bit_offset >= c->bm_bits)
1195 len = 0;
1196 } else {
1197
1198
1199 unsigned int data_size;
1200 unsigned long num_words;
1201 unsigned long *p = sock->sbuf + header_size;
1202
1203 data_size = DRBD_SOCKET_BUFFER_SIZE - header_size;
1204 num_words = min_t(size_t, data_size / sizeof(*p),
1205 c->bm_words - c->word_offset);
1206 len = num_words * sizeof(*p);
1207 if (len)
1208 drbd_bm_get_lel(mdev, c->word_offset, num_words, p);
1209 err = __send_command(mdev->tconn, mdev->vnr, sock, P_BITMAP, len, NULL, 0);
1210 c->word_offset += num_words;
1211 c->bit_offset = c->word_offset * BITS_PER_LONG;
1212
1213 c->packets[1]++;
1214 c->bytes[1] += header_size + len;
1215
1216 if (c->bit_offset > c->bm_bits)
1217 c->bit_offset = c->bm_bits;
1218 }
1219 if (!err) {
1220 if (len == 0) {
1221 INFO_bm_xfer_stats(mdev, "send", c);
1222 return 0;
1223 } else
1224 return 1;
1225 }
1226 return -EIO;
1227}
1228
1229
1230static int _drbd_send_bitmap(struct drbd_conf *mdev)
1231{
1232 struct bm_xfer_ctx c;
1233 int err;
1234
1235 if (!expect(mdev->bitmap))
1236 return false;
1237
1238 if (get_ldev(mdev)) {
1239 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1240 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
1241 drbd_bm_set_all(mdev);
1242 if (drbd_bm_write(mdev)) {
1243
1244
1245
1246 dev_err(DEV, "Failed to write bitmap to disk!\n");
1247 } else {
1248 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
1249 drbd_md_sync(mdev);
1250 }
1251 }
1252 put_ldev(mdev);
1253 }
1254
1255 c = (struct bm_xfer_ctx) {
1256 .bm_bits = drbd_bm_bits(mdev),
1257 .bm_words = drbd_bm_words(mdev),
1258 };
1259
1260 do {
1261 err = send_bitmap_rle_or_plain(mdev, &c);
1262 } while (err > 0);
1263
1264 return err == 0;
1265}
1266
1267int drbd_send_bitmap(struct drbd_conf *mdev)
1268{
1269 struct drbd_socket *sock = &mdev->tconn->data;
1270 int err = -1;
1271
1272 mutex_lock(&sock->mutex);
1273 if (sock->socket)
1274 err = !_drbd_send_bitmap(mdev);
1275 mutex_unlock(&sock->mutex);
1276 return err;
1277}
1278
1279void drbd_send_b_ack(struct drbd_tconn *tconn, u32 barrier_nr, u32 set_size)
1280{
1281 struct drbd_socket *sock;
1282 struct p_barrier_ack *p;
1283
1284 if (tconn->cstate < C_WF_REPORT_PARAMS)
1285 return;
1286
1287 sock = &tconn->meta;
1288 p = conn_prepare_command(tconn, sock);
1289 if (!p)
1290 return;
1291 p->barrier = barrier_nr;
1292 p->set_size = cpu_to_be32(set_size);
1293 conn_send_command(tconn, sock, P_BARRIER_ACK, sizeof(*p), NULL, 0);
1294}
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
1305 u64 sector, u32 blksize, u64 block_id)
1306{
1307 struct drbd_socket *sock;
1308 struct p_block_ack *p;
1309
1310 if (mdev->state.conn < C_CONNECTED)
1311 return -EIO;
1312
1313 sock = &mdev->tconn->meta;
1314 p = drbd_prepare_command(mdev, sock);
1315 if (!p)
1316 return -EIO;
1317 p->sector = sector;
1318 p->block_id = block_id;
1319 p->blksize = blksize;
1320 p->seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
1321 return drbd_send_command(mdev, sock, cmd, sizeof(*p), NULL, 0);
1322}
1323
1324
1325
1326
1327void drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
1328 struct p_data *dp, int data_size)
1329{
1330 if (mdev->tconn->peer_integrity_tfm)
1331 data_size -= crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm);
1332 _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
1333 dp->block_id);
1334}
1335
1336void drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
1337 struct p_block_req *rp)
1338{
1339 _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
1340}
1341
1342
1343
1344
1345
1346
1347
1348int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
1349 struct drbd_peer_request *peer_req)
1350{
1351 return _drbd_send_ack(mdev, cmd,
1352 cpu_to_be64(peer_req->i.sector),
1353 cpu_to_be32(peer_req->i.size),
1354 peer_req->block_id);
1355}
1356
1357
1358
1359int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
1360 sector_t sector, int blksize, u64 block_id)
1361{
1362 return _drbd_send_ack(mdev, cmd,
1363 cpu_to_be64(sector),
1364 cpu_to_be32(blksize),
1365 cpu_to_be64(block_id));
1366}
1367
1368int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1369 sector_t sector, int size, u64 block_id)
1370{
1371 struct drbd_socket *sock;
1372 struct p_block_req *p;
1373
1374 sock = &mdev->tconn->data;
1375 p = drbd_prepare_command(mdev, sock);
1376 if (!p)
1377 return -EIO;
1378 p->sector = cpu_to_be64(sector);
1379 p->block_id = block_id;
1380 p->blksize = cpu_to_be32(size);
1381 return drbd_send_command(mdev, sock, cmd, sizeof(*p), NULL, 0);
1382}
1383
1384int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector, int size,
1385 void *digest, int digest_size, enum drbd_packet cmd)
1386{
1387 struct drbd_socket *sock;
1388 struct p_block_req *p;
1389
1390
1391
1392 sock = &mdev->tconn->data;
1393 p = drbd_prepare_command(mdev, sock);
1394 if (!p)
1395 return -EIO;
1396 p->sector = cpu_to_be64(sector);
1397 p->block_id = ID_SYNCER ;
1398 p->blksize = cpu_to_be32(size);
1399 return drbd_send_command(mdev, sock, cmd, sizeof(*p),
1400 digest, digest_size);
1401}
1402
1403int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
1404{
1405 struct drbd_socket *sock;
1406 struct p_block_req *p;
1407
1408 sock = &mdev->tconn->data;
1409 p = drbd_prepare_command(mdev, sock);
1410 if (!p)
1411 return -EIO;
1412 p->sector = cpu_to_be64(sector);
1413 p->block_id = ID_SYNCER ;
1414 p->blksize = cpu_to_be32(size);
1415 return drbd_send_command(mdev, sock, P_OV_REQUEST, sizeof(*p), NULL, 0);
1416}
1417
1418
1419
1420
1421
1422static int we_should_drop_the_connection(struct drbd_tconn *tconn, struct socket *sock)
1423{
1424 int drop_it;
1425
1426
1427 drop_it = tconn->meta.socket == sock
1428 || !tconn->asender.task
1429 || get_t_state(&tconn->asender) != RUNNING
1430 || tconn->cstate < C_WF_REPORT_PARAMS;
1431
1432 if (drop_it)
1433 return true;
1434
1435 drop_it = !--tconn->ko_count;
1436 if (!drop_it) {
1437 conn_err(tconn, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1438 current->comm, current->pid, tconn->ko_count);
1439 request_ping(tconn);
1440 }
1441
1442 return drop_it; ;
1443}
1444
1445static void drbd_update_congested(struct drbd_tconn *tconn)
1446{
1447 struct sock *sk = tconn->data.socket->sk;
1448 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5)
1449 set_bit(NET_CONGESTED, &tconn->flags);
1450}
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
1474 int offset, size_t size, unsigned msg_flags)
1475{
1476 struct socket *socket;
1477 void *addr;
1478 int err;
1479
1480 socket = mdev->tconn->data.socket;
1481 addr = kmap(page) + offset;
1482 err = drbd_send_all(mdev->tconn, socket, addr, size, msg_flags);
1483 kunmap(page);
1484 if (!err)
1485 mdev->send_cnt += size >> 9;
1486 return err;
1487}
1488
1489static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
1490 int offset, size_t size, unsigned msg_flags)
1491{
1492 struct socket *socket = mdev->tconn->data.socket;
1493 mm_segment_t oldfs = get_fs();
1494 int len = size;
1495 int err = -EIO;
1496
1497
1498
1499
1500
1501
1502
1503 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
1504 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
1505
1506 msg_flags |= MSG_NOSIGNAL;
1507 drbd_update_congested(mdev->tconn);
1508 set_fs(KERNEL_DS);
1509 do {
1510 int sent;
1511
1512 sent = socket->ops->sendpage(socket, page, offset, len, msg_flags);
1513 if (sent <= 0) {
1514 if (sent == -EAGAIN) {
1515 if (we_should_drop_the_connection(mdev->tconn, socket))
1516 break;
1517 continue;
1518 }
1519 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
1520 __func__, (int)size, len, sent);
1521 if (sent < 0)
1522 err = sent;
1523 break;
1524 }
1525 len -= sent;
1526 offset += sent;
1527 } while (len > 0 );
1528 set_fs(oldfs);
1529 clear_bit(NET_CONGESTED, &mdev->tconn->flags);
1530
1531 if (len == 0) {
1532 err = 0;
1533 mdev->send_cnt += size >> 9;
1534 }
1535 return err;
1536}
1537
1538static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
1539{
1540 struct bio_vec *bvec;
1541 int i;
1542
1543 bio_for_each_segment(bvec, bio, i) {
1544 int err;
1545
1546 err = _drbd_no_send_page(mdev, bvec->bv_page,
1547 bvec->bv_offset, bvec->bv_len,
1548 i == bio->bi_vcnt - 1 ? 0 : MSG_MORE);
1549 if (err)
1550 return err;
1551 }
1552 return 0;
1553}
1554
1555static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
1556{
1557 struct bio_vec *bvec;
1558 int i;
1559
1560 bio_for_each_segment(bvec, bio, i) {
1561 int err;
1562
1563 err = _drbd_send_page(mdev, bvec->bv_page,
1564 bvec->bv_offset, bvec->bv_len,
1565 i == bio->bi_vcnt - 1 ? 0 : MSG_MORE);
1566 if (err)
1567 return err;
1568 }
1569 return 0;
1570}
1571
1572static int _drbd_send_zc_ee(struct drbd_conf *mdev,
1573 struct drbd_peer_request *peer_req)
1574{
1575 struct page *page = peer_req->pages;
1576 unsigned len = peer_req->i.size;
1577 int err;
1578
1579
1580 page_chain_for_each(page) {
1581 unsigned l = min_t(unsigned, len, PAGE_SIZE);
1582
1583 err = _drbd_send_page(mdev, page, 0, l,
1584 page_chain_next(page) ? MSG_MORE : 0);
1585 if (err)
1586 return err;
1587 len -= l;
1588 }
1589 return 0;
1590}
1591
1592static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
1593{
1594 if (mdev->tconn->agreed_pro_version >= 95)
1595 return (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
1596 (bi_rw & REQ_FUA ? DP_FUA : 0) |
1597 (bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
1598 (bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
1599 else
1600 return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
1601}
1602
1603
1604
1605
1606int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
1607{
1608 struct drbd_socket *sock;
1609 struct p_data *p;
1610 unsigned int dp_flags = 0;
1611 int dgs;
1612 int err;
1613
1614 sock = &mdev->tconn->data;
1615 p = drbd_prepare_command(mdev, sock);
1616 dgs = mdev->tconn->integrity_tfm ? crypto_hash_digestsize(mdev->tconn->integrity_tfm) : 0;
1617
1618 if (!p)
1619 return -EIO;
1620 p->sector = cpu_to_be64(req->i.sector);
1621 p->block_id = (unsigned long)req;
1622 p->seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
1623 dp_flags = bio_flags_to_wire(mdev, req->master_bio->bi_rw);
1624 if (mdev->state.conn >= C_SYNC_SOURCE &&
1625 mdev->state.conn <= C_PAUSED_SYNC_T)
1626 dp_flags |= DP_MAY_SET_IN_SYNC;
1627 if (mdev->tconn->agreed_pro_version >= 100) {
1628 if (req->rq_state & RQ_EXP_RECEIVE_ACK)
1629 dp_flags |= DP_SEND_RECEIVE_ACK;
1630 if (req->rq_state & RQ_EXP_WRITE_ACK)
1631 dp_flags |= DP_SEND_WRITE_ACK;
1632 }
1633 p->dp_flags = cpu_to_be32(dp_flags);
1634 if (dgs)
1635 drbd_csum_bio(mdev, mdev->tconn->integrity_tfm, req->master_bio, p + 1);
1636 err = __send_command(mdev->tconn, mdev->vnr, sock, P_DATA, sizeof(*p) + dgs, NULL, req->i.size);
1637 if (!err) {
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649 if (!(req->rq_state & (RQ_EXP_RECEIVE_ACK | RQ_EXP_WRITE_ACK)) || dgs)
1650 err = _drbd_send_bio(mdev, req->master_bio);
1651 else
1652 err = _drbd_send_zc_bio(mdev, req->master_bio);
1653
1654
1655 if (dgs > 0 && dgs <= 64) {
1656
1657
1658 unsigned char digest[64];
1659 drbd_csum_bio(mdev, mdev->tconn->integrity_tfm, req->master_bio, digest);
1660 if (memcmp(p + 1, digest, dgs)) {
1661 dev_warn(DEV,
1662 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
1663 (unsigned long long)req->i.sector, req->i.size);
1664 }
1665 }
1666
1667
1668 }
1669 mutex_unlock(&sock->mutex);
1670
1671 return err;
1672}
1673
1674
1675
1676
1677
1678int drbd_send_block(struct drbd_conf *mdev, enum drbd_packet cmd,
1679 struct drbd_peer_request *peer_req)
1680{
1681 struct drbd_socket *sock;
1682 struct p_data *p;
1683 int err;
1684 int dgs;
1685
1686 sock = &mdev->tconn->data;
1687 p = drbd_prepare_command(mdev, sock);
1688
1689 dgs = mdev->tconn->integrity_tfm ? crypto_hash_digestsize(mdev->tconn->integrity_tfm) : 0;
1690
1691 if (!p)
1692 return -EIO;
1693 p->sector = cpu_to_be64(peer_req->i.sector);
1694 p->block_id = peer_req->block_id;
1695 p->seq_num = 0;
1696 p->dp_flags = 0;
1697 if (dgs)
1698 drbd_csum_ee(mdev, mdev->tconn->integrity_tfm, peer_req, p + 1);
1699 err = __send_command(mdev->tconn, mdev->vnr, sock, cmd, sizeof(*p) + dgs, NULL, peer_req->i.size);
1700 if (!err)
1701 err = _drbd_send_zc_ee(mdev, peer_req);
1702 mutex_unlock(&sock->mutex);
1703
1704 return err;
1705}
1706
1707int drbd_send_out_of_sync(struct drbd_conf *mdev, struct drbd_request *req)
1708{
1709 struct drbd_socket *sock;
1710 struct p_block_desc *p;
1711
1712 sock = &mdev->tconn->data;
1713 p = drbd_prepare_command(mdev, sock);
1714 if (!p)
1715 return -EIO;
1716 p->sector = cpu_to_be64(req->i.sector);
1717 p->blksize = cpu_to_be32(req->i.size);
1718 return drbd_send_command(mdev, sock, P_OUT_OF_SYNC, sizeof(*p), NULL, 0);
1719}
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
1738 void *buf, size_t size, unsigned msg_flags)
1739{
1740 struct kvec iov;
1741 struct msghdr msg;
1742 int rv, sent = 0;
1743
1744 if (!sock)
1745 return -EBADR;
1746
1747
1748
1749 iov.iov_base = buf;
1750 iov.iov_len = size;
1751
1752 msg.msg_name = NULL;
1753 msg.msg_namelen = 0;
1754 msg.msg_control = NULL;
1755 msg.msg_controllen = 0;
1756 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
1757
1758 if (sock == tconn->data.socket) {
1759 rcu_read_lock();
1760 tconn->ko_count = rcu_dereference(tconn->net_conf)->ko_count;
1761 rcu_read_unlock();
1762 drbd_update_congested(tconn);
1763 }
1764 do {
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
1775 if (rv == -EAGAIN) {
1776 if (we_should_drop_the_connection(tconn, sock))
1777 break;
1778 else
1779 continue;
1780 }
1781 if (rv == -EINTR) {
1782 flush_signals(current);
1783 rv = 0;
1784 }
1785 if (rv < 0)
1786 break;
1787 sent += rv;
1788 iov.iov_base += rv;
1789 iov.iov_len -= rv;
1790 } while (sent < size);
1791
1792 if (sock == tconn->data.socket)
1793 clear_bit(NET_CONGESTED, &tconn->flags);
1794
1795 if (rv <= 0) {
1796 if (rv != -EAGAIN) {
1797 conn_err(tconn, "%s_sendmsg returned %d\n",
1798 sock == tconn->meta.socket ? "msock" : "sock",
1799 rv);
1800 conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
1801 } else
1802 conn_request_state(tconn, NS(conn, C_TIMEOUT), CS_HARD);
1803 }
1804
1805 return sent;
1806}
1807
1808
1809
1810
1811
1812
1813int drbd_send_all(struct drbd_tconn *tconn, struct socket *sock, void *buffer,
1814 size_t size, unsigned msg_flags)
1815{
1816 int err;
1817
1818 err = drbd_send(tconn, sock, buffer, size, msg_flags);
1819 if (err < 0)
1820 return err;
1821 if (err != size)
1822 return -EIO;
1823 return 0;
1824}
1825
1826static int drbd_open(struct block_device *bdev, fmode_t mode)
1827{
1828 struct drbd_conf *mdev = bdev->bd_disk->private_data;
1829 unsigned long flags;
1830 int rv = 0;
1831
1832 mutex_lock(&drbd_main_mutex);
1833 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
1834
1835
1836
1837 if (mdev->state.role != R_PRIMARY) {
1838 if (mode & FMODE_WRITE)
1839 rv = -EROFS;
1840 else if (!allow_oos)
1841 rv = -EMEDIUMTYPE;
1842 }
1843
1844 if (!rv)
1845 mdev->open_cnt++;
1846 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
1847 mutex_unlock(&drbd_main_mutex);
1848
1849 return rv;
1850}
1851
1852static void drbd_release(struct gendisk *gd, fmode_t mode)
1853{
1854 struct drbd_conf *mdev = gd->private_data;
1855 mutex_lock(&drbd_main_mutex);
1856 mdev->open_cnt--;
1857 mutex_unlock(&drbd_main_mutex);
1858}
1859
1860static void drbd_set_defaults(struct drbd_conf *mdev)
1861{
1862
1863
1864 mdev->state = (union drbd_dev_state) {
1865 { .role = R_SECONDARY,
1866 .peer = R_UNKNOWN,
1867 .conn = C_STANDALONE,
1868 .disk = D_DISKLESS,
1869 .pdsk = D_UNKNOWN,
1870 } };
1871}
1872
1873void drbd_init_set_defaults(struct drbd_conf *mdev)
1874{
1875
1876
1877
1878 drbd_set_defaults(mdev);
1879
1880 atomic_set(&mdev->ap_bio_cnt, 0);
1881 atomic_set(&mdev->ap_pending_cnt, 0);
1882 atomic_set(&mdev->rs_pending_cnt, 0);
1883 atomic_set(&mdev->unacked_cnt, 0);
1884 atomic_set(&mdev->local_cnt, 0);
1885 atomic_set(&mdev->pp_in_use_by_net, 0);
1886 atomic_set(&mdev->rs_sect_in, 0);
1887 atomic_set(&mdev->rs_sect_ev, 0);
1888 atomic_set(&mdev->ap_in_flight, 0);
1889 atomic_set(&mdev->md_io_in_use, 0);
1890
1891 mutex_init(&mdev->own_state_mutex);
1892 mdev->state_mutex = &mdev->own_state_mutex;
1893
1894 spin_lock_init(&mdev->al_lock);
1895 spin_lock_init(&mdev->peer_seq_lock);
1896
1897 INIT_LIST_HEAD(&mdev->active_ee);
1898 INIT_LIST_HEAD(&mdev->sync_ee);
1899 INIT_LIST_HEAD(&mdev->done_ee);
1900 INIT_LIST_HEAD(&mdev->read_ee);
1901 INIT_LIST_HEAD(&mdev->net_ee);
1902 INIT_LIST_HEAD(&mdev->resync_reads);
1903 INIT_LIST_HEAD(&mdev->resync_work.list);
1904 INIT_LIST_HEAD(&mdev->unplug_work.list);
1905 INIT_LIST_HEAD(&mdev->go_diskless.list);
1906 INIT_LIST_HEAD(&mdev->md_sync_work.list);
1907 INIT_LIST_HEAD(&mdev->start_resync_work.list);
1908 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
1909
1910 mdev->resync_work.cb = w_resync_timer;
1911 mdev->unplug_work.cb = w_send_write_hint;
1912 mdev->go_diskless.cb = w_go_diskless;
1913 mdev->md_sync_work.cb = w_md_sync;
1914 mdev->bm_io_work.w.cb = w_bitmap_io;
1915 mdev->start_resync_work.cb = w_start_resync;
1916
1917 mdev->resync_work.mdev = mdev;
1918 mdev->unplug_work.mdev = mdev;
1919 mdev->go_diskless.mdev = mdev;
1920 mdev->md_sync_work.mdev = mdev;
1921 mdev->bm_io_work.w.mdev = mdev;
1922 mdev->start_resync_work.mdev = mdev;
1923
1924 init_timer(&mdev->resync_timer);
1925 init_timer(&mdev->md_sync_timer);
1926 init_timer(&mdev->start_resync_timer);
1927 init_timer(&mdev->request_timer);
1928 mdev->resync_timer.function = resync_timer_fn;
1929 mdev->resync_timer.data = (unsigned long) mdev;
1930 mdev->md_sync_timer.function = md_sync_timer_fn;
1931 mdev->md_sync_timer.data = (unsigned long) mdev;
1932 mdev->start_resync_timer.function = start_resync_timer_fn;
1933 mdev->start_resync_timer.data = (unsigned long) mdev;
1934 mdev->request_timer.function = request_timer_fn;
1935 mdev->request_timer.data = (unsigned long) mdev;
1936
1937 init_waitqueue_head(&mdev->misc_wait);
1938 init_waitqueue_head(&mdev->state_wait);
1939 init_waitqueue_head(&mdev->ee_wait);
1940 init_waitqueue_head(&mdev->al_wait);
1941 init_waitqueue_head(&mdev->seq_wait);
1942
1943 mdev->resync_wenr = LC_FREE;
1944 mdev->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
1945 mdev->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
1946}
1947
1948void drbd_mdev_cleanup(struct drbd_conf *mdev)
1949{
1950 int i;
1951 if (mdev->tconn->receiver.t_state != NONE)
1952 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
1953 mdev->tconn->receiver.t_state);
1954
1955 mdev->al_writ_cnt =
1956 mdev->bm_writ_cnt =
1957 mdev->read_cnt =
1958 mdev->recv_cnt =
1959 mdev->send_cnt =
1960 mdev->writ_cnt =
1961 mdev->p_size =
1962 mdev->rs_start =
1963 mdev->rs_total =
1964 mdev->rs_failed = 0;
1965 mdev->rs_last_events = 0;
1966 mdev->rs_last_sect_ev = 0;
1967 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
1968 mdev->rs_mark_left[i] = 0;
1969 mdev->rs_mark_time[i] = 0;
1970 }
1971 D_ASSERT(mdev->tconn->net_conf == NULL);
1972
1973 drbd_set_my_capacity(mdev, 0);
1974 if (mdev->bitmap) {
1975
1976 drbd_bm_resize(mdev, 0, 1);
1977 drbd_bm_cleanup(mdev);
1978 }
1979
1980 drbd_free_bc(mdev->ldev);
1981 mdev->ldev = NULL;
1982
1983 clear_bit(AL_SUSPENDED, &mdev->flags);
1984
1985 D_ASSERT(list_empty(&mdev->active_ee));
1986 D_ASSERT(list_empty(&mdev->sync_ee));
1987 D_ASSERT(list_empty(&mdev->done_ee));
1988 D_ASSERT(list_empty(&mdev->read_ee));
1989 D_ASSERT(list_empty(&mdev->net_ee));
1990 D_ASSERT(list_empty(&mdev->resync_reads));
1991 D_ASSERT(list_empty(&mdev->tconn->sender_work.q));
1992 D_ASSERT(list_empty(&mdev->resync_work.list));
1993 D_ASSERT(list_empty(&mdev->unplug_work.list));
1994 D_ASSERT(list_empty(&mdev->go_diskless.list));
1995
1996 drbd_set_defaults(mdev);
1997}
1998
1999
2000static void drbd_destroy_mempools(void)
2001{
2002 struct page *page;
2003
2004 while (drbd_pp_pool) {
2005 page = drbd_pp_pool;
2006 drbd_pp_pool = (struct page *)page_private(page);
2007 __free_page(page);
2008 drbd_pp_vacant--;
2009 }
2010
2011
2012
2013 if (drbd_md_io_bio_set)
2014 bioset_free(drbd_md_io_bio_set);
2015 if (drbd_md_io_page_pool)
2016 mempool_destroy(drbd_md_io_page_pool);
2017 if (drbd_ee_mempool)
2018 mempool_destroy(drbd_ee_mempool);
2019 if (drbd_request_mempool)
2020 mempool_destroy(drbd_request_mempool);
2021 if (drbd_ee_cache)
2022 kmem_cache_destroy(drbd_ee_cache);
2023 if (drbd_request_cache)
2024 kmem_cache_destroy(drbd_request_cache);
2025 if (drbd_bm_ext_cache)
2026 kmem_cache_destroy(drbd_bm_ext_cache);
2027 if (drbd_al_ext_cache)
2028 kmem_cache_destroy(drbd_al_ext_cache);
2029
2030 drbd_md_io_bio_set = NULL;
2031 drbd_md_io_page_pool = NULL;
2032 drbd_ee_mempool = NULL;
2033 drbd_request_mempool = NULL;
2034 drbd_ee_cache = NULL;
2035 drbd_request_cache = NULL;
2036 drbd_bm_ext_cache = NULL;
2037 drbd_al_ext_cache = NULL;
2038
2039 return;
2040}
2041
2042static int drbd_create_mempools(void)
2043{
2044 struct page *page;
2045 const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;
2046 int i;
2047
2048
2049 drbd_request_mempool = NULL;
2050 drbd_ee_cache = NULL;
2051 drbd_request_cache = NULL;
2052 drbd_bm_ext_cache = NULL;
2053 drbd_al_ext_cache = NULL;
2054 drbd_pp_pool = NULL;
2055 drbd_md_io_page_pool = NULL;
2056 drbd_md_io_bio_set = NULL;
2057
2058
2059 drbd_request_cache = kmem_cache_create(
2060 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2061 if (drbd_request_cache == NULL)
2062 goto Enomem;
2063
2064 drbd_ee_cache = kmem_cache_create(
2065 "drbd_ee", sizeof(struct drbd_peer_request), 0, 0, NULL);
2066 if (drbd_ee_cache == NULL)
2067 goto Enomem;
2068
2069 drbd_bm_ext_cache = kmem_cache_create(
2070 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2071 if (drbd_bm_ext_cache == NULL)
2072 goto Enomem;
2073
2074 drbd_al_ext_cache = kmem_cache_create(
2075 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2076 if (drbd_al_ext_cache == NULL)
2077 goto Enomem;
2078
2079
2080 drbd_md_io_bio_set = bioset_create(DRBD_MIN_POOL_PAGES, 0);
2081 if (drbd_md_io_bio_set == NULL)
2082 goto Enomem;
2083
2084 drbd_md_io_page_pool = mempool_create_page_pool(DRBD_MIN_POOL_PAGES, 0);
2085 if (drbd_md_io_page_pool == NULL)
2086 goto Enomem;
2087
2088 drbd_request_mempool = mempool_create(number,
2089 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2090 if (drbd_request_mempool == NULL)
2091 goto Enomem;
2092
2093 drbd_ee_mempool = mempool_create(number,
2094 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
2095 if (drbd_ee_mempool == NULL)
2096 goto Enomem;
2097
2098
2099 spin_lock_init(&drbd_pp_lock);
2100
2101 for (i = 0; i < number; i++) {
2102 page = alloc_page(GFP_HIGHUSER);
2103 if (!page)
2104 goto Enomem;
2105 set_page_private(page, (unsigned long)drbd_pp_pool);
2106 drbd_pp_pool = page;
2107 }
2108 drbd_pp_vacant = number;
2109
2110 return 0;
2111
2112Enomem:
2113 drbd_destroy_mempools();
2114 return -ENOMEM;
2115}
2116
2117static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2118 void *unused)
2119{
2120
2121
2122
2123
2124 return NOTIFY_DONE;
2125}
2126
2127static struct notifier_block drbd_notifier = {
2128 .notifier_call = drbd_notify_sys,
2129};
2130
2131static void drbd_release_all_peer_reqs(struct drbd_conf *mdev)
2132{
2133 int rr;
2134
2135 rr = drbd_free_peer_reqs(mdev, &mdev->active_ee);
2136 if (rr)
2137 dev_err(DEV, "%d EEs in active list found!\n", rr);
2138
2139 rr = drbd_free_peer_reqs(mdev, &mdev->sync_ee);
2140 if (rr)
2141 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2142
2143 rr = drbd_free_peer_reqs(mdev, &mdev->read_ee);
2144 if (rr)
2145 dev_err(DEV, "%d EEs in read list found!\n", rr);
2146
2147 rr = drbd_free_peer_reqs(mdev, &mdev->done_ee);
2148 if (rr)
2149 dev_err(DEV, "%d EEs in done list found!\n", rr);
2150
2151 rr = drbd_free_peer_reqs(mdev, &mdev->net_ee);
2152 if (rr)
2153 dev_err(DEV, "%d EEs in net list found!\n", rr);
2154}
2155
2156
2157void drbd_minor_destroy(struct kref *kref)
2158{
2159 struct drbd_conf *mdev = container_of(kref, struct drbd_conf, kref);
2160 struct drbd_tconn *tconn = mdev->tconn;
2161
2162 del_timer_sync(&mdev->request_timer);
2163
2164
2165 D_ASSERT(mdev->open_cnt == 0);
2166
2167
2168
2169
2170
2171 if (mdev->this_bdev)
2172 bdput(mdev->this_bdev);
2173
2174 drbd_free_bc(mdev->ldev);
2175 mdev->ldev = NULL;
2176
2177 drbd_release_all_peer_reqs(mdev);
2178
2179 lc_destroy(mdev->act_log);
2180 lc_destroy(mdev->resync);
2181
2182 kfree(mdev->p_uuid);
2183
2184
2185 if (mdev->bitmap)
2186 drbd_bm_cleanup(mdev);
2187 __free_page(mdev->md_io_page);
2188 put_disk(mdev->vdisk);
2189 blk_cleanup_queue(mdev->rq_queue);
2190 kfree(mdev->rs_plan_s);
2191 kfree(mdev);
2192
2193 kref_put(&tconn->kref, &conn_destroy);
2194}
2195
2196
2197
2198
2199static struct retry_worker {
2200 struct workqueue_struct *wq;
2201 struct work_struct worker;
2202
2203 spinlock_t lock;
2204 struct list_head writes;
2205} retry;
2206
2207static void do_retry(struct work_struct *ws)
2208{
2209 struct retry_worker *retry = container_of(ws, struct retry_worker, worker);
2210 LIST_HEAD(writes);
2211 struct drbd_request *req, *tmp;
2212
2213 spin_lock_irq(&retry->lock);
2214 list_splice_init(&retry->writes, &writes);
2215 spin_unlock_irq(&retry->lock);
2216
2217 list_for_each_entry_safe(req, tmp, &writes, tl_requests) {
2218 struct drbd_conf *mdev = req->w.mdev;
2219 struct bio *bio = req->master_bio;
2220 unsigned long start_time = req->start_time;
2221 bool expected;
2222
2223 expected =
2224 expect(atomic_read(&req->completion_ref) == 0) &&
2225 expect(req->rq_state & RQ_POSTPONED) &&
2226 expect((req->rq_state & RQ_LOCAL_PENDING) == 0 ||
2227 (req->rq_state & RQ_LOCAL_ABORTED) != 0);
2228
2229 if (!expected)
2230 dev_err(DEV, "req=%p completion_ref=%d rq_state=%x\n",
2231 req, atomic_read(&req->completion_ref),
2232 req->rq_state);
2233
2234
2235
2236
2237
2238
2239 kref_put(&req->kref, drbd_req_destroy);
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254 inc_ap_bio(mdev);
2255 __drbd_make_request(mdev, bio, start_time);
2256 }
2257}
2258
2259void drbd_restart_request(struct drbd_request *req)
2260{
2261 unsigned long flags;
2262 spin_lock_irqsave(&retry.lock, flags);
2263 list_move_tail(&req->tl_requests, &retry.writes);
2264 spin_unlock_irqrestore(&retry.lock, flags);
2265
2266
2267
2268
2269 dec_ap_bio(req->w.mdev);
2270
2271 queue_work(retry.wq, &retry.worker);
2272}
2273
2274
2275static void drbd_cleanup(void)
2276{
2277 unsigned int i;
2278 struct drbd_conf *mdev;
2279 struct drbd_tconn *tconn, *tmp;
2280
2281 unregister_reboot_notifier(&drbd_notifier);
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291 if (drbd_proc)
2292 remove_proc_entry("drbd", NULL);
2293
2294 if (retry.wq)
2295 destroy_workqueue(retry.wq);
2296
2297 drbd_genl_unregister();
2298
2299 idr_for_each_entry(&minors, mdev, i) {
2300 idr_remove(&minors, mdev_to_minor(mdev));
2301 idr_remove(&mdev->tconn->volumes, mdev->vnr);
2302 destroy_workqueue(mdev->submit.wq);
2303 del_gendisk(mdev->vdisk);
2304
2305 kref_put(&mdev->kref, &drbd_minor_destroy);
2306 }
2307
2308
2309 list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
2310 list_del(&tconn->all_tconn);
2311
2312 kref_put(&tconn->kref, &conn_destroy);
2313 }
2314
2315 drbd_destroy_mempools();
2316 unregister_blkdev(DRBD_MAJOR, "drbd");
2317
2318 idr_destroy(&minors);
2319
2320 printk(KERN_INFO "drbd: module cleanup done.\n");
2321}
2322
2323
2324
2325
2326
2327
2328
2329
2330static int drbd_congested(void *congested_data, int bdi_bits)
2331{
2332 struct drbd_conf *mdev = congested_data;
2333 struct request_queue *q;
2334 char reason = '-';
2335 int r = 0;
2336
2337 if (!may_inc_ap_bio(mdev)) {
2338
2339 r = bdi_bits;
2340 reason = 'd';
2341 goto out;
2342 }
2343
2344 if (test_bit(CALLBACK_PENDING, &mdev->tconn->flags)) {
2345 r |= (1 << BDI_async_congested);
2346
2347
2348
2349
2350
2351 if (!get_ldev_if_state(mdev, D_UP_TO_DATE))
2352 r |= (1 << BDI_sync_congested);
2353 else
2354 put_ldev(mdev);
2355 r &= bdi_bits;
2356 reason = 'c';
2357 goto out;
2358 }
2359
2360 if (get_ldev(mdev)) {
2361 q = bdev_get_queue(mdev->ldev->backing_bdev);
2362 r = bdi_congested(&q->backing_dev_info, bdi_bits);
2363 put_ldev(mdev);
2364 if (r)
2365 reason = 'b';
2366 }
2367
2368 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->tconn->flags)) {
2369 r |= (1 << BDI_async_congested);
2370 reason = reason == 'b' ? 'a' : 'n';
2371 }
2372
2373out:
2374 mdev->congestion_reason = reason;
2375 return r;
2376}
2377
2378static void drbd_init_workqueue(struct drbd_work_queue* wq)
2379{
2380 spin_lock_init(&wq->q_lock);
2381 INIT_LIST_HEAD(&wq->q);
2382 init_waitqueue_head(&wq->q_wait);
2383}
2384
2385struct drbd_tconn *conn_get_by_name(const char *name)
2386{
2387 struct drbd_tconn *tconn;
2388
2389 if (!name || !name[0])
2390 return NULL;
2391
2392 rcu_read_lock();
2393 list_for_each_entry_rcu(tconn, &drbd_tconns, all_tconn) {
2394 if (!strcmp(tconn->name, name)) {
2395 kref_get(&tconn->kref);
2396 goto found;
2397 }
2398 }
2399 tconn = NULL;
2400found:
2401 rcu_read_unlock();
2402 return tconn;
2403}
2404
2405struct drbd_tconn *conn_get_by_addrs(void *my_addr, int my_addr_len,
2406 void *peer_addr, int peer_addr_len)
2407{
2408 struct drbd_tconn *tconn;
2409
2410 rcu_read_lock();
2411 list_for_each_entry_rcu(tconn, &drbd_tconns, all_tconn) {
2412 if (tconn->my_addr_len == my_addr_len &&
2413 tconn->peer_addr_len == peer_addr_len &&
2414 !memcmp(&tconn->my_addr, my_addr, my_addr_len) &&
2415 !memcmp(&tconn->peer_addr, peer_addr, peer_addr_len)) {
2416 kref_get(&tconn->kref);
2417 goto found;
2418 }
2419 }
2420 tconn = NULL;
2421found:
2422 rcu_read_unlock();
2423 return tconn;
2424}
2425
2426static int drbd_alloc_socket(struct drbd_socket *socket)
2427{
2428 socket->rbuf = (void *) __get_free_page(GFP_KERNEL);
2429 if (!socket->rbuf)
2430 return -ENOMEM;
2431 socket->sbuf = (void *) __get_free_page(GFP_KERNEL);
2432 if (!socket->sbuf)
2433 return -ENOMEM;
2434 return 0;
2435}
2436
2437static void drbd_free_socket(struct drbd_socket *socket)
2438{
2439 free_page((unsigned long) socket->sbuf);
2440 free_page((unsigned long) socket->rbuf);
2441}
2442
2443void conn_free_crypto(struct drbd_tconn *tconn)
2444{
2445 drbd_free_sock(tconn);
2446
2447 crypto_free_hash(tconn->csums_tfm);
2448 crypto_free_hash(tconn->verify_tfm);
2449 crypto_free_hash(tconn->cram_hmac_tfm);
2450 crypto_free_hash(tconn->integrity_tfm);
2451 crypto_free_hash(tconn->peer_integrity_tfm);
2452 kfree(tconn->int_dig_in);
2453 kfree(tconn->int_dig_vv);
2454
2455 tconn->csums_tfm = NULL;
2456 tconn->verify_tfm = NULL;
2457 tconn->cram_hmac_tfm = NULL;
2458 tconn->integrity_tfm = NULL;
2459 tconn->peer_integrity_tfm = NULL;
2460 tconn->int_dig_in = NULL;
2461 tconn->int_dig_vv = NULL;
2462}
2463
2464int set_resource_options(struct drbd_tconn *tconn, struct res_opts *res_opts)
2465{
2466 cpumask_var_t new_cpu_mask;
2467 int err;
2468
2469 if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL))
2470 return -ENOMEM;
2471
2472
2473
2474
2475
2476
2477 if (nr_cpu_ids > 1 && res_opts->cpu_mask[0] != 0) {
2478
2479 err = bitmap_parse(res_opts->cpu_mask, 32,
2480 cpumask_bits(new_cpu_mask), nr_cpu_ids);
2481 if (err) {
2482 conn_warn(tconn, "bitmap_parse() failed with %d\n", err);
2483
2484 goto fail;
2485 }
2486 }
2487 tconn->res_opts = *res_opts;
2488 if (!cpumask_equal(tconn->cpu_mask, new_cpu_mask)) {
2489 cpumask_copy(tconn->cpu_mask, new_cpu_mask);
2490 drbd_calc_cpu_mask(tconn);
2491 tconn->receiver.reset_cpu_mask = 1;
2492 tconn->asender.reset_cpu_mask = 1;
2493 tconn->worker.reset_cpu_mask = 1;
2494 }
2495 err = 0;
2496
2497fail:
2498 free_cpumask_var(new_cpu_mask);
2499 return err;
2500
2501}
2502
2503
2504struct drbd_tconn *conn_create(const char *name, struct res_opts *res_opts)
2505{
2506 struct drbd_tconn *tconn;
2507
2508 tconn = kzalloc(sizeof(struct drbd_tconn), GFP_KERNEL);
2509 if (!tconn)
2510 return NULL;
2511
2512 tconn->name = kstrdup(name, GFP_KERNEL);
2513 if (!tconn->name)
2514 goto fail;
2515
2516 if (drbd_alloc_socket(&tconn->data))
2517 goto fail;
2518 if (drbd_alloc_socket(&tconn->meta))
2519 goto fail;
2520
2521 if (!zalloc_cpumask_var(&tconn->cpu_mask, GFP_KERNEL))
2522 goto fail;
2523
2524 if (set_resource_options(tconn, res_opts))
2525 goto fail;
2526
2527 tconn->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
2528 if (!tconn->current_epoch)
2529 goto fail;
2530
2531 INIT_LIST_HEAD(&tconn->transfer_log);
2532
2533 INIT_LIST_HEAD(&tconn->current_epoch->list);
2534 tconn->epochs = 1;
2535 spin_lock_init(&tconn->epoch_lock);
2536 tconn->write_ordering = WO_bdev_flush;
2537
2538 tconn->send.seen_any_write_yet = false;
2539 tconn->send.current_epoch_nr = 0;
2540 tconn->send.current_epoch_writes = 0;
2541
2542 tconn->cstate = C_STANDALONE;
2543 mutex_init(&tconn->cstate_mutex);
2544 spin_lock_init(&tconn->req_lock);
2545 mutex_init(&tconn->conf_update);
2546 init_waitqueue_head(&tconn->ping_wait);
2547 idr_init(&tconn->volumes);
2548
2549 drbd_init_workqueue(&tconn->sender_work);
2550 mutex_init(&tconn->data.mutex);
2551 mutex_init(&tconn->meta.mutex);
2552
2553 drbd_thread_init(tconn, &tconn->receiver, drbdd_init, "receiver");
2554 drbd_thread_init(tconn, &tconn->worker, drbd_worker, "worker");
2555 drbd_thread_init(tconn, &tconn->asender, drbd_asender, "asender");
2556
2557 kref_init(&tconn->kref);
2558 list_add_tail_rcu(&tconn->all_tconn, &drbd_tconns);
2559
2560 return tconn;
2561
2562fail:
2563 kfree(tconn->current_epoch);
2564 free_cpumask_var(tconn->cpu_mask);
2565 drbd_free_socket(&tconn->meta);
2566 drbd_free_socket(&tconn->data);
2567 kfree(tconn->name);
2568 kfree(tconn);
2569
2570 return NULL;
2571}
2572
2573void conn_destroy(struct kref *kref)
2574{
2575 struct drbd_tconn *tconn = container_of(kref, struct drbd_tconn, kref);
2576
2577 if (atomic_read(&tconn->current_epoch->epoch_size) != 0)
2578 conn_err(tconn, "epoch_size:%d\n", atomic_read(&tconn->current_epoch->epoch_size));
2579 kfree(tconn->current_epoch);
2580
2581 idr_destroy(&tconn->volumes);
2582
2583 free_cpumask_var(tconn->cpu_mask);
2584 drbd_free_socket(&tconn->meta);
2585 drbd_free_socket(&tconn->data);
2586 kfree(tconn->name);
2587 kfree(tconn->int_dig_in);
2588 kfree(tconn->int_dig_vv);
2589 kfree(tconn);
2590}
2591
2592int init_submitter(struct drbd_conf *mdev)
2593{
2594
2595
2596 mdev->submit.wq = alloc_workqueue("drbd%u_submit",
2597 WQ_UNBOUND | WQ_MEM_RECLAIM, 1, mdev->minor);
2598 if (!mdev->submit.wq)
2599 return -ENOMEM;
2600
2601 INIT_WORK(&mdev->submit.worker, do_submit);
2602 spin_lock_init(&mdev->submit.lock);
2603 INIT_LIST_HEAD(&mdev->submit.writes);
2604 return 0;
2605}
2606
2607enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr)
2608{
2609 struct drbd_conf *mdev;
2610 struct gendisk *disk;
2611 struct request_queue *q;
2612 int vnr_got = vnr;
2613 int minor_got = minor;
2614 enum drbd_ret_code err = ERR_NOMEM;
2615
2616 mdev = minor_to_mdev(minor);
2617 if (mdev)
2618 return ERR_MINOR_EXISTS;
2619
2620
2621 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
2622 if (!mdev)
2623 return ERR_NOMEM;
2624
2625 kref_get(&tconn->kref);
2626 mdev->tconn = tconn;
2627
2628 mdev->minor = minor;
2629 mdev->vnr = vnr;
2630
2631 drbd_init_set_defaults(mdev);
2632
2633 q = blk_alloc_queue(GFP_KERNEL);
2634 if (!q)
2635 goto out_no_q;
2636 mdev->rq_queue = q;
2637 q->queuedata = mdev;
2638
2639 disk = alloc_disk(1);
2640 if (!disk)
2641 goto out_no_disk;
2642 mdev->vdisk = disk;
2643
2644 set_disk_ro(disk, true);
2645
2646 disk->queue = q;
2647 disk->major = DRBD_MAJOR;
2648 disk->first_minor = minor;
2649 disk->fops = &drbd_ops;
2650 sprintf(disk->disk_name, "drbd%d", minor);
2651 disk->private_data = mdev;
2652
2653 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
2654
2655 mdev->this_bdev->bd_contains = mdev->this_bdev;
2656
2657 q->backing_dev_info.congested_fn = drbd_congested;
2658 q->backing_dev_info.congested_data = mdev;
2659
2660 blk_queue_make_request(q, drbd_make_request);
2661 blk_queue_flush(q, REQ_FLUSH | REQ_FUA);
2662
2663
2664 blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
2665 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
2666 blk_queue_merge_bvec(q, drbd_merge_bvec);
2667 q->queue_lock = &mdev->tconn->req_lock;
2668
2669 mdev->md_io_page = alloc_page(GFP_KERNEL);
2670 if (!mdev->md_io_page)
2671 goto out_no_io_page;
2672
2673 if (drbd_bm_init(mdev))
2674 goto out_no_bitmap;
2675 mdev->read_requests = RB_ROOT;
2676 mdev->write_requests = RB_ROOT;
2677
2678 minor_got = idr_alloc(&minors, mdev, minor, minor + 1, GFP_KERNEL);
2679 if (minor_got < 0) {
2680 if (minor_got == -ENOSPC) {
2681 err = ERR_MINOR_EXISTS;
2682 drbd_msg_put_info("requested minor exists already");
2683 }
2684 goto out_no_minor_idr;
2685 }
2686
2687 vnr_got = idr_alloc(&tconn->volumes, mdev, vnr, vnr + 1, GFP_KERNEL);
2688 if (vnr_got < 0) {
2689 if (vnr_got == -ENOSPC) {
2690 err = ERR_INVALID_REQUEST;
2691 drbd_msg_put_info("requested volume exists already");
2692 }
2693 goto out_idr_remove_minor;
2694 }
2695
2696 if (init_submitter(mdev)) {
2697 err = ERR_NOMEM;
2698 drbd_msg_put_info("unable to create submit workqueue");
2699 goto out_idr_remove_vol;
2700 }
2701
2702 add_disk(disk);
2703 kref_init(&mdev->kref);
2704
2705
2706 mdev->state.conn = tconn->cstate;
2707 if (mdev->state.conn == C_WF_REPORT_PARAMS)
2708 drbd_connected(mdev);
2709
2710 return NO_ERROR;
2711
2712out_idr_remove_vol:
2713 idr_remove(&tconn->volumes, vnr_got);
2714out_idr_remove_minor:
2715 idr_remove(&minors, minor_got);
2716 synchronize_rcu();
2717out_no_minor_idr:
2718 drbd_bm_cleanup(mdev);
2719out_no_bitmap:
2720 __free_page(mdev->md_io_page);
2721out_no_io_page:
2722 put_disk(disk);
2723out_no_disk:
2724 blk_cleanup_queue(q);
2725out_no_q:
2726 kfree(mdev);
2727 kref_put(&tconn->kref, &conn_destroy);
2728 return err;
2729}
2730
2731int __init drbd_init(void)
2732{
2733 int err;
2734
2735 if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {
2736 printk(KERN_ERR
2737 "drbd: invalid minor_count (%d)\n", minor_count);
2738#ifdef MODULE
2739 return -EINVAL;
2740#else
2741 minor_count = DRBD_MINOR_COUNT_DEF;
2742#endif
2743 }
2744
2745 err = register_blkdev(DRBD_MAJOR, "drbd");
2746 if (err) {
2747 printk(KERN_ERR
2748 "drbd: unable to register block device major %d\n",
2749 DRBD_MAJOR);
2750 return err;
2751 }
2752
2753 err = drbd_genl_register();
2754 if (err) {
2755 printk(KERN_ERR "drbd: unable to register generic netlink family\n");
2756 goto fail;
2757 }
2758
2759
2760 register_reboot_notifier(&drbd_notifier);
2761
2762
2763
2764
2765 init_waitqueue_head(&drbd_pp_wait);
2766
2767 drbd_proc = NULL;
2768 idr_init(&minors);
2769
2770 err = drbd_create_mempools();
2771 if (err)
2772 goto fail;
2773
2774 err = -ENOMEM;
2775 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
2776 if (!drbd_proc) {
2777 printk(KERN_ERR "drbd: unable to register proc file\n");
2778 goto fail;
2779 }
2780
2781 rwlock_init(&global_state_lock);
2782 INIT_LIST_HEAD(&drbd_tconns);
2783
2784 retry.wq = create_singlethread_workqueue("drbd-reissue");
2785 if (!retry.wq) {
2786 printk(KERN_ERR "drbd: unable to create retry workqueue\n");
2787 goto fail;
2788 }
2789 INIT_WORK(&retry.worker, do_retry);
2790 spin_lock_init(&retry.lock);
2791 INIT_LIST_HEAD(&retry.writes);
2792
2793 printk(KERN_INFO "drbd: initialized. "
2794 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
2795 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
2796 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
2797 printk(KERN_INFO "drbd: registered as block device major %d\n",
2798 DRBD_MAJOR);
2799
2800 return 0;
2801
2802fail:
2803 drbd_cleanup();
2804 if (err == -ENOMEM)
2805 printk(KERN_ERR "drbd: ran out of memory\n");
2806 else
2807 printk(KERN_ERR "drbd: initialization failure\n");
2808 return err;
2809}
2810
2811void drbd_free_bc(struct drbd_backing_dev *ldev)
2812{
2813 if (ldev == NULL)
2814 return;
2815
2816 blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2817 blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2818
2819 kfree(ldev->disk_conf);
2820 kfree(ldev);
2821}
2822
2823void drbd_free_sock(struct drbd_tconn *tconn)
2824{
2825 if (tconn->data.socket) {
2826 mutex_lock(&tconn->data.mutex);
2827 kernel_sock_shutdown(tconn->data.socket, SHUT_RDWR);
2828 sock_release(tconn->data.socket);
2829 tconn->data.socket = NULL;
2830 mutex_unlock(&tconn->data.mutex);
2831 }
2832 if (tconn->meta.socket) {
2833 mutex_lock(&tconn->meta.mutex);
2834 kernel_sock_shutdown(tconn->meta.socket, SHUT_RDWR);
2835 sock_release(tconn->meta.socket);
2836 tconn->meta.socket = NULL;
2837 mutex_unlock(&tconn->meta.mutex);
2838 }
2839}
2840
2841
2842
2843void conn_md_sync(struct drbd_tconn *tconn)
2844{
2845 struct drbd_conf *mdev;
2846 int vnr;
2847
2848 rcu_read_lock();
2849 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
2850 kref_get(&mdev->kref);
2851 rcu_read_unlock();
2852 drbd_md_sync(mdev);
2853 kref_put(&mdev->kref, &drbd_minor_destroy);
2854 rcu_read_lock();
2855 }
2856 rcu_read_unlock();
2857}
2858
2859
2860struct meta_data_on_disk {
2861 u64 la_size_sect;
2862 u64 uuid[UI_SIZE];
2863 u64 device_uuid;
2864 u64 reserved_u64_1;
2865 u32 flags;
2866 u32 magic;
2867 u32 md_size_sect;
2868 u32 al_offset;
2869 u32 al_nr_extents;
2870
2871 u32 bm_offset;
2872 u32 bm_bytes_per_bit;
2873 u32 la_peer_max_bio_size;
2874
2875
2876 u32 al_stripes;
2877 u32 al_stripe_size_4k;
2878
2879 u8 reserved_u8[4096 - (7*8 + 10*4)];
2880} __packed;
2881
2882
2883
2884void drbd_md_write(struct drbd_conf *mdev, void *b)
2885{
2886 struct meta_data_on_disk *buffer = b;
2887 sector_t sector;
2888 int i;
2889
2890 memset(buffer, 0, sizeof(*buffer));
2891
2892 buffer->la_size_sect = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
2893 for (i = UI_CURRENT; i < UI_SIZE; i++)
2894 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
2895 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
2896 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC_84_UNCLEAN);
2897
2898 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
2899 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
2900 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
2901 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
2902 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
2903
2904 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
2905 buffer->la_peer_max_bio_size = cpu_to_be32(mdev->peer_max_bio_size);
2906
2907 buffer->al_stripes = cpu_to_be32(mdev->ldev->md.al_stripes);
2908 buffer->al_stripe_size_4k = cpu_to_be32(mdev->ldev->md.al_stripe_size_4k);
2909
2910 D_ASSERT(drbd_md_ss(mdev->ldev) == mdev->ldev->md.md_offset);
2911 sector = mdev->ldev->md.md_offset;
2912
2913 if (drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
2914
2915 dev_err(DEV, "meta data update failed!\n");
2916 drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
2917 }
2918}
2919
2920
2921
2922
2923
2924void drbd_md_sync(struct drbd_conf *mdev)
2925{
2926 struct meta_data_on_disk *buffer;
2927
2928
2929 BUILD_BUG_ON(UI_SIZE != 4);
2930 BUILD_BUG_ON(sizeof(struct meta_data_on_disk) != 4096);
2931
2932 del_timer(&mdev->md_sync_timer);
2933
2934 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
2935 return;
2936
2937
2938
2939 if (!get_ldev_if_state(mdev, D_FAILED))
2940 return;
2941
2942 buffer = drbd_md_get_buffer(mdev);
2943 if (!buffer)
2944 goto out;
2945
2946 drbd_md_write(mdev, buffer);
2947
2948
2949
2950 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
2951
2952 drbd_md_put_buffer(mdev);
2953out:
2954 put_ldev(mdev);
2955}
2956
2957static int check_activity_log_stripe_size(struct drbd_conf *mdev,
2958 struct meta_data_on_disk *on_disk,
2959 struct drbd_md *in_core)
2960{
2961 u32 al_stripes = be32_to_cpu(on_disk->al_stripes);
2962 u32 al_stripe_size_4k = be32_to_cpu(on_disk->al_stripe_size_4k);
2963 u64 al_size_4k;
2964
2965
2966 if (al_stripes == 0 && al_stripe_size_4k == 0) {
2967 al_stripes = 1;
2968 al_stripe_size_4k = MD_32kB_SECT/8;
2969 }
2970
2971
2972
2973
2974 if (al_stripes == 0 || al_stripe_size_4k == 0)
2975 goto err;
2976
2977 al_size_4k = (u64)al_stripes * al_stripe_size_4k;
2978
2979
2980
2981
2982
2983 if (al_size_4k > (16 * 1024 * 1024/4))
2984 goto err;
2985
2986
2987
2988 if (al_size_4k < MD_32kB_SECT/8)
2989 goto err;
2990
2991 in_core->al_stripe_size_4k = al_stripe_size_4k;
2992 in_core->al_stripes = al_stripes;
2993 in_core->al_size_4k = al_size_4k;
2994
2995 return 0;
2996err:
2997 dev_err(DEV, "invalid activity log striping: al_stripes=%u, al_stripe_size_4k=%u\n",
2998 al_stripes, al_stripe_size_4k);
2999 return -EINVAL;
3000}
3001
3002static int check_offsets_and_sizes(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
3003{
3004 sector_t capacity = drbd_get_capacity(bdev->md_bdev);
3005 struct drbd_md *in_core = &bdev->md;
3006 s32 on_disk_al_sect;
3007 s32 on_disk_bm_sect;
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017 if (in_core->al_offset < 0) {
3018 if (in_core->bm_offset > in_core->al_offset)
3019 goto err;
3020 on_disk_al_sect = -in_core->al_offset;
3021 on_disk_bm_sect = in_core->al_offset - in_core->bm_offset;
3022 } else {
3023 if (in_core->al_offset != MD_4kB_SECT)
3024 goto err;
3025 if (in_core->bm_offset < in_core->al_offset + in_core->al_size_4k * MD_4kB_SECT)
3026 goto err;
3027
3028 on_disk_al_sect = in_core->bm_offset - MD_4kB_SECT;
3029 on_disk_bm_sect = in_core->md_size_sect - in_core->bm_offset;
3030 }
3031
3032
3033 if (in_core->meta_dev_idx >= 0) {
3034 if (in_core->md_size_sect != MD_128MB_SECT
3035 || in_core->al_offset != MD_4kB_SECT
3036 || in_core->bm_offset != MD_4kB_SECT + MD_32kB_SECT
3037 || in_core->al_stripes != 1
3038 || in_core->al_stripe_size_4k != MD_32kB_SECT/8)
3039 goto err;
3040 }
3041
3042 if (capacity < in_core->md_size_sect)
3043 goto err;
3044 if (capacity - in_core->md_size_sect < drbd_md_first_sector(bdev))
3045 goto err;
3046
3047
3048 if ((on_disk_al_sect & 7) || (on_disk_al_sect < MD_32kB_SECT))
3049 goto err;
3050
3051
3052
3053 if (on_disk_al_sect != in_core->al_size_4k * MD_4kB_SECT)
3054 goto err;
3055
3056
3057 if (in_core->bm_offset & 7)
3058 goto err;
3059
3060
3061
3062
3063 if (on_disk_bm_sect < (in_core->la_size_sect+7)/MD_4kB_SECT/8/512)
3064 goto err;
3065
3066 return 0;
3067
3068err:
3069 dev_err(DEV, "meta data offsets don't make sense: idx=%d "
3070 "al_s=%u, al_sz4k=%u, al_offset=%d, bm_offset=%d, "
3071 "md_size_sect=%u, la_size=%llu, md_capacity=%llu\n",
3072 in_core->meta_dev_idx,
3073 in_core->al_stripes, in_core->al_stripe_size_4k,
3074 in_core->al_offset, in_core->bm_offset, in_core->md_size_sect,
3075 (unsigned long long)in_core->la_size_sect,
3076 (unsigned long long)capacity);
3077
3078 return -EINVAL;
3079}
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
3094{
3095 struct meta_data_on_disk *buffer;
3096 u32 magic, flags;
3097 int i, rv = NO_ERROR;
3098
3099 if (mdev->state.disk != D_DISKLESS)
3100 return ERR_DISK_CONFIGURED;
3101
3102 buffer = drbd_md_get_buffer(mdev);
3103 if (!buffer)
3104 return ERR_NOMEM;
3105
3106
3107
3108 bdev->md.meta_dev_idx = bdev->disk_conf->meta_dev_idx;
3109 bdev->md.md_offset = drbd_md_ss(bdev);
3110
3111 if (drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
3112
3113
3114 dev_err(DEV, "Error while reading metadata.\n");
3115 rv = ERR_IO_MD_DISK;
3116 goto err;
3117 }
3118
3119 magic = be32_to_cpu(buffer->magic);
3120 flags = be32_to_cpu(buffer->flags);
3121 if (magic == DRBD_MD_MAGIC_84_UNCLEAN ||
3122 (magic == DRBD_MD_MAGIC_08 && !(flags & MDF_AL_CLEAN))) {
3123
3124 dev_err(DEV, "Found unclean meta data. Did you \"drbdadm apply-al\"?\n");
3125 rv = ERR_MD_UNCLEAN;
3126 goto err;
3127 }
3128
3129 rv = ERR_MD_INVALID;
3130 if (magic != DRBD_MD_MAGIC_08) {
3131 if (magic == DRBD_MD_MAGIC_07)
3132 dev_err(DEV, "Found old (0.7) meta data magic. Did you \"drbdadm create-md\"?\n");
3133 else
3134 dev_err(DEV, "Meta data magic not found. Did you \"drbdadm create-md\"?\n");
3135 goto err;
3136 }
3137
3138 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
3139 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
3140 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
3141 goto err;
3142 }
3143
3144
3145
3146 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size_sect);
3147 for (i = UI_CURRENT; i < UI_SIZE; i++)
3148 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
3149 bdev->md.flags = be32_to_cpu(buffer->flags);
3150 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
3151
3152 bdev->md.md_size_sect = be32_to_cpu(buffer->md_size_sect);
3153 bdev->md.al_offset = be32_to_cpu(buffer->al_offset);
3154 bdev->md.bm_offset = be32_to_cpu(buffer->bm_offset);
3155
3156 if (check_activity_log_stripe_size(mdev, buffer, &bdev->md))
3157 goto err;
3158 if (check_offsets_and_sizes(mdev, bdev))
3159 goto err;
3160
3161 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
3162 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
3163 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
3164 goto err;
3165 }
3166 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
3167 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
3168 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
3169 goto err;
3170 }
3171
3172 rv = NO_ERROR;
3173
3174 spin_lock_irq(&mdev->tconn->req_lock);
3175 if (mdev->state.conn < C_CONNECTED) {
3176 unsigned int peer;
3177 peer = be32_to_cpu(buffer->la_peer_max_bio_size);
3178 peer = max(peer, DRBD_MAX_BIO_SIZE_SAFE);
3179 mdev->peer_max_bio_size = peer;
3180 }
3181 spin_unlock_irq(&mdev->tconn->req_lock);
3182
3183 err:
3184 drbd_md_put_buffer(mdev);
3185
3186 return rv;
3187}
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197#ifdef DEBUG
3198void drbd_md_mark_dirty_(struct drbd_conf *mdev, unsigned int line, const char *func)
3199{
3200 if (!test_and_set_bit(MD_DIRTY, &mdev->flags)) {
3201 mod_timer(&mdev->md_sync_timer, jiffies + HZ);
3202 mdev->last_md_mark_dirty.line = line;
3203 mdev->last_md_mark_dirty.func = func;
3204 }
3205}
3206#else
3207void drbd_md_mark_dirty(struct drbd_conf *mdev)
3208{
3209 if (!test_and_set_bit(MD_DIRTY, &mdev->flags))
3210 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
3211}
3212#endif
3213
3214void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
3215{
3216 int i;
3217
3218 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
3219 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
3220}
3221
3222void __drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3223{
3224 if (idx == UI_CURRENT) {
3225 if (mdev->state.role == R_PRIMARY)
3226 val |= 1;
3227 else
3228 val &= ~((u64)1);
3229
3230 drbd_set_ed_uuid(mdev, val);
3231 }
3232
3233 mdev->ldev->md.uuid[idx] = val;
3234 drbd_md_mark_dirty(mdev);
3235}
3236
3237void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3238{
3239 unsigned long flags;
3240 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
3241 __drbd_uuid_set(mdev, idx, val);
3242 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
3243}
3244
3245void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3246{
3247 unsigned long flags;
3248 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
3249 if (mdev->ldev->md.uuid[idx]) {
3250 drbd_uuid_move_history(mdev);
3251 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
3252 }
3253 __drbd_uuid_set(mdev, idx, val);
3254 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
3255}
3256
3257
3258
3259
3260
3261
3262
3263
3264void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
3265{
3266 u64 val;
3267 unsigned long long bm_uuid;
3268
3269 get_random_bytes(&val, sizeof(u64));
3270
3271 spin_lock_irq(&mdev->ldev->md.uuid_lock);
3272 bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
3273
3274 if (bm_uuid)
3275 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
3276
3277 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
3278 __drbd_uuid_set(mdev, UI_CURRENT, val);
3279 spin_unlock_irq(&mdev->ldev->md.uuid_lock);
3280
3281 drbd_print_uuids(mdev, "new current UUID");
3282
3283 drbd_md_sync(mdev);
3284}
3285
3286void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
3287{
3288 unsigned long flags;
3289 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
3290 return;
3291
3292 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
3293 if (val == 0) {
3294 drbd_uuid_move_history(mdev);
3295 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
3296 mdev->ldev->md.uuid[UI_BITMAP] = 0;
3297 } else {
3298 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
3299 if (bm_uuid)
3300 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
3301
3302 mdev->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);
3303 }
3304 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
3305
3306 drbd_md_mark_dirty(mdev);
3307}
3308
3309
3310
3311
3312
3313
3314
3315int drbd_bmio_set_n_write(struct drbd_conf *mdev)
3316{
3317 int rv = -EIO;
3318
3319 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3320 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3321 drbd_md_sync(mdev);
3322 drbd_bm_set_all(mdev);
3323
3324 rv = drbd_bm_write(mdev);
3325
3326 if (!rv) {
3327 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
3328 drbd_md_sync(mdev);
3329 }
3330
3331 put_ldev(mdev);
3332 }
3333
3334 return rv;
3335}
3336
3337
3338
3339
3340
3341
3342
3343int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
3344{
3345 int rv = -EIO;
3346
3347 drbd_resume_al(mdev);
3348 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3349 drbd_bm_clear_all(mdev);
3350 rv = drbd_bm_write(mdev);
3351 put_ldev(mdev);
3352 }
3353
3354 return rv;
3355}
3356
3357static int w_bitmap_io(struct drbd_work *w, int unused)
3358{
3359 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
3360 struct drbd_conf *mdev = w->mdev;
3361 int rv = -EIO;
3362
3363 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
3364
3365 if (get_ldev(mdev)) {
3366 drbd_bm_lock(mdev, work->why, work->flags);
3367 rv = work->io_fn(mdev);
3368 drbd_bm_unlock(mdev);
3369 put_ldev(mdev);
3370 }
3371
3372 clear_bit_unlock(BITMAP_IO, &mdev->flags);
3373 wake_up(&mdev->misc_wait);
3374
3375 if (work->done)
3376 work->done(mdev, rv);
3377
3378 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
3379 work->why = NULL;
3380 work->flags = 0;
3381
3382 return 0;
3383}
3384
3385void drbd_ldev_destroy(struct drbd_conf *mdev)
3386{
3387 lc_destroy(mdev->resync);
3388 mdev->resync = NULL;
3389 lc_destroy(mdev->act_log);
3390 mdev->act_log = NULL;
3391 __no_warn(local,
3392 drbd_free_bc(mdev->ldev);
3393 mdev->ldev = NULL;);
3394
3395 clear_bit(GO_DISKLESS, &mdev->flags);
3396}
3397
3398static int w_go_diskless(struct drbd_work *w, int unused)
3399{
3400 struct drbd_conf *mdev = w->mdev;
3401
3402 D_ASSERT(mdev->state.disk == D_FAILED);
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421 if (mdev->bitmap && mdev->ldev) {
3422
3423
3424
3425
3426 if (drbd_bitmap_io_from_worker(mdev, drbd_bm_write,
3427 "detach", BM_LOCKED_TEST_ALLOWED)) {
3428 if (test_bit(WAS_READ_ERROR, &mdev->flags)) {
3429 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3430 drbd_md_sync(mdev);
3431 }
3432 }
3433 }
3434
3435 drbd_force_state(mdev, NS(disk, D_DISKLESS));
3436 return 0;
3437}
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451void drbd_queue_bitmap_io(struct drbd_conf *mdev,
3452 int (*io_fn)(struct drbd_conf *),
3453 void (*done)(struct drbd_conf *, int),
3454 char *why, enum bm_flag flags)
3455{
3456 D_ASSERT(current == mdev->tconn->worker.task);
3457
3458 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
3459 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
3460 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
3461 if (mdev->bm_io_work.why)
3462 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
3463 why, mdev->bm_io_work.why);
3464
3465 mdev->bm_io_work.io_fn = io_fn;
3466 mdev->bm_io_work.done = done;
3467 mdev->bm_io_work.why = why;
3468 mdev->bm_io_work.flags = flags;
3469
3470 spin_lock_irq(&mdev->tconn->req_lock);
3471 set_bit(BITMAP_IO, &mdev->flags);
3472 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
3473 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
3474 drbd_queue_work(&mdev->tconn->sender_work, &mdev->bm_io_work.w);
3475 }
3476 spin_unlock_irq(&mdev->tconn->req_lock);
3477}
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *),
3489 char *why, enum bm_flag flags)
3490{
3491 int rv;
3492
3493 D_ASSERT(current != mdev->tconn->worker.task);
3494
3495 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3496 drbd_suspend_io(mdev);
3497
3498 drbd_bm_lock(mdev, why, flags);
3499 rv = io_fn(mdev);
3500 drbd_bm_unlock(mdev);
3501
3502 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3503 drbd_resume_io(mdev);
3504
3505 return rv;
3506}
3507
3508void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3509{
3510 if ((mdev->ldev->md.flags & flag) != flag) {
3511 drbd_md_mark_dirty(mdev);
3512 mdev->ldev->md.flags |= flag;
3513 }
3514}
3515
3516void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3517{
3518 if ((mdev->ldev->md.flags & flag) != 0) {
3519 drbd_md_mark_dirty(mdev);
3520 mdev->ldev->md.flags &= ~flag;
3521 }
3522}
3523int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3524{
3525 return (bdev->md.flags & flag) != 0;
3526}
3527
3528static void md_sync_timer_fn(unsigned long data)
3529{
3530 struct drbd_conf *mdev = (struct drbd_conf *) data;
3531
3532
3533 if (list_empty(&mdev->md_sync_work.list))
3534 drbd_queue_work_front(&mdev->tconn->sender_work, &mdev->md_sync_work);
3535}
3536
3537static int w_md_sync(struct drbd_work *w, int unused)
3538{
3539 struct drbd_conf *mdev = w->mdev;
3540
3541 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
3542#ifdef DEBUG
3543 dev_warn(DEV, "last md_mark_dirty: %s:%u\n",
3544 mdev->last_md_mark_dirty.func, mdev->last_md_mark_dirty.line);
3545#endif
3546 drbd_md_sync(mdev);
3547 return 0;
3548}
3549
3550const char *cmdname(enum drbd_packet cmd)
3551{
3552
3553
3554
3555 static const char *cmdnames[] = {
3556 [P_DATA] = "Data",
3557 [P_DATA_REPLY] = "DataReply",
3558 [P_RS_DATA_REPLY] = "RSDataReply",
3559 [P_BARRIER] = "Barrier",
3560 [P_BITMAP] = "ReportBitMap",
3561 [P_BECOME_SYNC_TARGET] = "BecomeSyncTarget",
3562 [P_BECOME_SYNC_SOURCE] = "BecomeSyncSource",
3563 [P_UNPLUG_REMOTE] = "UnplugRemote",
3564 [P_DATA_REQUEST] = "DataRequest",
3565 [P_RS_DATA_REQUEST] = "RSDataRequest",
3566 [P_SYNC_PARAM] = "SyncParam",
3567 [P_SYNC_PARAM89] = "SyncParam89",
3568 [P_PROTOCOL] = "ReportProtocol",
3569 [P_UUIDS] = "ReportUUIDs",
3570 [P_SIZES] = "ReportSizes",
3571 [P_STATE] = "ReportState",
3572 [P_SYNC_UUID] = "ReportSyncUUID",
3573 [P_AUTH_CHALLENGE] = "AuthChallenge",
3574 [P_AUTH_RESPONSE] = "AuthResponse",
3575 [P_PING] = "Ping",
3576 [P_PING_ACK] = "PingAck",
3577 [P_RECV_ACK] = "RecvAck",
3578 [P_WRITE_ACK] = "WriteAck",
3579 [P_RS_WRITE_ACK] = "RSWriteAck",
3580 [P_SUPERSEDED] = "Superseded",
3581 [P_NEG_ACK] = "NegAck",
3582 [P_NEG_DREPLY] = "NegDReply",
3583 [P_NEG_RS_DREPLY] = "NegRSDReply",
3584 [P_BARRIER_ACK] = "BarrierAck",
3585 [P_STATE_CHG_REQ] = "StateChgRequest",
3586 [P_STATE_CHG_REPLY] = "StateChgReply",
3587 [P_OV_REQUEST] = "OVRequest",
3588 [P_OV_REPLY] = "OVReply",
3589 [P_OV_RESULT] = "OVResult",
3590 [P_CSUM_RS_REQUEST] = "CsumRSRequest",
3591 [P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
3592 [P_COMPRESSED_BITMAP] = "CBitmap",
3593 [P_DELAY_PROBE] = "DelayProbe",
3594 [P_OUT_OF_SYNC] = "OutOfSync",
3595 [P_RETRY_WRITE] = "RetryWrite",
3596 [P_RS_CANCEL] = "RSCancel",
3597 [P_CONN_ST_CHG_REQ] = "conn_st_chg_req",
3598 [P_CONN_ST_CHG_REPLY] = "conn_st_chg_reply",
3599 [P_RETRY_WRITE] = "retry_write",
3600 [P_PROTOCOL_UPDATE] = "protocol_update",
3601
3602
3603
3604
3605
3606 };
3607
3608
3609 if (cmd == P_INITIAL_META)
3610 return "InitialMeta";
3611 if (cmd == P_INITIAL_DATA)
3612 return "InitialData";
3613 if (cmd == P_CONNECTION_FEATURES)
3614 return "ConnectionFeatures";
3615 if (cmd >= ARRAY_SIZE(cmdnames))
3616 return "Unknown";
3617 return cmdnames[cmd];
3618}
3619
3620
3621
3622
3623
3624
3625
3626int drbd_wait_misc(struct drbd_conf *mdev, struct drbd_interval *i)
3627{
3628 struct net_conf *nc;
3629 DEFINE_WAIT(wait);
3630 long timeout;
3631
3632 rcu_read_lock();
3633 nc = rcu_dereference(mdev->tconn->net_conf);
3634 if (!nc) {
3635 rcu_read_unlock();
3636 return -ETIMEDOUT;
3637 }
3638 timeout = nc->ko_count ? nc->timeout * HZ / 10 * nc->ko_count : MAX_SCHEDULE_TIMEOUT;
3639 rcu_read_unlock();
3640
3641
3642 i->waiting = true;
3643 prepare_to_wait(&mdev->misc_wait, &wait, TASK_INTERRUPTIBLE);
3644 spin_unlock_irq(&mdev->tconn->req_lock);
3645 timeout = schedule_timeout(timeout);
3646 finish_wait(&mdev->misc_wait, &wait);
3647 spin_lock_irq(&mdev->tconn->req_lock);
3648 if (!timeout || mdev->state.conn < C_CONNECTED)
3649 return -ETIMEDOUT;
3650 if (signal_pending(current))
3651 return -ERESTARTSYS;
3652 return 0;
3653}
3654
3655#ifdef CONFIG_DRBD_FAULT_INJECTION
3656
3657
3658struct fault_random_state {
3659 unsigned long state;
3660 unsigned long count;
3661};
3662
3663#define FAULT_RANDOM_MULT 39916801
3664#define FAULT_RANDOM_ADD 479001701
3665#define FAULT_RANDOM_REFRESH 10000
3666
3667
3668
3669
3670
3671static unsigned long
3672_drbd_fault_random(struct fault_random_state *rsp)
3673{
3674 long refresh;
3675
3676 if (!rsp->count--) {
3677 get_random_bytes(&refresh, sizeof(refresh));
3678 rsp->state += refresh;
3679 rsp->count = FAULT_RANDOM_REFRESH;
3680 }
3681 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3682 return swahw32(rsp->state);
3683}
3684
3685static char *
3686_drbd_fault_str(unsigned int type) {
3687 static char *_faults[] = {
3688 [DRBD_FAULT_MD_WR] = "Meta-data write",
3689 [DRBD_FAULT_MD_RD] = "Meta-data read",
3690 [DRBD_FAULT_RS_WR] = "Resync write",
3691 [DRBD_FAULT_RS_RD] = "Resync read",
3692 [DRBD_FAULT_DT_WR] = "Data write",
3693 [DRBD_FAULT_DT_RD] = "Data read",
3694 [DRBD_FAULT_DT_RA] = "Data read ahead",
3695 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
3696 [DRBD_FAULT_AL_EE] = "EE allocation",
3697 [DRBD_FAULT_RECEIVE] = "receive data corruption",
3698 };
3699
3700 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3701}
3702
3703unsigned int
3704_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3705{
3706 static struct fault_random_state rrs = {0, 0};
3707
3708 unsigned int ret = (
3709 (fault_devs == 0 ||
3710 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3711 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3712
3713 if (ret) {
3714 fault_count++;
3715
3716 if (__ratelimit(&drbd_ratelimit_state))
3717 dev_warn(DEV, "***Simulating %s failure\n",
3718 _drbd_fault_str(type));
3719 }
3720
3721 return ret;
3722}
3723#endif
3724
3725const char *drbd_buildtag(void)
3726{
3727
3728
3729
3730 static char buildtag[38] = "\0uilt-in";
3731
3732 if (buildtag[0] == 0) {
3733#ifdef MODULE
3734 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3735#else
3736 buildtag[0] = 'b';
3737#endif
3738 }
3739
3740 return buildtag;
3741}
3742
3743module_init(drbd_init)
3744module_exit(drbd_cleanup)
3745
3746EXPORT_SYMBOL(drbd_conn_str);
3747EXPORT_SYMBOL(drbd_role_str);
3748EXPORT_SYMBOL(drbd_disk_str);
3749EXPORT_SYMBOL(drbd_set_st_err_str);
3750