1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2008, 2009 Yahoo!, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The names of the authors may not be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/param.h> 33 #include <sys/ioctl.h> 34 #include <sys/sysctl.h> 35 #include <sys/uio.h> 36 37 #include <err.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <time.h> 44 #include <unistd.h> 45 #include <paths.h> 46 47 #include "mfiutil.h" 48 #include <dev/mfi/mfi_ioctl.h> 49 50 static const char *mfi_status_codes[] = { 51 "Command completed successfully", 52 "Invalid command", 53 "Invalid DMCD opcode", 54 "Invalid parameter", 55 "Invalid Sequence Number", 56 "Abort isn't possible for the requested command", 57 "Application 'host' code not found", 58 "Application in use", 59 "Application not initialized", 60 "Array index invalid", 61 "Array row not empty", 62 "Configuration resource conflict", 63 "Device not found", 64 "Drive too small", 65 "Flash memory allocation failed", 66 "Flash download already in progress", 67 "Flash operation failed", 68 "Bad flash image", 69 "Incomplete flash image", 70 "Flash not open", 71 "Flash not started", 72 "Flush failed", 73 "Specified application doesn't have host-resident code", 74 "Volume consistency check in progress", 75 "Volume initialization in progress", 76 "Volume LBA out of range", 77 "Maximum number of volumes are already configured", 78 "Volume is not OPTIMAL", 79 "Volume rebuild in progress", 80 "Volume reconstruction in progress", 81 "Volume RAID level is wrong for requested operation", 82 "Too many spares assigned", 83 "Scratch memory not available", 84 "Error writing MFC data to SEEPROM", 85 "Required hardware is missing", 86 "Item not found", 87 "Volume drives are not within an enclosure", 88 "Drive clear in progress", 89 "Drive type mismatch (SATA vs SAS)", 90 "Patrol read disabled", 91 "Invalid row index", 92 "SAS Config - Invalid action", 93 "SAS Config - Invalid data", 94 "SAS Config - Invalid page", 95 "SAS Config - Invalid type", 96 "SCSI command completed with error", 97 "SCSI I/O request failed", 98 "SCSI RESERVATION_CONFLICT", 99 "One or more flush operations during shutdown failed", 100 "Firmware time is not set", 101 "Wrong firmware or drive state", 102 "Volume is offline", 103 "Peer controller rejected request", 104 "Unable to inform peer of communication changes", 105 "Volume reservation already in progress", 106 "I2C errors were detected", 107 "PCI errors occurred during XOR/DMA operation", 108 "Diagnostics failed", 109 "Unable to process command as boot messages are pending", 110 "Foreign configuration is incomplete" 111 }; 112 113 const char * 114 mfi_status(u_int status_code) 115 { 116 static char buffer[16]; 117 118 if (status_code == MFI_STAT_INVALID_STATUS) 119 return ("Invalid status"); 120 if (status_code < sizeof(mfi_status_codes) / sizeof(char *)) 121 return (mfi_status_codes[status_code]); 122 snprintf(buffer, sizeof(buffer), "Status: 0x%02x", status_code); 123 return (buffer); 124 } 125 126 const char * 127 mfi_raid_level(uint8_t primary_level, uint8_t secondary_level) 128 { 129 static char buf[16]; 130 131 switch (primary_level) { 132 case DDF_RAID0: 133 return ("RAID-0"); 134 case DDF_RAID1: 135 if (secondary_level != 0) 136 return ("RAID-10"); 137 else 138 return ("RAID-1"); 139 case DDF_RAID1E: 140 return ("RAID-1E"); 141 case DDF_RAID3: 142 return ("RAID-3"); 143 case DDF_RAID5: 144 if (secondary_level != 0) 145 return ("RAID-50"); 146 else 147 return ("RAID-5"); 148 case DDF_RAID5E: 149 return ("RAID-5E"); 150 case DDF_RAID5EE: 151 return ("RAID-5EE"); 152 case DDF_RAID6: 153 if (secondary_level != 0) 154 return ("RAID-60"); 155 else 156 return ("RAID-6"); 157 case DDF_JBOD: 158 return ("JBOD"); 159 case DDF_CONCAT: 160 return ("CONCAT"); 161 default: 162 sprintf(buf, "LVL 0x%02x", primary_level); 163 return (buf); 164 } 165 } 166 167 static int 168 mfi_query_disk(int fd, uint8_t target_id, struct mfi_query_disk *info) 169 { 170 171 bzero(info, sizeof(*info)); 172 info->array_id = target_id; 173 if (ioctl(fd, MFIIO_QUERY_DISK, info) < 0) 174 return (-1); 175 if (!info->present) { 176 errno = ENXIO; 177 return (-1); 178 } 179 return (0); 180 } 181 182 const char * 183 mfi_volume_name(int fd, uint8_t target_id) 184 { 185 static struct mfi_query_disk info; 186 static char buf[4]; 187 188 if (mfi_query_disk(fd, target_id, &info) < 0) { 189 snprintf(buf, sizeof(buf), "%d", target_id); 190 return (buf); 191 } 192 return (info.devname); 193 } 194 195 int 196 mfi_volume_busy(int fd, uint8_t target_id) 197 { 198 struct mfi_query_disk info; 199 200 /* Assume it isn't mounted if we can't get information. */ 201 if (mfi_query_disk(fd, target_id, &info) < 0) 202 return (0); 203 return (info.open != 0); 204 } 205 206 /* 207 * Check if the running kernel supports changing the RAID 208 * configuration of the mfi controller. 209 */ 210 int 211 mfi_reconfig_supported(const char *dev) 212 { 213 char mibname[64]; 214 const char *cp; 215 size_t len; 216 int dummy, mfi_unit; 217 218 cp = dev + strlen(_PATH_DEV); 219 if (strncmp(cp, MRSAS_TYPE, strlen(MRSAS_TYPE)) == 0) 220 return (1); 221 222 cp += strlen(MFI_TYPE); 223 mfi_unit = strtol(cp, NULL, 10);; 224 225 len = sizeof(dummy); 226 snprintf(mibname, sizeof(mibname), 227 "dev.mfi.%d.delete_busy_volumes", mfi_unit); 228 return (sysctlbyname(mibname, &dummy, &len, NULL, 0) == 0); 229 } 230 231 int 232 mfi_lookup_volume(int fd, const char *name, uint8_t *target_id) 233 { 234 struct mfi_query_disk info; 235 struct mfi_ld_list list; 236 char *cp; 237 long val; 238 u_int i; 239 240 /* If it's a valid number, treat it as a raw target ID. */ 241 val = strtol(name, &cp, 0); 242 if (*cp == '\0') { 243 *target_id = val; 244 return (0); 245 } 246 247 if (mfi_dcmd_command(fd, MFI_DCMD_LD_GET_LIST, &list, sizeof(list), 248 NULL, 0, NULL) < 0) 249 return (-1); 250 251 for (i = 0; i < list.ld_count; i++) { 252 if (mfi_query_disk(fd, list.ld_list[i].ld.v.target_id, 253 &info) < 0) 254 continue; 255 if (strcmp(name, info.devname) == 0) { 256 *target_id = list.ld_list[i].ld.v.target_id; 257 return (0); 258 } 259 } 260 errno = EINVAL; 261 return (-1); 262 } 263 264 int 265 mfi_dcmd_command(int fd, uint32_t opcode, void *buf, size_t bufsize, 266 uint8_t *mbox, size_t mboxlen, uint8_t *statusp) 267 { 268 struct mfi_ioc_passthru ioc; 269 struct mfi_dcmd_frame *dcmd; 270 int r; 271 272 if ((mbox != NULL && (mboxlen == 0 || mboxlen > MFI_MBOX_SIZE)) || 273 (mbox == NULL && mboxlen != 0)) { 274 errno = EINVAL; 275 return (-1); 276 } 277 278 bzero(&ioc, sizeof(ioc)); 279 dcmd = &ioc.ioc_frame; 280 if (mbox) 281 bcopy(mbox, dcmd->mbox, mboxlen); 282 dcmd->header.cmd = MFI_CMD_DCMD; 283 dcmd->header.timeout = 0; 284 dcmd->header.flags = 0; 285 dcmd->header.data_len = bufsize; 286 dcmd->opcode = opcode; 287 288 ioc.buf = buf; 289 ioc.buf_size = bufsize; 290 r = ioctl(fd, MFIIO_PASSTHRU, &ioc); 291 if (r < 0) 292 return (r); 293 294 if (statusp != NULL) 295 *statusp = dcmd->header.cmd_status; 296 else if (dcmd->header.cmd_status != MFI_STAT_OK) { 297 warnx("Command failed: %s", 298 mfi_status(dcmd->header.cmd_status)); 299 errno = EIO; 300 return (-1); 301 } 302 return (0); 303 } 304 305 int 306 mfi_ctrl_get_info(int fd, struct mfi_ctrl_info *info, uint8_t *statusp) 307 { 308 309 return (mfi_dcmd_command(fd, MFI_DCMD_CTRL_GETINFO, info, 310 sizeof(struct mfi_ctrl_info), NULL, 0, statusp)); 311 } 312 313 int 314 mfi_open(char *dev, int acs) 315 { 316 int ret; 317 318 ret = open(dev, acs); 319 if (ret < 0) 320 warn("Couldn't open %s", dev); 321 return (ret); 322 } 323 324 static void 325 print_time_humanized(uint seconds) 326 { 327 328 if (seconds > 3600) { 329 printf("%u:", seconds / 3600); 330 } 331 if (seconds > 60) { 332 seconds %= 3600; 333 printf("%02u:%02u", seconds / 60, seconds % 60); 334 } else { 335 printf("%us", seconds); 336 } 337 } 338 339 void 340 mfi_display_progress(const char *label, struct mfi_progress *prog) 341 { 342 uint seconds; 343 344 printf("%s: %.2f%% complete after ", label, 345 (float)prog->progress * 100 / 0xffff); 346 print_time_humanized(prog->elapsed_seconds); 347 if (prog->progress != 0 && prog->elapsed_seconds > 10) { 348 printf(" finished in "); 349 seconds = (0x10000 * (uint32_t)prog->elapsed_seconds) / 350 prog->progress - prog->elapsed_seconds; 351 print_time_humanized(seconds); 352 } 353 printf("\n"); 354 } 355 356 int 357 mfi_table_handler(struct mfiutil_command **start, struct mfiutil_command **end, 358 int ac, char **av) 359 { 360 struct mfiutil_command **cmd; 361 362 if (ac < 2) { 363 warnx("The %s command requires a sub-command.", av[0]); 364 return (EINVAL); 365 } 366 for (cmd = start; cmd < end; cmd++) { 367 if (strcmp((*cmd)->name, av[1]) == 0) 368 return ((*cmd)->handler(ac - 1, av + 1)); 369 } 370 371 warnx("%s is not a valid sub-command of %s.", av[1], av[0]); 372 return (ENOENT); 373 } 374