SCSI DMA correctness

scsi_base.c

 /*      $OpenBSD: scsi_base.c,v 1.198 2011/03/02 04:38:01 krw Exp $     */
 /*      $NetBSD: scsi_base.c,v 1.43 1997/04/02 02:29:36 mycroft Exp $   */
 
 /*
  * Copyright (c) 1994, 1995, 1997 Charles M. Hannum.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 23 matching lines @@
  * Originally written by Julian Elischer (julian@dialix.oz.au)
  * Detailed SCSI error printing Copyright 1997 by Matthew Jacob.
  */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/buf.h>
 #include <sys/uio.h>
-#include <sys/malloc.h>
 #include <sys/errno.h>
 #include <sys/device.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 
 #include <scsi/scsi_all.h>
 #include <scsi/scsi_disk.h>
 #include <scsi/scsiconf.h>
 
 static __inline void asc2ascii(u_int8_t, u_int8_t ascq, char *result,
@@ skipping 721 matching lines @@
         int error;
 
         if (blksize != NULL)
                 *blksize = 0;
 
         CLR(flags, SCSI_IGNORE_ILLEGAL_REQUEST);
 
         /*
          * Start with a READ CAPACITY(10).
          */
-        rdcap = malloc(sizeof(*rdcap), M_TEMP, ((flags & SCSI_NOSLEEP) ?
-            M_NOWAIT : M_WAITOK) | M_ZERO);
+        rdcap = dma_alloc(sizeof(*rdcap), ((flags & SCSI_NOSLEEP) ?
+            PR_NOWAIT : PR_WAITOK) | PR_ZERO);
         if (rdcap == NULL)
                 return (0);
 
         xs = scsi_xs_get(sc_link, flags | SCSI_DATA_IN | SCSI_SILENT);
         if (xs == NULL) {
-                free(rdcap, M_TEMP);
+                dma_free(rdcap, sizeof(*rdcap));
                 return (0);
         }
         xs->cmdlen = sizeof(*cmd10);
         xs->data = (void *)rdcap;
         xs->datalen = sizeof(*rdcap);
         xs->timeout = 20000;
 
         cmd10 = (struct scsi_read_capacity *)xs->cmd;
         cmd10->opcode = READ_CAPACITY;
 
         error = scsi_xs_sync(xs);
         scsi_xs_put(xs);
 
         if (error) {
                 SC_DEBUG(sc_link, SDEV_DB1, ("READ CAPACITY error (%#x)\n",
                     error));
-                free(rdcap, M_TEMP);
+                dma_free(rdcap, sizeof(*rdcap));
                 return (0);
         }
 
         max_addr = _4btol(rdcap->addr);
         if (blksize != NULL)
                 *blksize = _4btol(rdcap->length);
-        free(rdcap, M_TEMP);
+        dma_free(rdcap, sizeof(*rdcap));
 
         if (SCSISPC(sc_link->inqdata.version) < 3 && max_addr != 0xffffffff)
                 goto exit;
 
         /*
          * SCSI-3 devices, or devices reporting more than 2^32-1 sectors can
          * try READ CAPACITY(16).
          */
-        rdcap16 = malloc(sizeof(*rdcap16), M_TEMP, ((flags & SCSI_NOSLEEP) ?
-            M_NOWAIT : M_WAITOK) | M_ZERO);
+        rdcap16 = dma_alloc(sizeof(*rdcap16), ((flags & SCSI_NOSLEEP) ?
+            PR_NOWAIT : PR_WAITOK) | PR_ZERO);
         if (rdcap16 == NULL)
                 goto exit;
 
         xs = scsi_xs_get(sc_link, flags | SCSI_DATA_IN | SCSI_SILENT);
         if (xs == NULL) {
-                free(rdcap16, M_TEMP);
+                dma_free(rdcap16, sizeof(*rdcap16));
                 goto exit;
         }
         xs->cmdlen = sizeof(*cmd);
         xs->data = (void *)rdcap16;
         xs->datalen = sizeof(*rdcap16);
         xs->timeout = 20000;
 
         cmd = (struct scsi_read_capacity_16 *)xs->cmd;
         cmd->opcode = READ_CAPACITY_16;
         cmd->byte2 = SRC16_SERVICE_ACTION;
         _lto4b(sizeof(*rdcap16), cmd->length);
 
         error = scsi_xs_sync(xs);
         scsi_xs_put(xs);
         if (error) {
                 SC_DEBUG(sc_link, SDEV_DB1, ("READ CAPACITY 16 error (%#x)\n",
                     error));
-                free(rdcap16, M_TEMP);
+                dma_free(rdcap16, sizeof(*rdcap16));
                 goto exit;
         }
 
         max_addr = _8btol(rdcap16->addr);
         if (blksize != NULL)
                 *blksize = _4btol(rdcap16->length);
         /* XXX The other READ CAPACITY(16) info could be stored away. */
-        free(rdcap16, M_TEMP);
+        dma_free(rdcap16, sizeof(*rdcap16));
 
         return (max_addr + 1);
 
 exit:
         /* Return READ CAPACITY 10 values. */
         if (max_addr != 0xffffffff)
                 return (max_addr + 1);
         else if (blksize != NULL)
                 *blksize = 0;
         return (0);
@@ skipping 1768 matching lines @@
         case WRITE_16: {
                 struct scsi_rw_16 *rw16 = (struct scsi_rw_16 *)cmd;
                 *blkno = _8btol(rw16->addr);
                 *nblks = _4btol(rw16->length);
                 break;
         }
         default:
                 panic("scsi_cmd_rw_decode: bad opcode 0x%02x", cmd->opcode);
         }
 }