1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #ifndef _SYS_MDVAR_H 27 #define _SYS_MDVAR_H 28 29 #pragma ident "%Z%%M% %I% %E% SMI" 30 31 #include <sys/types.h> 32 #include <sys/kmem.h> 33 #include <sys/mkdev.h> 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/t_lock.h> 37 #include <sys/open.h> 38 #include <sys/devops.h> 39 #include <sys/modctl.h> 40 #ifdef DEBUG 41 #include <sys/thread.h> 42 #endif 43 #include <sys/kstat.h> 44 #include <sys/efi_partition.h> 45 #include <sys/byteorder.h> 46 #include <sys/door.h> 47 48 #include <sys/lvm/mdmn_commd.h> 49 #include <sys/lvm/mdio.h> 50 #include <sys/lvm/md_mdiox.h> 51 #include <sys/lvm/md_mddb.h> 52 #include <sys/lvm/md_notify.h> 53 54 #ifdef __cplusplus 55 extern "C" { 56 #endif 57 58 /* 59 * defaults 60 */ 61 #define NMD_DEFAULT 128 /* number of metadevices */ 62 #define MD_NOPS 25 /* number of misc modules */ 63 #define MAXBOOTLIST 64 64 65 /* 66 * Needed for backwards-compatibility with metadevices created under 67 * 2.6 or earlier. Back then, a krwlock_t was twelve bytes. More 68 * recently, it's four bytes. Since these get included in structures 69 * written out to disk, we have to make sure we're using the largest 70 * size. Things will get interesting if krwlock_t ever gets bigger 71 * than twelve bytes. 72 */ 73 74 typedef union _md_krwlock { 75 krwlock_t lock; 76 struct { 77 void *_opaque[3]; 78 } xx; 79 } md_krwlock_t; 80 81 typedef struct { 82 kmutex_t md_io_mx; /* counter mutex */ 83 kcondvar_t md_io_cv; /* ioctl wait on if draining */ 84 long io_cnt; /* number of I/Os */ 85 long io_state; /* !0 if waiting on zero */ 86 } md_set_io_t; 87 88 typedef enum set_iostate { 89 MD_SET_ACTIVE = 1, 90 MD_SET_RELEASE = 2 91 }set_iostate_t; 92 93 /* 94 * for md_dev64_t translation 95 */ 96 struct md_xlate_table { 97 dev32_t mini_devt; 98 dev32_t targ_devt; 99 }; 100 101 extern struct md_xlate_table *md_tuple_table; 102 103 /* 104 * for major number translation 105 */ 106 107 struct md_xlate_major_table { 108 char *drv_name; 109 major_t targ_maj; 110 }; 111 112 extern struct md_xlate_major_table *md_major_tuple_table; 113 114 extern int md_tuple_length; 115 extern uint_t md_majortab_len; 116 extern int md_in_upgrade; 117 118 extern md_mn_nodeid_t md_mn_mynode_id; 119 120 #define MD_UPGRADE (md_in_upgrade == 1) 121 122 /* 123 * Flags used during upgrade: 124 * 125 * md_keep_repl_state flag means that mddb should be kept in the format 126 * that was found on disk (non-device id format vs. device id format). 127 * This is used during the upgrade process when install is probing 128 * for root disks so that the user can choose the one to be upgraded. 129 * 130 * md_devid_destroy flag is used to destroy device ids stored in the 131 * metadevice state database (mddb). 132 * 133 * The md_devid_destroy flag is to be used only in a catastrophic failure 134 * case. An example of this would be if a user upgrades firmware on all 135 * disks where this causes the disks to now have different device id's. 136 * The user would not be able to boot a mirror'd root filesystem since the 137 * system would recognize none of the device id's stored in the mddb. 138 * This flag would destroy all device id information stored in the mddb and 139 * if the md_keep_repl_state flag was not set, the mddb would be reconverted 140 * to device id format on SLVM startup and all of the device id 141 * information would be regenerated. 142 * 143 * If the md_devid_destroy flag is set and the md_keep_repl_state flag is 144 * set, the mddb's would have their device id information destroyed and 145 * would be left in non-devid format since the device id information would 146 * not be regenerated. 147 * 148 * This flag is not documented anywhere and is only to be used as a last 149 * resort as in the described case or if a device driver has a bug where 150 * device id's are found to not be unique. If device id's aren't unique, 151 * the user could run without device id's until a patch is released for 152 * that driver. 153 */ 154 extern int md_keep_repl_state; 155 extern int md_devid_destroy; 156 extern int mdmn_door_did; 157 #ifdef _KERNEL 158 extern door_handle_t mdmn_door_handle; 159 #endif /* _KERNEL */ 160 161 /* 162 * An io_lock mechanism for raid, the MD_UL_XXXX bits are used for 163 * convenience. 164 */ 165 typedef struct md_io_lock { 166 ulong_t io_readercnt; /* number of unit readers */ 167 ulong_t io_wanabecnt; /* # pending on becoming unit writer */ 168 ulong_t io_lock; 169 void *io_list_front; 170 void *io_list_back; 171 kmutex_t io_mx; 172 kcondvar_t io_cv; 173 kmutex_t io_list_mutex; /* list of waiting io */ 174 kthread_id_t io_owner; /* writer thread */ 175 } md_io_lock_t; 176 177 /* 178 * The following flags are in un_flag field of mdc_unit struct. 179 */ 180 #define MD_LABELED 0x1 /* First sector of the metadevice is a label */ 181 #define MD_EFILABEL 0x2 /* This md has an EFI label and no vtoc */ 182 183 /* 184 * This is the number of bytes a DKIOCGETEFI ioctl returns 185 * For now it's one time the header and once the size for a partition info 186 */ 187 #define MD_EFI_LABEL_SIZE (sizeof (efi_gpt_t) + sizeof (efi_gpe_t)) 188 189 /* This is the number of bytes consumed by efi_gpe_PartitionName */ 190 #define MD_EFI_PARTNAME_BYTES (EFI_PART_NAME_LEN * sizeof (ushort_t)) 191 192 typedef enum hs_cmds { 193 HS_GET, HS_FREE, HS_BAD, HSP_INCREF, HSP_DECREF, HS_MKDEV 194 } hs_cmds_t; 195 196 typedef struct md_link { 197 struct md_link *ln_next; 198 set_t ln_setno; 199 uint_t ln_id; 200 } md_link_t; 201 202 typedef struct mdi_unit { 203 md_link_t ui_link; 204 ulong_t ui_readercnt; /* number of unit readers */ 205 ulong_t ui_wanabecnt; /* # pending on becoming unit writer */ 206 ulong_t ui_lock; 207 kmutex_t ui_mx; 208 kcondvar_t ui_cv; 209 int ui_opsindex; 210 uint_t ui_ocnt[OTYPCNT]; /* open counts */ 211 md_io_lock_t *ui_io_lock; /* pointer to io lock */ 212 kstat_t *ui_kstat; /* kernel statistics */ 213 kthread_id_t ui_owner; /* writer thread */ 214 uint_t ui_tstate; /* transient state bits */ 215 uint_t ui_capab; /* Capability bits supported */ 216 } mdi_unit_t; 217 218 /* 219 * Following are used with ui_lock 220 * which is in the unit incore structure. 221 */ 222 #define MD_UL_WRITER 0x0001 /* Stall all new strategy calls */ 223 #define MD_UL_WANABEWRITER 0x0002 224 #define MD_UL_OPENORCLOSE 0x0004 225 226 #define MD_UL_OPEN 0x0008 /* unit is open */ 227 #define MD_UL_EXCL 0x0010 /* unit is open exclusively */ 228 229 /* 230 * The softpart open code may do an I/O to validate the watermarks 231 * and should hold no open locks during this I/O. So, mark the unit 232 * as OPENINPROGRESS and drop the locks. This will keep any other 233 * softpart open's waiting until the validate has completed. 234 */ 235 #define MD_UL_OPENINPROGRESS 0x0020 /* Open in Progress */ 236 237 /* 238 * Following are used with ui_tstate to specify any transient states which 239 * occur during metadevice operation. These are not written to the metadb as 240 * they do not represent a failure of the underlying metadevice. 241 * Transient errors are stored in the lower 16 bits and other transient 242 * state is stored in the upper 16 bits. 243 * MD_NOTOPENABLE should contain all the states that are set prior to an 244 * open (by snarf) and that indicate that a metadevice cannot be opened. 245 */ 246 #define MD_DEV_ERRORED 0x0000ffff /* ui_tstate error bits */ 247 #define MD_EOF_METADEVICE 0x00000001 /* EOF'd metadevice */ 248 #define MD_64MD_ON_32KERNEL 0x00000002 /* 64bit metadev on 32bit kernel */ 249 #define MD_INACCESSIBLE 0x00000004 /* metadevice unavailable */ 250 #define MD_RETRYING 0x00010000 /* retrying errored failfast I/O */ 251 #define MD_OPENLOCKED 0x00020000 /* MN: open locked before removing */ 252 #define MD_ERR_PENDING 0x00040000 /* MN: error pending */ 253 #define MD_ABR_CAP 0x00080000 /* MN: Application Based Recovery */ 254 #define MD_DMR_CAP 0x00100000 /* MN: Directed Mirror Read */ 255 #define MD_RELEASE_IOERR_DONE 0x00200000 /* ioerr console message done */ 256 #define MD_RESYNC_NOT_DONE 0x00400000 /* resync not done yet */ 257 258 /* A metadevice cannot be opened when these states are set */ 259 #define MD_NOTOPENABLE (MD_EOF_METADEVICE|MD_64MD_ON_32KERNEL) 260 261 typedef struct md_ioctl_lock { 262 int l_flags; /* locks held */ 263 mdi_unit_t *l_ui; /* unit for which lock is held */ 264 } md_ioctl_lock_t; 265 266 #define MD_MASTER_DROPPED 0x0001 267 #define MD_READER_HELD 0x0002 268 #define MD_WRITER_HELD 0x0004 269 #define MD_IO_HELD 0x0008 270 #define MD_ARRAY_READER 0x0010 271 #define MD_ARRAY_WRITER 0x0020 272 #define STALE_OK 0x0100 273 #define NO_OLD 0x0200 274 #define NO_LOCK 0x0400 275 #define MD_MT_IOCTL 0x80000 /* MD_GBL_IOCTL_LOCK not set */ 276 #define IOLOCK md_ioctl_lock_t 277 278 #define WR_LOCK MD_WRITER_HELD 279 #define RD_LOCK MD_READER_HELD | STALE_OK 280 #define ARRAY_WRITER MD_ARRAY_WRITER 281 #define ARRAY_READER MD_ARRAY_READER 282 #define WRITERS MD_WRITER_HELD | MD_IO_HELD | MD_ARRAY_WRITER 283 #define READERS RD_LOCK | MD_ARRAY_READER 284 285 #define IOLOCK_RETURN_IOCTLEND(code, lock) \ 286 md_ioctl_lock_exit((code), (lock)->l_flags, (lock)->l_ui, TRUE) 287 288 #define IOLOCK_RETURN(code, lock) \ 289 md_ioctl_lock_exit((code), (lock)->l_flags, (lock)->l_ui, FALSE) 290 291 #define IOLOCK_RETURN_RELEASE(code, lock) \ 292 md_ioctl_releaselocks((code), (lock)->l_flags, (lock)->l_ui) 293 294 #define IOLOCK_RETURN_REACQUIRE(lock) \ 295 md_ioctl_reacquirelocks((lock)->l_flags, (lock)->l_ui) 296 297 #define IOLOCK_INIT(lock) bzero((caddr_t)(lock), sizeof (*(lock))) 298 /* 299 * checks to be sure locks are held 300 */ 301 #define UNIT_WRITER_HELD(un) \ 302 (MDI_UNIT(MD_SID(un))->ui_lock & MD_UL_WRITER) 303 #define UNIT_READER_HELD(un) \ 304 (MDI_UNIT(MD_SID(un))->ui_readercnt != 0) 305 #define IO_WRITER_HELD(un) \ 306 (MDI_UNIT(MD_SID(un))->ui_io_lock->io_lock & MD_UL_WRITER) 307 #define IO_READER_HELD(un) \ 308 (MDI_UNIT(MD_SID(un))->ui_io_lock->io_readercnt != 0) 309 310 #ifdef DEBUG 311 #define STAT_INC(statvar) \ 312 statvar++ 313 #define STAT_DEC(statvar) \ 314 statvar-- 315 #define STAT_ZERO(statvar) \ 316 statvar = 0; 317 #define STAT_MAX(statmax, statvar) \ 318 { \ 319 statvar++; \ 320 if (statvar > statmax) \ 321 statmax = statvar; \ 322 } 323 #define STAT_CHECK(statvar, value) \ 324 { \ 325 if (value) \ 326 statvar++; \ 327 } 328 #else 329 #define STAT_INC(statvar) 330 #define STAT_DEC(statvar) 331 #define STAT_ZERO(statvar) 332 #define STAT_MAX(statmax, statvar) 333 #define STAT_CHECK(statvar, value) 334 #endif 335 /* 336 * bit map related macros 337 */ 338 #define setbit(a, i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY)) 339 #define clrbit(a, i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY))) 340 #define isset(a, i) ((a)[(i)/NBBY] & (1<<((i)%NBBY))) 341 #define isclr(a, i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0) 342 343 typedef struct daemon_queue { 344 int maxq_len; 345 int qlen; 346 int treqs; /* total number of requests */ 347 struct daemon_queue *dq_next; 348 struct daemon_queue *dq_prev; 349 void (*dq_call)(); 350 } daemon_queue_t; 351 352 #define DAEMON_QUEUE daemon_queue_t dq; 353 354 #ifdef _KERNEL 355 #include <sys/buf.h> 356 #include <sys/dkio.h> 357 #include <sys/vtoc.h> 358 359 #define MD_DEV2SET(d) (MD_MIN2SET(md_getminor(d))) 360 361 #define MD_UNIT(m) (md_set[MD_MIN2SET(m)].s_un[MD_MIN2UNIT(m)]) 362 #define MDI_UNIT(m) ((mdi_unit_t *) \ 363 md_set[MD_MIN2SET(m)].s_ui[MD_MIN2UNIT(m)]) 364 #define MD_VOIDUNIT(m) (md_set[MD_MIN2SET(m)].s_un[MD_MIN2UNIT(m)]) 365 #define MDI_VOIDUNIT(m) (md_set[MD_MIN2SET(m)].s_ui[MD_MIN2UNIT(m)]) 366 367 /* 368 * This is the current maximum number of real disks per Virtual Disk. 369 */ 370 extern uint_t md_mdelay; /* md_mirror timeout delay */ 371 372 #define MD_ADM_MINOR L_MAXMIN32 /* the minor number for md_admin */ 373 #define MD_MDELAY (md_mdelay) 374 #define NUM_USEC_IN_SEC 1000000 /* 1 million usec in a second */ 375 376 #define ANY_SERVICE -1 /* md_get_named_service() wild card */ 377 378 /* 379 * daemon threads are used in multiple places in md. The following set of 380 * structures and routines allow a common way to create and initialize them. 381 * 382 * md_requestq_entry_t - entry of creating request queues. 383 * struct mdq_anchor - request queue header 384 * 385 * Functions associated with request queues: 386 * 387 * int init_requestq_entry - 388 * void daemon_request - put a request on the queue. 389 */ 390 391 typedef struct md_requestq_entry { 392 struct mdq_anchor *dispq_headp; 393 int *num_threadsp; /* threads servicing the queue */ 394 } md_requestq_entry_t; 395 396 #define NULL_REQUESTQ_ENTRY(rqp)\ 397 ((rqp)->dispq_headp == NULL || (rqp)->num_threadsp == NULL) 398 399 /* this typedef is used to differentiate between the two call styles */ 400 typedef enum callstyle { 401 REQ_OLD, 402 REQ_NEW 403 } callstyle_t; 404 405 406 #define daemon_request_new daemon_request 407 408 typedef struct mdq_anchor { 409 DAEMON_QUEUE 410 kcondvar_t a_cv; /* Request has been put on queue */ 411 kmutex_t a_mx; 412 } mdq_anchor_t; 413 414 typedef struct daemon_request { 415 DAEMON_QUEUE 416 kmutex_t dr_mx; 417 int dr_pending; 418 timeout_id_t dr_timeout_id; 419 } daemon_request_t; 420 421 typedef struct sv_dev { 422 set_t setno; 423 side_t side; 424 mdkey_t key; 425 } sv_dev_t; 426 427 /* 428 * Types of device probes 429 */ 430 431 432 typedef struct probe_req { 433 DAEMON_QUEUE 434 minor_t mnum; /* mnum of the metadevice to probe */ 435 void *private_handle; /* private handle */ 436 intptr_t (*probe_fcn)(); /* type of probeing to be done */ 437 } probe_req_t; 438 439 /* Global flags */ 440 #define MD_NO_GBL_LOCKS_HELD 0x0000 /* currently holding no global locks */ 441 #define MD_GBL_DAEMONS_LIVE 0x0001 /* master daemon has been started. */ 442 #define MD_GBL_DAEMONS_DIE 0x0002 443 #define MD_GBL_HALTED 0x0004 /* driver is shut down */ 444 445 /* Available bit was GBL_STALE 0x0008 */ 446 447 #define MD_GBL_IOCTL_LOCK 0x0010 /* single-threads ioctls */ 448 #define MD_GBL_HS_LOCK 0x0020 /* single-threads hotspares */ 449 #define MD_GBL_OPEN 0x0040 /* admin is open */ 450 #define MD_GBL_EXCL 0x0080 /* admin is open exclusively */ 451 452 #define MD_OFLG_NULL 0x0000 /* Null flag */ 453 #define MD_OFLG_CONT_ERRS 0x0001 /* Continue on open errors */ 454 #define MD_OFLG_PROBEDEV 0x0002 /* force a simulated open */ 455 #define MD_OFLG_ISINIT 0x0004 /* raid initialization */ 456 #define MD_OFLG_FROMIOCTL 0x0008 /* Called from an ioctl handler */ 457 458 459 typedef struct md_named_services { 460 461 intptr_t (*md_service)(); 462 char *md_name; 463 } md_named_services_t; 464 465 typedef enum md_snarfcmd {MD_SNARF_CLEANUP, MD_SNARF_DOIT} md_snarfcmd_t; 466 467 typedef struct md_ops { 468 int (*md_open)( 469 dev_t *devp, 470 int flag, 471 int otyp, 472 cred_t *credp, 473 int md_oflags); 474 int (*md_close)( 475 dev_t dev, 476 int flag, 477 int otyp, 478 cred_t *credp, 479 int md_oflags); 480 void (*md_strategy)( 481 buf_t *bufp, 482 int flag, 483 void *private); 484 int (*md_print)(); /* unused now */ 485 int (*md_dump)( 486 dev_t dev, 487 caddr_t addr, 488 daddr_t blkno, 489 int nblk); 490 int (*md_read)( 491 dev_t dev, 492 struct uio *uiop, 493 cred_t *credp); 494 int (*md_write)( 495 dev_t dev, 496 struct uio *uiop, 497 cred_t *credp); 498 int (*md_ioctl)( 499 dev_t dev, 500 int cmd, 501 void *data, 502 int mode, 503 IOLOCK *lockp); 504 int (*md_snarf)( 505 md_snarfcmd_t cmd, 506 set_t setno); 507 int (*md_halt)(); 508 int (*md_aread)( 509 dev_t dev, 510 struct aio_req *aiop, 511 cred_t *credp); 512 int (*md_awrite)( 513 dev_t dev, 514 struct aio_req *aiop, 515 cred_t *credp); 516 int (*md_imp_set)( 517 set_t setno); 518 md_named_services_t *md_services; 519 md_krwlock_t md_link_rw; 520 md_link_t *md_head; 521 /* 522 * NOTE: when TSlvm s10/onnv compatibility is not an issue: 523 * o md_modid and md_locked should be deleted. 524 * o md_mod should be added 525 * ddi_modhandle_t md_mod; 526 * and used instead of the md_mods array (md_mods should 527 * be deleted). 528 */ 529 int md_modid; 530 int md_locked; 531 int md_selfindex; 532 struct md_ops *md_next; 533 md_driver_t md_driver; 534 /* NOTE: TSlvm depends on offsets in and sizeof this structure */ 535 } md_ops_t; 536 537 /* macro to generate linkage for a md misc plugin module */ 538 #define md_noop 539 #define MD_PLUGIN_MISC_MODULE(desc, init_init, fini_uninit) \ 540 static struct modlmisc modlmisc = { \ 541 &mod_miscops, "Solaris Volume Manager " desc \ 542 }; \ 543 static struct modlinkage modlinkage = { \ 544 MODREV_1, (void *)&modlmisc, NULL \ 545 }; \ 546 int \ 547 _init(void) \ 548 { \ 549 int i; \ 550 init_init; \ 551 if ((i = mod_install(&modlinkage)) != 0) { \ 552 fini_uninit; \ 553 } \ 554 return (i); \ 555 } \ 556 int \ 557 _fini() \ 558 { \ 559 int i; \ 560 if ((i = mod_remove(&modlinkage)) == 0) { \ 561 fini_uninit; \ 562 } \ 563 return (i); \ 564 } \ 565 int \ 566 _info(struct modinfo *modinfop) \ 567 { \ 568 return (mod_info(&modlinkage, modinfop)); \ 569 } 570 571 typedef enum md_haltcmd {MD_HALT_ALL, MD_HALT_CHECK, MD_HALT_DOIT, 572 MD_HALT_CLOSE, MD_HALT_OPEN, MD_HALT_UNLOAD 573 } md_haltcmd_t; 574 575 /* 576 * To support cpr (Energy Star) we need to know when the resync threads are 577 * running to not allow suspention. 578 */ 579 typedef struct md_resync_thds_cnt { 580 int md_raid_resync; /* count of active raid resync threads */ 581 int md_mirror_resync; /* count of active mirror resync threads */ 582 kmutex_t md_resync_mutex; /* protects both resync counts */ 583 } md_resync_t; 584 585 /* 586 * flags used with call to individual strategy routines 587 */ 588 #define MD_STR_PASSEDON 0x0000ffff 589 #define MD_STR_NOTTOP 0x00000001 590 #define MD_STR_MAPPED 0x00000002 /* set when buf_t is mapped in */ 591 #define MD_STR_ABR 0x00000004 /* use ABR to handle any recovery */ 592 #define MD_STR_WMUPDATE 0x00000008 /* set if updating watermarks for sp */ 593 #define MD_IO_COUNTED 0x00000400 /* io has been counted */ 594 #define MD_NOBLOCK 0x00000800 /* do not block io durring release */ 595 596 #define MD_STR_WAR 0x00010000 /* this write is write after read */ 597 #define MD_STR_WOW 0x00020000 /* handling a write-on-write */ 598 #define MD_STR_DMR 0x00040000 /* Directed Read request */ 599 #define MD_STR_DIRTY_RD 0x00080000 /* Read of a dirty block */ 600 #define MD_STR_FLAG_ERR 0x00100000 /* Flag any write error on this i/o */ 601 602 /* 603 * Bits for return value of md_getdevnum 604 */ 605 #define MD_TRUST_DEVT 1 606 #define MD_NOTRUST_DEVT 0 607 608 /* Flag for drivers to pass to kmem_cache_alloc() */ 609 #define MD_ALLOCFLAGS (KM_PUSHPAGE | KM_SLEEP) 610 611 /* Named services */ 612 #define MD_CHECK_OFFLINE "check_offline" 613 #define MD_INC_ABR_COUNT "inc abr count" 614 #define MD_DEC_ABR_COUNT "dec abr count" 615 616 /* Externals from md.c */ 617 extern int md_snarf_db_set(set_t setno, md_error_t *ep); 618 extern void get_info(struct dk_cinfo *, minor_t); 619 extern void get_minfo(struct dk_minfo *, minor_t); 620 extern int mdstrategy(buf_t *); 621 extern int md_create_minor_node(set_t, minor_t); 622 623 624 /* External from md_subr.c */ 625 extern int md_inc_iocount(set_t); 626 extern void md_inc_iocount_noblock(set_t); 627 extern void md_dec_iocount(set_t); 628 extern int md_isblock_setio(set_t); 629 extern int md_block_setio(set_t); 630 extern void md_clearblock_setio(set_t); 631 extern void md_unblock_setio(set_t); 632 extern int md_tas_block_setio(set_t); 633 extern void md_biodone(struct buf *); 634 extern void md_bioreset(struct buf *); 635 extern md_dev64_t md_xlate_targ_2_mini(md_dev64_t); 636 extern md_dev64_t md_xlate_mini_2_targ(md_dev64_t); 637 extern void md_xlate_free(int); 638 extern major_t md_targ_name_to_major(char *); 639 extern char *md_targ_major_to_name(major_t); 640 extern void md_majortab_free(); 641 extern void md_set_status(int); 642 extern void md_clr_status(int); 643 extern int md_get_status(void); 644 extern void md_set_setstatus(set_t, int); 645 extern void md_clr_setstatus(set_t, int); 646 extern uint_t md_get_setstatus(set_t); 647 extern void *md_unit_readerlock(mdi_unit_t *); 648 extern void *md_unit_writerlock(mdi_unit_t *); 649 extern void md_unit_readerexit(mdi_unit_t *); 650 extern void md_unit_writerexit(mdi_unit_t *); 651 extern void md_ioctl_releaselocks(int, int, mdi_unit_t *); 652 extern void md_ioctl_reacquirelocks(int, mdi_unit_t *); 653 extern int md_ioctl_lock_exit(int, int, mdi_unit_t *, int); 654 extern int md_ioctl_lock_enter(void); 655 extern void *md_ioctl_readerlock(IOLOCK *, mdi_unit_t *); 656 extern void md_ioctl_readerexit(IOLOCK *); 657 extern void *md_ioctl_writerlock(IOLOCK *, mdi_unit_t *); 658 extern void md_ioctl_writerexit(IOLOCK *); 659 extern void md_ioctl_io_exit(IOLOCK *); 660 extern void *md_ioctl_io_lock(IOLOCK *, mdi_unit_t *); 661 extern void md_ioctl_droplocks(IOLOCK *); 662 extern void md_array_writer(IOLOCK *); 663 extern void md_array_reader(IOLOCK *); 664 extern void *md_ioctl_openclose_enter(IOLOCK *, mdi_unit_t *); 665 extern void md_ioctl_openclose_exit(IOLOCK *); 666 extern void md_ioctl_openclose_exit_lh(IOLOCK *); 667 extern void *md_unit_openclose_enter(mdi_unit_t *); 668 extern void md_unit_openclose_exit(mdi_unit_t *); 669 extern void md_unit_openclose_exit_lh(mdi_unit_t *); 670 extern int md_unit_isopen(mdi_unit_t *ui); 671 extern int md_unit_incopen(minor_t mnum, int flag, int otyp); 672 extern int md_unit_decopen(minor_t mnum, int otyp); 673 extern void *md_io_readerlock(mdi_unit_t *); 674 extern void *md_io_writerlock(mdi_unit_t *); 675 extern void md_io_readerexit(mdi_unit_t *); 676 extern void md_io_writerexit(mdi_unit_t *); 677 extern intptr_t (*md_get_named_service())(); 678 extern int init_requestq(md_requestq_entry_t *, void (*)(), 679 caddr_t, int, int); 680 extern void daemon_request(mdq_anchor_t *, void(*)(), 681 daemon_queue_t *, callstyle_t); 682 extern void md_daemon(int, mdq_anchor_t *); 683 extern void mddb_commitrec_wrapper(mddb_recid_t); 684 extern void mddb_commitrecs_wrapper(mddb_recid_t *); 685 extern void mddb_deleterec_wrapper(mddb_recid_t); 686 extern void md_holdset_enter(set_t setno); 687 extern void md_holdset_exit(set_t setno); 688 extern int md_holdset_testandenter(set_t setno); 689 extern void md_haltsnarf_enter(set_t setno); 690 extern void md_haltsnarf_exit(set_t setno); 691 extern void md_haltsnarf_wait(set_t setno); 692 extern int md_halt_set(set_t setno, enum md_haltcmd cmd); 693 extern int md_halt(int global_lock_flag); 694 extern int md_layered_open(minor_t, md_dev64_t *, int); 695 extern void md_layered_close(md_dev64_t, int); 696 extern char *md_get_device_name(md_dev64_t); 697 extern int errdone(mdi_unit_t *, struct buf *, int); 698 extern int md_checkbuf(mdi_unit_t *, md_unit_t *, buf_t *); 699 extern int md_start_daemons(int init_queues); 700 extern int md_loadsubmod(set_t, char *, int); 701 extern int md_getmodindex(md_driver_t *, int, int); 702 extern void md_call_strategy(buf_t *, int, void *); 703 extern int md_call_ioctl(md_dev64_t, int, void *, int, IOLOCK *); 704 extern void md_rem_link(set_t, int, krwlock_t *, md_link_t **); 705 extern int md_dev_exists(md_dev64_t); 706 extern md_parent_t md_get_parent(md_dev64_t); 707 extern void md_set_parent(md_dev64_t, md_parent_t); 708 extern void md_reset_parent(md_dev64_t); 709 extern struct hot_spare_pool *find_hot_spare_pool(set_t, int); 710 extern int md_hot_spare_ifc(hs_cmds_t, mddb_recid_t, u_longlong_t, int, 711 mddb_recid_t *, mdkey_t *, md_dev64_t *, diskaddr_t *); 712 extern int md_notify_interface(md_event_cmds_t cmd, md_tags_t type, 713 set_t set, md_dev64_t dev, md_event_type_t event); 714 extern void svm_gen_sysevent(char *se_class, char *se_subclass, 715 uint32_t tag, set_t setno, md_dev64_t devid); 716 extern void md_create_unit_incore(minor_t, md_ops_t *, int); 717 extern void md_destroy_unit_incore(minor_t, md_ops_t *); 718 extern void md_rem_names(sv_dev_t *, int); 719 struct uio; 720 extern int md_chk_uio(struct uio *); 721 extern char *md_shortname(minor_t mnum); 722 extern char *md_devname(set_t setno, md_dev64_t dev, char *buf, 723 size_t size); 724 extern void md_minphys(buf_t *); 725 extern void md_kstat_init(minor_t mnum); 726 extern void md_kstat_init_ui(minor_t mnum, mdi_unit_t *ui); 727 extern void md_kstat_destroy(minor_t mnum); 728 extern void md_kstat_destroy_ui(mdi_unit_t *ui); 729 extern void md_kstat_waitq_enter(mdi_unit_t *ui); 730 extern void md_kstat_waitq_to_runq(mdi_unit_t *ui); 731 extern void md_kstat_waitq_exit(mdi_unit_t *ui); 732 extern void md_kstat_runq_enter(mdi_unit_t *ui); 733 extern void md_kstat_runq_exit(mdi_unit_t *ui); 734 extern void md_kstat_done(mdi_unit_t *ui, buf_t *bp, int war); 735 extern pid_t md_getpid(void); 736 extern proc_t *md_getproc(void); 737 extern int md_checkpid(pid_t pid, proc_t *proc); 738 extern char *md_strdup(char *cp); 739 extern void freestr(char *cp); 740 extern int md_check_ioctl_against_efi(int, ushort_t); 741 extern mddb_recid_t md_vtoc_to_efi_record(mddb_recid_t, set_t); 742 743 extern int mdmn_ksend_message(set_t, md_mn_msgtype_t, uint_t, char *, int, 744 md_mn_kresult_t *); 745 extern void mdmn_ksend_show_error(int, md_mn_kresult_t *, const char *); 746 extern int mdmn_send_capability_message(minor_t, volcap_t, IOLOCK *); 747 extern void mdmn_clear_all_capabilities(minor_t); 748 extern int md_init_probereq(struct md_probedev_impl *p, 749 daemon_queue_t **hdrpp); 750 extern boolean_t callb_md_mrs_cpr(void *, int); 751 extern void md_upd_set_unnext(set_t, unit_t); 752 extern int md_rem_selfname(minor_t); 753 extern void md_rem_hspname(set_t, mdkey_t); 754 755 /* Externals from md_ioctl.c */ 756 extern int md_mn_is_commd_present(void); 757 extern void md_mn_clear_commd_present(void); 758 extern int md_admin_ioctl(md_dev64_t, int, caddr_t, int, IOLOCK *lockp); 759 extern void md_get_geom(md_unit_t *, struct dk_geom *); 760 extern void md_get_vtoc(md_unit_t *, struct vtoc *); 761 extern int md_set_vtoc(md_unit_t *, struct vtoc *); 762 extern void md_get_cgapart(md_unit_t *, struct dk_map *); 763 extern void md_get_efi(md_unit_t *, char *); 764 extern int md_set_efi(md_unit_t *, char *); 765 extern int md_dkiocgetefi(minor_t, void *, int); 766 extern int md_dkiocsetefi(minor_t, void *, int); 767 extern int md_dkiocpartition(minor_t, void *, int); 768 extern void md_remove_minor_node(minor_t); 769 770 771 /* Externals from md_names.c */ 772 extern mdkey_t md_setdevname(set_t, side_t, mdkey_t, char *, minor_t, char *, 773 int imp_flag, ddi_devid_t devid, char *minorname, 774 set_t, md_error_t *); 775 extern int md_getdevname(set_t, side_t, mdkey_t, md_dev64_t, char *, 776 size_t); 777 extern int md_gethspinfo(set_t, side_t, mdkey_t, char *, hsp_t *, 778 char *); 779 extern int md_getkeyfromdev(set_t, side_t, md_dev64_t, mdkey_t *, int *); 780 extern int md_devid_found(set_t, side_t, mdkey_t); 781 extern int md_getnment(set_t, side_t, mdkey_t, md_dev64_t, 782 char *, uint_t, major_t *, minor_t *, mdkey_t *); 783 extern md_dev64_t md_getdevnum(set_t, side_t, mdkey_t, int); 784 extern mdkey_t md_getnextkey(set_t, side_t, mdkey_t, uint_t *); 785 extern int md_remdevname(set_t, side_t, mdkey_t); 786 extern mdkey_t md_setshared_name(set_t, char *, int); 787 extern char *md_getshared_name(set_t, mdkey_t); 788 extern int md_remshared_name(set_t, mdkey_t); 789 extern mdkey_t md_getshared_key(set_t, char *); 790 extern int md_setshared_data(set_t, uint_t, caddr_t); 791 extern caddr_t md_getshared_data(set_t, uint_t); 792 extern int md_load_namespace(set_t, md_error_t *ep, int); 793 extern void md_unload_namespace(set_t, int); 794 extern int md_nm_did_chkspace(set_t); 795 extern void md_bioinit(); 796 extern buf_t *md_bioclone(buf_t *, off_t, size_t, dev_t, diskaddr_t, 797 int (*)(buf_t *), buf_t *, int); 798 extern int md_getdevid(set_t setno, side_t side, mdkey_t key, 799 ddi_devid_t devid, ushort_t *did_size); 800 extern int md_getdevidminor(set_t setno, side_t side, mdkey_t key, 801 char *minorname, size_t minorname_len); 802 extern int md_update_namespace(set_t setno, side_t side, mdkey_t key, 803 caddr_t devname, caddr_t pathname, minor_t mnum); 804 extern int md_update_locator_namespace(set_t setno, side_t side, 805 caddr_t devname, caddr_t pathname, md_dev64_t devt); 806 extern int md_update_namespace_did(set_t setno, side_t side, mdkey_t key, 807 md_error_t *ep); 808 extern int md_validate_devid(set_t setno, side_t side, int *maxsz); 809 extern int md_get_invdid(set_t setno, side_t side, int cnt, int maxsz, 810 void *didptr); 811 extern md_dev64_t md_resolve_bydevid(minor_t, md_dev64_t, mdkey_t key); 812 extern md_dev64_t md_expldev(md_dev64_t); 813 extern dev32_t md_cmpldev(md_dev64_t); 814 extern dev_t md_dev64_to_dev(md_dev64_t); 815 extern md_dev64_t md_makedevice(major_t, minor_t); 816 extern major_t md_getmajor(md_dev64_t); 817 extern minor_t md_getminor(md_dev64_t); 818 extern void md_timeval(md_timeval32_t *); 819 extern int md_imp_snarf_set(mddb_config_t *); 820 821 /* externals from md_mddb.c */ 822 extern int mddb_reread_rr(set_t, mddb_recid_t); 823 extern int mddb_setowner(mddb_recid_t id, md_mn_nodeid_t owner); 824 extern int mddb_parse(mddb_parse_parm_t *mpp); 825 extern int mddb_block(mddb_block_parm_t *mpp); 826 extern int mddb_optrecfix(mddb_optrec_parm_t *mop); 827 extern int mddb_check_write_ioctl(mddb_config_t *info); 828 extern int mddb_setflags_ioctl(mddb_setflags_config_t *info); 829 extern struct nm_next_hdr *get_first_record(set_t, int, int); 830 extern void *lookup_entry(struct nm_next_hdr *, set_t, 831 side_t, mdkey_t, md_dev64_t, int); 832 extern void *lookup_shared_entry(struct nm_next_hdr *, 833 mdkey_t key, char *, mddb_recid_t *, int); 834 extern int remove_shared_entry(struct nm_next_hdr *, mdkey_t key, 835 char *, int); 836 extern void *alloc_entry(struct nm_next_hdr *, mddb_recid_t, size_t, int, 837 mddb_recid_t *); 838 extern void *getshared_name(set_t, mdkey_t, int); 839 840 #endif /* _KERNEL */ 841 842 843 /* externals from md_revchk.c */ 844 extern int revchk(uint_t my_rev, uint_t data); 845 846 847 #ifdef __cplusplus 848 } 849 #endif 850 851 #endif /* _SYS_MDVAR_H */ 852