uspace/app/blkdump/blkdump.c

   1 /*
   2  * Copyright (c) 2011 Martin Sucha
   3  * Copyright (c) 2013 Jiri Svoboda
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * - The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /** @addtogroup fs
  31  * @{
  32  */
  33
  34 /**
  35  * @file        blockdump.c
  36  * @brief       Tool for dumping content of block devices
  37  *
  38  */
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <stdint.h>
  43 #include <block.h>
  44 #include <mem.h>
  45 #include <loc.h>
  46 #include <byteorder.h>
  47 #include <scsi/mmc.h>
  48 #include <offset.h>
  49 #include <inttypes.h>
  50 #include <errno.h>
  51 #include <str.h>
  52
  53 #define NAME    "blkdump"
  54
  55 static void syntax_print(void);
  56 static int print_blocks(aoff64_t block_offset, aoff64_t block_count, size_t block_size);
  57 static int print_toc(void);
  58 static void print_hex_row(uint8_t *data, size_t length, size_t bytes_per_row);
  59
  60 static bool relative = false;
  61 static service_id_t service_id;
  62
  63 int main(int argc, char **argv)
  64 {
  65
  66         errno_t rc;
  67         char *dev_path;
  68         size_t block_size;
  69         char *endptr;
  70         aoff64_t block_offset = 0;
  71         aoff64_t block_count = 1;
  72         aoff64_t dev_nblocks;
  73         bool toc = false;
  74
  75         if (argc < 2) {
  76                 printf(NAME ": Error, argument missing.\n");
  77                 syntax_print();
  78                 return 1;
  79         }
  80
  81         --argc;
  82         ++argv;
  83
  84         if (str_cmp(*argv, "--toc") == 0) {
  85                 --argc;
  86                 ++argv;
  87                 toc = true;
  88                 goto devname;
  89         }
  90
  91         if (str_cmp(*argv, "--relative") == 0) {
  92                 --argc;
  93                 ++argv;
  94                 relative = true;
  95         }
  96
  97         if (str_cmp(*argv, "--offset") == 0) {
  98                 --argc;
  99                 ++argv;
 100                 if (*argv == NULL) {
 101                         printf(NAME ": Error, argument missing (offset).\n");
 102                         syntax_print();
 103                         return 1;
 104                 }
 105
 106                 block_offset = strtol(*argv, &endptr, 10);
 107                 if (*endptr != '\0') {
 108                         printf(NAME ": Error, invalid argument (offset).\n");
 109                         syntax_print();
 110                         return 1;
 111                 }
 112
 113                 --argc;
 114                 ++argv;
 115         }
 116
 117         if (str_cmp(*argv, "--count") == 0) {
 118                 --argc;
 119                 ++argv;
 120                 if (*argv == NULL) {
 121                         printf(NAME ": Error, argument missing (count).\n");
 122                         syntax_print();
 123                         return 1;
 124                 }
 125
 126                 block_count = strtol(*argv, &endptr, 10);
 127                 if (*endptr != '\0') {
 128                         printf(NAME ": Error, invalid argument (count).\n");
 129                         syntax_print();
 130                         return 1;
 131                 }
 132
 133                 --argc;
 134                 ++argv;
 135         }
 136
 137 devname:
 138         if (argc != 1) {
 139                 printf(NAME ": Error, unexpected argument.\n");
 140                 syntax_print();
 141                 return 1;
 142         }
 143
 144         dev_path = *argv;
 145
 146         rc = loc_service_get_id(dev_path, &service_id, 0);
 147         if (rc != EOK) {
 148                 printf(NAME ": Error resolving device `%s'.\n", dev_path);
 149                 return 2;
 150         }
 151
 152         rc = block_init(service_id, 2048);
 153         if (rc != EOK)  {
 154                 printf(NAME ": Error initializing libblock.\n");
 155                 return 2;
 156         }
 157
 158         rc = block_get_bsize(service_id, &block_size);
 159         if (rc != EOK) {
 160                 printf(NAME ": Error determining device block size.\n");
 161                 return 2;
 162         }
 163
 164         rc = block_get_nblocks(service_id, &dev_nblocks);
 165         if (rc != EOK) {
 166                 printf(NAME ": Warning, failed to obtain block device size.\n");
 167         }
 168
 169         printf("Device %s has %" PRIuOFF64 " blocks, %" PRIuOFF64 " bytes each\n", dev_path, dev_nblocks, (aoff64_t) block_size);
 170
 171         int ret;
 172         if (toc)
 173                 ret = print_toc();
 174         else
 175                 ret = print_blocks(block_offset, block_count, block_size);
 176
 177         block_fini(service_id);
 178
 179         return ret;
 180 }
 181
 182 static int print_blocks(aoff64_t block_offset, aoff64_t block_count, size_t block_size)
 183 {
 184         uint8_t *data;
 185         aoff64_t current;
 186         aoff64_t limit;
 187         size_t data_offset;
 188         errno_t rc;
 189
 190         data = malloc(block_size);
 191         if (data == NULL) {
 192                 printf(NAME ": Error allocating data buffer of %" PRIuOFF64 " bytes", (aoff64_t) block_size);
 193                 return 3;
 194         }
 195
 196         limit = block_offset + block_count;
 197         for (current = block_offset; current < limit; current++) {
 198                 rc = block_read_direct(service_id, current, 1, data);
 199                 if (rc != EOK) {
 200                         printf(NAME ": Error reading block at %" PRIuOFF64 " \n", current);
 201                         free(data);
 202                         return 3;
 203                 }
 204
 205                 printf("---- Block %" PRIuOFF64 " (at %" PRIuOFF64 ") ----\n", current, current * block_size);
 206
 207                 for (data_offset = 0; data_offset < block_size; data_offset += 16) {
 208                         if (relative) {
 209                                 printf("%8" PRIxOFF64 ": ", (aoff64_t) data_offset);
 210                         } else {
 211                                 printf("%8" PRIxOFF64 ": ", current * block_size + data_offset);
 212                         }
 213                         print_hex_row(data + data_offset, block_size - data_offset, 16);
 214                         printf("\n");
 215                 }
 216                 printf("\n");
 217         }
 218
 219         free(data);
 220         return 0;
 221 }
 222
 223 static int print_toc(void)
 224 {
 225         scsi_toc_multisess_data_t toc;
 226         errno_t rc;
 227
 228         rc = block_read_toc(service_id, 0, &toc, sizeof(toc));
 229         if (rc != EOK)
 230                 return 1;
 231
 232         printf("Multisession Information:\n");
 233         printf("\tFirst complete session: %" PRIu8 "\n", toc.first_sess);
 234         printf("\tLast complete session: %" PRIu8 "\n", toc.last_sess);
 235         printf("\tFirst track of last complete session:\n");
 236         printf("\t\tADR / Control: 0x%" PRIx8 "\n", toc.ftrack_lsess.adr_control);
 237         printf("\t\tTrack number: %" PRIu8 "\n", toc.ftrack_lsess.track_no);
 238         printf("\t\tStart block address: %" PRIu32 "\n", toc.ftrack_lsess.start_addr);
 239
 240         return 0;
 241 }
 242
 243 /**
 244  * Print a row of 16 bytes as commonly seen in hexadecimal dumps
 245  */
 246 static void print_hex_row(uint8_t *data, size_t length, size_t bytes_per_row)
 247 {
 248         size_t pos;
 249         uint8_t b;
 250
 251         if (length > bytes_per_row) {
 252                 length = bytes_per_row;
 253         }
 254
 255         /* Print hexadecimal values */
 256         for (pos = 0; pos < length; pos++) {
 257                 if (pos == length / 2) {
 258                         printf(" ");
 259                 }
 260                 printf("%02hhX ", data[pos]);
 261         }
 262
 263         /* Pad with spaces if we have less than 16 bytes */
 264         for (pos = length; pos < bytes_per_row; pos++) {
 265                 if (pos == length / 2) {
 266                         printf(" ");
 267                 }
 268                 printf("   ");
 269         }
 270
 271         /* Print printable characters */
 272         for (pos = 0; pos < length; pos++) {
 273                 if (pos == length / 2) {
 274                         printf(" ");
 275                 }
 276                 b = data[pos];
 277                 if (b >= 32 && b < 128) {
 278                         putchar(b);
 279                 } else {
 280                         putchar('.');
 281                 }
 282         }
 283 }
 284
 285 static void syntax_print(void)
 286 {
 287         printf("syntax: blkdump [--toc] [--relative] [--offset <num_blocks>] "
 288             "[--count <num_blocks>] <device_name>\n");
 289 }
 290
 291 /**
 292  * @}
 293  */