1 /* $OpenBSD: softraidvar.h,v 1.116 2012/01/28 14:40:04 jsing Exp $ */ 2 /* 3 * Copyright (c) 2006 Marco Peereboom <marco@peereboom.us> 4 * Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #ifndef SOFTRAIDVAR_H 20 #define SOFTRAIDVAR_H 21 22 #include <sys/socket.h> 23 #include <sys/vnode.h> 24 25 #include <net/if.h> 26 #include <netinet/in.h> 27 #include <netinet/if_ether.h> 28 29 #include <crypto/md5.h> 30 31 #define SR_META_VERSION 5 /* bump when sr_metadata changes */ 32 #define SR_META_SIZE 64 /* save space at chunk beginning */ 33 #define SR_META_OFFSET 16 /* skip 8192 bytes at chunk beginning */ 34 35 #define SR_META_V3_SIZE 64 36 #define SR_META_V3_OFFSET 16 37 #define SR_META_V3_DATA_OFFSET (SR_META_V3_OFFSET + SR_META_V3_SIZE) 38 39 #define SR_META_F_NATIVE 0 /* Native metadata format. */ 40 #define SR_META_F_INVALID -1 41 42 #define SR_BOOT_OFFSET (SR_META_OFFSET + SR_META_SIZE) 43 #define SR_BOOT_LOADER_SIZE 320 /* Size of boot loader storage. */ 44 #define SR_BOOT_LOADER_OFFSET SR_BOOT_OFFSET 45 #define SR_BOOT_BLOCKS_SIZE 128 /* Size of boot block storage. */ 46 #define SR_BOOT_BLOCKS_OFFSET (SR_BOOT_LOADER_OFFSET + SR_BOOT_LOADER_SIZE) 47 #define SR_BOOT_SIZE (SR_BOOT_LOADER_SIZE + SR_BOOT_BLOCKS_SIZE) 48 49 #define SR_HEADER_SIZE (SR_META_SIZE + SR_BOOT_SIZE) 50 #define SR_DATA_OFFSET (SR_META_OFFSET + SR_HEADER_SIZE) 51 52 #define SR_HOTSPARE_LEVEL 0xffffffff 53 #define SR_HOTSPARE_VOLID 0xffffffff 54 #define SR_KEYDISK_LEVEL 0xfffffffe 55 #define SR_KEYDISK_VOLID 0xfffffffe 56 57 #define SR_UUID_MAX 16 58 struct sr_uuid { 59 u_int8_t sui_id[SR_UUID_MAX]; 60 } __packed; 61 62 struct sr_disk { 63 dev_t sdk_devno; 64 SLIST_ENTRY(sr_disk) sdk_link; 65 }; 66 SLIST_HEAD(sr_disk_head, sr_disk); 67 68 struct sr_metadata { 69 struct sr_meta_invariant { 70 /* do not change order of ssd_magic, ssd_version */ 71 u_int64_t ssd_magic; /* magic id */ 72 #define SR_MAGIC 0x4d4152436372616dLLU 73 u_int32_t ssd_version; /* meta data version */ 74 u_int32_t ssd_vol_flags; /* volume specific flags. */ 75 struct sr_uuid ssd_uuid; /* unique identifier */ 76 77 /* chunks */ 78 u_int32_t ssd_chunk_no; /* number of chunks */ 79 u_int32_t ssd_chunk_id; /* chunk identifier */ 80 81 /* optional */ 82 u_int32_t ssd_opt_no; /* nr of optional md elements */ 83 u_int32_t ssd_pad; 84 85 /* volume metadata */ 86 u_int32_t ssd_volid; /* volume id */ 87 u_int32_t ssd_level; /* raid level */ 88 int64_t ssd_size; /* virt disk size in blocks */ 89 char ssd_vendor[8]; /* scsi vendor */ 90 char ssd_product[16];/* scsi product */ 91 char ssd_revision[4];/* scsi revision */ 92 /* optional volume members */ 93 u_int32_t ssd_strip_size; /* strip size */ 94 } _sdd_invariant; 95 #define ssdi _sdd_invariant 96 /* MD5 of invariant metadata */ 97 u_int8_t ssd_checksum[MD5_DIGEST_LENGTH]; 98 char ssd_devname[32];/* /dev/XXXXX */ 99 u_int32_t ssd_meta_flags; 100 #define SR_META_DIRTY 0x1 101 u_int32_t ssd_data_offset; 102 u_int64_t ssd_ondisk; /* on disk version counter */ 103 int64_t ssd_rebuild; /* last block of rebuild */ 104 } __packed; 105 106 struct sr_meta_chunk { 107 struct sr_meta_chunk_invariant { 108 u_int32_t scm_volid; /* vd we belong to */ 109 u_int32_t scm_chunk_id; /* chunk id */ 110 char scm_devname[32];/* /dev/XXXXX */ 111 int64_t scm_size; /* size of partition in blocks*/ 112 int64_t scm_coerced_size; /* coerced sz of part in blk*/ 113 struct sr_uuid scm_uuid; /* unique identifier */ 114 } _scm_invariant; 115 #define scmi _scm_invariant 116 /* MD5 of invariant chunk metadata */ 117 u_int8_t scm_checksum[MD5_DIGEST_LENGTH]; 118 u_int32_t scm_status; /* use bio bioc_disk status */ 119 } __packed; 120 121 #define SR_CRYPTO_MAXKEYBYTES 32 /* max bytes in a key (AES-XTS-256) */ 122 #define SR_CRYPTO_MAXKEYS 32 /* max keys per volume */ 123 #define SR_CRYPTO_KEYBITS 512 /* AES-XTS with 2 * 256 bit keys */ 124 #define SR_CRYPTO_KEYBYTES (SR_CRYPTO_KEYBITS >> 3) 125 #define SR_CRYPTO_KDFHINTBYTES 256 /* size of opaque KDF hint */ 126 #define SR_CRYPTO_CHECKBYTES 64 /* size of generic key chksum struct */ 127 #define SR_CRYPTO_KEY_BLKSHIFT 30 /* 0.5TB per key */ 128 129 /* 130 * Check that HMAC-SHA1_k(decrypted scm_key) == sch_mac, where 131 * k = SHA1(masking key) 132 */ 133 struct sr_crypto_chk_hmac_sha1 { 134 u_int8_t sch_mac[20]; 135 } __packed; 136 137 #define SR_OPT_INVALID 0x00 138 #define SR_OPT_CRYPTO 0x01 139 #define SR_OPT_BOOT 0x02 140 #define SR_OPT_KEYDISK 0x03 141 142 struct sr_meta_opt_hdr { 143 u_int32_t som_type; /* optional metadata type. */ 144 u_int32_t som_length; /* optional metadata length. */ 145 u_int8_t som_checksum[MD5_DIGEST_LENGTH]; 146 } __packed; 147 148 struct sr_meta_crypto { 149 struct sr_meta_opt_hdr scm_hdr; 150 u_int32_t scm_alg; /* vol crypto algorithm */ 151 #define SR_CRYPTOA_AES_XTS_128 1 152 #define SR_CRYPTOA_AES_XTS_256 2 153 u_int32_t scm_flags; /* key & kdfhint valid */ 154 #define SR_CRYPTOF_INVALID (0) 155 #define SR_CRYPTOF_KEY (1<<0) 156 #define SR_CRYPTOF_KDFHINT (1<<1) 157 u_int32_t scm_mask_alg; /* disk key masking crypt alg */ 158 #define SR_CRYPTOM_AES_ECB_256 1 159 u_int32_t scm_pad1; 160 u_int8_t scm_reserved[64]; 161 162 /* symmetric keys used for disk encryption */ 163 u_int8_t scm_key[SR_CRYPTO_MAXKEYS][SR_CRYPTO_KEYBYTES]; 164 /* hint to kdf algorithm (opaque to kernel) */ 165 u_int8_t scm_kdfhint[SR_CRYPTO_KDFHINTBYTES]; 166 167 u_int32_t scm_check_alg; /* key chksum algorithm */ 168 #define SR_CRYPTOC_HMAC_SHA1 1 169 u_int32_t scm_pad2; 170 union { 171 struct sr_crypto_chk_hmac_sha1 chk_hmac_sha1; 172 u_int8_t chk_reserved2[64]; 173 } _scm_chk; 174 #define chk_hmac_sha1 _scm_chk.chk_hmac_sha1 175 } __packed; 176 177 #define SR_MAX_BOOT_DISKS 16 178 struct sr_meta_boot { 179 struct sr_meta_opt_hdr sbm_hdr; 180 u_int32_t sbm_bootblk_size; 181 u_int32_t sbm_bootldr_size; 182 u_char sbm_root_duid[8]; 183 u_char sbm_boot_duid[SR_MAX_BOOT_DISKS][8]; 184 } __packed; 185 186 struct sr_meta_keydisk { 187 struct sr_meta_opt_hdr skm_hdr; 188 u_int8_t skm_maskkey[SR_CRYPTO_MAXKEYBYTES]; 189 } __packed; 190 191 #define SR_OLD_META_OPT_SIZE 2480 192 #define SR_OLD_META_OPT_OFFSET 8 193 #define SR_OLD_META_OPT_MD5 (SR_OLD_META_OPT_SIZE - MD5_DIGEST_LENGTH) 194 195 struct sr_meta_opt_item { 196 struct sr_meta_opt_hdr *omi_som; 197 SLIST_ENTRY(sr_meta_opt_item) omi_link; 198 }; 199 200 SLIST_HEAD(sr_meta_opt_head, sr_meta_opt_item); 201 202 /* this is a generic hint for KDF done in userland, not interpreted by the kernel. */ 203 struct sr_crypto_genkdf { 204 u_int32_t len; 205 u_int32_t type; 206 #define SR_CRYPTOKDFT_INVALID 0 207 #define SR_CRYPTOKDFT_PBKDF2 1 208 #define SR_CRYPTOKDFT_KEYDISK 2 209 }; 210 211 /* this is a hint for KDF using PKCS#5. Not interpreted by the kernel */ 212 struct sr_crypto_kdf_pbkdf2 { 213 u_int32_t len; 214 u_int32_t type; 215 u_int32_t rounds; 216 u_int8_t salt[128]; 217 }; 218 219 /* 220 * this structure is used to copy masking keys and KDF hints from/to userland. 221 * the embedded hint structures are not interpreted by the kernel. 222 */ 223 struct sr_crypto_kdfinfo { 224 u_int32_t len; 225 u_int32_t flags; 226 #define SR_CRYPTOKDF_INVALID (0) 227 #define SR_CRYPTOKDF_KEY (1<<0) 228 #define SR_CRYPTOKDF_HINT (1<<1) 229 u_int8_t maskkey[SR_CRYPTO_MAXKEYBYTES]; 230 union { 231 struct sr_crypto_genkdf generic; 232 struct sr_crypto_kdf_pbkdf2 pbkdf2; 233 } _kdfhint; 234 #define genkdf _kdfhint.generic 235 #define pbkdf2 _kdfhint.pbkdf2 236 }; 237 238 #define SR_IOCTL_GET_KDFHINT 0x01 /* Get KDF hint. */ 239 #define SR_IOCTL_CHANGE_PASSPHRASE 0x02 /* Change passphase. */ 240 241 struct sr_crypto_kdfpair { 242 void *kdfinfo1; 243 u_int32_t kdfsize1; 244 void *kdfinfo2; 245 u_int32_t kdfsize2; 246 }; 247 248 struct sr_aoe_config { 249 char nic[IFNAMSIZ]; 250 struct ether_addr dsteaddr; 251 unsigned short shelf; 252 unsigned char slot; 253 }; 254 255 struct sr_boot_chunk { 256 struct sr_metadata *sbc_metadata; 257 dev_t sbc_mm; 258 259 u_int32_t sbc_chunk_id; /* Chunk ID. */ 260 u_int32_t sbc_state; /* Chunk state. */ 261 u_int32_t sbc_disk; /* Disk number. */ 262 int sbc_part; /* Partition number. */ 263 u_int64_t sbc_ondisk; /* Ondisk version. */ 264 265 void *sbc_diskinfo; /* MD disk information. */ 266 267 SLIST_ENTRY(sr_boot_chunk) sbc_link; 268 }; 269 270 SLIST_HEAD(sr_boot_chunk_head, sr_boot_chunk); 271 272 struct sr_boot_volume { 273 struct sr_uuid sbv_uuid; /* Volume UUID. */ 274 u_int32_t sbv_level; /* RAID Level. */ 275 u_int32_t sbv_volid; /* Volume ID. */ 276 u_int32_t sbv_chunk_no; /* Number of chunks. */ 277 u_int32_t sbv_flags; /* Volume specific flags. */ 278 u_int32_t sbv_state; /* Volume state. */ 279 int64_t sbv_size; /* Virtual disk size. */ 280 u_int32_t sbv_data_offset; /* Data offset. */ 281 u_int64_t sbv_ondisk; /* Ondisk version. */ 282 283 u_int32_t sbv_chunks_found; /* Number of chunks found. */ 284 u_int32_t sbv_unit; /* Disk unit number. */ 285 char sbv_part; /* Partition opened. */ 286 void *sbv_diskinfo; /* MD disk information. */ 287 288 struct sr_boot_chunk_head sbv_chunks; /* List of chunks. */ 289 290 SLIST_ENTRY(sr_boot_volume) sbv_link; 291 }; 292 293 SLIST_HEAD(sr_boot_volume_head, sr_boot_volume); 294 295 #ifdef _KERNEL 296 #include <dev/biovar.h> 297 298 #include <sys/buf.h> 299 #include <sys/pool.h> 300 #include <sys/queue.h> 301 #include <sys/rwlock.h> 302 303 #include <scsi/scsi_all.h> 304 #include <scsi/scsi_disk.h> 305 #include <scsi/scsiconf.h> 306 307 #define DEVNAME(_s) ((_s)->sc_dev.dv_xname) 308 309 /* #define SR_DEBUG */ 310 #ifdef SR_DEBUG 311 extern u_int32_t sr_debug; 312 #define DPRINTF(x...) do { if (sr_debug) printf(x); } while(0) 313 #define DNPRINTF(n,x...) do { if (sr_debug & n) printf(x); } while(0) 314 #define SR_D_CMD 0x0001 315 #define SR_D_INTR 0x0002 316 #define SR_D_MISC 0x0004 317 #define SR_D_IOCTL 0x0008 318 #define SR_D_CCB 0x0010 319 #define SR_D_WU 0x0020 320 #define SR_D_META 0x0040 321 #define SR_D_DIS 0x0080 322 #define SR_D_STATE 0x0100 323 #else 324 #define DPRINTF(x...) 325 #define DNPRINTF(n,x...) 326 #endif 327 328 #define SR_MAXFER MAXPHYS 329 #define SR_MAX_LD 256 330 #define SR_MAX_CMDS 16 331 #define SR_MAX_STATES 7 332 #define SR_VM_IGNORE_DIRTY 1 333 #define SR_REBUILD_IO_SIZE 128 /* blocks */ 334 335 /* forward define to prevent dependency goo */ 336 struct sr_softc; 337 338 struct sr_ccb { 339 struct buf ccb_buf; /* MUST BE FIRST!! */ 340 341 struct sr_workunit *ccb_wu; 342 struct sr_discipline *ccb_dis; 343 344 int ccb_target; 345 int ccb_state; 346 #define SR_CCB_FREE 0 347 #define SR_CCB_INPROGRESS 1 348 #define SR_CCB_OK 2 349 #define SR_CCB_FAILED 3 350 351 int ccb_flag; 352 #define SR_CCBF_FREEBUF (1<<0) /* free ccb_buf.b_data */ 353 354 void *ccb_opaque; /* discipline usable pointer */ 355 356 TAILQ_ENTRY(sr_ccb) ccb_link; 357 }; 358 359 TAILQ_HEAD(sr_ccb_list, sr_ccb); 360 361 struct sr_workunit { 362 struct scsi_xfer *swu_xs; 363 struct sr_discipline *swu_dis; 364 365 int swu_state; 366 #define SR_WU_FREE 0 367 #define SR_WU_INPROGRESS 1 368 #define SR_WU_OK 2 369 #define SR_WU_FAILED 3 370 #define SR_WU_PARTIALLYFAILED 4 371 #define SR_WU_DEFERRED 5 372 #define SR_WU_PENDING 6 373 #define SR_WU_RESTART 7 374 #define SR_WU_REQUEUE 8 375 376 int swu_flags; /* additional hints */ 377 #define SR_WUF_REBUILD (1<<0) /* rebuild io */ 378 #define SR_WUF_REBUILDIOCOMP (1<<1) /* rbuild io complete */ 379 #define SR_WUF_FAIL (1<<2) /* RAID6: failure */ 380 #define SR_WUF_FAILIOCOMP (1<<3) 381 382 int swu_fake; /* faked wu */ 383 /* workunit io range */ 384 daddr64_t swu_blk_start; 385 daddr64_t swu_blk_end; 386 387 /* in flight totals */ 388 u_int32_t swu_ios_complete; 389 u_int32_t swu_ios_failed; 390 u_int32_t swu_ios_succeeded; 391 392 /* number of ios that makes up the whole work unit */ 393 u_int32_t swu_io_count; 394 395 /* colliding wu */ 396 struct sr_workunit *swu_collider; 397 398 /* all ios that make up this workunit */ 399 struct sr_ccb_list swu_ccb; 400 401 /* task memory */ 402 struct workq_task swu_wqt; 403 struct workq_task swu_intr; 404 int swu_cb_active; /* in callback */ 405 406 TAILQ_ENTRY(sr_workunit) swu_link; 407 }; 408 409 TAILQ_HEAD(sr_wu_list, sr_workunit); 410 411 /* RAID 0 */ 412 #define SR_RAID0_NOWU 16 413 struct sr_raid0 { 414 int32_t sr0_strip_bits; 415 }; 416 417 /* RAID 1 */ 418 #define SR_RAID1_NOWU 16 419 struct sr_raid1 { 420 u_int32_t sr1_counter; 421 }; 422 423 /* RAID 4 */ 424 #define SR_RAIDP_NOWU 16 425 struct sr_raidp { 426 int32_t srp_strip_bits; 427 }; 428 429 /* RAID 6 */ 430 #define SR_RAID6_NOWU 16 431 struct sr_raid6 { 432 int32_t sr6_strip_bits; 433 }; 434 435 /* CRYPTO */ 436 TAILQ_HEAD(sr_crypto_wu_head, sr_crypto_wu); 437 #define SR_CRYPTO_NOWU 16 438 439 struct sr_crypto { 440 struct mutex scr_mutex; 441 struct sr_crypto_wu_head scr_wus; 442 struct sr_meta_crypto *scr_meta; 443 struct sr_chunk *key_disk; 444 445 /* XXX only keep scr_sid over time */ 446 u_int8_t scr_key[SR_CRYPTO_MAXKEYS][SR_CRYPTO_KEYBYTES]; 447 u_int8_t scr_maskkey[SR_CRYPTO_MAXKEYBYTES]; 448 u_int64_t scr_sid[SR_CRYPTO_MAXKEYS]; 449 }; 450 451 /* ata over ethernet */ 452 #define SR_RAIDAOE_NOWU 2 453 struct sr_aoe { 454 struct aoe_handler *sra_ah; 455 int sra_tag; 456 struct ifnet *sra_ifp; 457 struct ether_addr sra_eaddr; 458 }; 459 460 #define SR_CONCAT_NOWU 16 461 struct sr_concat { 462 }; 463 464 struct sr_chunk { 465 struct sr_meta_chunk src_meta; /* chunk meta data */ 466 467 /* runtime data */ 468 dev_t src_dev_mm; /* major/minor */ 469 struct vnode *src_vn; /* vnode */ 470 471 /* helper members before metadata makes it onto the chunk */ 472 int src_meta_ondisk;/* set when meta is on disk */ 473 char src_devname[32]; 474 u_char src_duid[8]; /* Chunk disklabel UID. */ 475 int64_t src_size; /* in blocks */ 476 477 SLIST_ENTRY(sr_chunk) src_link; 478 }; 479 480 SLIST_HEAD(sr_chunk_head, sr_chunk); 481 482 struct sr_volume { 483 /* runtime data */ 484 struct sr_chunk_head sv_chunk_list; /* linked list of all chunks */ 485 struct sr_chunk **sv_chunks; /* array to same chunks */ 486 int64_t sv_chunk_minsz; /* Size of smallest chunk. */ 487 int64_t sv_chunk_maxsz; /* Size of largest chunk. */ 488 489 /* sensors */ 490 struct ksensor sv_sensor; 491 int sv_sensor_attached; 492 }; 493 494 struct sr_discipline { 495 struct sr_softc *sd_sc; /* link back to sr softc */ 496 u_int8_t sd_type; /* type of discipline */ 497 #define SR_MD_RAID0 0 498 #define SR_MD_RAID1 1 499 #define SR_MD_RAID5 2 500 #define SR_MD_CACHE 3 501 #define SR_MD_CRYPTO 4 502 #define SR_MD_AOE_INIT 5 503 #define SR_MD_AOE_TARG 6 504 #define SR_MD_RAID4 7 505 #define SR_MD_RAID6 8 506 #define SR_MD_CONCAT 9 507 char sd_name[10]; /* human readable dis name */ 508 u_int16_t sd_target; /* scsibus target discipline uses */ 509 510 u_int32_t sd_capabilities; 511 #define SR_CAP_SYSTEM_DISK 0x00000001 /* Attaches as a system disk. */ 512 #define SR_CAP_AUTO_ASSEMBLE 0x00000002 /* Can auto assemble. */ 513 #define SR_CAP_REBUILD 0x00000004 /* Supports rebuild. */ 514 #define SR_CAP_NON_COERCED 0x00000008 /* Uses non-coerced size. */ 515 516 union { 517 struct sr_raid0 mdd_raid0; 518 struct sr_raid1 mdd_raid1; 519 struct sr_raidp mdd_raidp; 520 struct sr_raid6 mdd_raid6; 521 struct sr_concat mdd_concat; 522 #ifdef CRYPTO 523 struct sr_crypto mdd_crypto; 524 #endif /* CRYPTO */ 525 #ifdef AOE 526 struct sr_aoe mdd_aoe; 527 #endif /* AOE */ 528 } sd_dis_specific;/* dis specific members */ 529 #define mds sd_dis_specific 530 531 struct workq *sd_workq; 532 533 /* discipline metadata */ 534 struct sr_metadata *sd_meta; /* in memory copy of metadata */ 535 void *sd_meta_foreign; /* non native metadata */ 536 u_int32_t sd_meta_flags; 537 int sd_meta_type; /* metadata functions */ 538 struct sr_meta_opt_head sd_meta_opt; /* optional metadata. */ 539 540 int sd_sync; 541 int sd_must_flush; 542 543 int sd_deleted; 544 545 struct device *sd_scsibus_dev; 546 547 /* discipline volume */ 548 struct sr_volume sd_vol; /* volume associated */ 549 int sd_vol_status; /* runtime vol status */ 550 /* discipline resources */ 551 struct sr_ccb *sd_ccb; 552 struct sr_ccb_list sd_ccb_freeq; 553 u_int32_t sd_max_ccb_per_wu; 554 555 struct sr_workunit *sd_wu; /* all workunits */ 556 u_int32_t sd_max_wu; 557 int sd_reb_active; /* rebuild in progress */ 558 int sd_reb_abort; /* abort rebuild */ 559 int sd_ready; /* fully operational */ 560 561 struct sr_wu_list sd_wu_freeq; /* free wu queue */ 562 struct sr_wu_list sd_wu_pendq; /* pending wu queue */ 563 struct sr_wu_list sd_wu_defq; /* deferred wu queue */ 564 565 struct mutex sd_wu_mtx; 566 struct scsi_iopool sd_iopool; 567 568 /* discipline stats */ 569 int sd_wu_pending; 570 u_int64_t sd_wu_collisions; 571 572 /* discipline functions */ 573 int (*sd_create)(struct sr_discipline *, 574 struct bioc_createraid *, int, int64_t); 575 int (*sd_assemble)(struct sr_discipline *, 576 struct bioc_createraid *, int); 577 int (*sd_alloc_resources)(struct sr_discipline *); 578 int (*sd_free_resources)(struct sr_discipline *); 579 int (*sd_ioctl_handler)(struct sr_discipline *, 580 struct bioc_discipline *); 581 int (*sd_start_discipline)(struct sr_discipline *); 582 void (*sd_set_chunk_state)(struct sr_discipline *, 583 int, int); 584 void (*sd_set_vol_state)(struct sr_discipline *); 585 int (*sd_openings)(struct sr_discipline *); 586 int (*sd_meta_opt_handler)(struct sr_discipline *, 587 struct sr_meta_opt_hdr *); 588 589 /* SCSI emulation */ 590 struct scsi_sense_data sd_scsi_sense; 591 int (*sd_scsi_rw)(struct sr_workunit *); 592 int (*sd_scsi_sync)(struct sr_workunit *); 593 int (*sd_scsi_tur)(struct sr_workunit *); 594 int (*sd_scsi_start_stop)(struct sr_workunit *); 595 int (*sd_scsi_inquiry)(struct sr_workunit *); 596 int (*sd_scsi_read_cap)(struct sr_workunit *); 597 int (*sd_scsi_req_sense)(struct sr_workunit *); 598 599 /* background operation */ 600 struct proc *sd_background_proc; 601 }; 602 603 struct sr_softc { 604 struct device sc_dev; 605 606 void (*sc_shutdownhook)(void *); 607 608 struct rwlock sc_lock; 609 610 struct bio_status sc_status; /* Status and messages. */ 611 612 struct sr_chunk_head sc_hotspare_list; /* List of hotspares. */ 613 struct rwlock sc_hs_lock; /* Lock for hotspares list. */ 614 int sc_hotspare_no; /* Number of hotspares. */ 615 616 struct ksensordev sc_sensordev; 617 struct sensor_task *sc_sensor_task; 618 619 struct scsi_link sc_link; /* scsi prototype link */ 620 struct scsibus_softc *sc_scsibus; 621 622 /* 623 * XXX expensive, alternative would be nice but has to be cheap 624 * since the target lookup happens on each IO 625 */ 626 struct sr_discipline *sc_dis[SR_MAX_LD]; 627 }; 628 629 /* hotplug */ 630 void sr_hotplug_register(struct sr_discipline *, void *); 631 void sr_hotplug_unregister(struct sr_discipline *, void *); 632 633 /* Hotspare and rebuild. */ 634 void sr_hotspare_rebuild_callback(void *, void *); 635 636 /* work units & ccbs */ 637 int sr_ccb_alloc(struct sr_discipline *); 638 void sr_ccb_free(struct sr_discipline *); 639 struct sr_ccb *sr_ccb_get(struct sr_discipline *); 640 void sr_ccb_put(struct sr_ccb *); 641 int sr_wu_alloc(struct sr_discipline *); 642 void sr_wu_free(struct sr_discipline *); 643 void *sr_wu_get(void *); 644 void sr_wu_put(void *, void *); 645 646 /* misc functions */ 647 void sr_info(struct sr_softc *, const char *, ...); 648 void sr_warn(struct sr_softc *, const char *, ...); 649 void sr_error(struct sr_softc *, const char *, ...); 650 int32_t sr_validate_stripsize(u_int32_t); 651 int sr_meta_read(struct sr_discipline *); 652 int sr_meta_native_read(struct sr_discipline *, dev_t, 653 struct sr_metadata *, void *); 654 int sr_meta_validate(struct sr_discipline *, dev_t, 655 struct sr_metadata *, void *); 656 void sr_meta_save_callback(void *, void *); 657 int sr_meta_save(struct sr_discipline *, u_int32_t); 658 void sr_meta_getdevname(struct sr_softc *, dev_t, char *, 659 int); 660 void sr_meta_opt_load(struct sr_softc *, 661 struct sr_metadata *, struct sr_meta_opt_head *); 662 void sr_checksum(struct sr_softc *, void *, void *, 663 u_int32_t); 664 int sr_validate_io(struct sr_workunit *, daddr64_t *, 665 char *); 666 int sr_check_io_collision(struct sr_workunit *); 667 void sr_scsi_done(struct sr_discipline *, 668 struct scsi_xfer *); 669 int sr_chunk_in_use(struct sr_softc *, dev_t); 670 671 /* discipline functions */ 672 int sr_raid_inquiry(struct sr_workunit *); 673 int sr_raid_read_cap(struct sr_workunit *); 674 int sr_raid_tur(struct sr_workunit *); 675 int sr_raid_request_sense( struct sr_workunit *); 676 int sr_raid_start_stop(struct sr_workunit *); 677 int sr_raid_sync(struct sr_workunit *); 678 void sr_raid_startwu(struct sr_workunit *); 679 680 /* Discipline specific initialisation. */ 681 void sr_raid0_discipline_init(struct sr_discipline *); 682 void sr_raid1_discipline_init(struct sr_discipline *); 683 void sr_raidp_discipline_init(struct sr_discipline *, 684 u_int8_t); 685 void sr_raid6_discipline_init(struct sr_discipline *); 686 void sr_crypto_discipline_init(struct sr_discipline *); 687 void sr_concat_discipline_init(struct sr_discipline *); 688 void sr_aoe_discipline_init(struct sr_discipline *); 689 void sr_aoe_server_discipline_init(struct sr_discipline *); 690 691 /* Crypto discipline hooks. */ 692 int sr_crypto_get_kdf(struct bioc_createraid *, 693 struct sr_discipline *); 694 int sr_crypto_create_keys(struct sr_discipline *); 695 struct sr_chunk * sr_crypto_create_key_disk(struct sr_discipline *, dev_t); 696 struct sr_chunk * sr_crypto_read_key_disk(struct sr_discipline *, dev_t); 697 698 #ifdef SR_DEBUG 699 void sr_dump_mem(u_int8_t *, int); 700 #endif 701 702 #endif /* _KERNEL */ 703 704 #endif /* SOFTRAIDVAR_H */ 705