| /* |
| * Copyright (c) 2009-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 <stdbool.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <getopt.h> |
| #include <limits.h> |
| #define __STDC_FORMAT_MACROS 1 |
| #include <inttypes.h> |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| #include "sg_lib.h" |
| #include "sg_cmds_basic.h" |
| #include "sg_cmds_extra.h" |
| #include "sg_unaligned.h" |
| #include "sg_pr2serr.h" |
| |
| |
| /* A utility program originally written for the Linux OS SCSI subsystem. |
| * |
| * This utility invokes the UNMAP SCSI command to unmap (trim) one or more |
| * logical blocks. Note that DATA MAY BE LOST. |
| */ |
| |
| static const char * version_str = "1.19 20220813"; |
| |
| |
| #define DEF_TIMEOUT_SECS 60 |
| #define MAX_NUM_ADDR 128 |
| #define RCAP10_RESP_LEN 8 |
| #define RCAP16_RESP_LEN 32 |
| |
| #ifndef UINT32_MAX |
| #define UINT32_MAX ((uint32_t)-1) |
| #endif |
| |
| |
| static struct option long_options[] = { |
| {"all", required_argument, 0, 'A'}, |
| {"anchor", no_argument, 0, 'a'}, |
| {"dry-run", no_argument, 0, 'd'}, |
| {"dry_run", no_argument, 0, 'd'}, |
| {"force", no_argument, 0, 'f'}, |
| {"grpnum", required_argument, 0, 'g'}, |
| {"help", no_argument, 0, 'h'}, |
| {"in", required_argument, 0, 'I'}, |
| {"lba", required_argument, 0, 'l'}, |
| {"num", required_argument, 0, 'n'}, |
| {"timeout", required_argument, 0, 't'}, |
| {"verbose", no_argument, 0, 'v'}, |
| {"version", no_argument, 0, 'V'}, |
| {0, 0, 0, 0}, |
| }; |
| |
| |
| static void |
| usage() |
| { |
| pr2serr("Usage: " |
| "sg_unmap [--all=ST,RN[,LA]] [--anchor] [--dry-run] [--force]\n" |
| " [--grpnum=GN] [--help] [--in=FILE] " |
| "[--lba=LBA,LBA...]\n" |
| " [--num=NUM,NUM...] [--timeout=TO] [--verbose] " |
| "[--version]\n" |
| " DEVICE\n" |
| " where:\n" |
| " --all=ST,RN[,LA]|-A ST,RN[,LA] start unmaps at LBA ST, " |
| "RN blocks\n" |
| " per unmap until the end of disk, or " |
| "until\n" |
| " and including LBA LA (last)\n" |
| " --anchor|-a set anchor field in cdb\n" |
| " --dry-run|-d prepare but skip UNMAP call(s)\n" |
| " --force|-f don't ask for confirmation before " |
| "zapping media\n" |
| " --grpnum=GN|-g GN GN is group number field (def: 0)\n" |
| " --help|-h print out usage message\n" |
| " --in=FILE|-I FILE read LBA, NUM pairs from FILE (if " |
| "FILE is '-'\n" |
| " then stdin is read)\n" |
| " --lba=LBA,LBA...|-l LBA,LBA... LBA is the logical block " |
| "address\n" |
| " to start NUM unmaps\n" |
| " --num=NUM,NUM...|-n NUM,NUM... NUM is number of logical " |
| "blocks to\n" |
| " unmap starting at " |
| "corresponding LBA\n" |
| " --timeout=TO|-t TO command timeout (unit: seconds) " |
| "(def: 60)\n" |
| " --verbose|-v increase verbosity\n" |
| " --version|-V print version string and exit\n\n" |
| "Perform a SCSI UNMAP command. LBA, NUM and the values in FILE " |
| "are assumed\nto be decimal. Use '0x' prefix or 'h' suffix for " |
| "hex values.\n" |
| "Example to unmap LBA 0x12345:\n" |
| " sg_unmap --lba=0x12345 --num=1 /dev/sdb\n" |
| "Example to unmap starting at LBA 0x12345, 256 blocks per command:" |
| "\n sg_unmap --all=0x12345,256 /dev/sg2\n" |
| "until the end if /dev/sg2 (assumed to be a storage device)\n\n" |
| ); |
| pr2serr("WARNING: This utility will destroy data on DEVICE in the given " |
| "range(s)\nthat will be unmapped. Unmap is also known as 'trim' " |
| "and is irreversible.\n"); |
| } |
| |
| /* Read numbers (up to 64 bits in size) from command line (comma (or |
| * (single) space) separated list). Assumed decimal unless prefixed |
| * by '0x', '0X' or contains trailing 'h' or 'H' (which indicate hex). |
| * Returns 0 if ok, or 1 if error. */ |
| static int |
| build_lba_arr(const char * inp, uint64_t * lba_arr, int * lba_arr_len, |
| int max_arr_len) |
| { |
| int in_len, k; |
| int64_t ll; |
| const char * lcp; |
| char * cp; |
| char * c2p; |
| |
| if ((NULL == inp) || (NULL == lba_arr) || |
| (NULL == lba_arr_len)) |
| return 1; |
| lcp = inp; |
| in_len = strlen(inp); |
| if (0 == in_len) |
| *lba_arr_len = 0; |
| if ('-' == inp[0]) { /* read from stdin */ |
| pr2serr("'--lba' cannot be read from stdin\n"); |
| return 1; |
| } else { /* list of numbers (default decimal) on command line */ |
| k = strspn(inp, "0123456789aAbBcCdDeEfFhHxXiIkKmMgGtTpP, "); |
| if (in_len != k) { |
| pr2serr("build_lba_arr: error at pos %d\n", k + 1); |
| return 1; |
| } |
| for (k = 0; k < max_arr_len; ++k) { |
| ll = sg_get_llnum(lcp); |
| if (-1 != ll) { |
| lba_arr[k] = (uint64_t)ll; |
| cp = (char *)strchr(lcp, ','); |
| c2p = (char *)strchr(lcp, ' '); |
| if (NULL == cp) |
| cp = c2p; |
| if (NULL == cp) |
| break; |
| if (c2p && (c2p < cp)) |
| cp = c2p; |
| lcp = cp + 1; |
| } else { |
| pr2serr("build_lba_arr: error at pos %d\n", |
| (int)(lcp - inp + 1)); |
| return 1; |
| } |
| } |
| *lba_arr_len = k + 1; |
| if (k == max_arr_len) { |
| pr2serr("build_lba_arr: array length exceeded\n"); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| /* Read numbers (up to 32 bits in size) from command line (comma (or |
| * (single) space) separated list). Assumed decimal unless prefixed |
| * by '0x', '0X' or contains trailing 'h' or 'H' (which indicate hex). |
| * Returns 0 if ok, or 1 if error. */ |
| static int |
| build_num_arr(const char * inp, uint32_t * num_arr, int * num_arr_len, |
| int max_arr_len) |
| { |
| int in_len, k; |
| const char * lcp; |
| int64_t ll; |
| char * cp; |
| char * c2p; |
| |
| if ((NULL == inp) || (NULL == num_arr) || |
| (NULL == num_arr_len)) |
| return 1; |
| lcp = inp; |
| in_len = strlen(inp); |
| if (0 == in_len) |
| *num_arr_len = 0; |
| if ('-' == inp[0]) { /* read from stdin */ |
| pr2serr("'--len' cannot be read from stdin\n"); |
| return 1; |
| } else { /* list of numbers (default decimal) on command line */ |
| k = strspn(inp, "0123456789aAbBcCdDeEfFhHxXiIkKmMgGtTpP, "); |
| if (in_len != k) { |
| pr2serr("build_num_arr: error at pos %d\n", k + 1); |
| return 1; |
| } |
| for (k = 0; k < max_arr_len; ++k) { |
| ll = sg_get_llnum(lcp); |
| if (-1 != ll) { |
| if (ll > UINT32_MAX) { |
| pr2serr("build_num_arr: number exceeds 32 bits at pos " |
| "%d\n", (int)(lcp - inp + 1)); |
| return 1; |
| } |
| num_arr[k] = (uint32_t)ll; |
| cp = (char *)strchr(lcp, ','); |
| c2p = (char *)strchr(lcp, ' '); |
| if (NULL == cp) |
| cp = c2p; |
| if (NULL == cp) |
| break; |
| if (c2p && (c2p < cp)) |
| cp = c2p; |
| lcp = cp + 1; |
| } else { |
| pr2serr("build_num_arr: error at pos %d\n", |
| (int)(lcp - inp + 1)); |
| return 1; |
| } |
| } |
| *num_arr_len = k + 1; |
| if (k == max_arr_len) { |
| pr2serr("build_num_arr: array length exceeded\n"); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| |
| /* Read numbers from filename (or stdin) line by line (comma (or |
| * (single) space) separated list). Assumed decimal unless prefixed |
| * by '0x', '0X' or contains trailing 'h' or 'H' (which indicate hex). |
| * Returns 0 if ok, or 1 if error. */ |
| static int |
| build_joint_arr(const char * file_name, uint64_t * lba_arr, uint32_t * num_arr, |
| int * arr_len, int max_arr_len) |
| { |
| bool have_stdin; |
| int off = 0; |
| int in_len, k, j, m, ind, bit0; |
| int64_t ll; |
| char line[1024]; |
| char * lcp; |
| FILE * fp = NULL; |
| |
| have_stdin = ((1 == strlen(file_name)) && ('-' == file_name[0])); |
| if (have_stdin) |
| fp = stdin; |
| else { |
| fp = fopen(file_name, "r"); |
| if (NULL == fp) { |
| pr2serr("%s: unable to open %s\n", __func__, file_name); |
| return 1; |
| } |
| } |
| |
| for (j = 0; j < 512; ++j) { |
| if (NULL == fgets(line, sizeof(line), fp)) |
| break; |
| // could improve with carry_over logic if sizeof(line) too small |
| in_len = strlen(line); |
| if (in_len > 0) { |
| if ('\n' == line[in_len - 1]) { |
| --in_len; |
| line[in_len] = '\0'; |
| } |
| } |
| if (in_len < 1) |
| continue; |
| lcp = line; |
| m = strspn(lcp, " \t"); |
| if (m == in_len) |
| continue; |
| lcp += m; |
| in_len -= m; |
| if ('#' == *lcp) |
| continue; |
| k = strspn(lcp, "0123456789aAbBcCdDeEfFhHxXiIkKmMgGtTpP ,\t"); |
| if ((k < in_len) && ('#' != lcp[k])) { |
| pr2serr("%s: syntax error at line %d, pos %d\n", __func__, j + 1, |
| m + k + 1); |
| goto bad_exit; |
| } |
| for (k = 0; k < 1024; ++k) { |
| ll = sg_get_llnum(lcp); |
| if (-1 != ll) { |
| ind = ((off + k) >> 1); |
| bit0 = 0x1 & (off + k); |
| if (ind >= max_arr_len) { |
| pr2serr("%s: array length exceeded\n", __func__); |
| goto bad_exit; |
| } |
| if (bit0) { |
| if (ll > UINT32_MAX) { |
| pr2serr("%s: number exceeds 32 bits in line %d, at " |
| "pos %d\n", __func__, j + 1, |
| (int)(lcp - line + 1)); |
| goto bad_exit; |
| } |
| num_arr[ind] = (uint32_t)ll; |
| } else |
| lba_arr[ind] = (uint64_t)ll; |
| lcp = strpbrk(lcp, " ,\t"); |
| if (NULL == lcp) |
| break; |
| lcp += strspn(lcp, " ,\t"); |
| if ('\0' == *lcp) |
| break; |
| } else { |
| if ('#' == *lcp) { |
| --k; |
| break; |
| } |
| pr2serr("%s: error on line %d, at pos %d\n", __func__, j + 1, |
| (int)(lcp - line + 1)); |
| goto bad_exit; |
| } |
| } |
| off += (k + 1); |
| } |
| if (0x1 & off) { |
| pr2serr("%s: expect LBA,NUM pairs but decoded odd number\n from " |
| "%s\n", __func__, have_stdin ? "stdin" : file_name); |
| goto bad_exit; |
| } |
| *arr_len = off >> 1; |
| if (fp && (! have_stdin)) |
| fclose(fp); |
| return 0; |
| |
| bad_exit: |
| if (fp && (! have_stdin)) |
| fclose(fp); |
| return 1; |
| } |
| |
| |
| int |
| main(int argc, char * argv[]) |
| { |
| bool anchor = false; |
| bool do_force = false; |
| bool dry_run = false; |
| bool err_printed = false; |
| bool verbose_given = false; |
| bool version_given = false; |
| int res, c, num, k, j; |
| int sg_fd = -1; |
| int grpnum = 0; |
| int addr_arr_len = 0; |
| int num_arr_len = 0; |
| int param_len = 4; |
| int ret = 0; |
| int timeout = DEF_TIMEOUT_SECS; |
| int vb = 0; |
| uint32_t all_rn = 0; /* Repetition Number, 0 for inactive */ |
| uint64_t all_start = 0; |
| uint64_t all_last = 0; |
| int64_t ll; |
| const char * lba_op = NULL; |
| const char * num_op = NULL; |
| const char * in_op = NULL; |
| const char * device_name = NULL; |
| char * first_comma = NULL; |
| char * second_comma = NULL; |
| struct sg_simple_inquiry_resp inq_resp; |
| uint64_t addr_arr[MAX_NUM_ADDR]; |
| uint32_t num_arr[MAX_NUM_ADDR]; |
| uint8_t param_arr[8 + (MAX_NUM_ADDR * 16)]; |
| |
| while (1) { |
| int option_index = 0; |
| |
| c = getopt_long(argc, argv, "aA:dfg:hI:Hl:n:t:vV", long_options, |
| &option_index); |
| if (c == -1) |
| break; |
| |
| switch (c) { |
| case 'a': |
| anchor = true; |
| break; |
| case 'A': |
| first_comma = strchr(optarg, ','); |
| if (NULL == first_comma) { |
| pr2serr("--all=ST,RN[,LA] expects at least one comma in " |
| "argument, found none\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| ll = sg_get_llnum(optarg); |
| if (ll < 0) { |
| pr2serr("unable to decode --all=ST,.... (starting LBA)\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| all_start = (uint64_t)ll; |
| ll = sg_get_llnum(first_comma + 1); |
| if ((ll < 0) || (ll > UINT32_MAX)) { |
| pr2serr("unable to decode --all=ST,RN.... (repeat number)\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| all_rn = (uint32_t)ll; |
| if (0 == ll) |
| pr2serr("warning: --all=ST,RN... being ignored because RN " |
| "is 0\n"); |
| second_comma = strchr(first_comma + 1, ','); |
| if (second_comma) { |
| ll = sg_get_llnum(second_comma + 1); |
| if (ll < 0) { |
| pr2serr("unable to decode --all=ST,NR,LA (last LBA)\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| all_last = (uint64_t)ll; |
| } |
| break; |
| case 'd': |
| dry_run = true; |
| break; |
| case 'f': |
| do_force = true; |
| break; |
| case 'g': |
| num = sscanf(optarg, "%d", &res); |
| if ((1 == num) && (res >= 0) && (res <= 63)) |
| grpnum = res; |
| else { |
| pr2serr("value for '--grpnum=' must be 0 to 63\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'h': |
| case '?': |
| usage(); |
| return 0; |
| case 'I': |
| in_op = optarg; |
| break; |
| case 'l': |
| lba_op = optarg; |
| break; |
| case 'n': |
| num_op = optarg; |
| break; |
| case 't': |
| timeout = sg_get_num(optarg); |
| if (timeout < 0) { |
| pr2serr("bad argument to '--timeout'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } else if (0 == timeout) |
| timeout = DEF_TIMEOUT_SECS; |
| break; |
| case 'v': |
| verbose_given = true; |
| ++vb; |
| break; |
| case 'V': |
| version_given = true; |
| break; |
| default: |
| pr2serr("unrecognised option code 0x%x ??\n", c); |
| usage(); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| } |
| if (optind < argc) { |
| if (NULL == device_name) { |
| device_name = argv[optind]; |
| ++optind; |
| } |
| if (optind < argc) { |
| for (; optind < argc; ++optind) |
| pr2serr("Unexpected extra argument: %s\n", argv[optind]); |
| usage(); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| } |
| |
| #ifdef DEBUG |
| pr2serr("In DEBUG mode, "); |
| if (verbose_given && version_given) { |
| pr2serr("but override: '-vV' given, zero verbose and continue\n"); |
| verbose_given = false; |
| version_given = false; |
| vb = 0; |
| } else if (! verbose_given) { |
| pr2serr("set '-vv'\n"); |
| vb = 2; |
| } else |
| pr2serr("keep verbose=%d\n", vb); |
| #else |
| if (verbose_given && version_given) |
| pr2serr("Not in DEBUG mode, so '-vV' has no special action\n"); |
| #endif |
| if (version_given) { |
| pr2serr("version: %s\n", version_str); |
| return 0; |
| } |
| |
| if (NULL == device_name) { |
| pr2serr("missing device name!\n\n"); |
| usage(); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| |
| if (all_rn > 0) { |
| if (lba_op || num_op || in_op) { |
| pr2serr("Can't have --all= together with --lba=, --num= or " |
| "--in=\n\n"); |
| usage(); |
| return SG_LIB_CONTRADICT; |
| } |
| /* here if --all= looks okay so far */ |
| } else if (in_op && (lba_op || num_op)) { |
| pr2serr("expect '--in=' by itself, or both '--lba=' and " |
| "'--num='\n\n"); |
| usage(); |
| return SG_LIB_CONTRADICT; |
| } else if (in_op || (lba_op && num_op)) |
| ; |
| else { |
| if (lba_op) |
| pr2serr("since '--lba=' is given, also need '--num='\n\n"); |
| else |
| pr2serr("expect either both '--lba=' and '--num=', or " |
| "'--in=', or '--all='\n\n"); |
| usage(); |
| return SG_LIB_CONTRADICT; |
| } |
| |
| if (all_rn > 0) { |
| if ((all_last > 0) && (all_start > all_last)) { |
| pr2serr("in --all=ST,RN,LA start address (ST) exceeds last " |
| "address (LA)\n"); |
| return SG_LIB_CONTRADICT; |
| } |
| } else { |
| memset(addr_arr, 0, sizeof(addr_arr)); |
| memset(num_arr, 0, sizeof(num_arr)); |
| addr_arr_len = 0; |
| if (lba_op && num_op) { |
| if (0 != build_lba_arr(lba_op, addr_arr, &addr_arr_len, |
| MAX_NUM_ADDR)) { |
| pr2serr("bad argument to '--lba'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| if (0 != build_num_arr(num_op, num_arr, &num_arr_len, |
| MAX_NUM_ADDR)) { |
| pr2serr("bad argument to '--num'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| if ((addr_arr_len != num_arr_len) || (num_arr_len <= 0)) { |
| pr2serr("need same number of arguments to '--lba=' " |
| "and '--num=' options\n"); |
| return SG_LIB_CONTRADICT; |
| } |
| } |
| if (in_op) { |
| if (0 != build_joint_arr(in_op, addr_arr, num_arr, &addr_arr_len, |
| MAX_NUM_ADDR)) { |
| pr2serr("bad argument to '--in'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| if (addr_arr_len <= 0) { |
| pr2serr("no addresses found in '--in=' argument, file: %s\n", |
| in_op); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| } |
| param_len = 8 + (16 * addr_arr_len); |
| memset(param_arr, 0, param_len); |
| k = 8; |
| for (j = 0; j < addr_arr_len; ++j) { |
| sg_put_unaligned_be64(addr_arr[j], param_arr + k); |
| k += 8; |
| sg_put_unaligned_be32(num_arr[j], param_arr + k); |
| k += 4 + 4; |
| } |
| k = 0; |
| num = param_len - 2; |
| sg_put_unaligned_be16((uint16_t)num, param_arr + k); |
| k += 2; |
| num = param_len - 8; |
| sg_put_unaligned_be16((uint16_t)num, param_arr + k); |
| } |
| |
| sg_fd = sg_cmds_open_device(device_name, false /* rw */, vb); |
| if (sg_fd < 0) { |
| ret = sg_convert_errno(-sg_fd); |
| pr2serr("open error: %s: %s\n", device_name, safe_strerror(-sg_fd)); |
| goto err_out; |
| } |
| ret = sg_simple_inquiry(sg_fd, &inq_resp, true, vb); |
| |
| if (all_rn > 0) { |
| bool last_retry; |
| bool to_end_of_device = false; |
| uint64_t ull; |
| uint32_t bump; |
| |
| if (0 == all_last) { /* READ CAPACITY(10 or 16) to find last */ |
| uint8_t resp_buff[RCAP16_RESP_LEN]; |
| |
| res = sg_ll_readcap_16(sg_fd, false /* pmi */, 0 /* llba */, |
| resp_buff, RCAP16_RESP_LEN, true, vb); |
| if (SG_LIB_CAT_UNIT_ATTENTION == res) { |
| pr2serr("Read capacity(16) unit attention, try again\n"); |
| res = sg_ll_readcap_16(sg_fd, false, 0, resp_buff, |
| RCAP16_RESP_LEN, true, vb); |
| } |
| if (0 == res) { |
| if (vb > 3) { |
| pr2serr("Read capacity(16) response:\n"); |
| hex2stderr(resp_buff, RCAP16_RESP_LEN, 1); |
| } |
| all_last = sg_get_unaligned_be64(resp_buff + 0); |
| } else if ((SG_LIB_CAT_INVALID_OP == res) || |
| (SG_LIB_CAT_ILLEGAL_REQ == res)) { |
| if (vb) |
| pr2serr("Read capacity(16) not supported, try Read " |
| "capacity(10)\n"); |
| res = sg_ll_readcap_10(sg_fd, false /* pmi */, 0 /* lba */, |
| resp_buff, RCAP10_RESP_LEN, true, |
| vb); |
| if (0 == res) { |
| if (vb > 3) { |
| pr2serr("Read capacity(10) response:\n"); |
| hex2stderr(resp_buff, RCAP10_RESP_LEN, 1); |
| } |
| all_last = (uint64_t)sg_get_unaligned_be32(resp_buff + 0); |
| } else { |
| if (res < 0) |
| res = sg_convert_errno(-res); |
| pr2serr("Read capacity(10) failed\n"); |
| ret = res; |
| goto err_out; |
| } |
| } else { |
| if (res < 0) |
| res = sg_convert_errno(-res); |
| pr2serr("Read capacity(16) failed\n"); |
| ret = res; |
| goto err_out; |
| } |
| if (all_start > all_last) { |
| pr2serr("after READ CAPACITY the last block (0x%" PRIx64 |
| ") less than start address (0x%" PRIx64 ")\n", |
| all_start, all_last); |
| ret = SG_LIB_CONTRADICT; |
| goto err_out; |
| } |
| to_end_of_device = true; |
| } |
| if (! do_force) { |
| char b[120]; |
| |
| printf("%s is: %.8s %.16s %.4s\n", device_name, |
| inq_resp.vendor, inq_resp.product, inq_resp.revision); |
| sg_sleep_secs(3); |
| if (to_end_of_device) |
| snprintf(b, sizeof(b), "%s from LBA 0x%" PRIx64 " to end " |
| "(0x%" PRIx64 ")", device_name, all_start, all_last); |
| else |
| snprintf(b, sizeof(b), "%s from LBA 0x%" PRIx64 " to 0x%" |
| PRIx64, device_name, all_start, all_last); |
| sg_warn_and_wait("UNMAP (a.k.a. trim)", b, false); |
| } |
| if (dry_run) { |
| pr2serr("Doing dry-run, would have unmapped from LBA 0x%" PRIx64 |
| " to 0x%" PRIx64 "\n %u blocks per UNMAP command\n", |
| all_start, all_last, all_rn); |
| goto err_out; |
| } |
| last_retry = false; |
| param_len = 8 + (16 * 1); |
| for (ull = all_start, j = 0; ull <= all_last; ull += bump, ++j) { |
| if ((all_last - ull) < all_rn) |
| bump = (uint32_t)(all_last + 1 - ull); |
| else |
| bump = all_rn; |
| retry: |
| memset(param_arr, 0, param_len); |
| k = 8; |
| sg_put_unaligned_be64(ull, param_arr + k); |
| k += 8; |
| sg_put_unaligned_be32(bump, param_arr + k); |
| k = 0; |
| num = param_len - 2; |
| sg_put_unaligned_be16((uint16_t)num, param_arr + k); |
| k += 2; |
| num = param_len - 8; |
| sg_put_unaligned_be16((uint16_t)num, param_arr + k); |
| ret = sg_ll_unmap_v2(sg_fd, anchor, grpnum, timeout, param_arr, |
| param_len, true, (vb > 2 ? vb - 2 : 0)); |
| if (last_retry) |
| break; |
| if (ret) { |
| if ((SG_LIB_LBA_OUT_OF_RANGE == ret) && |
| ((ull + bump) > all_last)) { |
| pr2serr("Typical end of disk out-of-range, decrement " |
| "count and retry\n"); |
| if (bump > 1) { |
| --bump; |
| last_retry = true; |
| goto retry; |
| } /* if bump==1 can't do last, so we are finished */ |
| } |
| break; |
| } |
| } /* end of for loop doing unmaps */ |
| if (vb) |
| pr2serr("Completed %d UNMAP commands\n", j); |
| } else { /* --all= not given */ |
| if (dry_run) { |
| pr2serr("Doing dry-run so here is 'LBA, number_of_blocks' list " |
| "of candidates\n"); |
| k = 8; |
| for (j = 0; j < addr_arr_len; ++j) { |
| printf(" 0x%" PRIx64 ", 0x%u\n", |
| sg_get_unaligned_be64(param_arr + k), |
| sg_get_unaligned_be32(param_arr + k + 8)); |
| k += (8 + 4 + 4); |
| } |
| goto err_out; |
| } |
| if (! do_force) { |
| printf("%s is: %.8s %.16s %.4s\n", device_name, |
| inq_resp.vendor, inq_resp.product, inq_resp.revision); |
| sg_sleep_secs(3); |
| printf("\nAn UNMAP (a.k.a. trim) will commence in 15 seconds\n"); |
| printf(" Some data will be LOST\n"); |
| printf(" Press control-C to abort\n"); |
| sg_sleep_secs(5); |
| printf("\nAn UNMAP will commence in 10 seconds\n"); |
| printf(" Some data will be LOST\n"); |
| printf(" Press control-C to abort\n"); |
| sg_sleep_secs(5); |
| printf("\nAn UNMAP (a.k.a. trim) will commence in 5 seconds\n"); |
| printf(" Some data will be LOST\n"); |
| printf(" Press control-C to abort\n"); |
| sg_sleep_secs(7); |
| } |
| res = sg_ll_unmap_v2(sg_fd, anchor, grpnum, timeout, param_arr, |
| param_len, true, vb); |
| ret = res; |
| err_printed = true; |
| switch (ret) { |
| case SG_LIB_CAT_NOT_READY: |
| pr2serr("UNMAP failed, device not ready\n"); |
| break; |
| case SG_LIB_CAT_UNIT_ATTENTION: |
| pr2serr("UNMAP, unit attention\n"); |
| break; |
| case SG_LIB_CAT_ABORTED_COMMAND: |
| pr2serr("UNMAP, aborted command\n"); |
| break; |
| case SG_LIB_CAT_INVALID_OP: |
| pr2serr("UNMAP not supported\n"); |
| break; |
| case SG_LIB_CAT_ILLEGAL_REQ: |
| pr2serr("bad field in UNMAP cdb\n"); |
| break; |
| default: |
| err_printed = false; |
| break; |
| } |
| } |
| |
| err_out: |
| if (sg_fd >= 0) { |
| res = sg_cmds_close_device(sg_fd); |
| if (res < 0) { |
| pr2serr("close error: %s\n", safe_strerror(-res)); |
| if (0 == ret) |
| ret = sg_convert_errno(-res); |
| } |
| } |
| if ((0 == vb) && (! err_printed)) { |
| if (! sg_if_can2stderr("sg_unmap failed: ", ret)) |
| pr2serr("Some error occurred, try again with '-v' or '-vv' for " |
| "more information\n"); |
| } |
| return (ret >= 0) ? ret : SG_LIB_CAT_OTHER; |
| } |
