kernel/drivers/block/drbd/drbd_state.c

   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
  33 struct 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
  42 enum 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
  51 static int w_after_state_ch(struct drbd_work *w, int unused);
  52 static void after_state_ch(struct drbd_device *device, union drbd_state os,
  53                            union drbd_state ns, enum chg_state_flags flags);
  54 static enum drbd_state_rv is_valid_state(struct drbd_device *, union drbd_state);
  55 static enum drbd_state_rv is_valid_soft_transition(union drbd_state, union drbd_state, struct drbd_connection *);
  56 static enum drbd_state_rv is_valid_transition(union drbd_state os, union drbd_state ns);
  57 static union drbd_state sanitize_state(struct drbd_device *device, union drbd_state os,
  58                                        union drbd_state ns, enum sanitize_state_warnings *warn);
  59
  60 static inline bool is_susp(union drbd_state s)
  61 {
  62         return s.susp || s.susp_nod || s.susp_fen;
  63 }
  64
  65 bool 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. */
  88 static 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 }
  96 static 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
 105 enum 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
 121 enum 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
 137 enum 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
 153 enum 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
 169 enum 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
 185 enum 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
 201 static 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
 218 static 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  */
 237 static 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
 250 static union drbd_state
 251 apply_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
 258 enum drbd_state_rv
 259 drbd_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  */
 280 void 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
 286 static 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  */
 332 static enum drbd_state_rv
 333 drbd_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
 396 abort:
 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  */
 413 enum 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
 425 enum 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
 441 static 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
 459 void 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
 469 static 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
 500 static 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
 525 static 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  */
 548 static enum drbd_state_rv
 549 is_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  */
 636 static enum drbd_state_rv
 637 is_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
 689 static enum drbd_state_rv
 690 is_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  */
 729 static enum drbd_state_rv
 730 is_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
 743 static 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  */
 768 static 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
 934 void 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 */
 941 static 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  */
 976 enum 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
1196 static 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
1210 static 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
1228 int 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  */
1255 static 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
1568 struct 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
1577 static 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
1636 static 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
1682 static enum drbd_state_rv
1683 conn_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
1725 static void
1726 conn_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
1799 static 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
1817 enum 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
1907 enum drbd_state_rv
1908 conn_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 }