/** * zbc_list_zones - report zones for a ZBC device * @dev: (IN) ZBC device handle to report on * @start_lba: (IN) start LBA for the first zone to reported * @ro: (IN) Reporting options * @zones: (OUT) pointer for reported zones * @nr_zones: (OUT) number of returned zones * * Reports the number and details of available zones. The @zones * parameter is used to return an array of zones which is allocated using * malloc(3) internally and needs to be freed using free(3). The number * of zones in @zones is returned in @nr_zones. * * Returns -EIO if an error happened when communicating to the device. * Returns -ENOMEM if memory could not be allocated for @zones. */ int zbc_list_zones(struct zbc_device *dev, uint64_t start_lba, enum zbc_reporting_options ro, struct zbc_zone **pzones, unsigned int *pnr_zones) { zbc_zone_t *zones = NULL; unsigned int nr_zones; int ret; /* Get total number of zones */ ret = zbc_report_nr_zones(dev, start_lba, ro, &nr_zones); if ( ret < 0 ) { return( ret ); } zbc_debug("Device %s: %d zones\n", dev->zbd_filename, nr_zones); /* Allocate zone array */ zones = (zbc_zone_t *) malloc(sizeof(zbc_zone_t) * nr_zones); if ( ! zones ) { zbc_error("No memory\n"); return( -ENOMEM ); } memset(zones, 0, sizeof(zbc_zone_t) * nr_zones); /* Get zones info */ ret = zbc_report_zones(dev, start_lba, ro, zones, &nr_zones); if ( ret != 0 ) { zbc_error("zbc_report_zones failed\n"); free(zones); } else { *pzones = zones; *pnr_zones = nr_zones; } return( ret ); }
int dz_get_zones(dz_dev_t *dzd) { int ret; if ( ! dzd->zones ) { /* Get zone list */ dzd->zone_ro = ZBC_RO_ALL; ret = zbc_list_zones(dzd->dev, 0, dzd->zone_ro, &dzd->zones, &dzd->nr_zones); if ( ret == 0 ) { dzd->max_nr_zones = dzd->nr_zones; } } else { /* Refresh zone list */ dzd->nr_zones = dzd->max_nr_zones; ret = zbc_report_zones(dzd->dev, 0, dzd->zone_ro, dzd->zones, &dzd->nr_zones); if ( ret != 0 ) { fprintf(stderr, "Get zone information failed %d (%s)\n", errno, strerror(errno)); if ( dzd->zones ) { free(dzd->zones); dzd->zones = NULL; dzd->nr_zones = 0; dzd->max_nr_zones = 0; } } } return( ret ); }
int main(int argc, char **argv) { struct zbc_device_info info; unsigned long long lba = 0; struct zbc_device *dev; enum zbc_reporting_options ro = ZBC_RO_ALL; int i, ret = 1; zbc_zone_t *z, *zones = NULL; unsigned int nr_zones, nz = 0; int num = 0; char *path; /* Check command line */ if ( argc < 2 ) { usage: printf("Usage: %s [options] <dev>\n" "Options:\n" " -v : Verbose mode\n" " -n : Get only the number of zones\n" " -nz <num> : Get at most <num> zones\n" " -lba <lba> : Specify zone start LBA (default is 0)\n" " -ro <opt> : Specify reporting option: \"all\", \"empty\",\n" " \"imp_open\", \"exp_open\", \"closed\", \"full\",\n" " \"rdonly\", \"offline\", \"reset\", \"non_seq\" or \"not_wp\".\n" " Default is \"all\"\n", argv[0]); return( 1 ); } /* Parse options */ for(i = 1; i < (argc - 1); i++) { if ( strcmp(argv[i], "-v") == 0 ) { zbc_set_log_level("debug"); } else if ( strcmp(argv[i], "-n") == 0 ) { num = 1; } else if ( strcmp(argv[i], "-nz") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; nz = strtol(argv[i], NULL, 10); if ( nz <= 0 ) { goto usage; } } else if ( strcmp(argv[i], "-lba") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; lba = strtoll(argv[i], NULL, 10); } else if ( strcmp(argv[i], "-ro") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; if ( strcmp(argv[i], "all") == 0 ) { ro = ZBC_RO_ALL; } else if ( strcmp(argv[i], "empty") == 0 ) { ro = ZBC_RO_EMPTY; } else if ( strcmp(argv[i], "imp_open") == 0 ) { ro = ZBC_RO_IMP_OPEN; } else if ( strcmp(argv[i], "exp_open") == 0 ) { ro = ZBC_RO_EXP_OPEN; } else if ( strcmp(argv[i], "closed") == 0 ) { ro = ZBC_RO_CLOSED; } else if ( strcmp(argv[i], "full") == 0 ) { ro = ZBC_RO_FULL; } else if ( strcmp(argv[i], "rdonly") == 0 ) { ro = ZBC_RO_RDONLY; } else if ( strcmp(argv[i], "offline") == 0 ) { ro = ZBC_RO_OFFLINE; } else if ( strcmp(argv[i], "reset") == 0 ) { ro = ZBC_RO_RESET; } else if ( strcmp(argv[i], "non_seq") == 0 ) { ro = ZBC_RO_NON_SEQ; } else if ( strcmp(argv[i], "not_wp") == 0 ) { ro = ZBC_RO_NOT_WP; } else { fprintf(stderr, "Unknown zone reporting option \"%s\"\n", argv[i]); goto usage; } } else if ( argv[i][0] == '-' ) { printf("Unknown option \"%s\"\n", argv[i]); goto usage; } else { break; } } if ( i != (argc - 1) ) { goto usage; } /* Open device */ path = argv[i]; ret = zbc_open(path, O_RDONLY, &dev); if ( ret != 0 ) { return( 1 ); } ret = zbc_get_device_info(dev, &info); if ( ret < 0 ) { fprintf(stderr, "zbc_get_device_info failed\n"); goto out; } printf("Device %s: %s\n", path, info.zbd_vendor_id); printf(" %s interface, %s disk model\n", zbc_disk_type_str(info.zbd_type), zbc_disk_model_str(info.zbd_model)); printf(" %llu logical blocks of %u B\n", (unsigned long long) info.zbd_logical_blocks, (unsigned int) info.zbd_logical_block_size); printf(" %llu physical blocks of %u B\n", (unsigned long long) info.zbd_physical_blocks, (unsigned int) info.zbd_physical_block_size); printf(" %.03F GB capacity\n", (double) (info.zbd_physical_blocks * info.zbd_physical_block_size) / 1000000000); /* Get the number of zones */ ret = zbc_report_nr_zones(dev, lba, ro, &nr_zones); if ( ret != 0 ) { fprintf(stderr, "zbc_report_nr_zones at lba %llu, ro 0x%02x failed %d\n", (unsigned long long) lba, (unsigned int) ro, ret); ret = 1; goto out; } /* Print zone info */ printf(" %u zones from LBA %llu, reporting option 0x%02x\n", nr_zones, lba, ro); if ( num ) { goto out; } if ( (! nz) || (nz > nr_zones) ) { nz = nr_zones; } /* Allocate zone array */ zones = (zbc_zone_t *) malloc(sizeof(zbc_zone_t) * nz); if ( ! zones ) { fprintf(stderr, "No memory\n"); ret = 1; goto out; } memset(zones, 0, sizeof(zbc_zone_t) * nz); /* Get zone information */ ret = zbc_report_zones(dev, lba, ro, zones, &nz); if ( ret != 0 ) { fprintf(stderr, "zbc_list_zones failed %d\n", ret); ret = 1; goto out; } printf("%u / %u zones:\n", nz, nr_zones); for(i = 0; i < (int)nz; i++) { z = &zones[i]; if ( zbc_zone_conventional(z) ) { printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), LBA %llu, %llu sectors, wp N/A\n", i, zbc_zone_type(z), zbc_zone_type_str(z), zbc_zone_condition(z), zbc_zone_condition_str(z), zbc_zone_start_lba(z), zbc_zone_length(z)); } else { printf("Zone %05d: type 0x%x (%s), cond 0x%x (%s), need_reset %d, non_seq %d, LBA %llu, %llu sectors, wp %llu\n", i, zbc_zone_type(z), zbc_zone_type_str(z), zbc_zone_condition(z), zbc_zone_condition_str(z), zbc_zone_need_reset(z), zbc_zone_non_seq(z), zbc_zone_start_lba(z), zbc_zone_length(z), zbc_zone_wp_lba(z)); } } out: if ( zones ) { free(zones); } zbc_close(dev); return( ret ); }
int main(int argc, char **argv) { struct zbc_device_info info; struct zbc_device *dev = NULL; unsigned long long elapsed; unsigned long long bcount = 0; unsigned long long fsize, brate; struct stat st; int zidx; int floop = 0, fd = -1, i, ret = 1; size_t iosize, ioalign; void *iobuf = NULL; uint32_t lba_count = 0; int iocount = 0, ionum = 0; struct zbc_zone *zones = NULL; struct zbc_zone *iozone = NULL; unsigned int nr_zones; char *path, *file = NULL; long long lba_ofst = 0; int flush = 0; /* Check command line */ if ( argc < 4 ) { usage: printf("Usage: %s [options] <dev> <zone no> <I/O size>\n" " Write into a zone from the current write pointer until\n" " the zone is full or the number of I/O specified is executed\n" "Options:\n" " -v : Verbose mode\n" " -s : (sync) Run zbc_flush after writing\n" " -nio <num> : Limit the number of I/O executed to <num>\n" " -f <file> : Write the content of <file>\n" " -loop : If a file is specified, repeatedly write the\n" " file to the zone until the zone is full.\n" " -lba : lba offset, from given zone <zone no> starting lba, where to write.\n", argv[0]); return( 1 ); } /* Parse options */ for(i = 1; i < (argc - 1); i++) { if ( strcmp(argv[i], "-v") == 0 ) { zbc_set_log_level("debug"); } else if ( strcmp(argv[i], "-s") == 0 ) { flush = 1; } else if ( strcmp(argv[i], "-nio") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; ionum = atoi(argv[i]); if ( ionum <= 0 ) { fprintf(stderr, "Invalid number of I/Os\n"); return( 1 ); } } else if ( strcmp(argv[i], "-f") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; file = argv[i]; } else if ( strcmp(argv[i], "-loop") == 0 ) { floop = 1; } else if ( strcmp(argv[i], "-lba") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; lba_ofst = atoll(argv[i]); if ( lba_ofst < 0 ) { fprintf(stderr, "Invalid negative LBA offset\n"); return( 1 ); } } else if ( argv[i][0] == '-' ) { fprintf(stderr, "Unknown option \"%s\"\n", argv[i]); goto usage; } else { break; } } if ( i != (argc - 3) ) { goto usage; } /* Get parameters */ path = argv[i]; zidx = atoi(argv[i + 1]); if ( zidx < 0 ) { fprintf(stderr, "Invalid zone number %s\n", argv[i + 1]); ret = 1; goto out; } iosize = atol(argv[i + 2]); if ( ! iosize ) { fprintf(stderr, "Invalid I/O size %s\n", argv[i + 2]); ret = 1; goto out; } /* Setup signal handler */ signal(SIGQUIT, zbc_write_zone_sigcatcher); signal(SIGINT, zbc_write_zone_sigcatcher); signal(SIGTERM, zbc_write_zone_sigcatcher); /* Open device */ ret = zbc_open(path, O_WRONLY, &dev); if ( ret != 0 ) { return( 1 ); } ret = zbc_get_device_info(dev, &info); if ( ret < 0 ) { fprintf(stderr, "zbc_get_device_info failed\n"); goto out; } /* Get zone list */ ret = zbc_list_zones(dev, 0, ZBC_RO_ALL, &zones, &nr_zones); if ( ret != 0 ) { fprintf(stderr, "zbc_list_zones failed\n"); ret = 1; goto out; } /* Get target zone */ if ( zidx >= (int)nr_zones ) { fprintf(stderr, "Target zone not found\n"); ret = 1; goto out; } iozone = &zones[zidx]; printf("Device %s: %s interface, %s disk model\n", path, zbc_disk_type_str(info.zbd_type), zbc_disk_model_str(info.zbd_model)); printf(" %llu logical blocks of %u B\n", (unsigned long long) info.zbd_logical_blocks, (unsigned int) info.zbd_logical_block_size); printf(" %llu physical blocks of %u B\n", (unsigned long long) info.zbd_physical_blocks, (unsigned int) info.zbd_physical_block_size); printf("Target zone: Zone %d / %d, type 0x%x, cond 0x%x, need_reset %d, non_seq %d, LBA %llu, %llu sectors, wp %llu\n", zidx, nr_zones, iozone->zbz_type, iozone->zbz_condition, iozone->zbz_need_reset, iozone->zbz_non_seq, zbc_zone_start_lba(iozone), zbc_zone_length(iozone), zbc_zone_wp_lba(iozone)); /* Check I/O size alignment */ if ( zbc_zone_sequential_req(iozone) ) { ioalign = info.zbd_physical_block_size; } else { ioalign = info.zbd_logical_block_size; } if ( iosize % ioalign ) { fprintf(stderr, "Invalid I/O size %zu (must be aligned on %zu)\n", iosize, ioalign); ret = 1; goto out; } /* Get an I/O buffer */ ret = posix_memalign((void **) &iobuf, ioalign, iosize); if ( ret != 0 ) { fprintf(stderr, "No memory for I/O buffer (%zu B)\n", iosize); ret = 1; goto out; } /* Open the file to write, if any */ if ( file ) { fd = open(file, O_LARGEFILE | O_RDONLY); if ( fd < 0 ) { fprintf(stderr, "Open file \"%s\" failed %d (%s)\n", file, errno, strerror(errno)); ret = 1; goto out; } ret = fstat(fd, &st); if ( ret != 0 ) { fprintf(stderr, "Stat file \"%s\" failed %d (%s)\n", file, errno, strerror(errno)); ret = 1; goto out; } if ( S_ISREG(st.st_mode) ) { fsize = st.st_size; } else if ( S_ISBLK(st.st_mode) ) { ret = ioctl(fd, BLKGETSIZE64, &fsize); if ( ret != 0 ) { fprintf(stderr, "ioctl BLKGETSIZE64 block device \"%s\" failed %d (%s)\n", file, errno, strerror(errno)); ret = 1; goto out; } } else { fprintf(stderr, "Unsupported file \"%s\" type\n", file); ret = 1; goto out; } printf("Writting file \"%s\" (%llu B) to target zone %d, %zu B I/Os\n", file, fsize, zidx, iosize); } else if ( ! ionum ) { printf("Filling target zone %d, %zu B I/Os\n", zidx, iosize); } else { printf("Writting to target zone %d, %d I/Os of %zu B\n", zidx, ionum, iosize); } if ( ! zbc_zone_conventional(iozone) ) { lba_ofst = zbc_zone_wp_lba(iozone) - zbc_zone_start_lba(iozone); } elapsed = zbc_write_zone_usec(); while( (! zbc_write_zone_abort) && (lba_ofst < (long long)zbc_zone_length(iozone)) ) { if ( file ) { size_t ios; /* Read file */ ret = read(fd, iobuf, iosize); if ( ret < 0 ) { fprintf(stderr, "Read file \"%s\" failed %d (%s)\n", file, errno, strerror(errno)); ret = 1; break; } ios = ret; if ( ios < iosize ) { if ( floop ) { /* Rewind and read remaining of buffer */ lseek(fd, 0, SEEK_SET); ret = read(fd, iobuf + ios, iosize - ios); if ( ret < 0 ) { fprintf(stderr, "Read file \"%s\" failed %d (%s)\n", file, errno, strerror(errno)); ret = 1; break; } ios += ret; } else if ( ios ) { /* Clear end of buffer */ memset(iobuf + ios, 0, iosize - ios); } } if ( ! ios ) { /* EOF */ break; } } /* Write to zone */ lba_count = iosize / info.zbd_logical_block_size; if ( (lba_ofst + lba_count) > (long long)zbc_zone_length(iozone) ) { lba_count = zbc_zone_length(iozone) - lba_ofst; } if ( zbc_zone_conventional(iozone) ) { ret = zbc_pwrite(dev, iozone, iobuf, lba_count, lba_ofst); if ( ret > 0 ) { lba_ofst += ret; } } else { ret = zbc_write(dev, iozone, iobuf, lba_count); } if ( ret <= 0 ) { ret = 1; break; } /* Update zone write pointer */ lba_ofst += ret; if ( zbc_zone_sequential_req(iozone) ) { iozone->zbz_write_pointer += ret; } else if ( zbc_zone_sequential_pref(iozone) ) { ret = zbc_report_zones(dev, 0, ZBC_RO_ALL, zones, &nr_zones); if ( ret != 0 ) { fprintf(stderr, "zbc_report_zones failed\n"); ret = 1; goto out; } } bcount += ret * info.zbd_logical_block_size; iocount++; if ( (ionum > 0) && (iocount >= ionum) ) { break; } } elapsed = zbc_write_zone_usec() - elapsed; if ( elapsed ) { printf("Wrote %llu B (%d I/Os) in %llu.%03llu sec\n", bcount, iocount, elapsed / 1000000, (elapsed % 1000000) / 1000); printf(" IOPS %llu\n", iocount * 1000000 / elapsed); brate = bcount * 1000000 / elapsed; printf(" BW %llu.%03llu MB/s\n", brate / 1000000, (brate % 1000000) / 1000); } else { printf("Wrote %llu B (%d I/Os)\n", bcount, iocount); } if ( flush ) { printf("Flushing disk...\n"); ret = zbc_flush(dev); if ( ret != 0 ) { fprintf(stderr, "zbc_flush failed %d (%s)\n", -ret, strerror(-ret)); ret = 1; } } out: if ( iobuf ) { free(iobuf); } if ( fd > 0 ) { close(fd); } if ( zones ) { free(zones); } zbc_close(dev); return( ret ); }
int main(int argc, char **argv) { struct zbc_device_info info; unsigned long long lba = 0; struct zbc_device *dev; enum zbc_reporting_options ro = ZBC_RO_ALL; int i, ret = 1; zbc_zone_t *z, *zones = NULL; unsigned int nr_zones, nz = 0, prtl = 0; int num = 0; char *path; /* Check command line */ if ( argc < 2 ) { usage: printf("Usage: %s [options] <dev>\n" "Options:\n" " -v : Verbose mode\n" " -lba <lba> : Specify zone start LBA (default is 0)\n" " -ro <opt> : Reporting Option\n" " -p : Partial bit\n", argv[0]); return( 1 ); } /* Parse options */ for(i = 1; i < (argc - 1); i++) { if ( strcmp(argv[i], "-v") == 0 ) { zbc_set_log_level("debug"); } else if ( strcmp(argv[i], "-lba") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; lba = strtoll(argv[i], NULL, 10); } else if ( strcmp(argv[i], "-ro") == 0 ) { if ( i >= (argc - 1) ) { goto usage; } i++; ro = atoi(argv[i]); if ( ro < 0 ) { goto usage; } } else if ( strcmp(argv[i], "-p") == 0 ) { prtl = ZBC_RO_PARTIAL; } else if ( argv[i][0] == '-' ) { printf("Unknown option \"%s\"\n", argv[i]); goto usage; } else { break; } } if ( i != (argc - 1) ) { goto usage; } /* Merging ro */ ro |= prtl; /* Open device */ path = argv[i]; ret = zbc_open(path, O_RDONLY, &dev); if ( ret != 0 ) { fprintf(stderr, "[TEST][ERROR],open device failed\n"); printf("[TEST][ERROR][SENSE_KEY],open-device-failed\n"); printf("[TEST][ERROR][ASC_ASCQ],open-device-failed\n"); return( 1 ); } ret = zbc_get_device_info(dev, &info); if ( ret < 0 ) { fprintf(stderr, "[TEST][ERROR],zbc_get_device_info failed\n"); goto out; } /* Get the number of zones */ ret = zbc_report_nr_zones(dev, lba, ro, &nr_zones); if ( ret != 0 ) { fprintf(stderr, "[TEST][ERROR],zbc_report_nr_zones at lba %llu, ro 0x%02x failed %d\n", (unsigned long long) lba, (unsigned int) ro, ret); ret = 1; goto out; } if ( num ) { goto out; } if ( (! nz) || (nz > nr_zones) ) { nz = nr_zones; } /* Allocate zone array */ zones = (zbc_zone_t *) malloc(sizeof(zbc_zone_t) * nz); if ( ! zones ) { fprintf(stderr, "[TEST][ERROR],No memory\n"); ret = 1; goto out; } memset(zones, 0, sizeof(zbc_zone_t) * nz); /* Get zone information */ ret = zbc_report_zones(dev, lba, ro, zones, &nz); if ( ret != 0 ) { fprintf(stderr, "[TEST][ERROR],zbc_report_zones failed %d\n", ret); ret = 1; goto out; } for(i = 0; i < (int)nz; i++) { z = &zones[i]; if ( zbc_zone_conventional(z) ) { printf("[ZONE_INFO],%05d,0x%x,0x%x,%llu,%llu,N/A\n", i, zbc_zone_type(z), zbc_zone_condition(z), zbc_zone_start_lba(z), zbc_zone_length(z)); } else { printf("[ZONE_INFO],%05d,0x%x,0x%x,%llu,%llu,%llu\n", i, zbc_zone_type(z), zbc_zone_condition(z), zbc_zone_start_lba(z), zbc_zone_length(z), zbc_zone_wp_lba(z)); } } out: if ( ret ) { zbc_errno_t zbc_err; const char *sk_name; const char *ascq_name; zbc_errno(dev, &zbc_err); sk_name = zbc_sk_str(zbc_err.sk); ascq_name = zbc_asc_ascq_str(zbc_err.asc_ascq); printf("[TEST][ERROR][SENSE_KEY],%s\n", sk_name); printf("[TEST][ERROR][ASC_ASCQ],%s\n", ascq_name); } if ( zones ) { free(zones); } zbc_close(dev); return( ret ); }