1 /* 2 drbd_int.h 3 4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5 6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9 10 drbd is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2, or (at your option) 13 any later version. 14 15 drbd is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with drbd; see the file COPYING. If not, write to 22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23 24 */ 25 26 #ifndef _DRBD_INT_H 27 #define _DRBD_INT_H 28 29 #include <linux/compiler.h> 30 #include <linux/types.h> 31 #include <linux/version.h> 32 #include <linux/list.h> 33 #include <linux/sched.h> 34 #include <linux/bitops.h> 35 #include <linux/slab.h> 36 #include <linux/crypto.h> 37 #include <linux/ratelimit.h> 38 #include <linux/tcp.h> 39 #include <linux/mutex.h> 40 #include <linux/major.h> 41 #include <linux/blkdev.h> 42 #include <linux/genhd.h> 43 #include <net/tcp.h> 44 #include <linux/lru_cache.h> 45 46 #ifdef __CHECKER__ 47 # define __protected_by(x) __attribute__((require_context(x,1,999,"rdwr"))) 48 # define __protected_read_by(x) __attribute__((require_context(x,1,999,"read"))) 49 # define __protected_write_by(x) __attribute__((require_context(x,1,999,"write"))) 50 # define __must_hold(x) __attribute__((context(x,1,1), require_context(x,1,999,"call"))) 51 #else 52 # define __protected_by(x) 53 # define __protected_read_by(x) 54 # define __protected_write_by(x) 55 # define __must_hold(x) 56 #endif 57 58 #define __no_warn(lock, stmt) do { __acquire(lock); stmt; __release(lock); } while (0) 59 60 /* module parameter, defined in drbd_main.c */ 61 extern unsigned int minor_count; 62 extern int disable_sendpage; 63 extern int allow_oos; 64 extern unsigned int cn_idx; 65 66 #ifdef CONFIG_DRBD_FAULT_INJECTION 67 extern int enable_faults; 68 extern int fault_rate; 69 extern int fault_devs; 70 #endif 71 72 extern char usermode_helper[]; 73 74 75 #ifndef TRUE 76 #define TRUE 1 77 #endif 78 #ifndef FALSE 79 #define FALSE 0 80 #endif 81 82 /* I don't remember why XCPU ... 83 * This is used to wake the asender, 84 * and to interrupt sending the sending task 85 * on disconnect. 86 */ 87 #define DRBD_SIG SIGXCPU 88 89 /* This is used to stop/restart our threads. 90 * Cannot use SIGTERM nor SIGKILL, since these 91 * are sent out by init on runlevel changes 92 * I choose SIGHUP for now. 93 */ 94 #define DRBD_SIGKILL SIGHUP 95 96 /* All EEs on the free list should have ID_VACANT (== 0) 97 * freshly allocated EEs get !ID_VACANT (== 1) 98 * so if it says "cannot dereference null pointer at address 0x00000001", 99 * it is most likely one of these :( */ 100 101 #define ID_IN_SYNC (4711ULL) 102 #define ID_OUT_OF_SYNC (4712ULL) 103 104 #define ID_SYNCER (-1ULL) 105 #define ID_VACANT 0 106 #define is_syncer_block_id(id) ((id) == ID_SYNCER) 107 108 struct drbd_conf; 109 110 111 /* to shorten dev_warn(DEV, "msg"); and relatives statements */ 112 #define DEV (disk_to_dev(mdev->vdisk)) 113 114 #define D_ASSERT(exp) if (!(exp)) \ 115 dev_err(DEV, "ASSERT( " #exp " ) in %s:%d\n", __FILE__, __LINE__) 116 117 #define ERR_IF(exp) if (({ \ 118 int _b = (exp) != 0; \ 119 if (_b) dev_err(DEV, "%s: (%s) in %s:%d\n", \ 120 __func__, #exp, __FILE__, __LINE__); \ 121 _b; \ 122 })) 123 124 /* Defines to control fault insertion */ 125 enum { 126 DRBD_FAULT_MD_WR = 0, /* meta data write */ 127 DRBD_FAULT_MD_RD = 1, /* read */ 128 DRBD_FAULT_RS_WR = 2, /* resync */ 129 DRBD_FAULT_RS_RD = 3, 130 DRBD_FAULT_DT_WR = 4, /* data */ 131 DRBD_FAULT_DT_RD = 5, 132 DRBD_FAULT_DT_RA = 6, /* data read ahead */ 133 DRBD_FAULT_BM_ALLOC = 7, /* bitmap allocation */ 134 DRBD_FAULT_AL_EE = 8, /* alloc ee */ 135 DRBD_FAULT_RECEIVE = 9, /* Changes some bytes upon receiving a [rs]data block */ 136 137 DRBD_FAULT_MAX, 138 }; 139 140 #ifdef CONFIG_DRBD_FAULT_INJECTION 141 extern unsigned int 142 _drbd_insert_fault(struct drbd_conf *mdev, unsigned int type); 143 static inline int 144 drbd_insert_fault(struct drbd_conf *mdev, unsigned int type) { 145 return fault_rate && 146 (enable_faults & (1<<type)) && 147 _drbd_insert_fault(mdev, type); 148 } 149 #define FAULT_ACTIVE(_m, _t) (drbd_insert_fault((_m), (_t))) 150 151 #else 152 #define FAULT_ACTIVE(_m, _t) (0) 153 #endif 154 155 /* integer division, round _UP_ to the next integer */ 156 #define div_ceil(A, B) ((A)/(B) + ((A)%(B) ? 1 : 0)) 157 /* usual integer division */ 158 #define div_floor(A, B) ((A)/(B)) 159 160 /* drbd_meta-data.c (still in drbd_main.c) */ 161 /* 4th incarnation of the disk layout. */ 162 #define DRBD_MD_MAGIC (DRBD_MAGIC+4) 163 164 extern struct drbd_conf **minor_table; 165 extern struct ratelimit_state drbd_ratelimit_state; 166 167 /* on the wire */ 168 enum drbd_packets { 169 /* receiver (data socket) */ 170 P_DATA = 0x00, 171 P_DATA_REPLY = 0x01, /* Response to P_DATA_REQUEST */ 172 P_RS_DATA_REPLY = 0x02, /* Response to P_RS_DATA_REQUEST */ 173 P_BARRIER = 0x03, 174 P_BITMAP = 0x04, 175 P_BECOME_SYNC_TARGET = 0x05, 176 P_BECOME_SYNC_SOURCE = 0x06, 177 P_UNPLUG_REMOTE = 0x07, /* Used at various times to hint the peer */ 178 P_DATA_REQUEST = 0x08, /* Used to ask for a data block */ 179 P_RS_DATA_REQUEST = 0x09, /* Used to ask for a data block for resync */ 180 P_SYNC_PARAM = 0x0a, 181 P_PROTOCOL = 0x0b, 182 P_UUIDS = 0x0c, 183 P_SIZES = 0x0d, 184 P_STATE = 0x0e, 185 P_SYNC_UUID = 0x0f, 186 P_AUTH_CHALLENGE = 0x10, 187 P_AUTH_RESPONSE = 0x11, 188 P_STATE_CHG_REQ = 0x12, 189 190 /* asender (meta socket */ 191 P_PING = 0x13, 192 P_PING_ACK = 0x14, 193 P_RECV_ACK = 0x15, /* Used in protocol B */ 194 P_WRITE_ACK = 0x16, /* Used in protocol C */ 195 P_RS_WRITE_ACK = 0x17, /* Is a P_WRITE_ACK, additionally call set_in_sync(). */ 196 P_DISCARD_ACK = 0x18, /* Used in proto C, two-primaries conflict detection */ 197 P_NEG_ACK = 0x19, /* Sent if local disk is unusable */ 198 P_NEG_DREPLY = 0x1a, /* Local disk is broken... */ 199 P_NEG_RS_DREPLY = 0x1b, /* Local disk is broken... */ 200 P_BARRIER_ACK = 0x1c, 201 P_STATE_CHG_REPLY = 0x1d, 202 203 /* "new" commands, no longer fitting into the ordering scheme above */ 204 205 P_OV_REQUEST = 0x1e, /* data socket */ 206 P_OV_REPLY = 0x1f, 207 P_OV_RESULT = 0x20, /* meta socket */ 208 P_CSUM_RS_REQUEST = 0x21, /* data socket */ 209 P_RS_IS_IN_SYNC = 0x22, /* meta socket */ 210 P_SYNC_PARAM89 = 0x23, /* data socket, protocol version 89 replacement for P_SYNC_PARAM */ 211 P_COMPRESSED_BITMAP = 0x24, /* compressed or otherwise encoded bitmap transfer */ 212 /* P_CKPT_FENCE_REQ = 0x25, * currently reserved for protocol D */ 213 /* P_CKPT_DISABLE_REQ = 0x26, * currently reserved for protocol D */ 214 P_DELAY_PROBE = 0x27, /* is used on BOTH sockets */ 215 216 P_MAX_CMD = 0x28, 217 P_MAY_IGNORE = 0x100, /* Flag to test if (cmd > P_MAY_IGNORE) ... */ 218 P_MAX_OPT_CMD = 0x101, 219 220 /* special command ids for handshake */ 221 222 P_HAND_SHAKE_M = 0xfff1, /* First Packet on the MetaSock */ 223 P_HAND_SHAKE_S = 0xfff2, /* First Packet on the Socket */ 224 225 P_HAND_SHAKE = 0xfffe /* FIXED for the next century! */ 226 }; 227 228 static inline const char *cmdname(enum drbd_packets cmd) 229 { 230 /* THINK may need to become several global tables 231 * when we want to support more than 232 * one PRO_VERSION */ 233 static const char *cmdnames[] = { 234 [P_DATA] = "Data", 235 [P_DATA_REPLY] = "DataReply", 236 [P_RS_DATA_REPLY] = "RSDataReply", 237 [P_BARRIER] = "Barrier", 238 [P_BITMAP] = "ReportBitMap", 239 [P_BECOME_SYNC_TARGET] = "BecomeSyncTarget", 240 [P_BECOME_SYNC_SOURCE] = "BecomeSyncSource", 241 [P_UNPLUG_REMOTE] = "UnplugRemote", 242 [P_DATA_REQUEST] = "DataRequest", 243 [P_RS_DATA_REQUEST] = "RSDataRequest", 244 [P_SYNC_PARAM] = "SyncParam", 245 [P_SYNC_PARAM89] = "SyncParam89", 246 [P_PROTOCOL] = "ReportProtocol", 247 [P_UUIDS] = "ReportUUIDs", 248 [P_SIZES] = "ReportSizes", 249 [P_STATE] = "ReportState", 250 [P_SYNC_UUID] = "ReportSyncUUID", 251 [P_AUTH_CHALLENGE] = "AuthChallenge", 252 [P_AUTH_RESPONSE] = "AuthResponse", 253 [P_PING] = "Ping", 254 [P_PING_ACK] = "PingAck", 255 [P_RECV_ACK] = "RecvAck", 256 [P_WRITE_ACK] = "WriteAck", 257 [P_RS_WRITE_ACK] = "RSWriteAck", 258 [P_DISCARD_ACK] = "DiscardAck", 259 [P_NEG_ACK] = "NegAck", 260 [P_NEG_DREPLY] = "NegDReply", 261 [P_NEG_RS_DREPLY] = "NegRSDReply", 262 [P_BARRIER_ACK] = "BarrierAck", 263 [P_STATE_CHG_REQ] = "StateChgRequest", 264 [P_STATE_CHG_REPLY] = "StateChgReply", 265 [P_OV_REQUEST] = "OVRequest", 266 [P_OV_REPLY] = "OVReply", 267 [P_OV_RESULT] = "OVResult", 268 [P_CSUM_RS_REQUEST] = "CsumRSRequest", 269 [P_RS_IS_IN_SYNC] = "CsumRSIsInSync", 270 [P_COMPRESSED_BITMAP] = "CBitmap", 271 [P_DELAY_PROBE] = "DelayProbe", 272 [P_MAX_CMD] = NULL, 273 }; 274 275 if (cmd == P_HAND_SHAKE_M) 276 return "HandShakeM"; 277 if (cmd == P_HAND_SHAKE_S) 278 return "HandShakeS"; 279 if (cmd == P_HAND_SHAKE) 280 return "HandShake"; 281 if (cmd >= P_MAX_CMD) 282 return "Unknown"; 283 return cmdnames[cmd]; 284 } 285 286 /* for sending/receiving the bitmap, 287 * possibly in some encoding scheme */ 288 struct bm_xfer_ctx { 289 /* "const" 290 * stores total bits and long words 291 * of the bitmap, so we don't need to 292 * call the accessor functions over and again. */ 293 unsigned long bm_bits; 294 unsigned long bm_words; 295 /* during xfer, current position within the bitmap */ 296 unsigned long bit_offset; 297 unsigned long word_offset; 298 299 /* statistics; index: (h->command == P_BITMAP) */ 300 unsigned packets[2]; 301 unsigned bytes[2]; 302 }; 303 304 extern void INFO_bm_xfer_stats(struct drbd_conf *mdev, 305 const char *direction, struct bm_xfer_ctx *c); 306 307 static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c) 308 { 309 /* word_offset counts "native long words" (32 or 64 bit), 310 * aligned at 64 bit. 311 * Encoded packet may end at an unaligned bit offset. 312 * In case a fallback clear text packet is transmitted in 313 * between, we adjust this offset back to the last 64bit 314 * aligned "native long word", which makes coding and decoding 315 * the plain text bitmap much more convenient. */ 316 #if BITS_PER_LONG == 64 317 c->word_offset = c->bit_offset >> 6; 318 #elif BITS_PER_LONG == 32 319 c->word_offset = c->bit_offset >> 5; 320 c->word_offset &= ~(1UL); 321 #else 322 # error "unsupported BITS_PER_LONG" 323 #endif 324 } 325 326 #ifndef __packed 327 #define __packed __attribute__((packed)) 328 #endif 329 330 /* This is the layout for a packet on the wire. 331 * The byteorder is the network byte order. 332 * (except block_id and barrier fields. 333 * these are pointers to local structs 334 * and have no relevance for the partner, 335 * which just echoes them as received.) 336 * 337 * NOTE that the payload starts at a long aligned offset, 338 * regardless of 32 or 64 bit arch! 339 */ 340 struct p_header { 341 u32 magic; 342 u16 command; 343 u16 length; /* bytes of data after this header */ 344 u8 payload[0]; 345 } __packed; 346 /* 8 bytes. packet FIXED for the next century! */ 347 348 /* 349 * short commands, packets without payload, plain p_header: 350 * P_PING 351 * P_PING_ACK 352 * P_BECOME_SYNC_TARGET 353 * P_BECOME_SYNC_SOURCE 354 * P_UNPLUG_REMOTE 355 */ 356 357 /* 358 * commands with out-of-struct payload: 359 * P_BITMAP (no additional fields) 360 * P_DATA, P_DATA_REPLY (see p_data) 361 * P_COMPRESSED_BITMAP (see receive_compressed_bitmap) 362 */ 363 364 /* these defines must not be changed without changing the protocol version */ 365 #define DP_HARDBARRIER 1 366 #define DP_RW_SYNC 2 367 #define DP_MAY_SET_IN_SYNC 4 368 369 struct p_data { 370 struct p_header head; 371 u64 sector; /* 64 bits sector number */ 372 u64 block_id; /* to identify the request in protocol B&C */ 373 u32 seq_num; 374 u32 dp_flags; 375 } __packed; 376 377 /* 378 * commands which share a struct: 379 * p_block_ack: 380 * P_RECV_ACK (proto B), P_WRITE_ACK (proto C), 381 * P_DISCARD_ACK (proto C, two-primaries conflict detection) 382 * p_block_req: 383 * P_DATA_REQUEST, P_RS_DATA_REQUEST 384 */ 385 struct p_block_ack { 386 struct p_header head; 387 u64 sector; 388 u64 block_id; 389 u32 blksize; 390 u32 seq_num; 391 } __packed; 392 393 394 struct p_block_req { 395 struct p_header head; 396 u64 sector; 397 u64 block_id; 398 u32 blksize; 399 u32 pad; /* to multiple of 8 Byte */ 400 } __packed; 401 402 /* 403 * commands with their own struct for additional fields: 404 * P_HAND_SHAKE 405 * P_BARRIER 406 * P_BARRIER_ACK 407 * P_SYNC_PARAM 408 * ReportParams 409 */ 410 411 struct p_handshake { 412 struct p_header head; /* 8 bytes */ 413 u32 protocol_min; 414 u32 feature_flags; 415 u32 protocol_max; 416 417 /* should be more than enough for future enhancements 418 * for now, feature_flags and the reserverd array shall be zero. 419 */ 420 421 u32 _pad; 422 u64 reserverd[7]; 423 } __packed; 424 /* 80 bytes, FIXED for the next century */ 425 426 struct p_barrier { 427 struct p_header head; 428 u32 barrier; /* barrier number _handle_ only */ 429 u32 pad; /* to multiple of 8 Byte */ 430 } __packed; 431 432 struct p_barrier_ack { 433 struct p_header head; 434 u32 barrier; 435 u32 set_size; 436 } __packed; 437 438 struct p_rs_param { 439 struct p_header head; 440 u32 rate; 441 442 /* Since protocol version 88 and higher. */ 443 char verify_alg[0]; 444 } __packed; 445 446 struct p_rs_param_89 { 447 struct p_header head; 448 u32 rate; 449 /* protocol version 89: */ 450 char verify_alg[SHARED_SECRET_MAX]; 451 char csums_alg[SHARED_SECRET_MAX]; 452 } __packed; 453 454 enum drbd_conn_flags { 455 CF_WANT_LOSE = 1, 456 CF_DRY_RUN = 2, 457 }; 458 459 struct p_protocol { 460 struct p_header head; 461 u32 protocol; 462 u32 after_sb_0p; 463 u32 after_sb_1p; 464 u32 after_sb_2p; 465 u32 conn_flags; 466 u32 two_primaries; 467 468 /* Since protocol version 87 and higher. */ 469 char integrity_alg[0]; 470 471 } __packed; 472 473 struct p_uuids { 474 struct p_header head; 475 u64 uuid[UI_EXTENDED_SIZE]; 476 } __packed; 477 478 struct p_rs_uuid { 479 struct p_header head; 480 u64 uuid; 481 } __packed; 482 483 struct p_sizes { 484 struct p_header head; 485 u64 d_size; /* size of disk */ 486 u64 u_size; /* user requested size */ 487 u64 c_size; /* current exported size */ 488 u32 max_segment_size; /* Maximal size of a BIO */ 489 u16 queue_order_type; /* not yet implemented in DRBD*/ 490 u16 dds_flags; /* use enum dds_flags here. */ 491 } __packed; 492 493 struct p_state { 494 struct p_header head; 495 u32 state; 496 } __packed; 497 498 struct p_req_state { 499 struct p_header head; 500 u32 mask; 501 u32 val; 502 } __packed; 503 504 struct p_req_state_reply { 505 struct p_header head; 506 u32 retcode; 507 } __packed; 508 509 struct p_drbd06_param { 510 u64 size; 511 u32 state; 512 u32 blksize; 513 u32 protocol; 514 u32 version; 515 u32 gen_cnt[5]; 516 u32 bit_map_gen[5]; 517 } __packed; 518 519 struct p_discard { 520 struct p_header head; 521 u64 block_id; 522 u32 seq_num; 523 u32 pad; 524 } __packed; 525 526 /* Valid values for the encoding field. 527 * Bump proto version when changing this. */ 528 enum drbd_bitmap_code { 529 /* RLE_VLI_Bytes = 0, 530 * and other bit variants had been defined during 531 * algorithm evaluation. */ 532 RLE_VLI_Bits = 2, 533 }; 534 535 struct p_compressed_bm { 536 struct p_header head; 537 /* (encoding & 0x0f): actual encoding, see enum drbd_bitmap_code 538 * (encoding & 0x80): polarity (set/unset) of first runlength 539 * ((encoding >> 4) & 0x07): pad_bits, number of trailing zero bits 540 * used to pad up to head.length bytes 541 */ 542 u8 encoding; 543 544 u8 code[0]; 545 } __packed; 546 547 struct p_delay_probe { 548 struct p_header head; 549 u32 seq_num; /* sequence number to match the two probe packets */ 550 u32 offset; /* usecs the probe got sent after the reference time point */ 551 } __packed; 552 553 /* DCBP: Drbd Compressed Bitmap Packet ... */ 554 static inline enum drbd_bitmap_code 555 DCBP_get_code(struct p_compressed_bm *p) 556 { 557 return (enum drbd_bitmap_code)(p->encoding & 0x0f); 558 } 559 560 static inline void 561 DCBP_set_code(struct p_compressed_bm *p, enum drbd_bitmap_code code) 562 { 563 BUG_ON(code & ~0xf); 564 p->encoding = (p->encoding & ~0xf) | code; 565 } 566 567 static inline int 568 DCBP_get_start(struct p_compressed_bm *p) 569 { 570 return (p->encoding & 0x80) != 0; 571 } 572 573 static inline void 574 DCBP_set_start(struct p_compressed_bm *p, int set) 575 { 576 p->encoding = (p->encoding & ~0x80) | (set ? 0x80 : 0); 577 } 578 579 static inline int 580 DCBP_get_pad_bits(struct p_compressed_bm *p) 581 { 582 return (p->encoding >> 4) & 0x7; 583 } 584 585 static inline void 586 DCBP_set_pad_bits(struct p_compressed_bm *p, int n) 587 { 588 BUG_ON(n & ~0x7); 589 p->encoding = (p->encoding & (~0x7 << 4)) | (n << 4); 590 } 591 592 /* one bitmap packet, including the p_header, 593 * should fit within one _architecture independend_ page. 594 * so we need to use the fixed size 4KiB page size 595 * most architechtures have used for a long time. 596 */ 597 #define BM_PACKET_PAYLOAD_BYTES (4096 - sizeof(struct p_header)) 598 #define BM_PACKET_WORDS (BM_PACKET_PAYLOAD_BYTES/sizeof(long)) 599 #define BM_PACKET_VLI_BYTES_MAX (4096 - sizeof(struct p_compressed_bm)) 600 #if (PAGE_SIZE < 4096) 601 /* drbd_send_bitmap / receive_bitmap would break horribly */ 602 #error "PAGE_SIZE too small" 603 #endif 604 605 union p_polymorph { 606 struct p_header header; 607 struct p_handshake handshake; 608 struct p_data data; 609 struct p_block_ack block_ack; 610 struct p_barrier barrier; 611 struct p_barrier_ack barrier_ack; 612 struct p_rs_param_89 rs_param_89; 613 struct p_protocol protocol; 614 struct p_sizes sizes; 615 struct p_uuids uuids; 616 struct p_state state; 617 struct p_req_state req_state; 618 struct p_req_state_reply req_state_reply; 619 struct p_block_req block_req; 620 } __packed; 621 622 /**********************************************************************/ 623 enum drbd_thread_state { 624 None, 625 Running, 626 Exiting, 627 Restarting 628 }; 629 630 struct drbd_thread { 631 spinlock_t t_lock; 632 struct task_struct *task; 633 struct completion stop; 634 enum drbd_thread_state t_state; 635 int (*function) (struct drbd_thread *); 636 struct drbd_conf *mdev; 637 int reset_cpu_mask; 638 }; 639 640 static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi) 641 { 642 /* THINK testing the t_state seems to be uncritical in all cases 643 * (but thread_{start,stop}), so we can read it *without* the lock. 644 * --lge */ 645 646 smp_rmb(); 647 return thi->t_state; 648 } 649 650 651 /* 652 * Having this as the first member of a struct provides sort of "inheritance". 653 * "derived" structs can be "drbd_queue_work()"ed. 654 * The callback should know and cast back to the descendant struct. 655 * drbd_request and drbd_epoch_entry are descendants of drbd_work. 656 */ 657 struct drbd_work; 658 typedef int (*drbd_work_cb)(struct drbd_conf *, struct drbd_work *, int cancel); 659 struct drbd_work { 660 struct list_head list; 661 drbd_work_cb cb; 662 }; 663 664 struct drbd_tl_epoch; 665 struct drbd_request { 666 struct drbd_work w; 667 struct drbd_conf *mdev; 668 669 /* if local IO is not allowed, will be NULL. 670 * if local IO _is_ allowed, holds the locally submitted bio clone, 671 * or, after local IO completion, the ERR_PTR(error). 672 * see drbd_endio_pri(). */ 673 struct bio *private_bio; 674 675 struct hlist_node colision; 676 sector_t sector; 677 unsigned int size; 678 unsigned int epoch; /* barrier_nr */ 679 680 /* barrier_nr: used to check on "completion" whether this req was in 681 * the current epoch, and we therefore have to close it, 682 * starting a new epoch... 683 */ 684 685 /* up to here, the struct layout is identical to drbd_epoch_entry; 686 * we might be able to use that to our advantage... */ 687 688 struct list_head tl_requests; /* ring list in the transfer log */ 689 struct bio *master_bio; /* master bio pointer */ 690 unsigned long rq_state; /* see comments above _req_mod() */ 691 int seq_num; 692 unsigned long start_time; 693 }; 694 695 struct drbd_tl_epoch { 696 struct drbd_work w; 697 struct list_head requests; /* requests before */ 698 struct drbd_tl_epoch *next; /* pointer to the next barrier */ 699 unsigned int br_number; /* the barriers identifier. */ 700 int n_req; /* number of requests attached before this barrier */ 701 }; 702 703 struct drbd_request; 704 705 /* These Tl_epoch_entries may be in one of 6 lists: 706 active_ee .. data packet being written 707 sync_ee .. syncer block being written 708 done_ee .. block written, need to send P_WRITE_ACK 709 read_ee .. [RS]P_DATA_REQUEST being read 710 */ 711 712 struct drbd_epoch { 713 struct list_head list; 714 unsigned int barrier_nr; 715 atomic_t epoch_size; /* increased on every request added. */ 716 atomic_t active; /* increased on every req. added, and dec on every finished. */ 717 unsigned long flags; 718 }; 719 720 /* drbd_epoch flag bits */ 721 enum { 722 DE_BARRIER_IN_NEXT_EPOCH_ISSUED, 723 DE_BARRIER_IN_NEXT_EPOCH_DONE, 724 DE_CONTAINS_A_BARRIER, 725 DE_HAVE_BARRIER_NUMBER, 726 DE_IS_FINISHING, 727 }; 728 729 enum epoch_event { 730 EV_PUT, 731 EV_GOT_BARRIER_NR, 732 EV_BARRIER_DONE, 733 EV_BECAME_LAST, 734 EV_CLEANUP = 32, /* used as flag */ 735 }; 736 737 struct drbd_wq_barrier { 738 struct drbd_work w; 739 struct completion done; 740 }; 741 742 struct digest_info { 743 int digest_size; 744 void *digest; 745 }; 746 747 struct drbd_epoch_entry { 748 struct drbd_work w; 749 struct hlist_node colision; 750 struct drbd_epoch *epoch; 751 struct drbd_conf *mdev; 752 struct page *pages; 753 atomic_t pending_bios; 754 unsigned int size; 755 /* see comments on ee flag bits below */ 756 unsigned long flags; 757 sector_t sector; 758 u64 block_id; 759 }; 760 761 /* ee flag bits. 762 * While corresponding bios are in flight, the only modification will be 763 * set_bit WAS_ERROR, which has to be atomic. 764 * If no bios are in flight yet, or all have been completed, 765 * non-atomic modification to ee->flags is ok. 766 */ 767 enum { 768 __EE_CALL_AL_COMPLETE_IO, 769 __EE_MAY_SET_IN_SYNC, 770 771 /* This epoch entry closes an epoch using a barrier. 772 * On sucessful completion, the epoch is released, 773 * and the P_BARRIER_ACK send. */ 774 __EE_IS_BARRIER, 775 776 /* In case a barrier failed, 777 * we need to resubmit without the barrier flag. */ 778 __EE_RESUBMITTED, 779 780 /* we may have several bios per epoch entry. 781 * if any of those fail, we set this flag atomically 782 * from the endio callback */ 783 __EE_WAS_ERROR, 784 }; 785 #define EE_CALL_AL_COMPLETE_IO (1<<__EE_CALL_AL_COMPLETE_IO) 786 #define EE_MAY_SET_IN_SYNC (1<<__EE_MAY_SET_IN_SYNC) 787 #define EE_IS_BARRIER (1<<__EE_IS_BARRIER) 788 #define EE_RESUBMITTED (1<<__EE_RESUBMITTED) 789 #define EE_WAS_ERROR (1<<__EE_WAS_ERROR) 790 791 /* global flag bits */ 792 enum { 793 CREATE_BARRIER, /* next P_DATA is preceeded by a P_BARRIER */ 794 SIGNAL_ASENDER, /* whether asender wants to be interrupted */ 795 SEND_PING, /* whether asender should send a ping asap */ 796 797 STOP_SYNC_TIMER, /* tell timer to cancel itself */ 798 UNPLUG_QUEUED, /* only relevant with kernel 2.4 */ 799 UNPLUG_REMOTE, /* sending a "UnplugRemote" could help */ 800 MD_DIRTY, /* current uuids and flags not yet on disk */ 801 DISCARD_CONCURRENT, /* Set on one node, cleared on the peer! */ 802 USE_DEGR_WFC_T, /* degr-wfc-timeout instead of wfc-timeout. */ 803 CLUSTER_ST_CHANGE, /* Cluster wide state change going on... */ 804 CL_ST_CHG_SUCCESS, 805 CL_ST_CHG_FAIL, 806 CRASHED_PRIMARY, /* This node was a crashed primary. 807 * Gets cleared when the state.conn 808 * goes into C_CONNECTED state. */ 809 WRITE_BM_AFTER_RESYNC, /* A kmalloc() during resync failed */ 810 NO_BARRIER_SUPP, /* underlying block device doesn't implement barriers */ 811 CONSIDER_RESYNC, 812 813 MD_NO_BARRIER, /* meta data device does not support barriers, 814 so don't even try */ 815 SUSPEND_IO, /* suspend application io */ 816 BITMAP_IO, /* suspend application io; 817 once no more io in flight, start bitmap io */ 818 BITMAP_IO_QUEUED, /* Started bitmap IO */ 819 RESYNC_AFTER_NEG, /* Resync after online grow after the attach&negotiate finished. */ 820 NET_CONGESTED, /* The data socket is congested */ 821 822 CONFIG_PENDING, /* serialization of (re)configuration requests. 823 * if set, also prevents the device from dying */ 824 DEVICE_DYING, /* device became unconfigured, 825 * but worker thread is still handling the cleanup. 826 * reconfiguring (nl_disk_conf, nl_net_conf) is dissalowed, 827 * while this is set. */ 828 RESIZE_PENDING, /* Size change detected locally, waiting for the response from 829 * the peer, if it changed there as well. */ 830 CONN_DRY_RUN, /* Expect disconnect after resync handshake. */ 831 GOT_PING_ACK, /* set when we receive a ping_ack packet, misc wait gets woken */ 832 }; 833 834 struct drbd_bitmap; /* opaque for drbd_conf */ 835 836 /* TODO sort members for performance 837 * MAYBE group them further */ 838 839 /* THINK maybe we actually want to use the default "event/%s" worker threads 840 * or similar in linux 2.6, which uses per cpu data and threads. 841 * 842 * To be general, this might need a spin_lock member. 843 * For now, please use the mdev->req_lock to protect list_head, 844 * see drbd_queue_work below. 845 */ 846 struct drbd_work_queue { 847 struct list_head q; 848 struct semaphore s; /* producers up it, worker down()s it */ 849 spinlock_t q_lock; /* to protect the list. */ 850 }; 851 852 struct drbd_socket { 853 struct drbd_work_queue work; 854 struct mutex mutex; 855 struct socket *socket; 856 /* this way we get our 857 * send/receive buffers off the stack */ 858 union p_polymorph sbuf; 859 union p_polymorph rbuf; 860 }; 861 862 struct drbd_md { 863 u64 md_offset; /* sector offset to 'super' block */ 864 865 u64 la_size_sect; /* last agreed size, unit sectors */ 866 u64 uuid[UI_SIZE]; 867 u64 device_uuid; 868 u32 flags; 869 u32 md_size_sect; 870 871 s32 al_offset; /* signed relative sector offset to al area */ 872 s32 bm_offset; /* signed relative sector offset to bitmap */ 873 874 /* u32 al_nr_extents; important for restoring the AL 875 * is stored into sync_conf.al_extents, which in turn 876 * gets applied to act_log->nr_elements 877 */ 878 }; 879 880 /* for sync_conf and other types... */ 881 #define NL_PACKET(name, number, fields) struct name { fields }; 882 #define NL_INTEGER(pn,pr,member) int member; 883 #define NL_INT64(pn,pr,member) __u64 member; 884 #define NL_BIT(pn,pr,member) unsigned member:1; 885 #define NL_STRING(pn,pr,member,len) unsigned char member[len]; int member ## _len; 886 #include "linux/drbd_nl.h" 887 888 struct drbd_backing_dev { 889 struct block_device *backing_bdev; 890 struct block_device *md_bdev; 891 struct file *lo_file; 892 struct file *md_file; 893 struct drbd_md md; 894 struct disk_conf dc; /* The user provided config... */ 895 sector_t known_size; /* last known size of that backing device */ 896 }; 897 898 struct drbd_md_io { 899 struct drbd_conf *mdev; 900 struct completion event; 901 int error; 902 }; 903 904 struct bm_io_work { 905 struct drbd_work w; 906 char *why; 907 int (*io_fn)(struct drbd_conf *mdev); 908 void (*done)(struct drbd_conf *mdev, int rv); 909 }; 910 911 enum write_ordering_e { 912 WO_none, 913 WO_drain_io, 914 WO_bdev_flush, 915 WO_bio_barrier 916 }; 917 918 struct drbd_conf { 919 /* things that are stored as / read from meta data on disk */ 920 unsigned long flags; 921 922 /* configured by drbdsetup */ 923 struct net_conf *net_conf; /* protected by get_net_conf() and put_net_conf() */ 924 struct syncer_conf sync_conf; 925 struct drbd_backing_dev *ldev __protected_by(local); 926 927 sector_t p_size; /* partner's disk size */ 928 struct request_queue *rq_queue; 929 struct block_device *this_bdev; 930 struct gendisk *vdisk; 931 932 struct drbd_socket data; /* data/barrier/cstate/parameter packets */ 933 struct drbd_socket meta; /* ping/ack (metadata) packets */ 934 int agreed_pro_version; /* actually used protocol version */ 935 unsigned long last_received; /* in jiffies, either socket */ 936 unsigned int ko_count; 937 struct drbd_work resync_work, 938 unplug_work, 939 md_sync_work; 940 struct timer_list resync_timer; 941 struct timer_list md_sync_timer; 942 943 /* Used after attach while negotiating new disk state. */ 944 union drbd_state new_state_tmp; 945 946 union drbd_state state; 947 wait_queue_head_t misc_wait; 948 wait_queue_head_t state_wait; /* upon each state change. */ 949 unsigned int send_cnt; 950 unsigned int recv_cnt; 951 unsigned int read_cnt; 952 unsigned int writ_cnt; 953 unsigned int al_writ_cnt; 954 unsigned int bm_writ_cnt; 955 atomic_t ap_bio_cnt; /* Requests we need to complete */ 956 atomic_t ap_pending_cnt; /* AP data packets on the wire, ack expected */ 957 atomic_t rs_pending_cnt; /* RS request/data packets on the wire */ 958 atomic_t unacked_cnt; /* Need to send replys for */ 959 atomic_t local_cnt; /* Waiting for local completion */ 960 atomic_t net_cnt; /* Users of net_conf */ 961 spinlock_t req_lock; 962 struct drbd_tl_epoch *unused_spare_tle; /* for pre-allocation */ 963 struct drbd_tl_epoch *newest_tle; 964 struct drbd_tl_epoch *oldest_tle; 965 struct list_head out_of_sequence_requests; 966 struct hlist_head *tl_hash; 967 unsigned int tl_hash_s; 968 969 /* blocks to sync in this run [unit BM_BLOCK_SIZE] */ 970 unsigned long rs_total; 971 /* number of sync IOs that failed in this run */ 972 unsigned long rs_failed; 973 /* Syncer's start time [unit jiffies] */ 974 unsigned long rs_start; 975 /* cumulated time in PausedSyncX state [unit jiffies] */ 976 unsigned long rs_paused; 977 /* block not up-to-date at mark [unit BM_BLOCK_SIZE] */ 978 unsigned long rs_mark_left; 979 /* marks's time [unit jiffies] */ 980 unsigned long rs_mark_time; 981 /* skipped because csum was equeal [unit BM_BLOCK_SIZE] */ 982 unsigned long rs_same_csum; 983 984 /* where does the admin want us to start? (sector) */ 985 sector_t ov_start_sector; 986 /* where are we now? (sector) */ 987 sector_t ov_position; 988 /* Start sector of out of sync range (to merge printk reporting). */ 989 sector_t ov_last_oos_start; 990 /* size of out-of-sync range in sectors. */ 991 sector_t ov_last_oos_size; 992 unsigned long ov_left; /* in bits */ 993 struct crypto_hash *csums_tfm; 994 struct crypto_hash *verify_tfm; 995 996 struct drbd_thread receiver; 997 struct drbd_thread worker; 998 struct drbd_thread asender; 999 struct drbd_bitmap *bitmap; 1000 unsigned long bm_resync_fo; /* bit offset for drbd_bm_find_next */ 1001 1002 /* Used to track operations of resync... */ 1003 struct lru_cache *resync; 1004 /* Number of locked elements in resync LRU */ 1005 unsigned int resync_locked; 1006 /* resync extent number waiting for application requests */ 1007 unsigned int resync_wenr; 1008 1009 int open_cnt; 1010 u64 *p_uuid; 1011 struct drbd_epoch *current_epoch; 1012 spinlock_t epoch_lock; 1013 unsigned int epochs; 1014 enum write_ordering_e write_ordering; 1015 struct list_head active_ee; /* IO in progress */ 1016 struct list_head sync_ee; /* IO in progress */ 1017 struct list_head done_ee; /* send ack */ 1018 struct list_head read_ee; /* IO in progress */ 1019 struct list_head net_ee; /* zero-copy network send in progress */ 1020 struct hlist_head *ee_hash; /* is proteced by req_lock! */ 1021 unsigned int ee_hash_s; 1022 1023 /* this one is protected by ee_lock, single thread */ 1024 struct drbd_epoch_entry *last_write_w_barrier; 1025 1026 int next_barrier_nr; 1027 struct hlist_head *app_reads_hash; /* is proteced by req_lock */ 1028 struct list_head resync_reads; 1029 atomic_t pp_in_use; 1030 wait_queue_head_t ee_wait; 1031 struct page *md_io_page; /* one page buffer for md_io */ 1032 struct page *md_io_tmpp; /* for logical_block_size != 512 */ 1033 struct mutex md_io_mutex; /* protects the md_io_buffer */ 1034 spinlock_t al_lock; 1035 wait_queue_head_t al_wait; 1036 struct lru_cache *act_log; /* activity log */ 1037 unsigned int al_tr_number; 1038 int al_tr_cycle; 1039 int al_tr_pos; /* position of the next transaction in the journal */ 1040 struct crypto_hash *cram_hmac_tfm; 1041 struct crypto_hash *integrity_w_tfm; /* to be used by the worker thread */ 1042 struct crypto_hash *integrity_r_tfm; /* to be used by the receiver thread */ 1043 void *int_dig_out; 1044 void *int_dig_in; 1045 void *int_dig_vv; 1046 wait_queue_head_t seq_wait; 1047 atomic_t packet_seq; 1048 unsigned int peer_seq; 1049 spinlock_t peer_seq_lock; 1050 unsigned int minor; 1051 unsigned long comm_bm_set; /* communicated number of set bits. */ 1052 cpumask_var_t cpu_mask; 1053 struct bm_io_work bm_io_work; 1054 u64 ed_uuid; /* UUID of the exposed data */ 1055 struct mutex state_mutex; 1056 char congestion_reason; /* Why we where congested... */ 1057 }; 1058 1059 static inline struct drbd_conf *minor_to_mdev(unsigned int minor) 1060 { 1061 struct drbd_conf *mdev; 1062 1063 mdev = minor < minor_count ? minor_table[minor] : NULL; 1064 1065 return mdev; 1066 } 1067 1068 static inline unsigned int mdev_to_minor(struct drbd_conf *mdev) 1069 { 1070 return mdev->minor; 1071 } 1072 1073 /* returns 1 if it was successfull, 1074 * returns 0 if there was no data socket. 1075 * so wherever you are going to use the data.socket, e.g. do 1076 * if (!drbd_get_data_sock(mdev)) 1077 * return 0; 1078 * CODE(); 1079 * drbd_put_data_sock(mdev); 1080 */ 1081 static inline int drbd_get_data_sock(struct drbd_conf *mdev) 1082 { 1083 mutex_lock(&mdev->data.mutex); 1084 /* drbd_disconnect() could have called drbd_free_sock() 1085 * while we were waiting in down()... */ 1086 if (unlikely(mdev->data.socket == NULL)) { 1087 mutex_unlock(&mdev->data.mutex); 1088 return 0; 1089 } 1090 return 1; 1091 } 1092 1093 static inline void drbd_put_data_sock(struct drbd_conf *mdev) 1094 { 1095 mutex_unlock(&mdev->data.mutex); 1096 } 1097 1098 /* 1099 * function declarations 1100 *************************/ 1101 1102 /* drbd_main.c */ 1103 1104 enum chg_state_flags { 1105 CS_HARD = 1, 1106 CS_VERBOSE = 2, 1107 CS_WAIT_COMPLETE = 4, 1108 CS_SERIALIZE = 8, 1109 CS_ORDERED = CS_WAIT_COMPLETE + CS_SERIALIZE, 1110 }; 1111 1112 enum dds_flags { 1113 DDSF_FORCED = 1, 1114 DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */ 1115 }; 1116 1117 extern void drbd_init_set_defaults(struct drbd_conf *mdev); 1118 extern int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f, 1119 union drbd_state mask, union drbd_state val); 1120 extern void drbd_force_state(struct drbd_conf *, union drbd_state, 1121 union drbd_state); 1122 extern int _drbd_request_state(struct drbd_conf *, union drbd_state, 1123 union drbd_state, enum chg_state_flags); 1124 extern int __drbd_set_state(struct drbd_conf *, union drbd_state, 1125 enum chg_state_flags, struct completion *done); 1126 extern void print_st_err(struct drbd_conf *, union drbd_state, 1127 union drbd_state, int); 1128 extern int drbd_thread_start(struct drbd_thread *thi); 1129 extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait); 1130 #ifdef CONFIG_SMP 1131 extern void drbd_thread_current_set_cpu(struct drbd_conf *mdev); 1132 extern void drbd_calc_cpu_mask(struct drbd_conf *mdev); 1133 #else 1134 #define drbd_thread_current_set_cpu(A) ({}) 1135 #define drbd_calc_cpu_mask(A) ({}) 1136 #endif 1137 extern void drbd_free_resources(struct drbd_conf *mdev); 1138 extern void tl_release(struct drbd_conf *mdev, unsigned int barrier_nr, 1139 unsigned int set_size); 1140 extern void tl_clear(struct drbd_conf *mdev); 1141 extern void _tl_add_barrier(struct drbd_conf *, struct drbd_tl_epoch *); 1142 extern void drbd_free_sock(struct drbd_conf *mdev); 1143 extern int drbd_send(struct drbd_conf *mdev, struct socket *sock, 1144 void *buf, size_t size, unsigned msg_flags); 1145 extern int drbd_send_protocol(struct drbd_conf *mdev); 1146 extern int drbd_send_uuids(struct drbd_conf *mdev); 1147 extern int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev); 1148 extern int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val); 1149 extern int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags); 1150 extern int _drbd_send_state(struct drbd_conf *mdev); 1151 extern int drbd_send_state(struct drbd_conf *mdev); 1152 extern int _drbd_send_cmd(struct drbd_conf *mdev, struct socket *sock, 1153 enum drbd_packets cmd, struct p_header *h, 1154 size_t size, unsigned msg_flags); 1155 #define USE_DATA_SOCKET 1 1156 #define USE_META_SOCKET 0 1157 extern int drbd_send_cmd(struct drbd_conf *mdev, int use_data_socket, 1158 enum drbd_packets cmd, struct p_header *h, 1159 size_t size); 1160 extern int drbd_send_cmd2(struct drbd_conf *mdev, enum drbd_packets cmd, 1161 char *data, size_t size); 1162 extern int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc); 1163 extern int drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, 1164 u32 set_size); 1165 extern int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packets cmd, 1166 struct drbd_epoch_entry *e); 1167 extern int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packets cmd, 1168 struct p_block_req *rp); 1169 extern int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packets cmd, 1170 struct p_data *dp); 1171 extern int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packets cmd, 1172 sector_t sector, int blksize, u64 block_id); 1173 extern int drbd_send_block(struct drbd_conf *mdev, enum drbd_packets cmd, 1174 struct drbd_epoch_entry *e); 1175 extern int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req); 1176 extern int _drbd_send_barrier(struct drbd_conf *mdev, 1177 struct drbd_tl_epoch *barrier); 1178 extern int drbd_send_drequest(struct drbd_conf *mdev, int cmd, 1179 sector_t sector, int size, u64 block_id); 1180 extern int drbd_send_drequest_csum(struct drbd_conf *mdev, 1181 sector_t sector,int size, 1182 void *digest, int digest_size, 1183 enum drbd_packets cmd); 1184 extern int drbd_send_ov_request(struct drbd_conf *mdev,sector_t sector,int size); 1185 1186 extern int drbd_send_bitmap(struct drbd_conf *mdev); 1187 extern int _drbd_send_bitmap(struct drbd_conf *mdev); 1188 extern int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode); 1189 extern void drbd_free_bc(struct drbd_backing_dev *ldev); 1190 extern void drbd_mdev_cleanup(struct drbd_conf *mdev); 1191 1192 /* drbd_meta-data.c (still in drbd_main.c) */ 1193 extern void drbd_md_sync(struct drbd_conf *mdev); 1194 extern int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev); 1195 /* maybe define them below as inline? */ 1196 extern void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local); 1197 extern void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local); 1198 extern void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local); 1199 extern void _drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local); 1200 extern void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local); 1201 extern void drbd_md_set_flag(struct drbd_conf *mdev, int flags) __must_hold(local); 1202 extern void drbd_md_clear_flag(struct drbd_conf *mdev, int flags)__must_hold(local); 1203 extern int drbd_md_test_flag(struct drbd_backing_dev *, int); 1204 extern void drbd_md_mark_dirty(struct drbd_conf *mdev); 1205 extern void drbd_queue_bitmap_io(struct drbd_conf *mdev, 1206 int (*io_fn)(struct drbd_conf *), 1207 void (*done)(struct drbd_conf *, int), 1208 char *why); 1209 extern int drbd_bmio_set_n_write(struct drbd_conf *mdev); 1210 extern int drbd_bmio_clear_n_write(struct drbd_conf *mdev); 1211 extern int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *), char *why); 1212 1213 1214 /* Meta data layout 1215 We reserve a 128MB Block (4k aligned) 1216 * either at the end of the backing device 1217 * or on a separate meta data device. */ 1218 1219 #define MD_RESERVED_SECT (128LU << 11) /* 128 MB, unit sectors */ 1220 /* The following numbers are sectors */ 1221 #define MD_AL_OFFSET 8 /* 8 Sectors after start of meta area */ 1222 #define MD_AL_MAX_SIZE 64 /* = 32 kb LOG ~ 3776 extents ~ 14 GB Storage */ 1223 /* Allows up to about 3.8TB */ 1224 #define MD_BM_OFFSET (MD_AL_OFFSET + MD_AL_MAX_SIZE) 1225 1226 /* Since the smalles IO unit is usually 512 byte */ 1227 #define MD_SECTOR_SHIFT 9 1228 #define MD_SECTOR_SIZE (1<<MD_SECTOR_SHIFT) 1229 1230 /* activity log */ 1231 #define AL_EXTENTS_PT ((MD_SECTOR_SIZE-12)/8-1) /* 61 ; Extents per 512B sector */ 1232 #define AL_EXTENT_SHIFT 22 /* One extent represents 4M Storage */ 1233 #define AL_EXTENT_SIZE (1<<AL_EXTENT_SHIFT) 1234 1235 #if BITS_PER_LONG == 32 1236 #define LN2_BPL 5 1237 #define cpu_to_lel(A) cpu_to_le32(A) 1238 #define lel_to_cpu(A) le32_to_cpu(A) 1239 #elif BITS_PER_LONG == 64 1240 #define LN2_BPL 6 1241 #define cpu_to_lel(A) cpu_to_le64(A) 1242 #define lel_to_cpu(A) le64_to_cpu(A) 1243 #else 1244 #error "LN2 of BITS_PER_LONG unknown!" 1245 #endif 1246 1247 /* resync bitmap */ 1248 /* 16MB sized 'bitmap extent' to track syncer usage */ 1249 struct bm_extent { 1250 int rs_left; /* number of bits set (out of sync) in this extent. */ 1251 int rs_failed; /* number of failed resync requests in this extent. */ 1252 unsigned long flags; 1253 struct lc_element lce; 1254 }; 1255 1256 #define BME_NO_WRITES 0 /* bm_extent.flags: no more requests on this one! */ 1257 #define BME_LOCKED 1 /* bm_extent.flags: syncer active on this one. */ 1258 1259 /* drbd_bitmap.c */ 1260 /* 1261 * We need to store one bit for a block. 1262 * Example: 1GB disk @ 4096 byte blocks ==> we need 32 KB bitmap. 1263 * Bit 0 ==> local node thinks this block is binary identical on both nodes 1264 * Bit 1 ==> local node thinks this block needs to be synced. 1265 */ 1266 1267 #define BM_BLOCK_SHIFT 12 /* 4k per bit */ 1268 #define BM_BLOCK_SIZE (1<<BM_BLOCK_SHIFT) 1269 /* (9+3) : 512 bytes @ 8 bits; representing 16M storage 1270 * per sector of on disk bitmap */ 1271 #define BM_EXT_SHIFT (BM_BLOCK_SHIFT + MD_SECTOR_SHIFT + 3) /* = 24 */ 1272 #define BM_EXT_SIZE (1<<BM_EXT_SHIFT) 1273 1274 #if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12) 1275 #error "HAVE YOU FIXED drbdmeta AS WELL??" 1276 #endif 1277 1278 /* thus many _storage_ sectors are described by one bit */ 1279 #define BM_SECT_TO_BIT(x) ((x)>>(BM_BLOCK_SHIFT-9)) 1280 #define BM_BIT_TO_SECT(x) ((sector_t)(x)<<(BM_BLOCK_SHIFT-9)) 1281 #define BM_SECT_PER_BIT BM_BIT_TO_SECT(1) 1282 1283 /* bit to represented kilo byte conversion */ 1284 #define Bit2KB(bits) ((bits)<<(BM_BLOCK_SHIFT-10)) 1285 1286 /* in which _bitmap_ extent (resp. sector) the bit for a certain 1287 * _storage_ sector is located in */ 1288 #define BM_SECT_TO_EXT(x) ((x)>>(BM_EXT_SHIFT-9)) 1289 1290 /* how much _storage_ sectors we have per bitmap sector */ 1291 #define BM_EXT_TO_SECT(x) ((sector_t)(x) << (BM_EXT_SHIFT-9)) 1292 #define BM_SECT_PER_EXT BM_EXT_TO_SECT(1) 1293 1294 /* in one sector of the bitmap, we have this many activity_log extents. */ 1295 #define AL_EXT_PER_BM_SECT (1 << (BM_EXT_SHIFT - AL_EXTENT_SHIFT)) 1296 #define BM_WORDS_PER_AL_EXT (1 << (AL_EXTENT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL)) 1297 1298 #define BM_BLOCKS_PER_BM_EXT_B (BM_EXT_SHIFT - BM_BLOCK_SHIFT) 1299 #define BM_BLOCKS_PER_BM_EXT_MASK ((1<<BM_BLOCKS_PER_BM_EXT_B) - 1) 1300 1301 /* the extent in "PER_EXTENT" below is an activity log extent 1302 * we need that many (long words/bytes) to store the bitmap 1303 * of one AL_EXTENT_SIZE chunk of storage. 1304 * we can store the bitmap for that many AL_EXTENTS within 1305 * one sector of the _on_disk_ bitmap: 1306 * bit 0 bit 37 bit 38 bit (512*8)-1 1307 * ...|........|........|.. // ..|........| 1308 * sect. 0 `296 `304 ^(512*8*8)-1 1309 * 1310 #define BM_WORDS_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / BITS_PER_LONG ) 1311 #define BM_BYTES_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / 8 ) // 128 1312 #define BM_EXT_PER_SECT ( 512 / BM_BYTES_PER_EXTENT ) // 4 1313 */ 1314 1315 #define DRBD_MAX_SECTORS_32 (0xffffffffLU) 1316 #define DRBD_MAX_SECTORS_BM \ 1317 ((MD_RESERVED_SECT - MD_BM_OFFSET) * (1LL<<(BM_EXT_SHIFT-9))) 1318 #if DRBD_MAX_SECTORS_BM < DRBD_MAX_SECTORS_32 1319 #define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_BM 1320 #define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_BM 1321 #elif !defined(CONFIG_LBDAF) && BITS_PER_LONG == 32 1322 #define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_32 1323 #define DRBD_MAX_SECTORS_FLEX DRBD_MAX_SECTORS_32 1324 #else 1325 #define DRBD_MAX_SECTORS DRBD_MAX_SECTORS_BM 1326 /* 16 TB in units of sectors */ 1327 #if BITS_PER_LONG == 32 1328 /* adjust by one page worth of bitmap, 1329 * so we won't wrap around in drbd_bm_find_next_bit. 1330 * you should use 64bit OS for that much storage, anyways. */ 1331 #define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0xffff7fff) 1332 #else 1333 #define DRBD_MAX_SECTORS_FLEX BM_BIT_TO_SECT(0x1LU << 32) 1334 #endif 1335 #endif 1336 1337 /* Sector shift value for the "hash" functions of tl_hash and ee_hash tables. 1338 * With a value of 6 all IO in one 32K block make it to the same slot of the 1339 * hash table. */ 1340 #define HT_SHIFT 6 1341 #define DRBD_MAX_SEGMENT_SIZE (1U<<(9+HT_SHIFT)) 1342 1343 /* Number of elements in the app_reads_hash */ 1344 #define APP_R_HSIZE 15 1345 1346 extern int drbd_bm_init(struct drbd_conf *mdev); 1347 extern int drbd_bm_resize(struct drbd_conf *mdev, sector_t sectors, int set_new_bits); 1348 extern void drbd_bm_cleanup(struct drbd_conf *mdev); 1349 extern void drbd_bm_set_all(struct drbd_conf *mdev); 1350 extern void drbd_bm_clear_all(struct drbd_conf *mdev); 1351 extern int drbd_bm_set_bits( 1352 struct drbd_conf *mdev, unsigned long s, unsigned long e); 1353 extern int drbd_bm_clear_bits( 1354 struct drbd_conf *mdev, unsigned long s, unsigned long e); 1355 /* bm_set_bits variant for use while holding drbd_bm_lock */ 1356 extern void _drbd_bm_set_bits(struct drbd_conf *mdev, 1357 const unsigned long s, const unsigned long e); 1358 extern int drbd_bm_test_bit(struct drbd_conf *mdev, unsigned long bitnr); 1359 extern int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr); 1360 extern int drbd_bm_write_sect(struct drbd_conf *mdev, unsigned long enr) __must_hold(local); 1361 extern int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local); 1362 extern int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local); 1363 extern unsigned long drbd_bm_ALe_set_all(struct drbd_conf *mdev, 1364 unsigned long al_enr); 1365 extern size_t drbd_bm_words(struct drbd_conf *mdev); 1366 extern unsigned long drbd_bm_bits(struct drbd_conf *mdev); 1367 extern sector_t drbd_bm_capacity(struct drbd_conf *mdev); 1368 extern unsigned long drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo); 1369 /* bm_find_next variants for use while you hold drbd_bm_lock() */ 1370 extern unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo); 1371 extern unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo); 1372 extern unsigned long drbd_bm_total_weight(struct drbd_conf *mdev); 1373 extern int drbd_bm_rs_done(struct drbd_conf *mdev); 1374 /* for receive_bitmap */ 1375 extern void drbd_bm_merge_lel(struct drbd_conf *mdev, size_t offset, 1376 size_t number, unsigned long *buffer); 1377 /* for _drbd_send_bitmap and drbd_bm_write_sect */ 1378 extern void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset, 1379 size_t number, unsigned long *buffer); 1380 1381 extern void drbd_bm_lock(struct drbd_conf *mdev, char *why); 1382 extern void drbd_bm_unlock(struct drbd_conf *mdev); 1383 1384 extern int drbd_bm_count_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e); 1385 /* drbd_main.c */ 1386 1387 extern struct kmem_cache *drbd_request_cache; 1388 extern struct kmem_cache *drbd_ee_cache; /* epoch entries */ 1389 extern struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */ 1390 extern struct kmem_cache *drbd_al_ext_cache; /* activity log extents */ 1391 extern mempool_t *drbd_request_mempool; 1392 extern mempool_t *drbd_ee_mempool; 1393 1394 extern struct page *drbd_pp_pool; /* drbd's page pool */ 1395 extern spinlock_t drbd_pp_lock; 1396 extern int drbd_pp_vacant; 1397 extern wait_queue_head_t drbd_pp_wait; 1398 1399 extern rwlock_t global_state_lock; 1400 1401 extern struct drbd_conf *drbd_new_device(unsigned int minor); 1402 extern void drbd_free_mdev(struct drbd_conf *mdev); 1403 1404 extern int proc_details; 1405 1406 /* drbd_req */ 1407 extern int drbd_make_request_26(struct request_queue *q, struct bio *bio); 1408 extern int drbd_read_remote(struct drbd_conf *mdev, struct drbd_request *req); 1409 extern int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec); 1410 extern int is_valid_ar_handle(struct drbd_request *, sector_t); 1411 1412 1413 /* drbd_nl.c */ 1414 extern void drbd_suspend_io(struct drbd_conf *mdev); 1415 extern void drbd_resume_io(struct drbd_conf *mdev); 1416 extern char *ppsize(char *buf, unsigned long long size); 1417 extern sector_t drbd_new_dev_size(struct drbd_conf *, struct drbd_backing_dev *, int); 1418 enum determine_dev_size { dev_size_error = -1, unchanged = 0, shrunk = 1, grew = 2 }; 1419 extern enum determine_dev_size drbd_determin_dev_size(struct drbd_conf *, enum dds_flags) __must_hold(local); 1420 extern void resync_after_online_grow(struct drbd_conf *); 1421 extern void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int) __must_hold(local); 1422 extern int drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, 1423 int force); 1424 enum drbd_disk_state drbd_try_outdate_peer(struct drbd_conf *mdev); 1425 extern int drbd_khelper(struct drbd_conf *mdev, char *cmd); 1426 1427 /* drbd_worker.c */ 1428 extern int drbd_worker(struct drbd_thread *thi); 1429 extern int drbd_alter_sa(struct drbd_conf *mdev, int na); 1430 extern void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side); 1431 extern void resume_next_sg(struct drbd_conf *mdev); 1432 extern void suspend_other_sg(struct drbd_conf *mdev); 1433 extern int drbd_resync_finished(struct drbd_conf *mdev); 1434 /* maybe rather drbd_main.c ? */ 1435 extern int drbd_md_sync_page_io(struct drbd_conf *mdev, 1436 struct drbd_backing_dev *bdev, sector_t sector, int rw); 1437 extern void drbd_ov_oos_found(struct drbd_conf*, sector_t, int); 1438 1439 static inline void ov_oos_print(struct drbd_conf *mdev) 1440 { 1441 if (mdev->ov_last_oos_size) { 1442 dev_err(DEV, "Out of sync: start=%llu, size=%lu (sectors)\n", 1443 (unsigned long long)mdev->ov_last_oos_start, 1444 (unsigned long)mdev->ov_last_oos_size); 1445 } 1446 mdev->ov_last_oos_size=0; 1447 } 1448 1449 1450 extern void drbd_csum_bio(struct drbd_conf *, struct crypto_hash *, struct bio *, void *); 1451 extern void drbd_csum_ee(struct drbd_conf *, struct crypto_hash *, struct drbd_epoch_entry *, void *); 1452 /* worker callbacks */ 1453 extern int w_req_cancel_conflict(struct drbd_conf *, struct drbd_work *, int); 1454 extern int w_read_retry_remote(struct drbd_conf *, struct drbd_work *, int); 1455 extern int w_e_end_data_req(struct drbd_conf *, struct drbd_work *, int); 1456 extern int w_e_end_rsdata_req(struct drbd_conf *, struct drbd_work *, int); 1457 extern int w_e_end_csum_rs_req(struct drbd_conf *, struct drbd_work *, int); 1458 extern int w_e_end_ov_reply(struct drbd_conf *, struct drbd_work *, int); 1459 extern int w_e_end_ov_req(struct drbd_conf *, struct drbd_work *, int); 1460 extern int w_ov_finished(struct drbd_conf *, struct drbd_work *, int); 1461 extern int w_resync_inactive(struct drbd_conf *, struct drbd_work *, int); 1462 extern int w_resume_next_sg(struct drbd_conf *, struct drbd_work *, int); 1463 extern int w_send_write_hint(struct drbd_conf *, struct drbd_work *, int); 1464 extern int w_make_resync_request(struct drbd_conf *, struct drbd_work *, int); 1465 extern int w_send_dblock(struct drbd_conf *, struct drbd_work *, int); 1466 extern int w_send_barrier(struct drbd_conf *, struct drbd_work *, int); 1467 extern int w_send_read_req(struct drbd_conf *, struct drbd_work *, int); 1468 extern int w_prev_work_done(struct drbd_conf *, struct drbd_work *, int); 1469 extern int w_e_reissue(struct drbd_conf *, struct drbd_work *, int); 1470 1471 extern void resync_timer_fn(unsigned long data); 1472 1473 /* drbd_receiver.c */ 1474 extern int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, 1475 const unsigned rw, const int fault_type); 1476 extern int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list); 1477 extern struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev, 1478 u64 id, 1479 sector_t sector, 1480 unsigned int data_size, 1481 gfp_t gfp_mask) __must_hold(local); 1482 extern void drbd_free_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e); 1483 extern void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 1484 struct list_head *head); 1485 extern void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 1486 struct list_head *head); 1487 extern void drbd_set_recv_tcq(struct drbd_conf *mdev, int tcq_enabled); 1488 extern void _drbd_clear_done_ee(struct drbd_conf *mdev, struct list_head *to_be_freed); 1489 extern void drbd_flush_workqueue(struct drbd_conf *mdev); 1490 1491 /* yes, there is kernel_setsockopt, but only since 2.6.18. we don't need to 1492 * mess with get_fs/set_fs, we know we are KERNEL_DS always. */ 1493 static inline int drbd_setsockopt(struct socket *sock, int level, int optname, 1494 char __user *optval, int optlen) 1495 { 1496 int err; 1497 if (level == SOL_SOCKET) 1498 err = sock_setsockopt(sock, level, optname, optval, optlen); 1499 else 1500 err = sock->ops->setsockopt(sock, level, optname, optval, 1501 optlen); 1502 return err; 1503 } 1504 1505 static inline void drbd_tcp_cork(struct socket *sock) 1506 { 1507 int __user val = 1; 1508 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK, 1509 (char __user *)&val, sizeof(val)); 1510 } 1511 1512 static inline void drbd_tcp_uncork(struct socket *sock) 1513 { 1514 int __user val = 0; 1515 (void) drbd_setsockopt(sock, SOL_TCP, TCP_CORK, 1516 (char __user *)&val, sizeof(val)); 1517 } 1518 1519 static inline void drbd_tcp_nodelay(struct socket *sock) 1520 { 1521 int __user val = 1; 1522 (void) drbd_setsockopt(sock, SOL_TCP, TCP_NODELAY, 1523 (char __user *)&val, sizeof(val)); 1524 } 1525 1526 static inline void drbd_tcp_quickack(struct socket *sock) 1527 { 1528 int __user val = 2; 1529 (void) drbd_setsockopt(sock, SOL_TCP, TCP_QUICKACK, 1530 (char __user *)&val, sizeof(val)); 1531 } 1532 1533 void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo); 1534 1535 /* drbd_proc.c */ 1536 extern struct proc_dir_entry *drbd_proc; 1537 extern const struct file_operations drbd_proc_fops; 1538 extern const char *drbd_conn_str(enum drbd_conns s); 1539 extern const char *drbd_role_str(enum drbd_role s); 1540 1541 /* drbd_actlog.c */ 1542 extern void drbd_al_begin_io(struct drbd_conf *mdev, sector_t sector); 1543 extern void drbd_al_complete_io(struct drbd_conf *mdev, sector_t sector); 1544 extern void drbd_rs_complete_io(struct drbd_conf *mdev, sector_t sector); 1545 extern int drbd_rs_begin_io(struct drbd_conf *mdev, sector_t sector); 1546 extern int drbd_try_rs_begin_io(struct drbd_conf *mdev, sector_t sector); 1547 extern void drbd_rs_cancel_all(struct drbd_conf *mdev); 1548 extern int drbd_rs_del_all(struct drbd_conf *mdev); 1549 extern void drbd_rs_failed_io(struct drbd_conf *mdev, 1550 sector_t sector, int size); 1551 extern int drbd_al_read_log(struct drbd_conf *mdev, struct drbd_backing_dev *); 1552 extern void __drbd_set_in_sync(struct drbd_conf *mdev, sector_t sector, 1553 int size, const char *file, const unsigned int line); 1554 #define drbd_set_in_sync(mdev, sector, size) \ 1555 __drbd_set_in_sync(mdev, sector, size, __FILE__, __LINE__) 1556 extern void __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector, 1557 int size, const char *file, const unsigned int line); 1558 #define drbd_set_out_of_sync(mdev, sector, size) \ 1559 __drbd_set_out_of_sync(mdev, sector, size, __FILE__, __LINE__) 1560 extern void drbd_al_apply_to_bm(struct drbd_conf *mdev); 1561 extern void drbd_al_to_on_disk_bm(struct drbd_conf *mdev); 1562 extern void drbd_al_shrink(struct drbd_conf *mdev); 1563 1564 1565 /* drbd_nl.c */ 1566 1567 void drbd_nl_cleanup(void); 1568 int __init drbd_nl_init(void); 1569 void drbd_bcast_state(struct drbd_conf *mdev, union drbd_state); 1570 void drbd_bcast_sync_progress(struct drbd_conf *mdev); 1571 void drbd_bcast_ee(struct drbd_conf *mdev, 1572 const char *reason, const int dgs, 1573 const char* seen_hash, const char* calc_hash, 1574 const struct drbd_epoch_entry* e); 1575 1576 1577 /** 1578 * DOC: DRBD State macros 1579 * 1580 * These macros are used to express state changes in easily readable form. 1581 * 1582 * The NS macros expand to a mask and a value, that can be bit ored onto the 1583 * current state as soon as the spinlock (req_lock) was taken. 1584 * 1585 * The _NS macros are used for state functions that get called with the 1586 * spinlock. These macros expand directly to the new state value. 1587 * 1588 * Besides the basic forms NS() and _NS() additional _?NS[23] are defined 1589 * to express state changes that affect more than one aspect of the state. 1590 * 1591 * E.g. NS2(conn, C_CONNECTED, peer, R_SECONDARY) 1592 * Means that the network connection was established and that the peer 1593 * is in secondary role. 1594 */ 1595 #define role_MASK R_MASK 1596 #define peer_MASK R_MASK 1597 #define disk_MASK D_MASK 1598 #define pdsk_MASK D_MASK 1599 #define conn_MASK C_MASK 1600 #define susp_MASK 1 1601 #define user_isp_MASK 1 1602 #define aftr_isp_MASK 1 1603 1604 #define NS(T, S) \ 1605 ({ union drbd_state mask; mask.i = 0; mask.T = T##_MASK; mask; }), \ 1606 ({ union drbd_state val; val.i = 0; val.T = (S); val; }) 1607 #define NS2(T1, S1, T2, S2) \ 1608 ({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \ 1609 mask.T2 = T2##_MASK; mask; }), \ 1610 ({ union drbd_state val; val.i = 0; val.T1 = (S1); \ 1611 val.T2 = (S2); val; }) 1612 #define NS3(T1, S1, T2, S2, T3, S3) \ 1613 ({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \ 1614 mask.T2 = T2##_MASK; mask.T3 = T3##_MASK; mask; }), \ 1615 ({ union drbd_state val; val.i = 0; val.T1 = (S1); \ 1616 val.T2 = (S2); val.T3 = (S3); val; }) 1617 1618 #define _NS(D, T, S) \ 1619 D, ({ union drbd_state __ns; __ns.i = D->state.i; __ns.T = (S); __ns; }) 1620 #define _NS2(D, T1, S1, T2, S2) \ 1621 D, ({ union drbd_state __ns; __ns.i = D->state.i; __ns.T1 = (S1); \ 1622 __ns.T2 = (S2); __ns; }) 1623 #define _NS3(D, T1, S1, T2, S2, T3, S3) \ 1624 D, ({ union drbd_state __ns; __ns.i = D->state.i; __ns.T1 = (S1); \ 1625 __ns.T2 = (S2); __ns.T3 = (S3); __ns; }) 1626 1627 /* 1628 * inline helper functions 1629 *************************/ 1630 1631 /* see also page_chain_add and friends in drbd_receiver.c */ 1632 static inline struct page *page_chain_next(struct page *page) 1633 { 1634 return (struct page *)page_private(page); 1635 } 1636 #define page_chain_for_each(page) \ 1637 for (; page && ({ prefetch(page_chain_next(page)); 1; }); \ 1638 page = page_chain_next(page)) 1639 #define page_chain_for_each_safe(page, n) \ 1640 for (; page && ({ n = page_chain_next(page); 1; }); page = n) 1641 1642 static inline int drbd_bio_has_active_page(struct bio *bio) 1643 { 1644 struct bio_vec *bvec; 1645 int i; 1646 1647 __bio_for_each_segment(bvec, bio, i, 0) { 1648 if (page_count(bvec->bv_page) > 1) 1649 return 1; 1650 } 1651 1652 return 0; 1653 } 1654 1655 static inline int drbd_ee_has_active_page(struct drbd_epoch_entry *e) 1656 { 1657 struct page *page = e->pages; 1658 page_chain_for_each(page) { 1659 if (page_count(page) > 1) 1660 return 1; 1661 } 1662 return 0; 1663 } 1664 1665 1666 static inline void drbd_state_lock(struct drbd_conf *mdev) 1667 { 1668 wait_event(mdev->misc_wait, 1669 !test_and_set_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 1670 } 1671 1672 static inline void drbd_state_unlock(struct drbd_conf *mdev) 1673 { 1674 clear_bit(CLUSTER_ST_CHANGE, &mdev->flags); 1675 wake_up(&mdev->misc_wait); 1676 } 1677 1678 static inline int _drbd_set_state(struct drbd_conf *mdev, 1679 union drbd_state ns, enum chg_state_flags flags, 1680 struct completion *done) 1681 { 1682 int rv; 1683 1684 read_lock(&global_state_lock); 1685 rv = __drbd_set_state(mdev, ns, flags, done); 1686 read_unlock(&global_state_lock); 1687 1688 return rv; 1689 } 1690 1691 /** 1692 * drbd_request_state() - Reqest a state change 1693 * @mdev: DRBD device. 1694 * @mask: mask of state bits to change. 1695 * @val: value of new state bits. 1696 * 1697 * This is the most graceful way of requesting a state change. It is verbose 1698 * quite verbose in case the state change is not possible, and all those 1699 * state changes are globally serialized. 1700 */ 1701 static inline int drbd_request_state(struct drbd_conf *mdev, 1702 union drbd_state mask, 1703 union drbd_state val) 1704 { 1705 return _drbd_request_state(mdev, mask, val, CS_VERBOSE + CS_ORDERED); 1706 } 1707 1708 #define __drbd_chk_io_error(m,f) __drbd_chk_io_error_(m,f, __func__) 1709 static inline void __drbd_chk_io_error_(struct drbd_conf *mdev, int forcedetach, const char *where) 1710 { 1711 switch (mdev->ldev->dc.on_io_error) { 1712 case EP_PASS_ON: 1713 if (!forcedetach) { 1714 if (__ratelimit(&drbd_ratelimit_state)) 1715 dev_err(DEV, "Local IO failed in %s." 1716 "Passing error on...\n", where); 1717 break; 1718 } 1719 /* NOTE fall through to detach case if forcedetach set */ 1720 case EP_DETACH: 1721 case EP_CALL_HELPER: 1722 if (mdev->state.disk > D_FAILED) { 1723 _drbd_set_state(_NS(mdev, disk, D_FAILED), CS_HARD, NULL); 1724 dev_err(DEV, "Local IO failed in %s." 1725 "Detaching...\n", where); 1726 } 1727 break; 1728 } 1729 } 1730 1731 /** 1732 * drbd_chk_io_error: Handle the on_io_error setting, should be called from all io completion handlers 1733 * @mdev: DRBD device. 1734 * @error: Error code passed to the IO completion callback 1735 * @forcedetach: Force detach. I.e. the error happened while accessing the meta data 1736 * 1737 * See also drbd_main.c:after_state_ch() if (os.disk > D_FAILED && ns.disk == D_FAILED) 1738 */ 1739 #define drbd_chk_io_error(m,e,f) drbd_chk_io_error_(m,e,f, __func__) 1740 static inline void drbd_chk_io_error_(struct drbd_conf *mdev, 1741 int error, int forcedetach, const char *where) 1742 { 1743 if (error) { 1744 unsigned long flags; 1745 spin_lock_irqsave(&mdev->req_lock, flags); 1746 __drbd_chk_io_error_(mdev, forcedetach, where); 1747 spin_unlock_irqrestore(&mdev->req_lock, flags); 1748 } 1749 } 1750 1751 1752 /** 1753 * drbd_md_first_sector() - Returns the first sector number of the meta data area 1754 * @bdev: Meta data block device. 1755 * 1756 * BTW, for internal meta data, this happens to be the maximum capacity 1757 * we could agree upon with our peer node. 1758 */ 1759 static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev) 1760 { 1761 switch (bdev->dc.meta_dev_idx) { 1762 case DRBD_MD_INDEX_INTERNAL: 1763 case DRBD_MD_INDEX_FLEX_INT: 1764 return bdev->md.md_offset + bdev->md.bm_offset; 1765 case DRBD_MD_INDEX_FLEX_EXT: 1766 default: 1767 return bdev->md.md_offset; 1768 } 1769 } 1770 1771 /** 1772 * drbd_md_last_sector() - Return the last sector number of the meta data area 1773 * @bdev: Meta data block device. 1774 */ 1775 static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev) 1776 { 1777 switch (bdev->dc.meta_dev_idx) { 1778 case DRBD_MD_INDEX_INTERNAL: 1779 case DRBD_MD_INDEX_FLEX_INT: 1780 return bdev->md.md_offset + MD_AL_OFFSET - 1; 1781 case DRBD_MD_INDEX_FLEX_EXT: 1782 default: 1783 return bdev->md.md_offset + bdev->md.md_size_sect; 1784 } 1785 } 1786 1787 /* Returns the number of 512 byte sectors of the device */ 1788 static inline sector_t drbd_get_capacity(struct block_device *bdev) 1789 { 1790 /* return bdev ? get_capacity(bdev->bd_disk) : 0; */ 1791 return bdev ? bdev->bd_inode->i_size >> 9 : 0; 1792 } 1793 1794 /** 1795 * drbd_get_max_capacity() - Returns the capacity we announce to out peer 1796 * @bdev: Meta data block device. 1797 * 1798 * returns the capacity we announce to out peer. we clip ourselves at the 1799 * various MAX_SECTORS, because if we don't, current implementation will 1800 * oops sooner or later 1801 */ 1802 static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev) 1803 { 1804 sector_t s; 1805 switch (bdev->dc.meta_dev_idx) { 1806 case DRBD_MD_INDEX_INTERNAL: 1807 case DRBD_MD_INDEX_FLEX_INT: 1808 s = drbd_get_capacity(bdev->backing_bdev) 1809 ? min_t(sector_t, DRBD_MAX_SECTORS_FLEX, 1810 drbd_md_first_sector(bdev)) 1811 : 0; 1812 break; 1813 case DRBD_MD_INDEX_FLEX_EXT: 1814 s = min_t(sector_t, DRBD_MAX_SECTORS_FLEX, 1815 drbd_get_capacity(bdev->backing_bdev)); 1816 /* clip at maximum size the meta device can support */ 1817 s = min_t(sector_t, s, 1818 BM_EXT_TO_SECT(bdev->md.md_size_sect 1819 - bdev->md.bm_offset)); 1820 break; 1821 default: 1822 s = min_t(sector_t, DRBD_MAX_SECTORS, 1823 drbd_get_capacity(bdev->backing_bdev)); 1824 } 1825 return s; 1826 } 1827 1828 /** 1829 * drbd_md_ss__() - Return the sector number of our meta data super block 1830 * @mdev: DRBD device. 1831 * @bdev: Meta data block device. 1832 */ 1833 static inline sector_t drbd_md_ss__(struct drbd_conf *mdev, 1834 struct drbd_backing_dev *bdev) 1835 { 1836 switch (bdev->dc.meta_dev_idx) { 1837 default: /* external, some index */ 1838 return MD_RESERVED_SECT * bdev->dc.meta_dev_idx; 1839 case DRBD_MD_INDEX_INTERNAL: 1840 /* with drbd08, internal meta data is always "flexible" */ 1841 case DRBD_MD_INDEX_FLEX_INT: 1842 /* sizeof(struct md_on_disk_07) == 4k 1843 * position: last 4k aligned block of 4k size */ 1844 if (!bdev->backing_bdev) { 1845 if (__ratelimit(&drbd_ratelimit_state)) { 1846 dev_err(DEV, "bdev->backing_bdev==NULL\n"); 1847 dump_stack(); 1848 } 1849 return 0; 1850 } 1851 return (drbd_get_capacity(bdev->backing_bdev) & ~7ULL) 1852 - MD_AL_OFFSET; 1853 case DRBD_MD_INDEX_FLEX_EXT: 1854 return 0; 1855 } 1856 } 1857 1858 static inline void 1859 _drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w) 1860 { 1861 list_add_tail(&w->list, &q->q); 1862 up(&q->s); 1863 } 1864 1865 static inline void 1866 drbd_queue_work_front(struct drbd_work_queue *q, struct drbd_work *w) 1867 { 1868 unsigned long flags; 1869 spin_lock_irqsave(&q->q_lock, flags); 1870 list_add(&w->list, &q->q); 1871 up(&q->s); /* within the spinlock, 1872 see comment near end of drbd_worker() */ 1873 spin_unlock_irqrestore(&q->q_lock, flags); 1874 } 1875 1876 static inline void 1877 drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w) 1878 { 1879 unsigned long flags; 1880 spin_lock_irqsave(&q->q_lock, flags); 1881 list_add_tail(&w->list, &q->q); 1882 up(&q->s); /* within the spinlock, 1883 see comment near end of drbd_worker() */ 1884 spin_unlock_irqrestore(&q->q_lock, flags); 1885 } 1886 1887 static inline void wake_asender(struct drbd_conf *mdev) 1888 { 1889 if (test_bit(SIGNAL_ASENDER, &mdev->flags)) 1890 force_sig(DRBD_SIG, mdev->asender.task); 1891 } 1892 1893 static inline void request_ping(struct drbd_conf *mdev) 1894 { 1895 set_bit(SEND_PING, &mdev->flags); 1896 wake_asender(mdev); 1897 } 1898 1899 static inline int drbd_send_short_cmd(struct drbd_conf *mdev, 1900 enum drbd_packets cmd) 1901 { 1902 struct p_header h; 1903 return drbd_send_cmd(mdev, USE_DATA_SOCKET, cmd, &h, sizeof(h)); 1904 } 1905 1906 static inline int drbd_send_ping(struct drbd_conf *mdev) 1907 { 1908 struct p_header h; 1909 return drbd_send_cmd(mdev, USE_META_SOCKET, P_PING, &h, sizeof(h)); 1910 } 1911 1912 static inline int drbd_send_ping_ack(struct drbd_conf *mdev) 1913 { 1914 struct p_header h; 1915 return drbd_send_cmd(mdev, USE_META_SOCKET, P_PING_ACK, &h, sizeof(h)); 1916 } 1917 1918 static inline void drbd_thread_stop(struct drbd_thread *thi) 1919 { 1920 _drbd_thread_stop(thi, FALSE, TRUE); 1921 } 1922 1923 static inline void drbd_thread_stop_nowait(struct drbd_thread *thi) 1924 { 1925 _drbd_thread_stop(thi, FALSE, FALSE); 1926 } 1927 1928 static inline void drbd_thread_restart_nowait(struct drbd_thread *thi) 1929 { 1930 _drbd_thread_stop(thi, TRUE, FALSE); 1931 } 1932 1933 /* counts how many answer packets packets we expect from our peer, 1934 * for either explicit application requests, 1935 * or implicit barrier packets as necessary. 1936 * increased: 1937 * w_send_barrier 1938 * _req_mod(req, queue_for_net_write or queue_for_net_read); 1939 * it is much easier and equally valid to count what we queue for the 1940 * worker, even before it actually was queued or send. 1941 * (drbd_make_request_common; recovery path on read io-error) 1942 * decreased: 1943 * got_BarrierAck (respective tl_clear, tl_clear_barrier) 1944 * _req_mod(req, data_received) 1945 * [from receive_DataReply] 1946 * _req_mod(req, write_acked_by_peer or recv_acked_by_peer or neg_acked) 1947 * [from got_BlockAck (P_WRITE_ACK, P_RECV_ACK)] 1948 * for some reason it is NOT decreased in got_NegAck, 1949 * but in the resulting cleanup code from report_params. 1950 * we should try to remember the reason for that... 1951 * _req_mod(req, send_failed or send_canceled) 1952 * _req_mod(req, connection_lost_while_pending) 1953 * [from tl_clear_barrier] 1954 */ 1955 static inline void inc_ap_pending(struct drbd_conf *mdev) 1956 { 1957 atomic_inc(&mdev->ap_pending_cnt); 1958 } 1959 1960 #define ERR_IF_CNT_IS_NEGATIVE(which) \ 1961 if (atomic_read(&mdev->which) < 0) \ 1962 dev_err(DEV, "in %s:%d: " #which " = %d < 0 !\n", \ 1963 __func__ , __LINE__ , \ 1964 atomic_read(&mdev->which)) 1965 1966 #define dec_ap_pending(mdev) do { \ 1967 typecheck(struct drbd_conf *, mdev); \ 1968 if (atomic_dec_and_test(&mdev->ap_pending_cnt)) \ 1969 wake_up(&mdev->misc_wait); \ 1970 ERR_IF_CNT_IS_NEGATIVE(ap_pending_cnt); } while (0) 1971 1972 /* counts how many resync-related answers we still expect from the peer 1973 * increase decrease 1974 * C_SYNC_TARGET sends P_RS_DATA_REQUEST (and expects P_RS_DATA_REPLY) 1975 * C_SYNC_SOURCE sends P_RS_DATA_REPLY (and expects P_WRITE_ACK whith ID_SYNCER) 1976 * (or P_NEG_ACK with ID_SYNCER) 1977 */ 1978 static inline void inc_rs_pending(struct drbd_conf *mdev) 1979 { 1980 atomic_inc(&mdev->rs_pending_cnt); 1981 } 1982 1983 #define dec_rs_pending(mdev) do { \ 1984 typecheck(struct drbd_conf *, mdev); \ 1985 atomic_dec(&mdev->rs_pending_cnt); \ 1986 ERR_IF_CNT_IS_NEGATIVE(rs_pending_cnt); } while (0) 1987 1988 /* counts how many answers we still need to send to the peer. 1989 * increased on 1990 * receive_Data unless protocol A; 1991 * we need to send a P_RECV_ACK (proto B) 1992 * or P_WRITE_ACK (proto C) 1993 * receive_RSDataReply (recv_resync_read) we need to send a P_WRITE_ACK 1994 * receive_DataRequest (receive_RSDataRequest) we need to send back P_DATA 1995 * receive_Barrier_* we need to send a P_BARRIER_ACK 1996 */ 1997 static inline void inc_unacked(struct drbd_conf *mdev) 1998 { 1999 atomic_inc(&mdev->unacked_cnt); 2000 } 2001 2002 #define dec_unacked(mdev) do { \ 2003 typecheck(struct drbd_conf *, mdev); \ 2004 atomic_dec(&mdev->unacked_cnt); \ 2005 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt); } while (0) 2006 2007 #define sub_unacked(mdev, n) do { \ 2008 typecheck(struct drbd_conf *, mdev); \ 2009 atomic_sub(n, &mdev->unacked_cnt); \ 2010 ERR_IF_CNT_IS_NEGATIVE(unacked_cnt); } while (0) 2011 2012 2013 static inline void put_net_conf(struct drbd_conf *mdev) 2014 { 2015 if (atomic_dec_and_test(&mdev->net_cnt)) 2016 wake_up(&mdev->misc_wait); 2017 } 2018 2019 /** 2020 * get_net_conf() - Increase ref count on mdev->net_conf; Returns 0 if nothing there 2021 * @mdev: DRBD device. 2022 * 2023 * You have to call put_net_conf() when finished working with mdev->net_conf. 2024 */ 2025 static inline int get_net_conf(struct drbd_conf *mdev) 2026 { 2027 int have_net_conf; 2028 2029 atomic_inc(&mdev->net_cnt); 2030 have_net_conf = mdev->state.conn >= C_UNCONNECTED; 2031 if (!have_net_conf) 2032 put_net_conf(mdev); 2033 return have_net_conf; 2034 } 2035 2036 /** 2037 * get_ldev() - Increase the ref count on mdev->ldev. Returns 0 if there is no ldev 2038 * @M: DRBD device. 2039 * 2040 * You have to call put_ldev() when finished working with mdev->ldev. 2041 */ 2042 #define get_ldev(M) __cond_lock(local, _get_ldev_if_state(M,D_INCONSISTENT)) 2043 #define get_ldev_if_state(M,MINS) __cond_lock(local, _get_ldev_if_state(M,MINS)) 2044 2045 static inline void put_ldev(struct drbd_conf *mdev) 2046 { 2047 __release(local); 2048 if (atomic_dec_and_test(&mdev->local_cnt)) 2049 wake_up(&mdev->misc_wait); 2050 D_ASSERT(atomic_read(&mdev->local_cnt) >= 0); 2051 } 2052 2053 #ifndef __CHECKER__ 2054 static inline int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins) 2055 { 2056 int io_allowed; 2057 2058 atomic_inc(&mdev->local_cnt); 2059 io_allowed = (mdev->state.disk >= mins); 2060 if (!io_allowed) 2061 put_ldev(mdev); 2062 return io_allowed; 2063 } 2064 #else 2065 extern int _get_ldev_if_state(struct drbd_conf *mdev, enum drbd_disk_state mins); 2066 #endif 2067 2068 /* you must have an "get_ldev" reference */ 2069 static inline void drbd_get_syncer_progress(struct drbd_conf *mdev, 2070 unsigned long *bits_left, unsigned int *per_mil_done) 2071 { 2072 /* 2073 * this is to break it at compile time when we change that 2074 * (we may feel 4TB maximum storage per drbd is not enough) 2075 */ 2076 typecheck(unsigned long, mdev->rs_total); 2077 2078 /* note: both rs_total and rs_left are in bits, i.e. in 2079 * units of BM_BLOCK_SIZE. 2080 * for the percentage, we don't care. */ 2081 2082 *bits_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 2083 /* >> 10 to prevent overflow, 2084 * +1 to prevent division by zero */ 2085 if (*bits_left > mdev->rs_total) { 2086 /* doh. maybe a logic bug somewhere. 2087 * may also be just a race condition 2088 * between this and a disconnect during sync. 2089 * for now, just prevent in-kernel buffer overflow. 2090 */ 2091 smp_rmb(); 2092 dev_warn(DEV, "cs:%s rs_left=%lu > rs_total=%lu (rs_failed %lu)\n", 2093 drbd_conn_str(mdev->state.conn), 2094 *bits_left, mdev->rs_total, mdev->rs_failed); 2095 *per_mil_done = 0; 2096 } else { 2097 /* make sure the calculation happens in long context */ 2098 unsigned long tmp = 1000UL - 2099 (*bits_left >> 10)*1000UL 2100 / ((mdev->rs_total >> 10) + 1UL); 2101 *per_mil_done = tmp; 2102 } 2103 } 2104 2105 2106 /* this throttles on-the-fly application requests 2107 * according to max_buffers settings; 2108 * maybe re-implement using semaphores? */ 2109 static inline int drbd_get_max_buffers(struct drbd_conf *mdev) 2110 { 2111 int mxb = 1000000; /* arbitrary limit on open requests */ 2112 if (get_net_conf(mdev)) { 2113 mxb = mdev->net_conf->max_buffers; 2114 put_net_conf(mdev); 2115 } 2116 return mxb; 2117 } 2118 2119 static inline int drbd_state_is_stable(union drbd_state s) 2120 { 2121 2122 /* DO NOT add a default clause, we want the compiler to warn us 2123 * for any newly introduced state we may have forgotten to add here */ 2124 2125 switch ((enum drbd_conns)s.conn) { 2126 /* new io only accepted when there is no connection, ... */ 2127 case C_STANDALONE: 2128 case C_WF_CONNECTION: 2129 /* ... or there is a well established connection. */ 2130 case C_CONNECTED: 2131 case C_SYNC_SOURCE: 2132 case C_SYNC_TARGET: 2133 case C_VERIFY_S: 2134 case C_VERIFY_T: 2135 case C_PAUSED_SYNC_S: 2136 case C_PAUSED_SYNC_T: 2137 /* maybe stable, look at the disk state */ 2138 break; 2139 2140 /* no new io accepted during tansitional states 2141 * like handshake or teardown */ 2142 case C_DISCONNECTING: 2143 case C_UNCONNECTED: 2144 case C_TIMEOUT: 2145 case C_BROKEN_PIPE: 2146 case C_NETWORK_FAILURE: 2147 case C_PROTOCOL_ERROR: 2148 case C_TEAR_DOWN: 2149 case C_WF_REPORT_PARAMS: 2150 case C_STARTING_SYNC_S: 2151 case C_STARTING_SYNC_T: 2152 case C_WF_BITMAP_S: 2153 case C_WF_BITMAP_T: 2154 case C_WF_SYNC_UUID: 2155 case C_MASK: 2156 /* not "stable" */ 2157 return 0; 2158 } 2159 2160 switch ((enum drbd_disk_state)s.disk) { 2161 case D_DISKLESS: 2162 case D_INCONSISTENT: 2163 case D_OUTDATED: 2164 case D_CONSISTENT: 2165 case D_UP_TO_DATE: 2166 /* disk state is stable as well. */ 2167 break; 2168 2169 /* no new io accepted during tansitional states */ 2170 case D_ATTACHING: 2171 case D_FAILED: 2172 case D_NEGOTIATING: 2173 case D_UNKNOWN: 2174 case D_MASK: 2175 /* not "stable" */ 2176 return 0; 2177 } 2178 2179 return 1; 2180 } 2181 2182 static inline int __inc_ap_bio_cond(struct drbd_conf *mdev) 2183 { 2184 int mxb = drbd_get_max_buffers(mdev); 2185 2186 if (mdev->state.susp) 2187 return 0; 2188 if (test_bit(SUSPEND_IO, &mdev->flags)) 2189 return 0; 2190 2191 /* to avoid potential deadlock or bitmap corruption, 2192 * in various places, we only allow new application io 2193 * to start during "stable" states. */ 2194 2195 /* no new io accepted when attaching or detaching the disk */ 2196 if (!drbd_state_is_stable(mdev->state)) 2197 return 0; 2198 2199 /* since some older kernels don't have atomic_add_unless, 2200 * and we are within the spinlock anyways, we have this workaround. */ 2201 if (atomic_read(&mdev->ap_bio_cnt) > mxb) 2202 return 0; 2203 if (test_bit(BITMAP_IO, &mdev->flags)) 2204 return 0; 2205 return 1; 2206 } 2207 2208 /* I'd like to use wait_event_lock_irq, 2209 * but I'm not sure when it got introduced, 2210 * and not sure when it has 3 or 4 arguments */ 2211 static inline void inc_ap_bio(struct drbd_conf *mdev, int count) 2212 { 2213 /* compare with after_state_ch, 2214 * os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S */ 2215 DEFINE_WAIT(wait); 2216 2217 /* we wait here 2218 * as long as the device is suspended 2219 * until the bitmap is no longer on the fly during connection 2220 * handshake as long as we would exeed the max_buffer limit. 2221 * 2222 * to avoid races with the reconnect code, 2223 * we need to atomic_inc within the spinlock. */ 2224 2225 spin_lock_irq(&mdev->req_lock); 2226 while (!__inc_ap_bio_cond(mdev)) { 2227 prepare_to_wait(&mdev->misc_wait, &wait, TASK_UNINTERRUPTIBLE); 2228 spin_unlock_irq(&mdev->req_lock); 2229 schedule(); 2230 finish_wait(&mdev->misc_wait, &wait); 2231 spin_lock_irq(&mdev->req_lock); 2232 } 2233 atomic_add(count, &mdev->ap_bio_cnt); 2234 spin_unlock_irq(&mdev->req_lock); 2235 } 2236 2237 static inline void dec_ap_bio(struct drbd_conf *mdev) 2238 { 2239 int mxb = drbd_get_max_buffers(mdev); 2240 int ap_bio = atomic_dec_return(&mdev->ap_bio_cnt); 2241 2242 D_ASSERT(ap_bio >= 0); 2243 /* this currently does wake_up for every dec_ap_bio! 2244 * maybe rather introduce some type of hysteresis? 2245 * e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */ 2246 if (ap_bio < mxb) 2247 wake_up(&mdev->misc_wait); 2248 if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) { 2249 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags)) 2250 drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w); 2251 } 2252 } 2253 2254 static inline void drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val) 2255 { 2256 mdev->ed_uuid = val; 2257 } 2258 2259 static inline int seq_cmp(u32 a, u32 b) 2260 { 2261 /* we assume wrap around at 32bit. 2262 * for wrap around at 24bit (old atomic_t), 2263 * we'd have to 2264 * a <<= 8; b <<= 8; 2265 */ 2266 return (s32)(a) - (s32)(b); 2267 } 2268 #define seq_lt(a, b) (seq_cmp((a), (b)) < 0) 2269 #define seq_gt(a, b) (seq_cmp((a), (b)) > 0) 2270 #define seq_ge(a, b) (seq_cmp((a), (b)) >= 0) 2271 #define seq_le(a, b) (seq_cmp((a), (b)) <= 0) 2272 /* CAUTION: please no side effects in arguments! */ 2273 #define seq_max(a, b) ((u32)(seq_gt((a), (b)) ? (a) : (b))) 2274 2275 static inline void update_peer_seq(struct drbd_conf *mdev, unsigned int new_seq) 2276 { 2277 unsigned int m; 2278 spin_lock(&mdev->peer_seq_lock); 2279 m = seq_max(mdev->peer_seq, new_seq); 2280 mdev->peer_seq = m; 2281 spin_unlock(&mdev->peer_seq_lock); 2282 if (m == new_seq) 2283 wake_up(&mdev->seq_wait); 2284 } 2285 2286 static inline void drbd_update_congested(struct drbd_conf *mdev) 2287 { 2288 struct sock *sk = mdev->data.socket->sk; 2289 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5) 2290 set_bit(NET_CONGESTED, &mdev->flags); 2291 } 2292 2293 static inline int drbd_queue_order_type(struct drbd_conf *mdev) 2294 { 2295 /* sorry, we currently have no working implementation 2296 * of distributed TCQ stuff */ 2297 #ifndef QUEUE_ORDERED_NONE 2298 #define QUEUE_ORDERED_NONE 0 2299 #endif 2300 return QUEUE_ORDERED_NONE; 2301 } 2302 2303 static inline void drbd_blk_run_queue(struct request_queue *q) 2304 { 2305 if (q && q->unplug_fn) 2306 q->unplug_fn(q); 2307 } 2308 2309 static inline void drbd_kick_lo(struct drbd_conf *mdev) 2310 { 2311 if (get_ldev(mdev)) { 2312 drbd_blk_run_queue(bdev_get_queue(mdev->ldev->backing_bdev)); 2313 put_ldev(mdev); 2314 } 2315 } 2316 2317 static inline void drbd_md_flush(struct drbd_conf *mdev) 2318 { 2319 int r; 2320 2321 if (test_bit(MD_NO_BARRIER, &mdev->flags)) 2322 return; 2323 2324 r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL, 2325 BLKDEV_IFL_WAIT); 2326 if (r) { 2327 set_bit(MD_NO_BARRIER, &mdev->flags); 2328 dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r); 2329 } 2330 } 2331 2332 #endif 2333