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