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