1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #pragma ident "%Z%%M% %I% %E% SMI"
29
30 /*
31 * This file contains functions that implement the cache menu commands.
32 */
33 #include "global.h"
34 #include <sys/time.h>
35 #include <sys/resource.h>
36 #include <sys/wait.h>
37 #include <signal.h>
38 #include <string.h>
39 #include <sys/fcntl.h>
40 #include <sys/stat.h>
41
42 #include <sys/dklabel.h>
43
44 #include "main.h"
45 #include "analyze.h"
46 #include "menu.h"
47 #include "menu_cache.h"
48 #include "param.h"
49 #include "misc.h"
50 #include "label.h"
51 #include "startup.h"
52 #include "partition.h"
53 #include "prompts.h"
54 #include "checkdev.h"
55 #include "io.h"
56 #include "ctlr_scsi.h"
57 #include "auto_sense.h"
58 #include "hardware_structs.h"
59
60 extern struct menu_item menu_cache[];
61 extern struct menu_item menu_write_cache[];
62 extern struct menu_item menu_read_cache[];
63
64
65 int
c_cache()66 c_cache()
67 {
68 cur_menu++;
69 last_menu = cur_menu;
70 run_menu(menu_cache, "CACHE", "cache", 0);
71 cur_menu--;
72 return (0);
73 }
74
75 int
ca_write_cache()76 ca_write_cache()
77 {
78 cur_menu++;
79 last_menu = cur_menu;
80 run_menu(menu_write_cache, "WRITE_CACHE", "write_cache", 0);
81 cur_menu--;
82 return (0);
83 }
84
85 int
ca_read_cache()86 ca_read_cache()
87 {
88 cur_menu++;
89 last_menu = cur_menu;
90 run_menu(menu_read_cache, "READ_CACHE", "read_cache", 0);
91 cur_menu--;
92 return (0);
93 }
94
95 int
ca_write_display()96 ca_write_display()
97 {
98 struct mode_cache *page8;
99 struct scsi_ms_header header;
100 int status;
101 union {
102 struct mode_cache page8;
103 char rawbuf[MAX_MODE_SENSE_SIZE];
104 } u_page8;
105
106 page8 = &u_page8.page8;
107
108 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
109 MODE_SENSE_PC_CURRENT, (caddr_t)page8,
110 MAX_MODE_SENSE_SIZE, &header);
111
112 if (status == 0) {
113 if (page8->wce) {
114 fmt_print("Write Cache is enabled\n");
115 } else {
116 fmt_print("Write Cache is disabled\n");
117 }
118 } else {
119 err_print("Mode sense failed.\n");
120 }
121 return (0);
122 }
123
124 int
ca_write_enable()125 ca_write_enable()
126 {
127 struct mode_cache *page8;
128 struct scsi_ms_header header;
129 int status;
130 int length;
131 int sp_flags;
132 union {
133 struct mode_cache page8;
134 char rawbuf[MAX_MODE_SENSE_SIZE];
135 } u_page8;
136
137 page8 = &u_page8.page8;
138
139 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
140 MODE_SENSE_PC_CHANGEABLE, (caddr_t)page8,
141 MAX_MODE_SENSE_SIZE, &header);
142
143 if (status == 0) {
144 if (page8->wce) {
145 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
146 MODE_SENSE_PC_SAVED, (caddr_t)page8,
147 MAX_MODE_SENSE_SIZE, &header);
148 if (status != 0) {
149 status = uscsi_mode_sense(cur_file,
150 DAD_MODE_CACHE, MODE_SENSE_PC_CURRENT,
151 (caddr_t)page8, MAX_MODE_SENSE_SIZE, &header);
152 }
153
154 if (status == 0) {
155 length = MODESENSE_PAGE_LEN(page8);
156 sp_flags = MODE_SELECT_PF;
157 if (page8->mode_page.ps) {
158 sp_flags |= MODE_SELECT_SP;
159 } else {
160 err_print("\
161 This setting is valid until next reset only. It is not saved permanently.\n");
162 }
163 page8->mode_page.ps = 0;
164 page8->wce = 1;
165 header.mode_header.length = 0;
166 header.mode_header.device_specific = 0;
167 status = uscsi_mode_select(cur_file,
168 DAD_MODE_CACHE, sp_flags,
169 (caddr_t)page8, length, &header);
170 if (status != 0) {
171 err_print("Mode select failed\n");
172 return (0);
173 }
174 }
175 } else {
176 err_print("Write cache setting is not changeable\n");
177 }
178 }
179 if (status != 0) {
180 err_print("Mode sense failed.\n");
181 }
182 return (0);
183 }
184
185 int
ca_write_disable()186 ca_write_disable()
187 {
188 struct mode_cache *page8;
189 struct scsi_ms_header header;
190 int status;
191 int length;
192 int sp_flags;
193 union {
194 struct mode_cache page8;
195 char rawbuf[MAX_MODE_SENSE_SIZE];
196 } u_page8;
197
198 page8 = &u_page8.page8;
199
200 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
201 MODE_SENSE_PC_CHANGEABLE, (caddr_t)page8,
202 MAX_MODE_SENSE_SIZE, &header);
203
204 if (status == 0) {
205 if (page8->wce) {
206 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
207 MODE_SENSE_PC_SAVED, (caddr_t)page8,
208 MAX_MODE_SENSE_SIZE, &header);
209 if (status != 0) {
210 status = uscsi_mode_sense(cur_file,
211 DAD_MODE_CACHE, MODE_SENSE_PC_CURRENT,
212 (caddr_t)page8, MAX_MODE_SENSE_SIZE, &header);
213 }
214
215 if (status == 0) {
216 length = MODESENSE_PAGE_LEN(page8);
217 sp_flags = MODE_SELECT_PF;
218 if (page8->mode_page.ps) {
219 sp_flags |= MODE_SELECT_SP;
220 } else {
221 err_print("\
222 This setting is valid until next reset only. It is not saved permanently.\n");
223 }
224 page8->mode_page.ps = 0;
225 page8->wce = 0;
226 header.mode_header.length = 0;
227 header.mode_header.device_specific = 0;
228 status = uscsi_mode_select(cur_file,
229 DAD_MODE_CACHE, sp_flags,
230 (caddr_t)page8, length, &header);
231 if (status != 0) {
232 err_print("Mode select failed\n");
233 return (0);
234 }
235 }
236 } else {
237 err_print("Write cache setting is not changeable\n");
238 }
239 }
240 if (status != 0) {
241 err_print("Mode sense failed.\n");
242 }
243 return (0);
244 }
245
246 int
ca_read_display()247 ca_read_display()
248 {
249 struct mode_cache *page8;
250 struct scsi_ms_header header;
251 int status;
252 union {
253 struct mode_cache page8;
254 char rawbuf[MAX_MODE_SENSE_SIZE];
255 } u_page8;
256
257 page8 = &u_page8.page8;
258
259 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
260 MODE_SENSE_PC_CURRENT, (caddr_t)page8,
261 MAX_MODE_SENSE_SIZE, &header);
262
263 if (status == 0) {
264 if (page8->rcd) {
265 fmt_print("Read Cache is disabled\n");
266 } else {
267 fmt_print("Read Cache is enabled\n");
268 }
269 } else {
270 err_print("Mode sense failed.\n");
271 }
272 return (0);
273 }
274
275 int
ca_read_enable()276 ca_read_enable()
277 {
278 struct mode_cache *page8;
279 struct scsi_ms_header header;
280 int status;
281 int length;
282 int sp_flags;
283 union {
284 struct mode_cache page8;
285 char rawbuf[MAX_MODE_SENSE_SIZE];
286 } u_page8;
287
288 page8 = &u_page8.page8;
289
290 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
291 MODE_SENSE_PC_CHANGEABLE, (caddr_t)page8,
292 MAX_MODE_SENSE_SIZE, &header);
293
294 if (status == 0) {
295 if (page8->rcd) {
296 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
297 MODE_SENSE_PC_SAVED, (caddr_t)page8,
298 MAX_MODE_SENSE_SIZE, &header);
299 if (status != 0) {
300 status = uscsi_mode_sense(cur_file,
301 DAD_MODE_CACHE, MODE_SENSE_PC_CURRENT,
302 (caddr_t)page8, MAX_MODE_SENSE_SIZE, &header);
303 }
304
305 if (status == 0) {
306 length = MODESENSE_PAGE_LEN(page8);
307 sp_flags = MODE_SELECT_PF;
308 if (page8->mode_page.ps) {
309 sp_flags |= MODE_SELECT_SP;
310 } else {
311 err_print("\
312 This setting is valid until next reset only. It is not saved permanently.\n");
313 }
314 page8->mode_page.ps = 0;
315 page8->rcd = 0;
316 header.mode_header.length = 0;
317 header.mode_header.device_specific = 0;
318 status = uscsi_mode_select(cur_file,
319 DAD_MODE_CACHE, sp_flags,
320 (caddr_t)page8, length, &header);
321 if (status != 0) {
322 err_print("Mode select failed\n");
323 return (0);
324 }
325 }
326 } else {
327 err_print("Read cache setting is not changeable\n");
328 }
329 }
330 if (status != 0) {
331 err_print("Mode sense failed.\n");
332 }
333 return (0);
334 }
335
336 int
ca_read_disable()337 ca_read_disable()
338 {
339 struct mode_cache *page8;
340 struct scsi_ms_header header;
341 int status;
342 int length;
343 int sp_flags;
344 union {
345 struct mode_cache page8;
346 char rawbuf[MAX_MODE_SENSE_SIZE];
347 } u_page8;
348
349 page8 = &u_page8.page8;
350
351 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
352 MODE_SENSE_PC_CHANGEABLE, (caddr_t)page8,
353 MAX_MODE_SENSE_SIZE, &header);
354
355 if (status == 0) {
356 if (page8->rcd) {
357 status = uscsi_mode_sense(cur_file, DAD_MODE_CACHE,
358 MODE_SENSE_PC_SAVED, (caddr_t)page8,
359 MAX_MODE_SENSE_SIZE, &header);
360 if (status != 0) {
361 status = uscsi_mode_sense(cur_file,
362 DAD_MODE_CACHE, MODE_SENSE_PC_CURRENT,
363 (caddr_t)page8, MAX_MODE_SENSE_SIZE, &header);
364 }
365
366 if (status == 0) {
367 length = MODESENSE_PAGE_LEN(page8);
368 sp_flags = MODE_SELECT_PF;
369 if (page8->mode_page.ps) {
370 sp_flags |= MODE_SELECT_SP;
371 } else {
372 err_print("\
373 This setting is valid until next reset only. It is not saved permanently.\n");
374 }
375 page8->mode_page.ps = 0;
376 page8->rcd = 1;
377 header.mode_header.length = 0;
378 header.mode_header.device_specific = 0;
379 status = uscsi_mode_select(cur_file,
380 DAD_MODE_CACHE, sp_flags,
381 (caddr_t)page8, length, &header);
382 if (status != 0) {
383 err_print("Mode select failed\n");
384 return (0);
385 }
386 }
387 } else {
388 err_print("Read cache setting is not changeable\n");
389 }
390 }
391 if (status != 0) {
392 err_print("Mode sense failed.\n");
393 }
394 return (0);
395 }
396