1 /* $OpenBSD: softraidvar.h,v 1.81 2009/08/09 14:12:25 marco 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 <crypto/md5.h> 23 #include <sys/vnode.h> 24 25 #define SR_UUID_MAX 16 26 struct sr_uuid { 27 u_int8_t sui_id[SR_UUID_MAX]; 28 } __packed; 29 30 #define SR_HOTSPARE_LEVEL 0xffffffff 31 #define SR_HOTSPARE_VOLID 0xffffffff 32 33 #define SR_META_SIZE 64 /* save space at chunk beginning */ 34 #define SR_META_OFFSET 16 /* skip 8192 bytes at chunk beginning */ 35 #define SR_META_VERSION 3 /* bump when sr_metadata changes */ 36 struct sr_metadata { 37 struct sr_meta_invariant { 38 /* do not change order of ssd_magic, ssd_version */ 39 u_int64_t ssd_magic; /* magic id */ 40 #define SR_MAGIC 0x4d4152436372616dLLU 41 u_int32_t ssd_version; /* meta data version */ 42 u_int32_t ssd_flags; 43 struct sr_uuid ssd_uuid; /* unique identifier */ 44 45 /* chunks */ 46 u_int32_t ssd_chunk_no; /* number of chunks */ 47 u_int32_t ssd_chunk_id; /* chunk identifier */ 48 49 /* optional */ 50 u_int32_t ssd_opt_no; /* nr of optional md elements */ 51 u_int32_t ssd_pad; 52 53 /* volume metadata */ 54 u_int32_t ssd_volid; /* volume id */ 55 u_int32_t ssd_level; /* raid level */ 56 int64_t ssd_size; /* virt disk size in blocks */ 57 char ssd_vendor[8]; /* scsi vendor */ 58 char ssd_product[16];/* scsi product */ 59 char ssd_revision[4];/* scsi revision */ 60 /* optional volume members */ 61 u_int32_t ssd_strip_size; /* strip size */ 62 } _sdd_invariant; 63 #define ssdi _sdd_invariant 64 /* MD5 of invariant metadata */ 65 u_int8_t ssd_checksum[MD5_DIGEST_LENGTH]; 66 char ssd_devname[32];/* /dev/XXXXX */ 67 u_int32_t ssd_meta_flags; 68 #define SR_META_DIRTY 0x1 69 u_int32_t ssd_pad; 70 u_int64_t ssd_ondisk; /* on disk version counter */ 71 int64_t ssd_rebuild; /* last block of rebuild */ 72 } __packed; 73 74 struct sr_meta_chunk { 75 struct sr_meta_chunk_invariant { 76 u_int32_t scm_volid; /* vd we belong to */ 77 u_int32_t scm_chunk_id; /* chunk id */ 78 char scm_devname[32];/* /dev/XXXXX */ 79 int64_t scm_size; /* size of partition in blocks*/ 80 int64_t scm_coerced_size; /* coerced sz of part in blk*/ 81 struct sr_uuid scm_uuid; /* unique identifier */ 82 } _scm_invariant; 83 #define scmi _scm_invariant 84 /* MD5 of invariant chunk metadata */ 85 u_int8_t scm_checksum[MD5_DIGEST_LENGTH]; 86 u_int32_t scm_status; /* use bio bioc_disk status */ 87 } __packed; 88 89 #define SR_CRYPTO_MAXKEYBYTES 32 /* max bytes in a key (AES-XTS-256) */ 90 #define SR_CRYPTO_MAXKEYS 32 /* max keys per volume */ 91 #define SR_CRYPTO_KEYBITS 512 /* AES-XTS with 2 * 256 bit keys */ 92 #define SR_CRYPTO_KEYBYTES (SR_CRYPTO_KEYBITS >> 3) 93 #define SR_CRYPTO_KDFHINTBYTES 256 /* size of opaque KDF hint */ 94 #define SR_CRYPTO_CHECKBYTES 64 /* size of generic key chksum struct */ 95 #define SR_CRYPTO_KEY_BLKSHIFT 30 /* 0.5TB per key */ 96 97 /* 98 * Check that HMAC-SHA1_k(decrypted scm_key) == sch_mac, where 99 * k = SHA1(masking key) 100 */ 101 struct sr_crypto_chk_hmac_sha1 { 102 u_int8_t sch_mac[20]; 103 } __packed; 104 105 struct sr_meta_crypto { 106 u_int32_t scm_alg; /* vol crypto algorithm */ 107 #define SR_CRYPTOA_AES_XTS_128 1 108 #define SR_CRYPTOA_AES_XTS_256 2 109 u_int32_t scm_flags; /* key & kdfhint valid */ 110 #define SR_CRYPTOF_INVALID (0) 111 #define SR_CRYPTOF_KEY (1<<0) 112 #define SR_CRYPTOF_KDFHINT (1<<1) 113 u_int32_t scm_mask_alg; /* disk key masking crypt alg */ 114 #define SR_CRYPTOM_AES_ECB_256 1 115 u_int32_t scm_pad1; 116 u_int8_t scm_reserved[64]; 117 118 /* symmetric keys used for disk encryption */ 119 u_int8_t scm_key[SR_CRYPTO_MAXKEYS][SR_CRYPTO_KEYBYTES]; 120 /* hint to kdf algorithm (opaque to kernel) */ 121 u_int8_t scm_kdfhint[SR_CRYPTO_KDFHINTBYTES]; 122 123 u_int32_t scm_check_alg; /* key chksum algorithm */ 124 #define SR_CRYPTOC_HMAC_SHA1 1 125 u_int32_t scm_pad2; 126 union { 127 struct sr_crypto_chk_hmac_sha1 chk_hmac_sha1; 128 u_int8_t chk_reserved2[64]; 129 } _scm_chk; 130 #define chk_hmac_sha1 _scm_chk.chk_hmac_sha1 131 } __packed; 132 133 struct sr_meta_opt { 134 struct sr_meta_opt_invariant { 135 u_int32_t som_type; /* optional type */ 136 #define SR_OPT_INVALID 0x00 137 #define SR_OPT_CRYPTO 0x01 138 u_int32_t som_pad; 139 union { 140 struct sr_meta_crypto smm_crypto; 141 } som_meta; 142 } _som_invariant; 143 #define somi _som_invariant 144 #define somi_crypto _som_invariant.smm_crypto 145 /* MD5 of invariant optional metadata */ 146 u_int8_t som_checksum[MD5_DIGEST_LENGTH]; 147 } __packed; 148 149 /* this is a generic hint for KDF done in userland, not interpreted by the kernel. */ 150 struct sr_crypto_genkdf { 151 u_int32_t len; 152 u_int32_t type; 153 #define SR_CRYPTOKDFT_INVALID (0) 154 #define SR_CRYPTOKDFT_PBKDF2 (1<<0) 155 }; 156 157 /* this is a hint for KDF using PKCS#5. Not interpreted by the kernel */ 158 struct sr_crypto_kdf_pbkdf2 { 159 u_int32_t len; 160 u_int32_t type; 161 u_int32_t rounds; 162 u_int8_t salt[128]; 163 }; 164 165 /* 166 * this structure is used to copy masking keys and KDF hints from/to userland. 167 * the embedded hint structures are not interpreted by the kernel. 168 */ 169 struct sr_crypto_kdfinfo { 170 u_int32_t len; 171 u_int32_t flags; 172 #define SR_CRYPTOKDF_INVALID (0) 173 #define SR_CRYPTOKDF_KEY (1<<0) 174 #define SR_CRYPTOKDF_HINT (1<<1) 175 u_int8_t maskkey[SR_CRYPTO_MAXKEYBYTES]; 176 union { 177 struct sr_crypto_genkdf generic; 178 struct sr_crypto_kdf_pbkdf2 pbkdf2; 179 } _kdfhint; 180 #define genkdf _kdfhint.generic 181 #define pbkdf2 _kdfhint.pbkdf2 182 }; 183 184 #ifdef _KERNEL 185 #include <dev/biovar.h> 186 187 #include <sys/buf.h> 188 #include <sys/pool.h> 189 #include <sys/queue.h> 190 #include <sys/rwlock.h> 191 192 #include <scsi/scsi_all.h> 193 #include <scsi/scsi_disk.h> 194 #include <scsi/scsiconf.h> 195 196 #define DEVNAME(_s) ((_s)->sc_dev.dv_xname) 197 198 /* #define SR_DEBUG */ 199 #ifdef SR_DEBUG 200 extern u_int32_t sr_debug; 201 #define DPRINTF(x...) do { if (sr_debug) printf(x); } while(0) 202 #define DNPRINTF(n,x...) do { if (sr_debug & n) printf(x); } while(0) 203 #define SR_D_CMD 0x0001 204 #define SR_D_INTR 0x0002 205 #define SR_D_MISC 0x0004 206 #define SR_D_IOCTL 0x0008 207 #define SR_D_CCB 0x0010 208 #define SR_D_WU 0x0020 209 #define SR_D_META 0x0040 210 #define SR_D_DIS 0x0080 211 #define SR_D_STATE 0x0100 212 #else 213 #define DPRINTF(x...) 214 #define DNPRINTF(n,x...) 215 #endif 216 217 #define SR_MAXFER MAXPHYS 218 #define SR_MAX_LD 1 219 #define SR_MAX_CMDS 16 220 #define SR_MAX_STATES 7 221 #define SR_VM_IGNORE_DIRTY 1 222 #define SR_REBUILD_IO_SIZE 128 /* blocks */ 223 224 /* forward define to prevent dependency goo */ 225 struct sr_softc; 226 227 struct sr_ccb { 228 struct buf ccb_buf; /* MUST BE FIRST!! */ 229 230 struct sr_workunit *ccb_wu; 231 struct sr_discipline *ccb_dis; 232 233 int ccb_target; 234 int ccb_state; 235 #define SR_CCB_FREE 0 236 #define SR_CCB_INPROGRESS 1 237 #define SR_CCB_OK 2 238 #define SR_CCB_FAILED 3 239 240 int ccb_flag; 241 #define SR_CCBF_FREEBUF (1<<0) /* free ccb_buf.b_data */ 242 243 void *ccb_opaque; /* discipline usable pointer */ 244 245 TAILQ_ENTRY(sr_ccb) ccb_link; 246 }; 247 248 TAILQ_HEAD(sr_ccb_list, sr_ccb); 249 250 struct sr_workunit { 251 struct scsi_xfer *swu_xs; 252 struct sr_discipline *swu_dis; 253 254 int swu_state; 255 #define SR_WU_FREE 0 256 #define SR_WU_INPROGRESS 1 257 #define SR_WU_OK 2 258 #define SR_WU_FAILED 3 259 #define SR_WU_PARTIALLYFAILED 4 260 #define SR_WU_DEFERRED 5 261 #define SR_WU_PENDING 6 262 #define SR_WU_RESTART 7 263 #define SR_WU_REQUEUE 8 264 265 int swu_flags; /* additional hints */ 266 #define SR_WUF_REBUILD (1<<0) /* rebuild io */ 267 #define SR_WUF_REBUILDIOCOMP (1<<1) /* rbuild io complete */ 268 #define SR_WUF_FAIL (1<<2) /* RAID6: failure */ 269 #define SR_WUF_FAILIOCOMP (1<<3) 270 271 int swu_fake; /* faked wu */ 272 /* workunit io range */ 273 daddr64_t swu_blk_start; 274 daddr64_t swu_blk_end; 275 276 /* in flight totals */ 277 u_int32_t swu_ios_complete; 278 u_int32_t swu_ios_failed; 279 u_int32_t swu_ios_succeeded; 280 281 /* number of ios that makes up the whole work unit */ 282 u_int32_t swu_io_count; 283 284 /* colliding wu */ 285 struct sr_workunit *swu_collider; 286 287 /* all ios that make up this workunit */ 288 struct sr_ccb_list swu_ccb; 289 290 TAILQ_ENTRY(sr_workunit) swu_link; 291 }; 292 293 TAILQ_HEAD(sr_wu_list, sr_workunit); 294 295 /* RAID 0 */ 296 #define SR_RAID0_NOWU 16 297 struct sr_raid0 { 298 int32_t sr0_strip_bits; 299 }; 300 301 /* RAID 1 */ 302 #define SR_RAID1_NOWU 16 303 struct sr_raid1 { 304 u_int32_t sr1_counter; 305 }; 306 307 /* RAID 4 */ 308 #define SR_RAIDP_NOWU 16 309 struct sr_raidp { 310 int32_t srp_strip_bits; 311 }; 312 313 /* RAID 6 */ 314 #define SR_RAID6_NOWU 16 315 struct sr_raid6 { 316 int32_t sr6_strip_bits; 317 }; 318 319 /* CRYPTO */ 320 #define SR_CRYPTO_NOWU 16 321 struct sr_crypto { 322 struct sr_meta_crypto scr_meta; 323 324 struct pool sr_uiopl; 325 struct pool sr_iovpl; 326 327 /* XXX only keep scr_sid over time */ 328 u_int8_t scr_key[SR_CRYPTO_MAXKEYS][SR_CRYPTO_KEYBYTES]; 329 u_int8_t scr_maskkey[SR_CRYPTO_MAXKEYBYTES]; 330 u_int64_t scr_sid[SR_CRYPTO_MAXKEYS]; 331 }; 332 333 /* ata over ethernet */ 334 #define SR_RAIDAOE_NOWU 2 335 struct sr_aoe { 336 struct aoe_handler *sra_ah; 337 int sra_tag; 338 struct ifnet *sra_ifp; 339 char sra_eaddr[6]; 340 }; 341 342 struct sr_metadata_list { 343 u_int8_t sml_metadata[SR_META_SIZE * 512]; 344 dev_t sml_mm; 345 struct vnode *sml_vn; 346 u_int32_t sml_chunk_id; 347 int sml_used; 348 349 SLIST_ENTRY(sr_metadata_list) sml_link; 350 }; 351 352 SLIST_HEAD(sr_metadata_list_head, sr_metadata_list); 353 354 struct sr_boot_volume { 355 struct sr_uuid sbv_uuid; /* Volume UUID. */ 356 u_int32_t sbv_level; /* Level. */ 357 u_int32_t sbv_volid; /* Volume ID. */ 358 u_int32_t sbv_chunk_no; /* Number of chunks. */ 359 u_int32_t sbv_dev_no; /* Number of devs discovered. */ 360 361 struct sr_metadata_list_head sml; /* List of metadata. */ 362 363 SLIST_ENTRY(sr_boot_volume) sbv_link; 364 }; 365 366 SLIST_HEAD(sr_boot_volume_head, sr_boot_volume); 367 368 struct sr_chunk { 369 struct sr_meta_chunk src_meta; /* chunk meta data */ 370 struct sr_meta_opt src_opt; /* optional metadata */ 371 372 /* runtime data */ 373 dev_t src_dev_mm; /* major/minor */ 374 struct vnode *src_vn; /* vnode */ 375 376 /* helper members before metadata makes it onto the chunk */ 377 int src_meta_ondisk;/* set when meta is on disk */ 378 char src_devname[32]; 379 int64_t src_size; /* in blocks */ 380 381 SLIST_ENTRY(sr_chunk) src_link; 382 }; 383 384 SLIST_HEAD(sr_chunk_head, sr_chunk); 385 386 struct sr_volume { 387 /* runtime data */ 388 struct sr_chunk_head sv_chunk_list; /* linked list of all chunks */ 389 struct sr_chunk **sv_chunks; /* array to same chunks */ 390 391 /* sensors */ 392 struct ksensor sv_sensor; 393 struct ksensordev sv_sensordev; 394 int sv_sensor_valid; 395 }; 396 397 struct sr_discipline { 398 struct sr_softc *sd_sc; /* link back to sr softc */ 399 u_int8_t sd_type; /* type of discipline */ 400 #define SR_MD_RAID0 0 401 #define SR_MD_RAID1 1 402 #define SR_MD_RAID5 2 403 #define SR_MD_CACHE 3 404 #define SR_MD_CRYPTO 4 405 #define SR_MD_AOE_INIT 5 406 #define SR_MD_AOE_TARG 6 407 #define SR_MD_RAID4 7 408 #define SR_MD_RAID6 8 409 char sd_name[10]; /* human readable dis name */ 410 u_int8_t sd_scsibus; /* scsibus discipline uses */ 411 struct scsi_link sd_link; /* link to midlayer */ 412 413 union { 414 struct sr_raid0 mdd_raid0; 415 struct sr_raid1 mdd_raid1; 416 struct sr_raidp mdd_raidp; 417 struct sr_raid6 mdd_raid6; 418 struct sr_crypto mdd_crypto; 419 #ifdef AOE 420 struct sr_aoe mdd_aoe; 421 #endif /* AOE */ 422 } sd_dis_specific;/* dis specific members */ 423 #define mds sd_dis_specific 424 425 /* discipline metadata */ 426 struct sr_metadata *sd_meta; /* in memory copy of metadata */ 427 void *sd_meta_foreign; /* non native metadata */ 428 u_int32_t sd_meta_flags; 429 int sd_meta_type; /* metadata functions */ 430 431 int sd_sync; 432 int sd_must_flush; 433 434 int sd_deleted; 435 436 struct device *sd_scsibus_dev; 437 void (*sd_shutdownhook)(void *); 438 439 /* discipline volume */ 440 struct sr_volume sd_vol; /* volume associated */ 441 int sd_vol_status; /* runtime vol status */ 442 /* discipline resources */ 443 struct sr_ccb *sd_ccb; 444 struct sr_ccb_list sd_ccb_freeq; 445 u_int32_t sd_max_ccb_per_wu; 446 447 struct sr_workunit *sd_wu; /* all workunits */ 448 u_int32_t sd_max_wu; 449 int sd_rebuild; /* can we rebuild? */ 450 int sd_reb_active; /* rebuild in progress */ 451 int sd_reb_abort; /* abort rebuild */ 452 int sd_ready; /* fully operational */ 453 454 struct sr_wu_list sd_wu_freeq; /* free wu queue */ 455 struct sr_wu_list sd_wu_pendq; /* pending wu queue */ 456 struct sr_wu_list sd_wu_defq; /* deferred wu queue */ 457 int sd_wu_sleep; /* wu sleepers counter */ 458 459 /* discipline stats */ 460 int sd_wu_pending; 461 u_int64_t sd_wu_collisions; 462 463 /* discipline functions */ 464 int (*sd_alloc_resources)(struct sr_discipline *); 465 int (*sd_free_resources)(struct sr_discipline *); 466 int (*sd_start_discipline)(struct sr_discipline *); 467 void (*sd_set_chunk_state)(struct sr_discipline *, 468 int, int); 469 void (*sd_set_vol_state)(struct sr_discipline *); 470 int (*sd_openings)(struct sr_discipline *); 471 472 /* SCSI emulation */ 473 struct scsi_sense_data sd_scsi_sense; 474 int (*sd_scsi_rw)(struct sr_workunit *); 475 int (*sd_scsi_sync)(struct sr_workunit *); 476 int (*sd_scsi_tur)(struct sr_workunit *); 477 int (*sd_scsi_start_stop)(struct sr_workunit *); 478 int (*sd_scsi_inquiry)(struct sr_workunit *); 479 int (*sd_scsi_read_cap)(struct sr_workunit *); 480 int (*sd_scsi_req_sense)(struct sr_workunit *); 481 482 /* background operation */ 483 struct proc *sd_background_proc; 484 }; 485 486 struct sr_softc { 487 struct device sc_dev; 488 489 int (*sc_ioctl)(struct device *, u_long, caddr_t); 490 491 struct rwlock sc_lock; 492 493 struct sr_chunk_head sc_hotspare_list; /* List of hotspares. */ 494 struct sr_chunk **sc_hotspares; /* Array to hotspare chunks. */ 495 struct rwlock sc_hs_lock; /* Lock for hotspares list. */ 496 int sc_hotspare_no; /* Number of hotspares. */ 497 498 int sc_sensors_running; 499 /* 500 * during scsibus attach this is the discipline that is in use 501 * this variable is protected by sc_lock and splhigh 502 */ 503 struct sr_discipline *sc_attach_dis; 504 505 /* 506 * XXX expensive, alternative would be nice but has to be cheap 507 * since the scsibus lookup happens on each IO 508 */ 509 #define SR_MAXSCSIBUS 256 510 struct sr_discipline *sc_dis[SR_MAXSCSIBUS]; /* scsibus is u_int8_t */ 511 }; 512 513 /* hotplug */ 514 void sr_hotplug_register(struct sr_discipline *, void *); 515 void sr_hotplug_unregister(struct sr_discipline *, void *); 516 517 /* Hotspare and rebuild. */ 518 void sr_hotspare_rebuild_callback(void *, void *); 519 520 /* work units & ccbs */ 521 int sr_ccb_alloc(struct sr_discipline *); 522 void sr_ccb_free(struct sr_discipline *); 523 struct sr_ccb *sr_ccb_get(struct sr_discipline *); 524 void sr_ccb_put(struct sr_ccb *); 525 int sr_wu_alloc(struct sr_discipline *); 526 void sr_wu_free(struct sr_discipline *); 527 struct sr_workunit *sr_wu_get(struct sr_discipline *, int); 528 void sr_wu_put(struct sr_workunit *); 529 530 /* misc functions */ 531 int32_t sr_validate_stripsize(u_int32_t); 532 void sr_meta_save_callback(void *, void *); 533 int sr_validate_io(struct sr_workunit *, daddr64_t *, 534 char *); 535 int sr_check_io_collision(struct sr_workunit *); 536 void sr_scsi_done(struct sr_discipline *, 537 struct scsi_xfer *); 538 539 /* discipline functions */ 540 int sr_raid_inquiry(struct sr_workunit *); 541 int sr_raid_read_cap(struct sr_workunit *); 542 int sr_raid_tur(struct sr_workunit *); 543 int sr_raid_request_sense( struct sr_workunit *); 544 int sr_raid_start_stop(struct sr_workunit *); 545 int sr_raid_sync(struct sr_workunit *); 546 void sr_raid_startwu(struct sr_workunit *); 547 548 /* Discipline specific initialisation. */ 549 void sr_raid0_discipline_init(struct sr_discipline *); 550 void sr_raid1_discipline_init(struct sr_discipline *); 551 void sr_raidp_discipline_init(struct sr_discipline *); 552 void sr_raid6_discipline_init(struct sr_discipline *); 553 void sr_crypto_discipline_init(struct sr_discipline *); 554 void sr_aoe_discipline_init(struct sr_discipline *); 555 void sr_aoe_server_discipline_init(struct sr_discipline *); 556 557 /* raid 1 */ 558 /* XXX - currently (ab)used by AOE and CRYPTO. */ 559 void sr_raid1_set_chunk_state(struct sr_discipline *, 560 int, int); 561 void sr_raid1_set_vol_state(struct sr_discipline *); 562 563 /* Crypto discipline hooks. */ 564 int sr_crypto_get_kdf(struct bioc_createraid *, 565 struct sr_discipline *); 566 int sr_crypto_create_keys(struct sr_discipline *); 567 568 #ifdef SR_DEBUG 569 void sr_dump_mem(u_int8_t *, int); 570 #endif 571 572 #endif /* _KERNEL */ 573 574 #endif /* SOFTRAIDVAR_H */ 575