1 /*- 2 * Copyright (c) 2008, 2009 Yahoo!, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The names of the authors may not be used to endorse or promote 14 * products derived from this software without specific prior written 15 * permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: src/usr.sbin/mfiutil/mfi_patrol.c,v 1.2 2010/10/26 19:11:09 jhb Exp $ 30 */ 31 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <err.h> 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <time.h> 39 #include <unistd.h> 40 #include "mfiutil.h" 41 42 static char * 43 adapter_time(time_t now, uint32_t at_now, uint32_t at) 44 { 45 time_t t; 46 47 t = (now - at_now) + at; 48 return (ctime(&t)); 49 } 50 51 static void 52 mfi_get_time(int fd, uint32_t *at) 53 { 54 55 if (mfi_dcmd_command(fd, MFI_DCMD_TIME_SECS_GET, at, sizeof(*at), NULL, 56 0, NULL) < 0) { 57 warn("Couldn't fetch adapter time"); 58 at = 0; 59 } 60 } 61 62 static int 63 patrol_get_props(int fd, struct mfi_pr_properties *prop) 64 { 65 int error; 66 67 if (mfi_dcmd_command(fd, MFI_DCMD_PR_GET_PROPERTIES, prop, 68 sizeof(*prop), NULL, 0, NULL) < 0) { 69 error = errno; 70 warn("Failed to get patrol read properties"); 71 return (error); 72 } 73 return (0); 74 } 75 76 static int 77 show_patrol(int ac, char **av) 78 { 79 struct mfi_pr_properties prop; 80 struct mfi_pr_status status; 81 struct mfi_pd_list *list; 82 struct mfi_pd_info info; 83 char label[16]; 84 time_t now; 85 uint32_t at; 86 int error, fd; 87 u_int i; 88 89 fd = mfi_open(mfi_unit); 90 if (fd < 0) { 91 error = errno; 92 warn("mfi_open"); 93 return (error); 94 } 95 96 time(&now); 97 mfi_get_time(fd, &at); 98 error = patrol_get_props(fd, &prop); 99 if (error) 100 return (error); 101 printf("Operation Mode: "); 102 switch (prop.op_mode) { 103 case MFI_PR_OPMODE_AUTO: 104 printf("auto\n"); 105 break; 106 case MFI_PR_OPMODE_MANUAL: 107 printf("manual\n"); 108 break; 109 case MFI_PR_OPMODE_DISABLED: 110 printf("disabled\n"); 111 break; 112 default: 113 printf("??? (%02x)\n", prop.op_mode); 114 break; 115 } 116 if (prop.op_mode == MFI_PR_OPMODE_AUTO) { 117 if (at != 0 && prop.next_exec) 118 printf(" Next Run Starts: %s", adapter_time(now, at, 119 prop.next_exec)); 120 if (prop.exec_freq == 0xffffffff) 121 printf(" Runs Execute Continuously\n"); 122 else if (prop.exec_freq != 0) 123 printf(" Runs Start Every %u seconds\n", 124 prop.exec_freq); 125 } 126 127 if (mfi_dcmd_command(fd, MFI_DCMD_PR_GET_STATUS, &status, 128 sizeof(status), NULL, 0, NULL) < 0) { 129 error = errno; 130 warn("Failed to get patrol read properties"); 131 return (error); 132 } 133 printf("Runs Completed: %u\n", status.num_iteration); 134 printf("Current State: "); 135 switch (status.state) { 136 case MFI_PR_STATE_STOPPED: 137 printf("stopped\n"); 138 break; 139 case MFI_PR_STATE_READY: 140 printf("ready\n"); 141 break; 142 case MFI_PR_STATE_ACTIVE: 143 printf("active\n"); 144 break; 145 case MFI_PR_STATE_ABORTED: 146 printf("aborted\n"); 147 break; 148 default: 149 printf("??? (%02x)\n", status.state); 150 break; 151 } 152 if (status.state == MFI_PR_STATE_ACTIVE) { 153 if (mfi_pd_get_list(fd, &list, NULL) < 0) { 154 error = errno; 155 warn("Failed to get drive list"); 156 return (error); 157 } 158 159 for (i = 0; i < list->count; i++) { 160 if (list->addr[i].scsi_dev_type != 0) 161 continue; 162 163 if (mfi_pd_get_info(fd, list->addr[i].device_id, &info, 164 NULL) < 0) { 165 error = errno; 166 warn("Failed to fetch info for drive %u", 167 list->addr[i].device_id); 168 return (error); 169 } 170 if (info.prog_info.active & MFI_PD_PROGRESS_PATROL) { 171 snprintf(label, sizeof(label), " Drive %u", 172 list->addr[i].device_id); 173 mfi_display_progress(label, 174 &info.prog_info.patrol); 175 } 176 } 177 } 178 179 close(fd); 180 181 return (0); 182 } 183 MFI_COMMAND(show, patrol, show_patrol); 184 185 static int 186 start_patrol(int ac, char **av) 187 { 188 int error, fd; 189 190 fd = mfi_open(mfi_unit); 191 if (fd < 0) { 192 error = errno; 193 warn("mfi_open"); 194 return (error); 195 } 196 197 if (mfi_dcmd_command(fd, MFI_DCMD_PR_START, NULL, 0, NULL, 0, NULL) < 198 0) { 199 error = errno; 200 warn("Failed to start patrol read"); 201 return (error); 202 } 203 204 close(fd); 205 206 return (0); 207 } 208 MFI_COMMAND(start, patrol, start_patrol); 209 210 static int 211 stop_patrol(int ac, char **av) 212 { 213 int error, fd; 214 215 fd = mfi_open(mfi_unit); 216 if (fd < 0) { 217 error = errno; 218 warn("mfi_open"); 219 return (error); 220 } 221 222 if (mfi_dcmd_command(fd, MFI_DCMD_PR_STOP, NULL, 0, NULL, 0, NULL) < 223 0) { 224 error = errno; 225 warn("Failed to stop patrol read"); 226 return (error); 227 } 228 229 close(fd); 230 231 return (0); 232 } 233 MFI_COMMAND(stop, patrol, stop_patrol); 234 235 static int 236 patrol_config(int ac, char **av) 237 { 238 struct mfi_pr_properties prop; 239 long val; 240 time_t now; 241 int error, fd; 242 uint32_t at, next_exec, exec_freq; 243 char *cp; 244 uint8_t op_mode; 245 246 exec_freq = 0; /* GCC too stupid */ 247 next_exec = 0; 248 if (ac < 2) { 249 warnx("patrol: command required"); 250 return (EINVAL); 251 } 252 if (strcasecmp(av[1], "auto") == 0) { 253 op_mode = MFI_PR_OPMODE_AUTO; 254 if (ac > 2) { 255 if (strcasecmp(av[2], "continuously") == 0) 256 exec_freq = 0xffffffff; 257 else { 258 val = strtol(av[2], &cp, 0); 259 if (*cp != '\0') { 260 warnx("patrol: Invalid interval %s", 261 av[2]); 262 return (EINVAL); 263 } 264 exec_freq = val; 265 } 266 } 267 if (ac > 3) { 268 val = strtol(av[3], &cp, 0); 269 if (*cp != '\0' || val < 0) { 270 warnx("patrol: Invalid start time %s", av[3]); 271 return (EINVAL); 272 } 273 next_exec = val; 274 } 275 } else if (strcasecmp(av[1], "manual") == 0) 276 op_mode = MFI_PR_OPMODE_MANUAL; 277 else if (strcasecmp(av[1], "disable") == 0) 278 op_mode = MFI_PR_OPMODE_DISABLED; 279 else { 280 warnx("patrol: Invalid command %s", av[1]); 281 return (EINVAL); 282 } 283 284 fd = mfi_open(mfi_unit); 285 if (fd < 0) { 286 error = errno; 287 warn("mfi_open"); 288 return (error); 289 } 290 291 error = patrol_get_props(fd, &prop); 292 if (error) 293 return (error); 294 prop.op_mode = op_mode; 295 if (op_mode == MFI_PR_OPMODE_AUTO) { 296 if (ac > 2) 297 prop.exec_freq = exec_freq; 298 if (ac > 3) { 299 time(&now); 300 mfi_get_time(fd, &at); 301 if (at == 0) 302 return (ENXIO); 303 prop.next_exec = at + next_exec; 304 printf("Starting next patrol read at %s", 305 adapter_time(now, at, prop.next_exec)); 306 } 307 } 308 if (mfi_dcmd_command(fd, MFI_DCMD_PR_SET_PROPERTIES, &prop, 309 sizeof(prop), NULL, 0, NULL) < 0) { 310 error = errno; 311 warn("Failed to set patrol read properties"); 312 return (error); 313 } 314 315 close(fd); 316 317 return (0); 318 } 319 MFI_COMMAND(top, patrol, patrol_config); 320