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_volume.c,v 1.5 2011/09/02 16:00:51 jhb Exp $ 30 */ 31 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <err.h> 35 #include <libutil.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <unistd.h> 40 #include "mfiutil.h" 41 42 MFI_TABLE(top, volume); 43 44 const char * 45 mfi_ldstate(enum mfi_ld_state state) 46 { 47 static char buf[16]; 48 49 switch (state) { 50 case MFI_LD_STATE_OFFLINE: 51 return ("OFFLINE"); 52 case MFI_LD_STATE_PARTIALLY_DEGRADED: 53 return ("PARTIALLY DEGRADED"); 54 case MFI_LD_STATE_DEGRADED: 55 return ("DEGRADED"); 56 case MFI_LD_STATE_OPTIMAL: 57 return ("OPTIMAL"); 58 default: 59 sprintf(buf, "LSTATE 0x%02x", state); 60 return (buf); 61 } 62 } 63 64 void 65 mbox_store_ldref(uint8_t *mbox, union mfi_ld_ref *ref) 66 { 67 68 mbox[0] = ref->v.target_id; 69 mbox[1] = ref->v.reserved; 70 mbox[2] = ref->v.seq & 0xff; 71 mbox[3] = ref->v.seq >> 8; 72 } 73 74 int 75 mfi_ld_get_list(int fd, struct mfi_ld_list *list, uint8_t *statusp) 76 { 77 78 return (mfi_dcmd_command(fd, MFI_DCMD_LD_GET_LIST, list, 79 sizeof(struct mfi_ld_list), NULL, 0, statusp)); 80 } 81 82 int 83 mfi_ld_get_info(int fd, uint8_t target_id, struct mfi_ld_info *info, 84 uint8_t *statusp) 85 { 86 uint8_t mbox[1]; 87 88 mbox[0] = target_id; 89 return (mfi_dcmd_command(fd, MFI_DCMD_LD_GET_INFO, info, 90 sizeof(struct mfi_ld_info), mbox, 1, statusp)); 91 } 92 93 static int 94 mfi_ld_get_props(int fd, uint8_t target_id, struct mfi_ld_props *props) 95 { 96 uint8_t mbox[1]; 97 98 mbox[0] = target_id; 99 return (mfi_dcmd_command(fd, MFI_DCMD_LD_GET_PROP, props, 100 sizeof(struct mfi_ld_props), mbox, 1, NULL)); 101 } 102 103 static int 104 mfi_ld_set_props(int fd, struct mfi_ld_props *props) 105 { 106 uint8_t mbox[4]; 107 108 mbox_store_ldref(mbox, &props->ld); 109 return (mfi_dcmd_command(fd, MFI_DCMD_LD_SET_PROP, props, 110 sizeof(struct mfi_ld_props), mbox, 4, NULL)); 111 } 112 113 static int 114 update_cache_policy(int fd, struct mfi_ld_props *old, struct mfi_ld_props *new) 115 { 116 int error; 117 uint8_t changes, policy; 118 119 if (old->default_cache_policy == new->default_cache_policy && 120 old->disk_cache_policy == new->disk_cache_policy) 121 return (0); 122 policy = new->default_cache_policy; 123 changes = policy ^ old->default_cache_policy; 124 if (changes & MR_LD_CACHE_ALLOW_WRITE_CACHE) 125 printf("%s caching of I/O writes\n", 126 policy & MR_LD_CACHE_ALLOW_WRITE_CACHE ? "Enabling" : 127 "Disabling"); 128 if (changes & MR_LD_CACHE_ALLOW_READ_CACHE) 129 printf("%s caching of I/O reads\n", 130 policy & MR_LD_CACHE_ALLOW_READ_CACHE ? "Enabling" : 131 "Disabling"); 132 if (changes & MR_LD_CACHE_WRITE_BACK) 133 printf("Setting write cache policy to %s\n", 134 policy & MR_LD_CACHE_WRITE_BACK ? "write-back" : 135 "write-through"); 136 if (changes & (MR_LD_CACHE_READ_AHEAD | MR_LD_CACHE_READ_ADAPTIVE)) 137 printf("Setting read ahead policy to %s\n", 138 policy & MR_LD_CACHE_READ_AHEAD ? 139 (policy & MR_LD_CACHE_READ_ADAPTIVE ? 140 "adaptive" : "always") : "none"); 141 if (changes & MR_LD_CACHE_WRITE_CACHE_BAD_BBU) 142 printf("%s write caching with bad BBU\n", 143 policy & MR_LD_CACHE_WRITE_CACHE_BAD_BBU ? "Enabling" : 144 "Disabling"); 145 if (old->disk_cache_policy != new->disk_cache_policy) { 146 switch (new->disk_cache_policy) { 147 case MR_PD_CACHE_ENABLE: 148 printf("Enabling write-cache on physical drives\n"); 149 break; 150 case MR_PD_CACHE_DISABLE: 151 printf("Disabling write-cache on physical drives\n"); 152 break; 153 case MR_PD_CACHE_UNCHANGED: 154 printf("Using default write-cache setting on physical drives\n"); 155 break; 156 } 157 } 158 159 if (mfi_ld_set_props(fd, new) < 0) { 160 error = errno; 161 warn("Failed to set volume properties"); 162 return (error); 163 } 164 return (0); 165 } 166 167 static void 168 stage_cache_setting(struct mfi_ld_props *props, uint8_t new_policy, 169 uint8_t mask) 170 { 171 172 props->default_cache_policy &= ~mask; 173 props->default_cache_policy |= new_policy; 174 } 175 176 /* 177 * Parse a single cache directive modifying the passed in policy. 178 * Returns -1 on a parse error and the number of arguments consumed 179 * on success. 180 */ 181 static int 182 process_cache_command(int ac, char **av, struct mfi_ld_props *props) 183 { 184 uint8_t policy; 185 186 /* I/O cache settings. */ 187 if (strcmp(av[0], "all") == 0 || strcmp(av[0], "enable") == 0) { 188 stage_cache_setting(props, MR_LD_CACHE_ALLOW_READ_CACHE | 189 MR_LD_CACHE_ALLOW_WRITE_CACHE, 190 MR_LD_CACHE_ALLOW_READ_CACHE | 191 MR_LD_CACHE_ALLOW_WRITE_CACHE); 192 return (1); 193 } 194 if (strcmp(av[0], "none") == 0 || strcmp(av[0], "disable") == 0) { 195 stage_cache_setting(props, 0, MR_LD_CACHE_ALLOW_READ_CACHE | 196 MR_LD_CACHE_ALLOW_WRITE_CACHE); 197 return (1); 198 } 199 if (strcmp(av[0], "reads") == 0) { 200 stage_cache_setting(props, MR_LD_CACHE_ALLOW_READ_CACHE, 201 MR_LD_CACHE_ALLOW_READ_CACHE | 202 MR_LD_CACHE_ALLOW_WRITE_CACHE); 203 return (1); 204 } 205 if (strcmp(av[0], "writes") == 0) { 206 stage_cache_setting(props, MR_LD_CACHE_ALLOW_WRITE_CACHE, 207 MR_LD_CACHE_ALLOW_READ_CACHE | 208 MR_LD_CACHE_ALLOW_WRITE_CACHE); 209 return (1); 210 } 211 212 /* Write cache behavior. */ 213 if (strcmp(av[0], "write-back") == 0) { 214 stage_cache_setting(props, MR_LD_CACHE_WRITE_BACK, 215 MR_LD_CACHE_WRITE_BACK); 216 return (1); 217 } 218 if (strcmp(av[0], "write-through") == 0) { 219 stage_cache_setting(props, 0, MR_LD_CACHE_WRITE_BACK); 220 return (1); 221 } 222 if (strcmp(av[0], "bad-bbu-write-cache") == 0) { 223 if (ac < 2) { 224 warnx("cache: bad BBU setting required"); 225 return (-1); 226 } 227 if (strcmp(av[1], "enable") == 0) 228 policy = MR_LD_CACHE_WRITE_CACHE_BAD_BBU; 229 else if (strcmp(av[1], "disable") == 0) 230 policy = 0; 231 else { 232 warnx("cache: invalid bad BBU setting"); 233 return (-1); 234 } 235 stage_cache_setting(props, policy, 236 MR_LD_CACHE_WRITE_CACHE_BAD_BBU); 237 return (2); 238 } 239 240 /* Read cache behavior. */ 241 if (strcmp(av[0], "read-ahead") == 0) { 242 if (ac < 2) { 243 warnx("cache: read-ahead setting required"); 244 return (-1); 245 } 246 if (strcmp(av[1], "none") == 0) 247 policy = 0; 248 else if (strcmp(av[1], "always") == 0) 249 policy = MR_LD_CACHE_READ_AHEAD; 250 else if (strcmp(av[1], "adaptive") == 0) 251 policy = MR_LD_CACHE_READ_AHEAD | 252 MR_LD_CACHE_READ_ADAPTIVE; 253 else { 254 warnx("cache: invalid read-ahead setting"); 255 return (-1); 256 } 257 stage_cache_setting(props, policy, MR_LD_CACHE_READ_AHEAD | 258 MR_LD_CACHE_READ_ADAPTIVE); 259 return (2); 260 } 261 262 /* Drive write-cache behavior. */ 263 if (strcmp(av[0], "write-cache") == 0) { 264 if (ac < 2) { 265 warnx("cache: write-cache setting required"); 266 return (-1); 267 } 268 if (strcmp(av[1], "enable") == 0) 269 props->disk_cache_policy = MR_PD_CACHE_ENABLE; 270 else if (strcmp(av[1], "disable") == 0) 271 props->disk_cache_policy = MR_PD_CACHE_DISABLE; 272 else if (strcmp(av[1], "default") == 0) 273 props->disk_cache_policy = MR_PD_CACHE_UNCHANGED; 274 else { 275 warnx("cache: invalid write-cache setting"); 276 return (-1); 277 } 278 return (2); 279 } 280 281 warnx("cache: Invalid command"); 282 return (-1); 283 } 284 285 static int 286 volume_cache(int ac, char **av) 287 { 288 struct mfi_ld_props props, new; 289 int error, fd, consumed; 290 uint8_t target_id; 291 292 if (ac < 2) { 293 warnx("cache: volume required"); 294 return (EINVAL); 295 } 296 297 fd = mfi_open(mfi_unit); 298 if (fd < 0) { 299 error = errno; 300 warn("mfi_open"); 301 return (error); 302 } 303 304 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 305 error = errno; 306 warn("Invalid volume: %s", av[1]); 307 close(fd); 308 return (error); 309 } 310 311 if (mfi_ld_get_props(fd, target_id, &props) < 0) { 312 error = errno; 313 warn("Failed to fetch volume properties"); 314 close(fd); 315 return (error); 316 } 317 318 if (ac == 2) { 319 printf("mfi%u volume %s cache settings:\n", mfi_unit, 320 mfi_volume_name(fd, target_id)); 321 printf(" I/O caching: "); 322 switch (props.default_cache_policy & 323 (MR_LD_CACHE_ALLOW_WRITE_CACHE | 324 MR_LD_CACHE_ALLOW_READ_CACHE)) { 325 case 0: 326 printf("disabled\n"); 327 break; 328 case MR_LD_CACHE_ALLOW_WRITE_CACHE: 329 printf("writes\n"); 330 break; 331 case MR_LD_CACHE_ALLOW_READ_CACHE: 332 printf("reads\n"); 333 break; 334 case MR_LD_CACHE_ALLOW_WRITE_CACHE | 335 MR_LD_CACHE_ALLOW_READ_CACHE: 336 printf("writes and reads\n"); 337 break; 338 } 339 printf(" write caching: %s\n", 340 props.default_cache_policy & MR_LD_CACHE_WRITE_BACK ? 341 "write-back" : "write-through"); 342 printf("write cache with bad BBU: %s\n", 343 props.default_cache_policy & 344 MR_LD_CACHE_WRITE_CACHE_BAD_BBU ? "enabled" : "disabled"); 345 printf(" read ahead: %s\n", 346 props.default_cache_policy & MR_LD_CACHE_READ_AHEAD ? 347 (props.default_cache_policy & MR_LD_CACHE_READ_ADAPTIVE ? 348 "adaptive" : "always") : "none"); 349 printf(" drive write cache: "); 350 switch (props.disk_cache_policy) { 351 case MR_PD_CACHE_UNCHANGED: 352 printf("default\n"); 353 break; 354 case MR_PD_CACHE_ENABLE: 355 printf("enabled\n"); 356 break; 357 case MR_PD_CACHE_DISABLE: 358 printf("disabled\n"); 359 break; 360 default: 361 printf("??? %d\n", props.disk_cache_policy); 362 break; 363 } 364 if (props.default_cache_policy != props.current_cache_policy) 365 printf("Cache Disabled Due to Dead Battery\n"); 366 error = 0; 367 } else { 368 new = props; 369 av += 2; 370 ac -= 2; 371 while (ac > 0) { 372 consumed = process_cache_command(ac, av, &new); 373 if (consumed < 0) { 374 close(fd); 375 return (EINVAL); 376 } 377 av += consumed; 378 ac -= consumed; 379 } 380 error = update_cache_policy(fd, &props, &new); 381 } 382 close(fd); 383 384 return (error); 385 } 386 MFI_COMMAND(top, cache, volume_cache); 387 388 static int 389 volume_name(int ac, char **av) 390 { 391 struct mfi_ld_props props; 392 int error, fd; 393 uint8_t target_id; 394 395 if (ac != 3) { 396 warnx("name: volume and name required"); 397 return (EINVAL); 398 } 399 400 if (strlen(av[2]) >= sizeof(props.name)) { 401 warnx("name: new name is too long"); 402 return (ENOSPC); 403 } 404 405 fd = mfi_open(mfi_unit); 406 if (fd < 0) { 407 error = errno; 408 warn("mfi_open"); 409 return (error); 410 } 411 412 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 413 error = errno; 414 warn("Invalid volume: %s", av[1]); 415 close(fd); 416 return (error); 417 } 418 419 if (mfi_ld_get_props(fd, target_id, &props) < 0) { 420 error = errno; 421 warn("Failed to fetch volume properties"); 422 close(fd); 423 return (error); 424 } 425 426 printf("mfi%u volume %s name changed from \"%s\" to \"%s\"\n", mfi_unit, 427 mfi_volume_name(fd, target_id), props.name, av[2]); 428 bzero(props.name, sizeof(props.name)); 429 strcpy(props.name, av[2]); 430 if (mfi_ld_set_props(fd, &props) < 0) { 431 error = errno; 432 warn("Failed to set volume properties"); 433 close(fd); 434 return (error); 435 } 436 437 close(fd); 438 439 return (0); 440 } 441 MFI_COMMAND(top, name, volume_name); 442 443 static int 444 volume_progress(int ac, char **av) 445 { 446 struct mfi_ld_info info; 447 int error, fd; 448 uint8_t target_id; 449 450 if (ac != 2) { 451 warnx("volume progress: %s", ac > 2 ? "extra arguments" : 452 "volume required"); 453 return (EINVAL); 454 } 455 456 fd = mfi_open(mfi_unit); 457 if (fd < 0) { 458 error = errno; 459 warn("mfi_open"); 460 return (error); 461 } 462 463 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 464 error = errno; 465 warn("Invalid volume: %s", av[1]); 466 close(fd); 467 return (error); 468 } 469 470 /* Get the info for this drive. */ 471 if (mfi_ld_get_info(fd, target_id, &info, NULL) < 0) { 472 error = errno; 473 warn("Failed to fetch info for volume %s", 474 mfi_volume_name(fd, target_id)); 475 close(fd); 476 return (error); 477 } 478 479 /* Display any of the active events. */ 480 if (info.progress.active & MFI_LD_PROGRESS_CC) 481 mfi_display_progress("Consistency Check", &info.progress.cc); 482 if (info.progress.active & MFI_LD_PROGRESS_BGI) 483 mfi_display_progress("Background Init", &info.progress.bgi); 484 if (info.progress.active & MFI_LD_PROGRESS_FGI) 485 mfi_display_progress("Foreground Init", &info.progress.fgi); 486 if (info.progress.active & MFI_LD_PROGRESS_RECON) 487 mfi_display_progress("Reconstruction", &info.progress.recon); 488 if ((info.progress.active & (MFI_LD_PROGRESS_CC | MFI_LD_PROGRESS_BGI | 489 MFI_LD_PROGRESS_FGI | MFI_LD_PROGRESS_RECON)) == 0) 490 printf("No activity in progress for volume %s.\n", 491 mfi_volume_name(fd, target_id)); 492 close(fd); 493 494 return (0); 495 } 496 MFI_COMMAND(volume, progress, volume_progress); 497