sys/dev/nvme/nvme_ns.c

   1 /*-
   2  * Copyright (C) 2012 Intel Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/bio.h>
  32 #include <sys/bus.h>
  33 #include <sys/conf.h>
  34 #include <sys/disk.h>
  35 #include <sys/fcntl.h>
  36 #include <sys/ioccom.h>
  37 #include <sys/module.h>
  38 #include <sys/proc.h>
  39
  40 #include <dev/pci/pcivar.h>
  41
  42 #include "nvme_private.h"
  43
  44 static void
  45 nvme_ns_cb(void *arg, const struct nvme_completion *status)
  46 {
  47         struct nvme_completion  *cpl = arg;
  48         struct mtx              *mtx;
  49
  50         /*
  51          * Copy status into the argument passed by the caller, so that
  52          *  the caller can check the status to determine if the
  53          *  the request passed or failed.
  54          */
  55         memcpy(cpl, status, sizeof(*cpl));
  56         mtx = mtx_pool_find(mtxpool_sleep, cpl);
  57         mtx_lock(mtx);
  58         wakeup(cpl);
  59         mtx_unlock(mtx);
  60 }
  61
  62 static int
  63 nvme_ns_ioctl(struct cdev *cdev, u_long cmd, caddr_t arg, int flag,
  64     struct thread *td)
  65 {
  66         struct nvme_namespace   *ns;
  67         struct nvme_controller  *ctrlr;
  68         struct nvme_completion  cpl;
  69         struct mtx              *mtx;
  70
  71         ns = cdev->si_drv1;
  72         ctrlr = ns->ctrlr;
  73
  74         switch (cmd) {
  75         case NVME_IDENTIFY_NAMESPACE:
  76 #ifdef CHATHAM2
  77                 /*
  78                  * Don't refresh data on Chatham, since Chatham returns
  79                  *  garbage on IDENTIFY anyways.
  80                  */
  81                 if (pci_get_devid(ctrlr->dev) == CHATHAM_PCI_ID) {
  82                         memcpy(arg, &ns->data, sizeof(ns->data));
  83                         break;
  84                 }
  85 #endif
  86                 /* Refresh data before returning to user. */
  87                 mtx = mtx_pool_find(mtxpool_sleep, &cpl);
  88                 mtx_lock(mtx);
  89                 nvme_ctrlr_cmd_identify_namespace(ctrlr, ns->id, &ns->data,
  90                     nvme_ns_cb, &cpl);
  91                 msleep(&cpl, mtx, PRIBIO, "nvme_ioctl", 0);
  92                 mtx_unlock(mtx);
  93                 if (cpl.sf_sc || cpl.sf_sct)
  94                         return (ENXIO);
  95                 memcpy(arg, &ns->data, sizeof(ns->data));
  96                 break;
  97         case NVME_IO_TEST:
  98         case NVME_BIO_TEST:
  99                 nvme_ns_test(ns, cmd, arg);
 100                 break;
 101         case DIOCGMEDIASIZE:
 102                 *(off_t *)arg = (off_t)nvme_ns_get_size(ns);
 103                 break;
 104         case DIOCGSECTORSIZE:
 105                 *(u_int *)arg = nvme_ns_get_sector_size(ns);
 106                 break;
 107         default:
 108                 return (ENOTTY);
 109         }
 110
 111         return (0);
 112 }
 113
 114 static int
 115 nvme_ns_open(struct cdev *dev __unused, int flags, int fmt __unused,
 116     struct thread *td)
 117 {
 118         int error = 0;
 119
 120         if (flags & FWRITE)
 121                 error = securelevel_gt(td->td_ucred, 0);
 122
 123         return (error);
 124 }
 125
 126 static int
 127 nvme_ns_close(struct cdev *dev __unused, int flags, int fmt __unused,
 128     struct thread *td)
 129 {
 130
 131         return (0);
 132 }
 133
 134 static void
 135 nvme_ns_strategy_done(void *arg, const struct nvme_completion *status)
 136 {
 137         struct bio *bp = arg;
 138
 139         /*
 140          * TODO: add more extensive translation of NVMe status codes
 141          *  to different bio error codes (i.e. EIO, EINVAL, etc.)
 142          */
 143         if (status->sf_sc || status->sf_sct) {
 144                 bp->bio_error = EIO;
 145                 bp->bio_flags |= BIO_ERROR;
 146                 bp->bio_resid = bp->bio_bcount;
 147         } else
 148                 bp->bio_resid = 0;
 149
 150         biodone(bp);
 151 }
 152
 153 static void
 154 nvme_ns_strategy(struct bio *bp)
 155 {
 156         struct nvme_namespace   *ns;
 157         int                     err;
 158
 159         ns = bp->bio_dev->si_drv1;
 160         err = nvme_ns_bio_process(ns, bp, nvme_ns_strategy_done);
 161
 162         if (err) {
 163                 bp->bio_error = err;
 164                 bp->bio_flags |= BIO_ERROR;
 165                 bp->bio_resid = bp->bio_bcount;
 166                 biodone(bp);
 167         }
 168
 169 }
 170
 171 static struct cdevsw nvme_ns_cdevsw = {
 172         .d_version =    D_VERSION,
 173         .d_flags =      D_DISK,
 174         .d_open =       nvme_ns_open,
 175         .d_close =      nvme_ns_close,
 176         .d_read =       nvme_ns_physio,
 177         .d_write =      nvme_ns_physio,
 178         .d_strategy =   nvme_ns_strategy,
 179         .d_ioctl =      nvme_ns_ioctl
 180 };
 181
 182 uint32_t
 183 nvme_ns_get_max_io_xfer_size(struct nvme_namespace *ns)
 184 {
 185         return ns->ctrlr->max_xfer_size;
 186 }
 187
 188 uint32_t
 189 nvme_ns_get_sector_size(struct nvme_namespace *ns)
 190 {
 191         return (1 << ns->data.lbaf[0].lbads);
 192 }
 193
 194 uint64_t
 195 nvme_ns_get_num_sectors(struct nvme_namespace *ns)
 196 {
 197         return (ns->data.nsze);
 198 }
 199
 200 uint64_t
 201 nvme_ns_get_size(struct nvme_namespace *ns)
 202 {
 203         return (nvme_ns_get_num_sectors(ns) * nvme_ns_get_sector_size(ns));
 204 }
 205
 206 uint32_t
 207 nvme_ns_get_flags(struct nvme_namespace *ns)
 208 {
 209         return (ns->flags);
 210 }
 211
 212 const char *
 213 nvme_ns_get_serial_number(struct nvme_namespace *ns)
 214 {
 215         return ((const char *)ns->ctrlr->cdata.sn);
 216 }
 217
 218 const char *
 219 nvme_ns_get_model_number(struct nvme_namespace *ns)
 220 {
 221         return ((const char *)ns->ctrlr->cdata.mn);
 222 }
 223
 224 const struct nvme_namespace_data *
 225 nvme_ns_get_data(struct nvme_namespace *ns)
 226 {
 227
 228         return (&ns->data);
 229 }
 230
 231 static void
 232 nvme_ns_bio_done(void *arg, const struct nvme_completion *status)
 233 {
 234         struct bio      *bp = arg;
 235         nvme_cb_fn_t    bp_cb_fn;
 236
 237         bp_cb_fn = bp->bio_driver1;
 238
 239         if (bp->bio_driver2)
 240                 free(bp->bio_driver2, M_NVME);
 241
 242         bp_cb_fn(bp, status);
 243 }
 244
 245 int
 246 nvme_ns_bio_process(struct nvme_namespace *ns, struct bio *bp,
 247         nvme_cb_fn_t cb_fn)
 248 {
 249         struct nvme_dsm_range   *dsm_range;
 250         int                     err;
 251
 252         bp->bio_driver1 = cb_fn;
 253
 254         switch (bp->bio_cmd) {
 255         case BIO_READ:
 256                 err = nvme_ns_cmd_read(ns, bp->bio_data,
 257                         bp->bio_offset/nvme_ns_get_sector_size(ns),
 258                         bp->bio_bcount/nvme_ns_get_sector_size(ns),
 259                         nvme_ns_bio_done, bp);
 260                 break;
 261         case BIO_WRITE:
 262                 err = nvme_ns_cmd_write(ns, bp->bio_data,
 263                         bp->bio_offset/nvme_ns_get_sector_size(ns),
 264                         bp->bio_bcount/nvme_ns_get_sector_size(ns),
 265                         nvme_ns_bio_done, bp);
 266                 break;
 267         case BIO_FLUSH:
 268                 err = nvme_ns_cmd_flush(ns, nvme_ns_bio_done, bp);
 269                 break;
 270         case BIO_DELETE:
 271                 /*
 272                  * Note: Chatham2 doesn't support DSM, so this code
 273                  *  can't be fully tested yet.
 274                  */
 275                 dsm_range =
 276                     malloc(sizeof(struct nvme_dsm_range), M_NVME,
 277                     M_ZERO | M_NOWAIT);
 278                 dsm_range->length =
 279                     bp->bio_bcount/nvme_ns_get_sector_size(ns);
 280                 dsm_range->starting_lba =
 281                     bp->bio_offset/nvme_ns_get_sector_size(ns);
 282                 bp->bio_driver2 = dsm_range;
 283                 err = nvme_ns_cmd_deallocate(ns, dsm_range, 1,
 284                         nvme_ns_bio_done, bp);
 285                 if (err != 0)
 286                         free(dsm_range, M_NVME);
 287                 break;
 288         default:
 289                 err = EIO;
 290                 break;
 291         }
 292
 293         return (err);
 294 }
 295
 296 #ifdef CHATHAM2
 297 static void
 298 nvme_ns_populate_chatham_data(struct nvme_namespace *ns)
 299 {
 300         struct nvme_controller          *ctrlr;
 301         struct nvme_namespace_data      *nsdata;
 302
 303         ctrlr = ns->ctrlr;
 304         nsdata = &ns->data;
 305
 306         nsdata->nsze = ctrlr->chatham_lbas;
 307         nsdata->ncap = ctrlr->chatham_lbas;
 308         nsdata->nuse = ctrlr->chatham_lbas;
 309
 310         /* Chatham2 doesn't support thin provisioning. */
 311         nsdata->nsfeat.thin_prov = 0;
 312
 313         /* Set LBA size to 512 bytes. */
 314         nsdata->lbaf[0].lbads = 9;
 315 }
 316 #endif /* CHATHAM2 */
 317
 318 int
 319 nvme_ns_construct(struct nvme_namespace *ns, uint16_t id,
 320     struct nvme_controller *ctrlr)
 321 {
 322         struct nvme_completion  cpl;
 323         struct mtx              *mtx;
 324         int                     status;
 325
 326         ns->ctrlr = ctrlr;
 327         ns->id = id;
 328
 329 #ifdef CHATHAM2
 330         if (pci_get_devid(ctrlr->dev) == CHATHAM_PCI_ID)
 331                 nvme_ns_populate_chatham_data(ns);
 332         else {
 333 #endif
 334                 mtx = mtx_pool_find(mtxpool_sleep, &cpl);
 335
 336                 mtx_lock(mtx);
 337                 nvme_ctrlr_cmd_identify_namespace(ctrlr, id, &ns->data,
 338                     nvme_ns_cb, &cpl);
 339                 status = msleep(&cpl, mtx, PRIBIO, "nvme_start", hz*5);
 340                 mtx_unlock(mtx);
 341                 if ((status != 0) || cpl.sf_sc || cpl.sf_sct) {
 342                         printf("nvme_identify_namespace failed!\n");
 343                         return (ENXIO);
 344                 }
 345 #ifdef CHATHAM2
 346         }
 347 #endif
 348
 349         if (ctrlr->cdata.oncs.dsm)
 350                 ns->flags |= NVME_NS_DEALLOCATE_SUPPORTED;
 351
 352         if (ctrlr->cdata.vwc.present)
 353                 ns->flags |= NVME_NS_FLUSH_SUPPORTED;
 354
 355         /*
 356          * cdev may have already been created, if we are reconstructing the
 357          *  namespace after a controller-level reset.
 358          */
 359         if (ns->cdev != NULL)
 360                 return (0);
 361
 362 /*
 363  * MAKEDEV_ETERNAL was added in r210923, for cdevs that will never
 364  *  be destroyed.  This avoids refcounting on the cdev object.
 365  *  That should be OK case here, as long as we're not supporting PCIe
 366  *  surprise removal nor namespace deletion.
 367  */
 368 #ifdef MAKEDEV_ETERNAL_KLD
 369         ns->cdev = make_dev_credf(MAKEDEV_ETERNAL_KLD, &nvme_ns_cdevsw, 0,
 370             NULL, UID_ROOT, GID_WHEEL, 0600, "nvme%dns%d",
 371             device_get_unit(ctrlr->dev), ns->id);
 372 #else
 373         ns->cdev = make_dev_credf(0, &nvme_ns_cdevsw, 0,
 374             NULL, UID_ROOT, GID_WHEEL, 0600, "nvme%dns%d",
 375             device_get_unit(ctrlr->dev), ns->id);
 376 #endif
 377
 378         if (ns->cdev != NULL)
 379                 ns->cdev->si_drv1 = ns;
 380
 381         return (0);
 382 }
 383
 384 void nvme_ns_destruct(struct nvme_namespace *ns)
 385 {
 386
 387         if (ns->cdev != NULL)
 388                 destroy_dev(ns->cdev);
 389 }