drbd_nl.c revision 087c24925cf4209be1a91f8ede9241e17e9734c7
1/* 2 drbd_nl.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 drbd is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2, or (at your option) 13 any later version. 14 15 drbd is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with drbd; see the file COPYING. If not, write to 22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23 24 */ 25 26#include <linux/module.h> 27#include <linux/drbd.h> 28#include <linux/in.h> 29#include <linux/fs.h> 30#include <linux/file.h> 31#include <linux/slab.h> 32#include <linux/connector.h> 33#include <linux/blkpg.h> 34#include <linux/cpumask.h> 35#include "drbd_int.h" 36#include "drbd_wrappers.h" 37#include <asm/unaligned.h> 38#include <linux/drbd_tag_magic.h> 39#include <linux/drbd_limits.h> 40 41static unsigned short *tl_add_blob(unsigned short *, enum drbd_tags, const void *, int); 42static unsigned short *tl_add_str(unsigned short *, enum drbd_tags, const char *); 43static unsigned short *tl_add_int(unsigned short *, enum drbd_tags, const void *); 44 45/* see get_sb_bdev and bd_claim */ 46static char *drbd_m_holder = "Hands off! this is DRBD's meta data device."; 47 48/* Generate the tag_list to struct functions */ 49#define NL_PACKET(name, number, fields) \ 50static int name ## _from_tags(struct drbd_conf *mdev, \ 51 unsigned short *tags, struct name *arg) __attribute__ ((unused)); \ 52static int name ## _from_tags(struct drbd_conf *mdev, \ 53 unsigned short *tags, struct name *arg) \ 54{ \ 55 int tag; \ 56 int dlen; \ 57 \ 58 while ((tag = get_unaligned(tags++)) != TT_END) { \ 59 dlen = get_unaligned(tags++); \ 60 switch (tag_number(tag)) { \ 61 fields \ 62 default: \ 63 if (tag & T_MANDATORY) { \ 64 dev_err(DEV, "Unknown tag: %d\n", tag_number(tag)); \ 65 return 0; \ 66 } \ 67 } \ 68 tags = (unsigned short *)((char *)tags + dlen); \ 69 } \ 70 return 1; \ 71} 72#define NL_INTEGER(pn, pr, member) \ 73 case pn: /* D_ASSERT( tag_type(tag) == TT_INTEGER ); */ \ 74 arg->member = get_unaligned((int *)(tags)); \ 75 break; 76#define NL_INT64(pn, pr, member) \ 77 case pn: /* D_ASSERT( tag_type(tag) == TT_INT64 ); */ \ 78 arg->member = get_unaligned((u64 *)(tags)); \ 79 break; 80#define NL_BIT(pn, pr, member) \ 81 case pn: /* D_ASSERT( tag_type(tag) == TT_BIT ); */ \ 82 arg->member = *(char *)(tags) ? 1 : 0; \ 83 break; 84#define NL_STRING(pn, pr, member, len) \ 85 case pn: /* D_ASSERT( tag_type(tag) == TT_STRING ); */ \ 86 if (dlen > len) { \ 87 dev_err(DEV, "arg too long: %s (%u wanted, max len: %u bytes)\n", \ 88 #member, dlen, (unsigned int)len); \ 89 return 0; \ 90 } \ 91 arg->member ## _len = dlen; \ 92 memcpy(arg->member, tags, min_t(size_t, dlen, len)); \ 93 break; 94#include "linux/drbd_nl.h" 95 96/* Generate the struct to tag_list functions */ 97#define NL_PACKET(name, number, fields) \ 98static unsigned short* \ 99name ## _to_tags(struct drbd_conf *mdev, \ 100 struct name *arg, unsigned short *tags) __attribute__ ((unused)); \ 101static unsigned short* \ 102name ## _to_tags(struct drbd_conf *mdev, \ 103 struct name *arg, unsigned short *tags) \ 104{ \ 105 fields \ 106 return tags; \ 107} 108 109#define NL_INTEGER(pn, pr, member) \ 110 put_unaligned(pn | pr | TT_INTEGER, tags++); \ 111 put_unaligned(sizeof(int), tags++); \ 112 put_unaligned(arg->member, (int *)tags); \ 113 tags = (unsigned short *)((char *)tags+sizeof(int)); 114#define NL_INT64(pn, pr, member) \ 115 put_unaligned(pn | pr | TT_INT64, tags++); \ 116 put_unaligned(sizeof(u64), tags++); \ 117 put_unaligned(arg->member, (u64 *)tags); \ 118 tags = (unsigned short *)((char *)tags+sizeof(u64)); 119#define NL_BIT(pn, pr, member) \ 120 put_unaligned(pn | pr | TT_BIT, tags++); \ 121 put_unaligned(sizeof(char), tags++); \ 122 *(char *)tags = arg->member; \ 123 tags = (unsigned short *)((char *)tags+sizeof(char)); 124#define NL_STRING(pn, pr, member, len) \ 125 put_unaligned(pn | pr | TT_STRING, tags++); \ 126 put_unaligned(arg->member ## _len, tags++); \ 127 memcpy(tags, arg->member, arg->member ## _len); \ 128 tags = (unsigned short *)((char *)tags + arg->member ## _len); 129#include "linux/drbd_nl.h" 130 131void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name); 132void drbd_nl_send_reply(struct cn_msg *, int); 133 134int drbd_khelper(struct drbd_conf *mdev, char *cmd) 135{ 136 char *envp[] = { "HOME=/", 137 "TERM=linux", 138 "PATH=/sbin:/usr/sbin:/bin:/usr/bin", 139 NULL, /* Will be set to address family */ 140 NULL, /* Will be set to address */ 141 NULL }; 142 143 char mb[12], af[20], ad[60], *afs; 144 char *argv[] = {usermode_helper, cmd, mb, NULL }; 145 int ret; 146 147 snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev)); 148 149 if (get_net_conf(mdev)) { 150 switch (((struct sockaddr *)mdev->net_conf->peer_addr)->sa_family) { 151 case AF_INET6: 152 afs = "ipv6"; 153 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI6", 154 &((struct sockaddr_in6 *)mdev->net_conf->peer_addr)->sin6_addr); 155 break; 156 case AF_INET: 157 afs = "ipv4"; 158 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4", 159 &((struct sockaddr_in *)mdev->net_conf->peer_addr)->sin_addr); 160 break; 161 default: 162 afs = "ssocks"; 163 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4", 164 &((struct sockaddr_in *)mdev->net_conf->peer_addr)->sin_addr); 165 } 166 snprintf(af, 20, "DRBD_PEER_AF=%s", afs); 167 envp[3]=af; 168 envp[4]=ad; 169 put_net_conf(mdev); 170 } 171 172 dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb); 173 174 drbd_bcast_ev_helper(mdev, cmd); 175 ret = call_usermodehelper(usermode_helper, argv, envp, 1); 176 if (ret) 177 dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n", 178 usermode_helper, cmd, mb, 179 (ret >> 8) & 0xff, ret); 180 else 181 dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n", 182 usermode_helper, cmd, mb, 183 (ret >> 8) & 0xff, ret); 184 185 if (ret < 0) /* Ignore any ERRNOs we got. */ 186 ret = 0; 187 188 return ret; 189} 190 191enum drbd_disk_state drbd_try_outdate_peer(struct drbd_conf *mdev) 192{ 193 char *ex_to_string; 194 int r; 195 enum drbd_disk_state nps; 196 enum drbd_fencing_p fp; 197 198 D_ASSERT(mdev->state.pdsk == D_UNKNOWN); 199 200 if (get_ldev_if_state(mdev, D_CONSISTENT)) { 201 fp = mdev->ldev->dc.fencing; 202 put_ldev(mdev); 203 } else { 204 dev_warn(DEV, "Not fencing peer, I'm not even Consistent myself.\n"); 205 return mdev->state.pdsk; 206 } 207 208 if (fp == FP_STONITH) 209 _drbd_request_state(mdev, NS(susp, 1), CS_WAIT_COMPLETE); 210 211 r = drbd_khelper(mdev, "fence-peer"); 212 213 switch ((r>>8) & 0xff) { 214 case 3: /* peer is inconsistent */ 215 ex_to_string = "peer is inconsistent or worse"; 216 nps = D_INCONSISTENT; 217 break; 218 case 4: /* peer got outdated, or was already outdated */ 219 ex_to_string = "peer was fenced"; 220 nps = D_OUTDATED; 221 break; 222 case 5: /* peer was down */ 223 if (mdev->state.disk == D_UP_TO_DATE) { 224 /* we will(have) create(d) a new UUID anyways... */ 225 ex_to_string = "peer is unreachable, assumed to be dead"; 226 nps = D_OUTDATED; 227 } else { 228 ex_to_string = "peer unreachable, doing nothing since disk != UpToDate"; 229 nps = mdev->state.pdsk; 230 } 231 break; 232 case 6: /* Peer is primary, voluntarily outdate myself. 233 * This is useful when an unconnected R_SECONDARY is asked to 234 * become R_PRIMARY, but finds the other peer being active. */ 235 ex_to_string = "peer is active"; 236 dev_warn(DEV, "Peer is primary, outdating myself.\n"); 237 nps = D_UNKNOWN; 238 _drbd_request_state(mdev, NS(disk, D_OUTDATED), CS_WAIT_COMPLETE); 239 break; 240 case 7: 241 if (fp != FP_STONITH) 242 dev_err(DEV, "fence-peer() = 7 && fencing != Stonith !!!\n"); 243 ex_to_string = "peer was stonithed"; 244 nps = D_OUTDATED; 245 break; 246 default: 247 /* The script is broken ... */ 248 nps = D_UNKNOWN; 249 dev_err(DEV, "fence-peer helper broken, returned %d\n", (r>>8)&0xff); 250 return nps; 251 } 252 253 dev_info(DEV, "fence-peer helper returned %d (%s)\n", 254 (r>>8) & 0xff, ex_to_string); 255 return nps; 256} 257 258 259int drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force) 260{ 261 const int max_tries = 4; 262 int r = 0; 263 int try = 0; 264 int forced = 0; 265 union drbd_state mask, val; 266 enum drbd_disk_state nps; 267 268 if (new_role == R_PRIMARY) 269 request_ping(mdev); /* Detect a dead peer ASAP */ 270 271 mutex_lock(&mdev->state_mutex); 272 273 mask.i = 0; mask.role = R_MASK; 274 val.i = 0; val.role = new_role; 275 276 while (try++ < max_tries) { 277 r = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE); 278 279 /* in case we first succeeded to outdate, 280 * but now suddenly could establish a connection */ 281 if (r == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) { 282 val.pdsk = 0; 283 mask.pdsk = 0; 284 continue; 285 } 286 287 if (r == SS_NO_UP_TO_DATE_DISK && force && 288 (mdev->state.disk < D_UP_TO_DATE && 289 mdev->state.disk >= D_INCONSISTENT)) { 290 mask.disk = D_MASK; 291 val.disk = D_UP_TO_DATE; 292 forced = 1; 293 continue; 294 } 295 296 if (r == SS_NO_UP_TO_DATE_DISK && 297 mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) { 298 D_ASSERT(mdev->state.pdsk == D_UNKNOWN); 299 nps = drbd_try_outdate_peer(mdev); 300 301 if (nps == D_OUTDATED || nps == D_INCONSISTENT) { 302 val.disk = D_UP_TO_DATE; 303 mask.disk = D_MASK; 304 } 305 306 val.pdsk = nps; 307 mask.pdsk = D_MASK; 308 309 continue; 310 } 311 312 if (r == SS_NOTHING_TO_DO) 313 goto fail; 314 if (r == SS_PRIMARY_NOP && mask.pdsk == 0) { 315 nps = drbd_try_outdate_peer(mdev); 316 317 if (force && nps > D_OUTDATED) { 318 dev_warn(DEV, "Forced into split brain situation!\n"); 319 nps = D_OUTDATED; 320 } 321 322 mask.pdsk = D_MASK; 323 val.pdsk = nps; 324 325 continue; 326 } 327 if (r == SS_TWO_PRIMARIES) { 328 /* Maybe the peer is detected as dead very soon... 329 retry at most once more in this case. */ 330 __set_current_state(TASK_INTERRUPTIBLE); 331 schedule_timeout((mdev->net_conf->ping_timeo+1)*HZ/10); 332 if (try < max_tries) 333 try = max_tries - 1; 334 continue; 335 } 336 if (r < SS_SUCCESS) { 337 r = _drbd_request_state(mdev, mask, val, 338 CS_VERBOSE + CS_WAIT_COMPLETE); 339 if (r < SS_SUCCESS) 340 goto fail; 341 } 342 break; 343 } 344 345 if (r < SS_SUCCESS) 346 goto fail; 347 348 if (forced) 349 dev_warn(DEV, "Forced to consider local data as UpToDate!\n"); 350 351 /* Wait until nothing is on the fly :) */ 352 wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0); 353 354 if (new_role == R_SECONDARY) { 355 set_disk_ro(mdev->vdisk, TRUE); 356 if (get_ldev(mdev)) { 357 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1; 358 put_ldev(mdev); 359 } 360 } else { 361 if (get_net_conf(mdev)) { 362 mdev->net_conf->want_lose = 0; 363 put_net_conf(mdev); 364 } 365 set_disk_ro(mdev->vdisk, FALSE); 366 if (get_ldev(mdev)) { 367 if (((mdev->state.conn < C_CONNECTED || 368 mdev->state.pdsk <= D_FAILED) 369 && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced) 370 drbd_uuid_new_current(mdev); 371 372 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1; 373 put_ldev(mdev); 374 } 375 } 376 377 if ((new_role == R_SECONDARY) && get_ldev(mdev)) { 378 drbd_al_to_on_disk_bm(mdev); 379 put_ldev(mdev); 380 } 381 382 if (mdev->state.conn >= C_WF_REPORT_PARAMS) { 383 /* if this was forced, we should consider sync */ 384 if (forced) 385 drbd_send_uuids(mdev); 386 drbd_send_state(mdev); 387 } 388 389 drbd_md_sync(mdev); 390 391 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE); 392 fail: 393 mutex_unlock(&mdev->state_mutex); 394 return r; 395} 396 397 398static int drbd_nl_primary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 399 struct drbd_nl_cfg_reply *reply) 400{ 401 struct primary primary_args; 402 403 memset(&primary_args, 0, sizeof(struct primary)); 404 if (!primary_from_tags(mdev, nlp->tag_list, &primary_args)) { 405 reply->ret_code = ERR_MANDATORY_TAG; 406 return 0; 407 } 408 409 reply->ret_code = 410 drbd_set_role(mdev, R_PRIMARY, primary_args.primary_force); 411 412 return 0; 413} 414 415static int drbd_nl_secondary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 416 struct drbd_nl_cfg_reply *reply) 417{ 418 reply->ret_code = drbd_set_role(mdev, R_SECONDARY, 0); 419 420 return 0; 421} 422 423/* initializes the md.*_offset members, so we are able to find 424 * the on disk meta data */ 425static void drbd_md_set_sector_offsets(struct drbd_conf *mdev, 426 struct drbd_backing_dev *bdev) 427{ 428 sector_t md_size_sect = 0; 429 switch (bdev->dc.meta_dev_idx) { 430 default: 431 /* v07 style fixed size indexed meta data */ 432 bdev->md.md_size_sect = MD_RESERVED_SECT; 433 bdev->md.md_offset = drbd_md_ss__(mdev, bdev); 434 bdev->md.al_offset = MD_AL_OFFSET; 435 bdev->md.bm_offset = MD_BM_OFFSET; 436 break; 437 case DRBD_MD_INDEX_FLEX_EXT: 438 /* just occupy the full device; unit: sectors */ 439 bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev); 440 bdev->md.md_offset = 0; 441 bdev->md.al_offset = MD_AL_OFFSET; 442 bdev->md.bm_offset = MD_BM_OFFSET; 443 break; 444 case DRBD_MD_INDEX_INTERNAL: 445 case DRBD_MD_INDEX_FLEX_INT: 446 bdev->md.md_offset = drbd_md_ss__(mdev, bdev); 447 /* al size is still fixed */ 448 bdev->md.al_offset = -MD_AL_MAX_SIZE; 449 /* we need (slightly less than) ~ this much bitmap sectors: */ 450 md_size_sect = drbd_get_capacity(bdev->backing_bdev); 451 md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT); 452 md_size_sect = BM_SECT_TO_EXT(md_size_sect); 453 md_size_sect = ALIGN(md_size_sect, 8); 454 455 /* plus the "drbd meta data super block", 456 * and the activity log; */ 457 md_size_sect += MD_BM_OFFSET; 458 459 bdev->md.md_size_sect = md_size_sect; 460 /* bitmap offset is adjusted by 'super' block size */ 461 bdev->md.bm_offset = -md_size_sect + MD_AL_OFFSET; 462 break; 463 } 464} 465 466char *ppsize(char *buf, unsigned long long size) 467{ 468 /* Needs 9 bytes at max. */ 469 static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' }; 470 int base = 0; 471 while (size >= 10000) { 472 /* shift + round */ 473 size = (size >> 10) + !!(size & (1<<9)); 474 base++; 475 } 476 sprintf(buf, "%lu %cB", (long)size, units[base]); 477 478 return buf; 479} 480 481/* there is still a theoretical deadlock when called from receiver 482 * on an D_INCONSISTENT R_PRIMARY: 483 * remote READ does inc_ap_bio, receiver would need to receive answer 484 * packet from remote to dec_ap_bio again. 485 * receiver receive_sizes(), comes here, 486 * waits for ap_bio_cnt == 0. -> deadlock. 487 * but this cannot happen, actually, because: 488 * R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable 489 * (not connected, or bad/no disk on peer): 490 * see drbd_fail_request_early, ap_bio_cnt is zero. 491 * R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET: 492 * peer may not initiate a resize. 493 */ 494void drbd_suspend_io(struct drbd_conf *mdev) 495{ 496 set_bit(SUSPEND_IO, &mdev->flags); 497 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 498} 499 500void drbd_resume_io(struct drbd_conf *mdev) 501{ 502 clear_bit(SUSPEND_IO, &mdev->flags); 503 wake_up(&mdev->misc_wait); 504} 505 506/** 507 * drbd_determine_dev_size() - Sets the right device size obeying all constraints 508 * @mdev: DRBD device. 509 * 510 * Returns 0 on success, negative return values indicate errors. 511 * You should call drbd_md_sync() after calling this function. 512 */ 513enum determine_dev_size drbd_determin_dev_size(struct drbd_conf *mdev, enum dds_flags flags) __must_hold(local) 514{ 515 sector_t prev_first_sect, prev_size; /* previous meta location */ 516 sector_t la_size; 517 sector_t size; 518 char ppb[10]; 519 520 int md_moved, la_size_changed; 521 enum determine_dev_size rv = unchanged; 522 523 /* race: 524 * application request passes inc_ap_bio, 525 * but then cannot get an AL-reference. 526 * this function later may wait on ap_bio_cnt == 0. -> deadlock. 527 * 528 * to avoid that: 529 * Suspend IO right here. 530 * still lock the act_log to not trigger ASSERTs there. 531 */ 532 drbd_suspend_io(mdev); 533 534 /* no wait necessary anymore, actually we could assert that */ 535 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log)); 536 537 prev_first_sect = drbd_md_first_sector(mdev->ldev); 538 prev_size = mdev->ldev->md.md_size_sect; 539 la_size = mdev->ldev->md.la_size_sect; 540 541 /* TODO: should only be some assert here, not (re)init... */ 542 drbd_md_set_sector_offsets(mdev, mdev->ldev); 543 544 size = drbd_new_dev_size(mdev, mdev->ldev, flags & DDSF_FORCED); 545 546 if (drbd_get_capacity(mdev->this_bdev) != size || 547 drbd_bm_capacity(mdev) != size) { 548 int err; 549 err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC)); 550 if (unlikely(err)) { 551 /* currently there is only one error: ENOMEM! */ 552 size = drbd_bm_capacity(mdev)>>1; 553 if (size == 0) { 554 dev_err(DEV, "OUT OF MEMORY! " 555 "Could not allocate bitmap!\n"); 556 } else { 557 dev_err(DEV, "BM resizing failed. " 558 "Leaving size unchanged at size = %lu KB\n", 559 (unsigned long)size); 560 } 561 rv = dev_size_error; 562 } 563 /* racy, see comments above. */ 564 drbd_set_my_capacity(mdev, size); 565 mdev->ldev->md.la_size_sect = size; 566 dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1), 567 (unsigned long long)size>>1); 568 } 569 if (rv == dev_size_error) 570 goto out; 571 572 la_size_changed = (la_size != mdev->ldev->md.la_size_sect); 573 574 md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev) 575 || prev_size != mdev->ldev->md.md_size_sect; 576 577 if (la_size_changed || md_moved) { 578 drbd_al_shrink(mdev); /* All extents inactive. */ 579 dev_info(DEV, "Writing the whole bitmap, %s\n", 580 la_size_changed && md_moved ? "size changed and md moved" : 581 la_size_changed ? "size changed" : "md moved"); 582 rv = drbd_bitmap_io(mdev, &drbd_bm_write, "size changed"); /* does drbd_resume_io() ! */ 583 drbd_md_mark_dirty(mdev); 584 } 585 586 if (size > la_size) 587 rv = grew; 588 if (size < la_size) 589 rv = shrunk; 590out: 591 lc_unlock(mdev->act_log); 592 wake_up(&mdev->al_wait); 593 drbd_resume_io(mdev); 594 595 return rv; 596} 597 598sector_t 599drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int assume_peer_has_space) 600{ 601 sector_t p_size = mdev->p_size; /* partner's disk size. */ 602 sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */ 603 sector_t m_size; /* my size */ 604 sector_t u_size = bdev->dc.disk_size; /* size requested by user. */ 605 sector_t size = 0; 606 607 m_size = drbd_get_max_capacity(bdev); 608 609 if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) { 610 dev_warn(DEV, "Resize while not connected was forced by the user!\n"); 611 p_size = m_size; 612 } 613 614 if (p_size && m_size) { 615 size = min_t(sector_t, p_size, m_size); 616 } else { 617 if (la_size) { 618 size = la_size; 619 if (m_size && m_size < size) 620 size = m_size; 621 if (p_size && p_size < size) 622 size = p_size; 623 } else { 624 if (m_size) 625 size = m_size; 626 if (p_size) 627 size = p_size; 628 } 629 } 630 631 if (size == 0) 632 dev_err(DEV, "Both nodes diskless!\n"); 633 634 if (u_size) { 635 if (u_size > size) 636 dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n", 637 (unsigned long)u_size>>1, (unsigned long)size>>1); 638 else 639 size = u_size; 640 } 641 642 return size; 643} 644 645/** 646 * drbd_check_al_size() - Ensures that the AL is of the right size 647 * @mdev: DRBD device. 648 * 649 * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation 650 * failed, and 0 on success. You should call drbd_md_sync() after you called 651 * this function. 652 */ 653static int drbd_check_al_size(struct drbd_conf *mdev) 654{ 655 struct lru_cache *n, *t; 656 struct lc_element *e; 657 unsigned int in_use; 658 int i; 659 660 ERR_IF(mdev->sync_conf.al_extents < 7) 661 mdev->sync_conf.al_extents = 127; 662 663 if (mdev->act_log && 664 mdev->act_log->nr_elements == mdev->sync_conf.al_extents) 665 return 0; 666 667 in_use = 0; 668 t = mdev->act_log; 669 n = lc_create("act_log", drbd_al_ext_cache, 670 mdev->sync_conf.al_extents, sizeof(struct lc_element), 0); 671 672 if (n == NULL) { 673 dev_err(DEV, "Cannot allocate act_log lru!\n"); 674 return -ENOMEM; 675 } 676 spin_lock_irq(&mdev->al_lock); 677 if (t) { 678 for (i = 0; i < t->nr_elements; i++) { 679 e = lc_element_by_index(t, i); 680 if (e->refcnt) 681 dev_err(DEV, "refcnt(%d)==%d\n", 682 e->lc_number, e->refcnt); 683 in_use += e->refcnt; 684 } 685 } 686 if (!in_use) 687 mdev->act_log = n; 688 spin_unlock_irq(&mdev->al_lock); 689 if (in_use) { 690 dev_err(DEV, "Activity log still in use!\n"); 691 lc_destroy(n); 692 return -EBUSY; 693 } else { 694 if (t) 695 lc_destroy(t); 696 } 697 drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */ 698 return 0; 699} 700 701void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_seg_s) __must_hold(local) 702{ 703 struct request_queue * const q = mdev->rq_queue; 704 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue; 705 int max_segments = mdev->ldev->dc.max_bio_bvecs; 706 707 if (b->merge_bvec_fn && !mdev->ldev->dc.use_bmbv) 708 max_seg_s = PAGE_SIZE; 709 710 max_seg_s = min(queue_max_sectors(b) * queue_logical_block_size(b), max_seg_s); 711 712 blk_queue_max_hw_sectors(q, max_seg_s >> 9); 713 blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS); 714 blk_queue_max_segment_size(q, max_seg_s); 715 blk_queue_logical_block_size(q, 512); 716 blk_queue_segment_boundary(q, PAGE_SIZE-1); 717 blk_stack_limits(&q->limits, &b->limits, 0); 718 719 if (b->merge_bvec_fn) 720 dev_warn(DEV, "Backing device's merge_bvec_fn() = %p\n", 721 b->merge_bvec_fn); 722 dev_info(DEV, "max_segment_size ( = BIO size ) = %u\n", queue_max_segment_size(q)); 723 724 if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) { 725 dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n", 726 q->backing_dev_info.ra_pages, 727 b->backing_dev_info.ra_pages); 728 q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages; 729 } 730} 731 732/* serialize deconfig (worker exiting, doing cleanup) 733 * and reconfig (drbdsetup disk, drbdsetup net) 734 * 735 * wait for a potentially exiting worker, then restart it, 736 * or start a new one. 737 */ 738static void drbd_reconfig_start(struct drbd_conf *mdev) 739{ 740 wait_event(mdev->state_wait, !test_and_set_bit(CONFIG_PENDING, &mdev->flags)); 741 wait_event(mdev->state_wait, !test_bit(DEVICE_DYING, &mdev->flags)); 742 drbd_thread_start(&mdev->worker); 743} 744 745/* if still unconfigured, stops worker again. 746 * if configured now, clears CONFIG_PENDING. 747 * wakes potential waiters */ 748static void drbd_reconfig_done(struct drbd_conf *mdev) 749{ 750 spin_lock_irq(&mdev->req_lock); 751 if (mdev->state.disk == D_DISKLESS && 752 mdev->state.conn == C_STANDALONE && 753 mdev->state.role == R_SECONDARY) { 754 set_bit(DEVICE_DYING, &mdev->flags); 755 drbd_thread_stop_nowait(&mdev->worker); 756 } else 757 clear_bit(CONFIG_PENDING, &mdev->flags); 758 spin_unlock_irq(&mdev->req_lock); 759 wake_up(&mdev->state_wait); 760} 761 762/* does always return 0; 763 * interesting return code is in reply->ret_code */ 764static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 765 struct drbd_nl_cfg_reply *reply) 766{ 767 enum drbd_ret_codes retcode; 768 enum determine_dev_size dd; 769 sector_t max_possible_sectors; 770 sector_t min_md_device_sectors; 771 struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */ 772 struct inode *inode, *inode2; 773 struct lru_cache *resync_lru = NULL; 774 union drbd_state ns, os; 775 int rv; 776 int cp_discovered = 0; 777 int logical_block_size; 778 779 drbd_reconfig_start(mdev); 780 781 /* if you want to reconfigure, please tear down first */ 782 if (mdev->state.disk > D_DISKLESS) { 783 retcode = ERR_DISK_CONFIGURED; 784 goto fail; 785 } 786 787 /* allocation not in the IO path, cqueue thread context */ 788 nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL); 789 if (!nbc) { 790 retcode = ERR_NOMEM; 791 goto fail; 792 } 793 794 nbc->dc.disk_size = DRBD_DISK_SIZE_SECT_DEF; 795 nbc->dc.on_io_error = DRBD_ON_IO_ERROR_DEF; 796 nbc->dc.fencing = DRBD_FENCING_DEF; 797 nbc->dc.max_bio_bvecs = DRBD_MAX_BIO_BVECS_DEF; 798 799 if (!disk_conf_from_tags(mdev, nlp->tag_list, &nbc->dc)) { 800 retcode = ERR_MANDATORY_TAG; 801 goto fail; 802 } 803 804 if (nbc->dc.meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) { 805 retcode = ERR_MD_IDX_INVALID; 806 goto fail; 807 } 808 809 nbc->lo_file = filp_open(nbc->dc.backing_dev, O_RDWR, 0); 810 if (IS_ERR(nbc->lo_file)) { 811 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev, 812 PTR_ERR(nbc->lo_file)); 813 nbc->lo_file = NULL; 814 retcode = ERR_OPEN_DISK; 815 goto fail; 816 } 817 818 inode = nbc->lo_file->f_dentry->d_inode; 819 820 if (!S_ISBLK(inode->i_mode)) { 821 retcode = ERR_DISK_NOT_BDEV; 822 goto fail; 823 } 824 825 nbc->md_file = filp_open(nbc->dc.meta_dev, O_RDWR, 0); 826 if (IS_ERR(nbc->md_file)) { 827 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev, 828 PTR_ERR(nbc->md_file)); 829 nbc->md_file = NULL; 830 retcode = ERR_OPEN_MD_DISK; 831 goto fail; 832 } 833 834 inode2 = nbc->md_file->f_dentry->d_inode; 835 836 if (!S_ISBLK(inode2->i_mode)) { 837 retcode = ERR_MD_NOT_BDEV; 838 goto fail; 839 } 840 841 nbc->backing_bdev = inode->i_bdev; 842 if (bd_claim(nbc->backing_bdev, mdev)) { 843 printk(KERN_ERR "drbd: bd_claim(%p,%p); failed [%p;%p;%u]\n", 844 nbc->backing_bdev, mdev, 845 nbc->backing_bdev->bd_holder, 846 nbc->backing_bdev->bd_contains->bd_holder, 847 nbc->backing_bdev->bd_holders); 848 retcode = ERR_BDCLAIM_DISK; 849 goto fail; 850 } 851 852 resync_lru = lc_create("resync", drbd_bm_ext_cache, 853 61, sizeof(struct bm_extent), 854 offsetof(struct bm_extent, lce)); 855 if (!resync_lru) { 856 retcode = ERR_NOMEM; 857 goto release_bdev_fail; 858 } 859 860 /* meta_dev_idx >= 0: external fixed size, 861 * possibly multiple drbd sharing one meta device. 862 * TODO in that case, paranoia check that [md_bdev, meta_dev_idx] is 863 * not yet used by some other drbd minor! 864 * (if you use drbd.conf + drbdadm, 865 * that should check it for you already; but if you don't, or someone 866 * fooled it, we need to double check here) */ 867 nbc->md_bdev = inode2->i_bdev; 868 if (bd_claim(nbc->md_bdev, (nbc->dc.meta_dev_idx < 0) ? (void *)mdev 869 : (void *) drbd_m_holder)) { 870 retcode = ERR_BDCLAIM_MD_DISK; 871 goto release_bdev_fail; 872 } 873 874 if ((nbc->backing_bdev == nbc->md_bdev) != 875 (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL || 876 nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) { 877 retcode = ERR_MD_IDX_INVALID; 878 goto release_bdev2_fail; 879 } 880 881 /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */ 882 drbd_md_set_sector_offsets(mdev, nbc); 883 884 if (drbd_get_max_capacity(nbc) < nbc->dc.disk_size) { 885 dev_err(DEV, "max capacity %llu smaller than disk size %llu\n", 886 (unsigned long long) drbd_get_max_capacity(nbc), 887 (unsigned long long) nbc->dc.disk_size); 888 retcode = ERR_DISK_TO_SMALL; 889 goto release_bdev2_fail; 890 } 891 892 if (nbc->dc.meta_dev_idx < 0) { 893 max_possible_sectors = DRBD_MAX_SECTORS_FLEX; 894 /* at least one MB, otherwise it does not make sense */ 895 min_md_device_sectors = (2<<10); 896 } else { 897 max_possible_sectors = DRBD_MAX_SECTORS; 898 min_md_device_sectors = MD_RESERVED_SECT * (nbc->dc.meta_dev_idx + 1); 899 } 900 901 if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) { 902 retcode = ERR_MD_DISK_TO_SMALL; 903 dev_warn(DEV, "refusing attach: md-device too small, " 904 "at least %llu sectors needed for this meta-disk type\n", 905 (unsigned long long) min_md_device_sectors); 906 goto release_bdev2_fail; 907 } 908 909 /* Make sure the new disk is big enough 910 * (we may currently be R_PRIMARY with no local disk...) */ 911 if (drbd_get_max_capacity(nbc) < 912 drbd_get_capacity(mdev->this_bdev)) { 913 retcode = ERR_DISK_TO_SMALL; 914 goto release_bdev2_fail; 915 } 916 917 nbc->known_size = drbd_get_capacity(nbc->backing_bdev); 918 919 if (nbc->known_size > max_possible_sectors) { 920 dev_warn(DEV, "==> truncating very big lower level device " 921 "to currently maximum possible %llu sectors <==\n", 922 (unsigned long long) max_possible_sectors); 923 if (nbc->dc.meta_dev_idx >= 0) 924 dev_warn(DEV, "==>> using internal or flexible " 925 "meta data may help <<==\n"); 926 } 927 928 drbd_suspend_io(mdev); 929 /* also wait for the last barrier ack. */ 930 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt)); 931 /* and for any other previously queued work */ 932 drbd_flush_workqueue(mdev); 933 934 retcode = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE); 935 drbd_resume_io(mdev); 936 if (retcode < SS_SUCCESS) 937 goto release_bdev2_fail; 938 939 if (!get_ldev_if_state(mdev, D_ATTACHING)) 940 goto force_diskless; 941 942 drbd_md_set_sector_offsets(mdev, nbc); 943 944 /* allocate a second IO page if logical_block_size != 512 */ 945 logical_block_size = bdev_logical_block_size(nbc->md_bdev); 946 if (logical_block_size == 0) 947 logical_block_size = MD_SECTOR_SIZE; 948 949 if (logical_block_size != MD_SECTOR_SIZE) { 950 if (!mdev->md_io_tmpp) { 951 struct page *page = alloc_page(GFP_NOIO); 952 if (!page) 953 goto force_diskless_dec; 954 955 dev_warn(DEV, "Meta data's bdev logical_block_size = %d != %d\n", 956 logical_block_size, MD_SECTOR_SIZE); 957 dev_warn(DEV, "Workaround engaged (has performance impact).\n"); 958 959 mdev->md_io_tmpp = page; 960 } 961 } 962 963 if (!mdev->bitmap) { 964 if (drbd_bm_init(mdev)) { 965 retcode = ERR_NOMEM; 966 goto force_diskless_dec; 967 } 968 } 969 970 retcode = drbd_md_read(mdev, nbc); 971 if (retcode != NO_ERROR) 972 goto force_diskless_dec; 973 974 if (mdev->state.conn < C_CONNECTED && 975 mdev->state.role == R_PRIMARY && 976 (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) { 977 dev_err(DEV, "Can only attach to data with current UUID=%016llX\n", 978 (unsigned long long)mdev->ed_uuid); 979 retcode = ERR_DATA_NOT_CURRENT; 980 goto force_diskless_dec; 981 } 982 983 /* Since we are diskless, fix the activity log first... */ 984 if (drbd_check_al_size(mdev)) { 985 retcode = ERR_NOMEM; 986 goto force_diskless_dec; 987 } 988 989 /* Prevent shrinking of consistent devices ! */ 990 if (drbd_md_test_flag(nbc, MDF_CONSISTENT) && 991 drbd_new_dev_size(mdev, nbc, 0) < nbc->md.la_size_sect) { 992 dev_warn(DEV, "refusing to truncate a consistent device\n"); 993 retcode = ERR_DISK_TO_SMALL; 994 goto force_diskless_dec; 995 } 996 997 if (!drbd_al_read_log(mdev, nbc)) { 998 retcode = ERR_IO_MD_DISK; 999 goto force_diskless_dec; 1000 } 1001 1002 /* Reset the "barriers don't work" bits here, then force meta data to 1003 * be written, to ensure we determine if barriers are supported. */ 1004 if (nbc->dc.no_md_flush) 1005 set_bit(MD_NO_BARRIER, &mdev->flags); 1006 else 1007 clear_bit(MD_NO_BARRIER, &mdev->flags); 1008 1009 /* Point of no return reached. 1010 * Devices and memory are no longer released by error cleanup below. 1011 * now mdev takes over responsibility, and the state engine should 1012 * clean it up somewhere. */ 1013 D_ASSERT(mdev->ldev == NULL); 1014 mdev->ldev = nbc; 1015 mdev->resync = resync_lru; 1016 nbc = NULL; 1017 resync_lru = NULL; 1018 1019 mdev->write_ordering = WO_bio_barrier; 1020 drbd_bump_write_ordering(mdev, WO_bio_barrier); 1021 1022 if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY)) 1023 set_bit(CRASHED_PRIMARY, &mdev->flags); 1024 else 1025 clear_bit(CRASHED_PRIMARY, &mdev->flags); 1026 1027 if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND)) { 1028 set_bit(CRASHED_PRIMARY, &mdev->flags); 1029 cp_discovered = 1; 1030 } 1031 1032 mdev->send_cnt = 0; 1033 mdev->recv_cnt = 0; 1034 mdev->read_cnt = 0; 1035 mdev->writ_cnt = 0; 1036 1037 drbd_setup_queue_param(mdev, DRBD_MAX_SEGMENT_SIZE); 1038 1039 /* If I am currently not R_PRIMARY, 1040 * but meta data primary indicator is set, 1041 * I just now recover from a hard crash, 1042 * and have been R_PRIMARY before that crash. 1043 * 1044 * Now, if I had no connection before that crash 1045 * (have been degraded R_PRIMARY), chances are that 1046 * I won't find my peer now either. 1047 * 1048 * In that case, and _only_ in that case, 1049 * we use the degr-wfc-timeout instead of the default, 1050 * so we can automatically recover from a crash of a 1051 * degraded but active "cluster" after a certain timeout. 1052 */ 1053 clear_bit(USE_DEGR_WFC_T, &mdev->flags); 1054 if (mdev->state.role != R_PRIMARY && 1055 drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) && 1056 !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND)) 1057 set_bit(USE_DEGR_WFC_T, &mdev->flags); 1058 1059 dd = drbd_determin_dev_size(mdev, 0); 1060 if (dd == dev_size_error) { 1061 retcode = ERR_NOMEM_BITMAP; 1062 goto force_diskless_dec; 1063 } else if (dd == grew) 1064 set_bit(RESYNC_AFTER_NEG, &mdev->flags); 1065 1066 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) { 1067 dev_info(DEV, "Assuming that all blocks are out of sync " 1068 "(aka FullSync)\n"); 1069 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from attaching")) { 1070 retcode = ERR_IO_MD_DISK; 1071 goto force_diskless_dec; 1072 } 1073 } else { 1074 if (drbd_bitmap_io(mdev, &drbd_bm_read, "read from attaching") < 0) { 1075 retcode = ERR_IO_MD_DISK; 1076 goto force_diskless_dec; 1077 } 1078 } 1079 1080 if (cp_discovered) { 1081 drbd_al_apply_to_bm(mdev); 1082 drbd_al_to_on_disk_bm(mdev); 1083 } 1084 1085 spin_lock_irq(&mdev->req_lock); 1086 os = mdev->state; 1087 ns.i = os.i; 1088 /* If MDF_CONSISTENT is not set go into inconsistent state, 1089 otherwise investigate MDF_WasUpToDate... 1090 If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state, 1091 otherwise into D_CONSISTENT state. 1092 */ 1093 if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) { 1094 if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE)) 1095 ns.disk = D_CONSISTENT; 1096 else 1097 ns.disk = D_OUTDATED; 1098 } else { 1099 ns.disk = D_INCONSISTENT; 1100 } 1101 1102 if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED)) 1103 ns.pdsk = D_OUTDATED; 1104 1105 if ( ns.disk == D_CONSISTENT && 1106 (ns.pdsk == D_OUTDATED || mdev->ldev->dc.fencing == FP_DONT_CARE)) 1107 ns.disk = D_UP_TO_DATE; 1108 1109 /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND, 1110 MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before 1111 this point, because drbd_request_state() modifies these 1112 flags. */ 1113 1114 /* In case we are C_CONNECTED postpone any decision on the new disk 1115 state after the negotiation phase. */ 1116 if (mdev->state.conn == C_CONNECTED) { 1117 mdev->new_state_tmp.i = ns.i; 1118 ns.i = os.i; 1119 ns.disk = D_NEGOTIATING; 1120 } 1121 1122 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 1123 ns = mdev->state; 1124 spin_unlock_irq(&mdev->req_lock); 1125 1126 if (rv < SS_SUCCESS) 1127 goto force_diskless_dec; 1128 1129 if (mdev->state.role == R_PRIMARY) 1130 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1; 1131 else 1132 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1; 1133 1134 drbd_md_mark_dirty(mdev); 1135 drbd_md_sync(mdev); 1136 1137 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE); 1138 put_ldev(mdev); 1139 reply->ret_code = retcode; 1140 drbd_reconfig_done(mdev); 1141 return 0; 1142 1143 force_diskless_dec: 1144 put_ldev(mdev); 1145 force_diskless: 1146 drbd_force_state(mdev, NS(disk, D_DISKLESS)); 1147 drbd_md_sync(mdev); 1148 release_bdev2_fail: 1149 if (nbc) 1150 bd_release(nbc->md_bdev); 1151 release_bdev_fail: 1152 if (nbc) 1153 bd_release(nbc->backing_bdev); 1154 fail: 1155 if (nbc) { 1156 if (nbc->lo_file) 1157 fput(nbc->lo_file); 1158 if (nbc->md_file) 1159 fput(nbc->md_file); 1160 kfree(nbc); 1161 } 1162 lc_destroy(resync_lru); 1163 1164 reply->ret_code = retcode; 1165 drbd_reconfig_done(mdev); 1166 return 0; 1167} 1168 1169static int drbd_nl_detach(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1170 struct drbd_nl_cfg_reply *reply) 1171{ 1172 reply->ret_code = drbd_request_state(mdev, NS(disk, D_DISKLESS)); 1173 return 0; 1174} 1175 1176static int drbd_nl_net_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1177 struct drbd_nl_cfg_reply *reply) 1178{ 1179 int i, ns; 1180 enum drbd_ret_codes retcode; 1181 struct net_conf *new_conf = NULL; 1182 struct crypto_hash *tfm = NULL; 1183 struct crypto_hash *integrity_w_tfm = NULL; 1184 struct crypto_hash *integrity_r_tfm = NULL; 1185 struct hlist_head *new_tl_hash = NULL; 1186 struct hlist_head *new_ee_hash = NULL; 1187 struct drbd_conf *odev; 1188 char hmac_name[CRYPTO_MAX_ALG_NAME]; 1189 void *int_dig_out = NULL; 1190 void *int_dig_in = NULL; 1191 void *int_dig_vv = NULL; 1192 struct sockaddr *new_my_addr, *new_peer_addr, *taken_addr; 1193 1194 drbd_reconfig_start(mdev); 1195 1196 if (mdev->state.conn > C_STANDALONE) { 1197 retcode = ERR_NET_CONFIGURED; 1198 goto fail; 1199 } 1200 1201 /* allocation not in the IO path, cqueue thread context */ 1202 new_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 1203 if (!new_conf) { 1204 retcode = ERR_NOMEM; 1205 goto fail; 1206 } 1207 1208 memset(new_conf, 0, sizeof(struct net_conf)); 1209 new_conf->timeout = DRBD_TIMEOUT_DEF; 1210 new_conf->try_connect_int = DRBD_CONNECT_INT_DEF; 1211 new_conf->ping_int = DRBD_PING_INT_DEF; 1212 new_conf->max_epoch_size = DRBD_MAX_EPOCH_SIZE_DEF; 1213 new_conf->max_buffers = DRBD_MAX_BUFFERS_DEF; 1214 new_conf->unplug_watermark = DRBD_UNPLUG_WATERMARK_DEF; 1215 new_conf->sndbuf_size = DRBD_SNDBUF_SIZE_DEF; 1216 new_conf->rcvbuf_size = DRBD_RCVBUF_SIZE_DEF; 1217 new_conf->ko_count = DRBD_KO_COUNT_DEF; 1218 new_conf->after_sb_0p = DRBD_AFTER_SB_0P_DEF; 1219 new_conf->after_sb_1p = DRBD_AFTER_SB_1P_DEF; 1220 new_conf->after_sb_2p = DRBD_AFTER_SB_2P_DEF; 1221 new_conf->want_lose = 0; 1222 new_conf->two_primaries = 0; 1223 new_conf->wire_protocol = DRBD_PROT_C; 1224 new_conf->ping_timeo = DRBD_PING_TIMEO_DEF; 1225 new_conf->rr_conflict = DRBD_RR_CONFLICT_DEF; 1226 1227 if (!net_conf_from_tags(mdev, nlp->tag_list, new_conf)) { 1228 retcode = ERR_MANDATORY_TAG; 1229 goto fail; 1230 } 1231 1232 if (new_conf->two_primaries 1233 && (new_conf->wire_protocol != DRBD_PROT_C)) { 1234 retcode = ERR_NOT_PROTO_C; 1235 goto fail; 1236 }; 1237 1238 if (mdev->state.role == R_PRIMARY && new_conf->want_lose) { 1239 retcode = ERR_DISCARD; 1240 goto fail; 1241 } 1242 1243 retcode = NO_ERROR; 1244 1245 new_my_addr = (struct sockaddr *)&new_conf->my_addr; 1246 new_peer_addr = (struct sockaddr *)&new_conf->peer_addr; 1247 for (i = 0; i < minor_count; i++) { 1248 odev = minor_to_mdev(i); 1249 if (!odev || odev == mdev) 1250 continue; 1251 if (get_net_conf(odev)) { 1252 taken_addr = (struct sockaddr *)&odev->net_conf->my_addr; 1253 if (new_conf->my_addr_len == odev->net_conf->my_addr_len && 1254 !memcmp(new_my_addr, taken_addr, new_conf->my_addr_len)) 1255 retcode = ERR_LOCAL_ADDR; 1256 1257 taken_addr = (struct sockaddr *)&odev->net_conf->peer_addr; 1258 if (new_conf->peer_addr_len == odev->net_conf->peer_addr_len && 1259 !memcmp(new_peer_addr, taken_addr, new_conf->peer_addr_len)) 1260 retcode = ERR_PEER_ADDR; 1261 1262 put_net_conf(odev); 1263 if (retcode != NO_ERROR) 1264 goto fail; 1265 } 1266 } 1267 1268 if (new_conf->cram_hmac_alg[0] != 0) { 1269 snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)", 1270 new_conf->cram_hmac_alg); 1271 tfm = crypto_alloc_hash(hmac_name, 0, CRYPTO_ALG_ASYNC); 1272 if (IS_ERR(tfm)) { 1273 tfm = NULL; 1274 retcode = ERR_AUTH_ALG; 1275 goto fail; 1276 } 1277 1278 if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 1279 retcode = ERR_AUTH_ALG_ND; 1280 goto fail; 1281 } 1282 } 1283 1284 if (new_conf->integrity_alg[0]) { 1285 integrity_w_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC); 1286 if (IS_ERR(integrity_w_tfm)) { 1287 integrity_w_tfm = NULL; 1288 retcode=ERR_INTEGRITY_ALG; 1289 goto fail; 1290 } 1291 1292 if (!drbd_crypto_is_hash(crypto_hash_tfm(integrity_w_tfm))) { 1293 retcode=ERR_INTEGRITY_ALG_ND; 1294 goto fail; 1295 } 1296 1297 integrity_r_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC); 1298 if (IS_ERR(integrity_r_tfm)) { 1299 integrity_r_tfm = NULL; 1300 retcode=ERR_INTEGRITY_ALG; 1301 goto fail; 1302 } 1303 } 1304 1305 ns = new_conf->max_epoch_size/8; 1306 if (mdev->tl_hash_s != ns) { 1307 new_tl_hash = kzalloc(ns*sizeof(void *), GFP_KERNEL); 1308 if (!new_tl_hash) { 1309 retcode = ERR_NOMEM; 1310 goto fail; 1311 } 1312 } 1313 1314 ns = new_conf->max_buffers/8; 1315 if (new_conf->two_primaries && (mdev->ee_hash_s != ns)) { 1316 new_ee_hash = kzalloc(ns*sizeof(void *), GFP_KERNEL); 1317 if (!new_ee_hash) { 1318 retcode = ERR_NOMEM; 1319 goto fail; 1320 } 1321 } 1322 1323 ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0; 1324 1325 if (integrity_w_tfm) { 1326 i = crypto_hash_digestsize(integrity_w_tfm); 1327 int_dig_out = kmalloc(i, GFP_KERNEL); 1328 if (!int_dig_out) { 1329 retcode = ERR_NOMEM; 1330 goto fail; 1331 } 1332 int_dig_in = kmalloc(i, GFP_KERNEL); 1333 if (!int_dig_in) { 1334 retcode = ERR_NOMEM; 1335 goto fail; 1336 } 1337 int_dig_vv = kmalloc(i, GFP_KERNEL); 1338 if (!int_dig_vv) { 1339 retcode = ERR_NOMEM; 1340 goto fail; 1341 } 1342 } 1343 1344 if (!mdev->bitmap) { 1345 if(drbd_bm_init(mdev)) { 1346 retcode = ERR_NOMEM; 1347 goto fail; 1348 } 1349 } 1350 1351 spin_lock_irq(&mdev->req_lock); 1352 if (mdev->net_conf != NULL) { 1353 retcode = ERR_NET_CONFIGURED; 1354 spin_unlock_irq(&mdev->req_lock); 1355 goto fail; 1356 } 1357 mdev->net_conf = new_conf; 1358 1359 mdev->send_cnt = 0; 1360 mdev->recv_cnt = 0; 1361 1362 if (new_tl_hash) { 1363 kfree(mdev->tl_hash); 1364 mdev->tl_hash_s = mdev->net_conf->max_epoch_size/8; 1365 mdev->tl_hash = new_tl_hash; 1366 } 1367 1368 if (new_ee_hash) { 1369 kfree(mdev->ee_hash); 1370 mdev->ee_hash_s = mdev->net_conf->max_buffers/8; 1371 mdev->ee_hash = new_ee_hash; 1372 } 1373 1374 crypto_free_hash(mdev->cram_hmac_tfm); 1375 mdev->cram_hmac_tfm = tfm; 1376 1377 crypto_free_hash(mdev->integrity_w_tfm); 1378 mdev->integrity_w_tfm = integrity_w_tfm; 1379 1380 crypto_free_hash(mdev->integrity_r_tfm); 1381 mdev->integrity_r_tfm = integrity_r_tfm; 1382 1383 kfree(mdev->int_dig_out); 1384 kfree(mdev->int_dig_in); 1385 kfree(mdev->int_dig_vv); 1386 mdev->int_dig_out=int_dig_out; 1387 mdev->int_dig_in=int_dig_in; 1388 mdev->int_dig_vv=int_dig_vv; 1389 spin_unlock_irq(&mdev->req_lock); 1390 1391 retcode = _drbd_request_state(mdev, NS(conn, C_UNCONNECTED), CS_VERBOSE); 1392 1393 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE); 1394 reply->ret_code = retcode; 1395 drbd_reconfig_done(mdev); 1396 return 0; 1397 1398fail: 1399 kfree(int_dig_out); 1400 kfree(int_dig_in); 1401 kfree(int_dig_vv); 1402 crypto_free_hash(tfm); 1403 crypto_free_hash(integrity_w_tfm); 1404 crypto_free_hash(integrity_r_tfm); 1405 kfree(new_tl_hash); 1406 kfree(new_ee_hash); 1407 kfree(new_conf); 1408 1409 reply->ret_code = retcode; 1410 drbd_reconfig_done(mdev); 1411 return 0; 1412} 1413 1414static int drbd_nl_disconnect(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1415 struct drbd_nl_cfg_reply *reply) 1416{ 1417 int retcode; 1418 1419 retcode = _drbd_request_state(mdev, NS(conn, C_DISCONNECTING), CS_ORDERED); 1420 1421 if (retcode == SS_NOTHING_TO_DO) 1422 goto done; 1423 else if (retcode == SS_ALREADY_STANDALONE) 1424 goto done; 1425 else if (retcode == SS_PRIMARY_NOP) { 1426 /* Our statche checking code wants to see the peer outdated. */ 1427 retcode = drbd_request_state(mdev, NS2(conn, C_DISCONNECTING, 1428 pdsk, D_OUTDATED)); 1429 } else if (retcode == SS_CW_FAILED_BY_PEER) { 1430 /* The peer probably wants to see us outdated. */ 1431 retcode = _drbd_request_state(mdev, NS2(conn, C_DISCONNECTING, 1432 disk, D_OUTDATED), 1433 CS_ORDERED); 1434 if (retcode == SS_IS_DISKLESS || retcode == SS_LOWER_THAN_OUTDATED) { 1435 drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 1436 retcode = SS_SUCCESS; 1437 } 1438 } 1439 1440 if (retcode < SS_SUCCESS) 1441 goto fail; 1442 1443 if (wait_event_interruptible(mdev->state_wait, 1444 mdev->state.conn != C_DISCONNECTING)) { 1445 /* Do not test for mdev->state.conn == C_STANDALONE, since 1446 someone else might connect us in the mean time! */ 1447 retcode = ERR_INTR; 1448 goto fail; 1449 } 1450 1451 done: 1452 retcode = NO_ERROR; 1453 fail: 1454 drbd_md_sync(mdev); 1455 reply->ret_code = retcode; 1456 return 0; 1457} 1458 1459void resync_after_online_grow(struct drbd_conf *mdev) 1460{ 1461 int iass; /* I am sync source */ 1462 1463 dev_info(DEV, "Resync of new storage after online grow\n"); 1464 if (mdev->state.role != mdev->state.peer) 1465 iass = (mdev->state.role == R_PRIMARY); 1466 else 1467 iass = test_bit(DISCARD_CONCURRENT, &mdev->flags); 1468 1469 if (iass) 1470 drbd_start_resync(mdev, C_SYNC_SOURCE); 1471 else 1472 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE); 1473} 1474 1475static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1476 struct drbd_nl_cfg_reply *reply) 1477{ 1478 struct resize rs; 1479 int retcode = NO_ERROR; 1480 enum determine_dev_size dd; 1481 enum dds_flags ddsf; 1482 1483 memset(&rs, 0, sizeof(struct resize)); 1484 if (!resize_from_tags(mdev, nlp->tag_list, &rs)) { 1485 retcode = ERR_MANDATORY_TAG; 1486 goto fail; 1487 } 1488 1489 if (mdev->state.conn > C_CONNECTED) { 1490 retcode = ERR_RESIZE_RESYNC; 1491 goto fail; 1492 } 1493 1494 if (mdev->state.role == R_SECONDARY && 1495 mdev->state.peer == R_SECONDARY) { 1496 retcode = ERR_NO_PRIMARY; 1497 goto fail; 1498 } 1499 1500 if (!get_ldev(mdev)) { 1501 retcode = ERR_NO_DISK; 1502 goto fail; 1503 } 1504 1505 if (rs.no_resync && mdev->agreed_pro_version < 93) { 1506 retcode = ERR_NEED_APV_93; 1507 goto fail; 1508 } 1509 1510 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) 1511 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 1512 1513 mdev->ldev->dc.disk_size = (sector_t)rs.resize_size; 1514 ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0); 1515 dd = drbd_determin_dev_size(mdev, ddsf); 1516 drbd_md_sync(mdev); 1517 put_ldev(mdev); 1518 if (dd == dev_size_error) { 1519 retcode = ERR_NOMEM_BITMAP; 1520 goto fail; 1521 } 1522 1523 if (mdev->state.conn == C_CONNECTED) { 1524 if (dd == grew) 1525 set_bit(RESIZE_PENDING, &mdev->flags); 1526 1527 drbd_send_uuids(mdev); 1528 drbd_send_sizes(mdev, 1, ddsf); 1529 } 1530 1531 fail: 1532 reply->ret_code = retcode; 1533 return 0; 1534} 1535 1536static int drbd_nl_syncer_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1537 struct drbd_nl_cfg_reply *reply) 1538{ 1539 int retcode = NO_ERROR; 1540 int err; 1541 int ovr; /* online verify running */ 1542 int rsr; /* re-sync running */ 1543 struct crypto_hash *verify_tfm = NULL; 1544 struct crypto_hash *csums_tfm = NULL; 1545 struct syncer_conf sc; 1546 cpumask_var_t new_cpu_mask; 1547 1548 if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL)) { 1549 retcode = ERR_NOMEM; 1550 goto fail; 1551 } 1552 1553 if (nlp->flags & DRBD_NL_SET_DEFAULTS) { 1554 memset(&sc, 0, sizeof(struct syncer_conf)); 1555 sc.rate = DRBD_RATE_DEF; 1556 sc.after = DRBD_AFTER_DEF; 1557 sc.al_extents = DRBD_AL_EXTENTS_DEF; 1558 } else 1559 memcpy(&sc, &mdev->sync_conf, sizeof(struct syncer_conf)); 1560 1561 if (!syncer_conf_from_tags(mdev, nlp->tag_list, &sc)) { 1562 retcode = ERR_MANDATORY_TAG; 1563 goto fail; 1564 } 1565 1566 /* re-sync running */ 1567 rsr = ( mdev->state.conn == C_SYNC_SOURCE || 1568 mdev->state.conn == C_SYNC_TARGET || 1569 mdev->state.conn == C_PAUSED_SYNC_S || 1570 mdev->state.conn == C_PAUSED_SYNC_T ); 1571 1572 if (rsr && strcmp(sc.csums_alg, mdev->sync_conf.csums_alg)) { 1573 retcode = ERR_CSUMS_RESYNC_RUNNING; 1574 goto fail; 1575 } 1576 1577 if (!rsr && sc.csums_alg[0]) { 1578 csums_tfm = crypto_alloc_hash(sc.csums_alg, 0, CRYPTO_ALG_ASYNC); 1579 if (IS_ERR(csums_tfm)) { 1580 csums_tfm = NULL; 1581 retcode = ERR_CSUMS_ALG; 1582 goto fail; 1583 } 1584 1585 if (!drbd_crypto_is_hash(crypto_hash_tfm(csums_tfm))) { 1586 retcode = ERR_CSUMS_ALG_ND; 1587 goto fail; 1588 } 1589 } 1590 1591 /* online verify running */ 1592 ovr = (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T); 1593 1594 if (ovr) { 1595 if (strcmp(sc.verify_alg, mdev->sync_conf.verify_alg)) { 1596 retcode = ERR_VERIFY_RUNNING; 1597 goto fail; 1598 } 1599 } 1600 1601 if (!ovr && sc.verify_alg[0]) { 1602 verify_tfm = crypto_alloc_hash(sc.verify_alg, 0, CRYPTO_ALG_ASYNC); 1603 if (IS_ERR(verify_tfm)) { 1604 verify_tfm = NULL; 1605 retcode = ERR_VERIFY_ALG; 1606 goto fail; 1607 } 1608 1609 if (!drbd_crypto_is_hash(crypto_hash_tfm(verify_tfm))) { 1610 retcode = ERR_VERIFY_ALG_ND; 1611 goto fail; 1612 } 1613 } 1614 1615 /* silently ignore cpu mask on UP kernel */ 1616 if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) { 1617 err = __bitmap_parse(sc.cpu_mask, 32, 0, 1618 cpumask_bits(new_cpu_mask), nr_cpu_ids); 1619 if (err) { 1620 dev_warn(DEV, "__bitmap_parse() failed with %d\n", err); 1621 retcode = ERR_CPU_MASK_PARSE; 1622 goto fail; 1623 } 1624 } 1625 1626 ERR_IF (sc.rate < 1) sc.rate = 1; 1627 ERR_IF (sc.al_extents < 7) sc.al_extents = 127; /* arbitrary minimum */ 1628#define AL_MAX ((MD_AL_MAX_SIZE-1) * AL_EXTENTS_PT) 1629 if (sc.al_extents > AL_MAX) { 1630 dev_err(DEV, "sc.al_extents > %d\n", AL_MAX); 1631 sc.al_extents = AL_MAX; 1632 } 1633#undef AL_MAX 1634 1635 /* most sanity checks done, try to assign the new sync-after 1636 * dependency. need to hold the global lock in there, 1637 * to avoid a race in the dependency loop check. */ 1638 retcode = drbd_alter_sa(mdev, sc.after); 1639 if (retcode != NO_ERROR) 1640 goto fail; 1641 1642 /* ok, assign the rest of it as well. 1643 * lock against receive_SyncParam() */ 1644 spin_lock(&mdev->peer_seq_lock); 1645 mdev->sync_conf = sc; 1646 1647 if (!rsr) { 1648 crypto_free_hash(mdev->csums_tfm); 1649 mdev->csums_tfm = csums_tfm; 1650 csums_tfm = NULL; 1651 } 1652 1653 if (!ovr) { 1654 crypto_free_hash(mdev->verify_tfm); 1655 mdev->verify_tfm = verify_tfm; 1656 verify_tfm = NULL; 1657 } 1658 spin_unlock(&mdev->peer_seq_lock); 1659 1660 if (get_ldev(mdev)) { 1661 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log)); 1662 drbd_al_shrink(mdev); 1663 err = drbd_check_al_size(mdev); 1664 lc_unlock(mdev->act_log); 1665 wake_up(&mdev->al_wait); 1666 1667 put_ldev(mdev); 1668 drbd_md_sync(mdev); 1669 1670 if (err) { 1671 retcode = ERR_NOMEM; 1672 goto fail; 1673 } 1674 } 1675 1676 if (mdev->state.conn >= C_CONNECTED) 1677 drbd_send_sync_param(mdev, &sc); 1678 1679 if (!cpumask_equal(mdev->cpu_mask, new_cpu_mask)) { 1680 cpumask_copy(mdev->cpu_mask, new_cpu_mask); 1681 drbd_calc_cpu_mask(mdev); 1682 mdev->receiver.reset_cpu_mask = 1; 1683 mdev->asender.reset_cpu_mask = 1; 1684 mdev->worker.reset_cpu_mask = 1; 1685 } 1686 1687 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE); 1688fail: 1689 free_cpumask_var(new_cpu_mask); 1690 crypto_free_hash(csums_tfm); 1691 crypto_free_hash(verify_tfm); 1692 reply->ret_code = retcode; 1693 return 0; 1694} 1695 1696static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1697 struct drbd_nl_cfg_reply *reply) 1698{ 1699 int retcode; 1700 1701 retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED); 1702 1703 if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION) 1704 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T)); 1705 1706 while (retcode == SS_NEED_CONNECTION) { 1707 spin_lock_irq(&mdev->req_lock); 1708 if (mdev->state.conn < C_CONNECTED) 1709 retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL); 1710 spin_unlock_irq(&mdev->req_lock); 1711 1712 if (retcode != SS_NEED_CONNECTION) 1713 break; 1714 1715 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T)); 1716 } 1717 1718 reply->ret_code = retcode; 1719 return 0; 1720} 1721 1722static int drbd_nl_invalidate_peer(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1723 struct drbd_nl_cfg_reply *reply) 1724{ 1725 1726 reply->ret_code = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S)); 1727 1728 return 0; 1729} 1730 1731static int drbd_nl_pause_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1732 struct drbd_nl_cfg_reply *reply) 1733{ 1734 int retcode = NO_ERROR; 1735 1736 if (drbd_request_state(mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO) 1737 retcode = ERR_PAUSE_IS_SET; 1738 1739 reply->ret_code = retcode; 1740 return 0; 1741} 1742 1743static int drbd_nl_resume_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1744 struct drbd_nl_cfg_reply *reply) 1745{ 1746 int retcode = NO_ERROR; 1747 1748 if (drbd_request_state(mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) 1749 retcode = ERR_PAUSE_IS_CLEAR; 1750 1751 reply->ret_code = retcode; 1752 return 0; 1753} 1754 1755static int drbd_nl_suspend_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1756 struct drbd_nl_cfg_reply *reply) 1757{ 1758 reply->ret_code = drbd_request_state(mdev, NS(susp, 1)); 1759 1760 return 0; 1761} 1762 1763static int drbd_nl_resume_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1764 struct drbd_nl_cfg_reply *reply) 1765{ 1766 reply->ret_code = drbd_request_state(mdev, NS(susp, 0)); 1767 return 0; 1768} 1769 1770static int drbd_nl_outdate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1771 struct drbd_nl_cfg_reply *reply) 1772{ 1773 reply->ret_code = drbd_request_state(mdev, NS(disk, D_OUTDATED)); 1774 return 0; 1775} 1776 1777static int drbd_nl_get_config(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1778 struct drbd_nl_cfg_reply *reply) 1779{ 1780 unsigned short *tl; 1781 1782 tl = reply->tag_list; 1783 1784 if (get_ldev(mdev)) { 1785 tl = disk_conf_to_tags(mdev, &mdev->ldev->dc, tl); 1786 put_ldev(mdev); 1787 } 1788 1789 if (get_net_conf(mdev)) { 1790 tl = net_conf_to_tags(mdev, mdev->net_conf, tl); 1791 put_net_conf(mdev); 1792 } 1793 tl = syncer_conf_to_tags(mdev, &mdev->sync_conf, tl); 1794 1795 put_unaligned(TT_END, tl++); /* Close the tag list */ 1796 1797 return (int)((char *)tl - (char *)reply->tag_list); 1798} 1799 1800static int drbd_nl_get_state(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1801 struct drbd_nl_cfg_reply *reply) 1802{ 1803 unsigned short *tl = reply->tag_list; 1804 union drbd_state s = mdev->state; 1805 unsigned long rs_left; 1806 unsigned int res; 1807 1808 tl = get_state_to_tags(mdev, (struct get_state *)&s, tl); 1809 1810 /* no local ref, no bitmap, no syncer progress. */ 1811 if (s.conn >= C_SYNC_SOURCE && s.conn <= C_PAUSED_SYNC_T) { 1812 if (get_ldev(mdev)) { 1813 drbd_get_syncer_progress(mdev, &rs_left, &res); 1814 tl = tl_add_int(tl, T_sync_progress, &res); 1815 put_ldev(mdev); 1816 } 1817 } 1818 put_unaligned(TT_END, tl++); /* Close the tag list */ 1819 1820 return (int)((char *)tl - (char *)reply->tag_list); 1821} 1822 1823static int drbd_nl_get_uuids(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1824 struct drbd_nl_cfg_reply *reply) 1825{ 1826 unsigned short *tl; 1827 1828 tl = reply->tag_list; 1829 1830 if (get_ldev(mdev)) { 1831 tl = tl_add_blob(tl, T_uuids, mdev->ldev->md.uuid, UI_SIZE*sizeof(u64)); 1832 tl = tl_add_int(tl, T_uuids_flags, &mdev->ldev->md.flags); 1833 put_ldev(mdev); 1834 } 1835 put_unaligned(TT_END, tl++); /* Close the tag list */ 1836 1837 return (int)((char *)tl - (char *)reply->tag_list); 1838} 1839 1840/** 1841 * drbd_nl_get_timeout_flag() - Used by drbdsetup to find out which timeout value to use 1842 * @mdev: DRBD device. 1843 * @nlp: Netlink/connector packet from drbdsetup 1844 * @reply: Reply packet for drbdsetup 1845 */ 1846static int drbd_nl_get_timeout_flag(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1847 struct drbd_nl_cfg_reply *reply) 1848{ 1849 unsigned short *tl; 1850 char rv; 1851 1852 tl = reply->tag_list; 1853 1854 rv = mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED : 1855 test_bit(USE_DEGR_WFC_T, &mdev->flags) ? UT_DEGRADED : UT_DEFAULT; 1856 1857 tl = tl_add_blob(tl, T_use_degraded, &rv, sizeof(rv)); 1858 put_unaligned(TT_END, tl++); /* Close the tag list */ 1859 1860 return (int)((char *)tl - (char *)reply->tag_list); 1861} 1862 1863static int drbd_nl_start_ov(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1864 struct drbd_nl_cfg_reply *reply) 1865{ 1866 /* default to resume from last known position, if possible */ 1867 struct start_ov args = 1868 { .start_sector = mdev->ov_start_sector }; 1869 1870 if (!start_ov_from_tags(mdev, nlp->tag_list, &args)) { 1871 reply->ret_code = ERR_MANDATORY_TAG; 1872 return 0; 1873 } 1874 /* w_make_ov_request expects position to be aligned */ 1875 mdev->ov_start_sector = args.start_sector & ~BM_SECT_PER_BIT; 1876 reply->ret_code = drbd_request_state(mdev,NS(conn,C_VERIFY_S)); 1877 return 0; 1878} 1879 1880 1881static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp, 1882 struct drbd_nl_cfg_reply *reply) 1883{ 1884 int retcode = NO_ERROR; 1885 int skip_initial_sync = 0; 1886 int err; 1887 1888 struct new_c_uuid args; 1889 1890 memset(&args, 0, sizeof(struct new_c_uuid)); 1891 if (!new_c_uuid_from_tags(mdev, nlp->tag_list, &args)) { 1892 reply->ret_code = ERR_MANDATORY_TAG; 1893 return 0; 1894 } 1895 1896 mutex_lock(&mdev->state_mutex); /* Protects us against serialized state changes. */ 1897 1898 if (!get_ldev(mdev)) { 1899 retcode = ERR_NO_DISK; 1900 goto out; 1901 } 1902 1903 /* this is "skip initial sync", assume to be clean */ 1904 if (mdev->state.conn == C_CONNECTED && mdev->agreed_pro_version >= 90 && 1905 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) { 1906 dev_info(DEV, "Preparing to skip initial sync\n"); 1907 skip_initial_sync = 1; 1908 } else if (mdev->state.conn != C_STANDALONE) { 1909 retcode = ERR_CONNECTED; 1910 goto out_dec; 1911 } 1912 1913 drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */ 1914 drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */ 1915 1916 if (args.clear_bm) { 1917 err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, "clear_n_write from new_c_uuid"); 1918 if (err) { 1919 dev_err(DEV, "Writing bitmap failed with %d\n",err); 1920 retcode = ERR_IO_MD_DISK; 1921 } 1922 if (skip_initial_sync) { 1923 drbd_send_uuids_skip_initial_sync(mdev); 1924 _drbd_uuid_set(mdev, UI_BITMAP, 0); 1925 spin_lock_irq(&mdev->req_lock); 1926 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 1927 CS_VERBOSE, NULL); 1928 spin_unlock_irq(&mdev->req_lock); 1929 } 1930 } 1931 1932 drbd_md_sync(mdev); 1933out_dec: 1934 put_ldev(mdev); 1935out: 1936 mutex_unlock(&mdev->state_mutex); 1937 1938 reply->ret_code = retcode; 1939 return 0; 1940} 1941 1942static struct drbd_conf *ensure_mdev(struct drbd_nl_cfg_req *nlp) 1943{ 1944 struct drbd_conf *mdev; 1945 1946 if (nlp->drbd_minor >= minor_count) 1947 return NULL; 1948 1949 mdev = minor_to_mdev(nlp->drbd_minor); 1950 1951 if (!mdev && (nlp->flags & DRBD_NL_CREATE_DEVICE)) { 1952 struct gendisk *disk = NULL; 1953 mdev = drbd_new_device(nlp->drbd_minor); 1954 1955 spin_lock_irq(&drbd_pp_lock); 1956 if (minor_table[nlp->drbd_minor] == NULL) { 1957 minor_table[nlp->drbd_minor] = mdev; 1958 disk = mdev->vdisk; 1959 mdev = NULL; 1960 } /* else: we lost the race */ 1961 spin_unlock_irq(&drbd_pp_lock); 1962 1963 if (disk) /* we won the race above */ 1964 /* in case we ever add a drbd_delete_device(), 1965 * don't forget the del_gendisk! */ 1966 add_disk(disk); 1967 else /* we lost the race above */ 1968 drbd_free_mdev(mdev); 1969 1970 mdev = minor_to_mdev(nlp->drbd_minor); 1971 } 1972 1973 return mdev; 1974} 1975 1976struct cn_handler_struct { 1977 int (*function)(struct drbd_conf *, 1978 struct drbd_nl_cfg_req *, 1979 struct drbd_nl_cfg_reply *); 1980 int reply_body_size; 1981}; 1982 1983static struct cn_handler_struct cnd_table[] = { 1984 [ P_primary ] = { &drbd_nl_primary, 0 }, 1985 [ P_secondary ] = { &drbd_nl_secondary, 0 }, 1986 [ P_disk_conf ] = { &drbd_nl_disk_conf, 0 }, 1987 [ P_detach ] = { &drbd_nl_detach, 0 }, 1988 [ P_net_conf ] = { &drbd_nl_net_conf, 0 }, 1989 [ P_disconnect ] = { &drbd_nl_disconnect, 0 }, 1990 [ P_resize ] = { &drbd_nl_resize, 0 }, 1991 [ P_syncer_conf ] = { &drbd_nl_syncer_conf, 0 }, 1992 [ P_invalidate ] = { &drbd_nl_invalidate, 0 }, 1993 [ P_invalidate_peer ] = { &drbd_nl_invalidate_peer, 0 }, 1994 [ P_pause_sync ] = { &drbd_nl_pause_sync, 0 }, 1995 [ P_resume_sync ] = { &drbd_nl_resume_sync, 0 }, 1996 [ P_suspend_io ] = { &drbd_nl_suspend_io, 0 }, 1997 [ P_resume_io ] = { &drbd_nl_resume_io, 0 }, 1998 [ P_outdate ] = { &drbd_nl_outdate, 0 }, 1999 [ P_get_config ] = { &drbd_nl_get_config, 2000 sizeof(struct syncer_conf_tag_len_struct) + 2001 sizeof(struct disk_conf_tag_len_struct) + 2002 sizeof(struct net_conf_tag_len_struct) }, 2003 [ P_get_state ] = { &drbd_nl_get_state, 2004 sizeof(struct get_state_tag_len_struct) + 2005 sizeof(struct sync_progress_tag_len_struct) }, 2006 [ P_get_uuids ] = { &drbd_nl_get_uuids, 2007 sizeof(struct get_uuids_tag_len_struct) }, 2008 [ P_get_timeout_flag ] = { &drbd_nl_get_timeout_flag, 2009 sizeof(struct get_timeout_flag_tag_len_struct)}, 2010 [ P_start_ov ] = { &drbd_nl_start_ov, 0 }, 2011 [ P_new_c_uuid ] = { &drbd_nl_new_c_uuid, 0 }, 2012}; 2013 2014static void drbd_connector_callback(struct cn_msg *req, struct netlink_skb_parms *nsp) 2015{ 2016 struct drbd_nl_cfg_req *nlp = (struct drbd_nl_cfg_req *)req->data; 2017 struct cn_handler_struct *cm; 2018 struct cn_msg *cn_reply; 2019 struct drbd_nl_cfg_reply *reply; 2020 struct drbd_conf *mdev; 2021 int retcode, rr; 2022 int reply_size = sizeof(struct cn_msg) 2023 + sizeof(struct drbd_nl_cfg_reply) 2024 + sizeof(short int); 2025 2026 if (!try_module_get(THIS_MODULE)) { 2027 printk(KERN_ERR "drbd: try_module_get() failed!\n"); 2028 return; 2029 } 2030 2031 if (!cap_raised(nsp->eff_cap, CAP_SYS_ADMIN)) { 2032 retcode = ERR_PERM; 2033 goto fail; 2034 } 2035 2036 mdev = ensure_mdev(nlp); 2037 if (!mdev) { 2038 retcode = ERR_MINOR_INVALID; 2039 goto fail; 2040 } 2041 2042 if (nlp->packet_type >= P_nl_after_last_packet) { 2043 retcode = ERR_PACKET_NR; 2044 goto fail; 2045 } 2046 2047 cm = cnd_table + nlp->packet_type; 2048 2049 /* This may happen if packet number is 0: */ 2050 if (cm->function == NULL) { 2051 retcode = ERR_PACKET_NR; 2052 goto fail; 2053 } 2054 2055 reply_size += cm->reply_body_size; 2056 2057 /* allocation not in the IO path, cqueue thread context */ 2058 cn_reply = kmalloc(reply_size, GFP_KERNEL); 2059 if (!cn_reply) { 2060 retcode = ERR_NOMEM; 2061 goto fail; 2062 } 2063 reply = (struct drbd_nl_cfg_reply *) cn_reply->data; 2064 2065 reply->packet_type = 2066 cm->reply_body_size ? nlp->packet_type : P_nl_after_last_packet; 2067 reply->minor = nlp->drbd_minor; 2068 reply->ret_code = NO_ERROR; /* Might by modified by cm->function. */ 2069 /* reply->tag_list; might be modified by cm->function. */ 2070 2071 rr = cm->function(mdev, nlp, reply); 2072 2073 cn_reply->id = req->id; 2074 cn_reply->seq = req->seq; 2075 cn_reply->ack = req->ack + 1; 2076 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + rr; 2077 cn_reply->flags = 0; 2078 2079 rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_KERNEL); 2080 if (rr && rr != -ESRCH) 2081 printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr); 2082 2083 kfree(cn_reply); 2084 module_put(THIS_MODULE); 2085 return; 2086 fail: 2087 drbd_nl_send_reply(req, retcode); 2088 module_put(THIS_MODULE); 2089} 2090 2091static atomic_t drbd_nl_seq = ATOMIC_INIT(2); /* two. */ 2092 2093static unsigned short * 2094__tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data, 2095 unsigned short len, int nul_terminated) 2096{ 2097 unsigned short l = tag_descriptions[tag_number(tag)].max_len; 2098 len = (len < l) ? len : l; 2099 put_unaligned(tag, tl++); 2100 put_unaligned(len, tl++); 2101 memcpy(tl, data, len); 2102 tl = (unsigned short*)((char*)tl + len); 2103 if (nul_terminated) 2104 *((char*)tl - 1) = 0; 2105 return tl; 2106} 2107 2108static unsigned short * 2109tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data, int len) 2110{ 2111 return __tl_add_blob(tl, tag, data, len, 0); 2112} 2113 2114static unsigned short * 2115tl_add_str(unsigned short *tl, enum drbd_tags tag, const char *str) 2116{ 2117 return __tl_add_blob(tl, tag, str, strlen(str)+1, 0); 2118} 2119 2120static unsigned short * 2121tl_add_int(unsigned short *tl, enum drbd_tags tag, const void *val) 2122{ 2123 put_unaligned(tag, tl++); 2124 switch(tag_type(tag)) { 2125 case TT_INTEGER: 2126 put_unaligned(sizeof(int), tl++); 2127 put_unaligned(*(int *)val, (int *)tl); 2128 tl = (unsigned short*)((char*)tl+sizeof(int)); 2129 break; 2130 case TT_INT64: 2131 put_unaligned(sizeof(u64), tl++); 2132 put_unaligned(*(u64 *)val, (u64 *)tl); 2133 tl = (unsigned short*)((char*)tl+sizeof(u64)); 2134 break; 2135 default: 2136 /* someone did something stupid. */ 2137 ; 2138 } 2139 return tl; 2140} 2141 2142void drbd_bcast_state(struct drbd_conf *mdev, union drbd_state state) 2143{ 2144 char buffer[sizeof(struct cn_msg)+ 2145 sizeof(struct drbd_nl_cfg_reply)+ 2146 sizeof(struct get_state_tag_len_struct)+ 2147 sizeof(short int)]; 2148 struct cn_msg *cn_reply = (struct cn_msg *) buffer; 2149 struct drbd_nl_cfg_reply *reply = 2150 (struct drbd_nl_cfg_reply *)cn_reply->data; 2151 unsigned short *tl = reply->tag_list; 2152 2153 /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */ 2154 2155 tl = get_state_to_tags(mdev, (struct get_state *)&state, tl); 2156 2157 put_unaligned(TT_END, tl++); /* Close the tag list */ 2158 2159 cn_reply->id.idx = CN_IDX_DRBD; 2160 cn_reply->id.val = CN_VAL_DRBD; 2161 2162 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq); 2163 cn_reply->ack = 0; /* not used here. */ 2164 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + 2165 (int)((char *)tl - (char *)reply->tag_list); 2166 cn_reply->flags = 0; 2167 2168 reply->packet_type = P_get_state; 2169 reply->minor = mdev_to_minor(mdev); 2170 reply->ret_code = NO_ERROR; 2171 2172 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO); 2173} 2174 2175void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name) 2176{ 2177 char buffer[sizeof(struct cn_msg)+ 2178 sizeof(struct drbd_nl_cfg_reply)+ 2179 sizeof(struct call_helper_tag_len_struct)+ 2180 sizeof(short int)]; 2181 struct cn_msg *cn_reply = (struct cn_msg *) buffer; 2182 struct drbd_nl_cfg_reply *reply = 2183 (struct drbd_nl_cfg_reply *)cn_reply->data; 2184 unsigned short *tl = reply->tag_list; 2185 2186 /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */ 2187 2188 tl = tl_add_str(tl, T_helper, helper_name); 2189 put_unaligned(TT_END, tl++); /* Close the tag list */ 2190 2191 cn_reply->id.idx = CN_IDX_DRBD; 2192 cn_reply->id.val = CN_VAL_DRBD; 2193 2194 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq); 2195 cn_reply->ack = 0; /* not used here. */ 2196 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + 2197 (int)((char *)tl - (char *)reply->tag_list); 2198 cn_reply->flags = 0; 2199 2200 reply->packet_type = P_call_helper; 2201 reply->minor = mdev_to_minor(mdev); 2202 reply->ret_code = NO_ERROR; 2203 2204 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO); 2205} 2206 2207void drbd_bcast_ee(struct drbd_conf *mdev, 2208 const char *reason, const int dgs, 2209 const char* seen_hash, const char* calc_hash, 2210 const struct drbd_epoch_entry* e) 2211{ 2212 struct cn_msg *cn_reply; 2213 struct drbd_nl_cfg_reply *reply; 2214 struct bio_vec *bvec; 2215 unsigned short *tl; 2216 int i; 2217 2218 if (!e) 2219 return; 2220 if (!reason || !reason[0]) 2221 return; 2222 2223 /* apparently we have to memcpy twice, first to prepare the data for the 2224 * struct cn_msg, then within cn_netlink_send from the cn_msg to the 2225 * netlink skb. */ 2226 /* receiver thread context, which is not in the writeout path (of this node), 2227 * but may be in the writeout path of the _other_ node. 2228 * GFP_NOIO to avoid potential "distributed deadlock". */ 2229 cn_reply = kmalloc( 2230 sizeof(struct cn_msg)+ 2231 sizeof(struct drbd_nl_cfg_reply)+ 2232 sizeof(struct dump_ee_tag_len_struct)+ 2233 sizeof(short int), 2234 GFP_NOIO); 2235 2236 if (!cn_reply) { 2237 dev_err(DEV, "could not kmalloc buffer for drbd_bcast_ee, sector %llu, size %u\n", 2238 (unsigned long long)e->sector, e->size); 2239 return; 2240 } 2241 2242 reply = (struct drbd_nl_cfg_reply*)cn_reply->data; 2243 tl = reply->tag_list; 2244 2245 tl = tl_add_str(tl, T_dump_ee_reason, reason); 2246 tl = tl_add_blob(tl, T_seen_digest, seen_hash, dgs); 2247 tl = tl_add_blob(tl, T_calc_digest, calc_hash, dgs); 2248 tl = tl_add_int(tl, T_ee_sector, &e->sector); 2249 tl = tl_add_int(tl, T_ee_block_id, &e->block_id); 2250 2251 put_unaligned(T_ee_data, tl++); 2252 put_unaligned(e->size, tl++); 2253 2254 __bio_for_each_segment(bvec, e->private_bio, i, 0) { 2255 void *d = kmap(bvec->bv_page); 2256 memcpy(tl, d + bvec->bv_offset, bvec->bv_len); 2257 kunmap(bvec->bv_page); 2258 tl=(unsigned short*)((char*)tl + bvec->bv_len); 2259 } 2260 put_unaligned(TT_END, tl++); /* Close the tag list */ 2261 2262 cn_reply->id.idx = CN_IDX_DRBD; 2263 cn_reply->id.val = CN_VAL_DRBD; 2264 2265 cn_reply->seq = atomic_add_return(1,&drbd_nl_seq); 2266 cn_reply->ack = 0; // not used here. 2267 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + 2268 (int)((char*)tl - (char*)reply->tag_list); 2269 cn_reply->flags = 0; 2270 2271 reply->packet_type = P_dump_ee; 2272 reply->minor = mdev_to_minor(mdev); 2273 reply->ret_code = NO_ERROR; 2274 2275 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO); 2276 kfree(cn_reply); 2277} 2278 2279void drbd_bcast_sync_progress(struct drbd_conf *mdev) 2280{ 2281 char buffer[sizeof(struct cn_msg)+ 2282 sizeof(struct drbd_nl_cfg_reply)+ 2283 sizeof(struct sync_progress_tag_len_struct)+ 2284 sizeof(short int)]; 2285 struct cn_msg *cn_reply = (struct cn_msg *) buffer; 2286 struct drbd_nl_cfg_reply *reply = 2287 (struct drbd_nl_cfg_reply *)cn_reply->data; 2288 unsigned short *tl = reply->tag_list; 2289 unsigned long rs_left; 2290 unsigned int res; 2291 2292 /* no local ref, no bitmap, no syncer progress, no broadcast. */ 2293 if (!get_ldev(mdev)) 2294 return; 2295 drbd_get_syncer_progress(mdev, &rs_left, &res); 2296 put_ldev(mdev); 2297 2298 tl = tl_add_int(tl, T_sync_progress, &res); 2299 put_unaligned(TT_END, tl++); /* Close the tag list */ 2300 2301 cn_reply->id.idx = CN_IDX_DRBD; 2302 cn_reply->id.val = CN_VAL_DRBD; 2303 2304 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq); 2305 cn_reply->ack = 0; /* not used here. */ 2306 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + 2307 (int)((char *)tl - (char *)reply->tag_list); 2308 cn_reply->flags = 0; 2309 2310 reply->packet_type = P_sync_progress; 2311 reply->minor = mdev_to_minor(mdev); 2312 reply->ret_code = NO_ERROR; 2313 2314 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO); 2315} 2316 2317int __init drbd_nl_init(void) 2318{ 2319 static struct cb_id cn_id_drbd; 2320 int err, try=10; 2321 2322 cn_id_drbd.val = CN_VAL_DRBD; 2323 do { 2324 cn_id_drbd.idx = cn_idx; 2325 err = cn_add_callback(&cn_id_drbd, "cn_drbd", &drbd_connector_callback); 2326 if (!err) 2327 break; 2328 cn_idx = (cn_idx + CN_IDX_STEP); 2329 } while (try--); 2330 2331 if (err) { 2332 printk(KERN_ERR "drbd: cn_drbd failed to register\n"); 2333 return err; 2334 } 2335 2336 return 0; 2337} 2338 2339void drbd_nl_cleanup(void) 2340{ 2341 static struct cb_id cn_id_drbd; 2342 2343 cn_id_drbd.idx = cn_idx; 2344 cn_id_drbd.val = CN_VAL_DRBD; 2345 2346 cn_del_callback(&cn_id_drbd); 2347} 2348 2349void drbd_nl_send_reply(struct cn_msg *req, int ret_code) 2350{ 2351 char buffer[sizeof(struct cn_msg)+sizeof(struct drbd_nl_cfg_reply)]; 2352 struct cn_msg *cn_reply = (struct cn_msg *) buffer; 2353 struct drbd_nl_cfg_reply *reply = 2354 (struct drbd_nl_cfg_reply *)cn_reply->data; 2355 int rr; 2356 2357 cn_reply->id = req->id; 2358 2359 cn_reply->seq = req->seq; 2360 cn_reply->ack = req->ack + 1; 2361 cn_reply->len = sizeof(struct drbd_nl_cfg_reply); 2362 cn_reply->flags = 0; 2363 2364 reply->minor = ((struct drbd_nl_cfg_req *)req->data)->drbd_minor; 2365 reply->ret_code = ret_code; 2366 2367 rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO); 2368 if (rr && rr != -ESRCH) 2369 printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr); 2370} 2371 2372