blob: 76faeab40c8f8b43d4d794b290edda616f444902 [file] [log] [blame]
Philipp Reisnerb411b362009-09-25 16:07:19 -07001/*
2 drbd.c
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 Thanks to Carter Burden, Bart Grantham and Gennadiy Nerubayev
11 from Logicworks, Inc. for making SDP replication support possible.
12
13 drbd is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
16 any later version.
17
18 drbd is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with drbd; see the file COPYING. If not, write to
25 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26
27 */
28
Philipp Reisnerb411b362009-09-25 16:07:19 -070029#include <linux/module.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070030#include <linux/drbd.h>
31#include <asm/uaccess.h>
32#include <asm/types.h>
33#include <net/sock.h>
34#include <linux/ctype.h>
Arnd Bergmann2a48fc02010-06-02 14:28:52 +020035#include <linux/mutex.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070036#include <linux/fs.h>
37#include <linux/file.h>
38#include <linux/proc_fs.h>
39#include <linux/init.h>
40#include <linux/mm.h>
41#include <linux/memcontrol.h>
42#include <linux/mm_inline.h>
43#include <linux/slab.h>
44#include <linux/random.h>
45#include <linux/reboot.h>
46#include <linux/notifier.h>
47#include <linux/kthread.h>
48
49#define __KERNEL_SYSCALLS__
50#include <linux/unistd.h>
51#include <linux/vmalloc.h>
52
53#include <linux/drbd_limits.h>
54#include "drbd_int.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070055#include "drbd_req.h" /* only for _req_mod in tl_release and tl_clear */
56
57#include "drbd_vli.h"
58
Arnd Bergmann2a48fc02010-06-02 14:28:52 +020059static DEFINE_MUTEX(drbd_main_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -070060int drbdd_init(struct drbd_thread *);
61int drbd_worker(struct drbd_thread *);
62int drbd_asender(struct drbd_thread *);
63
64int drbd_init(void);
65static int drbd_open(struct block_device *bdev, fmode_t mode);
66static int drbd_release(struct gendisk *gd, fmode_t mode);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +010067static int w_md_sync(struct drbd_work *w, int unused);
Philipp Reisnerb411b362009-09-25 16:07:19 -070068static void md_sync_timer_fn(unsigned long data);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +010069static int w_bitmap_io(struct drbd_work *w, int unused);
70static int w_go_diskless(struct drbd_work *w, int unused);
Philipp Reisnerb411b362009-09-25 16:07:19 -070071
Philipp Reisnerb411b362009-09-25 16:07:19 -070072MODULE_AUTHOR("Philipp Reisner <phil@linbit.com>, "
73 "Lars Ellenberg <lars@linbit.com>");
74MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);
75MODULE_VERSION(REL_VERSION);
76MODULE_LICENSE("GPL");
Philipp Reisner81a5d602011-02-22 19:53:16 -050077MODULE_PARM_DESC(minor_count, "Approximate number of drbd devices ("
Philipp Reisner2b8a90b2011-01-10 11:15:17 +010078 __stringify(DRBD_MINOR_COUNT_MIN) "-" __stringify(DRBD_MINOR_COUNT_MAX) ")");
Philipp Reisnerb411b362009-09-25 16:07:19 -070079MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);
80
81#include <linux/moduleparam.h>
82/* allow_open_on_secondary */
83MODULE_PARM_DESC(allow_oos, "DONT USE!");
84/* thanks to these macros, if compiled into the kernel (not-module),
85 * this becomes the boot parameter drbd.minor_count */
86module_param(minor_count, uint, 0444);
87module_param(disable_sendpage, bool, 0644);
88module_param(allow_oos, bool, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -070089module_param(proc_details, int, 0644);
90
91#ifdef CONFIG_DRBD_FAULT_INJECTION
92int enable_faults;
93int fault_rate;
94static int fault_count;
95int fault_devs;
96/* bitmap of enabled faults */
97module_param(enable_faults, int, 0664);
98/* fault rate % value - applies to all enabled faults */
99module_param(fault_rate, int, 0664);
100/* count of faults inserted */
101module_param(fault_count, int, 0664);
102/* bitmap of devices to insert faults on */
103module_param(fault_devs, int, 0644);
104#endif
105
106/* module parameter, defined */
Philipp Reisner2b8a90b2011-01-10 11:15:17 +0100107unsigned int minor_count = DRBD_MINOR_COUNT_DEF;
Rusty Russell90ab5ee2012-01-13 09:32:20 +1030108bool disable_sendpage;
109bool allow_oos;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700110int proc_details; /* Detail level in proc drbd*/
111
112/* Module parameter for setting the user mode helper program
113 * to run. Default is /sbin/drbdadm */
114char usermode_helper[80] = "/sbin/drbdadm";
115
116module_param_string(usermode_helper, usermode_helper, sizeof(usermode_helper), 0644);
117
118/* in 2.6.x, our device mapping and config info contains our virtual gendisks
119 * as member "struct gendisk *vdisk;"
120 */
Philipp Reisner81a5d602011-02-22 19:53:16 -0500121struct idr minors;
Philipp Reisner21114382011-01-19 12:26:59 +0100122struct list_head drbd_tconns; /* list of struct drbd_tconn */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700123
124struct kmem_cache *drbd_request_cache;
Andreas Gruenbacher6c852be2011-02-04 15:38:52 +0100125struct kmem_cache *drbd_ee_cache; /* peer requests */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700126struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */
127struct kmem_cache *drbd_al_ext_cache; /* activity log extents */
128mempool_t *drbd_request_mempool;
129mempool_t *drbd_ee_mempool;
Lars Ellenberg42818082011-02-23 12:39:46 +0100130mempool_t *drbd_md_io_page_pool;
Lars Ellenberg9476f392011-02-23 17:02:01 +0100131struct bio_set *drbd_md_io_bio_set;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700132
133/* I do not use a standard mempool, because:
134 1) I want to hand out the pre-allocated objects first.
135 2) I want to be able to interrupt sleeping allocation with a signal.
136 Note: This is a single linked list, the next pointer is the private
137 member of struct page.
138 */
139struct page *drbd_pp_pool;
140spinlock_t drbd_pp_lock;
141int drbd_pp_vacant;
142wait_queue_head_t drbd_pp_wait;
143
144DEFINE_RATELIMIT_STATE(drbd_ratelimit_state, 5 * HZ, 5);
145
Emese Revfy7d4e9d02009-12-14 00:59:30 +0100146static const struct block_device_operations drbd_ops = {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700147 .owner = THIS_MODULE,
148 .open = drbd_open,
149 .release = drbd_release,
150};
151
Lars Ellenberg9476f392011-02-23 17:02:01 +0100152struct bio *bio_alloc_drbd(gfp_t gfp_mask)
153{
Lars Ellenbergda4a75d2011-02-23 17:02:01 +0100154 struct bio *bio;
155
Lars Ellenberg9476f392011-02-23 17:02:01 +0100156 if (!drbd_md_io_bio_set)
157 return bio_alloc(gfp_mask, 1);
158
Lars Ellenbergda4a75d2011-02-23 17:02:01 +0100159 bio = bio_alloc_bioset(gfp_mask, 1, drbd_md_io_bio_set);
160 if (!bio)
161 return NULL;
Lars Ellenbergda4a75d2011-02-23 17:02:01 +0100162 return bio;
Lars Ellenberg9476f392011-02-23 17:02:01 +0100163}
164
Philipp Reisnerb411b362009-09-25 16:07:19 -0700165#ifdef __CHECKER__
166/* When checking with sparse, and this is an inline function, sparse will
167 give tons of false positives. When this is a real functions sparse works.
168 */
169int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins)
170{
171 int io_allowed;
172
173 atomic_inc(&mdev->local_cnt);
174 io_allowed = (mdev->state.disk >= mins);
175 if (!io_allowed) {
176 if (atomic_dec_and_test(&mdev->local_cnt))
177 wake_up(&mdev->misc_wait);
178 }
179 return io_allowed;
180}
181
182#endif
183
184/**
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100185 * tl_release() - mark as BARRIER_ACKED all requests in the corresponding transfer log epoch
186 * @tconn: DRBD connection.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700187 * @barrier_nr: Expected identifier of the DRBD write barrier packet.
188 * @set_size: Expected number of requests before that barrier.
189 *
190 * In case the passed barrier_nr or set_size does not match the oldest
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100191 * epoch of not yet barrier-acked requests, this function will cause a
192 * termination of the connection.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700193 */
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100194void tl_release(struct drbd_tconn *tconn, unsigned int barrier_nr,
195 unsigned int set_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700196{
Philipp Reisnerb411b362009-09-25 16:07:19 -0700197 struct drbd_request *r;
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100198 struct drbd_request *req = NULL;
199 int expect_epoch = 0;
200 int expect_size = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700201
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100202 spin_lock_irq(&tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700203
Philipp Reisner98683652012-11-09 14:18:43 +0100204 /* find oldest not yet barrier-acked write request,
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100205 * count writes in its epoch. */
206 list_for_each_entry(r, &tconn->transfer_log, tl_requests) {
Lars Ellenberga0d856d2012-01-24 17:19:42 +0100207 const unsigned s = r->rq_state;
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100208 if (!req) {
209 if (!(s & RQ_WRITE))
210 continue;
211 if (!(s & RQ_NET_MASK))
212 continue;
213 if (s & RQ_NET_DONE)
214 continue;
215 req = r;
216 expect_epoch = req->epoch;
217 expect_size ++;
218 } else {
219 if (r->epoch != expect_epoch)
220 break;
221 if (!(s & RQ_WRITE))
222 continue;
223 /* if (s & RQ_DONE): not expected */
224 /* if (!(s & RQ_NET_MASK)): not expected */
225 expect_size++;
226 }
227 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700228
229 /* first some paranoia code */
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100230 if (req == NULL) {
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100231 conn_err(tconn, "BAD! BarrierAck #%u received, but no epoch in tl!?\n",
232 barrier_nr);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700233 goto bail;
234 }
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100235 if (expect_epoch != barrier_nr) {
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100236 conn_err(tconn, "BAD! BarrierAck #%u received, expected #%u!\n",
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100237 barrier_nr, expect_epoch);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700238 goto bail;
239 }
240
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100241 if (expect_size != set_size) {
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100242 conn_err(tconn, "BAD! BarrierAck #%u received with n_writes=%u, expected n_writes=%u!\n",
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100243 barrier_nr, set_size, expect_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700244 goto bail;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700245 }
246
Philipp Reisner98683652012-11-09 14:18:43 +0100247 /* Clean up list of requests processed during current epoch. */
248 /* this extra list walk restart is paranoia,
249 * to catch requests being barrier-acked "unexpectedly".
250 * It usually should find the same req again, or some READ preceding it. */
251 list_for_each_entry(req, &tconn->transfer_log, tl_requests)
252 if (req->epoch == expect_epoch)
253 break;
254 list_for_each_entry_safe_from(req, r, &tconn->transfer_log, tl_requests) {
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100255 if (req->epoch != expect_epoch)
256 break;
257 _req_mod(req, BARRIER_ACKED);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700258 }
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100259 spin_unlock_irq(&tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700260
261 return;
262
263bail:
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100264 spin_unlock_irq(&tconn->req_lock);
265 conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700266}
267
Philipp Reisner617049a2010-12-22 12:48:31 +0100268
Philipp Reisner11b58e72010-05-12 17:08:26 +0200269/**
270 * _tl_restart() - Walks the transfer log, and applies an action to all requests
271 * @mdev: DRBD device.
272 * @what: The action/event to perform with all request objects
273 *
Andreas Gruenbacher8554df12011-01-25 15:37:43 +0100274 * @what might be one of CONNECTION_LOST_WHILE_PENDING, RESEND, FAIL_FROZEN_DISK_IO,
275 * RESTART_FROZEN_DISK_IO.
Philipp Reisner11b58e72010-05-12 17:08:26 +0200276 */
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100277/* must hold resource->req_lock */
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100278void _tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
Philipp Reisner11b58e72010-05-12 17:08:26 +0200279{
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100280 struct drbd_request *req, *r;
Philipp Reisner11b58e72010-05-12 17:08:26 +0200281
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100282 list_for_each_entry_safe(req, r, &tconn->transfer_log, tl_requests)
Philipp Reisner509fc012012-07-31 11:22:58 +0200283 _req_mod(req, what);
Philipp Reisner11b58e72010-05-12 17:08:26 +0200284}
285
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100286void tl_restart(struct drbd_tconn *tconn, enum drbd_req_event what)
287{
288 spin_lock_irq(&tconn->req_lock);
289 _tl_restart(tconn, what);
290 spin_unlock_irq(&tconn->req_lock);
Philipp Reisnercdfda632011-07-05 15:38:59 +0200291}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700292
293/**
294 * tl_clear() - Clears all requests and &struct drbd_tl_epoch objects out of the TL
295 * @mdev: DRBD device.
296 *
297 * This is called after the connection to the peer was lost. The storage covered
298 * by the requests on the transfer gets marked as our of sync. Called from the
299 * receiver thread and the worker thread.
300 */
Philipp Reisner2f5cdd02011-02-21 14:29:27 +0100301void tl_clear(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700302{
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100303 tl_restart(tconn, CONNECTION_LOST_WHILE_PENDING);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700304}
305
306/**
Philipp Reisnerfd2491f2011-07-18 16:25:15 +0200307 * tl_abort_disk_io() - Abort disk I/O for all requests for a certain mdev in the TL
308 * @mdev: DRBD device.
309 */
310void tl_abort_disk_io(struct drbd_conf *mdev)
311{
Philipp Reisnercdfda632011-07-05 15:38:59 +0200312 struct drbd_tconn *tconn = mdev->tconn;
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100313 struct drbd_request *req, *r;
Philipp Reisnerfd2491f2011-07-18 16:25:15 +0200314
Philipp Reisnercdfda632011-07-05 15:38:59 +0200315 spin_lock_irq(&tconn->req_lock);
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100316 list_for_each_entry_safe(req, r, &tconn->transfer_log, tl_requests) {
Philipp Reisnerfd2491f2011-07-18 16:25:15 +0200317 if (!(req->rq_state & RQ_LOCAL_PENDING))
318 continue;
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +0100319 if (req->w.mdev != mdev)
320 continue;
321 _req_mod(req, ABORT_DISK_IO);
Philipp Reisnerfd2491f2011-07-18 16:25:15 +0200322 }
Philipp Reisnercdfda632011-07-05 15:38:59 +0200323 spin_unlock_irq(&tconn->req_lock);
Philipp Reisnerfd2491f2011-07-18 16:25:15 +0200324}
325
Philipp Reisnerb411b362009-09-25 16:07:19 -0700326static int drbd_thread_setup(void *arg)
327{
328 struct drbd_thread *thi = (struct drbd_thread *) arg;
Philipp Reisner392c8802011-02-09 10:33:31 +0100329 struct drbd_tconn *tconn = thi->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700330 unsigned long flags;
331 int retval;
332
Philipp Reisnerf1b3a6e2011-02-08 15:35:58 +0100333 snprintf(current->comm, sizeof(current->comm), "drbd_%c_%s",
Philipp Reisner392c8802011-02-09 10:33:31 +0100334 thi->name[0], thi->tconn->name);
Philipp Reisnerf1b3a6e2011-02-08 15:35:58 +0100335
Philipp Reisnerb411b362009-09-25 16:07:19 -0700336restart:
337 retval = thi->function(thi);
338
339 spin_lock_irqsave(&thi->t_lock, flags);
340
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100341 /* if the receiver has been "EXITING", the last thing it did
Philipp Reisnerb411b362009-09-25 16:07:19 -0700342 * was set the conn state to "StandAlone",
343 * if now a re-connect request comes in, conn state goes C_UNCONNECTED,
344 * and receiver thread will be "started".
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100345 * drbd_thread_start needs to set "RESTARTING" in that case.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700346 * t_state check and assignment needs to be within the same spinlock,
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100347 * so either thread_start sees EXITING, and can remap to RESTARTING,
348 * or thread_start see NONE, and can proceed as normal.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700349 */
350
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100351 if (thi->t_state == RESTARTING) {
Philipp Reisner392c8802011-02-09 10:33:31 +0100352 conn_info(tconn, "Restarting %s thread\n", thi->name);
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100353 thi->t_state = RUNNING;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700354 spin_unlock_irqrestore(&thi->t_lock, flags);
355 goto restart;
356 }
357
358 thi->task = NULL;
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100359 thi->t_state = NONE;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700360 smp_mb();
Lars Ellenberg992d6e92011-05-02 11:47:18 +0200361 complete_all(&thi->stop);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700362 spin_unlock_irqrestore(&thi->t_lock, flags);
363
Philipp Reisner392c8802011-02-09 10:33:31 +0100364 conn_info(tconn, "Terminating %s\n", current->comm);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700365
366 /* Release mod reference taken when thread was started */
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200367
368 kref_put(&tconn->kref, &conn_destroy);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700369 module_put(THIS_MODULE);
370 return retval;
371}
372
Philipp Reisner392c8802011-02-09 10:33:31 +0100373static void drbd_thread_init(struct drbd_tconn *tconn, struct drbd_thread *thi,
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100374 int (*func) (struct drbd_thread *), char *name)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700375{
376 spin_lock_init(&thi->t_lock);
377 thi->task = NULL;
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100378 thi->t_state = NONE;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700379 thi->function = func;
Philipp Reisner392c8802011-02-09 10:33:31 +0100380 thi->tconn = tconn;
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100381 strncpy(thi->name, name, ARRAY_SIZE(thi->name));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700382}
383
384int drbd_thread_start(struct drbd_thread *thi)
385{
Philipp Reisner392c8802011-02-09 10:33:31 +0100386 struct drbd_tconn *tconn = thi->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700387 struct task_struct *nt;
388 unsigned long flags;
389
Philipp Reisnerb411b362009-09-25 16:07:19 -0700390 /* is used from state engine doing drbd_thread_stop_nowait,
391 * while holding the req lock irqsave */
392 spin_lock_irqsave(&thi->t_lock, flags);
393
394 switch (thi->t_state) {
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100395 case NONE:
Philipp Reisner392c8802011-02-09 10:33:31 +0100396 conn_info(tconn, "Starting %s thread (from %s [%d])\n",
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100397 thi->name, current->comm, current->pid);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700398
399 /* Get ref on module for thread - this is released when thread exits */
400 if (!try_module_get(THIS_MODULE)) {
Philipp Reisner392c8802011-02-09 10:33:31 +0100401 conn_err(tconn, "Failed to get module reference in drbd_thread_start\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700402 spin_unlock_irqrestore(&thi->t_lock, flags);
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100403 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700404 }
405
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200406 kref_get(&thi->tconn->kref);
407
Philipp Reisnerb411b362009-09-25 16:07:19 -0700408 init_completion(&thi->stop);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700409 thi->reset_cpu_mask = 1;
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100410 thi->t_state = RUNNING;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700411 spin_unlock_irqrestore(&thi->t_lock, flags);
412 flush_signals(current); /* otherw. may get -ERESTARTNOINTR */
413
414 nt = kthread_create(drbd_thread_setup, (void *) thi,
Philipp Reisner392c8802011-02-09 10:33:31 +0100415 "drbd_%c_%s", thi->name[0], thi->tconn->name);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700416
417 if (IS_ERR(nt)) {
Philipp Reisner392c8802011-02-09 10:33:31 +0100418 conn_err(tconn, "Couldn't start thread\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700419
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200420 kref_put(&tconn->kref, &conn_destroy);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700421 module_put(THIS_MODULE);
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100422 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700423 }
424 spin_lock_irqsave(&thi->t_lock, flags);
425 thi->task = nt;
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100426 thi->t_state = RUNNING;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700427 spin_unlock_irqrestore(&thi->t_lock, flags);
428 wake_up_process(nt);
429 break;
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100430 case EXITING:
431 thi->t_state = RESTARTING;
Philipp Reisner392c8802011-02-09 10:33:31 +0100432 conn_info(tconn, "Restarting %s thread (from %s [%d])\n",
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100433 thi->name, current->comm, current->pid);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700434 /* fall through */
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100435 case RUNNING:
436 case RESTARTING:
Philipp Reisnerb411b362009-09-25 16:07:19 -0700437 default:
438 spin_unlock_irqrestore(&thi->t_lock, flags);
439 break;
440 }
441
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100442 return true;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700443}
444
445
446void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait)
447{
448 unsigned long flags;
449
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100450 enum drbd_thread_state ns = restart ? RESTARTING : EXITING;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700451
452 /* may be called from state engine, holding the req lock irqsave */
453 spin_lock_irqsave(&thi->t_lock, flags);
454
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +0100455 if (thi->t_state == NONE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700456 spin_unlock_irqrestore(&thi->t_lock, flags);
457 if (restart)
458 drbd_thread_start(thi);
459 return;
460 }
461
462 if (thi->t_state != ns) {
463 if (thi->task == NULL) {
464 spin_unlock_irqrestore(&thi->t_lock, flags);
465 return;
466 }
467
468 thi->t_state = ns;
469 smp_mb();
470 init_completion(&thi->stop);
471 if (thi->task != current)
472 force_sig(DRBD_SIGKILL, thi->task);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700473 }
474
475 spin_unlock_irqrestore(&thi->t_lock, flags);
476
477 if (wait)
478 wait_for_completion(&thi->stop);
479}
480
Philipp Reisner392c8802011-02-09 10:33:31 +0100481static struct drbd_thread *drbd_task_to_thread(struct drbd_tconn *tconn, struct task_struct *task)
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100482{
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100483 struct drbd_thread *thi =
484 task == tconn->receiver.task ? &tconn->receiver :
485 task == tconn->asender.task ? &tconn->asender :
486 task == tconn->worker.task ? &tconn->worker : NULL;
487
488 return thi;
489}
490
Philipp Reisner392c8802011-02-09 10:33:31 +0100491char *drbd_task_to_thread_name(struct drbd_tconn *tconn, struct task_struct *task)
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100492{
Philipp Reisner392c8802011-02-09 10:33:31 +0100493 struct drbd_thread *thi = drbd_task_to_thread(tconn, task);
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100494 return thi ? thi->name : task->comm;
495}
496
Philipp Reisner80883192011-02-18 14:56:45 +0100497int conn_lowest_minor(struct drbd_tconn *tconn)
Philipp Reisner80822282011-02-08 12:46:30 +0100498{
Philipp Reisnere90285e2011-03-22 12:51:21 +0100499 struct drbd_conf *mdev;
Philipp Reisner695d08f2011-04-11 22:53:32 -0700500 int vnr = 0, m;
Philipp Reisner774b3052011-02-22 02:07:03 -0500501
Philipp Reisner695d08f2011-04-11 22:53:32 -0700502 rcu_read_lock();
Philipp Reisnere90285e2011-03-22 12:51:21 +0100503 mdev = idr_get_next(&tconn->volumes, &vnr);
Philipp Reisner695d08f2011-04-11 22:53:32 -0700504 m = mdev ? mdev_to_minor(mdev) : -1;
505 rcu_read_unlock();
506
507 return m;
Philipp Reisner80822282011-02-08 12:46:30 +0100508}
Philipp Reisner774b3052011-02-22 02:07:03 -0500509
Philipp Reisnerb411b362009-09-25 16:07:19 -0700510#ifdef CONFIG_SMP
511/**
512 * drbd_calc_cpu_mask() - Generate CPU masks, spread over all CPUs
513 * @mdev: DRBD device.
514 *
515 * Forces all threads of a device onto the same CPU. This is beneficial for
516 * DRBD's performance. May be overwritten by user's configuration.
517 */
Philipp Reisner80822282011-02-08 12:46:30 +0100518void drbd_calc_cpu_mask(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700519{
520 int ord, cpu;
521
522 /* user override. */
Philipp Reisner80822282011-02-08 12:46:30 +0100523 if (cpumask_weight(tconn->cpu_mask))
Philipp Reisnerb411b362009-09-25 16:07:19 -0700524 return;
525
Philipp Reisner80822282011-02-08 12:46:30 +0100526 ord = conn_lowest_minor(tconn) % cpumask_weight(cpu_online_mask);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700527 for_each_online_cpu(cpu) {
528 if (ord-- == 0) {
Philipp Reisner80822282011-02-08 12:46:30 +0100529 cpumask_set_cpu(cpu, tconn->cpu_mask);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700530 return;
531 }
532 }
533 /* should not be reached */
Philipp Reisner80822282011-02-08 12:46:30 +0100534 cpumask_setall(tconn->cpu_mask);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700535}
536
537/**
538 * drbd_thread_current_set_cpu() - modifies the cpu mask of the _current_ thread
539 * @mdev: DRBD device.
Philipp Reisnerbc31fe32011-02-07 11:14:38 +0100540 * @thi: drbd_thread object
Philipp Reisnerb411b362009-09-25 16:07:19 -0700541 *
542 * call in the "main loop" of _all_ threads, no need for any mutex, current won't die
543 * prematurely.
544 */
Philipp Reisner80822282011-02-08 12:46:30 +0100545void drbd_thread_current_set_cpu(struct drbd_thread *thi)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700546{
547 struct task_struct *p = current;
Philipp Reisnerbed879a2011-02-04 14:00:37 +0100548
Philipp Reisnerb411b362009-09-25 16:07:19 -0700549 if (!thi->reset_cpu_mask)
550 return;
551 thi->reset_cpu_mask = 0;
Philipp Reisner392c8802011-02-09 10:33:31 +0100552 set_cpus_allowed_ptr(p, thi->tconn->cpu_mask);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700553}
554#endif
555
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +0200556/**
557 * drbd_header_size - size of a packet header
558 *
559 * The header size is a multiple of 8, so any payload following the header is
560 * word aligned on 64-bit architectures. (The bitmap send and receive code
561 * relies on this.)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700562 */
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +0200563unsigned int drbd_header_size(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700564{
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +0200565 if (tconn->agreed_pro_version >= 100) {
566 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header100), 8));
567 return sizeof(struct p_header100);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700568 } else {
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +0200569 BUILD_BUG_ON(sizeof(struct p_header80) !=
570 sizeof(struct p_header95));
571 BUILD_BUG_ON(!IS_ALIGNED(sizeof(struct p_header80), 8));
572 return sizeof(struct p_header80);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700573 }
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +0200574}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700575
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200576static unsigned int prepare_header80(struct p_header80 *h, enum drbd_packet cmd, int size)
Philipp Reisnerfd340c12011-01-19 16:57:39 +0100577{
578 h->magic = cpu_to_be32(DRBD_MAGIC);
579 h->command = cpu_to_be16(cmd);
580 h->length = cpu_to_be16(size);
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200581 return sizeof(struct p_header80);
Philipp Reisnerfd340c12011-01-19 16:57:39 +0100582}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700583
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200584static unsigned int prepare_header95(struct p_header95 *h, enum drbd_packet cmd, int size)
Philipp Reisnerfd340c12011-01-19 16:57:39 +0100585{
586 h->magic = cpu_to_be16(DRBD_MAGIC_BIG);
587 h->command = cpu_to_be16(cmd);
Andreas Gruenbacherb55d84b2011-03-22 13:17:47 +0100588 h->length = cpu_to_be32(size);
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200589 return sizeof(struct p_header95);
Philipp Reisnerfd340c12011-01-19 16:57:39 +0100590}
591
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +0200592static unsigned int prepare_header100(struct p_header100 *h, enum drbd_packet cmd,
593 int size, int vnr)
Philipp Reisnerd38e7872011-02-07 15:32:04 +0100594{
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +0200595 h->magic = cpu_to_be32(DRBD_MAGIC_100);
596 h->volume = cpu_to_be16(vnr);
597 h->command = cpu_to_be16(cmd);
598 h->length = cpu_to_be32(size);
599 h->pad = 0;
600 return sizeof(struct p_header100);
601}
602
603static unsigned int prepare_header(struct drbd_tconn *tconn, int vnr,
604 void *buffer, enum drbd_packet cmd, int size)
605{
606 if (tconn->agreed_pro_version >= 100)
607 return prepare_header100(buffer, cmd, size, vnr);
608 else if (tconn->agreed_pro_version >= 95 &&
609 size > DRBD_MAX_SIZE_H80_PACKET)
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200610 return prepare_header95(buffer, cmd, size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700611 else
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200612 return prepare_header80(buffer, cmd, size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700613}
614
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200615static void *__conn_prepare_command(struct drbd_tconn *tconn,
616 struct drbd_socket *sock)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700617{
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200618 if (!sock->socket)
619 return NULL;
620 return sock->sbuf + drbd_header_size(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700621}
622
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200623void *conn_prepare_command(struct drbd_tconn *tconn, struct drbd_socket *sock)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700624{
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200625 void *p;
626
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200627 mutex_lock(&sock->mutex);
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200628 p = __conn_prepare_command(tconn, sock);
629 if (!p)
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200630 mutex_unlock(&sock->mutex);
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200631
632 return p;
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200633}
634
635void *drbd_prepare_command(struct drbd_conf *mdev, struct drbd_socket *sock)
636{
637 return conn_prepare_command(mdev->tconn, sock);
638}
639
640static int __send_command(struct drbd_tconn *tconn, int vnr,
641 struct drbd_socket *sock, enum drbd_packet cmd,
642 unsigned int header_size, void *data,
643 unsigned int size)
644{
645 int msg_flags;
646 int err;
647
648 /*
649 * Called with @data == NULL and the size of the data blocks in @size
650 * for commands that send data blocks. For those commands, omit the
651 * MSG_MORE flag: this will increase the likelihood that data blocks
652 * which are page aligned on the sender will end up page aligned on the
653 * receiver.
654 */
655 msg_flags = data ? MSG_MORE : 0;
656
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200657 header_size += prepare_header(tconn, vnr, sock->sbuf, cmd,
658 header_size + size);
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200659 err = drbd_send_all(tconn, sock->socket, sock->sbuf, header_size,
660 msg_flags);
661 if (data && !err)
662 err = drbd_send_all(tconn, sock->socket, data, size, 0);
663 return err;
664}
665
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200666static int __conn_send_command(struct drbd_tconn *tconn, struct drbd_socket *sock,
667 enum drbd_packet cmd, unsigned int header_size,
668 void *data, unsigned int size)
669{
670 return __send_command(tconn, 0, sock, cmd, header_size, data, size);
671}
672
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200673int conn_send_command(struct drbd_tconn *tconn, struct drbd_socket *sock,
674 enum drbd_packet cmd, unsigned int header_size,
675 void *data, unsigned int size)
676{
677 int err;
678
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200679 err = __conn_send_command(tconn, sock, cmd, header_size, data, size);
Andreas Gruenbacherdba58582011-03-29 16:55:40 +0200680 mutex_unlock(&sock->mutex);
681 return err;
682}
683
684int drbd_send_command(struct drbd_conf *mdev, struct drbd_socket *sock,
685 enum drbd_packet cmd, unsigned int header_size,
686 void *data, unsigned int size)
687{
688 int err;
689
690 err = __send_command(mdev->tconn, mdev->vnr, sock, cmd, header_size,
691 data, size);
692 mutex_unlock(&sock->mutex);
693 return err;
694}
695
Andreas Gruenbachere307f352011-03-22 10:55:48 +0100696int drbd_send_ping(struct drbd_tconn *tconn)
697{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200698 struct drbd_socket *sock;
699
700 sock = &tconn->meta;
701 if (!conn_prepare_command(tconn, sock))
702 return -EIO;
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200703 return conn_send_command(tconn, sock, P_PING, 0, NULL, 0);
Andreas Gruenbachere307f352011-03-22 10:55:48 +0100704}
705
706int drbd_send_ping_ack(struct drbd_tconn *tconn)
707{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200708 struct drbd_socket *sock;
709
710 sock = &tconn->meta;
711 if (!conn_prepare_command(tconn, sock))
712 return -EIO;
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200713 return conn_send_command(tconn, sock, P_PING_ACK, 0, NULL, 0);
Andreas Gruenbachere307f352011-03-22 10:55:48 +0100714}
715
Lars Ellenbergf3990022011-03-23 14:31:09 +0100716int drbd_send_sync_param(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700717{
Andreas Gruenbacher7c967152011-03-22 00:49:36 +0100718 struct drbd_socket *sock;
Philipp Reisner8e26f9c2010-07-06 17:25:54 +0200719 struct p_rs_param_95 *p;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200720 int size;
Philipp Reisner31890f42011-01-19 14:12:51 +0100721 const int apv = mdev->tconn->agreed_pro_version;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200722 enum drbd_packet cmd;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200723 struct net_conf *nc;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200724 struct disk_conf *dc;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200725
726 sock = &mdev->tconn->data;
727 p = drbd_prepare_command(mdev, sock);
728 if (!p)
729 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700730
Philipp Reisner44ed1672011-04-19 17:10:19 +0200731 rcu_read_lock();
732 nc = rcu_dereference(mdev->tconn->net_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700733
734 size = apv <= 87 ? sizeof(struct p_rs_param)
735 : apv == 88 ? sizeof(struct p_rs_param)
Philipp Reisner44ed1672011-04-19 17:10:19 +0200736 + strlen(nc->verify_alg) + 1
Philipp Reisner8e26f9c2010-07-06 17:25:54 +0200737 : apv <= 94 ? sizeof(struct p_rs_param_89)
738 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700739
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200740 cmd = apv >= 89 ? P_SYNC_PARAM89 : P_SYNC_PARAM;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700741
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200742 /* initialize verify_alg and csums_alg */
743 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700744
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200745 if (get_ldev(mdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200746 dc = rcu_dereference(mdev->ldev->disk_conf);
Andreas Gruenbacher6394b932011-05-11 14:29:52 +0200747 p->resync_rate = cpu_to_be32(dc->resync_rate);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200748 p->c_plan_ahead = cpu_to_be32(dc->c_plan_ahead);
749 p->c_delay_target = cpu_to_be32(dc->c_delay_target);
750 p->c_fill_target = cpu_to_be32(dc->c_fill_target);
751 p->c_max_rate = cpu_to_be32(dc->c_max_rate);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200752 put_ldev(mdev);
753 } else {
Andreas Gruenbacher6394b932011-05-11 14:29:52 +0200754 p->resync_rate = cpu_to_be32(DRBD_RESYNC_RATE_DEF);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200755 p->c_plan_ahead = cpu_to_be32(DRBD_C_PLAN_AHEAD_DEF);
756 p->c_delay_target = cpu_to_be32(DRBD_C_DELAY_TARGET_DEF);
757 p->c_fill_target = cpu_to_be32(DRBD_C_FILL_TARGET_DEF);
758 p->c_max_rate = cpu_to_be32(DRBD_C_MAX_RATE_DEF);
759 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700760
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200761 if (apv >= 88)
Philipp Reisner44ed1672011-04-19 17:10:19 +0200762 strcpy(p->verify_alg, nc->verify_alg);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200763 if (apv >= 89)
Philipp Reisner44ed1672011-04-19 17:10:19 +0200764 strcpy(p->csums_alg, nc->csums_alg);
765 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700766
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200767 return drbd_send_command(mdev, sock, cmd, size, NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700768}
769
Philipp Reisnerd659f2a2011-05-16 17:38:45 +0200770int __drbd_send_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700771{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200772 struct drbd_socket *sock;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700773 struct p_protocol *p;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200774 struct net_conf *nc;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200775 int size, cf;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700776
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200777 sock = &tconn->data;
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200778 p = __conn_prepare_command(tconn, sock);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200779 if (!p)
780 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700781
Philipp Reisner44ed1672011-04-19 17:10:19 +0200782 rcu_read_lock();
783 nc = rcu_dereference(tconn->net_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700784
Andreas Gruenbacher6dff2902011-06-28 14:18:12 +0200785 if (nc->tentative && tconn->agreed_pro_version < 92) {
Philipp Reisner44ed1672011-04-19 17:10:19 +0200786 rcu_read_unlock();
787 mutex_unlock(&sock->mutex);
788 conn_err(tconn, "--dry-run is not supported by peer");
789 return -EOPNOTSUPP;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +0100790 }
Philipp Reisner44ed1672011-04-19 17:10:19 +0200791
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200792 size = sizeof(*p);
Philipp Reisnerdc8228d2011-02-08 10:13:15 +0100793 if (tconn->agreed_pro_version >= 87)
Philipp Reisner44ed1672011-04-19 17:10:19 +0200794 size += strlen(nc->integrity_alg) + 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700795
Philipp Reisner44ed1672011-04-19 17:10:19 +0200796 p->protocol = cpu_to_be32(nc->wire_protocol);
797 p->after_sb_0p = cpu_to_be32(nc->after_sb_0p);
798 p->after_sb_1p = cpu_to_be32(nc->after_sb_1p);
799 p->after_sb_2p = cpu_to_be32(nc->after_sb_2p);
800 p->two_primaries = cpu_to_be32(nc->two_primaries);
Philipp Reisnercf14c2e2010-02-02 21:03:50 +0100801 cf = 0;
Andreas Gruenbacher6139f602011-05-06 20:00:02 +0200802 if (nc->discard_my_data)
803 cf |= CF_DISCARD_MY_DATA;
Andreas Gruenbacher6dff2902011-06-28 14:18:12 +0200804 if (nc->tentative)
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200805 cf |= CF_DRY_RUN;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +0100806 p->conn_flags = cpu_to_be32(cf);
807
Philipp Reisnerdc8228d2011-02-08 10:13:15 +0100808 if (tconn->agreed_pro_version >= 87)
Philipp Reisner44ed1672011-04-19 17:10:19 +0200809 strcpy(p->integrity_alg, nc->integrity_alg);
810 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700811
Philipp Reisnerd659f2a2011-05-16 17:38:45 +0200812 return __conn_send_command(tconn, sock, cmd, size, NULL, 0);
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200813}
814
815int drbd_send_protocol(struct drbd_tconn *tconn)
816{
817 int err;
818
819 mutex_lock(&tconn->data.mutex);
Philipp Reisnerd659f2a2011-05-16 17:38:45 +0200820 err = __drbd_send_protocol(tconn, P_PROTOCOL);
Andreas Gruenbachera7eb7bd2011-04-29 13:19:58 +0200821 mutex_unlock(&tconn->data.mutex);
822
823 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700824}
825
826int _drbd_send_uuids(struct drbd_conf *mdev, u64 uuid_flags)
827{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200828 struct drbd_socket *sock;
829 struct p_uuids *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700830 int i;
831
832 if (!get_ldev_if_state(mdev, D_NEGOTIATING))
Andreas Gruenbacher2ae5f952011-03-16 01:07:20 +0100833 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700834
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200835 sock = &mdev->tconn->data;
836 p = drbd_prepare_command(mdev, sock);
837 if (!p) {
838 put_ldev(mdev);
839 return -EIO;
840 }
Philipp Reisner9f2247b2012-08-16 14:25:58 +0200841 spin_lock_irq(&mdev->ldev->md.uuid_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700842 for (i = UI_CURRENT; i < UI_SIZE; i++)
Philipp Reisner298307e2012-11-16 12:27:41 +0100843 p->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
Philipp Reisner9f2247b2012-08-16 14:25:58 +0200844 spin_unlock_irq(&mdev->ldev->md.uuid_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700845
846 mdev->comm_bm_set = drbd_bm_total_weight(mdev);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200847 p->uuid[UI_SIZE] = cpu_to_be64(mdev->comm_bm_set);
Philipp Reisner44ed1672011-04-19 17:10:19 +0200848 rcu_read_lock();
Andreas Gruenbacher6139f602011-05-06 20:00:02 +0200849 uuid_flags |= rcu_dereference(mdev->tconn->net_conf)->discard_my_data ? 1 : 0;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200850 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700851 uuid_flags |= test_bit(CRASHED_PRIMARY, &mdev->flags) ? 2 : 0;
852 uuid_flags |= mdev->new_state_tmp.disk == D_INCONSISTENT ? 4 : 0;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200853 p->uuid[UI_FLAGS] = cpu_to_be64(uuid_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700854
855 put_ldev(mdev);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200856 return drbd_send_command(mdev, sock, P_UUIDS, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700857}
858
859int drbd_send_uuids(struct drbd_conf *mdev)
860{
861 return _drbd_send_uuids(mdev, 0);
862}
863
864int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev)
865{
866 return _drbd_send_uuids(mdev, 8);
867}
868
Lars Ellenberg62b0da32011-01-20 13:25:21 +0100869void drbd_print_uuids(struct drbd_conf *mdev, const char *text)
870{
871 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
872 u64 *uuid = mdev->ldev->md.uuid;
873 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX\n",
874 text,
875 (unsigned long long)uuid[UI_CURRENT],
876 (unsigned long long)uuid[UI_BITMAP],
877 (unsigned long long)uuid[UI_HISTORY_START],
878 (unsigned long long)uuid[UI_HISTORY_END]);
879 put_ldev(mdev);
880 } else {
881 dev_info(DEV, "%s effective data uuid: %016llX\n",
882 text,
883 (unsigned long long)mdev->ed_uuid);
884 }
885}
886
Andreas Gruenbacher9c1b7f72011-03-16 01:09:01 +0100887void drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700888{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200889 struct drbd_socket *sock;
890 struct p_rs_uuid *p;
Lars Ellenberg5a22db82010-12-17 21:14:23 +0100891 u64 uuid;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700892
Lars Ellenberg5a22db82010-12-17 21:14:23 +0100893 D_ASSERT(mdev->state.disk == D_UP_TO_DATE);
894
Philipp Reisner5ba3dac2011-10-05 15:54:18 +0200895 uuid = mdev->ldev->md.uuid[UI_BITMAP];
896 if (uuid && uuid != UUID_JUST_CREATED)
897 uuid = uuid + UUID_NEW_BM_OFFSET;
898 else
899 get_random_bytes(&uuid, sizeof(u64));
Lars Ellenberg5a22db82010-12-17 21:14:23 +0100900 drbd_uuid_set(mdev, UI_BITMAP, uuid);
Lars Ellenberg62b0da32011-01-20 13:25:21 +0100901 drbd_print_uuids(mdev, "updated sync UUID");
Lars Ellenberg5a22db82010-12-17 21:14:23 +0100902 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700903
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200904 sock = &mdev->tconn->data;
905 p = drbd_prepare_command(mdev, sock);
906 if (p) {
907 p->uuid = cpu_to_be64(uuid);
908 drbd_send_command(mdev, sock, P_SYNC_UUID, sizeof(*p), NULL, 0);
909 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700910}
911
Philipp Reisnere89b5912010-03-24 17:11:33 +0100912int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700913{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200914 struct drbd_socket *sock;
915 struct p_sizes *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700916 sector_t d_size, u_size;
Lars Ellenbergdb141b22012-06-25 19:15:58 +0200917 int q_order_type;
918 unsigned int max_bio_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700919
920 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
921 D_ASSERT(mdev->ldev->backing_bdev);
922 d_size = drbd_get_max_capacity(mdev->ldev);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200923 rcu_read_lock();
924 u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
925 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700926 q_order_type = drbd_queue_order_type(mdev);
Philipp Reisner99432fc2011-05-20 16:39:13 +0200927 max_bio_size = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
Lars Ellenbergdb141b22012-06-25 19:15:58 +0200928 max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700929 put_ldev(mdev);
930 } else {
931 d_size = 0;
932 u_size = 0;
933 q_order_type = QUEUE_ORDERED_NONE;
Philipp Reisner99432fc2011-05-20 16:39:13 +0200934 max_bio_size = DRBD_MAX_BIO_SIZE; /* ... multiple BIOs per peer_request */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700935 }
936
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200937 sock = &mdev->tconn->data;
938 p = drbd_prepare_command(mdev, sock);
939 if (!p)
940 return -EIO;
Philipp Reisner2ffca4f2011-06-30 15:43:06 +0200941
942 if (mdev->tconn->agreed_pro_version <= 94)
Lars Ellenbergdb141b22012-06-25 19:15:58 +0200943 max_bio_size = min(max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
Philipp Reisner2ffca4f2011-06-30 15:43:06 +0200944 else if (mdev->tconn->agreed_pro_version < 100)
Philipp Reisner98683652012-11-09 14:18:43 +0100945 max_bio_size = min(max_bio_size, DRBD_MAX_BIO_SIZE_P95);
Philipp Reisner68093842011-06-30 15:43:06 +0200946
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200947 p->d_size = cpu_to_be64(d_size);
948 p->u_size = cpu_to_be64(u_size);
949 p->c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));
950 p->max_bio_size = cpu_to_be32(max_bio_size);
951 p->queue_order_type = cpu_to_be16(q_order_type);
952 p->dds_flags = cpu_to_be16(flags);
953 return drbd_send_command(mdev, sock, P_SIZES, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700954}
955
956/**
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200957 * drbd_send_current_state() - Sends the drbd state to the peer
Philipp Reisnerb411b362009-09-25 16:07:19 -0700958 * @mdev: DRBD device.
959 */
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200960int drbd_send_current_state(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700961{
Andreas Gruenbacher7c967152011-03-22 00:49:36 +0100962 struct drbd_socket *sock;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200963 struct p_state *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700964
Andreas Gruenbacher7c967152011-03-22 00:49:36 +0100965 sock = &mdev->tconn->data;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200966 p = drbd_prepare_command(mdev, sock);
967 if (!p)
968 return -EIO;
969 p->state = cpu_to_be32(mdev->state.i); /* Within the send mutex */
970 return drbd_send_command(mdev, sock, P_STATE, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700971}
972
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200973/**
974 * drbd_send_state() - After a state change, sends the new state to the peer
Philipp Reisner43de7c82011-11-10 13:16:13 +0100975 * @mdev: DRBD device.
976 * @state: the state to send, not necessarily the current state.
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200977 *
978 * Each state change queues an "after_state_ch" work, which will eventually
979 * send the resulting new state to the peer. If more state changes happen
980 * between queuing and processing of the after_state_ch work, we still
981 * want to send each intermediary state in the order it occurred.
982 */
983int drbd_send_state(struct drbd_conf *mdev, union drbd_state state)
984{
Philipp Reisner43de7c82011-11-10 13:16:13 +0100985 struct drbd_socket *sock;
986 struct p_state *p;
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200987
Philipp Reisner43de7c82011-11-10 13:16:13 +0100988 sock = &mdev->tconn->data;
989 p = drbd_prepare_command(mdev, sock);
990 if (!p)
991 return -EIO;
992 p->state = cpu_to_be32(state.i); /* Within the send mutex */
993 return drbd_send_command(mdev, sock, P_STATE, sizeof(*p), NULL, 0);
994}
Lars Ellenbergf479ea02011-10-27 16:52:30 +0200995
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200996int drbd_send_state_req(struct drbd_conf *mdev, union drbd_state mask, union drbd_state val)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700997{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200998 struct drbd_socket *sock;
999 struct p_req_state *p;
Lars Ellenbergf479ea02011-10-27 16:52:30 +02001000
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001001 sock = &mdev->tconn->data;
1002 p = drbd_prepare_command(mdev, sock);
1003 if (!p)
1004 return -EIO;
1005 p->mask = cpu_to_be32(mask.i);
1006 p->val = cpu_to_be32(val.i);
1007 return drbd_send_command(mdev, sock, P_STATE_CHG_REQ, sizeof(*p), NULL, 0);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001008}
1009
1010int conn_send_state_req(struct drbd_tconn *tconn, union drbd_state mask, union drbd_state val)
1011{
1012 enum drbd_packet cmd;
1013 struct drbd_socket *sock;
1014 struct p_req_state *p;
1015
1016 cmd = tconn->agreed_pro_version < 100 ? P_STATE_CHG_REQ : P_CONN_ST_CHG_REQ;
1017 sock = &tconn->data;
1018 p = conn_prepare_command(tconn, sock);
1019 if (!p)
1020 return -EIO;
1021 p->mask = cpu_to_be32(mask.i);
1022 p->val = cpu_to_be32(val.i);
1023 return conn_send_command(tconn, sock, cmd, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001024}
1025
Andreas Gruenbacher2f4e7ab2011-03-16 01:20:38 +01001026void drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001027{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001028 struct drbd_socket *sock;
1029 struct p_req_state_reply *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001030
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001031 sock = &mdev->tconn->meta;
1032 p = drbd_prepare_command(mdev, sock);
1033 if (p) {
1034 p->retcode = cpu_to_be32(retcode);
1035 drbd_send_command(mdev, sock, P_STATE_CHG_REPLY, sizeof(*p), NULL, 0);
Lars Ellenbergf479ea02011-10-27 16:52:30 +02001036 }
Lars Ellenbergf479ea02011-10-27 16:52:30 +02001037}
1038
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001039void conn_send_sr_reply(struct drbd_tconn *tconn, enum drbd_state_rv retcode)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001040{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001041 struct drbd_socket *sock;
1042 struct p_req_state_reply *p;
Philipp Reisner047cd4a2011-02-15 11:09:33 +01001043 enum drbd_packet cmd = tconn->agreed_pro_version < 100 ? P_STATE_CHG_REPLY : P_CONN_ST_CHG_REPLY;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001044
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001045 sock = &tconn->meta;
1046 p = conn_prepare_command(tconn, sock);
1047 if (p) {
1048 p->retcode = cpu_to_be32(retcode);
1049 conn_send_command(tconn, sock, cmd, sizeof(*p), NULL, 0);
1050 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001051}
1052
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001053static void dcbp_set_code(struct p_compressed_bm *p, enum drbd_bitmap_code code)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001054{
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001055 BUG_ON(code & ~0xf);
1056 p->encoding = (p->encoding & ~0xf) | code;
1057}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001058
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001059static void dcbp_set_start(struct p_compressed_bm *p, int set)
1060{
1061 p->encoding = (p->encoding & ~0x80) | (set ? 0x80 : 0);
1062}
Philipp Reisnerb411b362009-09-25 16:07:19 -07001063
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001064static void dcbp_set_pad_bits(struct p_compressed_bm *p, int n)
1065{
1066 BUG_ON(n & ~0x7);
1067 p->encoding = (p->encoding & (~0x7 << 4)) | (n << 4);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001068}
1069
1070int fill_bitmap_rle_bits(struct drbd_conf *mdev,
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001071 struct p_compressed_bm *p,
1072 unsigned int size,
1073 struct bm_xfer_ctx *c)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001074{
1075 struct bitstream bs;
1076 unsigned long plain_bits;
1077 unsigned long tmp;
1078 unsigned long rl;
1079 unsigned len;
1080 unsigned toggle;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001081 int bits, use_rle;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001082
1083 /* may we use this feature? */
Philipp Reisner44ed1672011-04-19 17:10:19 +02001084 rcu_read_lock();
1085 use_rle = rcu_dereference(mdev->tconn->net_conf)->use_rle;
1086 rcu_read_unlock();
1087 if (!use_rle || mdev->tconn->agreed_pro_version < 90)
1088 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001089
1090 if (c->bit_offset >= c->bm_bits)
1091 return 0; /* nothing to do. */
1092
1093 /* use at most thus many bytes */
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001094 bitstream_init(&bs, p->code, size, 0);
1095 memset(p->code, 0, size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001096 /* plain bits covered in this code string */
1097 plain_bits = 0;
1098
1099 /* p->encoding & 0x80 stores whether the first run length is set.
1100 * bit offset is implicit.
1101 * start with toggle == 2 to be able to tell the first iteration */
1102 toggle = 2;
1103
1104 /* see how much plain bits we can stuff into one packet
1105 * using RLE and VLI. */
1106 do {
1107 tmp = (toggle == 0) ? _drbd_bm_find_next_zero(mdev, c->bit_offset)
1108 : _drbd_bm_find_next(mdev, c->bit_offset);
1109 if (tmp == -1UL)
1110 tmp = c->bm_bits;
1111 rl = tmp - c->bit_offset;
1112
1113 if (toggle == 2) { /* first iteration */
1114 if (rl == 0) {
1115 /* the first checked bit was set,
1116 * store start value, */
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001117 dcbp_set_start(p, 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001118 /* but skip encoding of zero run length */
1119 toggle = !toggle;
1120 continue;
1121 }
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001122 dcbp_set_start(p, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001123 }
1124
1125 /* paranoia: catch zero runlength.
1126 * can only happen if bitmap is modified while we scan it. */
1127 if (rl == 0) {
1128 dev_err(DEV, "unexpected zero runlength while encoding bitmap "
1129 "t:%u bo:%lu\n", toggle, c->bit_offset);
1130 return -1;
1131 }
1132
1133 bits = vli_encode_bits(&bs, rl);
1134 if (bits == -ENOBUFS) /* buffer full */
1135 break;
1136 if (bits <= 0) {
1137 dev_err(DEV, "error while encoding bitmap: %d\n", bits);
1138 return 0;
1139 }
1140
1141 toggle = !toggle;
1142 plain_bits += rl;
1143 c->bit_offset = tmp;
1144 } while (c->bit_offset < c->bm_bits);
1145
1146 len = bs.cur.b - p->code + !!bs.cur.bit;
1147
1148 if (plain_bits < (len << 3)) {
1149 /* incompressible with this method.
1150 * we need to rewind both word and bit position. */
1151 c->bit_offset -= plain_bits;
1152 bm_xfer_ctx_bit_to_word_offset(c);
1153 c->bit_offset = c->word_offset * BITS_PER_LONG;
1154 return 0;
1155 }
1156
1157 /* RLE + VLI was able to compress it just fine.
1158 * update c->word_offset. */
1159 bm_xfer_ctx_bit_to_word_offset(c);
1160
1161 /* store pad_bits */
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001162 dcbp_set_pad_bits(p, (8 - bs.cur.bit) & 0x7);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001163
1164 return len;
1165}
1166
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001167/**
1168 * send_bitmap_rle_or_plain
1169 *
1170 * Return 0 when done, 1 when another iteration is needed, and a negative error
1171 * code upon failure.
1172 */
1173static int
Andreas Gruenbacher79ed9bd2011-03-24 21:31:38 +01001174send_bitmap_rle_or_plain(struct drbd_conf *mdev, struct bm_xfer_ctx *c)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001175{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001176 struct drbd_socket *sock = &mdev->tconn->data;
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001177 unsigned int header_size = drbd_header_size(mdev->tconn);
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001178 struct p_compressed_bm *p = sock->sbuf + header_size;
Andreas Gruenbachera982dd52010-12-10 00:45:25 +01001179 int len, err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001180
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001181 len = fill_bitmap_rle_bits(mdev, p,
1182 DRBD_SOCKET_BUFFER_SIZE - header_size - sizeof(*p), c);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001183 if (len < 0)
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001184 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001185
1186 if (len) {
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01001187 dcbp_set_code(p, RLE_VLI_Bits);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001188 err = __send_command(mdev->tconn, mdev->vnr, sock,
1189 P_COMPRESSED_BITMAP, sizeof(*p) + len,
1190 NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001191 c->packets[0]++;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001192 c->bytes[0] += header_size + sizeof(*p) + len;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001193
1194 if (c->bit_offset >= c->bm_bits)
1195 len = 0; /* DONE */
1196 } else {
1197 /* was not compressible.
1198 * send a buffer full of plain text bits instead. */
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001199 unsigned int data_size;
1200 unsigned long num_words;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001201 unsigned long *p = sock->sbuf + header_size;
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001202
1203 data_size = DRBD_SOCKET_BUFFER_SIZE - header_size;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001204 num_words = min_t(size_t, data_size / sizeof(*p),
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001205 c->bm_words - c->word_offset);
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001206 len = num_words * sizeof(*p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001207 if (len)
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001208 drbd_bm_get_lel(mdev, c->word_offset, num_words, p);
1209 err = __send_command(mdev->tconn, mdev->vnr, sock, P_BITMAP, len, NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001210 c->word_offset += num_words;
1211 c->bit_offset = c->word_offset * BITS_PER_LONG;
1212
1213 c->packets[1]++;
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02001214 c->bytes[1] += header_size + len;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001215
1216 if (c->bit_offset > c->bm_bits)
1217 c->bit_offset = c->bm_bits;
1218 }
Andreas Gruenbachera982dd52010-12-10 00:45:25 +01001219 if (!err) {
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001220 if (len == 0) {
1221 INFO_bm_xfer_stats(mdev, "send", c);
1222 return 0;
1223 } else
1224 return 1;
1225 }
1226 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001227}
1228
1229/* See the comment at receive_bitmap() */
Andreas Gruenbacher058820c2011-03-22 16:03:43 +01001230static int _drbd_send_bitmap(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001231{
1232 struct bm_xfer_ctx c;
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001233 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001234
Andreas Gruenbacher841ce242010-12-15 19:31:20 +01001235 if (!expect(mdev->bitmap))
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001236 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001237
1238 if (get_ldev(mdev)) {
1239 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1240 dev_info(DEV, "Writing the whole bitmap, MDF_FullSync was set.\n");
1241 drbd_bm_set_all(mdev);
1242 if (drbd_bm_write(mdev)) {
1243 /* write_bm did fail! Leave full sync flag set in Meta P_DATA
1244 * but otherwise process as per normal - need to tell other
1245 * side that a full resync is required! */
1246 dev_err(DEV, "Failed to write bitmap to disk!\n");
1247 } else {
1248 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
1249 drbd_md_sync(mdev);
1250 }
1251 }
1252 put_ldev(mdev);
1253 }
1254
1255 c = (struct bm_xfer_ctx) {
1256 .bm_bits = drbd_bm_bits(mdev),
1257 .bm_words = drbd_bm_words(mdev),
1258 };
1259
1260 do {
Andreas Gruenbacher79ed9bd2011-03-24 21:31:38 +01001261 err = send_bitmap_rle_or_plain(mdev, &c);
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001262 } while (err > 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001263
Andreas Gruenbacherf70af112010-12-11 18:51:50 +01001264 return err == 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001265}
1266
1267int drbd_send_bitmap(struct drbd_conf *mdev)
1268{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001269 struct drbd_socket *sock = &mdev->tconn->data;
1270 int err = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001271
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001272 mutex_lock(&sock->mutex);
1273 if (sock->socket)
1274 err = !_drbd_send_bitmap(mdev);
1275 mutex_unlock(&sock->mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001276 return err;
1277}
1278
Lars Ellenberg9ed57dc2012-03-26 20:55:17 +02001279void drbd_send_b_ack(struct drbd_tconn *tconn, u32 barrier_nr, u32 set_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001280{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001281 struct drbd_socket *sock;
1282 struct p_barrier_ack *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001283
Lars Ellenberg9ed57dc2012-03-26 20:55:17 +02001284 if (tconn->cstate < C_WF_REPORT_PARAMS)
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001285 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001286
Lars Ellenberg9ed57dc2012-03-26 20:55:17 +02001287 sock = &tconn->meta;
1288 p = conn_prepare_command(tconn, sock);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001289 if (!p)
1290 return;
1291 p->barrier = barrier_nr;
1292 p->set_size = cpu_to_be32(set_size);
Lars Ellenberg9ed57dc2012-03-26 20:55:17 +02001293 conn_send_command(tconn, sock, P_BARRIER_ACK, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001294}
1295
1296/**
1297 * _drbd_send_ack() - Sends an ack packet
1298 * @mdev: DRBD device.
1299 * @cmd: Packet command code.
1300 * @sector: sector, needs to be in big endian byte order
1301 * @blksize: size in byte, needs to be in big endian byte order
1302 * @block_id: Id, big endian byte order
1303 */
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001304static int _drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
1305 u64 sector, u32 blksize, u64 block_id)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001306{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001307 struct drbd_socket *sock;
1308 struct p_block_ack *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001309
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001310 if (mdev->state.conn < C_CONNECTED)
Andreas Gruenbachera8c32aa2011-03-16 01:27:22 +01001311 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001312
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001313 sock = &mdev->tconn->meta;
1314 p = drbd_prepare_command(mdev, sock);
1315 if (!p)
1316 return -EIO;
1317 p->sector = sector;
1318 p->block_id = block_id;
1319 p->blksize = blksize;
1320 p->seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
1321 return drbd_send_command(mdev, sock, cmd, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001322}
1323
Lars Ellenberg2b2bf212010-10-06 11:46:55 +02001324/* dp->sector and dp->block_id already/still in network byte order,
1325 * data_size is payload size according to dp->head,
1326 * and may need to be corrected for digest size. */
Andreas Gruenbachera9a99942011-03-16 01:30:14 +01001327void drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packet cmd,
1328 struct p_data *dp, int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001329{
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001330 if (mdev->tconn->peer_integrity_tfm)
1331 data_size -= crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm);
Andreas Gruenbachera9a99942011-03-16 01:30:14 +01001332 _drbd_send_ack(mdev, cmd, dp->sector, cpu_to_be32(data_size),
1333 dp->block_id);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001334}
1335
Andreas Gruenbachera9a99942011-03-16 01:30:14 +01001336void drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packet cmd,
1337 struct p_block_req *rp)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001338{
Andreas Gruenbachera9a99942011-03-16 01:30:14 +01001339 _drbd_send_ack(mdev, cmd, rp->sector, rp->blksize, rp->block_id);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001340}
1341
1342/**
1343 * drbd_send_ack() - Sends an ack packet
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001344 * @mdev: DRBD device
1345 * @cmd: packet command code
1346 * @peer_req: peer request
Philipp Reisnerb411b362009-09-25 16:07:19 -07001347 */
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001348int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packet cmd,
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001349 struct drbd_peer_request *peer_req)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001350{
1351 return _drbd_send_ack(mdev, cmd,
Andreas Gruenbacherdd516122011-03-16 15:39:08 +01001352 cpu_to_be64(peer_req->i.sector),
1353 cpu_to_be32(peer_req->i.size),
1354 peer_req->block_id);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001355}
1356
1357/* This function misuses the block_id field to signal if the blocks
1358 * are is sync or not. */
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001359int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001360 sector_t sector, int blksize, u64 block_id)
1361{
1362 return _drbd_send_ack(mdev, cmd,
1363 cpu_to_be64(sector),
1364 cpu_to_be32(blksize),
1365 cpu_to_be64(block_id));
1366}
1367
1368int drbd_send_drequest(struct drbd_conf *mdev, int cmd,
1369 sector_t sector, int size, u64 block_id)
1370{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001371 struct drbd_socket *sock;
1372 struct p_block_req *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001373
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001374 sock = &mdev->tconn->data;
1375 p = drbd_prepare_command(mdev, sock);
1376 if (!p)
1377 return -EIO;
1378 p->sector = cpu_to_be64(sector);
1379 p->block_id = block_id;
1380 p->blksize = cpu_to_be32(size);
1381 return drbd_send_command(mdev, sock, cmd, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001382}
1383
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001384int drbd_send_drequest_csum(struct drbd_conf *mdev, sector_t sector, int size,
1385 void *digest, int digest_size, enum drbd_packet cmd)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001386{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001387 struct drbd_socket *sock;
1388 struct p_block_req *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001389
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001390 /* FIXME: Put the digest into the preallocated socket buffer. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001391
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001392 sock = &mdev->tconn->data;
1393 p = drbd_prepare_command(mdev, sock);
1394 if (!p)
1395 return -EIO;
1396 p->sector = cpu_to_be64(sector);
1397 p->block_id = ID_SYNCER /* unused */;
1398 p->blksize = cpu_to_be32(size);
1399 return drbd_send_command(mdev, sock, cmd, sizeof(*p),
1400 digest, digest_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001401}
1402
1403int drbd_send_ov_request(struct drbd_conf *mdev, sector_t sector, int size)
1404{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001405 struct drbd_socket *sock;
1406 struct p_block_req *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001407
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001408 sock = &mdev->tconn->data;
1409 p = drbd_prepare_command(mdev, sock);
1410 if (!p)
1411 return -EIO;
1412 p->sector = cpu_to_be64(sector);
1413 p->block_id = ID_SYNCER /* unused */;
1414 p->blksize = cpu_to_be32(size);
1415 return drbd_send_command(mdev, sock, P_OV_REQUEST, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001416}
1417
1418/* called on sndtimeo
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001419 * returns false if we should retry,
1420 * true if we think connection is dead
Philipp Reisnerb411b362009-09-25 16:07:19 -07001421 */
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001422static int we_should_drop_the_connection(struct drbd_tconn *tconn, struct socket *sock)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001423{
1424 int drop_it;
1425 /* long elapsed = (long)(jiffies - mdev->last_received); */
1426
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001427 drop_it = tconn->meta.socket == sock
1428 || !tconn->asender.task
1429 || get_t_state(&tconn->asender) != RUNNING
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01001430 || tconn->cstate < C_WF_REPORT_PARAMS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001431
1432 if (drop_it)
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01001433 return true;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001434
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001435 drop_it = !--tconn->ko_count;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001436 if (!drop_it) {
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001437 conn_err(tconn, "[%s/%d] sock_sendmsg time expired, ko = %u\n",
1438 current->comm, current->pid, tconn->ko_count);
1439 request_ping(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001440 }
1441
1442 return drop_it; /* && (mdev->state == R_PRIMARY) */;
1443}
1444
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001445static void drbd_update_congested(struct drbd_tconn *tconn)
Andreas Gruenbacher9e204cd2011-01-26 18:45:11 +01001446{
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001447 struct sock *sk = tconn->data.socket->sk;
Andreas Gruenbacher9e204cd2011-01-26 18:45:11 +01001448 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5)
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001449 set_bit(NET_CONGESTED, &tconn->flags);
Andreas Gruenbacher9e204cd2011-01-26 18:45:11 +01001450}
1451
Philipp Reisnerb411b362009-09-25 16:07:19 -07001452/* The idea of sendpage seems to be to put some kind of reference
1453 * to the page into the skb, and to hand it over to the NIC. In
1454 * this process get_page() gets called.
1455 *
1456 * As soon as the page was really sent over the network put_page()
1457 * gets called by some part of the network layer. [ NIC driver? ]
1458 *
1459 * [ get_page() / put_page() increment/decrement the count. If count
1460 * reaches 0 the page will be freed. ]
1461 *
1462 * This works nicely with pages from FSs.
1463 * But this means that in protocol A we might signal IO completion too early!
1464 *
1465 * In order not to corrupt data during a resync we must make sure
1466 * that we do not reuse our own buffer pages (EEs) to early, therefore
1467 * we have the net_ee list.
1468 *
1469 * XFS seems to have problems, still, it submits pages with page_count == 0!
1470 * As a workaround, we disable sendpage on pages
1471 * with page_count == 0 or PageSlab.
1472 */
1473static int _drbd_no_send_page(struct drbd_conf *mdev, struct page *page,
Andreas Gruenbacherb9874272011-03-16 09:41:10 +01001474 int offset, size_t size, unsigned msg_flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001475{
Andreas Gruenbacherb9874272011-03-16 09:41:10 +01001476 struct socket *socket;
1477 void *addr;
1478 int err;
1479
1480 socket = mdev->tconn->data.socket;
1481 addr = kmap(page) + offset;
1482 err = drbd_send_all(mdev->tconn, socket, addr, size, msg_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001483 kunmap(page);
Andreas Gruenbacherb9874272011-03-16 09:41:10 +01001484 if (!err)
1485 mdev->send_cnt += size >> 9;
1486 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001487}
1488
1489static int _drbd_send_page(struct drbd_conf *mdev, struct page *page,
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001490 int offset, size_t size, unsigned msg_flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001491{
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001492 struct socket *socket = mdev->tconn->data.socket;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001493 mm_segment_t oldfs = get_fs();
Philipp Reisnerb411b362009-09-25 16:07:19 -07001494 int len = size;
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001495 int err = -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001496
1497 /* e.g. XFS meta- & log-data is in slab pages, which have a
1498 * page_count of 0 and/or have PageSlab() set.
1499 * we cannot use send_page for those, as that does get_page();
1500 * put_page(); and would cause either a VM_BUG directly, or
1501 * __page_cache_release a page that would actually still be referenced
1502 * by someone, leading to some obscure delayed Oops somewhere else. */
1503 if (disable_sendpage || (page_count(page) < 1) || PageSlab(page))
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001504 return _drbd_no_send_page(mdev, page, offset, size, msg_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001505
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001506 msg_flags |= MSG_NOSIGNAL;
Philipp Reisner1a7ba642011-02-07 14:56:02 +01001507 drbd_update_congested(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001508 set_fs(KERNEL_DS);
1509 do {
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001510 int sent;
1511
1512 sent = socket->ops->sendpage(socket, page, offset, len, msg_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001513 if (sent <= 0) {
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001514 if (sent == -EAGAIN) {
1515 if (we_should_drop_the_connection(mdev->tconn, socket))
1516 break;
1517 continue;
1518 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001519 dev_warn(DEV, "%s: size=%d len=%d sent=%d\n",
1520 __func__, (int)size, len, sent);
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001521 if (sent < 0)
1522 err = sent;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001523 break;
1524 }
1525 len -= sent;
1526 offset += sent;
1527 } while (len > 0 /* THINK && mdev->cstate >= C_CONNECTED*/);
1528 set_fs(oldfs);
Philipp Reisner01a311a2011-02-07 14:30:33 +01001529 clear_bit(NET_CONGESTED, &mdev->tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001530
Andreas Gruenbacher88b390f2011-03-16 10:44:16 +01001531 if (len == 0) {
1532 err = 0;
1533 mdev->send_cnt += size >> 9;
1534 }
1535 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001536}
1537
1538static int _drbd_send_bio(struct drbd_conf *mdev, struct bio *bio)
1539{
1540 struct bio_vec *bvec;
1541 int i;
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001542 /* hint all but last page with MSG_MORE */
Lars Ellenberg001a8862012-03-08 16:43:45 +01001543 bio_for_each_segment(bvec, bio, i) {
Andreas Gruenbacher7fae55d2011-03-16 11:46:33 +01001544 int err;
1545
1546 err = _drbd_no_send_page(mdev, bvec->bv_page,
1547 bvec->bv_offset, bvec->bv_len,
1548 i == bio->bi_vcnt - 1 ? 0 : MSG_MORE);
1549 if (err)
1550 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001551 }
Andreas Gruenbacher7fae55d2011-03-16 11:46:33 +01001552 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001553}
1554
1555static int _drbd_send_zc_bio(struct drbd_conf *mdev, struct bio *bio)
1556{
1557 struct bio_vec *bvec;
1558 int i;
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001559 /* hint all but last page with MSG_MORE */
Lars Ellenberg001a8862012-03-08 16:43:45 +01001560 bio_for_each_segment(bvec, bio, i) {
Andreas Gruenbacher7fae55d2011-03-16 11:46:33 +01001561 int err;
1562
1563 err = _drbd_send_page(mdev, bvec->bv_page,
1564 bvec->bv_offset, bvec->bv_len,
1565 i == bio->bi_vcnt - 1 ? 0 : MSG_MORE);
1566 if (err)
1567 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001568 }
Andreas Gruenbacher7fae55d2011-03-16 11:46:33 +01001569 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001570}
1571
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001572static int _drbd_send_zc_ee(struct drbd_conf *mdev,
1573 struct drbd_peer_request *peer_req)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001574{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001575 struct page *page = peer_req->pages;
1576 unsigned len = peer_req->i.size;
Andreas Gruenbacher9f692302011-03-16 10:49:09 +01001577 int err;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001578
Lars Ellenbergba11ad92010-05-25 16:26:16 +02001579 /* hint all but last page with MSG_MORE */
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001580 page_chain_for_each(page) {
1581 unsigned l = min_t(unsigned, len, PAGE_SIZE);
Andreas Gruenbacher9f692302011-03-16 10:49:09 +01001582
1583 err = _drbd_send_page(mdev, page, 0, l,
1584 page_chain_next(page) ? MSG_MORE : 0);
1585 if (err)
1586 return err;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001587 len -= l;
1588 }
Andreas Gruenbacher9f692302011-03-16 10:49:09 +01001589 return 0;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001590}
1591
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001592static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
1593{
Philipp Reisner31890f42011-01-19 14:12:51 +01001594 if (mdev->tconn->agreed_pro_version >= 95)
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001595 return (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001596 (bi_rw & REQ_FUA ? DP_FUA : 0) |
1597 (bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
1598 (bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
1599 else
Jens Axboe721a9602011-03-09 11:56:30 +01001600 return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001601}
1602
Philipp Reisnerb411b362009-09-25 16:07:19 -07001603/* Used to send write requests
1604 * R_PRIMARY -> Peer (P_DATA)
1605 */
1606int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req)
1607{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001608 struct drbd_socket *sock;
1609 struct p_data *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001610 unsigned int dp_flags = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001611 int dgs;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001612 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001613
Philipp Reisner46e1ce42011-05-16 12:57:15 +02001614 sock = &mdev->tconn->data;
1615 p = drbd_prepare_command(mdev, sock);
Andreas Gruenbacher7d4c7822011-07-17 23:06:12 +02001616 dgs = mdev->tconn->integrity_tfm ? crypto_hash_digestsize(mdev->tconn->integrity_tfm) : 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001617
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001618 if (!p)
1619 return -EIO;
1620 p->sector = cpu_to_be64(req->i.sector);
1621 p->block_id = (unsigned long)req;
Lars Ellenberg5cdb0bf32012-03-26 16:21:25 +02001622 p->seq_num = cpu_to_be32(atomic_inc_return(&mdev->packet_seq));
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001623 dp_flags = bio_flags_to_wire(mdev, req->master_bio->bi_rw);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001624 if (mdev->state.conn >= C_SYNC_SOURCE &&
1625 mdev->state.conn <= C_PAUSED_SYNC_T)
1626 dp_flags |= DP_MAY_SET_IN_SYNC;
Philipp Reisner303d1442011-04-13 16:24:47 -07001627 if (mdev->tconn->agreed_pro_version >= 100) {
1628 if (req->rq_state & RQ_EXP_RECEIVE_ACK)
1629 dp_flags |= DP_SEND_RECEIVE_ACK;
1630 if (req->rq_state & RQ_EXP_WRITE_ACK)
1631 dp_flags |= DP_SEND_WRITE_ACK;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001632 }
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001633 p->dp_flags = cpu_to_be32(dp_flags);
1634 if (dgs)
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001635 drbd_csum_bio(mdev, mdev->tconn->integrity_tfm, req->master_bio, p + 1);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001636 err = __send_command(mdev->tconn, mdev->vnr, sock, P_DATA, sizeof(*p) + dgs, NULL, req->i.size);
Andreas Gruenbacher6bdb9b02011-03-16 11:52:58 +01001637 if (!err) {
Lars Ellenberg470be442010-11-10 10:36:52 +01001638 /* For protocol A, we have to memcpy the payload into
1639 * socket buffers, as we may complete right away
1640 * as soon as we handed it over to tcp, at which point the data
1641 * pages may become invalid.
1642 *
1643 * For data-integrity enabled, we copy it as well, so we can be
1644 * sure that even if the bio pages may still be modified, it
1645 * won't change the data on the wire, thus if the digest checks
1646 * out ok after sending on this side, but does not fit on the
1647 * receiving side, we sure have detected corruption elsewhere.
1648 */
Philipp Reisner303d1442011-04-13 16:24:47 -07001649 if (!(req->rq_state & (RQ_EXP_RECEIVE_ACK | RQ_EXP_WRITE_ACK)) || dgs)
Andreas Gruenbacher6bdb9b02011-03-16 11:52:58 +01001650 err = _drbd_send_bio(mdev, req->master_bio);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001651 else
Andreas Gruenbacher6bdb9b02011-03-16 11:52:58 +01001652 err = _drbd_send_zc_bio(mdev, req->master_bio);
Lars Ellenberg470be442010-11-10 10:36:52 +01001653
1654 /* double check digest, sometimes buffers have been modified in flight. */
1655 if (dgs > 0 && dgs <= 64) {
Bart Van Assche24c48302011-05-21 18:32:29 +02001656 /* 64 byte, 512 bit, is the largest digest size
Lars Ellenberg470be442010-11-10 10:36:52 +01001657 * currently supported in kernel crypto. */
1658 unsigned char digest[64];
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001659 drbd_csum_bio(mdev, mdev->tconn->integrity_tfm, req->master_bio, digest);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001660 if (memcmp(p + 1, digest, dgs)) {
Lars Ellenberg470be442010-11-10 10:36:52 +01001661 dev_warn(DEV,
1662 "Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",
Andreas Gruenbacherace652a2011-01-03 17:09:58 +01001663 (unsigned long long)req->i.sector, req->i.size);
Lars Ellenberg470be442010-11-10 10:36:52 +01001664 }
1665 } /* else if (dgs > 64) {
1666 ... Be noisy about digest too large ...
1667 } */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001668 }
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001669 mutex_unlock(&sock->mutex); /* locked by drbd_prepare_command() */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001670
Andreas Gruenbacher6bdb9b02011-03-16 11:52:58 +01001671 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001672}
1673
1674/* answer packet, used to send data back for read requests:
1675 * Peer -> (diskless) R_PRIMARY (P_DATA_REPLY)
1676 * C_SYNC_SOURCE -> C_SYNC_TARGET (P_RS_DATA_REPLY)
1677 */
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01001678int drbd_send_block(struct drbd_conf *mdev, enum drbd_packet cmd,
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001679 struct drbd_peer_request *peer_req)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001680{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001681 struct drbd_socket *sock;
1682 struct p_data *p;
Andreas Gruenbacher7b57b89d2011-03-16 11:35:20 +01001683 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001684 int dgs;
1685
Philipp Reisner46e1ce42011-05-16 12:57:15 +02001686 sock = &mdev->tconn->data;
1687 p = drbd_prepare_command(mdev, sock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001688
Andreas Gruenbacher7d4c7822011-07-17 23:06:12 +02001689 dgs = mdev->tconn->integrity_tfm ? crypto_hash_digestsize(mdev->tconn->integrity_tfm) : 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001690
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001691 if (!p)
1692 return -EIO;
1693 p->sector = cpu_to_be64(peer_req->i.sector);
1694 p->block_id = peer_req->block_id;
1695 p->seq_num = 0; /* unused */
Lars Ellenbergb17f33c2012-02-08 15:32:51 +01001696 p->dp_flags = 0;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001697 if (dgs)
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001698 drbd_csum_ee(mdev, mdev->tconn->integrity_tfm, peer_req, p + 1);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001699 err = __send_command(mdev->tconn, mdev->vnr, sock, cmd, sizeof(*p) + dgs, NULL, peer_req->i.size);
Andreas Gruenbacher7b57b89d2011-03-16 11:35:20 +01001700 if (!err)
1701 err = _drbd_send_zc_ee(mdev, peer_req);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001702 mutex_unlock(&sock->mutex); /* locked by drbd_prepare_command() */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001703
Andreas Gruenbacher7b57b89d2011-03-16 11:35:20 +01001704 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001705}
1706
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01001707int drbd_send_out_of_sync(struct drbd_conf *mdev, struct drbd_request *req)
Philipp Reisner73a01a12010-10-27 14:33:00 +02001708{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001709 struct drbd_socket *sock;
1710 struct p_block_desc *p;
Philipp Reisner73a01a12010-10-27 14:33:00 +02001711
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001712 sock = &mdev->tconn->data;
1713 p = drbd_prepare_command(mdev, sock);
1714 if (!p)
1715 return -EIO;
1716 p->sector = cpu_to_be64(req->i.sector);
1717 p->blksize = cpu_to_be32(req->i.size);
1718 return drbd_send_command(mdev, sock, P_OUT_OF_SYNC, sizeof(*p), NULL, 0);
Philipp Reisner73a01a12010-10-27 14:33:00 +02001719}
1720
Philipp Reisnerb411b362009-09-25 16:07:19 -07001721/*
1722 drbd_send distinguishes two cases:
1723
1724 Packets sent via the data socket "sock"
1725 and packets sent via the meta data socket "msock"
1726
1727 sock msock
1728 -----------------+-------------------------+------------------------------
1729 timeout conf.timeout / 2 conf.timeout / 2
1730 timeout action send a ping via msock Abort communication
1731 and close all sockets
1732*/
1733
1734/*
1735 * you must have down()ed the appropriate [m]sock_mutex elsewhere!
1736 */
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001737int drbd_send(struct drbd_tconn *tconn, struct socket *sock,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001738 void *buf, size_t size, unsigned msg_flags)
1739{
1740 struct kvec iov;
1741 struct msghdr msg;
1742 int rv, sent = 0;
1743
1744 if (!sock)
Andreas Gruenbacherc0d42c82010-12-09 23:52:22 +01001745 return -EBADR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001746
1747 /* THINK if (signal_pending) return ... ? */
1748
1749 iov.iov_base = buf;
1750 iov.iov_len = size;
1751
1752 msg.msg_name = NULL;
1753 msg.msg_namelen = 0;
1754 msg.msg_control = NULL;
1755 msg.msg_controllen = 0;
1756 msg.msg_flags = msg_flags | MSG_NOSIGNAL;
1757
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001758 if (sock == tconn->data.socket) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02001759 rcu_read_lock();
1760 tconn->ko_count = rcu_dereference(tconn->net_conf)->ko_count;
1761 rcu_read_unlock();
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001762 drbd_update_congested(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001763 }
1764 do {
1765 /* STRANGE
1766 * tcp_sendmsg does _not_ use its size parameter at all ?
1767 *
1768 * -EAGAIN on timeout, -EINTR on signal.
1769 */
1770/* THINK
1771 * do we need to block DRBD_SIG if sock == &meta.socket ??
1772 * otherwise wake_asender() might interrupt some send_*Ack !
1773 */
1774 rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
1775 if (rv == -EAGAIN) {
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001776 if (we_should_drop_the_connection(tconn, sock))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001777 break;
1778 else
1779 continue;
1780 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001781 if (rv == -EINTR) {
1782 flush_signals(current);
1783 rv = 0;
1784 }
1785 if (rv < 0)
1786 break;
1787 sent += rv;
1788 iov.iov_base += rv;
1789 iov.iov_len -= rv;
1790 } while (sent < size);
1791
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001792 if (sock == tconn->data.socket)
1793 clear_bit(NET_CONGESTED, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001794
1795 if (rv <= 0) {
1796 if (rv != -EAGAIN) {
Philipp Reisnerbedbd2a2011-02-07 15:08:48 +01001797 conn_err(tconn, "%s_sendmsg returned %d\n",
1798 sock == tconn->meta.socket ? "msock" : "sock",
1799 rv);
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01001800 conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001801 } else
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01001802 conn_request_state(tconn, NS(conn, C_TIMEOUT), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001803 }
1804
1805 return sent;
1806}
1807
Andreas Gruenbacherfb708e42010-12-15 17:04:36 +01001808/**
1809 * drbd_send_all - Send an entire buffer
1810 *
1811 * Returns 0 upon success and a negative error value otherwise.
1812 */
1813int drbd_send_all(struct drbd_tconn *tconn, struct socket *sock, void *buffer,
1814 size_t size, unsigned msg_flags)
1815{
1816 int err;
1817
1818 err = drbd_send(tconn, sock, buffer, size, msg_flags);
1819 if (err < 0)
1820 return err;
1821 if (err != size)
1822 return -EIO;
1823 return 0;
1824}
1825
Philipp Reisnerb411b362009-09-25 16:07:19 -07001826static int drbd_open(struct block_device *bdev, fmode_t mode)
1827{
1828 struct drbd_conf *mdev = bdev->bd_disk->private_data;
1829 unsigned long flags;
1830 int rv = 0;
1831
Arnd Bergmann2a48fc02010-06-02 14:28:52 +02001832 mutex_lock(&drbd_main_mutex);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001833 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001834 /* to have a stable mdev->state.role
1835 * and no race with updating open_cnt */
1836
1837 if (mdev->state.role != R_PRIMARY) {
1838 if (mode & FMODE_WRITE)
1839 rv = -EROFS;
1840 else if (!allow_oos)
1841 rv = -EMEDIUMTYPE;
1842 }
1843
1844 if (!rv)
1845 mdev->open_cnt++;
Philipp Reisner87eeee42011-01-19 14:16:30 +01001846 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
Arnd Bergmann2a48fc02010-06-02 14:28:52 +02001847 mutex_unlock(&drbd_main_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001848
1849 return rv;
1850}
1851
1852static int drbd_release(struct gendisk *gd, fmode_t mode)
1853{
1854 struct drbd_conf *mdev = gd->private_data;
Arnd Bergmann2a48fc02010-06-02 14:28:52 +02001855 mutex_lock(&drbd_main_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001856 mdev->open_cnt--;
Arnd Bergmann2a48fc02010-06-02 14:28:52 +02001857 mutex_unlock(&drbd_main_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001858 return 0;
1859}
1860
Philipp Reisnerb411b362009-09-25 16:07:19 -07001861static void drbd_set_defaults(struct drbd_conf *mdev)
1862{
Lars Ellenbergf3990022011-03-23 14:31:09 +01001863 /* Beware! The actual layout differs
1864 * between big endian and little endian */
Philipp Reisnerda9fbc22011-03-29 10:52:01 +02001865 mdev->state = (union drbd_dev_state) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001866 { .role = R_SECONDARY,
1867 .peer = R_UNKNOWN,
1868 .conn = C_STANDALONE,
1869 .disk = D_DISKLESS,
1870 .pdsk = D_UNKNOWN,
Philipp Reisnerb411b362009-09-25 16:07:19 -07001871 } };
1872}
1873
1874void drbd_init_set_defaults(struct drbd_conf *mdev)
1875{
1876 /* the memset(,0,) did most of this.
1877 * note: only assignments, no allocation in here */
1878
1879 drbd_set_defaults(mdev);
1880
Philipp Reisnerb411b362009-09-25 16:07:19 -07001881 atomic_set(&mdev->ap_bio_cnt, 0);
1882 atomic_set(&mdev->ap_pending_cnt, 0);
1883 atomic_set(&mdev->rs_pending_cnt, 0);
1884 atomic_set(&mdev->unacked_cnt, 0);
1885 atomic_set(&mdev->local_cnt, 0);
Lars Ellenberg435f0742010-09-06 12:30:25 +02001886 atomic_set(&mdev->pp_in_use_by_net, 0);
Philipp Reisner778f2712010-07-06 11:14:00 +02001887 atomic_set(&mdev->rs_sect_in, 0);
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001888 atomic_set(&mdev->rs_sect_ev, 0);
Philipp Reisner759fbdf2010-10-26 16:02:27 +02001889 atomic_set(&mdev->ap_in_flight, 0);
Philipp Reisnere1711732011-06-27 11:51:46 +02001890 atomic_set(&mdev->md_io_in_use, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001891
Philipp Reisner8410da82011-02-11 20:11:10 +01001892 mutex_init(&mdev->own_state_mutex);
1893 mdev->state_mutex = &mdev->own_state_mutex;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001894
1895 spin_lock_init(&mdev->al_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001896 spin_lock_init(&mdev->peer_seq_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001897
1898 INIT_LIST_HEAD(&mdev->active_ee);
1899 INIT_LIST_HEAD(&mdev->sync_ee);
1900 INIT_LIST_HEAD(&mdev->done_ee);
1901 INIT_LIST_HEAD(&mdev->read_ee);
1902 INIT_LIST_HEAD(&mdev->net_ee);
1903 INIT_LIST_HEAD(&mdev->resync_reads);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001904 INIT_LIST_HEAD(&mdev->resync_work.list);
1905 INIT_LIST_HEAD(&mdev->unplug_work.list);
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001906 INIT_LIST_HEAD(&mdev->go_diskless.list);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001907 INIT_LIST_HEAD(&mdev->md_sync_work.list);
Philipp Reisnerc4752ef2010-10-27 17:32:36 +02001908 INIT_LIST_HEAD(&mdev->start_resync_work.list);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001909 INIT_LIST_HEAD(&mdev->bm_io_work.w.list);
Philipp Reisner0ced55a2010-04-30 15:26:20 +02001910
Philipp Reisner794abb72010-12-27 11:51:23 +01001911 mdev->resync_work.cb = w_resync_timer;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001912 mdev->unplug_work.cb = w_send_write_hint;
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001913 mdev->go_diskless.cb = w_go_diskless;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001914 mdev->md_sync_work.cb = w_md_sync;
1915 mdev->bm_io_work.w.cb = w_bitmap_io;
Philipp Reisner370a43e2011-01-14 16:03:11 +01001916 mdev->start_resync_work.cb = w_start_resync;
Philipp Reisnera21e9292011-02-08 15:08:49 +01001917
1918 mdev->resync_work.mdev = mdev;
1919 mdev->unplug_work.mdev = mdev;
1920 mdev->go_diskless.mdev = mdev;
1921 mdev->md_sync_work.mdev = mdev;
1922 mdev->bm_io_work.w.mdev = mdev;
1923 mdev->start_resync_work.mdev = mdev;
1924
Philipp Reisnerb411b362009-09-25 16:07:19 -07001925 init_timer(&mdev->resync_timer);
1926 init_timer(&mdev->md_sync_timer);
Philipp Reisner370a43e2011-01-14 16:03:11 +01001927 init_timer(&mdev->start_resync_timer);
Philipp Reisner7fde2be2011-03-01 11:08:28 +01001928 init_timer(&mdev->request_timer);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001929 mdev->resync_timer.function = resync_timer_fn;
1930 mdev->resync_timer.data = (unsigned long) mdev;
1931 mdev->md_sync_timer.function = md_sync_timer_fn;
1932 mdev->md_sync_timer.data = (unsigned long) mdev;
Philipp Reisner370a43e2011-01-14 16:03:11 +01001933 mdev->start_resync_timer.function = start_resync_timer_fn;
1934 mdev->start_resync_timer.data = (unsigned long) mdev;
Philipp Reisner7fde2be2011-03-01 11:08:28 +01001935 mdev->request_timer.function = request_timer_fn;
1936 mdev->request_timer.data = (unsigned long) mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001937
1938 init_waitqueue_head(&mdev->misc_wait);
1939 init_waitqueue_head(&mdev->state_wait);
1940 init_waitqueue_head(&mdev->ee_wait);
1941 init_waitqueue_head(&mdev->al_wait);
1942 init_waitqueue_head(&mdev->seq_wait);
1943
Philipp Reisnerb411b362009-09-25 16:07:19 -07001944 mdev->resync_wenr = LC_FREE;
Philipp Reisner99432fc2011-05-20 16:39:13 +02001945 mdev->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
1946 mdev->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001947}
1948
1949void drbd_mdev_cleanup(struct drbd_conf *mdev)
1950{
Lars Ellenberg1d7734a2010-08-11 21:21:50 +02001951 int i;
Philipp Reisnere6b3ea82011-01-19 14:02:01 +01001952 if (mdev->tconn->receiver.t_state != NONE)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001953 dev_err(DEV, "ASSERT FAILED: receiver t_state == %d expected 0.\n",
Philipp Reisnere6b3ea82011-01-19 14:02:01 +01001954 mdev->tconn->receiver.t_state);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001955
Philipp Reisnerb411b362009-09-25 16:07:19 -07001956 mdev->al_writ_cnt =
1957 mdev->bm_writ_cnt =
1958 mdev->read_cnt =
1959 mdev->recv_cnt =
1960 mdev->send_cnt =
1961 mdev->writ_cnt =
1962 mdev->p_size =
1963 mdev->rs_start =
1964 mdev->rs_total =
Lars Ellenberg1d7734a2010-08-11 21:21:50 +02001965 mdev->rs_failed = 0;
1966 mdev->rs_last_events = 0;
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001967 mdev->rs_last_sect_ev = 0;
Lars Ellenberg1d7734a2010-08-11 21:21:50 +02001968 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
1969 mdev->rs_mark_left[i] = 0;
1970 mdev->rs_mark_time[i] = 0;
1971 }
Philipp Reisner89e58e72011-01-19 13:12:45 +01001972 D_ASSERT(mdev->tconn->net_conf == NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001973
1974 drbd_set_my_capacity(mdev, 0);
1975 if (mdev->bitmap) {
1976 /* maybe never allocated. */
Philipp Reisner02d9a942010-03-24 16:23:03 +01001977 drbd_bm_resize(mdev, 0, 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001978 drbd_bm_cleanup(mdev);
1979 }
1980
Philipp Reisner1d041222011-04-22 15:20:23 +02001981 drbd_free_bc(mdev->ldev);
1982 mdev->ldev = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001983
Philipp Reisnerb411b362009-09-25 16:07:19 -07001984 clear_bit(AL_SUSPENDED, &mdev->flags);
1985
Philipp Reisnerb411b362009-09-25 16:07:19 -07001986 D_ASSERT(list_empty(&mdev->active_ee));
1987 D_ASSERT(list_empty(&mdev->sync_ee));
1988 D_ASSERT(list_empty(&mdev->done_ee));
1989 D_ASSERT(list_empty(&mdev->read_ee));
1990 D_ASSERT(list_empty(&mdev->net_ee));
1991 D_ASSERT(list_empty(&mdev->resync_reads));
Lars Ellenbergd5b27b02011-11-14 15:42:37 +01001992 D_ASSERT(list_empty(&mdev->tconn->sender_work.q));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001993 D_ASSERT(list_empty(&mdev->resync_work.list));
1994 D_ASSERT(list_empty(&mdev->unplug_work.list));
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02001995 D_ASSERT(list_empty(&mdev->go_diskless.list));
Lars Ellenberg2265b472010-12-16 15:41:26 +01001996
1997 drbd_set_defaults(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001998}
1999
2000
2001static void drbd_destroy_mempools(void)
2002{
2003 struct page *page;
2004
2005 while (drbd_pp_pool) {
2006 page = drbd_pp_pool;
2007 drbd_pp_pool = (struct page *)page_private(page);
2008 __free_page(page);
2009 drbd_pp_vacant--;
2010 }
2011
2012 /* D_ASSERT(atomic_read(&drbd_pp_vacant)==0); */
2013
Lars Ellenberg9476f392011-02-23 17:02:01 +01002014 if (drbd_md_io_bio_set)
2015 bioset_free(drbd_md_io_bio_set);
Lars Ellenberg42818082011-02-23 12:39:46 +01002016 if (drbd_md_io_page_pool)
2017 mempool_destroy(drbd_md_io_page_pool);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002018 if (drbd_ee_mempool)
2019 mempool_destroy(drbd_ee_mempool);
2020 if (drbd_request_mempool)
2021 mempool_destroy(drbd_request_mempool);
2022 if (drbd_ee_cache)
2023 kmem_cache_destroy(drbd_ee_cache);
2024 if (drbd_request_cache)
2025 kmem_cache_destroy(drbd_request_cache);
2026 if (drbd_bm_ext_cache)
2027 kmem_cache_destroy(drbd_bm_ext_cache);
2028 if (drbd_al_ext_cache)
2029 kmem_cache_destroy(drbd_al_ext_cache);
2030
Lars Ellenberg9476f392011-02-23 17:02:01 +01002031 drbd_md_io_bio_set = NULL;
Lars Ellenberg42818082011-02-23 12:39:46 +01002032 drbd_md_io_page_pool = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002033 drbd_ee_mempool = NULL;
2034 drbd_request_mempool = NULL;
2035 drbd_ee_cache = NULL;
2036 drbd_request_cache = NULL;
2037 drbd_bm_ext_cache = NULL;
2038 drbd_al_ext_cache = NULL;
2039
2040 return;
2041}
2042
2043static int drbd_create_mempools(void)
2044{
2045 struct page *page;
Lars Ellenberg1816a2b2010-11-11 15:19:07 +01002046 const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002047 int i;
2048
2049 /* prepare our caches and mempools */
2050 drbd_request_mempool = NULL;
2051 drbd_ee_cache = NULL;
2052 drbd_request_cache = NULL;
2053 drbd_bm_ext_cache = NULL;
2054 drbd_al_ext_cache = NULL;
2055 drbd_pp_pool = NULL;
Lars Ellenberg42818082011-02-23 12:39:46 +01002056 drbd_md_io_page_pool = NULL;
Lars Ellenberg9476f392011-02-23 17:02:01 +01002057 drbd_md_io_bio_set = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002058
2059 /* caches */
2060 drbd_request_cache = kmem_cache_create(
2061 "drbd_req", sizeof(struct drbd_request), 0, 0, NULL);
2062 if (drbd_request_cache == NULL)
2063 goto Enomem;
2064
2065 drbd_ee_cache = kmem_cache_create(
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01002066 "drbd_ee", sizeof(struct drbd_peer_request), 0, 0, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002067 if (drbd_ee_cache == NULL)
2068 goto Enomem;
2069
2070 drbd_bm_ext_cache = kmem_cache_create(
2071 "drbd_bm", sizeof(struct bm_extent), 0, 0, NULL);
2072 if (drbd_bm_ext_cache == NULL)
2073 goto Enomem;
2074
2075 drbd_al_ext_cache = kmem_cache_create(
2076 "drbd_al", sizeof(struct lc_element), 0, 0, NULL);
2077 if (drbd_al_ext_cache == NULL)
2078 goto Enomem;
2079
2080 /* mempools */
Lars Ellenberg9476f392011-02-23 17:02:01 +01002081 drbd_md_io_bio_set = bioset_create(DRBD_MIN_POOL_PAGES, 0);
2082 if (drbd_md_io_bio_set == NULL)
2083 goto Enomem;
Lars Ellenberg9476f392011-02-23 17:02:01 +01002084
Lars Ellenberg42818082011-02-23 12:39:46 +01002085 drbd_md_io_page_pool = mempool_create_page_pool(DRBD_MIN_POOL_PAGES, 0);
2086 if (drbd_md_io_page_pool == NULL)
2087 goto Enomem;
2088
Philipp Reisnerb411b362009-09-25 16:07:19 -07002089 drbd_request_mempool = mempool_create(number,
2090 mempool_alloc_slab, mempool_free_slab, drbd_request_cache);
2091 if (drbd_request_mempool == NULL)
2092 goto Enomem;
2093
2094 drbd_ee_mempool = mempool_create(number,
2095 mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);
Nicolas Kaiser2027ae12010-10-28 06:15:26 -06002096 if (drbd_ee_mempool == NULL)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002097 goto Enomem;
2098
2099 /* drbd's page pool */
2100 spin_lock_init(&drbd_pp_lock);
2101
2102 for (i = 0; i < number; i++) {
2103 page = alloc_page(GFP_HIGHUSER);
2104 if (!page)
2105 goto Enomem;
2106 set_page_private(page, (unsigned long)drbd_pp_pool);
2107 drbd_pp_pool = page;
2108 }
2109 drbd_pp_vacant = number;
2110
2111 return 0;
2112
2113Enomem:
2114 drbd_destroy_mempools(); /* in case we allocated some */
2115 return -ENOMEM;
2116}
2117
2118static int drbd_notify_sys(struct notifier_block *this, unsigned long code,
2119 void *unused)
2120{
2121 /* just so we have it. you never know what interesting things we
2122 * might want to do here some day...
2123 */
2124
2125 return NOTIFY_DONE;
2126}
2127
2128static struct notifier_block drbd_notifier = {
2129 .notifier_call = drbd_notify_sys,
2130};
2131
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002132static void drbd_release_all_peer_reqs(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002133{
2134 int rr;
2135
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002136 rr = drbd_free_peer_reqs(mdev, &mdev->active_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002137 if (rr)
2138 dev_err(DEV, "%d EEs in active list found!\n", rr);
2139
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002140 rr = drbd_free_peer_reqs(mdev, &mdev->sync_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002141 if (rr)
2142 dev_err(DEV, "%d EEs in sync list found!\n", rr);
2143
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002144 rr = drbd_free_peer_reqs(mdev, &mdev->read_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002145 if (rr)
2146 dev_err(DEV, "%d EEs in read list found!\n", rr);
2147
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002148 rr = drbd_free_peer_reqs(mdev, &mdev->done_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002149 if (rr)
2150 dev_err(DEV, "%d EEs in done list found!\n", rr);
2151
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002152 rr = drbd_free_peer_reqs(mdev, &mdev->net_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002153 if (rr)
2154 dev_err(DEV, "%d EEs in net list found!\n", rr);
2155}
2156
Philipp Reisner774b3052011-02-22 02:07:03 -05002157/* caution. no locking. */
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002158void drbd_minor_destroy(struct kref *kref)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002159{
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002160 struct drbd_conf *mdev = container_of(kref, struct drbd_conf, kref);
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002161 struct drbd_tconn *tconn = mdev->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002162
Philipp Reisnerdfa8bed2011-06-29 14:06:08 +02002163 del_timer_sync(&mdev->request_timer);
2164
Philipp Reisnerb411b362009-09-25 16:07:19 -07002165 /* paranoia asserts */
Andreas Gruenbacher70dc65e2010-12-21 14:46:57 +01002166 D_ASSERT(mdev->open_cnt == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002167 /* end paranoia asserts */
2168
Philipp Reisnerb411b362009-09-25 16:07:19 -07002169 /* cleanup stuff that may have been allocated during
2170 * device (re-)configuration or state changes */
2171
2172 if (mdev->this_bdev)
2173 bdput(mdev->this_bdev);
2174
Philipp Reisner1d041222011-04-22 15:20:23 +02002175 drbd_free_bc(mdev->ldev);
2176 mdev->ldev = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002177
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02002178 drbd_release_all_peer_reqs(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002179
2180 lc_destroy(mdev->act_log);
2181 lc_destroy(mdev->resync);
2182
2183 kfree(mdev->p_uuid);
2184 /* mdev->p_uuid = NULL; */
2185
Philipp Reisnercd1d9952011-04-11 21:24:24 -07002186 if (mdev->bitmap) /* should no longer be there. */
2187 drbd_bm_cleanup(mdev);
2188 __free_page(mdev->md_io_page);
2189 put_disk(mdev->vdisk);
2190 blk_cleanup_queue(mdev->rq_queue);
Philipp Reisner9958c852011-05-03 16:19:31 +02002191 kfree(mdev->rs_plan_s);
Philipp Reisnercd1d9952011-04-11 21:24:24 -07002192 kfree(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002193
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002194 kref_put(&tconn->kref, &conn_destroy);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002195}
2196
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002197/* One global retry thread, if we need to push back some bio and have it
2198 * reinserted through our make request function.
2199 */
2200static struct retry_worker {
2201 struct workqueue_struct *wq;
2202 struct work_struct worker;
2203
2204 spinlock_t lock;
2205 struct list_head writes;
2206} retry;
2207
2208static void do_retry(struct work_struct *ws)
2209{
2210 struct retry_worker *retry = container_of(ws, struct retry_worker, worker);
2211 LIST_HEAD(writes);
2212 struct drbd_request *req, *tmp;
2213
2214 spin_lock_irq(&retry->lock);
2215 list_splice_init(&retry->writes, &writes);
2216 spin_unlock_irq(&retry->lock);
2217
2218 list_for_each_entry_safe(req, tmp, &writes, tl_requests) {
2219 struct drbd_conf *mdev = req->w.mdev;
2220 struct bio *bio = req->master_bio;
2221 unsigned long start_time = req->start_time;
Lars Ellenberg9a278a72012-07-24 10:12:36 +02002222 bool expected;
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002223
Lars Ellenberg9a278a72012-07-24 10:12:36 +02002224 expected =
2225 expect(atomic_read(&req->completion_ref) == 0) &&
2226 expect(req->rq_state & RQ_POSTPONED) &&
2227 expect((req->rq_state & RQ_LOCAL_PENDING) == 0 ||
2228 (req->rq_state & RQ_LOCAL_ABORTED) != 0);
2229
2230 if (!expected)
2231 dev_err(DEV, "req=%p completion_ref=%d rq_state=%x\n",
2232 req, atomic_read(&req->completion_ref),
2233 req->rq_state);
2234
2235 /* We still need to put one kref associated with the
2236 * "completion_ref" going zero in the code path that queued it
2237 * here. The request object may still be referenced by a
2238 * frozen local req->private_bio, in case we force-detached.
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002239 */
Lars Ellenberg9a278a72012-07-24 10:12:36 +02002240 kref_put(&req->kref, drbd_req_destroy);
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002241
2242 /* A single suspended or otherwise blocking device may stall
2243 * all others as well. Fortunately, this code path is to
2244 * recover from a situation that "should not happen":
2245 * concurrent writes in multi-primary setup.
2246 * In a "normal" lifecycle, this workqueue is supposed to be
2247 * destroyed without ever doing anything.
2248 * If it turns out to be an issue anyways, we can do per
2249 * resource (replication group) or per device (minor) retry
2250 * workqueues instead.
2251 */
2252
2253 /* We are not just doing generic_make_request(),
2254 * as we want to keep the start_time information. */
Lars Ellenberg5df69ec2012-01-24 16:49:58 +01002255 inc_ap_bio(mdev);
2256 __drbd_make_request(mdev, bio, start_time);
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002257 }
2258}
2259
Lars Ellenberg9d05e7c2012-07-17 10:05:04 +02002260void drbd_restart_request(struct drbd_request *req)
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002261{
2262 unsigned long flags;
2263 spin_lock_irqsave(&retry.lock, flags);
2264 list_move_tail(&req->tl_requests, &retry.writes);
2265 spin_unlock_irqrestore(&retry.lock, flags);
2266
2267 /* Drop the extra reference that would otherwise
2268 * have been dropped by complete_master_bio.
2269 * do_retry() needs to grab a new one. */
2270 dec_ap_bio(req->w.mdev);
2271
2272 queue_work(retry.wq, &retry.worker);
2273}
2274
2275
Philipp Reisnerb411b362009-09-25 16:07:19 -07002276static void drbd_cleanup(void)
2277{
2278 unsigned int i;
Philipp Reisner81a5d602011-02-22 19:53:16 -05002279 struct drbd_conf *mdev;
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002280 struct drbd_tconn *tconn, *tmp;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002281
2282 unregister_reboot_notifier(&drbd_notifier);
2283
Lars Ellenberg17a93f32010-11-24 10:37:35 +01002284 /* first remove proc,
2285 * drbdsetup uses it's presence to detect
2286 * whether DRBD is loaded.
2287 * If we would get stuck in proc removal,
2288 * but have netlink already deregistered,
2289 * some drbdsetup commands may wait forever
2290 * for an answer.
2291 */
2292 if (drbd_proc)
2293 remove_proc_entry("drbd", NULL);
2294
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002295 if (retry.wq)
2296 destroy_workqueue(retry.wq);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002297
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002298 drbd_genl_unregister();
Philipp Reisnerb411b362009-09-25 16:07:19 -07002299
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002300 idr_for_each_entry(&minors, mdev, i) {
2301 idr_remove(&minors, mdev_to_minor(mdev));
2302 idr_remove(&mdev->tconn->volumes, mdev->vnr);
2303 del_gendisk(mdev->vdisk);
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002304 /* synchronize_rcu(); No other threads running at this point */
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002305 kref_put(&mdev->kref, &drbd_minor_destroy);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002306 }
2307
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002308 /* not _rcu since, no other updater anymore. Genl already unregistered */
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002309 list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002310 list_del(&tconn->all_tconn); /* not _rcu no proc, not other threads */
2311 /* synchronize_rcu(); */
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002312 kref_put(&tconn->kref, &conn_destroy);
2313 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002314
Philipp Reisner81a5d602011-02-22 19:53:16 -05002315 drbd_destroy_mempools();
Philipp Reisnerb411b362009-09-25 16:07:19 -07002316 unregister_blkdev(DRBD_MAJOR, "drbd");
2317
Philipp Reisner81a5d602011-02-22 19:53:16 -05002318 idr_destroy(&minors);
2319
Philipp Reisnerb411b362009-09-25 16:07:19 -07002320 printk(KERN_INFO "drbd: module cleanup done.\n");
2321}
2322
2323/**
Artem Bityutskiyd97482e2012-07-25 18:12:12 +03002324 * drbd_congested() - Callback for the flusher thread
Philipp Reisnerb411b362009-09-25 16:07:19 -07002325 * @congested_data: User data
Artem Bityutskiyd97482e2012-07-25 18:12:12 +03002326 * @bdi_bits: Bits the BDI flusher thread is currently interested in
Philipp Reisnerb411b362009-09-25 16:07:19 -07002327 *
2328 * Returns 1<<BDI_async_congested and/or 1<<BDI_sync_congested if we are congested.
2329 */
2330static int drbd_congested(void *congested_data, int bdi_bits)
2331{
2332 struct drbd_conf *mdev = congested_data;
2333 struct request_queue *q;
2334 char reason = '-';
2335 int r = 0;
2336
Andreas Gruenbacher1b881ef2010-12-13 18:03:38 +01002337 if (!may_inc_ap_bio(mdev)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002338 /* DRBD has frozen IO */
2339 r = bdi_bits;
2340 reason = 'd';
2341 goto out;
2342 }
2343
Lars Ellenberg6f3465e2012-07-30 09:08:25 +02002344 if (test_bit(CALLBACK_PENDING, &mdev->tconn->flags)) {
Lars Ellenbergc2ba6862012-06-14 15:14:06 +02002345 r |= (1 << BDI_async_congested);
2346 /* Without good local data, we would need to read from remote,
2347 * and that would need the worker thread as well, which is
2348 * currently blocked waiting for that usermode helper to
2349 * finish.
2350 */
2351 if (!get_ldev_if_state(mdev, D_UP_TO_DATE))
2352 r |= (1 << BDI_sync_congested);
2353 else
2354 put_ldev(mdev);
2355 r &= bdi_bits;
2356 reason = 'c';
2357 goto out;
2358 }
2359
Philipp Reisnerb411b362009-09-25 16:07:19 -07002360 if (get_ldev(mdev)) {
2361 q = bdev_get_queue(mdev->ldev->backing_bdev);
2362 r = bdi_congested(&q->backing_dev_info, bdi_bits);
2363 put_ldev(mdev);
2364 if (r)
2365 reason = 'b';
2366 }
2367
Philipp Reisner01a311a2011-02-07 14:30:33 +01002368 if (bdi_bits & (1 << BDI_async_congested) && test_bit(NET_CONGESTED, &mdev->tconn->flags)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002369 r |= (1 << BDI_async_congested);
2370 reason = reason == 'b' ? 'a' : 'n';
2371 }
2372
2373out:
2374 mdev->congestion_reason = reason;
2375 return r;
2376}
2377
Philipp Reisner6699b652011-02-09 11:10:24 +01002378static void drbd_init_workqueue(struct drbd_work_queue* wq)
2379{
Philipp Reisner6699b652011-02-09 11:10:24 +01002380 spin_lock_init(&wq->q_lock);
2381 INIT_LIST_HEAD(&wq->q);
Lars Ellenberg8c0785a2011-10-19 11:50:57 +02002382 init_waitqueue_head(&wq->q_wait);
Philipp Reisner6699b652011-02-09 11:10:24 +01002383}
2384
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002385struct drbd_tconn *conn_get_by_name(const char *name)
Philipp Reisner1aba4d72011-02-21 15:38:08 +01002386{
2387 struct drbd_tconn *tconn;
2388
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002389 if (!name || !name[0])
2390 return NULL;
2391
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002392 rcu_read_lock();
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002393 list_for_each_entry_rcu(tconn, &drbd_tconns, all_tconn) {
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002394 if (!strcmp(tconn->name, name)) {
2395 kref_get(&tconn->kref);
Philipp Reisner1aba4d72011-02-21 15:38:08 +01002396 goto found;
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002397 }
Philipp Reisner1aba4d72011-02-21 15:38:08 +01002398 }
2399 tconn = NULL;
2400found:
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002401 rcu_read_unlock();
Philipp Reisner1aba4d72011-02-21 15:38:08 +01002402 return tconn;
2403}
2404
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002405struct drbd_tconn *conn_get_by_addrs(void *my_addr, int my_addr_len,
2406 void *peer_addr, int peer_addr_len)
2407{
2408 struct drbd_tconn *tconn;
2409
2410 rcu_read_lock();
2411 list_for_each_entry_rcu(tconn, &drbd_tconns, all_tconn) {
2412 if (tconn->my_addr_len == my_addr_len &&
2413 tconn->peer_addr_len == peer_addr_len &&
2414 !memcmp(&tconn->my_addr, my_addr, my_addr_len) &&
2415 !memcmp(&tconn->peer_addr, peer_addr, peer_addr_len)) {
2416 kref_get(&tconn->kref);
2417 goto found;
2418 }
2419 }
2420 tconn = NULL;
2421found:
2422 rcu_read_unlock();
2423 return tconn;
2424}
2425
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002426static int drbd_alloc_socket(struct drbd_socket *socket)
2427{
2428 socket->rbuf = (void *) __get_free_page(GFP_KERNEL);
2429 if (!socket->rbuf)
2430 return -ENOMEM;
Andreas Gruenbacher5a87d922011-03-24 21:17:52 +01002431 socket->sbuf = (void *) __get_free_page(GFP_KERNEL);
2432 if (!socket->sbuf)
2433 return -ENOMEM;
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002434 return 0;
2435}
2436
2437static void drbd_free_socket(struct drbd_socket *socket)
2438{
Andreas Gruenbacher5a87d922011-03-24 21:17:52 +01002439 free_page((unsigned long) socket->sbuf);
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002440 free_page((unsigned long) socket->rbuf);
2441}
2442
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002443void conn_free_crypto(struct drbd_tconn *tconn)
2444{
Philipp Reisner1d041222011-04-22 15:20:23 +02002445 drbd_free_sock(tconn);
2446
2447 crypto_free_hash(tconn->csums_tfm);
2448 crypto_free_hash(tconn->verify_tfm);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002449 crypto_free_hash(tconn->cram_hmac_tfm);
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02002450 crypto_free_hash(tconn->integrity_tfm);
Andreas Gruenbacher5b614ab2011-04-27 21:00:12 +02002451 crypto_free_hash(tconn->peer_integrity_tfm);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002452 kfree(tconn->int_dig_in);
2453 kfree(tconn->int_dig_vv);
Philipp Reisner1d041222011-04-22 15:20:23 +02002454
2455 tconn->csums_tfm = NULL;
2456 tconn->verify_tfm = NULL;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002457 tconn->cram_hmac_tfm = NULL;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02002458 tconn->integrity_tfm = NULL;
Andreas Gruenbacher5b614ab2011-04-27 21:00:12 +02002459 tconn->peer_integrity_tfm = NULL;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002460 tconn->int_dig_in = NULL;
2461 tconn->int_dig_vv = NULL;
2462}
2463
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002464int set_resource_options(struct drbd_tconn *tconn, struct res_opts *res_opts)
2465{
2466 cpumask_var_t new_cpu_mask;
2467 int err;
2468
2469 if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL))
2470 return -ENOMEM;
2471 /*
2472 retcode = ERR_NOMEM;
2473 drbd_msg_put_info("unable to allocate cpumask");
2474 */
2475
2476 /* silently ignore cpu mask on UP kernel */
2477 if (nr_cpu_ids > 1 && res_opts->cpu_mask[0] != 0) {
2478 /* FIXME: Get rid of constant 32 here */
Philipp Reisnerc5b005a2012-04-30 12:53:52 +02002479 err = bitmap_parse(res_opts->cpu_mask, 32,
2480 cpumask_bits(new_cpu_mask), nr_cpu_ids);
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002481 if (err) {
Philipp Reisnerc5b005a2012-04-30 12:53:52 +02002482 conn_warn(tconn, "bitmap_parse() failed with %d\n", err);
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002483 /* retcode = ERR_CPU_MASK_PARSE; */
2484 goto fail;
2485 }
2486 }
2487 tconn->res_opts = *res_opts;
2488 if (!cpumask_equal(tconn->cpu_mask, new_cpu_mask)) {
2489 cpumask_copy(tconn->cpu_mask, new_cpu_mask);
2490 drbd_calc_cpu_mask(tconn);
2491 tconn->receiver.reset_cpu_mask = 1;
2492 tconn->asender.reset_cpu_mask = 1;
2493 tconn->worker.reset_cpu_mask = 1;
2494 }
2495 err = 0;
2496
2497fail:
2498 free_cpumask_var(new_cpu_mask);
2499 return err;
2500
2501}
2502
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002503/* caller must be under genl_lock() */
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002504struct drbd_tconn *conn_create(const char *name, struct res_opts *res_opts)
Philipp Reisner21114382011-01-19 12:26:59 +01002505{
2506 struct drbd_tconn *tconn;
2507
2508 tconn = kzalloc(sizeof(struct drbd_tconn), GFP_KERNEL);
2509 if (!tconn)
2510 return NULL;
2511
2512 tconn->name = kstrdup(name, GFP_KERNEL);
2513 if (!tconn->name)
2514 goto fail;
2515
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002516 if (drbd_alloc_socket(&tconn->data))
2517 goto fail;
2518 if (drbd_alloc_socket(&tconn->meta))
2519 goto fail;
2520
Philipp Reisner774b3052011-02-22 02:07:03 -05002521 if (!zalloc_cpumask_var(&tconn->cpu_mask, GFP_KERNEL))
2522 goto fail;
2523
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002524 if (set_resource_options(tconn, res_opts))
2525 goto fail;
2526
Philipp Reisner12038a32011-11-09 19:18:00 +01002527 tconn->current_epoch = kzalloc(sizeof(struct drbd_epoch), GFP_KERNEL);
2528 if (!tconn->current_epoch)
2529 goto fail;
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +01002530
2531 INIT_LIST_HEAD(&tconn->transfer_log);
2532
Philipp Reisner12038a32011-11-09 19:18:00 +01002533 INIT_LIST_HEAD(&tconn->current_epoch->list);
2534 tconn->epochs = 1;
2535 spin_lock_init(&tconn->epoch_lock);
Philipp Reisner4b0007c2011-11-09 20:12:34 +01002536 tconn->write_ordering = WO_bdev_flush;
2537
Lars Ellenbergb6dd1a82011-11-28 15:04:49 +01002538 tconn->send.seen_any_write_yet = false;
2539 tconn->send.current_epoch_nr = 0;
2540 tconn->send.current_epoch_writes = 0;
2541
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01002542 tconn->cstate = C_STANDALONE;
Philipp Reisner8410da82011-02-11 20:11:10 +01002543 mutex_init(&tconn->cstate_mutex);
Philipp Reisner6699b652011-02-09 11:10:24 +01002544 spin_lock_init(&tconn->req_lock);
Philipp Reisnera0095502011-05-03 13:14:15 +02002545 mutex_init(&tconn->conf_update);
Philipp Reisner2a67d8b2011-02-09 14:10:32 +01002546 init_waitqueue_head(&tconn->ping_wait);
Philipp Reisner062e8792011-02-08 11:09:18 +01002547 idr_init(&tconn->volumes);
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +01002548
Lars Ellenbergd5b27b02011-11-14 15:42:37 +01002549 drbd_init_workqueue(&tconn->sender_work);
Philipp Reisner6699b652011-02-09 11:10:24 +01002550 mutex_init(&tconn->data.mutex);
Philipp Reisner6699b652011-02-09 11:10:24 +01002551 mutex_init(&tconn->meta.mutex);
2552
Philipp Reisner392c8802011-02-09 10:33:31 +01002553 drbd_thread_init(tconn, &tconn->receiver, drbdd_init, "receiver");
2554 drbd_thread_init(tconn, &tconn->worker, drbd_worker, "worker");
2555 drbd_thread_init(tconn, &tconn->asender, drbd_asender, "asender");
2556
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002557 kref_init(&tconn->kref);
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002558 list_add_tail_rcu(&tconn->all_tconn, &drbd_tconns);
Philipp Reisner21114382011-01-19 12:26:59 +01002559
2560 return tconn;
2561
2562fail:
Philipp Reisner12038a32011-11-09 19:18:00 +01002563 kfree(tconn->current_epoch);
Philipp Reisner774b3052011-02-22 02:07:03 -05002564 free_cpumask_var(tconn->cpu_mask);
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002565 drbd_free_socket(&tconn->meta);
2566 drbd_free_socket(&tconn->data);
Philipp Reisner21114382011-01-19 12:26:59 +01002567 kfree(tconn->name);
2568 kfree(tconn);
2569
2570 return NULL;
2571}
2572
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002573void conn_destroy(struct kref *kref)
Philipp Reisner21114382011-01-19 12:26:59 +01002574{
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002575 struct drbd_tconn *tconn = container_of(kref, struct drbd_tconn, kref);
2576
Philipp Reisner12038a32011-11-09 19:18:00 +01002577 if (atomic_read(&tconn->current_epoch->epoch_size) != 0)
2578 conn_err(tconn, "epoch_size:%d\n", atomic_read(&tconn->current_epoch->epoch_size));
2579 kfree(tconn->current_epoch);
2580
Philipp Reisner062e8792011-02-08 11:09:18 +01002581 idr_destroy(&tconn->volumes);
Philipp Reisner21114382011-01-19 12:26:59 +01002582
Philipp Reisner774b3052011-02-22 02:07:03 -05002583 free_cpumask_var(tconn->cpu_mask);
Andreas Gruenbachere6ef8a52011-03-24 18:07:54 +01002584 drbd_free_socket(&tconn->meta);
2585 drbd_free_socket(&tconn->data);
Philipp Reisner21114382011-01-19 12:26:59 +01002586 kfree(tconn->name);
Philipp Reisnerb42a70a2011-01-27 10:55:20 +01002587 kfree(tconn->int_dig_in);
2588 kfree(tconn->int_dig_vv);
Philipp Reisner21114382011-01-19 12:26:59 +01002589 kfree(tconn);
2590}
2591
Philipp Reisner774b3052011-02-22 02:07:03 -05002592enum drbd_ret_code conn_new_minor(struct drbd_tconn *tconn, unsigned int minor, int vnr)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002593{
2594 struct drbd_conf *mdev;
2595 struct gendisk *disk;
2596 struct request_queue *q;
Philipp Reisner774b3052011-02-22 02:07:03 -05002597 int vnr_got = vnr;
Philipp Reisner81a5d602011-02-22 19:53:16 -05002598 int minor_got = minor;
Lars Ellenberg8432b312011-03-08 16:11:16 +01002599 enum drbd_ret_code err = ERR_NOMEM;
Philipp Reisner774b3052011-02-22 02:07:03 -05002600
2601 mdev = minor_to_mdev(minor);
2602 if (mdev)
2603 return ERR_MINOR_EXISTS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002604
2605 /* GFP_KERNEL, we are outside of all write-out paths */
2606 mdev = kzalloc(sizeof(struct drbd_conf), GFP_KERNEL);
2607 if (!mdev)
Philipp Reisner774b3052011-02-22 02:07:03 -05002608 return ERR_NOMEM;
2609
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002610 kref_get(&tconn->kref);
Philipp Reisner774b3052011-02-22 02:07:03 -05002611 mdev->tconn = tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002612
2613 mdev->minor = minor;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002614 mdev->vnr = vnr;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002615
2616 drbd_init_set_defaults(mdev);
2617
2618 q = blk_alloc_queue(GFP_KERNEL);
2619 if (!q)
2620 goto out_no_q;
2621 mdev->rq_queue = q;
2622 q->queuedata = mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002623
2624 disk = alloc_disk(1);
2625 if (!disk)
2626 goto out_no_disk;
2627 mdev->vdisk = disk;
2628
Andreas Gruenbacher81e84652010-12-09 15:03:57 +01002629 set_disk_ro(disk, true);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002630
2631 disk->queue = q;
2632 disk->major = DRBD_MAJOR;
2633 disk->first_minor = minor;
2634 disk->fops = &drbd_ops;
2635 sprintf(disk->disk_name, "drbd%d", minor);
2636 disk->private_data = mdev;
2637
2638 mdev->this_bdev = bdget(MKDEV(DRBD_MAJOR, minor));
2639 /* we have no partitions. we contain only ourselves. */
2640 mdev->this_bdev->bd_contains = mdev->this_bdev;
2641
2642 q->backing_dev_info.congested_fn = drbd_congested;
2643 q->backing_dev_info.congested_data = mdev;
2644
Andreas Gruenbacher2f58dcf2010-12-13 17:48:19 +01002645 blk_queue_make_request(q, drbd_make_request);
Lars Ellenberga73ff322012-06-25 19:15:38 +02002646 blk_queue_flush(q, REQ_FLUSH | REQ_FUA);
Philipp Reisner99432fc2011-05-20 16:39:13 +02002647 /* Setting the max_hw_sectors to an odd value of 8kibyte here
2648 This triggers a max_bio_size message upon first attach or connect */
2649 blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002650 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
2651 blk_queue_merge_bvec(q, drbd_merge_bvec);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002652 q->queue_lock = &mdev->tconn->req_lock; /* needed since we use */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002653
2654 mdev->md_io_page = alloc_page(GFP_KERNEL);
2655 if (!mdev->md_io_page)
2656 goto out_no_io_page;
2657
2658 if (drbd_bm_init(mdev))
2659 goto out_no_bitmap;
Andreas Gruenbacherdac13892011-01-21 17:18:39 +01002660 mdev->read_requests = RB_ROOT;
Andreas Gruenbacherde696712011-01-20 15:00:24 +01002661 mdev->write_requests = RB_ROOT;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002662
Tejun Heo56de2102013-02-27 17:04:01 -08002663 minor_got = idr_alloc(&minors, mdev, minor, minor + 1, GFP_KERNEL);
2664 if (minor_got < 0) {
2665 if (minor_got == -ENOSPC) {
2666 err = ERR_MINOR_EXISTS;
2667 drbd_msg_put_info("requested minor exists already");
2668 }
Lars Ellenberg8432b312011-03-08 16:11:16 +01002669 goto out_no_minor_idr;
Tejun Heo56de2102013-02-27 17:04:01 -08002670 }
2671
2672 vnr_got = idr_alloc(&tconn->volumes, mdev, vnr, vnr + 1, GFP_KERNEL);
2673 if (vnr_got < 0) {
2674 if (vnr_got == -ENOSPC) {
2675 err = ERR_INVALID_REQUEST;
2676 drbd_msg_put_info("requested volume exists already");
2677 }
Lars Ellenberg8432b312011-03-08 16:11:16 +01002678 goto out_idr_remove_minor;
Lars Ellenberg569083c2011-03-07 09:49:02 +01002679 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002680
Philipp Reisner774b3052011-02-22 02:07:03 -05002681 add_disk(disk);
Philipp Reisner81fa2e62011-05-04 15:10:30 +02002682 kref_init(&mdev->kref); /* one ref for both idrs and the the add_disk */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002683
Philipp Reisner2325eb62011-03-15 16:56:18 +01002684 /* inherit the connection state */
2685 mdev->state.conn = tconn->cstate;
2686 if (mdev->state.conn == C_WF_REPORT_PARAMS)
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002687 drbd_connected(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002688
Philipp Reisner774b3052011-02-22 02:07:03 -05002689 return NO_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002690
Lars Ellenberg8432b312011-03-08 16:11:16 +01002691out_idr_remove_minor:
2692 idr_remove(&minors, minor_got);
Lars Ellenberg569083c2011-03-07 09:49:02 +01002693 synchronize_rcu();
Lars Ellenberg8432b312011-03-08 16:11:16 +01002694out_no_minor_idr:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002695 drbd_bm_cleanup(mdev);
2696out_no_bitmap:
2697 __free_page(mdev->md_io_page);
2698out_no_io_page:
2699 put_disk(disk);
2700out_no_disk:
2701 blk_cleanup_queue(q);
2702out_no_q:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002703 kfree(mdev);
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002704 kref_put(&tconn->kref, &conn_destroy);
Lars Ellenberg8432b312011-03-08 16:11:16 +01002705 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002706}
2707
Philipp Reisnerb411b362009-09-25 16:07:19 -07002708int __init drbd_init(void)
2709{
2710 int err;
2711
Philipp Reisner2b8a90b2011-01-10 11:15:17 +01002712 if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002713 printk(KERN_ERR
Philipp Reisner81a5d602011-02-22 19:53:16 -05002714 "drbd: invalid minor_count (%d)\n", minor_count);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002715#ifdef MODULE
2716 return -EINVAL;
2717#else
Andreas Gruenbacher46530e82011-05-31 13:08:53 +02002718 minor_count = DRBD_MINOR_COUNT_DEF;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002719#endif
2720 }
2721
Philipp Reisnerb411b362009-09-25 16:07:19 -07002722 err = register_blkdev(DRBD_MAJOR, "drbd");
2723 if (err) {
2724 printk(KERN_ERR
2725 "drbd: unable to register block device major %d\n",
2726 DRBD_MAJOR);
2727 return err;
2728 }
2729
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002730 err = drbd_genl_register();
2731 if (err) {
2732 printk(KERN_ERR "drbd: unable to register generic netlink family\n");
2733 goto fail;
2734 }
2735
2736
Philipp Reisnerb411b362009-09-25 16:07:19 -07002737 register_reboot_notifier(&drbd_notifier);
2738
2739 /*
2740 * allocate all necessary structs
2741 */
2742 err = -ENOMEM;
2743
2744 init_waitqueue_head(&drbd_pp_wait);
2745
2746 drbd_proc = NULL; /* play safe for drbd_cleanup */
Philipp Reisner81a5d602011-02-22 19:53:16 -05002747 idr_init(&minors);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002748
2749 err = drbd_create_mempools();
2750 if (err)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002751 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002752
Lars Ellenberg8c484ee2010-03-11 16:47:58 +01002753 drbd_proc = proc_create_data("drbd", S_IFREG | S_IRUGO , NULL, &drbd_proc_fops, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002754 if (!drbd_proc) {
2755 printk(KERN_ERR "drbd: unable to register proc file\n");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002756 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002757 }
2758
2759 rwlock_init(&global_state_lock);
Philipp Reisner21114382011-01-19 12:26:59 +01002760 INIT_LIST_HEAD(&drbd_tconns);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002761
Lars Ellenberg2312f0b32011-11-24 10:36:25 +01002762 retry.wq = create_singlethread_workqueue("drbd-reissue");
2763 if (!retry.wq) {
2764 printk(KERN_ERR "drbd: unable to create retry workqueue\n");
2765 goto fail;
2766 }
2767 INIT_WORK(&retry.worker, do_retry);
2768 spin_lock_init(&retry.lock);
2769 INIT_LIST_HEAD(&retry.writes);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002770
2771 printk(KERN_INFO "drbd: initialized. "
2772 "Version: " REL_VERSION " (api:%d/proto:%d-%d)\n",
2773 API_VERSION, PRO_VERSION_MIN, PRO_VERSION_MAX);
2774 printk(KERN_INFO "drbd: %s\n", drbd_buildtag());
2775 printk(KERN_INFO "drbd: registered as block device major %d\n",
2776 DRBD_MAJOR);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002777
2778 return 0; /* Success! */
2779
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002780fail:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002781 drbd_cleanup();
2782 if (err == -ENOMEM)
2783 /* currently always the case */
2784 printk(KERN_ERR "drbd: ran out of memory\n");
2785 else
2786 printk(KERN_ERR "drbd: initialization failure\n");
2787 return err;
2788}
2789
2790void drbd_free_bc(struct drbd_backing_dev *ldev)
2791{
2792 if (ldev == NULL)
2793 return;
2794
Tejun Heoe525fd82010-11-13 11:55:17 +01002795 blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2796 blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002797
2798 kfree(ldev);
2799}
2800
Philipp Reisner360cc742011-02-08 14:29:53 +01002801void drbd_free_sock(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002802{
Philipp Reisner360cc742011-02-08 14:29:53 +01002803 if (tconn->data.socket) {
2804 mutex_lock(&tconn->data.mutex);
2805 kernel_sock_shutdown(tconn->data.socket, SHUT_RDWR);
2806 sock_release(tconn->data.socket);
2807 tconn->data.socket = NULL;
2808 mutex_unlock(&tconn->data.mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002809 }
Philipp Reisner360cc742011-02-08 14:29:53 +01002810 if (tconn->meta.socket) {
2811 mutex_lock(&tconn->meta.mutex);
2812 kernel_sock_shutdown(tconn->meta.socket, SHUT_RDWR);
2813 sock_release(tconn->meta.socket);
2814 tconn->meta.socket = NULL;
2815 mutex_unlock(&tconn->meta.mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002816 }
2817}
2818
Philipp Reisnerb411b362009-09-25 16:07:19 -07002819/* meta data management */
2820
Philipp Reisner19fffd72012-08-28 16:48:03 +02002821void conn_md_sync(struct drbd_tconn *tconn)
2822{
2823 struct drbd_conf *mdev;
2824 int vnr;
2825
2826 rcu_read_lock();
2827 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
2828 kref_get(&mdev->kref);
2829 rcu_read_unlock();
2830 drbd_md_sync(mdev);
2831 kref_put(&mdev->kref, &drbd_minor_destroy);
2832 rcu_read_lock();
2833 }
2834 rcu_read_unlock();
2835}
2836
Lars Ellenbergae8bf312013-03-19 18:16:43 +01002837/* aligned 4kByte */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002838struct meta_data_on_disk {
2839 u64 la_size; /* last agreed size. */
2840 u64 uuid[UI_SIZE]; /* UUIDs. */
2841 u64 device_uuid;
2842 u64 reserved_u64_1;
2843 u32 flags; /* MDF */
2844 u32 magic;
2845 u32 md_size_sect;
2846 u32 al_offset; /* offset to this block */
Lars Ellenbergae8bf312013-03-19 18:16:43 +01002847 u32 al_nr_extents; /* important for restoring the AL (userspace) */
Lars Ellenbergf3990022011-03-23 14:31:09 +01002848 /* `-- act_log->nr_elements <-- ldev->dc.al_extents */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002849 u32 bm_offset; /* offset to the bitmap, from here */
2850 u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */
Philipp Reisner99432fc2011-05-20 16:39:13 +02002851 u32 la_peer_max_bio_size; /* last peer max_bio_size */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002852
Lars Ellenbergae8bf312013-03-19 18:16:43 +01002853 u8 reserved_u8[4096 - (7*8 + 8*4)];
Philipp Reisnerb411b362009-09-25 16:07:19 -07002854} __packed;
2855
2856/**
2857 * drbd_md_sync() - Writes the meta data super block if the MD_DIRTY flag bit is set
2858 * @mdev: DRBD device.
2859 */
2860void drbd_md_sync(struct drbd_conf *mdev)
2861{
2862 struct meta_data_on_disk *buffer;
2863 sector_t sector;
2864 int i;
2865
Lars Ellenbergae8bf312013-03-19 18:16:43 +01002866 /* Don't accidentally change the DRBD meta data layout. */
2867 BUILD_BUG_ON(UI_SIZE != 4);
2868 BUILD_BUG_ON(sizeof(struct meta_data_on_disk) != 4096);
2869
Lars Ellenbergee15b032010-09-03 10:00:09 +02002870 del_timer(&mdev->md_sync_timer);
2871 /* timer may be rearmed by drbd_md_mark_dirty() now. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002872 if (!test_and_clear_bit(MD_DIRTY, &mdev->flags))
2873 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002874
2875 /* We use here D_FAILED and not D_ATTACHING because we try to write
2876 * metadata even if we detach due to a disk failure! */
2877 if (!get_ldev_if_state(mdev, D_FAILED))
2878 return;
2879
Philipp Reisnere1711732011-06-27 11:51:46 +02002880 buffer = drbd_md_get_buffer(mdev);
2881 if (!buffer)
2882 goto out;
2883
Lars Ellenbergae8bf312013-03-19 18:16:43 +01002884 memset(buffer, 0, sizeof(*buffer));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002885
2886 buffer->la_size = cpu_to_be64(drbd_get_capacity(mdev->this_bdev));
2887 for (i = UI_CURRENT; i < UI_SIZE; i++)
2888 buffer->uuid[i] = cpu_to_be64(mdev->ldev->md.uuid[i]);
2889 buffer->flags = cpu_to_be32(mdev->ldev->md.flags);
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02002890 buffer->magic = cpu_to_be32(DRBD_MD_MAGIC_84_UNCLEAN);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002891
2892 buffer->md_size_sect = cpu_to_be32(mdev->ldev->md.md_size_sect);
2893 buffer->al_offset = cpu_to_be32(mdev->ldev->md.al_offset);
2894 buffer->al_nr_extents = cpu_to_be32(mdev->act_log->nr_elements);
2895 buffer->bm_bytes_per_bit = cpu_to_be32(BM_BLOCK_SIZE);
2896 buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);
2897
2898 buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);
Philipp Reisner99432fc2011-05-20 16:39:13 +02002899 buffer->la_peer_max_bio_size = cpu_to_be32(mdev->peer_max_bio_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002900
2901 D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);
2902 sector = mdev->ldev->md.md_offset;
2903
Andreas Gruenbacher3fbf4d22010-12-13 02:25:41 +01002904 if (drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002905 /* this was a try anyways ... */
2906 dev_err(DEV, "meta data update failed!\n");
Lars Ellenberg383606e2012-06-14 14:21:32 +02002907 drbd_chk_io_error(mdev, 1, DRBD_META_IO_ERROR);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002908 }
2909
2910 /* Update mdev->ldev->md.la_size_sect,
2911 * since we updated it on metadata. */
2912 mdev->ldev->md.la_size_sect = drbd_get_capacity(mdev->this_bdev);
2913
Philipp Reisnere1711732011-06-27 11:51:46 +02002914 drbd_md_put_buffer(mdev);
2915out:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002916 put_ldev(mdev);
2917}
2918
2919/**
2920 * drbd_md_read() - Reads in the meta data super block
2921 * @mdev: DRBD device.
2922 * @bdev: Device from which the meta data should be read in.
2923 *
Andreas Gruenbacher116676c2010-12-08 13:33:11 +01002924 * Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02002925 * something goes wrong.
Philipp Reisnerb411b362009-09-25 16:07:19 -07002926 */
2927int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)
2928{
2929 struct meta_data_on_disk *buffer;
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02002930 u32 magic, flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002931 int i, rv = NO_ERROR;
2932
2933 if (!get_ldev_if_state(mdev, D_ATTACHING))
2934 return ERR_IO_MD_DISK;
2935
Philipp Reisnere1711732011-06-27 11:51:46 +02002936 buffer = drbd_md_get_buffer(mdev);
2937 if (!buffer)
2938 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002939
Andreas Gruenbacher3fbf4d22010-12-13 02:25:41 +01002940 if (drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002941 /* NOTE: can't do normal error processing here as this is
Philipp Reisnerb411b362009-09-25 16:07:19 -07002942 called BEFORE disk is attached */
2943 dev_err(DEV, "Error while reading metadata.\n");
2944 rv = ERR_IO_MD_DISK;
2945 goto err;
2946 }
2947
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02002948 magic = be32_to_cpu(buffer->magic);
2949 flags = be32_to_cpu(buffer->flags);
2950 if (magic == DRBD_MD_MAGIC_84_UNCLEAN ||
2951 (magic == DRBD_MD_MAGIC_08 && !(flags & MDF_AL_CLEAN))) {
2952 /* btw: that's Activity Log clean, not "all" clean. */
2953 dev_err(DEV, "Found unclean meta data. Did you \"drbdadm apply-al\"?\n");
2954 rv = ERR_MD_UNCLEAN;
2955 goto err;
2956 }
2957 if (magic != DRBD_MD_MAGIC_08) {
Philipp Reisner43de7c82011-11-10 13:16:13 +01002958 if (magic == DRBD_MD_MAGIC_07)
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02002959 dev_err(DEV, "Found old (0.7) meta data magic. Did you \"drbdadm create-md\"?\n");
2960 else
2961 dev_err(DEV, "Meta data magic not found. Did you \"drbdadm create-md\"?\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07002962 rv = ERR_MD_INVALID;
2963 goto err;
2964 }
2965 if (be32_to_cpu(buffer->al_offset) != bdev->md.al_offset) {
2966 dev_err(DEV, "unexpected al_offset: %d (expected %d)\n",
2967 be32_to_cpu(buffer->al_offset), bdev->md.al_offset);
2968 rv = ERR_MD_INVALID;
2969 goto err;
2970 }
2971 if (be32_to_cpu(buffer->bm_offset) != bdev->md.bm_offset) {
2972 dev_err(DEV, "unexpected bm_offset: %d (expected %d)\n",
2973 be32_to_cpu(buffer->bm_offset), bdev->md.bm_offset);
2974 rv = ERR_MD_INVALID;
2975 goto err;
2976 }
2977 if (be32_to_cpu(buffer->md_size_sect) != bdev->md.md_size_sect) {
2978 dev_err(DEV, "unexpected md_size: %u (expected %u)\n",
2979 be32_to_cpu(buffer->md_size_sect), bdev->md.md_size_sect);
2980 rv = ERR_MD_INVALID;
2981 goto err;
2982 }
2983
2984 if (be32_to_cpu(buffer->bm_bytes_per_bit) != BM_BLOCK_SIZE) {
2985 dev_err(DEV, "unexpected bm_bytes_per_bit: %u (expected %u)\n",
2986 be32_to_cpu(buffer->bm_bytes_per_bit), BM_BLOCK_SIZE);
2987 rv = ERR_MD_INVALID;
2988 goto err;
2989 }
2990
2991 bdev->md.la_size_sect = be64_to_cpu(buffer->la_size);
2992 for (i = UI_CURRENT; i < UI_SIZE; i++)
2993 bdev->md.uuid[i] = be64_to_cpu(buffer->uuid[i]);
2994 bdev->md.flags = be32_to_cpu(buffer->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002995 bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);
2996
Philipp Reisner87eeee42011-01-19 14:16:30 +01002997 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner99432fc2011-05-20 16:39:13 +02002998 if (mdev->state.conn < C_CONNECTED) {
Lars Ellenbergdb141b22012-06-25 19:15:58 +02002999 unsigned int peer;
Philipp Reisner99432fc2011-05-20 16:39:13 +02003000 peer = be32_to_cpu(buffer->la_peer_max_bio_size);
Lars Ellenbergdb141b22012-06-25 19:15:58 +02003001 peer = max(peer, DRBD_MAX_BIO_SIZE_SAFE);
Philipp Reisner99432fc2011-05-20 16:39:13 +02003002 mdev->peer_max_bio_size = peer;
3003 }
Philipp Reisner87eeee42011-01-19 14:16:30 +01003004 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003005
3006 err:
Philipp Reisnere1711732011-06-27 11:51:46 +02003007 drbd_md_put_buffer(mdev);
3008 out:
Philipp Reisnerb411b362009-09-25 16:07:19 -07003009 put_ldev(mdev);
3010
3011 return rv;
3012}
3013
3014/**
3015 * drbd_md_mark_dirty() - Mark meta data super block as dirty
3016 * @mdev: DRBD device.
3017 *
3018 * Call this function if you change anything that should be written to
3019 * the meta-data super block. This function sets MD_DIRTY, and starts a
3020 * timer that ensures that within five seconds you have to call drbd_md_sync().
3021 */
Lars Ellenbergca0e6092010-10-14 15:01:21 +02003022#ifdef DEBUG
Lars Ellenbergee15b032010-09-03 10:00:09 +02003023void drbd_md_mark_dirty_(struct drbd_conf *mdev, unsigned int line, const char *func)
3024{
3025 if (!test_and_set_bit(MD_DIRTY, &mdev->flags)) {
3026 mod_timer(&mdev->md_sync_timer, jiffies + HZ);
3027 mdev->last_md_mark_dirty.line = line;
3028 mdev->last_md_mark_dirty.func = func;
3029 }
3030}
3031#else
Philipp Reisnerb411b362009-09-25 16:07:19 -07003032void drbd_md_mark_dirty(struct drbd_conf *mdev)
3033{
Lars Ellenbergee15b032010-09-03 10:00:09 +02003034 if (!test_and_set_bit(MD_DIRTY, &mdev->flags))
Lars Ellenbergca0e6092010-10-14 15:01:21 +02003035 mod_timer(&mdev->md_sync_timer, jiffies + 5*HZ);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003036}
Lars Ellenbergee15b032010-09-03 10:00:09 +02003037#endif
Philipp Reisnerb411b362009-09-25 16:07:19 -07003038
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003039void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003040{
3041 int i;
3042
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003043 for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003044 mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];
Philipp Reisnerb411b362009-09-25 16:07:19 -07003045}
3046
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003047void __drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003048{
3049 if (idx == UI_CURRENT) {
3050 if (mdev->state.role == R_PRIMARY)
3051 val |= 1;
3052 else
3053 val &= ~((u64)1);
3054
3055 drbd_set_ed_uuid(mdev, val);
3056 }
3057
3058 mdev->ldev->md.uuid[idx] = val;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003059 drbd_md_mark_dirty(mdev);
3060}
3061
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003062void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3063{
3064 unsigned long flags;
3065 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
3066 __drbd_uuid_set(mdev, idx, val);
3067 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
3068}
Philipp Reisnerb411b362009-09-25 16:07:19 -07003069
3070void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)
3071{
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003072 unsigned long flags;
3073 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003074 if (mdev->ldev->md.uuid[idx]) {
3075 drbd_uuid_move_history(mdev);
3076 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];
Philipp Reisnerb411b362009-09-25 16:07:19 -07003077 }
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003078 __drbd_uuid_set(mdev, idx, val);
3079 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003080}
3081
3082/**
3083 * drbd_uuid_new_current() - Creates a new current UUID
3084 * @mdev: DRBD device.
3085 *
3086 * Creates a new current UUID, and rotates the old current UUID into
3087 * the bitmap slot. Causes an incremental resync upon next connect.
3088 */
3089void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)
3090{
3091 u64 val;
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003092 unsigned long long bm_uuid;
3093
3094 get_random_bytes(&val, sizeof(u64));
3095
3096 spin_lock_irq(&mdev->ldev->md.uuid_lock);
3097 bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
Philipp Reisnerb411b362009-09-25 16:07:19 -07003098
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003099 if (bm_uuid)
3100 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
3101
Philipp Reisnerb411b362009-09-25 16:07:19 -07003102 mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003103 __drbd_uuid_set(mdev, UI_CURRENT, val);
3104 spin_unlock_irq(&mdev->ldev->md.uuid_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003105
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003106 drbd_print_uuids(mdev, "new current UUID");
Lars Ellenbergaaa8e2b2010-10-15 13:16:53 +02003107 /* get it to stable storage _now_ */
3108 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003109}
3110
3111void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local)
3112{
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003113 unsigned long flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003114 if (mdev->ldev->md.uuid[UI_BITMAP] == 0 && val == 0)
3115 return;
3116
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003117 spin_lock_irqsave(&mdev->ldev->md.uuid_lock, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003118 if (val == 0) {
3119 drbd_uuid_move_history(mdev);
3120 mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];
3121 mdev->ldev->md.uuid[UI_BITMAP] = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003122 } else {
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003123 unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];
3124 if (bm_uuid)
3125 dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003126
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003127 mdev->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003128 }
Philipp Reisner9f2247b2012-08-16 14:25:58 +02003129 spin_unlock_irqrestore(&mdev->ldev->md.uuid_lock, flags);
3130
Philipp Reisnerb411b362009-09-25 16:07:19 -07003131 drbd_md_mark_dirty(mdev);
3132}
3133
3134/**
3135 * drbd_bmio_set_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3136 * @mdev: DRBD device.
3137 *
3138 * Sets all bits in the bitmap and writes the whole bitmap to stable storage.
3139 */
3140int drbd_bmio_set_n_write(struct drbd_conf *mdev)
3141{
3142 int rv = -EIO;
3143
3144 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3145 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3146 drbd_md_sync(mdev);
3147 drbd_bm_set_all(mdev);
3148
3149 rv = drbd_bm_write(mdev);
3150
3151 if (!rv) {
3152 drbd_md_clear_flag(mdev, MDF_FULL_SYNC);
3153 drbd_md_sync(mdev);
3154 }
3155
3156 put_ldev(mdev);
3157 }
3158
3159 return rv;
3160}
3161
3162/**
3163 * drbd_bmio_clear_n_write() - io_fn for drbd_queue_bitmap_io() or drbd_bitmap_io()
3164 * @mdev: DRBD device.
3165 *
3166 * Clears all bits in the bitmap and writes the whole bitmap to stable storage.
3167 */
3168int drbd_bmio_clear_n_write(struct drbd_conf *mdev)
3169{
3170 int rv = -EIO;
3171
Philipp Reisner07782862010-08-31 12:00:50 +02003172 drbd_resume_al(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003173 if (get_ldev_if_state(mdev, D_ATTACHING)) {
3174 drbd_bm_clear_all(mdev);
3175 rv = drbd_bm_write(mdev);
3176 put_ldev(mdev);
3177 }
3178
3179 return rv;
3180}
3181
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003182static int w_bitmap_io(struct drbd_work *w, int unused)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003183{
3184 struct bm_io_work *work = container_of(w, struct bm_io_work, w);
Philipp Reisner00d56942011-02-09 18:09:48 +01003185 struct drbd_conf *mdev = w->mdev;
Lars Ellenberg02851e92010-12-16 14:47:39 +01003186 int rv = -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003187
3188 D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);
3189
Lars Ellenberg02851e92010-12-16 14:47:39 +01003190 if (get_ldev(mdev)) {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003191 drbd_bm_lock(mdev, work->why, work->flags);
Lars Ellenberg02851e92010-12-16 14:47:39 +01003192 rv = work->io_fn(mdev);
3193 drbd_bm_unlock(mdev);
3194 put_ldev(mdev);
3195 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003196
Lars Ellenberg4738fa12011-02-21 13:20:55 +01003197 clear_bit_unlock(BITMAP_IO, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003198 wake_up(&mdev->misc_wait);
3199
3200 if (work->done)
3201 work->done(mdev, rv);
3202
3203 clear_bit(BITMAP_IO_QUEUED, &mdev->flags);
3204 work->why = NULL;
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003205 work->flags = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003206
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003207 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003208}
3209
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02003210void drbd_ldev_destroy(struct drbd_conf *mdev)
3211{
3212 lc_destroy(mdev->resync);
3213 mdev->resync = NULL;
3214 lc_destroy(mdev->act_log);
3215 mdev->act_log = NULL;
3216 __no_warn(local,
3217 drbd_free_bc(mdev->ldev);
3218 mdev->ldev = NULL;);
3219
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02003220 clear_bit(GO_DISKLESS, &mdev->flags);
3221}
3222
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003223static int w_go_diskless(struct drbd_work *w, int unused)
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02003224{
Philipp Reisner00d56942011-02-09 18:09:48 +01003225 struct drbd_conf *mdev = w->mdev;
3226
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02003227 D_ASSERT(mdev->state.disk == D_FAILED);
Lars Ellenberg9d282872010-10-14 13:57:07 +02003228 /* we cannot assert local_cnt == 0 here, as get_ldev_if_state will
3229 * inc/dec it frequently. Once we are D_DISKLESS, no one will touch
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02003230 * the protected members anymore, though, so once put_ldev reaches zero
3231 * again, it will be safe to free them. */
Lars Ellenberga2a3c74f2012-09-22 12:26:57 +02003232
3233 /* Try to write changed bitmap pages, read errors may have just
3234 * set some bits outside the area covered by the activity log.
3235 *
3236 * If we have an IO error during the bitmap writeout,
3237 * we will want a full sync next time, just in case.
3238 * (Do we want a specific meta data flag for this?)
3239 *
3240 * If that does not make it to stable storage either,
Philipp Reisnerfd0017c2012-10-19 14:19:23 +02003241 * we cannot do anything about that anymore.
3242 *
3243 * We still need to check if both bitmap and ldev are present, we may
3244 * end up here after a failed attach, before ldev was even assigned.
3245 */
3246 if (mdev->bitmap && mdev->ldev) {
Lars Ellenberga2a3c74f2012-09-22 12:26:57 +02003247 if (drbd_bitmap_io_from_worker(mdev, drbd_bm_write,
3248 "detach", BM_LOCKED_MASK)) {
Lars Ellenbergedc9f5e2012-09-27 15:18:21 +02003249 if (test_bit(WAS_READ_ERROR, &mdev->flags)) {
Lars Ellenberga2a3c74f2012-09-22 12:26:57 +02003250 drbd_md_set_flag(mdev, MDF_FULL_SYNC);
3251 drbd_md_sync(mdev);
3252 }
3253 }
3254 }
3255
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02003256 drbd_force_state(mdev, NS(disk, D_DISKLESS));
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003257 return 0;
Lars Ellenberge9e6f3e2010-09-14 20:26:27 +02003258}
3259
Philipp Reisnerb411b362009-09-25 16:07:19 -07003260/**
3261 * drbd_queue_bitmap_io() - Queues an IO operation on the whole bitmap
3262 * @mdev: DRBD device.
3263 * @io_fn: IO callback to be called when bitmap IO is possible
3264 * @done: callback to be called after the bitmap IO was performed
3265 * @why: Descriptive text of the reason for doing the IO
3266 *
3267 * While IO on the bitmap happens we freeze application IO thus we ensure
3268 * that drbd_set_out_of_sync() can not be called. This function MAY ONLY be
3269 * called from worker context. It MUST NOT be used while a previous such
3270 * work is still pending!
3271 */
3272void drbd_queue_bitmap_io(struct drbd_conf *mdev,
3273 int (*io_fn)(struct drbd_conf *),
3274 void (*done)(struct drbd_conf *, int),
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003275 char *why, enum bm_flag flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003276{
Philipp Reisnere6b3ea82011-01-19 14:02:01 +01003277 D_ASSERT(current == mdev->tconn->worker.task);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003278
3279 D_ASSERT(!test_bit(BITMAP_IO_QUEUED, &mdev->flags));
3280 D_ASSERT(!test_bit(BITMAP_IO, &mdev->flags));
3281 D_ASSERT(list_empty(&mdev->bm_io_work.w.list));
3282 if (mdev->bm_io_work.why)
3283 dev_err(DEV, "FIXME going to queue '%s' but '%s' still pending?\n",
3284 why, mdev->bm_io_work.why);
3285
3286 mdev->bm_io_work.io_fn = io_fn;
3287 mdev->bm_io_work.done = done;
3288 mdev->bm_io_work.why = why;
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003289 mdev->bm_io_work.flags = flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003290
Philipp Reisner87eeee42011-01-19 14:16:30 +01003291 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003292 set_bit(BITMAP_IO, &mdev->flags);
3293 if (atomic_read(&mdev->ap_bio_cnt) == 0) {
Philipp Reisner127b3172010-11-16 10:07:53 +01003294 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))
Lars Ellenbergd5b27b02011-11-14 15:42:37 +01003295 drbd_queue_work(&mdev->tconn->sender_work, &mdev->bm_io_work.w);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003296 }
Philipp Reisner87eeee42011-01-19 14:16:30 +01003297 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003298}
3299
3300/**
3301 * drbd_bitmap_io() - Does an IO operation on the whole bitmap
3302 * @mdev: DRBD device.
3303 * @io_fn: IO callback to be called when bitmap IO is possible
3304 * @why: Descriptive text of the reason for doing the IO
3305 *
3306 * freezes application IO while that the actual IO operations runs. This
3307 * functions MAY NOT be called from worker context.
3308 */
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003309int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *),
3310 char *why, enum bm_flag flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003311{
3312 int rv;
3313
Philipp Reisnere6b3ea82011-01-19 14:02:01 +01003314 D_ASSERT(current != mdev->tconn->worker.task);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003315
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003316 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3317 drbd_suspend_io(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003318
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003319 drbd_bm_lock(mdev, why, flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003320 rv = io_fn(mdev);
3321 drbd_bm_unlock(mdev);
3322
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003323 if ((flags & BM_LOCKED_SET_ALLOWED) == 0)
3324 drbd_resume_io(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003325
3326 return rv;
3327}
3328
3329void drbd_md_set_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3330{
3331 if ((mdev->ldev->md.flags & flag) != flag) {
3332 drbd_md_mark_dirty(mdev);
3333 mdev->ldev->md.flags |= flag;
3334 }
3335}
3336
3337void drbd_md_clear_flag(struct drbd_conf *mdev, int flag) __must_hold(local)
3338{
3339 if ((mdev->ldev->md.flags & flag) != 0) {
3340 drbd_md_mark_dirty(mdev);
3341 mdev->ldev->md.flags &= ~flag;
3342 }
3343}
3344int drbd_md_test_flag(struct drbd_backing_dev *bdev, int flag)
3345{
3346 return (bdev->md.flags & flag) != 0;
3347}
3348
3349static void md_sync_timer_fn(unsigned long data)
3350{
3351 struct drbd_conf *mdev = (struct drbd_conf *) data;
3352
Lars Ellenbergb792b652012-08-22 14:59:06 +02003353 /* must not double-queue! */
3354 if (list_empty(&mdev->md_sync_work.list))
3355 drbd_queue_work_front(&mdev->tconn->sender_work, &mdev->md_sync_work);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003356}
3357
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003358static int w_md_sync(struct drbd_work *w, int unused)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003359{
Philipp Reisner00d56942011-02-09 18:09:48 +01003360 struct drbd_conf *mdev = w->mdev;
3361
Philipp Reisnerb411b362009-09-25 16:07:19 -07003362 dev_warn(DEV, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
Lars Ellenbergee15b032010-09-03 10:00:09 +02003363#ifdef DEBUG
3364 dev_warn(DEV, "last md_mark_dirty: %s:%u\n",
3365 mdev->last_md_mark_dirty.func, mdev->last_md_mark_dirty.line);
3366#endif
Philipp Reisnerb411b362009-09-25 16:07:19 -07003367 drbd_md_sync(mdev);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01003368 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003369}
3370
Andreas Gruenbacherd8763022011-01-26 17:39:41 +01003371const char *cmdname(enum drbd_packet cmd)
Andreas Gruenbacherf2ad9062011-01-26 17:13:25 +01003372{
3373 /* THINK may need to become several global tables
3374 * when we want to support more than
3375 * one PRO_VERSION */
3376 static const char *cmdnames[] = {
3377 [P_DATA] = "Data",
3378 [P_DATA_REPLY] = "DataReply",
3379 [P_RS_DATA_REPLY] = "RSDataReply",
3380 [P_BARRIER] = "Barrier",
3381 [P_BITMAP] = "ReportBitMap",
3382 [P_BECOME_SYNC_TARGET] = "BecomeSyncTarget",
3383 [P_BECOME_SYNC_SOURCE] = "BecomeSyncSource",
3384 [P_UNPLUG_REMOTE] = "UnplugRemote",
3385 [P_DATA_REQUEST] = "DataRequest",
3386 [P_RS_DATA_REQUEST] = "RSDataRequest",
3387 [P_SYNC_PARAM] = "SyncParam",
3388 [P_SYNC_PARAM89] = "SyncParam89",
3389 [P_PROTOCOL] = "ReportProtocol",
3390 [P_UUIDS] = "ReportUUIDs",
3391 [P_SIZES] = "ReportSizes",
3392 [P_STATE] = "ReportState",
3393 [P_SYNC_UUID] = "ReportSyncUUID",
3394 [P_AUTH_CHALLENGE] = "AuthChallenge",
3395 [P_AUTH_RESPONSE] = "AuthResponse",
3396 [P_PING] = "Ping",
3397 [P_PING_ACK] = "PingAck",
3398 [P_RECV_ACK] = "RecvAck",
3399 [P_WRITE_ACK] = "WriteAck",
3400 [P_RS_WRITE_ACK] = "RSWriteAck",
Lars Ellenbergd4dabbe2012-08-01 12:33:51 +02003401 [P_SUPERSEDED] = "Superseded",
Andreas Gruenbacherf2ad9062011-01-26 17:13:25 +01003402 [P_NEG_ACK] = "NegAck",
3403 [P_NEG_DREPLY] = "NegDReply",
3404 [P_NEG_RS_DREPLY] = "NegRSDReply",
3405 [P_BARRIER_ACK] = "BarrierAck",
3406 [P_STATE_CHG_REQ] = "StateChgRequest",
3407 [P_STATE_CHG_REPLY] = "StateChgReply",
3408 [P_OV_REQUEST] = "OVRequest",
3409 [P_OV_REPLY] = "OVReply",
3410 [P_OV_RESULT] = "OVResult",
3411 [P_CSUM_RS_REQUEST] = "CsumRSRequest",
3412 [P_RS_IS_IN_SYNC] = "CsumRSIsInSync",
3413 [P_COMPRESSED_BITMAP] = "CBitmap",
3414 [P_DELAY_PROBE] = "DelayProbe",
3415 [P_OUT_OF_SYNC] = "OutOfSync",
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01003416 [P_RETRY_WRITE] = "RetryWrite",
Lars Ellenbergae25b332011-04-24 00:01:16 +02003417 [P_RS_CANCEL] = "RSCancel",
3418 [P_CONN_ST_CHG_REQ] = "conn_st_chg_req",
3419 [P_CONN_ST_CHG_REPLY] = "conn_st_chg_reply",
Philipp Reisner036b17e2011-05-16 17:38:11 +02003420 [P_RETRY_WRITE] = "retry_write",
3421 [P_PROTOCOL_UPDATE] = "protocol_update",
Lars Ellenbergae25b332011-04-24 00:01:16 +02003422
3423 /* enum drbd_packet, but not commands - obsoleted flags:
3424 * P_MAY_IGNORE
3425 * P_MAX_OPT_CMD
3426 */
Andreas Gruenbacherf2ad9062011-01-26 17:13:25 +01003427 };
3428
Lars Ellenbergae25b332011-04-24 00:01:16 +02003429 /* too big for the array: 0xfffX */
Andreas Gruenbachere5d6f332011-03-28 16:44:40 +02003430 if (cmd == P_INITIAL_META)
3431 return "InitialMeta";
3432 if (cmd == P_INITIAL_DATA)
3433 return "InitialData";
Andreas Gruenbacher60381782011-03-28 17:05:50 +02003434 if (cmd == P_CONNECTION_FEATURES)
3435 return "ConnectionFeatures";
Andreas Gruenbacher6e849ce2011-03-14 17:27:45 +01003436 if (cmd >= ARRAY_SIZE(cmdnames))
Andreas Gruenbacherf2ad9062011-01-26 17:13:25 +01003437 return "Unknown";
3438 return cmdnames[cmd];
3439}
3440
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01003441/**
3442 * drbd_wait_misc - wait for a request to make progress
3443 * @mdev: device associated with the request
3444 * @i: the struct drbd_interval embedded in struct drbd_request or
3445 * struct drbd_peer_request
3446 */
3447int drbd_wait_misc(struct drbd_conf *mdev, struct drbd_interval *i)
3448{
Philipp Reisner44ed1672011-04-19 17:10:19 +02003449 struct net_conf *nc;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01003450 DEFINE_WAIT(wait);
3451 long timeout;
3452
Philipp Reisner44ed1672011-04-19 17:10:19 +02003453 rcu_read_lock();
3454 nc = rcu_dereference(mdev->tconn->net_conf);
3455 if (!nc) {
3456 rcu_read_unlock();
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01003457 return -ETIMEDOUT;
Philipp Reisner44ed1672011-04-19 17:10:19 +02003458 }
3459 timeout = nc->ko_count ? nc->timeout * HZ / 10 * nc->ko_count : MAX_SCHEDULE_TIMEOUT;
3460 rcu_read_unlock();
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01003461
3462 /* Indicate to wake up mdev->misc_wait on progress. */
3463 i->waiting = true;
3464 prepare_to_wait(&mdev->misc_wait, &wait, TASK_INTERRUPTIBLE);
3465 spin_unlock_irq(&mdev->tconn->req_lock);
3466 timeout = schedule_timeout(timeout);
3467 finish_wait(&mdev->misc_wait, &wait);
3468 spin_lock_irq(&mdev->tconn->req_lock);
3469 if (!timeout || mdev->state.conn < C_CONNECTED)
3470 return -ETIMEDOUT;
3471 if (signal_pending(current))
3472 return -ERESTARTSYS;
3473 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003474}
3475
3476#ifdef CONFIG_DRBD_FAULT_INJECTION
3477/* Fault insertion support including random number generator shamelessly
3478 * stolen from kernel/rcutorture.c */
3479struct fault_random_state {
3480 unsigned long state;
3481 unsigned long count;
3482};
3483
3484#define FAULT_RANDOM_MULT 39916801 /* prime */
3485#define FAULT_RANDOM_ADD 479001701 /* prime */
3486#define FAULT_RANDOM_REFRESH 10000
3487
3488/*
3489 * Crude but fast random-number generator. Uses a linear congruential
3490 * generator, with occasional help from get_random_bytes().
3491 */
3492static unsigned long
3493_drbd_fault_random(struct fault_random_state *rsp)
3494{
3495 long refresh;
3496
Roel Kluin49829ea2009-12-15 22:55:44 +01003497 if (!rsp->count--) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003498 get_random_bytes(&refresh, sizeof(refresh));
3499 rsp->state += refresh;
3500 rsp->count = FAULT_RANDOM_REFRESH;
3501 }
3502 rsp->state = rsp->state * FAULT_RANDOM_MULT + FAULT_RANDOM_ADD;
3503 return swahw32(rsp->state);
3504}
3505
3506static char *
3507_drbd_fault_str(unsigned int type) {
3508 static char *_faults[] = {
3509 [DRBD_FAULT_MD_WR] = "Meta-data write",
3510 [DRBD_FAULT_MD_RD] = "Meta-data read",
3511 [DRBD_FAULT_RS_WR] = "Resync write",
3512 [DRBD_FAULT_RS_RD] = "Resync read",
3513 [DRBD_FAULT_DT_WR] = "Data write",
3514 [DRBD_FAULT_DT_RD] = "Data read",
3515 [DRBD_FAULT_DT_RA] = "Data read ahead",
3516 [DRBD_FAULT_BM_ALLOC] = "BM allocation",
Philipp Reisner6b4388a2010-04-26 14:11:45 +02003517 [DRBD_FAULT_AL_EE] = "EE allocation",
3518 [DRBD_FAULT_RECEIVE] = "receive data corruption",
Philipp Reisnerb411b362009-09-25 16:07:19 -07003519 };
3520
3521 return (type < DRBD_FAULT_MAX) ? _faults[type] : "**Unknown**";
3522}
3523
3524unsigned int
3525_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type)
3526{
3527 static struct fault_random_state rrs = {0, 0};
3528
3529 unsigned int ret = (
3530 (fault_devs == 0 ||
3531 ((1 << mdev_to_minor(mdev)) & fault_devs) != 0) &&
3532 (((_drbd_fault_random(&rrs) % 100) + 1) <= fault_rate));
3533
3534 if (ret) {
3535 fault_count++;
3536
Lars Ellenberg73835062010-05-27 11:51:56 +02003537 if (__ratelimit(&drbd_ratelimit_state))
Philipp Reisnerb411b362009-09-25 16:07:19 -07003538 dev_warn(DEV, "***Simulating %s failure\n",
3539 _drbd_fault_str(type));
3540 }
3541
3542 return ret;
3543}
3544#endif
3545
3546const char *drbd_buildtag(void)
3547{
3548 /* DRBD built from external sources has here a reference to the
3549 git hash of the source code. */
3550
3551 static char buildtag[38] = "\0uilt-in";
3552
3553 if (buildtag[0] == 0) {
Cong Wangbc4854b2012-04-03 14:13:36 +08003554#ifdef MODULE
3555 sprintf(buildtag, "srcversion: %-24s", THIS_MODULE->srcversion);
3556#else
3557 buildtag[0] = 'b';
Philipp Reisnerb411b362009-09-25 16:07:19 -07003558#endif
Philipp Reisnerb411b362009-09-25 16:07:19 -07003559 }
3560
3561 return buildtag;
3562}
3563
3564module_init(drbd_init)
3565module_exit(drbd_cleanup)
3566
Philipp Reisnerb411b362009-09-25 16:07:19 -07003567EXPORT_SYMBOL(drbd_conn_str);
3568EXPORT_SYMBOL(drbd_role_str);
3569EXPORT_SYMBOL(drbd_disk_str);
3570EXPORT_SYMBOL(drbd_set_st_err_str);