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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * rmf_menu.c :
28 * Command line options to rmformat are processed in this file.
29 */
30
31 #include "rmformat.h"
32 #include <sys/smedia.h>
33 #include <priv_utils.h>
34
35 extern int32_t D_flag;
36 extern int32_t e_flag;
37 extern int32_t H_flag;
38 extern int32_t U_flag;
39 extern int32_t V_flag;
40 extern int32_t b_flag;
41 extern int32_t w_flag;
42 extern int32_t W_flag;
43 extern int32_t s_flag;
44 extern int32_t c_flag;
45 extern int32_t F_flag;
46 extern int32_t R_flag;
47 extern int32_t p_flag;
48 extern int32_t l_flag;
49
50 extern char *myname;
51 extern char *slice_file;
52 extern diskaddr_t repair_blk_no;
53 extern int32_t quick_format;
54 extern int32_t long_format;
55 extern int32_t force_format;
56 extern int32_t rw_protect_enable;
57 extern int32_t rw_protect_disable;
58 extern int32_t wp_enable_passwd;
59 extern int32_t wp_disable_passwd;
60 extern int32_t wp_enable;
61 extern int32_t wp_disable;
62 extern int32_t verify_write;
63 extern char *dev_name;
64 extern char *label;
65 extern int total_devices_found;
66 extern int removable_found;
67 char *global_intr_msg;
68 smmedium_prop_t med_info;
69 int vol_running;
70
71 extern void check_invalid_combinations();
72 extern void check_invalid_combinations_again(int32_t);
73 extern void process_options();
74 extern void get_passwd(struct smwp_state *wp, int32_t confirm);
75 extern int32_t valid_slice_file(smedia_handle_t, int32_t, char *,
76 struct extvtoc *);
77 extern void trap_SIGINT();
78 extern void release_SIGINT();
79 extern int32_t verify(smedia_handle_t handle, int32_t fd,
80 diskaddr_t start_sector, uint32_t nblocks,
81 char *buf, int32_t flag, int32_t blocksize, int32_t no_raw_rw);
82 extern void my_perror(char *err_string);
83 extern void write_default_label(smedia_handle_t, int32_t fd);
84 extern int find_device(int defer, char *tmpstr);
85
86 void overwrite_metadata(int32_t fd, smedia_handle_t handle);
87
88 int32_t write_sunos_label(int32_t fd, int32_t media_type);
89
90 int32_t my_open(char *device_name, int32_t flags);
91 int32_t check_and_unmount_vold(char *device_name, int32_t flag);
92 int32_t check_and_unmount_scsi(char *device_name, int32_t flag);
93
94 int32_t check_and_unmount_floppy(int32_t fd, int32_t flag);
95 int32_t get_confirmation(void);
96
97
98 static void process_F_flag(smedia_handle_t handle, int32_t fd);
99 static void process_w_flag(smedia_handle_t handle);
100 static void process_W_flag(smedia_handle_t handle);
101 static void process_R_flag(smedia_handle_t handle);
102 void process_p_flag(smedia_handle_t handle, int32_t fd);
103 static void process_c_flag(smedia_handle_t handle);
104 static void process_V_flag(smedia_handle_t handle, int32_t fd);
105 static void process_s_flag(smedia_handle_t, int32_t fd);
106 static void process_e_flag(smedia_handle_t handle);
107 static void process_H_flag(smedia_handle_t handle, int32_t fd);
108 static void process_D_flag(smedia_handle_t handle, int32_t fd);
109 static void process_b_flag(int32_t fd);
110 static void process_l_flag(void);
111
112 void
113 process_options()
114 {
115 int32_t fd;
116 smedia_handle_t handle;
117 int32_t m_scsi_umount = 0;
118 int32_t m_flp_umount = 0;
119 int32_t v_device_umount = 0;
120 int32_t umount_required = 0;
121 int32_t removable;
122 int32_t umount_failed = 0;
123 struct dk_minfo media;
124
125 check_invalid_combinations();
126
127 if (l_flag && !dev_name) {
128 process_l_flag();
129 return;
130 }
131
132 if (U_flag) {
133 if (!(F_flag || H_flag || D_flag)) {
134 F_flag = 1;
135 long_format = 1;
136 }
137 }
138
139 if (F_flag || w_flag || W_flag || R_flag || D_flag || H_flag ||
140 V_flag || c_flag || b_flag || s_flag || e_flag) {
141 umount_required = 1;
142 }
143
144 fd = my_open(dev_name, O_RDONLY|O_NDELAY);
145 if (fd < 0) {
146 PERROR("Could not open device");
147 (void) close(fd);
148 exit(1);
149 }
150
151 if (ioctl(fd, DKIOCREMOVABLE, &removable) < 0) {
152 PERROR("DKIOCREMOVABLE ioctl failed");
153 (void) close(fd);
154 exit(1);
155 }
156 if (!removable) {
157 (void) fprintf(stderr,
158 gettext("Not a removable media device\n"));
159 (void) close(fd);
160 exit(1);
161 }
162
163 if (ioctl(fd, DKIOCGMEDIAINFO, &media) < 0) {
164 (void) fprintf(stderr,
165 gettext("No media in specified device\n"));
166 (void) close(fd);
167 exit(1);
168 }
169
170 /* Check if volume manager has mounted this */
171 if (umount_required) {
172 v_device_umount = check_and_unmount_vold(dev_name, U_flag);
173 if (v_device_umount != 1) {
174 m_scsi_umount = check_and_unmount_scsi(dev_name,
175 U_flag);
176 if (m_scsi_umount != 1) {
177 m_flp_umount = check_and_unmount_floppy(fd,
178 U_flag);
179 if (m_flp_umount != 1) {
180 umount_failed = 1;
181 }
182 }
183 }
184 }
185
186 if (umount_required && U_flag && umount_failed) {
187 if (v_device_umount || m_scsi_umount || m_flp_umount) {
188 (void) fprintf(stderr,
189 gettext("Could not unmount device.\n"));
190 (void) close(fd);
191 exit(1);
192 }
193 }
194
195 if (umount_required && !U_flag) {
196 if (v_device_umount || m_scsi_umount || m_flp_umount) {
197 (void) fprintf(stderr, gettext("Device mounted.\n"));
198 (void) fprintf(stderr,
199 gettext("Requested operation can not be \
200 performed on a mounted device.\n"));
201 (void) close(fd);
202 exit(1);
203 }
204 }
205 /* register the fd with the libsmedia */
206 handle = smedia_get_handle(fd);
207 if (handle == NULL) {
208 (void) fprintf(stderr,
209 gettext("Failed to get libsmedia handle.\n"));
210 (void) close(fd);
211 exit(1);
212 }
213
214 if (smedia_get_medium_property(handle, &med_info) < 0) {
215 (void) fprintf(stderr,
216 gettext("Get medium property failed \n"));
217 (void) smedia_release_handle(handle);
218 (void) close(fd);
219 exit(1);
220 }
221
222 DPRINTF1("media type %x\n", med_info.sm_media_type);
223 DPRINTF1("media block size %x\n", med_info.sm_blocksize);
224 DPRINTF1("media capacity %u\n", (uint32_t)med_info.sm_capacity);
225 DPRINTF3("media cyl %d head %d sect %d\n",
226 med_info.sm_pcyl, med_info.sm_nhead, med_info.sm_nsect);
227 check_invalid_combinations_again(med_info.sm_media_type);
228
229 /*
230 * Special handling for pcmcia, sometimes open the file in
231 * read-write mode.
232 */
233
234 if (med_info.sm_media_type == SM_PCMCIA_MEM) {
235 if (F_flag || H_flag || D_flag || (V_flag && verify_write)) {
236 (void) close(fd);
237 DPRINTF("Reopening device\n");
238 fd = my_open(dev_name, O_RDWR|O_NDELAY);
239 if (fd < 0) {
240 PERROR("Could not open device");
241 (void) smedia_release_handle(handle);
242 (void) close(fd);
243 exit(1);
244 }
245 }
246 }
247
248 if (med_info.sm_media_type == SM_PCMCIA_ATA) {
249 if (V_flag || c_flag) {
250 (void) fprintf(stderr,
251 gettext("Option not supported on PC ATA cards\n"));
252 (void) smedia_release_handle(handle);
253 (void) close(fd);
254 exit(1);
255 }
256 if (F_flag) {
257 /* same text as used by the format command */
258 (void) fprintf(stderr,
259 gettext("Cannot format this drive. Please use your \
260 Manufacturer supplied formatting utility.\n"));
261 (void) smedia_release_handle(handle);
262 (void) close(fd);
263 exit(1);
264 }
265 }
266
267 if (F_flag)
268 process_F_flag(handle, fd);
269 if (w_flag)
270 process_w_flag(handle);
271 if (W_flag)
272 process_W_flag(handle);
273 if (R_flag)
274 process_R_flag(handle);
275 if (p_flag)
276 process_p_flag(handle, fd);
277 if (D_flag)
278 process_D_flag(handle, fd);
279 if (H_flag)
280 process_H_flag(handle, fd);
281 if (V_flag)
282 process_V_flag(handle, fd);
283 if (c_flag)
284 process_c_flag(handle);
285 if (b_flag)
286 process_b_flag(fd);
287 if (s_flag)
288 process_s_flag(handle, fd);
289 if (e_flag)
290 process_e_flag(handle);
291 if (l_flag) {
292 process_l_flag();
293 }
294
295 (void) smedia_release_handle(handle);
296 (void) close(fd);
297 }
298
299 /*
300 * This routine handles the F_flag.
301 * This options should not be used for floppy. However,
302 * if this option is used for floppy, the option will
303 * be forced to SM_FORMAT_HD and smedia_format is called.
304 * Note that smedia_format is a blocked mode format and it
305 * returns only after the complete formatting is over.
306 */
307
308 static void
309 process_F_flag(smedia_handle_t handle, int32_t fd)
310 {
311 uint32_t format_flag;
312 int32_t old_per = 0;
313 int32_t new_per, ret_val;
314
315 if (force_format) {
316 (void) fprintf(stderr,
317 gettext("Formatting disk.\n"));
318 } else {
319 (void) fprintf(stderr,
320 gettext("Formatting will erase all the data on disk.\n"));
321 if (!get_confirmation())
322 return;
323 }
324
325 if (quick_format)
326 format_flag = SM_FORMAT_QUICK;
327 else if (long_format)
328 format_flag = SM_FORMAT_LONG;
329 else if (force_format)
330 format_flag = SM_FORMAT_FORCE;
331
332 if (med_info.sm_media_type == SM_FLOPPY)
333 format_flag = SM_FORMAT_HD;
334
335 if ((med_info.sm_media_type != SM_FLOPPY) &&
336 (med_info.sm_media_type != SM_PCMCIA_MEM) &&
337 (med_info.sm_media_type != SM_SCSI_FLOPPY)) {
338 global_intr_msg = "Interrupting format may render the \
339 medium useless";
340 } else {
341 global_intr_msg = "";
342 }
343 trap_SIGINT();
344
345 if (smedia_format(handle, format_flag, SM_FORMAT_IMMEDIATE) != 0) {
346 if (errno == EINVAL) {
347 (void) fprintf(stderr, gettext("Format failed.\n"));
348 (void) fprintf(stderr, gettext("The medium may not \
349 be compatible for format operation.\n"));
350 (void) fprintf(stderr, gettext("read/write surface \
351 scan may be used to get the effect of formatting.\n"));
352 } else {
353 PERROR("Format failed");
354 }
355 (void) smedia_release_handle(handle);
356 (void) close(fd);
357 exit(1);
358 }
359
360 /* CONSTCOND */
361 while (1) {
362 ret_val = smedia_check_format_status(handle);
363 if (ret_val == -1) {
364 if (errno != ENOTSUP) {
365 PERROR("Format failed");
366 (void) smedia_release_handle(handle);
367 (void) close(fd);
368 exit(1);
369 } else {
370 /* Background formatting is not supported */
371 break;
372 }
373 }
374 if (ret_val == 100) {
375 (void) printf("\n");
376 (void) fflush(stdout);
377 break;
378 }
379 new_per = (ret_val * 80)/100;
380 while (new_per >= old_per) {
381 (void) printf(".");
382 (void) fflush(stdout);
383 old_per++;
384 }
385 (void) sleep(6);
386 }
387
388 if ((med_info.sm_media_type == SM_FLOPPY) ||
389 (med_info.sm_media_type == SM_PCMCIA_MEM) ||
390 (med_info.sm_media_type == SM_SCSI_FLOPPY)) {
391 (void) write_sunos_label(fd, med_info.sm_media_type);
392 } else {
393
394 /*
395 * Iomega drives don't destroy the data in quick format.
396 * Do a best effort write to first 1024 sectors.
397 */
398
399 if (quick_format)
400 overwrite_metadata(fd, handle);
401
402 (void) write_default_label(handle, fd);
403 }
404
405 release_SIGINT();
406 }
407
408 /*
409 * List removable devices.
410 */
411 static void
412 process_l_flag()
413 {
414 int retry;
415 int removable;
416 int total_devices_found_last_time;
417 int defer = 0;
418 char *tmpstr;
419
420 #define MAX_RETRIES_FOR_SCANNING 3
421
422 vol_running = volmgt_running();
423 if (vol_running)
424 defer = 1;
425 (void) printf(gettext("Looking for devices...\n"));
426 total_devices_found_last_time = 0;
427
428 /*
429 * Strip out any leading path. For example, /dev/rdsk/c3t0d0s2
430 * will result in tmpstr = c3t0d0s2. dev_name is given as input
431 * argument.
432 */
433 if (dev_name) {
434 if ((tmpstr = strrchr(dev_name, '/')) != NULL) {
435 tmpstr += sizeof (char);
436 } else {
437 tmpstr = dev_name;
438 }
439 }
440
441 for (retry = 0; retry < MAX_RETRIES_FOR_SCANNING; retry++) {
442 removable = find_device(defer, tmpstr);
443 if (removable == -1)
444 break;
445
446 /*
447 * We'll do a small sleep and retry the command if volume
448 * manager is running and no removable devices are found.
449 * This is because the device may be busy.
450 */
451 if (defer || (vol_running && (removable == 0))) {
452 if ((total_devices_found == 0) ||
453 (total_devices_found !=
454 total_devices_found_last_time)) {
455 total_devices_found_last_time =
456 total_devices_found;
457 (void) sleep(2);
458 } else {
459 /* Do the printing this time */
460 defer = 0;
461 removable_found = 0;
462 }
463
464 } else
465 break;
466 }
467 if (removable_found == 0)
468 (void) printf(gettext("No removables found.\n"));
469 }
470
471 /*
472 * The following three routines handle the write protect
473 * options. These options are mostly Iomega ZIP/Jaz centric.
474 * The following options are allowed :
475 * No write protect <=> write protect without passwd : use -w flag
476 * from any state to WP with passwd : use -W flag
477 * from WP with passwd to no write protect : use -W flag
478 * from any state to RWP with passwd : use -R flag
479 * from RWP with passwd to no write protect : use -R flag
480 *
481 * The following transitions is not allowed
482 * WP with passwd or RWP to WP without passwd.
483 */
484
485 static void
486 process_w_flag(smedia_handle_t handle)
487 {
488 int32_t rval;
489 int32_t med_status;
490 struct smwp_state wps;
491
492 if ((rval = smedia_get_protection_status((handle), &wps)) < 0) {
493 (void) fprintf(stderr,
494 gettext("Could not get medium status \n"));
495 return;
496 }
497 med_status = wps.sm_new_state;
498
499 wps.sm_version = SMWP_STATE_V_1;
500
501 if (wp_enable) { /* Enable write protect no password */
502
503 switch (med_status) {
504 case SM_WRITE_PROTECT_DISABLE :
505 wps.sm_new_state =
506 SM_WRITE_PROTECT_NOPASSWD;
507 wps.sm_passwd_len = 0;
508 rval = smedia_set_protection_status(handle,
509 &wps);
510 if (rval == -1)
511 PERROR(WP_ERROR);
512 break;
513 case SM_WRITE_PROTECT_NOPASSWD :
514 (void) fprintf(stderr, gettext(WP_MSG_0));
515 break;
516 case SM_WRITE_PROTECT_PASSWD :
517 (void) fprintf(stderr, gettext(WP_MSG_1));
518 break;
519 case SM_READ_WRITE_PROTECT :
520 (void) fprintf(stderr, gettext(WP_MSG_2));
521 break;
522 case SM_STATUS_UNKNOWN :
523 default :
524 (void) fprintf(stderr, gettext(WP_UNKNOWN));
525 break;
526 }
527 } else if (wp_disable) {
528 switch (med_status) {
529 case SM_WRITE_PROTECT_NOPASSWD :
530 wps.sm_new_state =
531 SM_WRITE_PROTECT_DISABLE;
532 wps.sm_passwd_len = 0;
533 rval = smedia_set_protection_status(handle,
534 &wps);
535 if (rval == -1)
536 PERROR(WP_ERROR);
537 break;
538 case SM_WRITE_PROTECT_DISABLE :
539 (void) fprintf(stderr, gettext(WP_MSG_3));
540 break;
541 case SM_WRITE_PROTECT_PASSWD :
542 (void) fprintf(stderr, gettext(WP_MSG_1));
543 break;
544 case SM_READ_WRITE_PROTECT :
545 (void) fprintf(stderr, gettext(WP_MSG_2));
546 break;
547 case SM_STATUS_UNKNOWN :
548 default :
549 (void) fprintf(stderr, gettext(WP_UNKNOWN));
550 break;
551 }
552 }
553 }
554
555 static void
556 process_W_flag(smedia_handle_t handle)
557 {
558 int32_t rval;
559 int32_t med_status;
560 struct smwp_state wps;
561
562 DPRINTF("Write protect with password\n");
563
564 if ((rval = smedia_get_protection_status((handle), &wps)) < 0) {
565 (void) fprintf(stderr,
566 gettext("Could not get medium status \n"));
567 return;
568 }
569 med_status = wps.sm_new_state;
570
571 wps.sm_version = SMWP_STATE_V_1;
572
573 if (wp_enable_passwd) { /* Enable write protect */
574 switch (med_status) {
575 case SM_WRITE_PROTECT_DISABLE :
576 case SM_WRITE_PROTECT_NOPASSWD :
577 DPRINTF("Getting passwd\n");
578 get_passwd(&wps, 1);
579 wps.sm_new_state =
580 SM_WRITE_PROTECT_PASSWD;
581 rval = smedia_set_protection_status(handle,
582 &wps);
583 if (rval == -1) {
584 PERROR(WP_ERROR);
585 }
586 break;
587 case SM_READ_WRITE_PROTECT :
588 (void) fprintf(stderr, gettext(WP_MSG_4));
589 (void) fprintf(stderr, gettext(WP_MSG_5));
590 get_passwd(&wps, 0);
591 wps.sm_new_state =
592 SM_WRITE_PROTECT_PASSWD;
593 rval = smedia_set_protection_status(handle,
594 &wps);
595 if (rval == -1) {
596 if (errno == EACCES) {
597 (void) fprintf(stderr,
598 gettext(WP_MSG_10));
599 } else {
600 PERROR(WP_ERROR);
601 }
602 }
603 break;
604 case SM_WRITE_PROTECT_PASSWD :
605 (void) fprintf(stderr, gettext(WP_MSG_6));
606 break;
607 case SM_STATUS_UNKNOWN :
608 default :
609 (void) fprintf(stderr,
610 gettext(WP_UNKNOWN));
611 break;
612 }
613 } else if (wp_disable_passwd) {
614 switch (med_status) {
615 case SM_WRITE_PROTECT_PASSWD :
616 get_passwd(&wps, 0);
617 wps.sm_new_state =
618 SM_WRITE_PROTECT_DISABLE;
619 rval = smedia_set_protection_status(handle,
620 &wps);
621 if (rval == -1) {
622 if (errno == EACCES) {
623 (void) fprintf(stderr,
624 gettext(WP_MSG_10));
625 } else {
626 PERROR(WP_ERROR);
627 }
628 }
629 break;
630 case SM_READ_WRITE_PROTECT :
631 (void) fprintf(stderr, gettext(WP_MSG_2));
632 break;
633 case SM_WRITE_PROTECT_NOPASSWD :
634 (void) fprintf(stderr, gettext(WP_MSG_7));
635 break;
636 case SM_WRITE_PROTECT_DISABLE :
637 (void) fprintf(stderr, gettext(WP_MSG_3));
638 break;
639 case SM_STATUS_UNKNOWN :
640 default :
641 (void) fprintf(stderr, gettext(WP_UNKNOWN));
642 break;
643 }
644 }
645 }
646
647 static void
648 process_R_flag(smedia_handle_t handle)
649 {
650 int32_t rval;
651 int32_t med_status;
652 struct smwp_state wps;
653
654 DPRINTF("Read Write protect \n");
655
656 if ((rval = smedia_get_protection_status((handle), &wps)) < 0) {
657 (void) fprintf(stderr,
658 gettext("Could not get medium status \n"));
659 return;
660 }
661 med_status = wps.sm_new_state;
662
663 wps.sm_version = SMWP_STATE_V_1;
664
665 if (rw_protect_enable) { /* Enable write protect */
666 switch (med_status) {
667 case SM_WRITE_PROTECT_DISABLE :
668 case SM_WRITE_PROTECT_NOPASSWD :
669 DPRINTF("Getting passwd\n");
670 get_passwd(&wps, 1);
671 wps.sm_new_state =
672 SM_READ_WRITE_PROTECT;
673 rval = smedia_set_protection_status(handle,
674 &wps);
675 if (rval == -1)
676 PERROR(WP_ERROR);
677 break;
678 case SM_WRITE_PROTECT_PASSWD :
679 (void) fprintf(stderr, gettext(WP_MSG_8));
680 (void) fprintf(stderr, gettext(WP_MSG_9));
681 get_passwd(&wps, 0);
682 wps.sm_new_state =
683 SM_READ_WRITE_PROTECT;
684 rval = smedia_set_protection_status(handle,
685 &wps);
686 if (rval == -1) {
687 if (errno == EACCES) {
688 (void) fprintf(stderr,
689 gettext(WP_MSG_10));
690 } else {
691 PERROR(WP_ERROR);
692 }
693 }
694 break;
695 case SM_READ_WRITE_PROTECT :
696 (void) fprintf(stderr, gettext(WP_MSG_4));
697 break;
698 case SM_STATUS_UNKNOWN :
699 default :
700 (void) fprintf(stderr, gettext(WP_UNKNOWN));
701 break;
702 }
703 } else if (rw_protect_disable) {
704 switch (med_status) {
705 case SM_READ_WRITE_PROTECT :
706 case SM_STATUS_UNKNOWN :
707 get_passwd(&wps, 0);
708 wps.sm_new_state =
709 SM_WRITE_PROTECT_DISABLE;
710 rval = smedia_set_protection_status(handle,
711 &wps);
712 if (rval == -1) {
713 if (errno == EACCES) {
714 (void) fprintf(stderr,
715 gettext(WP_MSG_10));
716 } else {
717 PERROR(WP_ERROR);
718 }
719 }
720 break;
721 case SM_WRITE_PROTECT_PASSWD :
722 (void) fprintf(stderr, gettext(WP_MSG_1));
723 break;
724 case SM_WRITE_PROTECT_NOPASSWD :
725 (void) fprintf(stderr, gettext(WP_MSG_7));
726 break;
727 case SM_WRITE_PROTECT_DISABLE :
728 (void) fprintf(stderr, gettext(WP_MSG_3));
729 break;
730 default :
731 (void) fprintf(stderr, gettext(WP_UNKNOWN));
732 break;
733 }
734 }
735 }
736
737 void
738 process_p_flag(smedia_handle_t handle, int32_t fd)
739 {
740 int32_t med_status;
741 smwp_state_t wps;
742
743 med_status = smedia_get_protection_status((handle), &wps);
744 DPRINTF("Could not get medium status \n");
745
746 /*
747 * Workaround in case mode sense fails.
748 *
749 * Also, special handling for PCMCIA. PCMCIA does not have any
750 * ioctl to find out the write protect status. So, open the
751 * device with O_RDWR. If it passes, it is not write protected,
752 * otherwise it is write protected.
753 * If it fails, reopen with O_RDONLY, may be some other
754 * operation can go through.
755 */
756 if ((med_status < 0) || (med_info.sm_media_type == SM_PCMCIA_MEM) ||
757 (med_info.sm_media_type == SM_PCMCIA_ATA)) {
758 (void) close(fd);
759 DPRINTF("Reopening device for -p option\n");
760 fd = my_open(dev_name, O_RDONLY|O_NDELAY);
761 if (fd < 0) {
762 if (p_flag) {
763 PERROR("Could not open device");
764 (void) smedia_release_handle(handle);
765 (void) close(fd);
766 exit(1);
767 } else {
768 (void) fprintf(stdout,
769 gettext("<Unknown>\n"));
770 (void) smedia_release_handle(handle);
771 (void) close(fd);
772 return;
773 }
774 fd = my_open(dev_name, O_RDWR|O_NDELAY);
775 if (fd < 0) {
776 (void) fprintf(stdout,
777 gettext("Medium is write protected.\n"));
778 }
779 } else { /* Open succeeded */
780 (void) fprintf(stdout,
781 gettext("Medium is not write protected.\n"));
782 }
783 return;
784 }
785 med_status = wps.sm_new_state;
786 switch (med_status) {
787
788 case SM_READ_WRITE_PROTECT :
789 (void) fprintf(stdout,
790 gettext("Medium is read-write protected.\n"));
791 break;
792 case SM_WRITE_PROTECT_PASSWD :
793 (void) fprintf(stdout,
794 gettext("Medium is write protected with password.\n"));
795 break;
796 case SM_WRITE_PROTECT_NOPASSWD :
797 (void) fprintf(stdout,
798 gettext("Medium is write protected.\n"));
799 break;
800 case SM_WRITE_PROTECT_DISABLE :
801 (void) fprintf(stdout,
802 gettext("Medium is not write protected.\n"));
803 break;
804 case SM_STATUS_UNKNOWN :
805 default:
806 (void) fprintf(stdout,
807 gettext("Unknown write protect status.\n"));
808 break;
809 }
810 }
811
812 static void
813 process_c_flag(smedia_handle_t handle)
814 {
815 char error_string[256];
816
817 if (smedia_reassign_block(handle, repair_blk_no) != 0) {
818 (void) snprintf(error_string, 255,
819 gettext("Could not repair block no %llu"), repair_blk_no);
820 PERROR(error_string);
821 return;
822 }
823 }
824
825 /*
826 * This routine handles the -V (verify) option.
827 * There can be devices without rw_read option. If the raw_read
828 * and raw_write are not supported by the interface, then read and
829 * write system calls are used. It is assumed that either both
830 * raw_read and raw_write are supported or both are unsupported.
831 */
832
833 static void
834 process_V_flag(smedia_handle_t handle, int32_t fd)
835 {
836 int32_t ret;
837 uint32_t j;
838 diskaddr_t bn;
839 char *read_buf, *write_buf;
840 int32_t old_per = 0;
841 int32_t new_per;
842 int32_t no_raw_rw = 0;
843 int32_t verify_size;
844 diskaddr_t capacity;
845 int32_t blocksize;
846
847 DPRINTF("ANALYSE MEDIA \n");
848
849 ret = smedia_get_medium_property(handle, &med_info);
850 if (ret == -1) {
851 DPRINTF("get_media_info failed\n");
852 return;
853 }
854
855 DPRINTF1("media_type %d\n", med_info.sm_media_type);
856 DPRINTF1("sector_size %d\n", med_info.sm_blocksize);
857 DPRINTF1("num_sectors %u\n", (uint32_t)med_info.sm_capacity);
858 DPRINTF1("nsect %d\n", med_info.sm_nsect);
859
860 blocksize = med_info.sm_blocksize;
861
862 capacity = (uint32_t)med_info.sm_capacity;
863 verify_size = (med_info.sm_nsect > 64) ? 64 : med_info.sm_nsect;
864 read_buf = (char *)malloc(blocksize * verify_size);
865 if (read_buf == NULL) {
866 DPRINTF("Could not allocate memory\n");
867 return;
868 }
869 write_buf = (char *)malloc(blocksize * verify_size);
870 if (write_buf == NULL) {
871 DPRINTF("Could not allocate memory\n");
872 free(read_buf);
873 return;
874 }
875
876 if (!verify_write) {
877 DPRINTF("Non-destructive verify \n");
878 for (bn = 0; bn < (uint32_t)med_info.sm_capacity;
879 bn += verify_size) {
880 new_per = (bn * 80)/(uint32_t)med_info.sm_capacity;
881 if (new_per >= old_per) {
882 (void) printf(".");
883 (void) fflush(stdout);
884 old_per++;
885 }
886 DPRINTF2("Reading %d blks starting at %llu\n",
887 verify_size, bn);
888 ret = verify(handle, fd, bn, verify_size, read_buf,
889 VERIFY_READ, blocksize, no_raw_rw);
890 if ((ret == -1) && (errno == ENOTSUP)) {
891 no_raw_rw = 1;
892 ret = verify(handle, fd, bn, verify_size,
893 read_buf,
894 VERIFY_READ, blocksize, no_raw_rw);
895 capacity = (diskaddr_t)med_info.sm_pcyl *
896 med_info.sm_nhead * med_info.sm_nsect;
897 }
898
899 if (ret != 0) {
900 for (j = 0; j < verify_size; j++) {
901 if ((bn + j) >= capacity)
902 return;
903 DPRINTF2(
904 "Reading %d blks starting "
905 "at %llu\n", 1, bn + j);
906 ret = verify(handle, fd, bn + j, 1,
907 read_buf,
908 VERIFY_READ, blocksize,
909 no_raw_rw);
910 if (ret == -1) {
911 (void) printf(
912 "Bad block %llu\n",
913 bn + j);
914 }
915 }
916 }
917 }
918 } else {
919
920 DPRINTF("Destrutive verify \n");
921 for (bn = 0; bn < (uint32_t)med_info.sm_capacity;
922 bn += verify_size) {
923 new_per = (bn * 80)/(uint32_t)med_info.sm_capacity;
924 if (new_per >= old_per) {
925 (void) printf(".");
926
927 (void) fflush(stdout);
928 old_per++;
929 }
930
931 for (j = 0; j < blocksize * verify_size; j++) {
932 write_buf[j] = (bn | j) & 0xFF;
933 }
934 DPRINTF2("Writing %d blks starting at %llu\n",
935 verify_size, bn);
936 ret = verify(handle, fd, bn, verify_size, write_buf,
937 VERIFY_WRITE, blocksize, no_raw_rw);
938
939 if (ret != 0) {
940 for (j = 0; j < verify_size; j++) {
941 if ((bn + j) >= capacity)
942 break;
943 DPRINTF2(
944 "Writing %d blks starting "
945 "at %llu\n", 1, bn + j);
946 ret = verify(handle, fd, bn + j, 1,
947 write_buf,
948 VERIFY_WRITE, blocksize,
949 no_raw_rw);
950 if (ret == -1) {
951 (void) printf(
952 "Bad block %llu\n", bn + j);
953 }
954 }
955 }
956 DPRINTF2("Read after write %d blks starting at %llu\n",
957 verify_size, bn);
958 ret = verify(handle, fd, bn, verify_size,
959 read_buf, VERIFY_READ, blocksize, no_raw_rw);
960
961 if (ret != 0) {
962 for (j = 0; j < verify_size; j++) {
963 if ((bn + j) >= capacity)
964 return;
965 DPRINTF2(
966 "Read after write %d blks "
967 "starting at %llu\n", 1, bn + j);
968 ret = verify(handle, fd, bn + j, 1,
969 read_buf, VERIFY_READ,
970 blocksize, no_raw_rw);
971 if (ret == -1) {
972 (void) printf(
973 "Bad block %llu\n", bn + j);
974 }
975 }
976 }
977
978
979 }
980 }
981 }
982
983 static void
984 process_s_flag(smedia_handle_t handle, int32_t fd)
985 {
986 int32_t i, ret;
987 struct extvtoc v_toc, t_vtoc;
988 if (valid_slice_file(handle, fd, slice_file, &v_toc)) {
989 (void) smedia_release_handle(handle);
990 (void) close(fd);
991 exit(1);
992 }
993
994 (void) memset(&t_vtoc, 0, sizeof (t_vtoc));
995
996
997 t_vtoc.v_nparts = V_NUMPAR;
998 t_vtoc.v_sanity = VTOC_SANE;
999 t_vtoc.v_version = V_VERSION;
1000 t_vtoc.v_sectorsz = DEV_BSIZE;
1001
1002 /* Get existing Vtoc, don't bother if it fails. */
1003
1004 /* Turn on privileges. */
1005 (void) __priv_bracket(PRIV_ON);
1006
1007 (void) read_extvtoc(fd, &t_vtoc);
1008
1009 /* Turn off privileges. */
1010 (void) __priv_bracket(PRIV_OFF);
1011
1012 for (i = 0; i < V_NUMPAR; i++) {
1013 t_vtoc.v_part[i].p_start = v_toc.v_part[i].p_start;
1014 t_vtoc.v_part[i].p_size = v_toc.v_part[i].p_size;
1015 t_vtoc.v_part[i].p_tag = v_toc.v_part[i].p_tag;
1016 t_vtoc.v_part[i].p_flag = v_toc.v_part[i].p_flag;
1017 }
1018
1019 errno = 0;
1020
1021
1022 /* Turn on privileges. */
1023 (void) __priv_bracket(PRIV_ON);
1024
1025 ret = write_extvtoc(fd, &t_vtoc);
1026
1027 /* Turn off privileges. */
1028 (void) __priv_bracket(PRIV_OFF);
1029
1030 if (ret < 0) {
1031 #ifdef sparc
1032 PERROR("write VTOC failed");
1033 DPRINTF1("Errno = %d\n", errno);
1034 #else /* i386 */
1035 if (errno == EIO) {
1036 PERROR("No Solaris partition, eject & retry");
1037 DPRINTF1("Errno = %d\n", errno);
1038 } else {
1039 PERROR("write VTOC failed");
1040 DPRINTF1("Errno = %d\n", errno);
1041 }
1042 #endif
1043 }
1044 }
1045 static void
1046 process_e_flag(smedia_handle_t handle)
1047 {
1048 if (smedia_eject(handle) < 0) {
1049 PERROR("Eject failed");
1050 }
1051 }
1052 static void
1053 process_H_flag(smedia_handle_t handle, int32_t fd)
1054 {
1055 uint32_t cyl, head;
1056 int32_t old_per = 0;
1057 int32_t new_per;
1058
1059 (void) fprintf(stderr,
1060 gettext("Formatting will erase all the data on disk.\n"));
1061 if (!get_confirmation())
1062 return;
1063
1064 for (cyl = 0; cyl < med_info.sm_pcyl; cyl++) {
1065 for (head = 0; head < med_info.sm_nhead; head++) {
1066 if (smedia_format_track(handle, cyl, head, SM_FORMAT_HD)
1067 < 0) {
1068 PERROR("Format failed");
1069 return;
1070 }
1071 }
1072 new_per = (cyl * 80)/med_info.sm_pcyl;
1073 while (new_per >= old_per) {
1074 (void) printf(".");
1075 (void) fflush(stdout);
1076 old_per++;
1077 }
1078 }
1079
1080 (void) write_sunos_label(fd, med_info.sm_media_type);
1081 }
1082
1083 static void
1084 process_D_flag(smedia_handle_t handle, int32_t fd)
1085 {
1086 uint32_t cyl, head;
1087 int32_t old_per = 0;
1088 int32_t new_per;
1089
1090 (void) fprintf(stderr,
1091 gettext("Formatting will erase all the data on disk.\n"));
1092 if (!get_confirmation())
1093 return;
1094 for (cyl = 0; cyl < med_info.sm_pcyl; cyl++) {
1095 for (head = 0; head < med_info.sm_nhead; head++) {
1096 if (smedia_format_track(handle, cyl, head, SM_FORMAT_DD)
1097 < 0) {
1098 PERROR("Format failed");
1099 return;
1100 }
1101 }
1102 new_per = (cyl * 80)/med_info.sm_pcyl;
1103 while (new_per >= old_per) {
1104 (void) printf(".");
1105 (void) fflush(stdout);
1106 old_per++;
1107 }
1108 }
1109 (void) write_sunos_label(fd, med_info.sm_media_type);
1110 }
1111
1112 /*
1113 * This routine handles the -b (label) option.
1114 * Please note that, this will fail if there is no valid vtoc is
1115 * there on the medium and the vtoc is not faked.
1116 */
1117
1118 static void
1119 process_b_flag(int32_t fd)
1120 {
1121 int32_t ret, nparts;
1122 struct extvtoc v_toc;
1123 struct dk_gpt *vtoc64;
1124
1125 /* For EFI disks. */
1126 if (efi_type(fd)) {
1127 if (efi_alloc_and_read(fd, &vtoc64) < 0) {
1128 /*
1129 * If reading the vtoc failed, try to
1130 * auto-sense the disk configuration.
1131 */
1132 if (efi_auto_sense(fd, &vtoc64) < 0) {
1133 (void) fprintf(stderr,
1134 gettext("Could not write label.\n"));
1135 return;
1136 }
1137 }
1138 for (nparts = 0; nparts < vtoc64->efi_nparts;
1139 nparts++) {
1140 if (vtoc64->efi_parts[nparts].p_tag ==
1141 V_RESERVED) {
1142 if (vtoc64->efi_parts[nparts].p_name) {
1143 (void) strncpy(
1144 vtoc64->efi_parts[nparts].p_name, label,
1145 EFI_PART_NAME_LEN);
1146 }
1147 break;
1148 }
1149 }
1150 if (efi_write(fd, vtoc64) != 0) {
1151 (void) efi_err_check(vtoc64);
1152 (void) fprintf(stderr,
1153 gettext("Could not write label.\n"));
1154 }
1155 return;
1156 }
1157
1158 /* Get existing Vtoc */
1159
1160 /* Turn on privileges. */
1161 (void) __priv_bracket(PRIV_ON);
1162
1163 ret = read_extvtoc(fd, &v_toc);
1164
1165 /* Turn off privileges */
1166 (void) __priv_bracket(PRIV_OFF);
1167
1168 if (ret < 0) {
1169 #ifdef sparc
1170 PERROR("read VTOC failed");
1171 DPRINTF1("Errno = %d\n", errno);
1172 #else /* i386 */
1173 if (errno == EIO) {
1174 PERROR("No Solaris partition, eject & retry");
1175 DPRINTF1("Errno = %d\n", errno);
1176 } else {
1177 PERROR("read VTOC failed");
1178 DPRINTF1("Errno = %d\n", errno);
1179 }
1180 #endif
1181 return;
1182 }
1183
1184 (void) strncpy(v_toc.v_volume, label, LEN_DKL_VVOL);
1185
1186
1187 /* Turn on the privileges. */
1188 (void) __priv_bracket(PRIV_ON);
1189
1190 ret = write_extvtoc(fd, &v_toc);
1191
1192 /* Turn off the privileges. */
1193 (void) __priv_bracket(PRIV_OFF);
1194
1195 if (ret < 0) {
1196 #ifdef sparc
1197 PERROR("write VTOC failed");
1198 DPRINTF1("Errno = %d\n", errno);
1199 #else /* i386 */
1200 if (errno == EIO) {
1201 PERROR("No Solaris partition, eject & retry");
1202 DPRINTF1("Errno = %d\n", errno);
1203 } else {
1204 PERROR("write VTOC failed");
1205 DPRINTF1("Errno = %d\n", errno);
1206 }
1207 #endif
1208 }
1209 }