[haiku-commits] haiku: hrev45750 - src/add-ons/kernel/bus_managers/scsi

  • From: korli@xxxxxxxxxxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Sun, 9 Jun 2013 20:19:39 +0200 (CEST)

hrev45750 adds 1 changeset to branch 'master'
old head: d8189e2aaff98e500e37f46108e52da449175408
new head: 8239f0320d8b32ddc648fc2f95a529a7f1cc0bdd
overview: http://cgit.haiku-os.org/haiku/log/?qt=range&q=8239f03+%5Ed8189e2

----------------------------------------------------------------------------

8239f03: scsi: improved code style and use of B_PRI macros

                                   [ Jérôme Duval <jerome.duval@xxxxxxxxx> ]

----------------------------------------------------------------------------

Revision:    hrev45750
Commit:      8239f0320d8b32ddc648fc2f95a529a7f1cc0bdd
URL:         http://cgit.haiku-os.org/haiku/commit/?id=8239f03
Author:      Jérôme Duval <jerome.duval@xxxxxxxxx>
Date:        Sun Jun  9 15:24:28 2013 UTC

----------------------------------------------------------------------------

5 files changed, 49 insertions(+), 50 deletions(-)
src/add-ons/kernel/bus_managers/scsi/busses.cpp  | 17 +++----
.../kernel/bus_managers/scsi/dma_buffer.cpp      | 49 ++++++++++----------
.../kernel/bus_managers/scsi/emulation.cpp       |  5 +-
.../kernel/bus_managers/scsi/scatter_gather.cpp  | 19 ++++----
.../kernel/bus_managers/scsi/virtual_memory.cpp  |  9 ++--

----------------------------------------------------------------------------

diff --git a/src/add-ons/kernel/bus_managers/scsi/busses.cpp 
b/src/add-ons/kernel/bus_managers/scsi/busses.cpp
index 59cfd28..d5a17d4 100644
--- a/src/add-ons/kernel/bus_managers/scsi/busses.cpp
+++ b/src/add-ons/kernel/bus_managers/scsi/busses.cpp
@@ -217,29 +217,30 @@ scsi_init_bus(device_node *node, void **cookie)
        bus->dma_params.max_sg_block_size &= ~bus->dma_params.alignment;
 
        if (bus->dma_params.alignment > B_PAGE_SIZE) {
-               SHOW_ERROR(0, "Alignment (0x%x) must be less then B_PAGE_SIZE",
-                       (int)bus->dma_params.alignment);
+               SHOW_ERROR(0, "Alignment (0x%" B_PRIx32 ") must be less then "
+                       "B_PAGE_SIZE", bus->dma_params.alignment);
                res = B_ERROR;
                goto err;
        }
 
        if (bus->dma_params.max_sg_block_size < 1) {
-               SHOW_ERROR(0, "Max s/g block size (0x%x) is too small",
-                       (int)bus->dma_params.max_sg_block_size);
+               SHOW_ERROR(0, "Max s/g block size (0x%" B_PRIx32 ") is too 
small",
+                       bus->dma_params.max_sg_block_size);
                res = B_ERROR;
                goto err;
        }
 
        if (bus->dma_params.dma_boundary < B_PAGE_SIZE - 1) {
-               SHOW_ERROR(0, "DMA boundary (0x%x) must be at least 
B_PAGE_SIZE",
-                       (int)bus->dma_params.dma_boundary);
+               SHOW_ERROR(0, "DMA boundary (0x%" B_PRIx32 ") must be at least "
+                       "B_PAGE_SIZE", bus->dma_params.dma_boundary);
                res = B_ERROR;
                goto err;
        }
 
        if (bus->dma_params.max_blocks < 1 || bus->dma_params.max_sg_blocks < 
1) {
-               SHOW_ERROR(0, "Max blocks (%d) and max s/g blocks (%d) must be 
at least 1",
-                       (int)bus->dma_params.max_blocks, 
(int)bus->dma_params.max_sg_blocks);
+               SHOW_ERROR(0, "Max blocks (%" B_PRIu32 ") and max s/g blocks (%"
+                       B_PRIu32 ") must be at least 1", 
bus->dma_params.max_blocks,
+                       bus->dma_params.max_sg_blocks);
                res = B_ERROR;
                goto err;
        }
diff --git a/src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp 
b/src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp
index ef54810..88af0cd 100644
--- a/src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp
+++ b/src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp
@@ -83,8 +83,8 @@ is_sg_list_dma_safe(scsi_ccb *request)
 
                // verify entry size
                if (sg_list->size > max_sg_block_size) {
-                       SHOW_FLOW(0, "S/G-entry is too long (%d/%d bytes)",
-                               (int)sg_list->size, (int)max_sg_block_size);
+                       SHOW_FLOW(0, "S/G-entry is too long (%" B_PRIuPHYSADDR 
"/%" B_PRIu32
+                               " bytes)", sg_list->size, max_sg_block_size);
                        return false;
                }
        }
@@ -103,7 +103,7 @@ scsi_copy_dma_buffer(scsi_ccb *request, uint32 size, bool 
to_buffer)
        uint32 num_vecs = buffer->sg_count_orig;
        uchar *buffer_data = buffer->address;
 
-       SHOW_FLOW(1, "to_buffer=%d, %d bytes", to_buffer, (int)size);
+       SHOW_FLOW(1, "to_buffer=%d, %" B_PRIu32 " bytes", to_buffer, size);
 
        // survive even if controller returned invalid data size
        size = min_c(size, request->data_length);
@@ -154,10 +154,8 @@ scsi_free_dma_buffer(dma_buffer *buffer)
 static bool
 scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params *dma_params, uint32 size)
 {
-       size_t sg_list_size, sg_list_entries;
-
        // free old buffer first
-       scsi_free_dma_buffer( buffer );
+       scsi_free_dma_buffer(buffer);
 
        // just in case alignment is ridiculously huge
        size = (size + dma_params->alignment) & ~dma_params->alignment;
@@ -171,14 +169,14 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
                uint32 boundary = dma_params->dma_boundary;
 
                // alright - a contiguous buffer is required to keep S/G table 
short
-               SHOW_INFO(1, "need to setup contiguous DMA buffer of size %d",
-                       (int)size);
+               SHOW_INFO(1, "need to setup contiguous DMA buffer of size %" 
B_PRIu32,
+                       size);
 
                // verify that we don't get problems with dma boundary
                if (boundary != ~(uint32)0) {
                        if (size > boundary + 1) {
-                               SHOW_ERROR(2, "data is longer then maximum DMA 
transfer len (%d/%d bytes)",
-                                       (int)size, (int)boundary + 1);
+                               SHOW_ERROR(2, "data is longer then maximum DMA 
transfer len (%"
+                                        B_PRId32 "/%" B_PRId32 " bytes)", 
size, boundary + 1);
                                return false;
                        }
                }
@@ -199,8 +197,8 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
                        (void**)&buffer->address);
 
                if (buffer->area < 0) {
-                       SHOW_ERROR(2, "Cannot create contignous DMA buffer of 
%d bytes",
-                               (int)size);
+                       SHOW_ERROR(2, "Cannot create contignous DMA buffer of 
%" B_PRIu32
+                               " bytes", size);
                        return false;
                }
 
@@ -212,8 +210,8 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
                        B_32_BIT_FULL_LOCK, 0);
                                // TODO: Use B_FULL_LOCK, if possible!
                if (buffer->area < 0) {
-                       SHOW_ERROR(2, "Cannot create DMA buffer of %d bytes",
-                               (int)size);
+                       SHOW_ERROR(2, "Cannot create DMA buffer of %" B_PRIu32 
" bytes",
+                               size);
                        return false;
                }
 
@@ -222,7 +220,7 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
 
        // create S/G list
        // worst case is one entry per page, and size is page-aligned
-       sg_list_size = buffer->size / B_PAGE_SIZE * sizeof( physical_entry );
+       size_t sg_list_size = buffer->size / B_PAGE_SIZE * sizeof( 
physical_entry );
        // create_area has page-granularity
        sg_list_size = (sg_list_size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
 
@@ -231,15 +229,15 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
                B_32_BIT_FULL_LOCK, 0);
                        // TODO: Use B_FULL_LOCK, if possible!
        if (buffer->sg_list_area < 0) {
-               SHOW_ERROR( 2, "Cannot craete DMA buffer S/G list of %d bytes",
-                       (int)sg_list_size );
+               SHOW_ERROR( 2, "Cannot create DMA buffer S/G list of %" 
B_PRIuSIZE
+                       " bytes", sg_list_size );
 
                delete_area(buffer->area);
                buffer->area = 0;
                return false;
        }
 
-       sg_list_entries = sg_list_size / sizeof( physical_entry );
+       size_t sg_list_entries = sg_list_size / sizeof(physical_entry);
 
        {
                size_t mapped_len;
@@ -255,8 +253,9 @@ scsi_alloc_dma_buffer(dma_buffer *buffer, dma_params 
*dma_params, uint32 size)
                        &mapped_len );
 
                if( res != B_OK || mapped_len != buffer->size ) {
-                       SHOW_ERROR(0, "Error creating S/G list for DMA buffer 
(%s; wanted %d, got %d bytes)",
-                               strerror(res), (int)mapped_len, 
(int)buffer->size);
+                       SHOW_ERROR(0, "Error creating S/G list for DMA buffer 
(%s; wanted "
+                               "%" B_PRIuSIZE ", got %" B_PRIuSIZE " bytes)", 
strerror(res),
+                               mapped_len, buffer->size);
                }
        }
 
@@ -278,7 +277,7 @@ scsi_free_dma_buffer_sg_orig(dma_buffer *buffer)
 /** allocate S/G list to original data */
 
 static bool
-scsi_alloc_dma_buffer_sg_orig(dma_buffer *buffer, int size)
+scsi_alloc_dma_buffer_sg_orig(dma_buffer *buffer, size_t size)
 {
        // free old list first
        scsi_free_dma_buffer_sg_orig(buffer);
@@ -290,15 +289,15 @@ scsi_alloc_dma_buffer_sg_orig(dma_buffer *buffer, int 
size)
                B_ANY_KERNEL_ADDRESS, size,
                B_NO_LOCK, 0);
        if (buffer->sg_orig < 0) {
-               SHOW_ERROR(2, "Cannot S/G list buffer to original data of %d 
bytes",
-                       (int)size);
+               SHOW_ERROR(2, "Cannot S/G list buffer to original data of %" 
B_PRIuSIZE
+                       " bytes", size);
                return false;
        }
 
        buffer->sg_count_max_orig = size / sizeof(physical_entry);
 
-       SHOW_INFO(3, "Got up to %d S/G entries to original data",
-               (int)buffer->sg_count_max_orig);
+       SHOW_INFO(3, "Got up to %" B_PRId32 " S/G entries to original data",
+               buffer->sg_count_max_orig);
 
        return true;
 }
diff --git a/src/add-ons/kernel/bus_managers/scsi/emulation.cpp 
b/src/add-ons/kernel/bus_managers/scsi/emulation.cpp
index 161b273..840517a 100644
--- a/src/add-ons/kernel/bus_managers/scsi/emulation.cpp
+++ b/src/add-ons/kernel/bus_managers/scsi/emulation.cpp
@@ -167,7 +167,6 @@ scsi_start_mode_sense_6(scsi_ccb *request)
 {
        scsi_cmd_mode_sense_6 *cmd = (scsi_cmd_mode_sense_6 *)request->orig_cdb;
        scsi_cmd_mode_sense_10 *cdb = (scsi_cmd_mode_sense_10 *)request->cdb;
-       size_t allocationLength;
 
        SHOW_FLOW0(3, "patching MODE SENSE(6) to MODE SENSE(10)");
 
@@ -180,11 +179,11 @@ scsi_start_mode_sense_6(scsi_ccb *request)
        cdb->page_code = cmd->page_code;
        cdb->page_control = cmd->page_control;
 
-       allocationLength = cmd->allocation_length
+       size_t allocationLength = cmd->allocation_length
                - sizeof(scsi_cmd_mode_sense_6) + 
sizeof(scsi_cmd_mode_sense_10);
        cdb->allocation_length = B_HOST_TO_BENDIAN_INT16(allocationLength);
 
-       SHOW_FLOW(3, "allocation_length=%ld", allocationLength);
+       SHOW_FLOW(3, "allocation_length=%" B_PRIuSIZE, allocationLength);
 
        cdb->control = cmd->control;
 
diff --git a/src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp 
b/src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp
index 2d4977f..cae10b5 100644
--- a/src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp
+++ b/src/add-ons/kernel/bus_managers/scsi/scatter_gather.cpp
@@ -37,7 +37,6 @@ fill_temp_sg(scsi_ccb *ccb)
        };
        size_t num_entries;
        size_t mapped_len;
-       uint32 cur_idx;
        physical_entry *temp_sg = (physical_entry *)ccb->sg_list;
 
        res = get_iovec_memory_map(&vec, 1, 0, ccb->data_length, temp_sg, 
max_sg_blocks,
@@ -54,10 +53,10 @@ fill_temp_sg(scsi_ccb *ccb)
        if (dma_boundary != ~(uint32)0 || ccb->data_length > max_sg_block_size) 
{
                // S/G list may not be controller-compatible:
                // we have to split offending entries
-               SHOW_FLOW(3, "Checking violation of dma boundary 0x%x and entry 
size 0x%x",
-                       (int)dma_boundary, (int)max_sg_block_size);
+               SHOW_FLOW(3, "Checking violation of dma boundary 0x%" B_PRIx32
+                       " and entry size 0x%" B_PRIx32, dma_boundary, 
max_sg_block_size);
 
-               for (cur_idx = 0; cur_idx < num_entries; ++cur_idx) {
+               for (uint32 cur_idx = 0; cur_idx < num_entries; ++cur_idx) {
                        addr_t max_len;
 
                        // calculate space upto next dma boundary crossing
@@ -66,10 +65,10 @@ fill_temp_sg(scsi_ccb *ccb)
                        // restrict size per sg item
                        max_len = std::min(max_len, (addr_t)max_sg_block_size);
 
-                       SHOW_FLOW(4, "addr=%#" B_PRIxPHYSADDR ", size=%x, 
max_len=%x, "
-                               "idx=%d, num=%d", temp_sg[cur_idx].address,
-                               (int)temp_sg[cur_idx].size, (int)max_len, 
(int)cur_idx,
-                               (int)num_entries);
+                       SHOW_FLOW(4, "addr=%#" B_PRIxPHYSADDR ", size=%" 
B_PRIxPHYSADDR
+                               ", max_len=%" B_PRIxADDR ", idx=%" B_PRId32 ", 
num=%"
+                               B_PRIuSIZE, temp_sg[cur_idx].address, 
temp_sg[cur_idx].size,
+                               max_len, cur_idx, num_entries);
 
                        if (max_len < temp_sg[cur_idx].size) {
                                // split sg block
@@ -153,8 +152,8 @@ cleanup_tmp_sg(scsi_ccb *ccb)
 {
        status_t res;
 
-       SHOW_FLOW(3, "ccb=%p, data=%p, data_length=%d",
-               ccb, ccb->data, (int)ccb->data_length);
+       SHOW_FLOW(3, "ccb=%p, data=%p, data_length=%" B_PRId32,
+               ccb, ccb->data, ccb->data_length);
 
        res = unlock_memory(ccb->data, ccb->data_length, B_DMA_IO
                |  ((ccb->flags & SCSI_DIR_MASK) == SCSI_DIR_IN ? B_READ_DEVICE 
: 0));
diff --git a/src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp 
b/src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp
index 3dd7b8d..aecdbf7 100644
--- a/src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp
+++ b/src/add-ons/kernel/bus_managers/scsi/virtual_memory.cpp
@@ -32,8 +32,9 @@ get_iovec_memory_map(iovec *vec, size_t vec_count, size_t 
vec_offset, size_t len
        size_t cur_idx;
        size_t left_len;
 
-       SHOW_FLOW(3, "vec_count=%lu, vec_offset=%lu, len=%lu, max_entries=%lu",
-               vec_count, vec_offset, len, max_entries);
+       SHOW_FLOW(3, "vec_count=%" B_PRIuSIZE ", vec_offset=%" B_PRIuSIZE ", 
len=%"
+               B_PRIuSIZE ", max_entries=%" B_PRIuSIZE, vec_count, vec_offset, 
len,
+               max_entries);
 
        // skip iovec blocks if needed
        while (vec_count > 0 && vec_offset > vec->iov_len) {
@@ -117,8 +118,8 @@ get_iovec_memory_map(iovec *vec, size_t vec_count, size_t 
vec_offset, size_t len
        *num_entries = cur_idx;
        *mapped_len = len - left_len;
 
-       SHOW_FLOW( 3, "num_entries=%d, mapped_len=%x",
-               (int)*num_entries, (int)*mapped_len );
+       SHOW_FLOW( 3, "num_entries=%" B_PRIuSIZE ", mapped_len=%" B_PRIxSIZE,
+               *num_entries, *mapped_len);
 
        return B_OK;
 }


Other related posts: