diff options
Diffstat (limited to 'testing/tst_sg_lib.c')
| -rw-r--r-- | testing/tst_sg_lib.c | 734 |
1 files changed, 734 insertions, 0 deletions
diff --git a/testing/tst_sg_lib.c b/testing/tst_sg_lib.c new file mode 100644 index 00000000..10cf3bbb --- /dev/null +++ b/testing/tst_sg_lib.c @@ -0,0 +1,734 @@ +/* + * Copyright (c) 2013-2022 Douglas Gilbert. + * All rights reserved. + * Use of this source code is governed by a BSD-style + * license that can be found in the BSD_LICENSE file. + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include <unistd.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#include <getopt.h> +#include <ctype.h> +#include <errno.h> +#define __STDC_FORMAT_MACROS 1 +#include <inttypes.h> + +#include <time.h> + +#if defined(__GNUC__) && ! defined(SG_LIB_FREEBSD) +#include <byteswap.h> +#endif + +#ifdef HAVE_CONFIG_H +#include "config.h" /* need this to see if HAVE_BYTESWAP_H */ +#endif + +#include "sg_lib.h" +#include "sg_pr2serr.h" + +/* Uncomment the next two undefs to force use of the generic (i.e. shifting) + * unaligned functions (i.e. sg_get_* and sg_put_*). Use "-b 16|32|64 + * -n 100m" to see the differences in timing. */ +/* #undef HAVE_CONFIG_H */ +/* #undef HAVE_BYTESWAP_H */ +#include "sg_unaligned.h" + +/* + * A utility program to test sg_libs string handling, specifically + * related to snprintf(). + */ + +static const char * version_str = "1.17 20220717"; + + +#define MY_NAME "tst_sg_lib" + +#define MAX_LINE_LEN 1024 + + +static struct option long_options[] = { + {"byteswap", required_argument, 0, 'b'}, + {"exit", no_argument, 0, 'e'}, + {"help", no_argument, 0, 'h'}, + {"hex2", no_argument, 0, 'H'}, + {"json", optional_argument, 0, 'j'}, + {"leadin", required_argument, 0, 'l'}, + {"num", required_argument, 0, 'n'}, + {"printf", no_argument, 0, 'p'}, + {"sense", no_argument, 0, 's'}, + {"unaligned", no_argument, 0, 'u'}, + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {0, 0, 0, 0}, /* sentinel */ +}; + +static const uint8_t desc_sense_data1[] = { + /* unrec_err, excessive_writes, sdat_ovfl, additional_len=? */ + 0x72, 0x1, 0x3, 0x2, 0x80, 0x0, 0x0, 12+12+8+4+8+4+28, + /* Information: 0x11223344556677bb */ + 0x0, 0xa, 0x80, 0x0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0xbb, + /* command specific: 0x3344556677bbccff */ + 0x1, 0xa, 0x0, 0x0, 0x33, 0x44, 0x55, 0x66, 0x77, 0xbb, 0xcc, 0xff, + /* sense key specific: SKSV=1, actual_count=257 (hex: 0x101) */ + 0x2, 0x6, 0x0, 0x0, 0x80, 0x1, 0x1, 0x0, + /* field replaceable code=0x45 */ + 0x3, 0x2, 0x0, 0x45, + /* another progress report indicator */ + 0xa, 0x6, 0x2, 0x1, 0x2, 0x0, 0x32, 0x01, + /* incorrect length indicator (ILI) */ + 0x5, 0x2, 0x0, 0x20, + /* user data segment referral */ + 0xb, 26, 0x1, 0x0, + 0,0,0,1, 0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8, + 0x1,0x2,0x3,0x4,0x55,0x6,0x7,0x8, + 2,0,0x12,0x34, + }; + +static const uint8_t desc_sense_data2[] = { + /* ill_req, inv fld in para list, additional_len=? */ + 0x72, 0x5, 0x26, 0x0, 0x0, 0x0, 0x0, 8+4, + /* sense key specific: SKSV=1, C/D*=0, bitp=7 bytep=34 */ + 0x2, 0x6, 0x0, 0x0, 0x8f, 0x0, 0x34, 0x0, + /* field replaceable code=0x45 */ + 0x3, 0x2, 0x0, 0x45, + }; + +static const uint8_t desc_sense_data3[] = { + /* medium err, vibration induced ..., additional_len=? */ + 0x72, 0x3, 0x9, 0x5, 0x0, 0x0, 0x0, 32+16, + /* 0xd: block dev: sense key specific: SKSV=1, retry_count=257, fru=0x45 + * info=0x1122334455, command_specific=0x1 */ + 0xd, 0x1e, 0xa0, 0x0, 0x80, 0x1, 0x1, 0x45, + 0x0, 0x0, 0x0, 0x11, 0x22, 0x33, 0x44, 0x55, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + /* following sbc3 (standard) and sbc4r10 inconsistency; add padding */ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + /* 0xe: reason: send_to_given+henceforth, lu, naa-5, 0x5333333000001f40 */ + 0xe, 0xe, 0x0, 0x1, 0x1, 0x3, 0x0, 0x8, + 0x53, 0x33, 0x33, 0x30, 0x0, 0x0, 0x1f, 0x40, + }; + +static const uint8_t desc_sense_data4[] = { + /* ill_req, inv fld in para list, additional_len=? */ + 0x72, 0x5, 0x26, 0x0, 0x0, 0x0, 0x0, 24, + /* Forwarded sense data, FSDT=0, sd_src=7, f_status=2 */ + 0xc, 22, 0x7, 0x2, + /* ill_req, inv fld in para list, additional_len=? */ + 0x72, 0x5, 0x26, 0x0, 0x0, 0x0, 0x0, 8+4, + /* sense key specific: SKSV=1, C/D*=0, bitp=7 bytep=34 */ + 0x2, 0x6, 0x0, 0x0, 0x8f, 0x0, 0x34, 0x0, + /* field replaceable code=0x45 */ + 0x3, 0x2, 0x0, 0x45, + }; + +static const uint8_t desc_sense_data5[] = { + /* no_sense, ATA info available */ + 0x72, 0x0, 0x0, 0x1d, 0x0, 0x0, 0x0, 14+14, + /* ATA descriptor extend=1 */ + 0x9, 0xc, 0x1, 0x0, 0x34, 0x12, 0x44, 0x11, + 0x55, 0x22, 0x66, 0x33, 0x1, 0x0, + /* ATA descriptor extend=0 */ + 0x9, 0xc, 0x0, 0x0, 0x34, 0x12, 0x44, 0x11, + 0x55, 0x22, 0x66, 0x33, 0x1, 0x0, + }; + +static const uint8_t desc_sense_data6[] = { + /* UA, req, subsidiary binding */ + 0x72, 0x6, 0x3f, 0x1a, 0x0, 0x0, 0x0, 26+12+12, + /* 0xe: designator, reason: preferred admin lu, uuid */ + 0xe, 0x18, 0x0, 0x4, 0x1, 0xa, 0x0, 0x12, + 0x10, 0x0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, + 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, + 0xfe, 0xdc, + /* 0x0: Information(valid): lun */ + 0x0, 0xa, 0x80, 0x0, + 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + /* 0x1: Command specific: 0x1 */ + 0x1, 0xa, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + }; + +static const char * leadin = NULL; + + +static void +usage() +{ + fprintf(stderr, + "Usage: tst_sg_lib [--exit] [--help] [--hex2] [--leadin=STR] " + "[--printf]\n" + " [--sense] [--unaligned] [--verbose] " + "[--version]\n" + " where:\n" +#if defined(__GNUC__) && ! defined(SG_LIB_FREEBSD) + " --byteswap=B|-b B B is 16, 32 or 64; tests NUM " + "byteswaps\n" + " compared to sg_unaligned " + "equivalent\n" + " --exit|-e test exit status strings\n" +#else + " --exit|-e test exit status strings\n" +#endif + " --help|-h print out usage message\n" + " --hex2|-H test hex2* variants\n" + " --leadin=STR|-l STR every line output by --sense " + "should\n" + " be prefixed by STR\n" + " --num=NUM|-n NUM number of iterations (def=1)\n" + " --printf|-p test library printf variants\n" + " --sense|-s test sense data handling\n" + " --unaligned|-u test unaligned data handling\n" + " --verbose|-v increase verbosity\n" + " --version|-V print version string and exit\n\n" + "Test various parts of sg_lib, see options. Sense data tests " + "overlap\nsomewhat with examples/sg_sense_test .\n" + ); + +} + +static char * +get_exit_status_str(int exit_status, bool longer, int b_len, char * b) +{ + int n; + + n = sg_scnpr(b, b_len, " ES=%d: ", exit_status); + if (n >= (b_len - 1)) + return b; + if (sg_exit2str(exit_status, longer, b_len - n, b + n)) { + n = (int)strlen(b); + if (n < (b_len - 1)) + sg_scnpr(b + n, b_len - n, " [ok=true]"); + return b; + } else + snprintf(b, b_len, " No ES string for %d%s", exit_status, + (longer ? " [ok=false]" : "")); + return b; +} + +static uint8_t arr[64]; + +#define OFF 7 /* in byteswap mode, can test different alignments (def: 8) */ + +int +main(int argc, char * argv[]) +{ + bool as_json = false; + bool do_exit_status = false; + bool ok; + int k, c, n, len; + int byteswap_sz = 0; + int do_hex2 = 0; + int do_num = 1; + int do_printf = 0; + int do_sense = 0; + int do_unaligned = 0; + int did_something = 0; + int vb = 0; + int ret = 0; + sgj_opaque_p jop = NULL; + sgj_opaque_p jo2p; + sgj_state json_st SG_C_CPP_ZERO_INIT; + sgj_state * jsp = &json_st; + char b[2048]; + char bb[256]; + const int b_len = sizeof(b); + + while (1) { + int option_index = 0; + + c = getopt_long(argc, argv, "b:ehHj::l:n:psuvV", long_options, + &option_index); + if (c == -1) + break; + + switch (c) { + case 'b': + byteswap_sz = sg_get_num(optarg); + if (! ((16 == byteswap_sz) || (32 == byteswap_sz) || + (64 == byteswap_sz))) { + fprintf(stderr, "--byteswap= requires 16, 32 or 64\n"); + return 1; + } + break; + case 'e': + do_exit_status = true; + break; + case 'h': + case '?': + usage(); + return 0; + case 'H': + ++do_hex2; + break; + case 'j': + if (! sgj_init_state(&json_st, optarg)) { + pr2serr("bad argument to --json= option, unrecognized " + "character '%c'\n", json_st.first_bad_char); + return SG_LIB_SYNTAX_ERROR; + } + break; + + case 'l': + leadin = optarg; + break; + case 'n': + do_num = sg_get_num(optarg); + if (do_num < 0) { + fprintf(stderr, "--num= unable decode argument as number\n"); + return 1; + } + break; + case 'p': + ++do_printf; + break; + case 's': + ++do_sense; + break; + case 'u': + ++do_unaligned; + break; + case 'v': + ++vb; + break; + case 'V': + fprintf(stderr, "version: %s\n", version_str); + return 0; + default: + fprintf(stderr, "unrecognised switch code 0x%x ??\n", c); + usage(); + return 1; + } + } + if (optind < argc) { + if (optind < argc) { + for (; optind < argc; ++optind) + fprintf(stderr, "Unexpected extra argument: %s\n", + argv[optind]); + usage(); + return 1; + } + } + + as_json = json_st.pr_as_json; + if (as_json) + jop = sgj_start_r(MY_NAME, version_str, argc, argv, jsp); + + if (do_exit_status) { + ++did_something; + + printf("Test Exit Status strings (add -v for long version):\n"); + printf(" No error (es=0): %s\n", + sg_get_category_sense_str(0, b_len, b, vb)); + ok = sg_exit2str(0, true, b_len, b); + printf(" No error (force verbose): %s\n", b); + if (vb) + printf(" for previous line sg_exit2str() returned: %s\n", + (ok ? "true" : "false")); + printf("%s\n", get_exit_status_str(1, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(2, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(3, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(4, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(5, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(6, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(7, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(8, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(25, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(33, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(36, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(48, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(50, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(51, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(96, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(97, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(97, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(255, (vb > 0), b_len, b)); + printf("%s\n", get_exit_status_str(-1, (vb > 0), b_len, b)); + + printf("\n"); + } + + if (do_sense ) { + ++did_something; + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, "desc_sense_data__test1"); + sgj_js_sense(jsp, jo2p, desc_sense_data1, + (int)sizeof(desc_sense_data1)); + } else { + printf("desc_sense_data test1:\n"); + sg_print_sense(leadin, desc_sense_data1, + (int)sizeof(desc_sense_data1), vb); + printf("\n"); + } +#if 1 + if (as_json) { + sgj_js_str_out(jsp, "sg_get_sense_str(ds_data1)", 999); + sg_get_sense_str(leadin, desc_sense_data1, + sizeof(desc_sense_data1), vb, b_len, b); + sgj_js_str_out(jsp, b, strlen(b)); + + } else { + printf("sg_get_sense_str(ds_data1):\n"); + sg_get_sense_str(leadin, desc_sense_data1, + sizeof(desc_sense_data1), vb, b_len, b); + printf("sg_get_sense_str: strlen(b)->%u\n", (uint32_t)strlen(b)); + printf("%s", b); + printf("\n"); + } +#endif + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, "desc_sense_data__test2"); + sgj_js_sense(jsp, jo2p, desc_sense_data2, + (int)sizeof(desc_sense_data2)); + } else { + printf("desc_sense_data test2\n"); + sg_print_sense(leadin, desc_sense_data2, + (int)sizeof(desc_sense_data2), vb); + printf("\n"); + } + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, + "desc_sense_block_combo_test3"); + sgj_js_sense(jsp, jo2p, desc_sense_data3, + (int)sizeof(desc_sense_data3)); + } else { + printf("desc_sense block dev combo plus designator test3\n"); + sg_print_sense(leadin, desc_sense_data3, + (int)sizeof(desc_sense_data3), vb); + printf("\n"); + } + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, + "desc_sense_forwarded_sense_test4"); + sgj_js_sense(jsp, jo2p, desc_sense_data4, + (int)sizeof(desc_sense_data4)); + } else { + printf("desc_sense forwarded sense test4\n"); + sg_print_sense(leadin, desc_sense_data4, + (int)sizeof(desc_sense_data4), vb); + printf("\n"); + } + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, + "desc_sense_ata_info_test5"); + sgj_js_sense(jsp, jo2p, desc_sense_data5, + (int)sizeof(desc_sense_data5)); + } else { + printf("desc_sense ATA Info test5\n"); + sg_print_sense(leadin, desc_sense_data5, + (int)sizeof(desc_sense_data5), vb); + printf("\n"); + } + if (as_json) { + jo2p = sgj_named_subobject_r(jsp, jop, + "desc_sense_ua_binding_test6"); + sgj_js_sense(jsp, jo2p, desc_sense_data6, + (int)sizeof(desc_sense_data6)); + } else { + printf("desc_sense UA subsidiary binding changed test6\n"); + sg_print_sense(leadin, desc_sense_data6, + (int)sizeof(desc_sense_data6), vb); + printf("\n"); + printf("\n"); + } + } + + if (do_printf) { + ++did_something; + printf("Testing sg_scnpr():\n"); + b[0] = '\0'; + len = b_len; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = -1; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 0; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 1; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 2; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 3; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 4; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 5; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 6; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + + b[0] = '\0'; + len = 7; + n = sg_scnpr(b, len, "%s", "test"); + printf("sg_scnpr(,%d,,\"test\") -> %d; strlen(b) -> %u\n", + len, n, (uint32_t)strlen(b)); + if (strlen(b) > 0) + printf("Resulting string: %s\n", b); + } + if (do_hex2) { + uint8_t b[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, + 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, + 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58}; + + ++did_something; + for (k = 0; k < 19; ++k) { + printf("k=%d:\n", k); + hex2stdout(b, k, 0); + hex2str(b, k, "h2str0: ", 0, sizeof(bb), bb); + printf("%s", bb); + hex2stdout(b, k, 1); + hex2str(b, k, "h2str1: ", 1, sizeof(bb), bb); + printf("%s", bb); + hex2str(b, k, "h2str2: ", 2, sizeof(bb), bb); + printf("%s\n", bb); + hex2stdout(b, k, -1); + printf("\n"); + } + } + if (do_unaligned) { + uint16_t u16 = 0x55aa; + uint16_t u16r; + uint32_t u24 = 0x224488; + uint32_t u24r; + uint32_t u32 = 0x224488aa; + uint32_t u32r; + uint64_t u48 = 0x112233445566ULL; + uint64_t u48r; + uint64_t u64 = 0x1122334455667788ULL; + uint64_t u64r; + uint8_t u8[64]; + + ++did_something; + if (vb) + memset(u8, 0, sizeof(u8)); + printf("u16=0x%" PRIx16 "\n", u16); + sg_put_unaligned_le16(u16, u8); + printf(" le16:\n"); + hex2stdout(u8, vb ? 10 : 2, -1); + u16r = sg_get_unaligned_le16(u8); + printf(" u16r=0x%" PRIx16 "\n", u16r); + sg_put_unaligned_be16(u16, u8); + printf(" be16:\n"); + hex2stdout(u8, vb ? 10 : 2, -1); + u16r = sg_get_unaligned_be16(u8); + printf(" u16r=0x%" PRIx16 "\n\n", u16r); + + printf("u24=0x%" PRIx32 "\n", u24); + sg_put_unaligned_le24(u24, u8); + printf(" le24:\n"); + hex2stdout(u8, vb ? 10 : 3, -1); + u24r = sg_get_unaligned_le24(u8); + printf(" u24r=0x%" PRIx32 "\n", u24r); + sg_put_unaligned_be24(u24, u8); + printf(" be24:\n"); + hex2stdout(u8, vb ? 10 : 3, -1); + u24r = sg_get_unaligned_be24(u8); + printf(" u24r=0x%" PRIx32 "\n\n", u24r); + + printf("u32=0x%" PRIx32 "\n", u32); + sg_put_unaligned_le32(u32, u8); + printf(" le32:\n"); + hex2stdout(u8, vb ? 10 : 4, -1); + u32r = sg_get_unaligned_le32(u8); + printf(" u32r=0x%" PRIx32 "\n", u32r); + sg_put_unaligned_be32(u32, u8); + printf(" be32:\n"); + hex2stdout(u8, vb ? 10 : 4, -1); + u32r = sg_get_unaligned_be32(u8); + printf(" u32r=0x%" PRIx32 "\n\n", u32r); + + printf("u48=0x%" PRIx64 "\n", u48); + sg_put_unaligned_le48(u48, u8); + printf(" le48:\n"); + hex2stdout(u8, vb ? 10 : 6, -1); + u48r = sg_get_unaligned_le48(u8); + printf(" u48r=0x%" PRIx64 "\n", u48r); + sg_put_unaligned_be48(u48, u8); + printf(" be48:\n"); + hex2stdout(u8, vb ? 10 : 6, -1); + u48r = sg_get_unaligned_be48(u8); + printf(" u48r=0x%" PRIx64 "\n\n", u48r); + + printf("u64=0x%" PRIx64 "\n", u64); + sg_put_unaligned_le64(u64, u8); + printf(" le64:\n"); + hex2stdout(u8, vb ? 10 : 8, -1); + u64r = sg_get_unaligned_le64(u8); + printf(" u64r=0x%" PRIx64 "\n", u64r); + sg_put_unaligned_be64(u64, u8); + printf(" be64:\n"); + hex2stdout(u8, vb ? 10 : 8, -1); + u64r = sg_get_unaligned_be64(u8); + printf(" u64r=0x%" PRIx64 "\n\n", u64r); + + printf(" be[v=8 bytes]:\n"); + hex2stdout(u8, vb ? 10 : 8, -1); + u64r = sg_get_unaligned_be(8, u8); + printf(" u64r[v=8 bytes]=0x%" PRIx64 "\n", u64r); + printf(" le[v=8 bytes]:\n"); + hex2stdout(u8, vb ? 10 : 8, -1); + u64r = sg_get_unaligned_le(8, u8); + printf(" u64r[v=8 bytes]=0x%" PRIx64 "\n\n", u64r); + } + +#if defined(__GNUC__) && ! defined(SG_LIB_FREEBSD) + if (byteswap_sz > 0) { + uint32_t elapsed_msecs; + uint16_t count16 = 0; + uint32_t count32 = 0; + uint64_t count64 = 0; + struct timespec start_tm, end_tm; + + ++did_something; + if (0 != clock_gettime(CLOCK_MONOTONIC, &start_tm)) { + perror("clock_gettime(CLOCK_MONOTONIC)\n"); + return 1; + } + for (k = 0; k < do_num; ++k) { + switch (byteswap_sz) { + case 16: + sg_put_unaligned_be16(count16 + 1, arr + OFF); + count16 = sg_get_unaligned_be16(arr + OFF); + break; + case 32: + sg_put_unaligned_be32(count32 + 1, arr + OFF); + count32 = sg_get_unaligned_be32(arr + OFF); + break; + case 64: + sg_put_unaligned_be64(count64 + 1, arr + OFF); + count64 = sg_get_unaligned_be64(arr + OFF); + break; + default: + break; + } + } + if (0 != clock_gettime(CLOCK_MONOTONIC, &end_tm)) { + perror("clock_gettime(CLOCK_MONOTONIC)\n"); + return 1; + } + elapsed_msecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000; + elapsed_msecs += (end_tm.tv_nsec - start_tm.tv_nsec) / 1000000; + if (16 == byteswap_sz) + printf(" last k=%d, last count16=%u\n", k, count16); + else if (32 == byteswap_sz) + printf(" last k=%d, last count32=%u\n", k, count32); + else + printf(" last k=%d, last count64=%" PRIu64 "\n", k, count64); + printf("Unaligned elapsed milliseconds: %u\n", elapsed_msecs); + count16 = 0; + count32 = 0; + count64 = 0; + + if (0 != clock_gettime(CLOCK_MONOTONIC, &start_tm)) { + perror("clock_gettime(CLOCK_MONOTONIC)\n"); + return 1; + } + for (k = 0; k < do_num; ++k) { + switch (byteswap_sz) { + case 16: + count16 = bswap_16(count16 + 1); + memcpy(arr + OFF, &count16, 2); + memcpy(&count16, arr + OFF, 2); + count16 = bswap_16(count16); + break; + case 32: + count32 = bswap_32(count32 + 1); + memcpy(arr + OFF, &count32, 4); + memcpy(&count32, arr + OFF, 4); + count32 = bswap_32(count32); + break; + case 64: + count64 = bswap_64(count64 + 1); + memcpy(arr + OFF, &count64, 8); + memcpy(&count64, arr + OFF, 8); + count64 = bswap_64(count64); + break; + default: + break; + } + } + if (0 != clock_gettime(CLOCK_MONOTONIC, &end_tm)) { + perror("clock_gettime(CLOCK_MONOTONIC)\n"); + return 1; + } + elapsed_msecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000; + elapsed_msecs += (end_tm.tv_nsec - start_tm.tv_nsec) / 1000000; + if (16 == byteswap_sz) + printf(" last k=%d, last count16=%u\n", k, count16); + else if (32 == byteswap_sz) + printf(" last k=%d, last count32=%u\n", k, count32); + else + printf(" last k=%d, last count64=%" PRIu64 "\n", k, count64); + printf("Byteswap/memcpy elapsed milliseconds: %u\n", elapsed_msecs); + count16 = 0; + count32 = 0; + count64 = 0; + } +#endif + + if (0 == did_something) + printf("Looks like no tests done, check usage with '-h'\n"); + ret = (ret >= 0) ? ret : SG_LIB_CAT_OTHER; + if (as_json) { + if (0 == do_hex2) + sgj_js2file(jsp, NULL, ret, stdout); + sgj_finish(jsp); + } + return ret; +} |