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.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 <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 *props, uint8_t new_policy, 115 uint8_t mask) 116 { 117 int error; 118 uint8_t changes, policy; 119 120 policy = (props->default_cache_policy & ~mask) | new_policy; 121 if (policy == props->default_cache_policy) 122 return (0); 123 changes = policy ^ props->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 142 props->default_cache_policy = policy; 143 if (mfi_ld_set_props(fd, props) < 0) { 144 error = errno; 145 warn("Failed to set volume properties"); 146 return (error); 147 } 148 return (0); 149 } 150 151 static int 152 volume_cache(int ac, char **av) 153 { 154 struct mfi_ld_props props; 155 int error, fd; 156 uint8_t target_id, policy; 157 158 if (ac < 2) { 159 warnx("cache: volume required"); 160 return (EINVAL); 161 } 162 163 fd = mfi_open(mfi_unit); 164 if (fd < 0) { 165 error = errno; 166 warn("mfi_open"); 167 return (error); 168 } 169 170 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 171 error = errno; 172 warn("Invalid volume: %s", av[1]); 173 return (error); 174 } 175 176 if (mfi_ld_get_props(fd, target_id, &props) < 0) { 177 error = errno; 178 warn("Failed to fetch volume properties"); 179 return (error); 180 } 181 182 if (ac == 2) { 183 printf("mfi%u volume %s cache settings:\n", mfi_unit, 184 mfi_volume_name(fd, target_id)); 185 printf(" I/O caching: "); 186 switch (props.default_cache_policy & 187 (MR_LD_CACHE_ALLOW_WRITE_CACHE | 188 MR_LD_CACHE_ALLOW_READ_CACHE)) { 189 case 0: 190 printf("disabled\n"); 191 break; 192 case MR_LD_CACHE_ALLOW_WRITE_CACHE: 193 printf("writes\n"); 194 break; 195 case MR_LD_CACHE_ALLOW_READ_CACHE: 196 printf("reads\n"); 197 break; 198 case MR_LD_CACHE_ALLOW_WRITE_CACHE | 199 MR_LD_CACHE_ALLOW_READ_CACHE: 200 printf("writes and reads\n"); 201 break; 202 } 203 printf(" write caching: %s\n", 204 props.default_cache_policy & MR_LD_CACHE_WRITE_BACK ? 205 "write-back" : "write-through"); 206 printf(" read ahead: %s\n", 207 props.default_cache_policy & MR_LD_CACHE_READ_AHEAD ? 208 (props.default_cache_policy & MR_LD_CACHE_READ_ADAPTIVE ? 209 "adaptive" : "always") : "none"); 210 printf("drive write cache: "); 211 switch (props.disk_cache_policy) { 212 case MR_PD_CACHE_UNCHANGED: 213 printf("default\n"); 214 break; 215 case MR_PD_CACHE_ENABLE: 216 printf("enabled\n"); 217 break; 218 case MR_PD_CACHE_DISABLE: 219 printf("disabled\n"); 220 break; 221 default: 222 printf("??? %d\n", props.disk_cache_policy); 223 break; 224 } 225 if (props.default_cache_policy != props.current_cache_policy) 226 printf("Cache Disabled Due to Dead Battery\n"); 227 error = 0; 228 } else { 229 if (strcmp(av[2], "all") == 0 || strcmp(av[2], "enable") == 0) 230 error = update_cache_policy(fd, &props, 231 MR_LD_CACHE_ALLOW_READ_CACHE | 232 MR_LD_CACHE_ALLOW_WRITE_CACHE, 233 MR_LD_CACHE_ALLOW_READ_CACHE | 234 MR_LD_CACHE_ALLOW_WRITE_CACHE); 235 else if (strcmp(av[2], "none") == 0 || 236 strcmp(av[2], "disable") == 0) 237 error = update_cache_policy(fd, &props, 0, 238 MR_LD_CACHE_ALLOW_READ_CACHE | 239 MR_LD_CACHE_ALLOW_WRITE_CACHE); 240 else if (strcmp(av[2], "reads") == 0) 241 error = update_cache_policy(fd, &props, 242 MR_LD_CACHE_ALLOW_READ_CACHE, 243 MR_LD_CACHE_ALLOW_READ_CACHE | 244 MR_LD_CACHE_ALLOW_WRITE_CACHE); 245 else if (strcmp(av[2], "writes") == 0) 246 error = update_cache_policy(fd, &props, 247 MR_LD_CACHE_ALLOW_WRITE_CACHE, 248 MR_LD_CACHE_ALLOW_READ_CACHE | 249 MR_LD_CACHE_ALLOW_WRITE_CACHE); 250 else if (strcmp(av[2], "write-back") == 0) 251 error = update_cache_policy(fd, &props, 252 MR_LD_CACHE_WRITE_BACK, 253 MR_LD_CACHE_WRITE_BACK); 254 else if (strcmp(av[2], "write-through") == 0) 255 error = update_cache_policy(fd, &props, 0, 256 MR_LD_CACHE_WRITE_BACK); 257 else if (strcmp(av[2], "read-ahead") == 0) { 258 if (ac < 4) { 259 warnx("cache: read-ahead setting required"); 260 return (EINVAL); 261 } 262 if (strcmp(av[3], "none") == 0) 263 policy = 0; 264 else if (strcmp(av[3], "always") == 0) 265 policy = MR_LD_CACHE_READ_AHEAD; 266 else if (strcmp(av[3], "adaptive") == 0) 267 policy = MR_LD_CACHE_READ_AHEAD | 268 MR_LD_CACHE_READ_ADAPTIVE; 269 else { 270 warnx("cache: invalid read-ahead setting"); 271 return (EINVAL); 272 } 273 error = update_cache_policy(fd, &props, policy, 274 MR_LD_CACHE_READ_AHEAD | 275 MR_LD_CACHE_READ_ADAPTIVE); 276 } else if (strcmp(av[2], "write-cache") == 0) { 277 if (ac < 4) { 278 warnx("cache: write-cache setting required"); 279 return (EINVAL); 280 } 281 if (strcmp(av[3], "enable") == 0) 282 policy = MR_PD_CACHE_ENABLE; 283 else if (strcmp(av[3], "disable") == 0) 284 policy = MR_PD_CACHE_DISABLE; 285 else if (strcmp(av[3], "default") == 0) 286 policy = MR_PD_CACHE_UNCHANGED; 287 else { 288 warnx("cache: invalid write-cache setting"); 289 return (EINVAL); 290 } 291 error = 0; 292 if (policy != props.disk_cache_policy) { 293 switch (policy) { 294 case MR_PD_CACHE_ENABLE: 295 printf("Enabling write-cache on physical drives\n"); 296 break; 297 case MR_PD_CACHE_DISABLE: 298 printf("Disabling write-cache on physical drives\n"); 299 break; 300 case MR_PD_CACHE_UNCHANGED: 301 printf("Using default write-cache setting on physical drives\n"); 302 break; 303 } 304 props.disk_cache_policy = policy; 305 if (mfi_ld_set_props(fd, &props) < 0) { 306 error = errno; 307 warn("Failed to set volume properties"); 308 } 309 } 310 } else { 311 warnx("cache: Invalid command"); 312 return (EINVAL); 313 } 314 } 315 close(fd); 316 317 return (error); 318 } 319 MFI_COMMAND(top, cache, volume_cache); 320 321 static int 322 volume_name(int ac, char **av) 323 { 324 struct mfi_ld_props props; 325 int error, fd; 326 uint8_t target_id; 327 328 if (ac != 3) { 329 warnx("name: volume and name required"); 330 return (EINVAL); 331 } 332 333 if (strlen(av[2]) >= sizeof(props.name)) { 334 warnx("name: new name is too long"); 335 return (ENOSPC); 336 } 337 338 fd = mfi_open(mfi_unit); 339 if (fd < 0) { 340 error = errno; 341 warn("mfi_open"); 342 return (error); 343 } 344 345 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 346 error = errno; 347 warn("Invalid volume: %s", av[1]); 348 return (error); 349 } 350 351 if (mfi_ld_get_props(fd, target_id, &props) < 0) { 352 error = errno; 353 warn("Failed to fetch volume properties"); 354 return (error); 355 } 356 357 printf("mfi%u volume %s name changed from \"%s\" to \"%s\"\n", mfi_unit, 358 mfi_volume_name(fd, target_id), props.name, av[2]); 359 bzero(props.name, sizeof(props.name)); 360 strcpy(props.name, av[2]); 361 if (mfi_ld_set_props(fd, &props) < 0) { 362 error = errno; 363 warn("Failed to set volume properties"); 364 return (error); 365 } 366 367 close(fd); 368 369 return (0); 370 } 371 MFI_COMMAND(top, name, volume_name); 372 373 static int 374 volume_progress(int ac, char **av) 375 { 376 struct mfi_ld_info info; 377 int error, fd; 378 uint8_t target_id; 379 380 if (ac != 2) { 381 warnx("volume progress: %s", ac > 2 ? "extra arguments" : 382 "volume required"); 383 return (EINVAL); 384 } 385 386 fd = mfi_open(mfi_unit); 387 if (fd < 0) { 388 error = errno; 389 warn("mfi_open"); 390 return (error); 391 } 392 393 if (mfi_lookup_volume(fd, av[1], &target_id) < 0) { 394 error = errno; 395 warn("Invalid volume: %s", av[1]); 396 return (error); 397 } 398 399 /* Get the info for this drive. */ 400 if (mfi_ld_get_info(fd, target_id, &info, NULL) < 0) { 401 error = errno; 402 warn("Failed to fetch info for volume %s", 403 mfi_volume_name(fd, target_id)); 404 return (error); 405 } 406 407 /* Display any of the active events. */ 408 if (info.progress.active & MFI_LD_PROGRESS_CC) 409 mfi_display_progress("Consistency Check", &info.progress.cc); 410 if (info.progress.active & MFI_LD_PROGRESS_BGI) 411 mfi_display_progress("Background Init", &info.progress.bgi); 412 if (info.progress.active & MFI_LD_PROGRESS_FGI) 413 mfi_display_progress("Foreground Init", &info.progress.fgi); 414 if (info.progress.active & MFI_LD_PROGRESS_RECON) 415 mfi_display_progress("Reconstruction", &info.progress.recon); 416 if ((info.progress.active & (MFI_LD_PROGRESS_CC | MFI_LD_PROGRESS_BGI | 417 MFI_LD_PROGRESS_FGI | MFI_LD_PROGRESS_RECON)) == 0) 418 printf("No activity in progress for volume %s.\n", 419 mfi_volume_name(fd, target_id)); 420 close(fd); 421 422 return (0); 423 } 424 MFI_COMMAND(volume, progress, volume_progress); 425