1/* 2 drbd_state.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#include <linux/drbd_limits.h> 29#include "drbd_int.h" 30#include "drbd_protocol.h" 31#include "drbd_req.h" 32 33struct after_state_chg_work { 34 struct drbd_work w; 35 struct drbd_device *device; 36 union drbd_state os; 37 union drbd_state ns; 38 enum chg_state_flags flags; 39 struct completion *done; 40}; 41 42enum sanitize_state_warnings { 43 NO_WARNING, 44 ABORTED_ONLINE_VERIFY, 45 ABORTED_RESYNC, 46 CONNECTION_LOST_NEGOTIATING, 47 IMPLICITLY_UPGRADED_DISK, 48 IMPLICITLY_UPGRADED_PDSK, 49}; 50 51static int w_after_state_ch(struct drbd_work *w, int unused); 52static void after_state_ch(struct drbd_device *device, union drbd_state os, 53 union drbd_state ns, enum chg_state_flags flags); 54static enum drbd_state_rv is_valid_state(struct drbd_device *, union drbd_state); 55static enum drbd_state_rv is_valid_soft_transition(union drbd_state, union drbd_state, struct drbd_connection *); 56static enum drbd_state_rv is_valid_transition(union drbd_state os, union drbd_state ns); 57static union drbd_state sanitize_state(struct drbd_device *device, union drbd_state os, 58 union drbd_state ns, enum sanitize_state_warnings *warn); 59 60static inline bool is_susp(union drbd_state s) 61{ 62 return s.susp || s.susp_nod || s.susp_fen; 63} 64 65bool conn_all_vols_unconf(struct drbd_connection *connection) 66{ 67 struct drbd_peer_device *peer_device; 68 bool rv = true; 69 int vnr; 70 71 rcu_read_lock(); 72 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 73 struct drbd_device *device = peer_device->device; 74 if (device->state.disk != D_DISKLESS || 75 device->state.conn != C_STANDALONE || 76 device->state.role != R_SECONDARY) { 77 rv = false; 78 break; 79 } 80 } 81 rcu_read_unlock(); 82 83 return rv; 84} 85 86/* Unfortunately the states where not correctly ordered, when 87 they where defined. therefore can not use max_t() here. */ 88static enum drbd_role max_role(enum drbd_role role1, enum drbd_role role2) 89{ 90 if (role1 == R_PRIMARY || role2 == R_PRIMARY) 91 return R_PRIMARY; 92 if (role1 == R_SECONDARY || role2 == R_SECONDARY) 93 return R_SECONDARY; 94 return R_UNKNOWN; 95} 96static enum drbd_role min_role(enum drbd_role role1, enum drbd_role role2) 97{ 98 if (role1 == R_UNKNOWN || role2 == R_UNKNOWN) 99 return R_UNKNOWN; 100 if (role1 == R_SECONDARY || role2 == R_SECONDARY) 101 return R_SECONDARY; 102 return R_PRIMARY; 103} 104 105enum drbd_role conn_highest_role(struct drbd_connection *connection) 106{ 107 enum drbd_role role = R_UNKNOWN; 108 struct drbd_peer_device *peer_device; 109 int vnr; 110 111 rcu_read_lock(); 112 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 113 struct drbd_device *device = peer_device->device; 114 role = max_role(role, device->state.role); 115 } 116 rcu_read_unlock(); 117 118 return role; 119} 120 121enum drbd_role conn_highest_peer(struct drbd_connection *connection) 122{ 123 enum drbd_role peer = R_UNKNOWN; 124 struct drbd_peer_device *peer_device; 125 int vnr; 126 127 rcu_read_lock(); 128 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 129 struct drbd_device *device = peer_device->device; 130 peer = max_role(peer, device->state.peer); 131 } 132 rcu_read_unlock(); 133 134 return peer; 135} 136 137enum drbd_disk_state conn_highest_disk(struct drbd_connection *connection) 138{ 139 enum drbd_disk_state disk_state = D_DISKLESS; 140 struct drbd_peer_device *peer_device; 141 int vnr; 142 143 rcu_read_lock(); 144 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 145 struct drbd_device *device = peer_device->device; 146 disk_state = max_t(enum drbd_disk_state, disk_state, device->state.disk); 147 } 148 rcu_read_unlock(); 149 150 return disk_state; 151} 152 153enum drbd_disk_state conn_lowest_disk(struct drbd_connection *connection) 154{ 155 enum drbd_disk_state disk_state = D_MASK; 156 struct drbd_peer_device *peer_device; 157 int vnr; 158 159 rcu_read_lock(); 160 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 161 struct drbd_device *device = peer_device->device; 162 disk_state = min_t(enum drbd_disk_state, disk_state, device->state.disk); 163 } 164 rcu_read_unlock(); 165 166 return disk_state; 167} 168 169enum drbd_disk_state conn_highest_pdsk(struct drbd_connection *connection) 170{ 171 enum drbd_disk_state disk_state = D_DISKLESS; 172 struct drbd_peer_device *peer_device; 173 int vnr; 174 175 rcu_read_lock(); 176 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 177 struct drbd_device *device = peer_device->device; 178 disk_state = max_t(enum drbd_disk_state, disk_state, device->state.pdsk); 179 } 180 rcu_read_unlock(); 181 182 return disk_state; 183} 184 185enum drbd_conns conn_lowest_conn(struct drbd_connection *connection) 186{ 187 enum drbd_conns conn = C_MASK; 188 struct drbd_peer_device *peer_device; 189 int vnr; 190 191 rcu_read_lock(); 192 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 193 struct drbd_device *device = peer_device->device; 194 conn = min_t(enum drbd_conns, conn, device->state.conn); 195 } 196 rcu_read_unlock(); 197 198 return conn; 199} 200 201static bool no_peer_wf_report_params(struct drbd_connection *connection) 202{ 203 struct drbd_peer_device *peer_device; 204 int vnr; 205 bool rv = true; 206 207 rcu_read_lock(); 208 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 209 if (peer_device->device->state.conn == C_WF_REPORT_PARAMS) { 210 rv = false; 211 break; 212 } 213 rcu_read_unlock(); 214 215 return rv; 216} 217 218static void wake_up_all_devices(struct drbd_connection *connection) 219{ 220 struct drbd_peer_device *peer_device; 221 int vnr; 222 223 rcu_read_lock(); 224 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 225 wake_up(&peer_device->device->state_wait); 226 rcu_read_unlock(); 227 228} 229 230 231/** 232 * cl_wide_st_chg() - true if the state change is a cluster wide one 233 * @device: DRBD device. 234 * @os: old (current) state. 235 * @ns: new (wanted) state. 236 */ 237static int cl_wide_st_chg(struct drbd_device *device, 238 union drbd_state os, union drbd_state ns) 239{ 240 return (os.conn >= C_CONNECTED && ns.conn >= C_CONNECTED && 241 ((os.role != R_PRIMARY && ns.role == R_PRIMARY) || 242 (os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) || 243 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S) || 244 (os.disk != D_FAILED && ns.disk == D_FAILED))) || 245 (os.conn >= C_CONNECTED && ns.conn == C_DISCONNECTING) || 246 (os.conn == C_CONNECTED && ns.conn == C_VERIFY_S) || 247 (os.conn == C_CONNECTED && ns.conn == C_WF_REPORT_PARAMS); 248} 249 250static union drbd_state 251apply_mask_val(union drbd_state os, union drbd_state mask, union drbd_state val) 252{ 253 union drbd_state ns; 254 ns.i = (os.i & ~mask.i) | val.i; 255 return ns; 256} 257 258enum drbd_state_rv 259drbd_change_state(struct drbd_device *device, enum chg_state_flags f, 260 union drbd_state mask, union drbd_state val) 261{ 262 unsigned long flags; 263 union drbd_state ns; 264 enum drbd_state_rv rv; 265 266 spin_lock_irqsave(&device->resource->req_lock, flags); 267 ns = apply_mask_val(drbd_read_state(device), mask, val); 268 rv = _drbd_set_state(device, ns, f, NULL); 269 spin_unlock_irqrestore(&device->resource->req_lock, flags); 270 271 return rv; 272} 273 274/** 275 * drbd_force_state() - Impose a change which happens outside our control on our state 276 * @device: DRBD device. 277 * @mask: mask of state bits to change. 278 * @val: value of new state bits. 279 */ 280void drbd_force_state(struct drbd_device *device, 281 union drbd_state mask, union drbd_state val) 282{ 283 drbd_change_state(device, CS_HARD, mask, val); 284} 285 286static enum drbd_state_rv 287_req_st_cond(struct drbd_device *device, union drbd_state mask, 288 union drbd_state val) 289{ 290 union drbd_state os, ns; 291 unsigned long flags; 292 enum drbd_state_rv rv; 293 294 if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &device->flags)) 295 return SS_CW_SUCCESS; 296 297 if (test_and_clear_bit(CL_ST_CHG_FAIL, &device->flags)) 298 return SS_CW_FAILED_BY_PEER; 299 300 spin_lock_irqsave(&device->resource->req_lock, flags); 301 os = drbd_read_state(device); 302 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL); 303 rv = is_valid_transition(os, ns); 304 if (rv >= SS_SUCCESS) 305 rv = SS_UNKNOWN_ERROR; /* cont waiting, otherwise fail. */ 306 307 if (!cl_wide_st_chg(device, os, ns)) 308 rv = SS_CW_NO_NEED; 309 if (rv == SS_UNKNOWN_ERROR) { 310 rv = is_valid_state(device, ns); 311 if (rv >= SS_SUCCESS) { 312 rv = is_valid_soft_transition(os, ns, first_peer_device(device)->connection); 313 if (rv >= SS_SUCCESS) 314 rv = SS_UNKNOWN_ERROR; /* cont waiting, otherwise fail. */ 315 } 316 } 317 spin_unlock_irqrestore(&device->resource->req_lock, flags); 318 319 return rv; 320} 321 322/** 323 * drbd_req_state() - Perform an eventually cluster wide state change 324 * @device: DRBD device. 325 * @mask: mask of state bits to change. 326 * @val: value of new state bits. 327 * @f: flags 328 * 329 * Should not be called directly, use drbd_request_state() or 330 * _drbd_request_state(). 331 */ 332static enum drbd_state_rv 333drbd_req_state(struct drbd_device *device, union drbd_state mask, 334 union drbd_state val, enum chg_state_flags f) 335{ 336 struct completion done; 337 unsigned long flags; 338 union drbd_state os, ns; 339 enum drbd_state_rv rv; 340 341 init_completion(&done); 342 343 if (f & CS_SERIALIZE) 344 mutex_lock(device->state_mutex); 345 346 spin_lock_irqsave(&device->resource->req_lock, flags); 347 os = drbd_read_state(device); 348 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL); 349 rv = is_valid_transition(os, ns); 350 if (rv < SS_SUCCESS) { 351 spin_unlock_irqrestore(&device->resource->req_lock, flags); 352 goto abort; 353 } 354 355 if (cl_wide_st_chg(device, os, ns)) { 356 rv = is_valid_state(device, ns); 357 if (rv == SS_SUCCESS) 358 rv = is_valid_soft_transition(os, ns, first_peer_device(device)->connection); 359 spin_unlock_irqrestore(&device->resource->req_lock, flags); 360 361 if (rv < SS_SUCCESS) { 362 if (f & CS_VERBOSE) 363 print_st_err(device, os, ns, rv); 364 goto abort; 365 } 366 367 if (drbd_send_state_req(first_peer_device(device), mask, val)) { 368 rv = SS_CW_FAILED_BY_PEER; 369 if (f & CS_VERBOSE) 370 print_st_err(device, os, ns, rv); 371 goto abort; 372 } 373 374 wait_event(device->state_wait, 375 (rv = _req_st_cond(device, mask, val))); 376 377 if (rv < SS_SUCCESS) { 378 if (f & CS_VERBOSE) 379 print_st_err(device, os, ns, rv); 380 goto abort; 381 } 382 spin_lock_irqsave(&device->resource->req_lock, flags); 383 ns = apply_mask_val(drbd_read_state(device), mask, val); 384 rv = _drbd_set_state(device, ns, f, &done); 385 } else { 386 rv = _drbd_set_state(device, ns, f, &done); 387 } 388 389 spin_unlock_irqrestore(&device->resource->req_lock, flags); 390 391 if (f & CS_WAIT_COMPLETE && rv == SS_SUCCESS) { 392 D_ASSERT(device, current != first_peer_device(device)->connection->worker.task); 393 wait_for_completion(&done); 394 } 395 396abort: 397 if (f & CS_SERIALIZE) 398 mutex_unlock(device->state_mutex); 399 400 return rv; 401} 402 403/** 404 * _drbd_request_state() - Request a state change (with flags) 405 * @device: DRBD device. 406 * @mask: mask of state bits to change. 407 * @val: value of new state bits. 408 * @f: flags 409 * 410 * Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE 411 * flag, or when logging of failed state change requests is not desired. 412 */ 413enum drbd_state_rv 414_drbd_request_state(struct drbd_device *device, union drbd_state mask, 415 union drbd_state val, enum chg_state_flags f) 416{ 417 enum drbd_state_rv rv; 418 419 wait_event(device->state_wait, 420 (rv = drbd_req_state(device, mask, val, f)) != SS_IN_TRANSIENT_STATE); 421 422 return rv; 423} 424 425enum drbd_state_rv 426_drbd_request_state_holding_state_mutex(struct drbd_device *device, union drbd_state mask, 427 union drbd_state val, enum chg_state_flags f) 428{ 429 enum drbd_state_rv rv; 430 431 BUG_ON(f & CS_SERIALIZE); 432 433 wait_event_cmd(device->state_wait, 434 (rv = drbd_req_state(device, mask, val, f)) != SS_IN_TRANSIENT_STATE, 435 mutex_unlock(device->state_mutex), 436 mutex_lock(device->state_mutex)); 437 438 return rv; 439} 440 441static void print_st(struct drbd_device *device, const char *name, union drbd_state ns) 442{ 443 drbd_err(device, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c%c%c }\n", 444 name, 445 drbd_conn_str(ns.conn), 446 drbd_role_str(ns.role), 447 drbd_role_str(ns.peer), 448 drbd_disk_str(ns.disk), 449 drbd_disk_str(ns.pdsk), 450 is_susp(ns) ? 's' : 'r', 451 ns.aftr_isp ? 'a' : '-', 452 ns.peer_isp ? 'p' : '-', 453 ns.user_isp ? 'u' : '-', 454 ns.susp_fen ? 'F' : '-', 455 ns.susp_nod ? 'N' : '-' 456 ); 457} 458 459void print_st_err(struct drbd_device *device, union drbd_state os, 460 union drbd_state ns, enum drbd_state_rv err) 461{ 462 if (err == SS_IN_TRANSIENT_STATE) 463 return; 464 drbd_err(device, "State change failed: %s\n", drbd_set_st_err_str(err)); 465 print_st(device, " state", os); 466 print_st(device, "wanted", ns); 467} 468 469static long print_state_change(char *pb, union drbd_state os, union drbd_state ns, 470 enum chg_state_flags flags) 471{ 472 char *pbp; 473 pbp = pb; 474 *pbp = 0; 475 476 if (ns.role != os.role && flags & CS_DC_ROLE) 477 pbp += sprintf(pbp, "role( %s -> %s ) ", 478 drbd_role_str(os.role), 479 drbd_role_str(ns.role)); 480 if (ns.peer != os.peer && flags & CS_DC_PEER) 481 pbp += sprintf(pbp, "peer( %s -> %s ) ", 482 drbd_role_str(os.peer), 483 drbd_role_str(ns.peer)); 484 if (ns.conn != os.conn && flags & CS_DC_CONN) 485 pbp += sprintf(pbp, "conn( %s -> %s ) ", 486 drbd_conn_str(os.conn), 487 drbd_conn_str(ns.conn)); 488 if (ns.disk != os.disk && flags & CS_DC_DISK) 489 pbp += sprintf(pbp, "disk( %s -> %s ) ", 490 drbd_disk_str(os.disk), 491 drbd_disk_str(ns.disk)); 492 if (ns.pdsk != os.pdsk && flags & CS_DC_PDSK) 493 pbp += sprintf(pbp, "pdsk( %s -> %s ) ", 494 drbd_disk_str(os.pdsk), 495 drbd_disk_str(ns.pdsk)); 496 497 return pbp - pb; 498} 499 500static void drbd_pr_state_change(struct drbd_device *device, union drbd_state os, union drbd_state ns, 501 enum chg_state_flags flags) 502{ 503 char pb[300]; 504 char *pbp = pb; 505 506 pbp += print_state_change(pbp, os, ns, flags ^ CS_DC_MASK); 507 508 if (ns.aftr_isp != os.aftr_isp) 509 pbp += sprintf(pbp, "aftr_isp( %d -> %d ) ", 510 os.aftr_isp, 511 ns.aftr_isp); 512 if (ns.peer_isp != os.peer_isp) 513 pbp += sprintf(pbp, "peer_isp( %d -> %d ) ", 514 os.peer_isp, 515 ns.peer_isp); 516 if (ns.user_isp != os.user_isp) 517 pbp += sprintf(pbp, "user_isp( %d -> %d ) ", 518 os.user_isp, 519 ns.user_isp); 520 521 if (pbp != pb) 522 drbd_info(device, "%s\n", pb); 523} 524 525static void conn_pr_state_change(struct drbd_connection *connection, union drbd_state os, union drbd_state ns, 526 enum chg_state_flags flags) 527{ 528 char pb[300]; 529 char *pbp = pb; 530 531 pbp += print_state_change(pbp, os, ns, flags); 532 533 if (is_susp(ns) != is_susp(os) && flags & CS_DC_SUSP) 534 pbp += sprintf(pbp, "susp( %d -> %d ) ", 535 is_susp(os), 536 is_susp(ns)); 537 538 if (pbp != pb) 539 drbd_info(connection, "%s\n", pb); 540} 541 542 543/** 544 * is_valid_state() - Returns an SS_ error code if ns is not valid 545 * @device: DRBD device. 546 * @ns: State to consider. 547 */ 548static enum drbd_state_rv 549is_valid_state(struct drbd_device *device, union drbd_state ns) 550{ 551 /* See drbd_state_sw_errors in drbd_strings.c */ 552 553 enum drbd_fencing_p fp; 554 enum drbd_state_rv rv = SS_SUCCESS; 555 struct net_conf *nc; 556 557 rcu_read_lock(); 558 fp = FP_DONT_CARE; 559 if (get_ldev(device)) { 560 fp = rcu_dereference(device->ldev->disk_conf)->fencing; 561 put_ldev(device); 562 } 563 564 nc = rcu_dereference(first_peer_device(device)->connection->net_conf); 565 if (nc) { 566 if (!nc->two_primaries && ns.role == R_PRIMARY) { 567 if (ns.peer == R_PRIMARY) 568 rv = SS_TWO_PRIMARIES; 569 else if (conn_highest_peer(first_peer_device(device)->connection) == R_PRIMARY) 570 rv = SS_O_VOL_PEER_PRI; 571 } 572 } 573 574 if (rv <= 0) 575 /* already found a reason to abort */; 576 else if (ns.role == R_SECONDARY && device->open_cnt) 577 rv = SS_DEVICE_IN_USE; 578 579 else if (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.disk < D_UP_TO_DATE) 580 rv = SS_NO_UP_TO_DATE_DISK; 581 582 else if (fp >= FP_RESOURCE && 583 ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk >= D_UNKNOWN) 584 rv = SS_PRIMARY_NOP; 585 586 else if (ns.role == R_PRIMARY && ns.disk <= D_INCONSISTENT && ns.pdsk <= D_INCONSISTENT) 587 rv = SS_NO_UP_TO_DATE_DISK; 588 589 else if (ns.conn > C_CONNECTED && ns.disk < D_INCONSISTENT) 590 rv = SS_NO_LOCAL_DISK; 591 592 else if (ns.conn > C_CONNECTED && ns.pdsk < D_INCONSISTENT) 593 rv = SS_NO_REMOTE_DISK; 594 595 else if (ns.conn > C_CONNECTED && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE) 596 rv = SS_NO_UP_TO_DATE_DISK; 597 598 else if ((ns.conn == C_CONNECTED || 599 ns.conn == C_WF_BITMAP_S || 600 ns.conn == C_SYNC_SOURCE || 601 ns.conn == C_PAUSED_SYNC_S) && 602 ns.disk == D_OUTDATED) 603 rv = SS_CONNECTED_OUTDATES; 604 605 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && 606 (nc->verify_alg[0] == 0)) 607 rv = SS_NO_VERIFY_ALG; 608 609 else if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && 610 first_peer_device(device)->connection->agreed_pro_version < 88) 611 rv = SS_NOT_SUPPORTED; 612 613 else if (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE) 614 rv = SS_NO_UP_TO_DATE_DISK; 615 616 else if ((ns.conn == C_STARTING_SYNC_S || ns.conn == C_STARTING_SYNC_T) && 617 ns.pdsk == D_UNKNOWN) 618 rv = SS_NEED_CONNECTION; 619 620 else if (ns.conn >= C_CONNECTED && ns.pdsk == D_UNKNOWN) 621 rv = SS_CONNECTED_OUTDATES; 622 623 rcu_read_unlock(); 624 625 return rv; 626} 627 628/** 629 * is_valid_soft_transition() - Returns an SS_ error code if the state transition is not possible 630 * This function limits state transitions that may be declined by DRBD. I.e. 631 * user requests (aka soft transitions). 632 * @device: DRBD device. 633 * @ns: new state. 634 * @os: old state. 635 */ 636static enum drbd_state_rv 637is_valid_soft_transition(union drbd_state os, union drbd_state ns, struct drbd_connection *connection) 638{ 639 enum drbd_state_rv rv = SS_SUCCESS; 640 641 if ((ns.conn == C_STARTING_SYNC_T || ns.conn == C_STARTING_SYNC_S) && 642 os.conn > C_CONNECTED) 643 rv = SS_RESYNC_RUNNING; 644 645 if (ns.conn == C_DISCONNECTING && os.conn == C_STANDALONE) 646 rv = SS_ALREADY_STANDALONE; 647 648 if (ns.disk > D_ATTACHING && os.disk == D_DISKLESS) 649 rv = SS_IS_DISKLESS; 650 651 if (ns.conn == C_WF_CONNECTION && os.conn < C_UNCONNECTED) 652 rv = SS_NO_NET_CONFIG; 653 654 if (ns.disk == D_OUTDATED && os.disk < D_OUTDATED && os.disk != D_ATTACHING) 655 rv = SS_LOWER_THAN_OUTDATED; 656 657 if (ns.conn == C_DISCONNECTING && os.conn == C_UNCONNECTED) 658 rv = SS_IN_TRANSIENT_STATE; 659 660 /* While establishing a connection only allow cstate to change. 661 Delay/refuse role changes, detach attach etc... (they do not touch cstate) */ 662 if (test_bit(STATE_SENT, &connection->flags) && 663 !((ns.conn == C_WF_REPORT_PARAMS && os.conn == C_WF_CONNECTION) || 664 (ns.conn >= C_CONNECTED && os.conn == C_WF_REPORT_PARAMS))) 665 rv = SS_IN_TRANSIENT_STATE; 666 667 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && os.conn < C_CONNECTED) 668 rv = SS_NEED_CONNECTION; 669 670 if ((ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T) && 671 ns.conn != os.conn && os.conn > C_CONNECTED) 672 rv = SS_RESYNC_RUNNING; 673 674 if ((ns.conn == C_STARTING_SYNC_S || ns.conn == C_STARTING_SYNC_T) && 675 os.conn < C_CONNECTED) 676 rv = SS_NEED_CONNECTION; 677 678 if ((ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE) 679 && os.conn < C_WF_REPORT_PARAMS) 680 rv = SS_NEED_CONNECTION; /* No NetworkFailure -> SyncTarget etc... */ 681 682 if (ns.conn == C_DISCONNECTING && ns.pdsk == D_OUTDATED && 683 os.conn < C_CONNECTED && os.pdsk > D_OUTDATED) 684 rv = SS_OUTDATE_WO_CONN; 685 686 return rv; 687} 688 689static enum drbd_state_rv 690is_valid_conn_transition(enum drbd_conns oc, enum drbd_conns nc) 691{ 692 /* no change -> nothing to do, at least for the connection part */ 693 if (oc == nc) 694 return SS_NOTHING_TO_DO; 695 696 /* disconnect of an unconfigured connection does not make sense */ 697 if (oc == C_STANDALONE && nc == C_DISCONNECTING) 698 return SS_ALREADY_STANDALONE; 699 700 /* from C_STANDALONE, we start with C_UNCONNECTED */ 701 if (oc == C_STANDALONE && nc != C_UNCONNECTED) 702 return SS_NEED_CONNECTION; 703 704 /* When establishing a connection we need to go through WF_REPORT_PARAMS! 705 Necessary to do the right thing upon invalidate-remote on a disconnected resource */ 706 if (oc < C_WF_REPORT_PARAMS && nc >= C_CONNECTED) 707 return SS_NEED_CONNECTION; 708 709 /* After a network error only C_UNCONNECTED or C_DISCONNECTING may follow. */ 710 if (oc >= C_TIMEOUT && oc <= C_TEAR_DOWN && nc != C_UNCONNECTED && nc != C_DISCONNECTING) 711 return SS_IN_TRANSIENT_STATE; 712 713 /* After C_DISCONNECTING only C_STANDALONE may follow */ 714 if (oc == C_DISCONNECTING && nc != C_STANDALONE) 715 return SS_IN_TRANSIENT_STATE; 716 717 return SS_SUCCESS; 718} 719 720 721/** 722 * is_valid_transition() - Returns an SS_ error code if the state transition is not possible 723 * This limits hard state transitions. Hard state transitions are facts there are 724 * imposed on DRBD by the environment. E.g. disk broke or network broke down. 725 * But those hard state transitions are still not allowed to do everything. 726 * @ns: new state. 727 * @os: old state. 728 */ 729static enum drbd_state_rv 730is_valid_transition(union drbd_state os, union drbd_state ns) 731{ 732 enum drbd_state_rv rv; 733 734 rv = is_valid_conn_transition(os.conn, ns.conn); 735 736 /* we cannot fail (again) if we already detached */ 737 if (ns.disk == D_FAILED && os.disk == D_DISKLESS) 738 rv = SS_IS_DISKLESS; 739 740 return rv; 741} 742 743static void print_sanitize_warnings(struct drbd_device *device, enum sanitize_state_warnings warn) 744{ 745 static const char *msg_table[] = { 746 [NO_WARNING] = "", 747 [ABORTED_ONLINE_VERIFY] = "Online-verify aborted.", 748 [ABORTED_RESYNC] = "Resync aborted.", 749 [CONNECTION_LOST_NEGOTIATING] = "Connection lost while negotiating, no data!", 750 [IMPLICITLY_UPGRADED_DISK] = "Implicitly upgraded disk", 751 [IMPLICITLY_UPGRADED_PDSK] = "Implicitly upgraded pdsk", 752 }; 753 754 if (warn != NO_WARNING) 755 drbd_warn(device, "%s\n", msg_table[warn]); 756} 757 758/** 759 * sanitize_state() - Resolves implicitly necessary additional changes to a state transition 760 * @device: DRBD device. 761 * @os: old state. 762 * @ns: new state. 763 * @warn_sync_abort: 764 * 765 * When we loose connection, we have to set the state of the peers disk (pdsk) 766 * to D_UNKNOWN. This rule and many more along those lines are in this function. 767 */ 768static union drbd_state sanitize_state(struct drbd_device *device, union drbd_state os, 769 union drbd_state ns, enum sanitize_state_warnings *warn) 770{ 771 enum drbd_fencing_p fp; 772 enum drbd_disk_state disk_min, disk_max, pdsk_min, pdsk_max; 773 774 if (warn) 775 *warn = NO_WARNING; 776 777 fp = FP_DONT_CARE; 778 if (get_ldev(device)) { 779 rcu_read_lock(); 780 fp = rcu_dereference(device->ldev->disk_conf)->fencing; 781 rcu_read_unlock(); 782 put_ldev(device); 783 } 784 785 /* Implications from connection to peer and peer_isp */ 786 if (ns.conn < C_CONNECTED) { 787 ns.peer_isp = 0; 788 ns.peer = R_UNKNOWN; 789 if (ns.pdsk > D_UNKNOWN || ns.pdsk < D_INCONSISTENT) 790 ns.pdsk = D_UNKNOWN; 791 } 792 793 /* Clear the aftr_isp when becoming unconfigured */ 794 if (ns.conn == C_STANDALONE && ns.disk == D_DISKLESS && ns.role == R_SECONDARY) 795 ns.aftr_isp = 0; 796 797 /* An implication of the disk states onto the connection state */ 798 /* Abort resync if a disk fails/detaches */ 799 if (ns.conn > C_CONNECTED && (ns.disk <= D_FAILED || ns.pdsk <= D_FAILED)) { 800 if (warn) 801 *warn = ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T ? 802 ABORTED_ONLINE_VERIFY : ABORTED_RESYNC; 803 ns.conn = C_CONNECTED; 804 } 805 806 /* Connection breaks down before we finished "Negotiating" */ 807 if (ns.conn < C_CONNECTED && ns.disk == D_NEGOTIATING && 808 get_ldev_if_state(device, D_NEGOTIATING)) { 809 if (device->ed_uuid == device->ldev->md.uuid[UI_CURRENT]) { 810 ns.disk = device->new_state_tmp.disk; 811 ns.pdsk = device->new_state_tmp.pdsk; 812 } else { 813 if (warn) 814 *warn = CONNECTION_LOST_NEGOTIATING; 815 ns.disk = D_DISKLESS; 816 ns.pdsk = D_UNKNOWN; 817 } 818 put_ldev(device); 819 } 820 821 /* D_CONSISTENT and D_OUTDATED vanish when we get connected */ 822 if (ns.conn >= C_CONNECTED && ns.conn < C_AHEAD) { 823 if (ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED) 824 ns.disk = D_UP_TO_DATE; 825 if (ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED) 826 ns.pdsk = D_UP_TO_DATE; 827 } 828 829 /* Implications of the connection stat on the disk states */ 830 disk_min = D_DISKLESS; 831 disk_max = D_UP_TO_DATE; 832 pdsk_min = D_INCONSISTENT; 833 pdsk_max = D_UNKNOWN; 834 switch ((enum drbd_conns)ns.conn) { 835 case C_WF_BITMAP_T: 836 case C_PAUSED_SYNC_T: 837 case C_STARTING_SYNC_T: 838 case C_WF_SYNC_UUID: 839 case C_BEHIND: 840 disk_min = D_INCONSISTENT; 841 disk_max = D_OUTDATED; 842 pdsk_min = D_UP_TO_DATE; 843 pdsk_max = D_UP_TO_DATE; 844 break; 845 case C_VERIFY_S: 846 case C_VERIFY_T: 847 disk_min = D_UP_TO_DATE; 848 disk_max = D_UP_TO_DATE; 849 pdsk_min = D_UP_TO_DATE; 850 pdsk_max = D_UP_TO_DATE; 851 break; 852 case C_CONNECTED: 853 disk_min = D_DISKLESS; 854 disk_max = D_UP_TO_DATE; 855 pdsk_min = D_DISKLESS; 856 pdsk_max = D_UP_TO_DATE; 857 break; 858 case C_WF_BITMAP_S: 859 case C_PAUSED_SYNC_S: 860 case C_STARTING_SYNC_S: 861 case C_AHEAD: 862 disk_min = D_UP_TO_DATE; 863 disk_max = D_UP_TO_DATE; 864 pdsk_min = D_INCONSISTENT; 865 pdsk_max = D_CONSISTENT; /* D_OUTDATED would be nice. But explicit outdate necessary*/ 866 break; 867 case C_SYNC_TARGET: 868 disk_min = D_INCONSISTENT; 869 disk_max = D_INCONSISTENT; 870 pdsk_min = D_UP_TO_DATE; 871 pdsk_max = D_UP_TO_DATE; 872 break; 873 case C_SYNC_SOURCE: 874 disk_min = D_UP_TO_DATE; 875 disk_max = D_UP_TO_DATE; 876 pdsk_min = D_INCONSISTENT; 877 pdsk_max = D_INCONSISTENT; 878 break; 879 case C_STANDALONE: 880 case C_DISCONNECTING: 881 case C_UNCONNECTED: 882 case C_TIMEOUT: 883 case C_BROKEN_PIPE: 884 case C_NETWORK_FAILURE: 885 case C_PROTOCOL_ERROR: 886 case C_TEAR_DOWN: 887 case C_WF_CONNECTION: 888 case C_WF_REPORT_PARAMS: 889 case C_MASK: 890 break; 891 } 892 if (ns.disk > disk_max) 893 ns.disk = disk_max; 894 895 if (ns.disk < disk_min) { 896 if (warn) 897 *warn = IMPLICITLY_UPGRADED_DISK; 898 ns.disk = disk_min; 899 } 900 if (ns.pdsk > pdsk_max) 901 ns.pdsk = pdsk_max; 902 903 if (ns.pdsk < pdsk_min) { 904 if (warn) 905 *warn = IMPLICITLY_UPGRADED_PDSK; 906 ns.pdsk = pdsk_min; 907 } 908 909 if (fp == FP_STONITH && 910 (ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk > D_OUTDATED) && 911 !(os.role == R_PRIMARY && os.conn < C_CONNECTED && os.pdsk > D_OUTDATED)) 912 ns.susp_fen = 1; /* Suspend IO while fence-peer handler runs (peer lost) */ 913 914 if (device->resource->res_opts.on_no_data == OND_SUSPEND_IO && 915 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE) && 916 !(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE)) 917 ns.susp_nod = 1; /* Suspend IO while no data available (no accessible data available) */ 918 919 if (ns.aftr_isp || ns.peer_isp || ns.user_isp) { 920 if (ns.conn == C_SYNC_SOURCE) 921 ns.conn = C_PAUSED_SYNC_S; 922 if (ns.conn == C_SYNC_TARGET) 923 ns.conn = C_PAUSED_SYNC_T; 924 } else { 925 if (ns.conn == C_PAUSED_SYNC_S) 926 ns.conn = C_SYNC_SOURCE; 927 if (ns.conn == C_PAUSED_SYNC_T) 928 ns.conn = C_SYNC_TARGET; 929 } 930 931 return ns; 932} 933 934void drbd_resume_al(struct drbd_device *device) 935{ 936 if (test_and_clear_bit(AL_SUSPENDED, &device->flags)) 937 drbd_info(device, "Resumed AL updates\n"); 938} 939 940/* helper for __drbd_set_state */ 941static void set_ov_position(struct drbd_device *device, enum drbd_conns cs) 942{ 943 if (first_peer_device(device)->connection->agreed_pro_version < 90) 944 device->ov_start_sector = 0; 945 device->rs_total = drbd_bm_bits(device); 946 device->ov_position = 0; 947 if (cs == C_VERIFY_T) { 948 /* starting online verify from an arbitrary position 949 * does not fit well into the existing protocol. 950 * on C_VERIFY_T, we initialize ov_left and friends 951 * implicitly in receive_DataRequest once the 952 * first P_OV_REQUEST is received */ 953 device->ov_start_sector = ~(sector_t)0; 954 } else { 955 unsigned long bit = BM_SECT_TO_BIT(device->ov_start_sector); 956 if (bit >= device->rs_total) { 957 device->ov_start_sector = 958 BM_BIT_TO_SECT(device->rs_total - 1); 959 device->rs_total = 1; 960 } else 961 device->rs_total -= bit; 962 device->ov_position = device->ov_start_sector; 963 } 964 device->ov_left = device->rs_total; 965} 966 967/** 968 * __drbd_set_state() - Set a new DRBD state 969 * @device: DRBD device. 970 * @ns: new state. 971 * @flags: Flags 972 * @done: Optional completion, that will get completed after the after_state_ch() finished 973 * 974 * Caller needs to hold req_lock, and global_state_lock. Do not call directly. 975 */ 976enum drbd_state_rv 977__drbd_set_state(struct drbd_device *device, union drbd_state ns, 978 enum chg_state_flags flags, struct completion *done) 979{ 980 struct drbd_peer_device *peer_device = first_peer_device(device); 981 struct drbd_connection *connection = peer_device ? peer_device->connection : NULL; 982 union drbd_state os; 983 enum drbd_state_rv rv = SS_SUCCESS; 984 enum sanitize_state_warnings ssw; 985 struct after_state_chg_work *ascw; 986 987 os = drbd_read_state(device); 988 989 ns = sanitize_state(device, os, ns, &ssw); 990 if (ns.i == os.i) 991 return SS_NOTHING_TO_DO; 992 993 rv = is_valid_transition(os, ns); 994 if (rv < SS_SUCCESS) 995 return rv; 996 997 if (!(flags & CS_HARD)) { 998 /* pre-state-change checks ; only look at ns */ 999 /* See drbd_state_sw_errors in drbd_strings.c */ 1000 1001 rv = is_valid_state(device, ns); 1002 if (rv < SS_SUCCESS) { 1003 /* If the old state was illegal as well, then let 1004 this happen...*/ 1005 1006 if (is_valid_state(device, os) == rv) 1007 rv = is_valid_soft_transition(os, ns, connection); 1008 } else 1009 rv = is_valid_soft_transition(os, ns, connection); 1010 } 1011 1012 if (rv < SS_SUCCESS) { 1013 if (flags & CS_VERBOSE) 1014 print_st_err(device, os, ns, rv); 1015 return rv; 1016 } 1017 1018 print_sanitize_warnings(device, ssw); 1019 1020 drbd_pr_state_change(device, os, ns, flags); 1021 1022 /* Display changes to the susp* flags that where caused by the call to 1023 sanitize_state(). Only display it here if we where not called from 1024 _conn_request_state() */ 1025 if (!(flags & CS_DC_SUSP)) 1026 conn_pr_state_change(connection, os, ns, 1027 (flags & ~CS_DC_MASK) | CS_DC_SUSP); 1028 1029 /* if we are going -> D_FAILED or D_DISKLESS, grab one extra reference 1030 * on the ldev here, to be sure the transition -> D_DISKLESS resp. 1031 * drbd_ldev_destroy() won't happen before our corresponding 1032 * after_state_ch works run, where we put_ldev again. */ 1033 if ((os.disk != D_FAILED && ns.disk == D_FAILED) || 1034 (os.disk != D_DISKLESS && ns.disk == D_DISKLESS)) 1035 atomic_inc(&device->local_cnt); 1036 1037 if (!is_sync_state(os.conn) && is_sync_state(ns.conn)) 1038 clear_bit(RS_DONE, &device->flags); 1039 1040 /* changes to local_cnt and device flags should be visible before 1041 * changes to state, which again should be visible before anything else 1042 * depending on that change happens. */ 1043 smp_wmb(); 1044 device->state.i = ns.i; 1045 device->resource->susp = ns.susp; 1046 device->resource->susp_nod = ns.susp_nod; 1047 device->resource->susp_fen = ns.susp_fen; 1048 smp_wmb(); 1049 1050 /* put replicated vs not-replicated requests in seperate epochs */ 1051 if (drbd_should_do_remote((union drbd_dev_state)os.i) != 1052 drbd_should_do_remote((union drbd_dev_state)ns.i)) 1053 start_new_tl_epoch(connection); 1054 1055 if (os.disk == D_ATTACHING && ns.disk >= D_NEGOTIATING) 1056 drbd_print_uuids(device, "attached to UUIDs"); 1057 1058 /* Wake up role changes, that were delayed because of connection establishing */ 1059 if (os.conn == C_WF_REPORT_PARAMS && ns.conn != C_WF_REPORT_PARAMS && 1060 no_peer_wf_report_params(connection)) { 1061 clear_bit(STATE_SENT, &connection->flags); 1062 wake_up_all_devices(connection); 1063 } 1064 1065 wake_up(&device->misc_wait); 1066 wake_up(&device->state_wait); 1067 wake_up(&connection->ping_wait); 1068 1069 /* Aborted verify run, or we reached the stop sector. 1070 * Log the last position, unless end-of-device. */ 1071 if ((os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) && 1072 ns.conn <= C_CONNECTED) { 1073 device->ov_start_sector = 1074 BM_BIT_TO_SECT(drbd_bm_bits(device) - device->ov_left); 1075 if (device->ov_left) 1076 drbd_info(device, "Online Verify reached sector %llu\n", 1077 (unsigned long long)device->ov_start_sector); 1078 } 1079 1080 if ((os.conn == C_PAUSED_SYNC_T || os.conn == C_PAUSED_SYNC_S) && 1081 (ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE)) { 1082 drbd_info(device, "Syncer continues.\n"); 1083 device->rs_paused += (long)jiffies 1084 -(long)device->rs_mark_time[device->rs_last_mark]; 1085 if (ns.conn == C_SYNC_TARGET) 1086 mod_timer(&device->resync_timer, jiffies); 1087 } 1088 1089 if ((os.conn == C_SYNC_TARGET || os.conn == C_SYNC_SOURCE) && 1090 (ns.conn == C_PAUSED_SYNC_T || ns.conn == C_PAUSED_SYNC_S)) { 1091 drbd_info(device, "Resync suspended\n"); 1092 device->rs_mark_time[device->rs_last_mark] = jiffies; 1093 } 1094 1095 if (os.conn == C_CONNECTED && 1096 (ns.conn == C_VERIFY_S || ns.conn == C_VERIFY_T)) { 1097 unsigned long now = jiffies; 1098 int i; 1099 1100 set_ov_position(device, ns.conn); 1101 device->rs_start = now; 1102 device->rs_last_sect_ev = 0; 1103 device->ov_last_oos_size = 0; 1104 device->ov_last_oos_start = 0; 1105 1106 for (i = 0; i < DRBD_SYNC_MARKS; i++) { 1107 device->rs_mark_left[i] = device->ov_left; 1108 device->rs_mark_time[i] = now; 1109 } 1110 1111 drbd_rs_controller_reset(device); 1112 1113 if (ns.conn == C_VERIFY_S) { 1114 drbd_info(device, "Starting Online Verify from sector %llu\n", 1115 (unsigned long long)device->ov_position); 1116 mod_timer(&device->resync_timer, jiffies); 1117 } 1118 } 1119 1120 if (get_ldev(device)) { 1121 u32 mdf = device->ldev->md.flags & ~(MDF_CONSISTENT|MDF_PRIMARY_IND| 1122 MDF_CONNECTED_IND|MDF_WAS_UP_TO_DATE| 1123 MDF_PEER_OUT_DATED|MDF_CRASHED_PRIMARY); 1124 1125 mdf &= ~MDF_AL_CLEAN; 1126 if (test_bit(CRASHED_PRIMARY, &device->flags)) 1127 mdf |= MDF_CRASHED_PRIMARY; 1128 if (device->state.role == R_PRIMARY || 1129 (device->state.pdsk < D_INCONSISTENT && device->state.peer == R_PRIMARY)) 1130 mdf |= MDF_PRIMARY_IND; 1131 if (device->state.conn > C_WF_REPORT_PARAMS) 1132 mdf |= MDF_CONNECTED_IND; 1133 if (device->state.disk > D_INCONSISTENT) 1134 mdf |= MDF_CONSISTENT; 1135 if (device->state.disk > D_OUTDATED) 1136 mdf |= MDF_WAS_UP_TO_DATE; 1137 if (device->state.pdsk <= D_OUTDATED && device->state.pdsk >= D_INCONSISTENT) 1138 mdf |= MDF_PEER_OUT_DATED; 1139 if (mdf != device->ldev->md.flags) { 1140 device->ldev->md.flags = mdf; 1141 drbd_md_mark_dirty(device); 1142 } 1143 if (os.disk < D_CONSISTENT && ns.disk >= D_CONSISTENT) 1144 drbd_set_ed_uuid(device, device->ldev->md.uuid[UI_CURRENT]); 1145 put_ldev(device); 1146 } 1147 1148 /* Peer was forced D_UP_TO_DATE & R_PRIMARY, consider to resync */ 1149 if (os.disk == D_INCONSISTENT && os.pdsk == D_INCONSISTENT && 1150 os.peer == R_SECONDARY && ns.peer == R_PRIMARY) 1151 set_bit(CONSIDER_RESYNC, &device->flags); 1152 1153 /* Receiver should clean up itself */ 1154 if (os.conn != C_DISCONNECTING && ns.conn == C_DISCONNECTING) 1155 drbd_thread_stop_nowait(&connection->receiver); 1156 1157 /* Now the receiver finished cleaning up itself, it should die */ 1158 if (os.conn != C_STANDALONE && ns.conn == C_STANDALONE) 1159 drbd_thread_stop_nowait(&connection->receiver); 1160 1161 /* Upon network failure, we need to restart the receiver. */ 1162 if (os.conn > C_WF_CONNECTION && 1163 ns.conn <= C_TEAR_DOWN && ns.conn >= C_TIMEOUT) 1164 drbd_thread_restart_nowait(&connection->receiver); 1165 1166 /* Resume AL writing if we get a connection */ 1167 if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED) { 1168 drbd_resume_al(device); 1169 connection->connect_cnt++; 1170 } 1171 1172 /* remember last attach time so request_timer_fn() won't 1173 * kill newly established sessions while we are still trying to thaw 1174 * previously frozen IO */ 1175 if ((os.disk == D_ATTACHING || os.disk == D_NEGOTIATING) && 1176 ns.disk > D_NEGOTIATING) 1177 device->last_reattach_jif = jiffies; 1178 1179 ascw = kmalloc(sizeof(*ascw), GFP_ATOMIC); 1180 if (ascw) { 1181 ascw->os = os; 1182 ascw->ns = ns; 1183 ascw->flags = flags; 1184 ascw->w.cb = w_after_state_ch; 1185 ascw->device = device; 1186 ascw->done = done; 1187 drbd_queue_work(&connection->sender_work, 1188 &ascw->w); 1189 } else { 1190 drbd_err(device, "Could not kmalloc an ascw\n"); 1191 } 1192 1193 return rv; 1194} 1195 1196static int w_after_state_ch(struct drbd_work *w, int unused) 1197{ 1198 struct after_state_chg_work *ascw = 1199 container_of(w, struct after_state_chg_work, w); 1200 struct drbd_device *device = ascw->device; 1201 1202 after_state_ch(device, ascw->os, ascw->ns, ascw->flags); 1203 if (ascw->flags & CS_WAIT_COMPLETE) 1204 complete(ascw->done); 1205 kfree(ascw); 1206 1207 return 0; 1208} 1209 1210static void abw_start_sync(struct drbd_device *device, int rv) 1211{ 1212 if (rv) { 1213 drbd_err(device, "Writing the bitmap failed not starting resync.\n"); 1214 _drbd_request_state(device, NS(conn, C_CONNECTED), CS_VERBOSE); 1215 return; 1216 } 1217 1218 switch (device->state.conn) { 1219 case C_STARTING_SYNC_T: 1220 _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 1221 break; 1222 case C_STARTING_SYNC_S: 1223 drbd_start_resync(device, C_SYNC_SOURCE); 1224 break; 1225 } 1226} 1227 1228int drbd_bitmap_io_from_worker(struct drbd_device *device, 1229 int (*io_fn)(struct drbd_device *), 1230 char *why, enum bm_flag flags) 1231{ 1232 int rv; 1233 1234 D_ASSERT(device, current == first_peer_device(device)->connection->worker.task); 1235 1236 /* open coded non-blocking drbd_suspend_io(device); */ 1237 set_bit(SUSPEND_IO, &device->flags); 1238 1239 drbd_bm_lock(device, why, flags); 1240 rv = io_fn(device); 1241 drbd_bm_unlock(device); 1242 1243 drbd_resume_io(device); 1244 1245 return rv; 1246} 1247 1248/** 1249 * after_state_ch() - Perform after state change actions that may sleep 1250 * @device: DRBD device. 1251 * @os: old state. 1252 * @ns: new state. 1253 * @flags: Flags 1254 */ 1255static void after_state_ch(struct drbd_device *device, union drbd_state os, 1256 union drbd_state ns, enum chg_state_flags flags) 1257{ 1258 struct drbd_resource *resource = device->resource; 1259 struct drbd_peer_device *peer_device = first_peer_device(device); 1260 struct drbd_connection *connection = peer_device ? peer_device->connection : NULL; 1261 struct sib_info sib; 1262 1263 sib.sib_reason = SIB_STATE_CHANGE; 1264 sib.os = os; 1265 sib.ns = ns; 1266 1267 if ((os.disk != D_UP_TO_DATE || os.pdsk != D_UP_TO_DATE) 1268 && (ns.disk == D_UP_TO_DATE && ns.pdsk == D_UP_TO_DATE)) { 1269 clear_bit(CRASHED_PRIMARY, &device->flags); 1270 if (device->p_uuid) 1271 device->p_uuid[UI_FLAGS] &= ~((u64)2); 1272 } 1273 1274 /* Inform userspace about the change... */ 1275 drbd_bcast_event(device, &sib); 1276 1277 if (!(os.role == R_PRIMARY && os.disk < D_UP_TO_DATE && os.pdsk < D_UP_TO_DATE) && 1278 (ns.role == R_PRIMARY && ns.disk < D_UP_TO_DATE && ns.pdsk < D_UP_TO_DATE)) 1279 drbd_khelper(device, "pri-on-incon-degr"); 1280 1281 /* Here we have the actions that are performed after a 1282 state change. This function might sleep */ 1283 1284 if (ns.susp_nod) { 1285 enum drbd_req_event what = NOTHING; 1286 1287 spin_lock_irq(&device->resource->req_lock); 1288 if (os.conn < C_CONNECTED && conn_lowest_conn(connection) >= C_CONNECTED) 1289 what = RESEND; 1290 1291 if ((os.disk == D_ATTACHING || os.disk == D_NEGOTIATING) && 1292 conn_lowest_disk(connection) > D_NEGOTIATING) 1293 what = RESTART_FROZEN_DISK_IO; 1294 1295 if (resource->susp_nod && what != NOTHING) { 1296 _tl_restart(connection, what); 1297 _conn_request_state(connection, 1298 (union drbd_state) { { .susp_nod = 1 } }, 1299 (union drbd_state) { { .susp_nod = 0 } }, 1300 CS_VERBOSE); 1301 } 1302 spin_unlock_irq(&device->resource->req_lock); 1303 } 1304 1305 if (ns.susp_fen) { 1306 spin_lock_irq(&device->resource->req_lock); 1307 if (resource->susp_fen && conn_lowest_conn(connection) >= C_CONNECTED) { 1308 /* case2: The connection was established again: */ 1309 struct drbd_peer_device *peer_device; 1310 int vnr; 1311 1312 rcu_read_lock(); 1313 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 1314 clear_bit(NEW_CUR_UUID, &peer_device->device->flags); 1315 rcu_read_unlock(); 1316 _tl_restart(connection, RESEND); 1317 _conn_request_state(connection, 1318 (union drbd_state) { { .susp_fen = 1 } }, 1319 (union drbd_state) { { .susp_fen = 0 } }, 1320 CS_VERBOSE); 1321 } 1322 spin_unlock_irq(&device->resource->req_lock); 1323 } 1324 1325 /* Became sync source. With protocol >= 96, we still need to send out 1326 * the sync uuid now. Need to do that before any drbd_send_state, or 1327 * the other side may go "paused sync" before receiving the sync uuids, 1328 * which is unexpected. */ 1329 if ((os.conn != C_SYNC_SOURCE && os.conn != C_PAUSED_SYNC_S) && 1330 (ns.conn == C_SYNC_SOURCE || ns.conn == C_PAUSED_SYNC_S) && 1331 connection->agreed_pro_version >= 96 && get_ldev(device)) { 1332 drbd_gen_and_send_sync_uuid(peer_device); 1333 put_ldev(device); 1334 } 1335 1336 /* Do not change the order of the if above and the two below... */ 1337 if (os.pdsk == D_DISKLESS && 1338 ns.pdsk > D_DISKLESS && ns.pdsk != D_UNKNOWN) { /* attach on the peer */ 1339 /* we probably will start a resync soon. 1340 * make sure those things are properly reset. */ 1341 device->rs_total = 0; 1342 device->rs_failed = 0; 1343 atomic_set(&device->rs_pending_cnt, 0); 1344 drbd_rs_cancel_all(device); 1345 1346 drbd_send_uuids(peer_device); 1347 drbd_send_state(peer_device, ns); 1348 } 1349 /* No point in queuing send_bitmap if we don't have a connection 1350 * anymore, so check also the _current_ state, not only the new state 1351 * at the time this work was queued. */ 1352 if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S && 1353 device->state.conn == C_WF_BITMAP_S) 1354 drbd_queue_bitmap_io(device, &drbd_send_bitmap, NULL, 1355 "send_bitmap (WFBitMapS)", 1356 BM_LOCKED_TEST_ALLOWED); 1357 1358 /* Lost contact to peer's copy of the data */ 1359 if ((os.pdsk >= D_INCONSISTENT && 1360 os.pdsk != D_UNKNOWN && 1361 os.pdsk != D_OUTDATED) 1362 && (ns.pdsk < D_INCONSISTENT || 1363 ns.pdsk == D_UNKNOWN || 1364 ns.pdsk == D_OUTDATED)) { 1365 if (get_ldev(device)) { 1366 if ((ns.role == R_PRIMARY || ns.peer == R_PRIMARY) && 1367 device->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) { 1368 if (drbd_suspended(device)) { 1369 set_bit(NEW_CUR_UUID, &device->flags); 1370 } else { 1371 drbd_uuid_new_current(device); 1372 drbd_send_uuids(peer_device); 1373 } 1374 } 1375 put_ldev(device); 1376 } 1377 } 1378 1379 if (ns.pdsk < D_INCONSISTENT && get_ldev(device)) { 1380 if (os.peer == R_SECONDARY && ns.peer == R_PRIMARY && 1381 device->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) { 1382 drbd_uuid_new_current(device); 1383 drbd_send_uuids(peer_device); 1384 } 1385 /* D_DISKLESS Peer becomes secondary */ 1386 if (os.peer == R_PRIMARY && ns.peer == R_SECONDARY) 1387 /* We may still be Primary ourselves. 1388 * No harm done if the bitmap still changes, 1389 * redirtied pages will follow later. */ 1390 drbd_bitmap_io_from_worker(device, &drbd_bm_write, 1391 "demote diskless peer", BM_LOCKED_SET_ALLOWED); 1392 put_ldev(device); 1393 } 1394 1395 /* Write out all changed bits on demote. 1396 * Though, no need to da that just yet 1397 * if there is a resync going on still */ 1398 if (os.role == R_PRIMARY && ns.role == R_SECONDARY && 1399 device->state.conn <= C_CONNECTED && get_ldev(device)) { 1400 /* No changes to the bitmap expected this time, so assert that, 1401 * even though no harm was done if it did change. */ 1402 drbd_bitmap_io_from_worker(device, &drbd_bm_write, 1403 "demote", BM_LOCKED_TEST_ALLOWED); 1404 put_ldev(device); 1405 } 1406 1407 /* Last part of the attaching process ... */ 1408 if (ns.conn >= C_CONNECTED && 1409 os.disk == D_ATTACHING && ns.disk == D_NEGOTIATING) { 1410 drbd_send_sizes(peer_device, 0, 0); /* to start sync... */ 1411 drbd_send_uuids(peer_device); 1412 drbd_send_state(peer_device, ns); 1413 } 1414 1415 /* We want to pause/continue resync, tell peer. */ 1416 if (ns.conn >= C_CONNECTED && 1417 ((os.aftr_isp != ns.aftr_isp) || 1418 (os.user_isp != ns.user_isp))) 1419 drbd_send_state(peer_device, ns); 1420 1421 /* In case one of the isp bits got set, suspend other devices. */ 1422 if ((!os.aftr_isp && !os.peer_isp && !os.user_isp) && 1423 (ns.aftr_isp || ns.peer_isp || ns.user_isp)) 1424 suspend_other_sg(device); 1425 1426 /* Make sure the peer gets informed about eventual state 1427 changes (ISP bits) while we were in WFReportParams. */ 1428 if (os.conn == C_WF_REPORT_PARAMS && ns.conn >= C_CONNECTED) 1429 drbd_send_state(peer_device, ns); 1430 1431 if (os.conn != C_AHEAD && ns.conn == C_AHEAD) 1432 drbd_send_state(peer_device, ns); 1433 1434 /* We are in the progress to start a full sync... */ 1435 if ((os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) || 1436 (os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S)) 1437 /* no other bitmap changes expected during this phase */ 1438 drbd_queue_bitmap_io(device, 1439 &drbd_bmio_set_n_write, &abw_start_sync, 1440 "set_n_write from StartingSync", BM_LOCKED_TEST_ALLOWED); 1441 1442 /* first half of local IO error, failure to attach, 1443 * or administrative detach */ 1444 if (os.disk != D_FAILED && ns.disk == D_FAILED) { 1445 enum drbd_io_error_p eh = EP_PASS_ON; 1446 int was_io_error = 0; 1447 /* corresponding get_ldev was in __drbd_set_state, to serialize 1448 * our cleanup here with the transition to D_DISKLESS. 1449 * But is is still not save to dreference ldev here, since 1450 * we might come from an failed Attach before ldev was set. */ 1451 if (device->ldev) { 1452 rcu_read_lock(); 1453 eh = rcu_dereference(device->ldev->disk_conf)->on_io_error; 1454 rcu_read_unlock(); 1455 1456 was_io_error = test_and_clear_bit(WAS_IO_ERROR, &device->flags); 1457 1458 if (was_io_error && eh == EP_CALL_HELPER) 1459 drbd_khelper(device, "local-io-error"); 1460 1461 /* Immediately allow completion of all application IO, 1462 * that waits for completion from the local disk, 1463 * if this was a force-detach due to disk_timeout 1464 * or administrator request (drbdsetup detach --force). 1465 * Do NOT abort otherwise. 1466 * Aborting local requests may cause serious problems, 1467 * if requests are completed to upper layers already, 1468 * and then later the already submitted local bio completes. 1469 * This can cause DMA into former bio pages that meanwhile 1470 * have been re-used for other things. 1471 * So aborting local requests may cause crashes, 1472 * or even worse, silent data corruption. 1473 */ 1474 if (test_and_clear_bit(FORCE_DETACH, &device->flags)) 1475 tl_abort_disk_io(device); 1476 1477 /* current state still has to be D_FAILED, 1478 * there is only one way out: to D_DISKLESS, 1479 * and that may only happen after our put_ldev below. */ 1480 if (device->state.disk != D_FAILED) 1481 drbd_err(device, 1482 "ASSERT FAILED: disk is %s during detach\n", 1483 drbd_disk_str(device->state.disk)); 1484 1485 if (ns.conn >= C_CONNECTED) 1486 drbd_send_state(peer_device, ns); 1487 1488 drbd_rs_cancel_all(device); 1489 1490 /* In case we want to get something to stable storage still, 1491 * this may be the last chance. 1492 * Following put_ldev may transition to D_DISKLESS. */ 1493 drbd_md_sync(device); 1494 } 1495 put_ldev(device); 1496 } 1497 1498 /* second half of local IO error, failure to attach, 1499 * or administrative detach, 1500 * after local_cnt references have reached zero again */ 1501 if (os.disk != D_DISKLESS && ns.disk == D_DISKLESS) { 1502 /* We must still be diskless, 1503 * re-attach has to be serialized with this! */ 1504 if (device->state.disk != D_DISKLESS) 1505 drbd_err(device, 1506 "ASSERT FAILED: disk is %s while going diskless\n", 1507 drbd_disk_str(device->state.disk)); 1508 1509 if (ns.conn >= C_CONNECTED) 1510 drbd_send_state(peer_device, ns); 1511 /* corresponding get_ldev in __drbd_set_state 1512 * this may finally trigger drbd_ldev_destroy. */ 1513 put_ldev(device); 1514 } 1515 1516 /* Notify peer that I had a local IO error, and did not detached.. */ 1517 if (os.disk == D_UP_TO_DATE && ns.disk == D_INCONSISTENT && ns.conn >= C_CONNECTED) 1518 drbd_send_state(peer_device, ns); 1519 1520 /* Disks got bigger while they were detached */ 1521 if (ns.disk > D_NEGOTIATING && ns.pdsk > D_NEGOTIATING && 1522 test_and_clear_bit(RESYNC_AFTER_NEG, &device->flags)) { 1523 if (ns.conn == C_CONNECTED) 1524 resync_after_online_grow(device); 1525 } 1526 1527 /* A resync finished or aborted, wake paused devices... */ 1528 if ((os.conn > C_CONNECTED && ns.conn <= C_CONNECTED) || 1529 (os.peer_isp && !ns.peer_isp) || 1530 (os.user_isp && !ns.user_isp)) 1531 resume_next_sg(device); 1532 1533 /* sync target done with resync. Explicitly notify peer, even though 1534 * it should (at least for non-empty resyncs) already know itself. */ 1535 if (os.disk < D_UP_TO_DATE && os.conn >= C_SYNC_SOURCE && ns.conn == C_CONNECTED) 1536 drbd_send_state(peer_device, ns); 1537 1538 /* Verify finished, or reached stop sector. Peer did not know about 1539 * the stop sector, and we may even have changed the stop sector during 1540 * verify to interrupt/stop early. Send the new state. */ 1541 if (os.conn == C_VERIFY_S && ns.conn == C_CONNECTED 1542 && verify_can_do_stop_sector(device)) 1543 drbd_send_state(peer_device, ns); 1544 1545 /* This triggers bitmap writeout of potentially still unwritten pages 1546 * if the resync finished cleanly, or aborted because of peer disk 1547 * failure, or because of connection loss. 1548 * For resync aborted because of local disk failure, we cannot do 1549 * any bitmap writeout anymore. 1550 * No harm done if some bits change during this phase. 1551 */ 1552 if (os.conn > C_CONNECTED && ns.conn <= C_CONNECTED && get_ldev(device)) { 1553 drbd_queue_bitmap_io(device, &drbd_bm_write_copy_pages, NULL, 1554 "write from resync_finished", BM_LOCKED_CHANGE_ALLOWED); 1555 put_ldev(device); 1556 } 1557 1558 if (ns.disk == D_DISKLESS && 1559 ns.conn == C_STANDALONE && 1560 ns.role == R_SECONDARY) { 1561 if (os.aftr_isp != ns.aftr_isp) 1562 resume_next_sg(device); 1563 } 1564 1565 drbd_md_sync(device); 1566} 1567 1568struct after_conn_state_chg_work { 1569 struct drbd_work w; 1570 enum drbd_conns oc; 1571 union drbd_state ns_min; 1572 union drbd_state ns_max; /* new, max state, over all devices */ 1573 enum chg_state_flags flags; 1574 struct drbd_connection *connection; 1575}; 1576 1577static int w_after_conn_state_ch(struct drbd_work *w, int unused) 1578{ 1579 struct after_conn_state_chg_work *acscw = 1580 container_of(w, struct after_conn_state_chg_work, w); 1581 struct drbd_connection *connection = acscw->connection; 1582 enum drbd_conns oc = acscw->oc; 1583 union drbd_state ns_max = acscw->ns_max; 1584 struct drbd_peer_device *peer_device; 1585 int vnr; 1586 1587 kfree(acscw); 1588 1589 /* Upon network configuration, we need to start the receiver */ 1590 if (oc == C_STANDALONE && ns_max.conn == C_UNCONNECTED) 1591 drbd_thread_start(&connection->receiver); 1592 1593 if (oc == C_DISCONNECTING && ns_max.conn == C_STANDALONE) { 1594 struct net_conf *old_conf; 1595 1596 mutex_lock(&connection->resource->conf_update); 1597 old_conf = connection->net_conf; 1598 connection->my_addr_len = 0; 1599 connection->peer_addr_len = 0; 1600 RCU_INIT_POINTER(connection->net_conf, NULL); 1601 conn_free_crypto(connection); 1602 mutex_unlock(&connection->resource->conf_update); 1603 1604 synchronize_rcu(); 1605 kfree(old_conf); 1606 } 1607 1608 if (ns_max.susp_fen) { 1609 /* case1: The outdate peer handler is successful: */ 1610 if (ns_max.pdsk <= D_OUTDATED) { 1611 rcu_read_lock(); 1612 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1613 struct drbd_device *device = peer_device->device; 1614 if (test_bit(NEW_CUR_UUID, &device->flags)) { 1615 drbd_uuid_new_current(device); 1616 clear_bit(NEW_CUR_UUID, &device->flags); 1617 } 1618 } 1619 rcu_read_unlock(); 1620 spin_lock_irq(&connection->resource->req_lock); 1621 _tl_restart(connection, CONNECTION_LOST_WHILE_PENDING); 1622 _conn_request_state(connection, 1623 (union drbd_state) { { .susp_fen = 1 } }, 1624 (union drbd_state) { { .susp_fen = 0 } }, 1625 CS_VERBOSE); 1626 spin_unlock_irq(&connection->resource->req_lock); 1627 } 1628 } 1629 kref_put(&connection->kref, drbd_destroy_connection); 1630 1631 conn_md_sync(connection); 1632 1633 return 0; 1634} 1635 1636static void conn_old_common_state(struct drbd_connection *connection, union drbd_state *pcs, enum chg_state_flags *pf) 1637{ 1638 enum chg_state_flags flags = ~0; 1639 struct drbd_peer_device *peer_device; 1640 int vnr, first_vol = 1; 1641 union drbd_dev_state os, cs = { 1642 { .role = R_SECONDARY, 1643 .peer = R_UNKNOWN, 1644 .conn = connection->cstate, 1645 .disk = D_DISKLESS, 1646 .pdsk = D_UNKNOWN, 1647 } }; 1648 1649 rcu_read_lock(); 1650 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1651 struct drbd_device *device = peer_device->device; 1652 os = device->state; 1653 1654 if (first_vol) { 1655 cs = os; 1656 first_vol = 0; 1657 continue; 1658 } 1659 1660 if (cs.role != os.role) 1661 flags &= ~CS_DC_ROLE; 1662 1663 if (cs.peer != os.peer) 1664 flags &= ~CS_DC_PEER; 1665 1666 if (cs.conn != os.conn) 1667 flags &= ~CS_DC_CONN; 1668 1669 if (cs.disk != os.disk) 1670 flags &= ~CS_DC_DISK; 1671 1672 if (cs.pdsk != os.pdsk) 1673 flags &= ~CS_DC_PDSK; 1674 } 1675 rcu_read_unlock(); 1676 1677 *pf |= CS_DC_MASK; 1678 *pf &= flags; 1679 (*pcs).i = cs.i; 1680} 1681 1682static enum drbd_state_rv 1683conn_is_valid_transition(struct drbd_connection *connection, union drbd_state mask, union drbd_state val, 1684 enum chg_state_flags flags) 1685{ 1686 enum drbd_state_rv rv = SS_SUCCESS; 1687 union drbd_state ns, os; 1688 struct drbd_peer_device *peer_device; 1689 int vnr; 1690 1691 rcu_read_lock(); 1692 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1693 struct drbd_device *device = peer_device->device; 1694 os = drbd_read_state(device); 1695 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL); 1696 1697 if (flags & CS_IGN_OUTD_FAIL && ns.disk == D_OUTDATED && os.disk < D_OUTDATED) 1698 ns.disk = os.disk; 1699 1700 if (ns.i == os.i) 1701 continue; 1702 1703 rv = is_valid_transition(os, ns); 1704 1705 if (rv >= SS_SUCCESS && !(flags & CS_HARD)) { 1706 rv = is_valid_state(device, ns); 1707 if (rv < SS_SUCCESS) { 1708 if (is_valid_state(device, os) == rv) 1709 rv = is_valid_soft_transition(os, ns, connection); 1710 } else 1711 rv = is_valid_soft_transition(os, ns, connection); 1712 } 1713 1714 if (rv < SS_SUCCESS) { 1715 if (flags & CS_VERBOSE) 1716 print_st_err(device, os, ns, rv); 1717 break; 1718 } 1719 } 1720 rcu_read_unlock(); 1721 1722 return rv; 1723} 1724 1725static void 1726conn_set_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val, 1727 union drbd_state *pns_min, union drbd_state *pns_max, enum chg_state_flags flags) 1728{ 1729 union drbd_state ns, os, ns_max = { }; 1730 union drbd_state ns_min = { 1731 { .role = R_MASK, 1732 .peer = R_MASK, 1733 .conn = val.conn, 1734 .disk = D_MASK, 1735 .pdsk = D_MASK 1736 } }; 1737 struct drbd_peer_device *peer_device; 1738 enum drbd_state_rv rv; 1739 int vnr, number_of_volumes = 0; 1740 1741 if (mask.conn == C_MASK) { 1742 /* remember last connect time so request_timer_fn() won't 1743 * kill newly established sessions while we are still trying to thaw 1744 * previously frozen IO */ 1745 if (connection->cstate != C_WF_REPORT_PARAMS && val.conn == C_WF_REPORT_PARAMS) 1746 connection->last_reconnect_jif = jiffies; 1747 1748 connection->cstate = val.conn; 1749 } 1750 1751 rcu_read_lock(); 1752 idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1753 struct drbd_device *device = peer_device->device; 1754 number_of_volumes++; 1755 os = drbd_read_state(device); 1756 ns = apply_mask_val(os, mask, val); 1757 ns = sanitize_state(device, os, ns, NULL); 1758 1759 if (flags & CS_IGN_OUTD_FAIL && ns.disk == D_OUTDATED && os.disk < D_OUTDATED) 1760 ns.disk = os.disk; 1761 1762 rv = __drbd_set_state(device, ns, flags, NULL); 1763 if (rv < SS_SUCCESS) 1764 BUG(); 1765 1766 ns.i = device->state.i; 1767 ns_max.role = max_role(ns.role, ns_max.role); 1768 ns_max.peer = max_role(ns.peer, ns_max.peer); 1769 ns_max.conn = max_t(enum drbd_conns, ns.conn, ns_max.conn); 1770 ns_max.disk = max_t(enum drbd_disk_state, ns.disk, ns_max.disk); 1771 ns_max.pdsk = max_t(enum drbd_disk_state, ns.pdsk, ns_max.pdsk); 1772 1773 ns_min.role = min_role(ns.role, ns_min.role); 1774 ns_min.peer = min_role(ns.peer, ns_min.peer); 1775 ns_min.conn = min_t(enum drbd_conns, ns.conn, ns_min.conn); 1776 ns_min.disk = min_t(enum drbd_disk_state, ns.disk, ns_min.disk); 1777 ns_min.pdsk = min_t(enum drbd_disk_state, ns.pdsk, ns_min.pdsk); 1778 } 1779 rcu_read_unlock(); 1780 1781 if (number_of_volumes == 0) { 1782 ns_min = ns_max = (union drbd_state) { { 1783 .role = R_SECONDARY, 1784 .peer = R_UNKNOWN, 1785 .conn = val.conn, 1786 .disk = D_DISKLESS, 1787 .pdsk = D_UNKNOWN 1788 } }; 1789 } 1790 1791 ns_min.susp = ns_max.susp = connection->resource->susp; 1792 ns_min.susp_nod = ns_max.susp_nod = connection->resource->susp_nod; 1793 ns_min.susp_fen = ns_max.susp_fen = connection->resource->susp_fen; 1794 1795 *pns_min = ns_min; 1796 *pns_max = ns_max; 1797} 1798 1799static enum drbd_state_rv 1800_conn_rq_cond(struct drbd_connection *connection, union drbd_state mask, union drbd_state val) 1801{ 1802 enum drbd_state_rv err, rv = SS_UNKNOWN_ERROR; /* continue waiting */; 1803 1804 if (test_and_clear_bit(CONN_WD_ST_CHG_OKAY, &connection->flags)) 1805 rv = SS_CW_SUCCESS; 1806 1807 if (test_and_clear_bit(CONN_WD_ST_CHG_FAIL, &connection->flags)) 1808 rv = SS_CW_FAILED_BY_PEER; 1809 1810 err = conn_is_valid_transition(connection, mask, val, 0); 1811 if (err == SS_SUCCESS && connection->cstate == C_WF_REPORT_PARAMS) 1812 return rv; 1813 1814 return err; 1815} 1816 1817enum drbd_state_rv 1818_conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val, 1819 enum chg_state_flags flags) 1820{ 1821 enum drbd_state_rv rv = SS_SUCCESS; 1822 struct after_conn_state_chg_work *acscw; 1823 enum drbd_conns oc = connection->cstate; 1824 union drbd_state ns_max, ns_min, os; 1825 bool have_mutex = false; 1826 1827 if (mask.conn) { 1828 rv = is_valid_conn_transition(oc, val.conn); 1829 if (rv < SS_SUCCESS) 1830 goto abort; 1831 } 1832 1833 rv = conn_is_valid_transition(connection, mask, val, flags); 1834 if (rv < SS_SUCCESS) 1835 goto abort; 1836 1837 if (oc == C_WF_REPORT_PARAMS && val.conn == C_DISCONNECTING && 1838 !(flags & (CS_LOCAL_ONLY | CS_HARD))) { 1839 1840 /* This will be a cluster-wide state change. 1841 * Need to give up the spinlock, grab the mutex, 1842 * then send the state change request, ... */ 1843 spin_unlock_irq(&connection->resource->req_lock); 1844 mutex_lock(&connection->cstate_mutex); 1845 have_mutex = true; 1846 1847 set_bit(CONN_WD_ST_CHG_REQ, &connection->flags); 1848 if (conn_send_state_req(connection, mask, val)) { 1849 /* sending failed. */ 1850 clear_bit(CONN_WD_ST_CHG_REQ, &connection->flags); 1851 rv = SS_CW_FAILED_BY_PEER; 1852 /* need to re-aquire the spin lock, though */ 1853 goto abort_unlocked; 1854 } 1855 1856 if (val.conn == C_DISCONNECTING) 1857 set_bit(DISCONNECT_SENT, &connection->flags); 1858 1859 /* ... and re-aquire the spinlock. 1860 * If _conn_rq_cond() returned >= SS_SUCCESS, we must call 1861 * conn_set_state() within the same spinlock. */ 1862 spin_lock_irq(&connection->resource->req_lock); 1863 wait_event_lock_irq(connection->ping_wait, 1864 (rv = _conn_rq_cond(connection, mask, val)), 1865 connection->resource->req_lock); 1866 clear_bit(CONN_WD_ST_CHG_REQ, &connection->flags); 1867 if (rv < SS_SUCCESS) 1868 goto abort; 1869 } 1870 1871 conn_old_common_state(connection, &os, &flags); 1872 flags |= CS_DC_SUSP; 1873 conn_set_state(connection, mask, val, &ns_min, &ns_max, flags); 1874 conn_pr_state_change(connection, os, ns_max, flags); 1875 1876 acscw = kmalloc(sizeof(*acscw), GFP_ATOMIC); 1877 if (acscw) { 1878 acscw->oc = os.conn; 1879 acscw->ns_min = ns_min; 1880 acscw->ns_max = ns_max; 1881 acscw->flags = flags; 1882 acscw->w.cb = w_after_conn_state_ch; 1883 kref_get(&connection->kref); 1884 acscw->connection = connection; 1885 drbd_queue_work(&connection->sender_work, &acscw->w); 1886 } else { 1887 drbd_err(connection, "Could not kmalloc an acscw\n"); 1888 } 1889 1890 abort: 1891 if (have_mutex) { 1892 /* mutex_unlock() "... must not be used in interrupt context.", 1893 * so give up the spinlock, then re-aquire it */ 1894 spin_unlock_irq(&connection->resource->req_lock); 1895 abort_unlocked: 1896 mutex_unlock(&connection->cstate_mutex); 1897 spin_lock_irq(&connection->resource->req_lock); 1898 } 1899 if (rv < SS_SUCCESS && flags & CS_VERBOSE) { 1900 drbd_err(connection, "State change failed: %s\n", drbd_set_st_err_str(rv)); 1901 drbd_err(connection, " mask = 0x%x val = 0x%x\n", mask.i, val.i); 1902 drbd_err(connection, " old_conn:%s wanted_conn:%s\n", drbd_conn_str(oc), drbd_conn_str(val.conn)); 1903 } 1904 return rv; 1905} 1906 1907enum drbd_state_rv 1908conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val, 1909 enum chg_state_flags flags) 1910{ 1911 enum drbd_state_rv rv; 1912 1913 spin_lock_irq(&connection->resource->req_lock); 1914 rv = _conn_request_state(connection, mask, val, flags); 1915 spin_unlock_irq(&connection->resource->req_lock); 1916 1917 return rv; 1918} 1919