| /* |
| * Copyright (C) 2018-2022 D. Gilbert |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2, or (at your option) |
| * any later version. |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| * |
| * Invocation: See usage() function below. |
| * |
| */ |
| |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <ctype.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <time.h> |
| #include <sys/ioctl.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/utsname.h> |
| #define __STDC_FORMAT_MACROS 1 |
| #include <inttypes.h> |
| |
| #include <sys/socket.h> /* For passing fd_s via Unix sockets */ |
| |
| #ifndef HAVE_LINUX_SG_V4_HDR |
| |
| /* Kernel uapi header contain __user decorations on user space pointers |
| * to indicate they are unsafe in the kernel space. However glibc takes |
| * all those __user decorations out from headers in /usr/include/linux . |
| * So to stop compile errors when directly importing include/uapi/scsi/sg.h |
| * undef __user before doing that include. */ |
| #define __user |
| |
| /* Want to block the original sg.h header from also being included. That |
| * causes lots of multiple definition errors. This will only work if this |
| * header is included _before_ the original sg.h header. */ |
| #define _SCSI_GENERIC_H /* original kernel header guard */ |
| #define _SCSI_SG_H /* glibc header guard */ |
| |
| #include "uapi_sg.h" /* local copy of include/uapi/scsi/sg.h */ |
| |
| #else |
| #define __user |
| #endif /* end of: ifndef HAVE_LINUX_SG_V4_HDR */ |
| |
| #include "sg_lib.h" |
| #include "sg_io_linux.h" |
| #include "sg_linux_inc.h" |
| #include "sg_pr2serr.h" |
| |
| /* This program tests ioctl() calls added and modified in version 4.0 and |
| * later of the Linux sg driver. */ |
| |
| |
| static const char * version_str = "Version: 1.21 20220202"; |
| |
| #define INQ_REPLY_LEN 128 |
| #define INQ_CMD_LEN 6 |
| #define SDIAG_CMD_LEN 6 |
| #define SENSE_BUFFER_LEN 96 |
| |
| #define EBUFF_SZ 512 |
| |
| #ifndef SG_FLAG_Q_AT_TAIL |
| #define SG_FLAG_Q_AT_TAIL 0x10 |
| #endif |
| |
| #ifndef SG_FLAG_Q_AT_HEAD |
| #define SG_FLAG_Q_AT_HEAD 0x20 |
| #endif |
| |
| #define DEF_Q_LEN 16 /* max in sg v3 and earlier */ |
| #define MAX_Q_LEN 512 |
| |
| #define DEF_RESERVE_BUFF_SZ (256 * 1024) |
| |
| static bool create_time = false; |
| static bool is_parent = false; |
| static bool do_fork = false; |
| static bool ioctl_only = false; |
| static bool more_async = false; |
| static bool no_duration = false; |
| static bool q_at_tail = false; |
| static bool write_only = false; |
| static bool mrq_immed = false; /* if set, also sets mrq_iosubmit */ |
| static bool mrq_half_immed = false; |
| static bool mrq_iosubmit = false; |
| static bool show_size_value = false; |
| static bool do_v3_only = false; |
| |
| static int childs_pid = 0; |
| static int iterator_test = -1; |
| static int object_walk_test = -1; |
| static int sg_drv_ver_num = 0; |
| static int q_len = DEF_Q_LEN; |
| static int sleep_secs = 0; |
| static int reserve_buff_sz = DEF_RESERVE_BUFF_SZ; |
| static int num_mrqs = 0; |
| static int num_sgnw = 0; |
| static int dname_current = 0; |
| static int dname_last = 0; |
| static int dname_pos = 0; |
| static int verbose = 0; |
| |
| static const char * relative_cp = ""; |
| static char * file_name = NULL; |
| |
| |
| static void |
| usage(void) |
| { |
| printf("Usage: sg_tst_ioctl [-3] [-c] [-f] [-h] [-I=0|1] [-J=0|1] " |
| "[-l=Q_LEN]\n" |
| " [-m=MRQS[,I|S]] [-M] [-n] [-o] [-r=SZ] " |
| "[-s=SEC]\n" |
| " [-S] [-t] [-T=NUM] [-v] [-V] [-w]\n" |
| " <sg_device>[-<num>] [<sg_device2>]\n" |
| " where:\n" |
| " -3 use sg v3 interface (def: sg v4 if available)\n" |
| " -c timestamp when sg driver created <sg_device>\n" |
| " -f fork and test share between processes\n" |
| " -h help: print usage message then exit\n" |
| " -I=0|1 iterator test of mid-level; 0: unlocked, 1: " |
| "locked\n" |
| " does test -T=NUM times, outputs duration\n" |
| " -J=0|1 object walk up then 2 lookups; 0: no logging; " |
| "1: log\n" |
| " up-scan once per 1000 iterations\n" |
| " -l=Q_LEN queue length, between 1 and 511 (def: 16)\n" |
| " -m=MRQS[,I|S] test multi-req, MRQS number to do; if " |
| "the letter\n" |
| " 'I' is appended after a comma, then do " |
| "IMMED mrq;\n" |
| " 'i' IMMED on submission, non-IMMED on " |
| "receive;\n" |
| " 'S' is appended, then use " |
| "ioctl(SG_IOSUBMIT)\n" |
| " -M set 'more async' flag\n" |
| " -n do not calculate per command duration (def: do)\n" |
| " -o ioctls only, then exit\n" |
| " -r=SZ reserve buffer size in KB (def: 256 --> 256 " |
| "KB)\n" |
| " -s=SEC sleep between writes and reads (def: 0)\n" |
| " -S size of interface structures plus ioctl " |
| "values\n" |
| " -t queue_at_tail (def: q_at_head)\n" |
| " -T=NUM time overhead of NUM invocations of\n" |
| " ioctl(SG_GET_NUM_WAITING); then exit\n" |
| " -v increase verbosity of output\n" |
| " -V print version string then exit\n" |
| " -w write (submit) only then exit\n\n"); |
| printf("There are various groups of options for different tests. The " |
| "get_num_waiting\ngroup needs '-T=NUM' given. When '-I=0|1' is " |
| "also given then an object tree\niterator test is done NUM " |
| "times. If instead '-J=0|1' is given then an\nobject tree " |
| "traversal (up/down) is done 10,000 times (and NUM is\n" |
| "ignored).\n" |
| ); |
| } |
| |
| static void |
| timespec_add(const struct timespec *lhs_p, const struct timespec *rhs_p, |
| struct timespec *res_p) |
| { |
| if ((lhs_p->tv_nsec + rhs_p->tv_nsec) > 1000000000L) { |
| res_p->tv_sec = lhs_p->tv_sec + rhs_p->tv_sec + 1; |
| res_p->tv_nsec = lhs_p->tv_nsec + rhs_p->tv_nsec - 1000000000L; |
| } else { |
| res_p->tv_sec = lhs_p->tv_sec + rhs_p->tv_sec; |
| res_p->tv_nsec = lhs_p->tv_nsec + rhs_p->tv_nsec; |
| } |
| } |
| |
| static void |
| timespec_diff(const struct timespec *lhs_p, const struct timespec *rhs_p, |
| struct timespec *res_p) |
| { |
| if ((lhs_p->tv_nsec - rhs_p->tv_nsec) < 0) { |
| res_p->tv_sec = lhs_p->tv_sec - rhs_p->tv_sec - 1; |
| res_p->tv_nsec = lhs_p->tv_nsec - rhs_p->tv_nsec + 1000000000L; |
| } else { |
| res_p->tv_sec = lhs_p->tv_sec - rhs_p->tv_sec; |
| res_p->tv_nsec = lhs_p->tv_nsec - rhs_p->tv_nsec; |
| } |
| } |
| |
| /* Returns 0 on success. */ |
| int timespec2str(char *buf, unsigned int len, struct timespec *ts) |
| { |
| int ret; |
| struct tm t; |
| |
| tzset(); |
| if (localtime_r(&(ts->tv_sec), &t) == NULL) |
| return 1; |
| |
| ret = strftime(buf, len, "%F %T", &t); |
| if (ret == 0) |
| return 2; |
| len -= ret - 1; |
| |
| ret = snprintf(&buf[strlen(buf)], len, ".%09ld", ts->tv_nsec); |
| if (ret >= (int)len) |
| return 3; |
| return 0; |
| } |
| |
| /* This function taken from Keith Parkard's blog dated 20121005 */ |
| static ssize_t |
| sock_fd_write(int sock, const void *buf, ssize_t buflen, int fd) |
| { |
| ssize_t size; |
| struct msghdr msg; |
| struct iovec iov; |
| union { |
| struct cmsghdr cmsghdr; |
| char control[CMSG_SPACE(sizeof (int))]; |
| } cmsgu; |
| struct cmsghdr *cmsg; |
| |
| iov.iov_base = (void *)buf; /* OS shouldn't write back in this */ |
| iov.iov_len = buflen; |
| |
| msg.msg_name = NULL; |
| msg.msg_namelen = 0; |
| msg.msg_iov = &iov; |
| msg.msg_iovlen = 1; |
| |
| if (fd != -1) { |
| msg.msg_control = cmsgu.control; |
| msg.msg_controllen = sizeof(cmsgu.control); |
| |
| cmsg = CMSG_FIRSTHDR(&msg); |
| cmsg->cmsg_len = CMSG_LEN(sizeof (int)); |
| cmsg->cmsg_level = SOL_SOCKET; |
| cmsg->cmsg_type = SCM_RIGHTS; |
| |
| printf ("passing fd %d\n", fd); |
| *((int *) CMSG_DATA(cmsg)) = fd; |
| } else { |
| msg.msg_control = NULL; |
| msg.msg_controllen = 0; |
| printf ("not passing fd\n"); |
| } |
| |
| size = sendmsg(sock, &msg, 0); |
| |
| if (size < 0) |
| perror ("sendmsg"); |
| return size; |
| } |
| |
| /* This function taken from Keith Parkard's blog dated 2101205 */ |
| static ssize_t |
| sock_fd_read(int sock, void *buf, ssize_t bufsize, int *fd) |
| { |
| ssize_t size; |
| |
| if (fd) { |
| struct msghdr msg; |
| struct iovec iov; |
| union { |
| struct cmsghdr cmsghdr; |
| char control[CMSG_SPACE(sizeof (int))]; |
| } cmsgu; |
| struct cmsghdr *cmsg; |
| |
| iov.iov_base = buf; |
| iov.iov_len = bufsize; |
| |
| msg.msg_name = NULL; |
| msg.msg_namelen = 0; |
| msg.msg_iov = &iov; |
| msg.msg_iovlen = 1; |
| msg.msg_control = cmsgu.control; |
| msg.msg_controllen = sizeof(cmsgu.control); |
| size = recvmsg (sock, &msg, 0); |
| if (size < 0) { |
| perror ("recvmsg"); |
| exit(1); |
| } |
| cmsg = CMSG_FIRSTHDR(&msg); |
| if (cmsg && cmsg->cmsg_len == CMSG_LEN(sizeof(int))) { |
| if (cmsg->cmsg_level != SOL_SOCKET) { |
| fprintf (stderr, "invalid cmsg_level %d\n", |
| cmsg->cmsg_level); |
| exit(1); |
| } |
| if (cmsg->cmsg_type != SCM_RIGHTS) { |
| fprintf (stderr, "invalid cmsg_type %d\n", |
| cmsg->cmsg_type); |
| exit(1); |
| } |
| |
| *fd = *((int *) CMSG_DATA(cmsg)); |
| printf ("received fd %d\n", *fd); |
| } else |
| *fd = -1; |
| } else { |
| size = read (sock, buf, bufsize); |
| if (size < 0) { |
| perror("read"); |
| exit(1); |
| } |
| } |
| return size; |
| } |
| |
| static void |
| set_more_async(int fd, bool more_asy, bool no_dur) |
| { |
| if (sg_drv_ver_num > 40030) { |
| struct sg_extended_info sei; |
| struct sg_extended_info * seip; |
| |
| seip = &sei; |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS; |
| seip->sei_rd_mask |= SG_SEIM_CTL_FLAGS; |
| if (more_asy) { |
| seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_MORE_ASYNC; |
| seip->ctl_flags = SG_CTL_FLAGM_MORE_ASYNC; |
| } |
| if (no_dur) { |
| seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_NO_DURATION; |
| seip->ctl_flags = SG_CTL_FLAGM_NO_DURATION; |
| } |
| if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED, MORE_ASYNC(|NO_DUR)) failed, " |
| "errno=%d %s\n", errno, strerror(errno)); |
| return; |
| } |
| } else |
| pr2serr("sg driver too old for ioctl(SG_SET_GET_EXTENDED)\n"); |
| } |
| |
| static void |
| pr_create_dev_time(int sg_fd, const char * dev_name) |
| { |
| uint32_t u; |
| uint64_t l; |
| struct sg_extended_info sei; |
| struct sg_extended_info * seip; |
| struct timespec time_up, realtime, boottime, createtime, tmp; |
| char b[64]; |
| |
| seip = &sei; |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_DEV_TS_LOWER; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("%s: ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", |
| __func__, errno, strerror(errno)); |
| return; |
| } |
| u = seip->read_value; |
| seip->read_value = SG_SEIRV_DEV_TS_UPPER; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("%s: ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", |
| __func__, errno, strerror(errno)); |
| return; |
| } |
| l = seip->read_value; |
| l <<= 32; |
| l |= u; |
| time_up.tv_sec = l / 1000000000UL; |
| time_up.tv_nsec = l % 1000000000UL; |
| /* printf("create time nanoseconds=%" PRIu64 "\n", l); */ |
| if (clock_gettime(CLOCK_REALTIME, &realtime) < 0) { |
| pr2serr("%s: clock_gettime(CLOCK_REALTIME) failed, errno=%d %s\n", |
| __func__, errno, strerror(errno)); |
| return; |
| } |
| if (clock_gettime(CLOCK_BOOTTIME, &boottime) < 0) { |
| pr2serr("%s: clock_gettime(CLOCK_REALTIME) failed, errno=%d %s\n", |
| __func__, errno, strerror(errno)); |
| return; |
| } |
| timespec_diff(&realtime, &boottime, &tmp); |
| timespec_add(&tmp, &time_up, &createtime); |
| #if 0 |
| printf("real time: %ld,%ld\n", realtime.tv_sec, realtime.tv_nsec); |
| printf("boot time: %ld,%ld\n", boottime.tv_sec, boottime.tv_nsec); |
| printf("time up: %ld,%ld\n", time_up.tv_sec, time_up.tv_nsec); |
| printf("create time: %ld,%ld\n", createtime.tv_sec, createtime.tv_nsec); |
| #endif |
| timespec2str(b, sizeof(b), &createtime); |
| printf("Create time of %s was %s\n", dev_name, b); |
| } |
| |
| static int |
| tst_extended_ioctl(const char * fnp, int sg_fd, const char * fn2p, int sg_fd2, |
| int sock, const char * cp) |
| { |
| uint32_t cflags; |
| struct sg_extended_info sei; |
| struct sg_extended_info * seip; |
| |
| seip = &sei; |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_RESERVED_SIZE; |
| seip->reserved_sz = reserve_buff_sz; |
| seip->sgat_elem_sz = 64 * 1024; |
| seip->sei_rd_mask |= SG_SEIM_RESERVED_SIZE; |
| seip->sei_rd_mask |= SG_SEIM_TOT_FD_THRESH; |
| seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS; |
| seip->sei_rd_mask |= SG_SEIM_CTL_FLAGS; /* this or previous optional */ |
| seip->sei_rd_mask |= SG_SEIM_MINOR_INDEX; |
| seip->sei_wr_mask |= SG_SEIM_SGAT_ELEM_SZ; |
| seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TIME_IN_NS; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_TIME_IN_NS; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_OTHER_OPENS; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_ORPHANS; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_Q_TAIL; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_IS_SHARE; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_IS_READ_SIDE; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_UNSHARE; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_READ_SIDE_FINI; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_READ_SIDE_ERR; |
| seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_NO_DURATION; |
| seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_NO_DURATION; |
| seip->ctl_flags |= SG_CTL_FLAGM_TIME_IN_NS; |
| seip->ctl_flags |= SG_CTL_FLAGM_NO_DURATION; |
| |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| #if 1 |
| printf("%sSG_SET_GET_EXTENDED ioctl ok\n", cp); |
| if (SG_SEIM_RESERVED_SIZE & seip->sei_rd_mask) |
| printf(" %sreserved size: %u\n", cp, seip->reserved_sz); |
| if (SG_SEIM_MINOR_INDEX & seip->sei_rd_mask) |
| printf(" %sminor index: %u\n", cp, seip->minor_index); |
| if (SG_SEIM_TOT_FD_THRESH & seip->sei_rd_mask) |
| printf(" %stot_fd_thresh: %u\n", cp, seip->tot_fd_thresh); |
| if ((SG_SEIM_CTL_FLAGS & seip->sei_rd_mask) || |
| (SG_SEIM_CTL_FLAGS & seip->sei_wr_mask)) { |
| cflags = seip->ctl_flags; |
| if (SG_CTL_FLAGM_TIME_IN_NS & seip->ctl_flags_rd_mask) |
| printf(" %sTIME_IN_NS: %s\n", cp, |
| (SG_CTL_FLAGM_TIME_IN_NS & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_OTHER_OPENS & seip->ctl_flags_rd_mask) |
| printf(" %sOTHER_OPENS: %s\n", cp, |
| (SG_CTL_FLAGM_OTHER_OPENS & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_ORPHANS & seip->ctl_flags_rd_mask) |
| printf(" %sORPHANS: %s\n", cp, |
| (SG_CTL_FLAGM_ORPHANS & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_Q_TAIL & seip->ctl_flags_rd_mask) |
| printf(" %sQ_TAIL: %s\n", cp, |
| (SG_CTL_FLAGM_Q_TAIL & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_IS_SHARE & seip->ctl_flags_rd_mask) |
| printf(" %sIS_SHARE: %s\n", cp, |
| (SG_CTL_FLAGM_IS_SHARE & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_IS_READ_SIDE & seip->ctl_flags_rd_mask) |
| printf(" %sIS_READ_SIDE: %s\n", cp, |
| (SG_CTL_FLAGM_IS_READ_SIDE & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_UNSHARE & seip->ctl_flags_rd_mask) |
| printf(" %sUNSHARE: %s\n", cp, |
| (SG_CTL_FLAGM_UNSHARE & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_READ_SIDE_FINI & seip->ctl_flags_rd_mask) |
| printf(" %sREAD_SIDE_FINI: %s\n", cp, |
| (SG_CTL_FLAGM_READ_SIDE_FINI & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_READ_SIDE_ERR & seip->ctl_flags_rd_mask) |
| printf(" %sREAD_SIDE_ERR: %s\n", cp, |
| (SG_CTL_FLAGM_READ_SIDE_ERR & cflags) ? "true" : "false"); |
| if (SG_CTL_FLAGM_NO_DURATION & seip->ctl_flags_rd_mask) |
| printf(" %sNO_DURATION: %s\n", cp, |
| (SG_CTL_FLAGM_NO_DURATION & cflags) ? "true" : "false"); |
| } |
| if (SG_SEIM_MINOR_INDEX & seip->sei_rd_mask) |
| printf(" %sminor_index: %u\n", cp, seip->minor_index); |
| printf("\n"); |
| #endif |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_INT_MASK; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_INT_MASK]= %u\n", cp, seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_BOOL_MASK; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_BOOL_MASK]= %u\n", cp, seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_VERS_NUM; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_VERS_NUM]= %u\n", cp, seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_INACT_RQS; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_INACT_RQS]= %u\n", cp, seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_DEV_INACT_RQS; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_DEV_INACT_RQS]= %u\n", cp, |
| seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_SUBMITTED; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_SUBMITTED]= %u\n", cp, seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_READ_VAL; |
| seip->sei_rd_mask |= SG_SEIM_READ_VAL; |
| seip->read_value = SG_SEIRV_DEV_SUBMITTED; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("ioctl(SG_SET_GET_EXTENDED) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| return 1; |
| } |
| printf(" %sread_value[SG_SEIRV_DEV_SUBMITTED]= %u\n", cp, |
| seip->read_value); |
| |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_SHARE_FD; |
| seip->sei_rd_mask |= SG_SEIM_SHARE_FD; |
| #if 1 |
| seip->share_fd = sg_fd2; |
| #else |
| seip->share_fd = sg_fd; |
| #endif |
| if (do_fork && is_parent) |
| goto bypass_share; |
| if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { |
| pr2serr("%sioctl(SG_SET_GET_EXTENDED) shared_fd=%d, failed errno=%d " |
| "%s\n", cp, sg_fd2, errno, strerror(errno)); |
| } |
| printf(" %sshare successful, read back previous shared_fd= %d\n", cp, |
| (int)seip->share_fd); |
| bypass_share: |
| |
| if (ioctl(sg_fd, SG_GET_TRANSFORM, NULL) < 0) |
| pr2serr("ioctl(SG_GET_TRANSFORM) fail expected, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("%sSG_GET_TRANSFORM okay (does nothing)\n", cp); |
| if (ioctl(sg_fd, SG_SET_TRANSFORM, NULL) < 0) |
| pr2serr("ioctl(SG_SET_TRANSFORM) fail expected, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("%sSG_SET_TRANSFORM okay (does nothing)\n", cp); |
| printf("\n"); |
| |
| /* test sending a sg file descriptor between 2 processes using UNIX |
| * sockets */ |
| if (do_fork && is_parent && fnp && (sock >= 0)) { /* master/READ side */ |
| int res; |
| int fd_ma = open(fnp, O_RDWR); |
| |
| if (fd_ma < 0) { |
| pr2serr("%s: opening %s failed: %s\n", __func__, fnp, |
| strerror(errno)); |
| return 1; |
| } |
| res = sock_fd_write(sock, "boo", 4, fd_ma); |
| if (res < 0) |
| pr2serr("%s: sock_fd_write() failed\n", __func__); |
| else |
| printf("%s: sock_fd_write() returned: %d\n", __func__, res); |
| } else if (do_fork && !is_parent && fn2p && (sock >= 0)) { |
| int res, fd_ma; |
| /* int fd_sl = open(fn2p, O_RDWR); not needed */ |
| uint8_t b[32]; |
| |
| fd_ma = -1; |
| res = sock_fd_read(sock, b, sizeof(b), &fd_ma); |
| if (res < 0) |
| pr2serr("%s: sock_fd_read() failed\n", __func__); |
| else |
| printf("%s: sock_fd_read() returned: %d, fd_ma=%d\n", __func__, |
| res, fd_ma); |
| /* yes it works! */ |
| } |
| return 0; |
| } |
| |
| static int |
| do_mrqs(int sg_fd, int sg_fd2, int mrqs) |
| { |
| bool both = (sg_fd2 >= 0); |
| int k, j, arr_v4_sz, good; |
| int res = 0; |
| struct sg_io_v4 * arr_v4; |
| struct sg_io_v4 * h4p; |
| struct sg_io_v4 * mrq_h4p; |
| struct sg_io_v4 mrq_h4; |
| uint8_t sense_buffer[SENSE_BUFFER_LEN] SG_C_CPP_ZERO_INIT; |
| uint8_t inq_cdb[INQ_CMD_LEN] = /* Device Id VPD page */ |
| {0x12, 0x1, 0x83, 0, INQ_REPLY_LEN, 0}; |
| uint8_t sdiag_cdb[SDIAG_CMD_LEN] = |
| {0x1d, 0x10 /* PF */, 0, 0, 0, 0}; |
| uint8_t inqBuff[INQ_REPLY_LEN]; |
| |
| if (both) { |
| struct sg_extended_info sei; |
| struct sg_extended_info * seip; |
| |
| seip = &sei; |
| memset(seip, 0, sizeof(*seip)); |
| seip->sei_wr_mask |= SG_SEIM_SHARE_FD; |
| seip->sei_rd_mask |= SG_SEIM_SHARE_FD; |
| seip->share_fd = sg_fd; /* master */ |
| if (ioctl(sg_fd2, SG_SET_GET_EXTENDED, seip) < 0) { |
| res = errno; |
| pr2serr("ioctl(sg_fd2, SG_SET_GET_EXTENDED) shared_fd, " |
| "failed errno=%d %s\n", res, strerror(res)); |
| return res; |
| } |
| } |
| memset(inqBuff, 0, sizeof(inqBuff)); |
| mrq_h4p = &mrq_h4; |
| memset(mrq_h4p, 0, sizeof(*mrq_h4p)); |
| mrq_h4p->guard = 'Q'; |
| mrq_h4p->flags = SGV4_FLAG_MULTIPLE_REQS; |
| if (mrq_immed) |
| mrq_h4p->flags |= SGV4_FLAG_IMMED; |
| arr_v4 = (struct sg_io_v4 *)calloc(mrqs, sizeof(struct sg_io_v4)); |
| if (NULL == arr_v4) { |
| res = ENOMEM; |
| goto fini; |
| } |
| arr_v4_sz = mrqs * sizeof(struct sg_io_v4); |
| |
| for (k = 0; k < mrqs; ++k) { |
| h4p = arr_v4 + k; |
| |
| h4p->guard = 'Q'; |
| /* ->protocol and ->subprotocol are already zero */ |
| /* io_hdr[k].iovec_count = 0; */ /* memset takes care of this */ |
| if (0 == (k % 2)) { |
| h4p->request_len = sizeof(sdiag_cdb); |
| h4p->request = (uint64_t)(uintptr_t)sdiag_cdb; |
| /* all din and dout fields are zero */ |
| } else { |
| h4p->request_len = sizeof(inq_cdb); |
| h4p->request = (uint64_t)(uintptr_t)inq_cdb; |
| h4p->din_xfer_len = INQ_REPLY_LEN; |
| h4p->din_xferp = (uint64_t)(uintptr_t)inqBuff; |
| if (both) |
| h4p->flags |= SGV4_FLAG_DO_ON_OTHER; |
| } |
| h4p->response = (uint64_t)(uintptr_t)sense_buffer; |
| h4p->max_response_len = sizeof(sense_buffer); |
| h4p->timeout = 20000; /* 20000 millisecs == 20 seconds */ |
| h4p->request_extra = k + 3; /* so pack_id doesn't start at 0 */ |
| /* default is to queue at head (in SCSI mid level) */ |
| if (q_at_tail) |
| h4p->flags |= SG_FLAG_Q_AT_TAIL; |
| else |
| h4p->flags |= SG_FLAG_Q_AT_HEAD; |
| } |
| mrq_h4p->dout_xferp = (uint64_t)(uintptr_t)arr_v4; |
| mrq_h4p->dout_xfer_len = arr_v4_sz; |
| mrq_h4p->din_xferp = mrq_h4p->dout_xferp; |
| mrq_h4p->din_xfer_len = mrq_h4p->dout_xfer_len; |
| if (ioctl(sg_fd, (mrq_iosubmit ? SG_IOSUBMIT : SG_IO), mrq_h4p) < 0) { |
| res = errno; |
| pr2serr("ioctl(SG_IO%s, mrq) failed, errno=%d %s\n", |
| (mrq_iosubmit ? "SUBMIT" : ""), res, strerror(res)); |
| goto fini; |
| } |
| if ((mrq_h4p->dout_resid > 0) || ((int)mrq_h4p->info < mrqs)) |
| pr2serr("ioctl(SG_IO%s, mrq) dout_resid=%d, info=%d\n\n", |
| (mrq_iosubmit ? "SUBMIT" : ""), mrq_h4p->dout_resid, |
| mrq_h4p->info); |
| |
| good = 0; |
| j = 0; |
| if (mrq_immed) { |
| receive_more: |
| if (mrq_half_immed) |
| mrq_h4p->flags = SGV4_FLAG_MULTIPLE_REQS; // zap SGV4_FLAG_IMMED |
| if (ioctl(sg_fd, SG_IORECEIVE, mrq_h4p) < 0) { |
| res = errno; |
| pr2serr("ioctl(SG_IORECEIVE, mrq) failed, errno=%d %s\n", |
| res, strerror(res)); |
| goto fini; |
| } |
| if ((mrq_h4p->din_resid > 0) || ((int)mrq_h4p->info < mrqs)) |
| pr2serr("ioctl(SG_IORECEIVE, mrq) din_resid=%d, info=%d\n", |
| mrq_h4p->din_resid, mrq_h4p->info); |
| } |
| |
| for (k = 0; k < (int)mrq_h4p->info; ++k, ++j) { |
| h4p = arr_v4 + k; |
| if (! (h4p->driver_status || h4p->transport_status || |
| h4p->device_status)) { |
| if (h4p->info & SG_INFO_MRQ_FINI) |
| ++good; |
| } |
| if ((! (h4p->info & SG_INFO_MRQ_FINI)) && (verbose > 1)) |
| pr2serr("%s: k=%d: SG_INFO_MRQ_FINI not set on response\n", |
| __func__, k); |
| } |
| if (mrq_immed && (j < mrqs)) |
| goto receive_more; |
| |
| if (good > 0) { |
| printf("Final INQUIRY response:\n"); |
| hex2stdout(inqBuff, INQ_REPLY_LEN, 0); |
| } |
| printf("Good responses: %d, bad responses: %d\n", good, mrqs - good); |
| if (mrq_h4p->driver_status != 0) |
| printf("Master mrq object: driver_status=%d\n", |
| mrq_h4p->driver_status); |
| h4p = arr_v4 + mrqs - 1; |
| if (h4p->driver_status != 0) |
| printf("Last mrq object: driver_status=%d\n", h4p->driver_status); |
| |
| fini: |
| if (arr_v4) |
| free(arr_v4); |
| return res; |
| } |
| |
| |
| int |
| main(int argc, char * argv[]) |
| { |
| bool done, is_first; |
| bool nw_given = false; |
| bool has_dname_range = false; |
| int k, ok, pack_id, num_waiting; |
| int res = 0; |
| int sum_nw = 0; |
| int sg_fd = -1; |
| int sg_fd2 = -1; |
| int sock = -1; |
| uint8_t inq_cdb[INQ_CMD_LEN] = |
| {0x12, 0, 0, 0, INQ_REPLY_LEN, 0}; |
| uint8_t sdiag_cdb[SDIAG_CMD_LEN] = |
| {0x1d, 0x10 /* PF */, 0, 0, 0, 0}; |
| uint8_t inqBuff[MAX_Q_LEN][INQ_REPLY_LEN]; |
| sg_io_hdr_t io_hdr[MAX_Q_LEN]; |
| sg_io_hdr_t rio_hdr; |
| char ebuff[EBUFF_SZ]; |
| char dname[256]; |
| uint8_t sense_buffer[MAX_Q_LEN][SENSE_BUFFER_LEN] SG_C_CPP_ZERO_INIT; |
| const char * second_fname = NULL; |
| const char * cp; |
| char * chp; |
| struct sg_scsi_id ssi; |
| |
| |
| if (sizeof(struct sg_extended_info) != 96) |
| pr2serr("Warning <<<< sizeof(struct sg_extended_info)=%zu not 96\n", |
| sizeof(struct sg_extended_info)); |
| for (k = 1; k < argc; ++k) { |
| if (0 == memcmp("-3", argv[k], 2)) |
| do_v3_only = true; |
| else if (0 == memcmp("-c", argv[k], 2)) |
| create_time = true; |
| else if (0 == memcmp("-f", argv[k], 2)) |
| do_fork = true; |
| else if (0 == memcmp("-h", argv[k], 2)) { |
| file_name = 0; |
| break; |
| } else if (0 == memcmp("-I=", argv[k], 3)) { |
| iterator_test = atoi(argv[k] + 3); |
| if ((iterator_test > 1) || (iterator_test < -1)) { |
| printf("Expect -I= to take a number, either 0 or 1\n"); |
| file_name = 0; |
| break; |
| } |
| } else if (0 == memcmp("-J=", argv[k], 3)) { |
| object_walk_test = atoi(argv[k] + 3); |
| if ((object_walk_test > 1) || (object_walk_test < -1)) { |
| printf("Expect -J= to take a number, either 0 or 1\n"); |
| file_name = 0; |
| break; |
| } |
| } else if (0 == memcmp("-l=", argv[k], 3)) { |
| q_len = atoi(argv[k] + 3); |
| if ((q_len > 511) || (q_len < 1)) { |
| printf("Expect -l= to take a number (q length) between 1 " |
| "and 511\n"); |
| file_name = 0; |
| break; |
| } |
| } else if (0 == memcmp("-m=", argv[k], 3)) { |
| num_mrqs = sg_get_num(argv[k] + 3); |
| if (num_mrqs < 1) { |
| printf("Expect -m= to take a number greater than 0\n"); |
| file_name = 0; |
| break; |
| } |
| if ((cp = strchr(argv[k] + 3, ','))) { |
| mrq_iosubmit = true; |
| if (cp[1] == 'I') |
| mrq_immed = true; |
| else if (cp[1] == 'i') { |
| mrq_immed = true; |
| mrq_half_immed = true; |
| } else if (toupper(cp[1]) == 'S') |
| ; |
| else { |
| printf("-m= option expects 'A' or 'a' as a suffix, " |
| "after comma\n"); |
| file_name = 0; |
| break; |
| } |
| } |
| } else if (0 == memcmp("-M", argv[k], 2)) |
| more_async = true; |
| else if (0 == memcmp("-n", argv[k], 2)) |
| no_duration = true; |
| else if (0 == memcmp("-o", argv[k], 2)) |
| ioctl_only = true; |
| else if (0 == memcmp("-r=", argv[k], 3)) { |
| reserve_buff_sz = atoi(argv[k] + 3); |
| if (reserve_buff_sz < 0) { |
| printf("Expect -r= to take a number 0 or higher\n"); |
| file_name = 0; |
| break; |
| } |
| } else if (0 == memcmp("-s=", argv[k], 3)) { |
| sleep_secs = atoi(argv[k] + 3); |
| if (sleep_secs < 0) { |
| printf("Expect -s= to take a number 0 or higher\n"); |
| file_name = 0; |
| break; |
| } |
| } else if (0 == memcmp("-S", argv[k], 2)) |
| show_size_value = true; |
| else if (0 == memcmp("-t", argv[k], 2)) |
| q_at_tail = true; |
| else if (0 == memcmp("-T=", argv[k], 3)) { |
| num_sgnw = sg_get_num(argv[k] + 3); |
| if (num_sgnw < 0) { |
| printf("Expect -T= to take a number >= 0\n"); |
| file_name = 0; |
| break; |
| } |
| nw_given = true; |
| } else if (0 == memcmp("-vvvvvvv", argv[k], 8)) |
| verbose += 7; |
| else if (0 == memcmp("-vvvvvv", argv[k], 7)) |
| verbose += 6; |
| else if (0 == memcmp("-vvvvv", argv[k], 6)) |
| verbose += 5; |
| else if (0 == memcmp("-vvvv", argv[k], 5)) |
| verbose += 4; |
| else if (0 == memcmp("-vvv", argv[k], 4)) |
| verbose += 3; |
| else if (0 == memcmp("-vv", argv[k], 3)) |
| verbose += 2; |
| else if (0 == memcmp("-v", argv[k], 2)) |
| verbose += 1; |
| else if (0 == memcmp("-V", argv[k], 2)) { |
| printf("%s\n", version_str); |
| return 0; |
| } else if (0 == memcmp("-w", argv[k], 2)) |
| write_only = true; |
| else if (*argv[k] == '-') { |
| printf("Unrecognized switch: %s\n", argv[k]); |
| file_name = 0; |
| break; |
| } |
| else if (0 == file_name) |
| file_name = argv[k]; |
| else if (NULL == second_fname) |
| second_fname = argv[k]; |
| else { |
| printf("too many arguments\n"); |
| file_name = 0; |
| break; |
| } |
| } |
| if ((iterator_test >= 0) || (object_walk_test >= 0)) |
| nw_given = false; |
| |
| if (show_size_value) { |
| struct utsname unam; |
| |
| printf("Size in bytes:\n"); |
| printf("\t%zu\tsizeof(struct sg_header) Version 2 interface " |
| "structure\n", sizeof(struct sg_header)); |
| printf("\t%zu\tsizeof(struct sg_io_hdr) Version 3 interface " |
| "structure\n", sizeof(struct sg_io_hdr)); |
| printf("\t%zu\tsizeof(struct sg_io_v4) Version 4 interface " |
| "structure\n", sizeof(struct sg_io_v4)); |
| printf("\t%zu\tsizeof(struct sg_iovec) scatter gather element\n", |
| sizeof(struct sg_iovec)); |
| printf("\t%zu\tsizeof(struct sg_scsi_id) topological device id\n", |
| sizeof(struct sg_scsi_id)); |
| printf("\t%zu\tsizeof(struct sg_req_info) request information\n", |
| sizeof(struct sg_req_info)); |
| printf("\t%zu\tsizeof(struct sg_extended_info) for " |
| "SG_SET_GET_EXTENDED\n", |
| sizeof(struct sg_extended_info)); |
| printf("\nioctl values (i.e. second argument to ioctl()):\n"); |
| printf("\t0x%lx\t\tvalue of SG_GET_NUM_WAITING ioctl\n", |
| (unsigned long)SG_GET_NUM_WAITING); |
| printf("\t0x%lx\t\tvalue of SG_IO ioctl\n", |
| (unsigned long)SG_IO); |
| printf("\t0x%lx\tvalue of SG_IOABORT ioctl\n", |
| (unsigned long)SG_IOABORT); |
| printf("\t0x%lx\tvalue of SG_IORECEIVE ioctl\n", |
| (unsigned long)SG_IORECEIVE); |
| printf("\t0x%lx\tvalue of SG_IORECEIVE_V3 ioctl\n", |
| (unsigned long)SG_IORECEIVE_V3); |
| printf("\t0x%lx\tvalue of SG_IOSUBMIT ioctl\n", |
| (unsigned long)SG_IOSUBMIT); |
| printf("\t0x%lx\tvalue of SG_IOSUBMIT_V3 ioctl\n", |
| (unsigned long)SG_IOSUBMIT_V3); |
| printf("\t0x%lx\tvalue of SG_SET_GET_EXTENDED ioctl\n", |
| (unsigned long)SG_SET_GET_EXTENDED); |
| printf("\n\t0x%x\t\tbase value of most SG_* ioctls\n", |
| SG_IOCTL_MAGIC_NUM); |
| printf("\nsizeof(void *) [a pointer] on this machine: %u bytes\n", |
| (unsigned)sizeof(void *)); |
| if (0 == uname(&unam)) |
| printf("Machine name: %s\n", unam.machine); |
| |
| return 0; |
| } |
| if (0 == file_name) { |
| printf("No filename (sg device) given\n\n"); |
| usage(); |
| return 1; |
| } |
| memset(dname, 0, sizeof(dname)); |
| if (strlen(file_name) > 255) { |
| fprintf(stderr, "file_name too long\n"); |
| goto out; |
| } |
| strncpy(dname, file_name, sizeof(dname) - 1); |
| if ((chp = strchr(dname, '-'))) { |
| if (1 != sscanf(chp + 1, "%d", &dname_last)) { |
| fprintf(stderr, "can't code number after '-' in file_name\n"); |
| goto out; |
| } |
| *chp = '\0'; |
| --chp; |
| while (isdigit(*chp)) |
| --chp; |
| ++chp; |
| if (1 != sscanf(chp, "%d", &dname_current)) { |
| fprintf(stderr, "can't code number before '-' in file_name\n"); |
| goto out; |
| } |
| *chp = '\0'; |
| has_dname_range = true; |
| dname_pos = strlen(dname); |
| } |
| is_first = true; |
| |
| dname_range_loop: |
| if (has_dname_range) |
| sprintf(dname + dname_pos, "%d", dname_current); |
| |
| /* An access mode of O_RDWR is required for write()/read() interface */ |
| if ((sg_fd = open(dname, O_RDWR)) < 0) { |
| snprintf(ebuff, EBUFF_SZ, "error opening file: %s", dname); |
| perror(ebuff); |
| return 1; |
| } |
| if (verbose) |
| fprintf(stderr, "opened given file: %s successfully, fd=%d\n", |
| dname, sg_fd); |
| |
| if (ioctl(sg_fd, SG_GET_VERSION_NUM, &sg_drv_ver_num) < 0) { |
| pr2serr("ioctl(SG_GET_VERSION_NUM) failed, errno=%d %s\n", errno, |
| strerror(errno)); |
| goto out; |
| } |
| if (is_first) |
| printf("Linux sg driver version: %d\n", sg_drv_ver_num); |
| |
| if (create_time && (sg_drv_ver_num > 40030)) { |
| pr_create_dev_time(sg_fd, dname); |
| goto out; |
| } |
| |
| if (nw_given || (iterator_test >= 0) || (object_walk_test >= 0)) { |
| /* -T=NUM and/or -I=0|1 or -j=0|1 */ |
| /* time ioctl(SG_GET_NUM_WAITING) or do iterator_test */ |
| int nw; |
| struct timespec start_tm, fin_tm, res_tm; |
| |
| if (is_first) { |
| int rang = has_dname_range ? (1 + dname_last - dname_current) : 1; |
| |
| is_first = false; |
| if (nw_given) |
| printf("Timing %d x %d calls to ioctl(SG_GET_NUM_WAITING)\n", |
| rang, num_sgnw); |
| else if (iterator_test >= 0) { |
| k = num_sgnw + 1000; |
| printf("Timing %d calls to ioctl(SG_SET_DEBUG, %d)\n", |
| rang, ((0 == iterator_test) ? -k : k)); |
| } else |
| printf("Timing %d calls to ioctl(SG_SET_DEBUG, %d)\n", |
| rang, (object_walk_test == 0) ? 999 : -999); |
| if (0 != clock_gettime(CLOCK_MONOTONIC, &start_tm)) { |
| res = errno; |
| perror("start clock_gettime() failed:"); |
| goto out; |
| } |
| } |
| if (nw_given) { |
| for (k = 0; k < num_sgnw; ++k, sum_nw += nw) { |
| if (ioctl(sg_fd, SG_GET_NUM_WAITING, &nw) < 0) { |
| res = errno; |
| fprintf(stderr, "%d: ioctl(SG_GET_NUM_WAITING) failed " |
| "errno=%d\n", k, res); |
| goto out; |
| } |
| } |
| } else if (iterator_test >= 0) { |
| int fd, pid; |
| |
| k = num_sgnw + 1000; |
| if (0 == iterator_test) |
| k = -k; |
| if (second_fname) { |
| if ((sg_fd2 = open(second_fname, O_RDWR)) < 0) { |
| snprintf(ebuff, EBUFF_SZ, "%s: error opening file: %s", |
| __func__, second_fname); |
| perror(ebuff); |
| return 1; |
| } |
| printf("About to fork due to second filename\n"); |
| pid = fork(); |
| if (pid < 0) { |
| perror("fork() failed"); |
| goto out; |
| } else if (0 == pid) { |
| relative_cp = "child: "; |
| is_parent = false; |
| fd = sg_fd2; |
| } else { |
| relative_cp = "parent: "; |
| is_parent = true; |
| childs_pid = pid; |
| fd = sg_fd; |
| } |
| } else { |
| fd = sg_fd; |
| relative_cp = ""; |
| } |
| if (ioctl(fd, SG_SET_DEBUG, &k) < 0) { |
| res = errno; |
| fprintf(stderr, "%s%d: ioctl(SG_SET_DEBUG) failed errno=%d\n", |
| relative_cp, k, res); |
| goto out; |
| } else if (verbose) |
| fprintf(stderr, "%siterator_test good ioctl(SG_SET_DEBUG, " |
| "%d)\n", relative_cp, k); |
| sum_nw += num_sgnw; |
| } else if (object_walk_test >= 0) { |
| const char * ccp = "object_walk_test"; |
| |
| relative_cp = ""; |
| k = (object_walk_test == 0) ? 999 : -999; |
| if (ioctl(sg_fd, SG_SET_DEBUG, &k) < 0) { |
| res = errno; |
| fprintf(stderr, "%s: ioctl(SG_SET_DEBUG, %d) failed " |
| "errno=%d\n", ccp, k, res); |
| } else if (verbose) |
| fprintf(stderr, "%s: good call to ioctl(SG_SET_DEBUG, %d)\n", |
| ccp, k); |
| sum_nw += 10000; /* (1_up-scan + 2_lookups) * 10,000 times */ |
| } |
| |
| if (has_dname_range) { |
| ++dname_current; |
| if (dname_current <= dname_last) { |
| if (sg_fd >= 0) |
| close(sg_fd); |
| goto dname_range_loop; |
| } |
| } |
| if (0 != clock_gettime(CLOCK_MONOTONIC, &fin_tm)) { |
| res = errno; |
| perror("finish clock_gettime() failed:"); |
| goto out; |
| } |
| res_tm.tv_sec = fin_tm.tv_sec - start_tm.tv_sec; |
| res_tm.tv_nsec = fin_tm.tv_nsec - start_tm.tv_nsec; |
| if (res_tm.tv_nsec < 0) { |
| --res_tm.tv_sec; |
| res_tm.tv_nsec += 1000000000; |
| } |
| if (verbose) { |
| if (nw_given && (verbose > 1)) |
| printf("sum of num_waiting_s=%d\n", sum_nw); |
| printf("%selapsed time (nanosecond precision): %d.%09d secs\n", |
| relative_cp, (int)res_tm.tv_sec, (int)res_tm.tv_nsec); |
| } else |
| printf("%selapsed time: %d.%06d secs\n", relative_cp, |
| (int)res_tm.tv_sec, (int)(res_tm.tv_nsec / 1000)); |
| if (num_sgnw >= 100) { |
| double m = (double)res_tm.tv_sec + |
| ((double)res_tm.tv_nsec / 1000000000.0); |
| double num = num_sgnw; |
| |
| if (m > 0.000001) |
| printf("%sCalls per second: %.2f\n", relative_cp, num / m); |
| } |
| res = 0; |
| goto out; |
| } |
| if ((more_async || no_duration) && !do_v3_only) |
| set_more_async(sg_fd, more_async, no_duration); |
| |
| if (second_fname) { |
| if ((sg_fd2 = open(second_fname, O_RDWR)) < 0) { |
| snprintf(ebuff, EBUFF_SZ, |
| "%s: error opening file: %s", __func__, second_fname); |
| perror(ebuff); |
| return 1; |
| } |
| if (verbose) |
| fprintf(stderr, "opened second file: %s successfully, fd=%d\n", |
| second_fname, sg_fd2); |
| if (more_async && !do_v3_only) |
| set_more_async(sg_fd2, more_async, no_duration); |
| } |
| |
| if ((num_mrqs > 0) && !do_v3_only) { |
| res = do_mrqs(sg_fd, sg_fd2, num_mrqs); |
| goto out; |
| } |
| |
| if (do_fork) { |
| int pid; |
| int sv[2]; |
| |
| if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sv) < 0) { |
| perror("socketpair"); |
| exit(1); |
| } |
| printf("socketpair: sv[0]=%d, sv[1]=%d sg_fd=%d\n", sv[0], sv[1], |
| sg_fd); |
| pid = fork(); |
| if (pid < 0) { |
| perror("fork() failed"); |
| goto out; |
| } else if (0 == pid) { |
| relative_cp = "child "; |
| is_parent = false; |
| close(sv[0]); |
| sock = sv[1]; |
| } else { |
| relative_cp = "parent "; |
| is_parent = true; |
| childs_pid = pid; |
| close(sv[1]); |
| sock = sv[0]; |
| } |
| } |
| |
| cp = do_fork ? relative_cp : ""; |
| if (! do_v3_only && (sg_drv_ver_num > 40030)) { |
| if (tst_extended_ioctl(dname, sg_fd, second_fname, sg_fd2, sock, |
| cp)) |
| goto out; |
| } |
| if (ioctl_only) |
| goto out; |
| |
| if (do_fork && !is_parent) |
| return 0; |
| |
| printf("start write() calls [submits]\n"); |
| for (k = 0; k < q_len; ++k) { |
| /* Prepare INQUIRY command */ |
| memset(&io_hdr[k], 0, sizeof(sg_io_hdr_t)); |
| io_hdr[k].interface_id = 'S'; |
| /* io_hdr[k].iovec_count = 0; */ /* memset takes care of this */ |
| io_hdr[k].mx_sb_len = (uint8_t)sizeof(sense_buffer); |
| if (0 == (k % 3)) { |
| io_hdr[k].cmd_len = sizeof(sdiag_cdb); |
| io_hdr[k].cmdp = sdiag_cdb; |
| io_hdr[k].dxfer_direction = SG_DXFER_NONE; |
| } else { |
| io_hdr[k].cmd_len = sizeof(inq_cdb); |
| io_hdr[k].cmdp = inq_cdb; |
| io_hdr[k].dxfer_direction = SG_DXFER_FROM_DEV; |
| io_hdr[k].dxfer_len = INQ_REPLY_LEN; |
| io_hdr[k].dxferp = inqBuff[k]; |
| } |
| io_hdr[k].sbp = sense_buffer[k]; |
| io_hdr[k].mx_sb_len = SENSE_BUFFER_LEN; |
| io_hdr[k].timeout = 20000; /* 20000 millisecs == 20 seconds */ |
| io_hdr[k].pack_id = k + 3; /* so pack_id doesn't start at 0 */ |
| /* default is to queue at head (in SCSI mid level) */ |
| if (q_at_tail) |
| io_hdr[k].flags |= SG_FLAG_Q_AT_TAIL; |
| else |
| io_hdr[k].flags |= SG_FLAG_Q_AT_HEAD; |
| /* io_hdr[k].usr_ptr = NULL; */ |
| |
| if (write(sg_fd, &io_hdr[k], sizeof(sg_io_hdr_t)) < 0) { |
| pr2serr("%ssg write errno=%d [%s]\n", cp, errno, strerror(errno)); |
| close(sg_fd); |
| return 1; |
| } |
| } |
| |
| memset(&ssi, 0, sizeof(ssi)); |
| if (ioctl(sg_fd, SG_GET_SCSI_ID, &ssi) < 0) |
| pr2serr("ioctl(SG_GET_SCSI_ID) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else { |
| printf("host_no: %d\n", ssi.host_no); |
| printf(" channel: %d\n", ssi.channel); |
| printf(" scsi_id: %d\n", ssi.scsi_id); |
| printf(" lun: %d\n", ssi.lun); |
| printf(" pdt: %d\n", ssi.scsi_type); |
| printf(" h_cmd_per_lun: %d\n", ssi.h_cmd_per_lun); |
| printf(" d_queue_depth: %d\n", ssi.d_queue_depth); |
| printf(" SCSI 8 byte LUN: "); |
| hex2stdout(ssi.scsi_lun, 8, -1); |
| } |
| if (ioctl(sg_fd, SG_GET_PACK_ID, &pack_id) < 0) |
| pr2serr("ioctl(SG_GET_PACK_ID) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("first available pack_id: %d\n", pack_id); |
| if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) |
| pr2serr("ioctl(SG_GET_NUM_WAITING) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("num_waiting: %d\n", num_waiting); |
| |
| sleep(sleep_secs); |
| |
| if (write_only) |
| goto out; |
| |
| if (do_fork) |
| printf("\n\nFollowing starting with get_pack_id are all CHILD\n"); |
| if (ioctl(sg_fd, SG_GET_PACK_ID, &pack_id) < 0) |
| pr2serr("ioctl(SG_GET_PACK_ID) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("first available pack_id: %d\n", pack_id); |
| if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) |
| pr2serr("ioctl(SG_GET_NUM_WAITING) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("num_waiting: %d\n", num_waiting); |
| |
| printf("\nstart read() calls [io receive]\n"); |
| for (k = 0, done = false; k < q_len; ++k) { |
| if ((! done) && (k == q_len / 2)) { |
| done = true; |
| printf("\n>>> half way through read\n"); |
| if (ioctl(sg_fd, SG_GET_PACK_ID, &pack_id) < 0) |
| pr2serr("ioctl(SG_GET_PACK_ID) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("first available pack_id: %d\n", pack_id); |
| if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) |
| pr2serr("ioctl(SG_GET_NUM_WAITING) failed, errno=%d %s\n", |
| errno, strerror(errno)); |
| else |
| printf("num_waiting: %d\n", num_waiting); |
| } |
| memset(&rio_hdr, 0, sizeof(sg_io_hdr_t)); |
| rio_hdr.interface_id = 'S'; |
| if (read(sg_fd, &rio_hdr, sizeof(sg_io_hdr_t)) < 0) { |
| perror("sg read error"); |
| close(sg_fd); |
| return 1; |
| } |
| /* now for the error processing */ |
| ok = 0; |
| switch (sg_err_category3(&rio_hdr)) { |
| case SG_LIB_CAT_CLEAN: |
| ok = 1; |
| break; |
| case SG_LIB_CAT_RECOVERED: |
| printf("Recovered error, continuing\n"); |
| ok = 1; |
| break; |
| default: /* won't bother decoding other categories */ |
| sg_chk_n_print3("command error", &rio_hdr, 1); |
| break; |
| } |
| |
| if (ok) { /* output result if it is available */ |
| if (0 == (rio_hdr.pack_id % 3)) |
| printf("SEND DIAGNOSTIC %d duration=%u\n", rio_hdr.pack_id, |
| rio_hdr.duration); |
| else |
| printf("INQUIRY %d duration=%u\n", rio_hdr.pack_id, |
| rio_hdr.duration); |
| } |
| } |
| |
| out: |
| if (sg_fd >= 0) |
| close(sg_fd); |
| if (sg_fd2 >= 0) |
| close(sg_fd2); |
| return res; |
| } |
