usr/src/uts/common/sys/cmlb.h

   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 2016 Toomas Soome <tsoome@me.com>
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #ifndef _SYS_CMLB_H
  28 #define _SYS_CMLB_H
  29
  30 #ifdef  __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 #include <sys/dktp/fdisk.h>
  35
  36 /*
  37  * structure used for getting phygeom and virtgeom from target driver
  38  */
  39 typedef struct cmlb_geom {
  40         unsigned int    g_ncyl;
  41         unsigned short  g_acyl;
  42         unsigned short  g_nhead;
  43         unsigned short  g_nsect;
  44         unsigned short  g_secsize;
  45         diskaddr_t      g_capacity;
  46         unsigned short  g_intrlv;
  47         unsigned short  g_rpm;
  48 } cmlb_geom_t;
  49
  50
  51 typedef struct tg_attribute {
  52         int media_is_writable;
  53         int media_is_solid_state;
  54         int media_is_rotational;
  55 } tg_attribute_t;
  56
  57
  58
  59 /* bit definitions for alter_behavior passed to cmlb_attach */
  60
  61 #define CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT       0x00000001
  62 #define CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8               0x00000002
  63 #define CMLB_OFF_BY_ONE                                 0x00000004
  64 #define CMLB_FAKE_LABEL_ONE_PARTITION                   0x00000008
  65 #define CMLB_INTERNAL_MINOR_NODES                       0x00000010
  66 #define CMLB_CREATE_P0_MINOR_NODE                       0x00000020
  67
  68 /* bit definitions of flag passed to cmlb_validate */
  69 #define CMLB_SILENT                                     0x00000001
  70
  71 /* version for tg_ops */
  72 #define TG_DK_OPS_VERSION_0     0
  73 #define TG_DK_OPS_VERSION_1     1
  74
  75 /* definitions for cmd passed to tg_rdwr */
  76 #define TG_READ                 0
  77 #define TG_WRITE                1
  78
  79 /* definitions for cmd passed to tg_getinfo */
  80 #define TG_GETPHYGEOM           1
  81 #define TG_GETVIRTGEOM          2
  82 #define TG_GETCAPACITY          3
  83 #define TG_GETBLOCKSIZE         4
  84 #define TG_GETATTR              5
  85
  86 #if defined(_SUNOS_VTOC_8)
  87
  88 #define CMLBUNIT_DFT_SHIFT      3
  89 /* This will support p0 node on sparc */
  90 #define CMLBUNIT_FORCE_P0_SHIFT (CMLBUNIT_DFT_SHIFT + 1)
  91
  92 #elif defined(_SUNOS_VTOC_16)
  93
  94 #define CMLBUNIT_DFT_SHIFT      6
  95 #define CMLBUNIT_FORCE_P0_SHIFT (CMLBUNIT_DFT_SHIFT)
  96
  97 #else   /* defined(_SUNOS_VTOC_16) */
  98
  99 #error "No VTOC format defined."
 100
 101 #endif  /* defined(_SUNOS_VTOC_8) */
 102
 103 /*
 104  * Ops vector including utility functions into target driver that cmlb uses.
 105  */
 106 typedef struct cmlb_tg_ops {
 107         int     tg_version;
 108
 109         /*
 110          * tg_rdwr:
 111          *      perform read/write on target device associated with devi.
 112          *
 113          * Arguments:
 114          *
 115          *      devi:           pointer to device's dev_info structure.
 116          *
 117          *      cmd:            operation to perform.
 118          *                      Possible values: TG_READ, TG_WRITE
 119          *
 120          *      bufp:           pointer to allocated buffer for transfer
 121          *
 122          *      start_block:    starting block number to read/write (based on
 123          *                      system blocksize, DEV_BSIZE)
 124          *
 125          *      reqlength:      requested transfer length (in bytes)
 126          *
 127          *      tg_cookie       cookie from target driver to be passed back to
 128          *                      target driver when we call back to it through
 129          *                      tg_ops.
 130          *
 131          * Note: It is the responsibility of caller to make sure
 132          *      length of buffer pointed to by bufp is at least equal to
 133          *      requested transfer length
 134          *
 135          * Return values:
 136          *      0               success
 137          *      ENOMEM          can not allocate memory
 138          *      EACCESS         reservation conflict
 139          *      EIO             I/O error
 140          *      EFAULT          copyin/copyout error
 141          *      ENXIO           internal error/ invalid devi
 142          *      EINVAL          invalid command value.
 143          */
 144         int (*tg_rdwr)(dev_info_t *devi, uchar_t cmd, void *bufp,
 145             diskaddr_t start_block, size_t reqlength, void *tg_cookie);
 146
 147         /*
 148          * tg_getinfo:
 149          *      Report the information requested on device/media and
 150          *      store the requested info in area pointed to by arg.
 151          *
 152          * Arguments:
 153          *      devi:           pointer to device's dev_info structure.
 154          *
 155          *      cmd:            operation to perform
 156          *
 157          *      arg:            arg for the operation for result.
 158          *
 159          *      tg_cookie       cookie from target driver to be passed back to
 160          *                      target driver when we call back to it through
 161          *                      tg_ops.
 162          *
 163          *      Possible commands and the interpretation of arg:
 164          *
 165          *      cmd:
 166          *              TG_GETPHYGEOM
 167          *                      Obtain raw physical geometry from target,
 168          *                      and store in structure pointed to by arg,
 169          *                      a cmlb_geom_t structure.
 170          *
 171          *              TG_GETVIRTGEOM:
 172          *                      Obtain HBA geometry for the target and
 173          *                      store in struct pointed to by arg,
 174          *                      a cmlb_geom_t structure.
 175          *
 176          *              TG_GETCAPACITY:
 177          *                      Report the capacity of the target (in system
 178          *                      blocksize (DEV_BSIZE) and store in the
 179          *                      space pointed to by arg, a diskaddr_t.
 180          *
 181          *              TG_GETBLOCKSIZE:
 182          *                      Report the block size of the target
 183          *                      in the space pointed to by arg, a uint32_t.
 184          *
 185          *              TG_GETATTR:
 186          *                      Report the information requested on
 187          *                      device/media and store in area pointed to by
 188          *                      arg, a tg_attribute_t structure.
 189          *                      Return values:
 190          *
 191          * Return values:
 192          *      0               success
 193          *
 194          *      EACCESS         reservation conflict
 195          *
 196          *      ENXIO           internal error/invalid devi
 197          *
 198          *      EINVAL          When command is TG_GETPHYGEOM or
 199          *                      TG_GETVIRTGEOM, or TG_GETATTR, this return code
 200          *                      indicates the operation is not applicable to
 201          *                      target.
 202          *                      In case of TG_GETCAP, this return code
 203          *                      indicates no media in the drive.
 204          *
 205          *      EIO             An error occurred during obtaining info
 206          *                      from device/media.
 207          *
 208          *      ENOTSUP         In case of TG_GETCAP, target does not
 209          *                      support getting capacity info.
 210          *
 211          *      ENOTTY          Unknown command.
 212          *
 213          *
 214          */
 215         int (*tg_getinfo)(dev_info_t *devi, int cmd, void *arg,
 216             void *tg_cookie);
 217
 218 } cmlb_tg_ops_t;
 219
 220
 221 typedef struct __cmlb_handle *cmlb_handle_t;
 222
 223 /*
 224  *
 225  * Functions exported from cmlb
 226  *
 227  * Note: Most these functions can callback to target driver through the
 228  * tg_ops functions. Target driver should consider this for synchronization.
 229  * Any functions that may adjust minor nodes should be called when
 230  * the target driver ensures it is safe to do so.
 231  */
 232
 233 /*
 234  * cmlb_alloc_handle:
 235  *
 236  *      Allocates a handle.
 237  *
 238  * Arguments:
 239  *      cmlbhandlep     pointer to handle
 240  *
 241  * Notes:
 242  *      Allocates a handle and stores the allocated handle in the area
 243  *      pointed to by cmlbhandlep
 244  *
 245  * Context:
 246  *      Kernel thread only (can sleep).
 247  */
 248 void
 249 cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep);
 250
 251
 252 /*
 253  * cmlb_attach:
 254  *
 255  *      Attach handle to device, create minor nodes for device.
 256  *
 257  *
 258  * Arguments:
 259  *      devi            pointer to device's dev_info structure.
 260  *      tgopsp          pointer to array of functions cmlb can use to callback
 261  *                      to target driver.
 262  *
 263  *      device_type     Peripheral device type as defined in
 264  *                      scsi/generic/inquiry.h
 265  *
 266  *      is_removable    whether or not device is removable.
 267  *
 268  *      is_hotpluggable whether or not device is hotpluggable.
 269  *
 270  *      node_type       minor node type (as used by ddi_create_minor_node)
 271  *
 272  *      alter_behavior
 273  *                      bit flags:
 274  *
 275  *                      CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
 276  *                      an alternate slice for the default label, if
 277  *                      device type is DTYPE_DIRECT an architectures default
 278  *                      label type is VTOC16.
 279  *                      Otherwise alternate slice will no be created.
 280  *
 281  *
 282  *                      CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
 283  *                      geometry and label for DKIOCGGEOM and DKIOCGVTOC
 284  *                      on architecture with VTOC 8 label types.
 285  *
 286  *                      CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
 287  *                      one bug in obtaining capacity (used for sd).
 288  *
 289  *
 290  *      cmlbhandle      cmlb handle associated with device
 291  *
 292  *      tg_cookie       cookie from target driver to be passed back to target
 293  *                      driver when we call back to it through tg_ops.
 294  *
 295  *                      cmlb does not interpret the values. It is currently
 296  *                      used for sd to indicate whether retries are allowed
 297  *                      on commands or not. e.g when cmlb entries are called
 298  *                      from interrupt context on removable media, sd rather
 299  *                      not have retries done.
 300  *
 301  *
 302  *
 303  * Notes:
 304  *      Assumes a default label based on capacity for non-removable devices.
 305  *      If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
 306  *      for the architecture).
 307  *      For removable devices, default label type is assumed to be VTOC
 308  *      type. Create minor nodes based on a default label type.
 309  *      Label on the media is not validated.
 310  *      minor number consists of:
 311  *              if _SUNOS_VTOC_8 is defined
 312  *                      lowest 3 bits is taken as partition number
 313  *                      the rest is instance number
 314  *              if _SUNOS_VTOC_16 is defined
 315  *                      lowest 6 bits is taken as partition number
 316  *                      the rest is instance number
 317  *
 318  *
 319  * Return values:
 320  *      0       Success
 321  *      ENXIO   creating minor nodes failed.
 322  *      EINVAL  invalid arg, unsupported tg_ops version
 323  *
 324  */
 325 int
 326 cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
 327     boolean_t is_removable, boolean_t is_hotpluggable, char *node_type,
 328     int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie);
 329
 330
 331 /*
 332  * cmlb_validate:
 333  *
 334  *      Validates label.
 335  *
 336  * Arguments
 337  *      cmlbhandle      cmlb handle associated with device.
 338  *
 339  *      int             flags
 340  *                      currently used for verbosity control.
 341  *                      CMLB_SILENT is the only current definition for it
 342  *      tg_cookie       cookie from target driver to be passed back to target
 343  *                      driver when we call back to it through tg_ops.
 344  * Notes:
 345  *      If new label type is different from the current, adjust minor nodes
 346  *      accordingly.
 347  *
 348  * Return values:
 349  *      0               success
 350  *                      Note: having fdisk but no solaris partition is assumed
 351  *                      success.
 352  *
 353  *      ENOMEM          memory allocation failed
 354  *      EIO             i/o errors during read or get capacity
 355  *      EACCESS         reservation conflicts
 356  *      EINVAL          label was corrupt, or no default label was assumed
 357  *      ENXIO           invalid handle
 358  *
 359  */
 360 int
 361 cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie);
 362
 363 /*
 364  * cmlb_invalidate:
 365  *      Invalidate in core label data
 366  *
 367  * Arguments:
 368  *      cmlbhandle      cmlb handle associated with device.
 369  *      tg_cookie       cookie from target driver to be passed back to target
 370  *                      driver when we call back to it through tg_ops.
 371  */
 372 void
 373 cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie);
 374
 375
 376
 377 /*
 378  * cmlb_is_valid
 379  *       Get status on whether the incore label/geom data is valid
 380  *
 381  * Arguments:
 382  *      cmlbhandle      cmlb handle associated with device.
 383  *
 384  * Return values:
 385  *      TRUE if valid
 386  *      FALSE otherwise.
 387  *
 388  */
 389 boolean_t
 390 cmlb_is_valid(cmlb_handle_t cmlbhandle);
 391
 392 /*
 393  * cmlb_partinfo:
 394  *      Get partition info for specified partition number.
 395  *
 396  * Arguments:
 397  *      cmlbhandle      cmlb handle associated with device.
 398  *      part            partition number
 399  *                      driver when we call back to it through tg_ops.
 400  *      nblocksp        pointer to number of blocks
 401  *      startblockp     pointer to starting block
 402  *      partnamep       pointer to name of partition
 403  *      tagp            pointer to tag info
 404  *      tg_cookie       cookie from target driver to be passed back to target
 405  *
 406  * Notes:
 407  *      If in-core label is not valid, this functions tries to revalidate
 408  *      the label. If label is valid, it stores the total number of blocks
 409  *      in this partition in the area pointed to by nblocksp, starting
 410  *      block number in area pointed to by startblockp,  pointer to partition
 411  *      name in area pointed to by partnamep, and tag value in area
 412  *      pointed by tagp.
 413  *      For EFI labels, tag value will be set to 0.
 414  *
 415  *      For all nblocksp, startblockp and partnamep, tagp, a value of NULL
 416  *      indicates the corresponding info is not requested.
 417  *
 418  *
 419  * Return values:
 420  *      0       success
 421  *      EINVAL  no valid label or requested partition number is invalid.
 422  *
 423  */
 424 int
 425 cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
 426     diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie);
 427
 428 /*
 429  * cmlb_efi_label_capacity:
 430  *      Get capacity stored in EFI disk label.
 431  *
 432  * Arguments:
 433  *      cmlbhandle      cmlb handle associated with device.
 434  *      capacity        pointer to capacity stored in EFI disk label.
 435  *      tg_cookie       cookie from target driver to be passed back to target
 436  *                      driver when we call back to it through tg_ops.
 437  *
 438  *
 439  * Notes:
 440  *      If in-core label is not valid, this functions tries to revalidate
 441  *      the label. If label is valid and is an EFI label, it stores the capacity
 442  *      in disk label in the area pointed to by capacity.
 443  *
 444  *
 445  * Return values:
 446  *      0       success
 447  *      EINVAL  no valid EFI label or capacity is NULL.
 448  *
 449  */
 450 int
 451 cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity,
 452     void *tg_cookie);
 453
 454 /*
 455  * cmlb_ioctl:
 456  * Ioctls for label handling will be handled by this function.
 457  * These are:
 458  *      DKIOCGGEOM
 459  *      DKIOCSGEOM
 460  *      DKIOCGAPART
 461  *      DKIOCSAPART
 462  *      DKIOCGVTOC
 463  *      DKIOCGETEFI
 464  *      DKIOCPARTITION
 465  *      DKIOCSVTOC
 466  *      DKIOCSETEFI
 467  *      DKIOCGMBOOT
 468  *      DKIOCSMBOOT
 469  *      DKIOCG_PHYGEOM
 470  *      DKIOCG_VIRTGEOM
 471  *      DKIOCPARTINFO
 472  *
 473  *
 474  *   Arguments:
 475  *      cmlbhandle      handle associated with device.
 476  *      cmd             ioctl operation to be performed
 477  *      arg             user argument, contains data to be set or reference
 478  *                      parameter for get
 479  *      flag            bit flag, indicating open settings, 32/64 bit type
 480  *      cred_p          user credential pointer (not currently used)
 481  *      rval_p          not currently used
 482  *      tg_cookie       cookie from target driver to be passed back to target
 483  *                      driver when we call back to it through tg_ops.
 484  *
 485  *
 486  *
 487  * Return values:
 488  *      0
 489  *      EINVAL
 490  *      ENOTTY
 491  *      ENXIO
 492  *      EIO
 493  *      EFAULT
 494  *      ENOTSUP
 495  *      EPERM
 496  */
 497 int
 498 cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd,
 499     intptr_t arg, int flag, cred_t *cred_p, int *rval_p, void *tg_cookie);
 500
 501 /*
 502  * cmlb_prop_op:
 503  *      provide common label prop_op(9E) implementation that understands the
 504  *      size(9p) properties.
 505  *
 506  * Arguments:
 507  *      cmlbhandle      cmlb handle associated with device.
 508  *      dev             See prop_op(9E)
 509  *      dip             "
 510  *      prop_op         "
 511  *      mod_flags       "
 512  *      name            "
 513  *      valuep          "
 514  *      lengthp         "
 515  *      part            partition number
 516  *      tg_cookie       cookie from target driver to be passed back to target
 517  */
 518 int
 519 cmlb_prop_op(cmlb_handle_t cmlbhandle,
 520     dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
 521     char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie);
 522
 523 /*
 524  * cmlb_get_devid_block:
 525  *       get the block number where device id is stored.
 526  *
 527  * Arguments:
 528  *      cmlbhandle      cmlb handle associated with device.
 529  *      devidblockp     pointer to block number.
 530  *      tg_cookie       cookie from target driver to be passed back to target
 531  *                      driver when we call back to it through tg_ops.
 532  *
 533  * Notes:
 534  *      It stores the block number of device id in the area pointed to
 535  *      by devidblockp.
 536  *
 537  * Return values:
 538  *      0       success
 539  *      EINVAL  device id does not apply to current label type.
 540  */
 541 int
 542 cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
 543     void *tg_cookie);
 544
 545
 546 /*
 547  * cmlb_close:
 548  *
 549  * Close the device, revert to a default label minor node for the device,
 550  * if it is removable.
 551  *
 552  * Arguments:
 553  *      cmlbhandle      cmlb handle associated with device.
 554  *
 555  *      tg_cookie       cookie from target driver to be passed back to target
 556  *                      driver when we call back to it through tg_ops.
 557  * Return values:
 558  *      0       Success
 559  *      ENXIO   Re-creating minor node failed.
 560  */
 561 int
 562 cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie);
 563
 564 /*
 565  * cmlb_detach:
 566  *
 567  * Invalidate in-core labeling data and remove all minor nodes for
 568  * the device associate with handle.
 569  *
 570  * Arguments:
 571  *      cmlbhandle      cmlb handle associated with device.
 572  *      tg_cookie       cookie from target driver to be passed back to target
 573  *                      driver when we call back to it through tg_ops.
 574  *
 575  */
 576 void
 577 cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie);
 578
 579 /*
 580  * cmlb_free_handle
 581  *
 582  *      Frees handle.
 583  *
 584  * Arguments:
 585  *      cmlbhandlep     pointer to handle
 586  *
 587  */
 588 void
 589 cmlb_free_handle(cmlb_handle_t *cmlbhandlep);
 590
 591 #ifdef  __cplusplus
 592 }
 593 #endif
 594
 595 #endif /* _SYS_CMLB_H */