Print this page 
NEX-8020 illumos nvme changes
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
NEX-6131 support EUI64 in blkdev
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
NEX-5236 harmless off-by-one in blkdev
Reviewed by: Dan Fields <dan.fields@nexenta.com>
NEX-4427 blkdev should provide the device_error kstat for iostat -E
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Garrett D'Amore <garrett@damore.org>
NEX-4424 kstat module needs cleanup
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Garrett D'Amore <garrett@damore.org>
NEX-4420 format(1M) should be able to use device inquiry properties
Reviewed by: Dan McDonald <danmcd@omniti.com>
NEX-4419 blkdev and blkdev drivers should provide inquiry properties
Reviewed by: Garrett D'Amore <garrett@damore.org>
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
port of illumos-3878
    3878 blkdev needs to support DKIOCGMEDIAINFOEXT
    Reviewed by: Saso Kiselkov <skiselkov.ml@gmail.com>
    Reviewed by: Garrett D'Amore <garrett@damore.org>
    Approved by: Garrett D'Amore <garrett@damore.org>
port of illumos-2911
    2911 blkdev-related panic on DEBUG kernels
    Reviewed by: Richard Lowe <richlowe@richlowe.net>
    Reviewed by: Garrett D'Amore <garrett@damore.org>
    Approved by: Garrett D'Amore <garrett@damore.org>
Adding AoE support to nza-kernel
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/blkdev/blkdev.c
          +++ new/usr/src/uts/common/io/blkdev/blkdev.c
↓ open down ↓ 42 lines elided ↑ open up ↑ 
  43   43  #include <sys/list.h>
  44   44  #include <sys/sysmacros.h>
  45   45  #include <sys/dkio.h>
  46   46  #include <sys/vtoc.h>
  47   47  #include <sys/scsi/scsi.h>      /* for DTYPE_DIRECT */
  48   48  #include <sys/kstat.h>
  49   49  #include <sys/fs/dv_node.h>
  50   50  #include <sys/ddi.h>
  51   51  #include <sys/sunddi.h>
  52   52  #include <sys/note.h>
       53 +#include <sys/mhd.h>
  53   54  #include <sys/blkdev.h>
  54   55  #include <sys/scsi/impl/inquiry.h>
  55   56  
  56   57  #define BD_MAXPART      64
  57   58  #define BDINST(dev)     (getminor(dev) / BD_MAXPART)
  58   59  #define BDPART(dev)     (getminor(dev) % BD_MAXPART)
  59   60  
  60   61  typedef struct bd bd_t;
  61   62  typedef struct bd_xfer_impl bd_xfer_impl_t;
  62   63
↓ open down ↓ 102 lines elided ↑ open up ↑ 
 165  166      void *);
 166  167  static int bd_tg_getinfo(dev_info_t *, int, void *, void *);
 167  168  static int bd_xfer_ctor(void *, void *, int);
 168  169  static void bd_xfer_dtor(void *, void *);
 169  170  static void bd_sched(bd_t *);
 170  171  static void bd_submit(bd_t *, bd_xfer_impl_t *);
 171  172  static void bd_runq_exit(bd_xfer_impl_t *, int);
 172  173  static void bd_update_state(bd_t *);
 173  174  static int bd_check_state(bd_t *, enum dkio_state *);
 174  175  static int bd_flush_write_cache(bd_t *, struct dk_callback *);
      176 +static int bd_reserve(bd_t *bd, int);
 175  177  static int bd_check_uio(dev_t, struct uio *);
 176  178  
 177  179  struct cmlb_tg_ops bd_tg_ops = {
 178  180          TG_DK_OPS_VERSION_1,
 179  181          bd_tg_rdwr,
 180  182          bd_tg_getinfo,
 181  183  };
 182  184  
 183  185  static struct cb_ops bd_cb_ops = {
 184  186          bd_open,                /* open */
↓ open down ↓ 683 lines elided ↑ open up ↑ 
 868  870  {
 869  871          dev_t           dev = *devp;
 870  872          bd_t            *bd;
 871  873          minor_t         part;
 872  874          minor_t         inst;
 873  875          uint64_t        mask;
 874  876          boolean_t       ndelay;
 875  877          int             rv;
 876  878          diskaddr_t      nblks;
 877  879          diskaddr_t      lba;
      880 +        int             i;
 878  881  
 879  882          _NOTE(ARGUNUSED(credp));
 880  883  
 881  884          part = BDPART(dev);
 882  885          inst = BDINST(dev);
 883  886  
 884  887          if (otyp >= OTYPCNT)
 885  888                  return (EINVAL);
 886  889  
 887  890          ndelay = (flag & (FNDELAY | FNONBLOCK)) ? B_TRUE : B_FALSE;
↓ open down ↓ 52 lines elided ↑ open up ↑ 
 940  943  
 941  944          if ((bd->d_open_excl) & (mask)) {
 942  945                  rv = EBUSY;
 943  946                  goto done;
 944  947          }
 945  948          if (flag & FEXCL) {
 946  949                  if (bd->d_open_lyr[part]) {
 947  950                          rv = EBUSY;
 948  951                          goto done;
 949  952                  }
 950      -                for (int i = 0; i < OTYP_LYR; i++) {
      953 +                for (i = 0; i < OTYP_LYR; i++) {
 951  954                          if (bd->d_open_reg[i] & mask) {
 952  955                                  rv = EBUSY;
 953  956                                  goto done;
 954  957                          }
 955  958                  }
 956  959          }
 957  960  
 958  961          if (otyp == OTYP_LYR) {
 959  962                  bd->d_open_lyr[part]++;
 960  963          } else {
↓ open down ↓ 12 lines elided ↑ open up ↑ 
 973  976  }
 974  977  
 975  978  static int
 976  979  bd_close(dev_t dev, int flag, int otyp, cred_t *credp)
 977  980  {
 978  981          bd_t            *bd;
 979  982          minor_t         inst;
 980  983          minor_t         part;
 981  984          uint64_t        mask;
 982  985          boolean_t       last = B_TRUE;
      986 +        int             i;
 983  987  
 984  988          _NOTE(ARGUNUSED(flag));
 985  989          _NOTE(ARGUNUSED(credp));
 986  990  
 987  991          part = BDPART(dev);
 988  992          inst = BDINST(dev);
 989  993  
 990  994          ASSERT(part < 64);
 991  995          mask = (1U << part);
 992  996
↓ open down ↓ 6 lines elided ↑ open up ↑ 
 999 1003  
1000 1004          mutex_enter(&bd->d_ocmutex);
1001 1005          if (bd->d_open_excl & mask) {
1002 1006                  bd->d_open_excl &= ~mask;
1003 1007          }
1004 1008          if (otyp == OTYP_LYR) {
1005 1009                  bd->d_open_lyr[part]--;
1006 1010          } else {
1007 1011                  bd->d_open_reg[otyp] &= ~mask;
1008 1012          }
1009      -        for (int i = 0; i < 64; i++) {
     1013 +        for (i = 0; i < 64; i++) {
1010 1014                  if (bd->d_open_lyr[part]) {
1011 1015                          last = B_FALSE;
1012 1016                  }
1013 1017          }
1014      -        for (int i = 0; last && (i < OTYP_LYR); i++) {
     1018 +        for (i = 0; last && (i < OTYP_LYR); i++) {
1015 1019                  if (bd->d_open_reg[i]) {
1016 1020                          last = B_FALSE;
1017 1021                  }
1018 1022          }
1019 1023          mutex_exit(&bd->d_ocmutex);
1020 1024  
1021 1025          if (last) {
1022 1026                  cmlb_invalidate(bd->d_cmlbh, 0);
1023 1027          }
1024 1028          rw_exit(&bd_lock);
↓ open down ↓ 357 lines elided ↑ open up ↑ 
1382 1386          case DKIOCFLUSHWRITECACHE: {
1383 1387                  struct dk_callback *dkc = NULL;
1384 1388  
1385 1389                  if (flag & FKIOCTL)
1386 1390                          dkc = (void *)arg;
1387 1391  
1388 1392                  rv = bd_flush_write_cache(bd, dkc);
1389 1393                  return (rv);
1390 1394          }
1391 1395  
     1396 +        case MHIOCTKOWN:
     1397 +        {
     1398 +                return (bd_reserve(bd, BD_XFER_MHD_TKOWN));
     1399 +        }
     1400 +
     1401 +        case MHIOCRELEASE:
     1402 +        {
     1403 +                return (bd_reserve(bd, BD_XFER_MHD_RELEASE));
     1404 +        }
     1405 +
     1406 +        case MHIOCSTATUS:
     1407 +        {
     1408 +                rv = bd_reserve(bd, BD_XFER_MHD_STATUS);
     1409 +                if (rvalp != NULL)
     1410 +                        *rvalp = rv == 0 ? 0: 1;
     1411 +                return (0);
     1412 +        }
     1413 +
     1414 +        case MHIOCQRESERVE:
     1415 +        {
     1416 +                return (bd_reserve(bd, BD_XFER_MHD_QRESERVE));
     1417 +        }
     1418 +
     1419 +        case MHIOCENFAILFAST:
     1420 +        {
     1421 +                return (bd_reserve(bd, BD_XFER_MHD_ENFAILFAST));
     1422 +        }
     1423 +
1392 1424          default:
1393 1425                  break;
1394 1426  
1395 1427          }
1396 1428          return (ENOTTY);
1397 1429  }
1398 1430  
1399 1431  static int
1400 1432  bd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
1401 1433      char *name, caddr_t valuep, int *lengthp)
↓ open down ↓ 341 lines elided ↑ open up ↑ 
1743 1775                  bp->b_iodone = bd_flush_write_cache_done;
1744 1776  
1745 1777                  bd_submit(bd, xi);
1746 1778                  return (0);
1747 1779          }
1748 1780  
1749 1781          /* In case there is no callback, perform a synchronous flush */
1750 1782          bd_submit(bd, xi);
1751 1783          (void) biowait(bp);
1752 1784          rv = geterror(bp);
     1785 +        freerbuf(bp);
     1786 +
     1787 +        return (rv);
     1788 +}
     1789 +
     1790 +static int
     1791 +bd_reserve(bd_t *bd, int flag)
     1792 +{
     1793 +        buf_t                   *bp;
     1794 +        bd_xfer_impl_t          *xi;
     1795 +        int                     rv;
     1796 +
     1797 +        if (bd->d_ops.o_reserve == NULL) {
     1798 +                return (ENOTSUP);
     1799 +        }
     1800 +        if ((bp = getrbuf(KM_SLEEP)) == NULL) {
     1801 +                return (ENOMEM);
     1802 +        }
     1803 +        bp->b_resid = 0;
     1804 +        bp->b_bcount = 0;
     1805 +
     1806 +        xi = bd_xfer_alloc(bd, bp, bd->d_ops.o_reserve, KM_SLEEP);
     1807 +        if (xi == NULL) {
     1808 +                rv = geterror(bp);
     1809 +                freerbuf(bp);
     1810 +                return (rv);
     1811 +        }
     1812 +
     1813 +        xi->i_flags = flag;
     1814 +
     1815 +        bd_submit(bd, xi);
     1816 +
     1817 +        /* wait synchronously */
     1818 +        (void) biowait(bp);
     1819 +        rv = geterror(bp);
1753 1820          freerbuf(bp);
1754 1821  
1755 1822          return (rv);
1756 1823  }
1757 1824  
1758 1825  /*
1759 1826   * Nexus support.
1760 1827   */
1761 1828  int
1762 1829  bd_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
↓ open down ↓ 322 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX