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 */ 61extern unsigned int minor_count; 62extern int disable_sendpage; 63extern int allow_oos; 64extern unsigned int cn_idx; 65 66#ifdef CONFIG_DRBD_FAULT_INJECTION 67extern int enable_faults; 68extern int fault_rate; 69extern int fault_devs; 70#endif 71 72extern 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 108struct 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 */ 125enum { 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 141extern unsigned int 142_drbd_insert_fault(struct drbd_conf *mdev, unsigned int type); 143static inline int 144drbd_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 164extern struct drbd_conf **minor_table; 165extern struct ratelimit_state drbd_ratelimit_state; 166 167/* on the wire */ 168enum 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 228static 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 */ 288struct 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 304extern void INFO_bm_xfer_stats(struct drbd_conf *mdev, 305 const char *direction, struct bm_xfer_ctx *c); 306 307static 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 */ 340struct 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 369struct 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 */ 385struct 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 394struct 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 411struct 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 426struct 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 432struct p_barrier_ack { 433 struct p_header head; 434 u32 barrier; 435 u32 set_size; 436} __packed; 437 438struct 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 446struct 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 454enum drbd_conn_flags { 455 CF_WANT_LOSE = 1, 456 CF_DRY_RUN = 2, 457}; 458 459struct 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 473struct p_uuids { 474 struct p_header head; 475 u64 uuid[UI_EXTENDED_SIZE]; 476} __packed; 477 478struct p_rs_uuid { 479 struct p_header head; 480 u64 uuid; 481} __packed; 482 483struct 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 493struct p_state { 494 struct p_header head; 495 u32 state; 496} __packed; 497 498struct p_req_state { 499 struct p_header head; 500 u32 mask; 501 u32 val; 502} __packed; 503 504struct p_req_state_reply { 505 struct p_header head; 506 u32 retcode; 507} __packed; 508 509struct 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 519struct 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. */ 528enum 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 535struct 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 547struct 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 ... */ 554static inline enum drbd_bitmap_code 555DCBP_get_code(struct p_compressed_bm *p) 556{ 557 return (enum drbd_bitmap_code)(p->encoding & 0x0f); 558} 559 560static inline void 561DCBP_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 567static inline int 568DCBP_get_start(struct p_compressed_bm *p) 569{ 570 return (p->encoding & 0x80) != 0; 571} 572 573static inline void 574DCBP_set_start(struct p_compressed_bm *p, int set) 575{ 576 p->encoding = (p->encoding & ~0x80) | (set ? 0x80 : 0); 577} 578 579static inline int 580DCBP_get_pad_bits(struct p_compressed_bm *p) 581{ 582 return (p->encoding >> 4) & 0x7; 583} 584 585static inline void 586DCBP_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 605union 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/**********************************************************************/ 623enum drbd_thread_state { 624 None, 625 Running, 626 Exiting, 627 Restarting 628}; 629 630struct 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 640static 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 */ 657struct drbd_work; 658typedef int (*drbd_work_cb)(struct drbd_conf *, struct drbd_work *, int cancel); 659struct drbd_work { 660 struct list_head list; 661 drbd_work_cb cb; 662}; 663 664struct drbd_tl_epoch; 665struct 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 695struct 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 703struct 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 712struct 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 */ 721enum { 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 729enum 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 737struct drbd_wq_barrier { 738 struct drbd_work w; 739 struct completion done; 740}; 741 742struct digest_info { 743 int digest_size; 744 void *digest; 745}; 746 747struct 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 */ 767enum { 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 */ 792enum { 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 834struct 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 */ 846struct 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 852struct 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 862struct 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 888struct 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 898struct drbd_md_io { 899 struct drbd_conf *mdev; 900 struct completion event; 901 int error; 902}; 903 904struct 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 911enum write_ordering_e { 912 WO_none, 913 WO_drain_io, 914 WO_bdev_flush, 915 WO_bio_barrier 916}; 917 918struct 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 1059static 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 1068static 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 */ 1081static 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 1093static 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 1104enum 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 1112enum dds_flags { 1113 DDSF_FORCED = 1, 1114 DDSF_NO_RESYNC = 2, /* Do not run a resync for the new space */ 1115}; 1116 1117extern void drbd_init_set_defaults(struct drbd_conf *mdev); 1118extern int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f, 1119 union drbd_state mask, union drbd_state val); 1120extern void drbd_force_state(struct drbd_conf *, union drbd_state, 1121 union drbd_state); 1122extern int _drbd_request_state(struct drbd_conf *, union drbd_state, 1123 union drbd_state, enum chg_state_flags); 1124extern int __drbd_set_state(struct drbd_conf *, union drbd_state, 1125 enum chg_state_flags, struct completion *done); 1126extern void print_st_err(struct drbd_conf *, union drbd_state, 1127 union drbd_state, int); 1128extern int drbd_thread_start(struct drbd_thread *thi); 1129extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait); 1130#ifdef CONFIG_SMP 1131extern void drbd_thread_current_set_cpu(struct drbd_conf *mdev); 1132extern 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 1137extern void drbd_free_resources(struct drbd_conf *mdev); 1138extern void tl_release(struct drbd_conf *mdev, unsigned int barrier_nr, 1139 unsigned int set_size); 1140extern void tl_clear(struct drbd_conf *mdev); 1141extern void _tl_add_barrier(struct drbd_conf *, struct drbd_tl_epoch *); 1142extern void drbd_free_sock(struct drbd_conf *mdev); 1143extern int drbd_send(struct drbd_conf *mdev, struct socket *sock, 1144 void *buf, size_t size, unsigned msg_flags); 1145extern int drbd_send_protocol(struct drbd_conf *mdev); 1146extern int drbd_send_uuids(struct drbd_conf *mdev); 1147extern int drbd_send_uuids_skip_initial_sync(struct drbd_conf *mdev); 1148extern int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val); 1149extern int drbd_send_sizes(struct drbd_conf *mdev, int trigger_reply, enum dds_flags flags); 1150extern int _drbd_send_state(struct drbd_conf *mdev); 1151extern int drbd_send_state(struct drbd_conf *mdev); 1152extern 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 1157extern 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); 1160extern int drbd_send_cmd2(struct drbd_conf *mdev, enum drbd_packets cmd, 1161 char *data, size_t size); 1162extern int drbd_send_sync_param(struct drbd_conf *mdev, struct syncer_conf *sc); 1163extern int drbd_send_b_ack(struct drbd_conf *mdev, u32 barrier_nr, 1164 u32 set_size); 1165extern int drbd_send_ack(struct drbd_conf *mdev, enum drbd_packets cmd, 1166 struct drbd_epoch_entry *e); 1167extern int drbd_send_ack_rp(struct drbd_conf *mdev, enum drbd_packets cmd, 1168 struct p_block_req *rp); 1169extern int drbd_send_ack_dp(struct drbd_conf *mdev, enum drbd_packets cmd, 1170 struct p_data *dp); 1171extern int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packets cmd, 1172 sector_t sector, int blksize, u64 block_id); 1173extern int drbd_send_block(struct drbd_conf *mdev, enum drbd_packets cmd, 1174 struct drbd_epoch_entry *e); 1175extern int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req); 1176extern int _drbd_send_barrier(struct drbd_conf *mdev, 1177 struct drbd_tl_epoch *barrier); 1178extern int drbd_send_drequest(struct drbd_conf *mdev, int cmd, 1179 sector_t sector, int size, u64 block_id); 1180extern 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); 1184extern int drbd_send_ov_request(struct drbd_conf *mdev,sector_t sector,int size); 1185 1186extern int drbd_send_bitmap(struct drbd_conf *mdev); 1187extern int _drbd_send_bitmap(struct drbd_conf *mdev); 1188extern int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode); 1189extern void drbd_free_bc(struct drbd_backing_dev *ldev); 1190extern void drbd_mdev_cleanup(struct drbd_conf *mdev); 1191 1192/* drbd_meta-data.c (still in drbd_main.c) */ 1193extern void drbd_md_sync(struct drbd_conf *mdev); 1194extern int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev); 1195/* maybe define them below as inline? */ 1196extern void drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local); 1197extern void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local); 1198extern void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local); 1199extern void _drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local); 1200extern void drbd_uuid_set_bm(struct drbd_conf *mdev, u64 val) __must_hold(local); 1201extern void drbd_md_set_flag(struct drbd_conf *mdev, int flags) __must_hold(local); 1202extern void drbd_md_clear_flag(struct drbd_conf *mdev, int flags)__must_hold(local); 1203extern int drbd_md_test_flag(struct drbd_backing_dev *, int); 1204extern void drbd_md_mark_dirty(struct drbd_conf *mdev); 1205extern 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); 1209extern int drbd_bmio_set_n_write(struct drbd_conf *mdev); 1210extern int drbd_bmio_clear_n_write(struct drbd_conf *mdev); 1211extern 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 */ 1249struct 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 1346extern int drbd_bm_init(struct drbd_conf *mdev); 1347extern int drbd_bm_resize(struct drbd_conf *mdev, sector_t sectors, int set_new_bits); 1348extern void drbd_bm_cleanup(struct drbd_conf *mdev); 1349extern void drbd_bm_set_all(struct drbd_conf *mdev); 1350extern void drbd_bm_clear_all(struct drbd_conf *mdev); 1351extern int drbd_bm_set_bits( 1352 struct drbd_conf *mdev, unsigned long s, unsigned long e); 1353extern 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 */ 1356extern void _drbd_bm_set_bits(struct drbd_conf *mdev, 1357 const unsigned long s, const unsigned long e); 1358extern int drbd_bm_test_bit(struct drbd_conf *mdev, unsigned long bitnr); 1359extern int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr); 1360extern int drbd_bm_write_sect(struct drbd_conf *mdev, unsigned long enr) __must_hold(local); 1361extern int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local); 1362extern int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local); 1363extern unsigned long drbd_bm_ALe_set_all(struct drbd_conf *mdev, 1364 unsigned long al_enr); 1365extern size_t drbd_bm_words(struct drbd_conf *mdev); 1366extern unsigned long drbd_bm_bits(struct drbd_conf *mdev); 1367extern sector_t drbd_bm_capacity(struct drbd_conf *mdev); 1368extern 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() */ 1370extern unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo); 1371extern unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo); 1372extern unsigned long drbd_bm_total_weight(struct drbd_conf *mdev); 1373extern int drbd_bm_rs_done(struct drbd_conf *mdev); 1374/* for receive_bitmap */ 1375extern 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 */ 1378extern void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset, 1379 size_t number, unsigned long *buffer); 1380 1381extern void drbd_bm_lock(struct drbd_conf *mdev, char *why); 1382extern void drbd_bm_unlock(struct drbd_conf *mdev); 1383 1384extern int drbd_bm_count_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e); 1385/* drbd_main.c */ 1386 1387extern struct kmem_cache *drbd_request_cache; 1388extern struct kmem_cache *drbd_ee_cache; /* epoch entries */ 1389extern struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */ 1390extern struct kmem_cache *drbd_al_ext_cache; /* activity log extents */ 1391extern mempool_t *drbd_request_mempool; 1392extern mempool_t *drbd_ee_mempool; 1393 1394extern struct page *drbd_pp_pool; /* drbd's page pool */ 1395extern spinlock_t drbd_pp_lock; 1396extern int drbd_pp_vacant; 1397extern wait_queue_head_t drbd_pp_wait; 1398 1399extern rwlock_t global_state_lock; 1400 1401extern struct drbd_conf *drbd_new_device(unsigned int minor); 1402extern void drbd_free_mdev(struct drbd_conf *mdev); 1403 1404extern int proc_details; 1405 1406/* drbd_req */ 1407extern int drbd_make_request_26(struct request_queue *q, struct bio *bio); 1408extern int drbd_read_remote(struct drbd_conf *mdev, struct drbd_request *req); 1409extern int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec); 1410extern int is_valid_ar_handle(struct drbd_request *, sector_t); 1411 1412 1413/* drbd_nl.c */ 1414extern void drbd_suspend_io(struct drbd_conf *mdev); 1415extern void drbd_resume_io(struct drbd_conf *mdev); 1416extern char *ppsize(char *buf, unsigned long long size); 1417extern sector_t drbd_new_dev_size(struct drbd_conf *, struct drbd_backing_dev *, int); 1418enum determine_dev_size { dev_size_error = -1, unchanged = 0, shrunk = 1, grew = 2 }; 1419extern enum determine_dev_size drbd_determin_dev_size(struct drbd_conf *, enum dds_flags) __must_hold(local); 1420extern void resync_after_online_grow(struct drbd_conf *); 1421extern void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int) __must_hold(local); 1422extern int drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, 1423 int force); 1424enum drbd_disk_state drbd_try_outdate_peer(struct drbd_conf *mdev); 1425extern int drbd_khelper(struct drbd_conf *mdev, char *cmd); 1426 1427/* drbd_worker.c */ 1428extern int drbd_worker(struct drbd_thread *thi); 1429extern int drbd_alter_sa(struct drbd_conf *mdev, int na); 1430extern void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side); 1431extern void resume_next_sg(struct drbd_conf *mdev); 1432extern void suspend_other_sg(struct drbd_conf *mdev); 1433extern int drbd_resync_finished(struct drbd_conf *mdev); 1434/* maybe rather drbd_main.c ? */ 1435extern int drbd_md_sync_page_io(struct drbd_conf *mdev, 1436 struct drbd_backing_dev *bdev, sector_t sector, int rw); 1437extern void drbd_ov_oos_found(struct drbd_conf*, sector_t, int); 1438 1439static 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 1450extern void drbd_csum_bio(struct drbd_conf *, struct crypto_hash *, struct bio *, void *); 1451extern void drbd_csum_ee(struct drbd_conf *, struct crypto_hash *, struct drbd_epoch_entry *, void *); 1452/* worker callbacks */ 1453extern int w_req_cancel_conflict(struct drbd_conf *, struct drbd_work *, int); 1454extern int w_read_retry_remote(struct drbd_conf *, struct drbd_work *, int); 1455extern int w_e_end_data_req(struct drbd_conf *, struct drbd_work *, int); 1456extern int w_e_end_rsdata_req(struct drbd_conf *, struct drbd_work *, int); 1457extern int w_e_end_csum_rs_req(struct drbd_conf *, struct drbd_work *, int); 1458extern int w_e_end_ov_reply(struct drbd_conf *, struct drbd_work *, int); 1459extern int w_e_end_ov_req(struct drbd_conf *, struct drbd_work *, int); 1460extern int w_ov_finished(struct drbd_conf *, struct drbd_work *, int); 1461extern int w_resync_inactive(struct drbd_conf *, struct drbd_work *, int); 1462extern int w_resume_next_sg(struct drbd_conf *, struct drbd_work *, int); 1463extern int w_send_write_hint(struct drbd_conf *, struct drbd_work *, int); 1464extern int w_make_resync_request(struct drbd_conf *, struct drbd_work *, int); 1465extern int w_send_dblock(struct drbd_conf *, struct drbd_work *, int); 1466extern int w_send_barrier(struct drbd_conf *, struct drbd_work *, int); 1467extern int w_send_read_req(struct drbd_conf *, struct drbd_work *, int); 1468extern int w_prev_work_done(struct drbd_conf *, struct drbd_work *, int); 1469extern int w_e_reissue(struct drbd_conf *, struct drbd_work *, int); 1470 1471extern void resync_timer_fn(unsigned long data); 1472 1473/* drbd_receiver.c */ 1474extern int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, 1475 const unsigned rw, const int fault_type); 1476extern int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list); 1477extern 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); 1482extern void drbd_free_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e); 1483extern void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 1484 struct list_head *head); 1485extern void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 1486 struct list_head *head); 1487extern void drbd_set_recv_tcq(struct drbd_conf *mdev, int tcq_enabled); 1488extern void _drbd_clear_done_ee(struct drbd_conf *mdev, struct list_head *to_be_freed); 1489extern 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. */ 1493static 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 1505static 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 1512static 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 1519static 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 1526static 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 1533void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo); 1534 1535/* drbd_proc.c */ 1536extern struct proc_dir_entry *drbd_proc; 1537extern const struct file_operations drbd_proc_fops; 1538extern const char *drbd_conn_str(enum drbd_conns s); 1539extern const char *drbd_role_str(enum drbd_role s); 1540 1541/* drbd_actlog.c */ 1542extern void drbd_al_begin_io(struct drbd_conf *mdev, sector_t sector); 1543extern void drbd_al_complete_io(struct drbd_conf *mdev, sector_t sector); 1544extern void drbd_rs_complete_io(struct drbd_conf *mdev, sector_t sector); 1545extern int drbd_rs_begin_io(struct drbd_conf *mdev, sector_t sector); 1546extern int drbd_try_rs_begin_io(struct drbd_conf *mdev, sector_t sector); 1547extern void drbd_rs_cancel_all(struct drbd_conf *mdev); 1548extern int drbd_rs_del_all(struct drbd_conf *mdev); 1549extern void drbd_rs_failed_io(struct drbd_conf *mdev, 1550 sector_t sector, int size); 1551extern int drbd_al_read_log(struct drbd_conf *mdev, struct drbd_backing_dev *); 1552extern 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__) 1556extern 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__) 1560extern void drbd_al_apply_to_bm(struct drbd_conf *mdev); 1561extern void drbd_al_to_on_disk_bm(struct drbd_conf *mdev); 1562extern void drbd_al_shrink(struct drbd_conf *mdev); 1563 1564 1565/* drbd_nl.c */ 1566 1567void drbd_nl_cleanup(void); 1568int __init drbd_nl_init(void); 1569void drbd_bcast_state(struct drbd_conf *mdev, union drbd_state); 1570void drbd_bcast_sync_progress(struct drbd_conf *mdev); 1571void 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 */ 1632static 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 1642static 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 1655static 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 1666static 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 1672static 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 1678static 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 */ 1701static 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__) 1709static 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__) 1740static 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 */ 1759static 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 */ 1775static 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 */ 1788static 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 */ 1802static 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 */ 1833static 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 1858static 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 1865static inline void 1866drbd_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 1876static inline void 1877drbd_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 1887static 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 1893static inline void request_ping(struct drbd_conf *mdev) 1894{ 1895 set_bit(SEND_PING, &mdev->flags); 1896 wake_asender(mdev); 1897} 1898 1899static 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 1906static 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 1912static 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 1918static inline void drbd_thread_stop(struct drbd_thread *thi) 1919{ 1920 _drbd_thread_stop(thi, FALSE, TRUE); 1921} 1922 1923static inline void drbd_thread_stop_nowait(struct drbd_thread *thi) 1924{ 1925 _drbd_thread_stop(thi, FALSE, FALSE); 1926} 1927 1928static 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 */ 1955static 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 */ 1978static 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 */ 1997static 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 2013static 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 */ 2025static 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 2045static 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__ 2054static 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 2065extern 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 */ 2069static 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? */ 2109static 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 2119static 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 2182static 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 if (atomic_read(&mdev->ap_bio_cnt) > mxb) 2200 return 0; 2201 if (test_bit(BITMAP_IO, &mdev->flags)) 2202 return 0; 2203 return 1; 2204} 2205 2206/* I'd like to use wait_event_lock_irq, 2207 * but I'm not sure when it got introduced, 2208 * and not sure when it has 3 or 4 arguments */ 2209static inline void inc_ap_bio(struct drbd_conf *mdev, int count) 2210{ 2211 /* compare with after_state_ch, 2212 * os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S */ 2213 DEFINE_WAIT(wait); 2214 2215 /* we wait here 2216 * as long as the device is suspended 2217 * until the bitmap is no longer on the fly during connection 2218 * handshake as long as we would exeed the max_buffer limit. 2219 * 2220 * to avoid races with the reconnect code, 2221 * we need to atomic_inc within the spinlock. */ 2222 2223 spin_lock_irq(&mdev->req_lock); 2224 while (!__inc_ap_bio_cond(mdev)) { 2225 prepare_to_wait(&mdev->misc_wait, &wait, TASK_UNINTERRUPTIBLE); 2226 spin_unlock_irq(&mdev->req_lock); 2227 schedule(); 2228 finish_wait(&mdev->misc_wait, &wait); 2229 spin_lock_irq(&mdev->req_lock); 2230 } 2231 atomic_add(count, &mdev->ap_bio_cnt); 2232 spin_unlock_irq(&mdev->req_lock); 2233} 2234 2235static inline void dec_ap_bio(struct drbd_conf *mdev) 2236{ 2237 int mxb = drbd_get_max_buffers(mdev); 2238 int ap_bio = atomic_dec_return(&mdev->ap_bio_cnt); 2239 2240 D_ASSERT(ap_bio >= 0); 2241 /* this currently does wake_up for every dec_ap_bio! 2242 * maybe rather introduce some type of hysteresis? 2243 * e.g. (ap_bio == mxb/2 || ap_bio == 0) ? */ 2244 if (ap_bio < mxb) 2245 wake_up(&mdev->misc_wait); 2246 if (ap_bio == 0 && test_bit(BITMAP_IO, &mdev->flags)) { 2247 if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags)) 2248 drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w); 2249 } 2250} 2251 2252static inline void drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val) 2253{ 2254 mdev->ed_uuid = val; 2255} 2256 2257static inline int seq_cmp(u32 a, u32 b) 2258{ 2259 /* we assume wrap around at 32bit. 2260 * for wrap around at 24bit (old atomic_t), 2261 * we'd have to 2262 * a <<= 8; b <<= 8; 2263 */ 2264 return (s32)(a) - (s32)(b); 2265} 2266#define seq_lt(a, b) (seq_cmp((a), (b)) < 0) 2267#define seq_gt(a, b) (seq_cmp((a), (b)) > 0) 2268#define seq_ge(a, b) (seq_cmp((a), (b)) >= 0) 2269#define seq_le(a, b) (seq_cmp((a), (b)) <= 0) 2270/* CAUTION: please no side effects in arguments! */ 2271#define seq_max(a, b) ((u32)(seq_gt((a), (b)) ? (a) : (b))) 2272 2273static inline void update_peer_seq(struct drbd_conf *mdev, unsigned int new_seq) 2274{ 2275 unsigned int m; 2276 spin_lock(&mdev->peer_seq_lock); 2277 m = seq_max(mdev->peer_seq, new_seq); 2278 mdev->peer_seq = m; 2279 spin_unlock(&mdev->peer_seq_lock); 2280 if (m == new_seq) 2281 wake_up(&mdev->seq_wait); 2282} 2283 2284static inline void drbd_update_congested(struct drbd_conf *mdev) 2285{ 2286 struct sock *sk = mdev->data.socket->sk; 2287 if (sk->sk_wmem_queued > sk->sk_sndbuf * 4 / 5) 2288 set_bit(NET_CONGESTED, &mdev->flags); 2289} 2290 2291static inline int drbd_queue_order_type(struct drbd_conf *mdev) 2292{ 2293 /* sorry, we currently have no working implementation 2294 * of distributed TCQ stuff */ 2295#ifndef QUEUE_ORDERED_NONE 2296#define QUEUE_ORDERED_NONE 0 2297#endif 2298 return QUEUE_ORDERED_NONE; 2299} 2300 2301static inline void drbd_blk_run_queue(struct request_queue *q) 2302{ 2303 if (q && q->unplug_fn) 2304 q->unplug_fn(q); 2305} 2306 2307static inline void drbd_kick_lo(struct drbd_conf *mdev) 2308{ 2309 if (get_ldev(mdev)) { 2310 drbd_blk_run_queue(bdev_get_queue(mdev->ldev->backing_bdev)); 2311 put_ldev(mdev); 2312 } 2313} 2314 2315static inline void drbd_md_flush(struct drbd_conf *mdev) 2316{ 2317 int r; 2318 2319 if (test_bit(MD_NO_BARRIER, &mdev->flags)) 2320 return; 2321 2322 r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL, 2323 BLKDEV_IFL_WAIT); 2324 if (r) { 2325 set_bit(MD_NO_BARRIER, &mdev->flags); 2326 dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r); 2327 } 2328} 2329 2330#endif 2331