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 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * Portions of this source code were derived from Berkeley 4.3 BSD
31 * under license from the Regents of the University of California.
32 */
33
34 /*
35 * make file system for udfs (UDF - ISO13346)
36 *
37 * usage:
38 *
39 * mkfs [-F FSType] [-V] [-m] [options]
40 * [-o specific_options] special size
41 *
42 * where specific_options are:
43 * N - no create
44 * label - volume label
45 * psize - physical block size
46 */
47
48 #include <stdio.h>
49 #include <strings.h>
50 #include <string.h>
51 #include <stdlib.h>
52 #include <unistd.h>
53 #include <time.h>
54 #include <locale.h>
55 #include <fcntl.h>
56 #include <errno.h>
57 #include <limits.h>
58 #include <sys/mnttab.h>
59 #include <sys/param.h>
60 #include <sys/types.h>
61 #include <sys/sysmacros.h>
62 #include <sys/vnode.h>
63 #include <sys/mntent.h>
64 #include <sys/filio.h>
65 #include <sys/stat.h>
66 #include <ustat.h>
67 #include <sys/isa_defs.h> /* for ENDIAN defines */
68 #include <sys/dkio.h>
69 #include <sys/fdio.h>
70 #include <sys/vtoc.h>
71 #include <sys/fs/udf_volume.h>
72
73 extern char *getfullrawname(char *);
74 extern char *getfullblkname(char *);
75 extern struct tm *localtime_r(const time_t *, struct tm *);
76 extern void maketag(struct tag *, struct tag *);
77 extern int verifytag(struct tag *, uint32_t, struct tag *, int);
78 extern void setcharspec(struct charspec *, int32_t, uint8_t *);
79
80
81 #define UMASK 0755
82 #define POWEROF2(num) (((num) & ((num) - 1)) == 0)
83 #define MB (1024*1024)
84
85 /*
86 * Forward declarations
87 */
88 static void rdfs(daddr_t bno, int size, char *bf);
89 static void wtfs(daddr_t bno, int size, char *bf);
90 static void dump_fscmd(char *fsys, int fsi);
91 static int32_t number(long big, char *param);
92 static void usage();
93 static int match(char *s);
94 static int readvolseq();
95 static uint32_t get_last_block();
96
97 /*
98 * variables set up by front end.
99 */
100 static int Nflag = 0; /* run mkfs without writing */
101 /* file system */
102 static int mflag = 0; /* return the command line used */
103 /* to create this FS */
104 static int fssize; /* file system size */
105 static uint32_t disk_size; /* partition size from VTOC */
106 static uint32_t unused; /* unused sectors in partition */
107 static int sectorsize = 2048; /* bytes/sector default */
108 /* If nothing specified */
109
110 static char *fsys;
111 static int fsi;
112 static int fso;
113
114 #define BIG LONG_MAX
115 static uint32_t number_flags = 0;
116
117 static char *string;
118
119 static void setstamp(tstamp_t *);
120 static void setextad(extent_ad_t *, uint32_t, uint32_t);
121 static void setdstring(dstring_t *, char *, int32_t);
122 static void wtvolseq(tag_t *, daddr_t, daddr_t);
123 static void volseqinit();
124 static void setstamp(tstamp_t *);
125 static uint32_t get_bsize();
126
127
128 #define VOLRECSTART (32 * 1024)
129
130 #define VOLSEQSTART 128
131 #define VOLSEQLEN 16
132 #define INTSEQSTART 192
133 #define INTSEQLEN 8192
134 #define FIRSTAVDP 256
135 #define AVDPLEN 1
136
137
138 #define FILESETLEN 2
139
140 #define SPACEMAP_OFF 24
141 #define MAXID 16
142
143 static time_t mkfstime;
144 static struct tm res;
145 static long tzone;
146 static char vsibuf[128];
147
148 static regid_t sunmicro = { 0, "*SUN SOLARIS UDF", 4, 2 };
149 static regid_t lvinfo = { 0, "*UDF LV Info", 0x50, 0x1, 4, 2 };
150 static regid_t partid = { 0, "+NSR02", 0 };
151 static regid_t udf_compliant = { 0, "*OSTA UDF Compliant", 0x50, 0x1, 0 };
152 static uint8_t osta_unicode[] = "OSTA Compressed Unicode";
153
154 static int bdevismounted;
155 static int ismounted;
156 static int directory;
157 static char buf[MAXBSIZE];
158 static char buf2[MAXBSIZE];
159 static char lvid[MAXBSIZE];
160
161 uint32_t ecma_version = 2;
162
163 static int serialnum = 1; /* Tag serial number */
164 static char udfs_label[128] = "*NoLabel*";
165 static int acctype = PART_ACC_OW;
166 static uint32_t part_start;
167 static uint32_t part_len;
168 static uint32_t part_bmp_bytes;
169 static uint32_t part_bmp_sectors;
170 static int32_t part_unalloc = -1;
171 static uint32_t filesetblock;
172
173 /* Set by readvolseq for -m option */
174 static uint32_t oldfssize;
175 static char *oldlabel;
176
177 int
main(int32_t argc,int8_t * argv[])178 main(int32_t argc, int8_t *argv[])
179 {
180 long i;
181 FILE *mnttab;
182 struct mnttab mntp;
183 char *special, *raw_special;
184 struct stat statarea;
185 struct ustat ustatarea;
186 int c;
187 uint32_t temp_secsz;
188 int isfs;
189
190 (void) setlocale(LC_ALL, "");
191
192 #if !defined(TEXT_DOMAIN)
193 #define TEXT_DOMAIN "SYS_TEST"
194 #endif
195 (void) textdomain(TEXT_DOMAIN);
196
197 while ((c = getopt(argc, argv, "F:Vmo:")) != EOF) {
198 switch (c) {
199
200 case 'F':
201 string = optarg;
202 if (strcmp(string, "udfs") != 0) {
203 usage();
204 }
205 break;
206
207 case 'V':
208 {
209 char *opt_text;
210 int opt_count;
211
212 (void) fprintf(stdout,
213 gettext("mkfs -F udfs "));
214 for (opt_count = 1; opt_count < argc;
215 opt_count++) {
216 opt_text = argv[opt_count];
217 if (opt_text) {
218 (void) fprintf(stdout,
219 " %s ", opt_text);
220 }
221 }
222 (void) fprintf(stdout, "\n");
223 }
224 break;
225
226 case 'm':
227 /*
228 * return command line used
229 * to create this FS
230 */
231 mflag++;
232 break;
233
234 case 'o':
235 /*
236 * udfs specific options.
237 */
238 string = optarg;
239 while (*string != '\0') {
240 if (match("N")) {
241 Nflag++;
242 } else if (match("psize=")) {
243 number_flags = 0;
244 sectorsize = number(BIG,
245 "psize");
246 } else if (match("label=")) {
247 for (i = 0; i < 31; i++) {
248 if (*string == '\0') {
249 break;
250 }
251 udfs_label[i] =
252 *string++;
253 }
254 udfs_label[i] = '\0';
255 } else if (*string == '\0') {
256 break;
257 } else {
258 (void) fprintf(stdout,
259 gettext("illegal "
260 "option: %s\n"),
261 string);
262 usage();
263 }
264 if (*string == ',') {
265 string++;
266 }
267 if (*string == ' ') {
268 string++;
269 }
270 }
271 break;
272
273 case '?':
274 usage();
275 break;
276 }
277 }
278
279 (void) time(&mkfstime);
280 if (optind > (argc - 1)) {
281 usage();
282 }
283
284 argc -= optind;
285 argv = &argv[optind];
286 fsys = argv[0];
287 raw_special = getfullrawname(fsys);
288 fsi = open(raw_special, 0);
289 if (fsi < 0) {
290 (void) fprintf(stdout,
291 gettext("%s: cannot open\n"), fsys);
292 exit(32);
293 }
294 fso = fsi;
295
296 if ((temp_secsz = get_bsize()) != 0) {
297 sectorsize = temp_secsz;
298 }
299
300 /* Get old file system information */
301 isfs = readvolseq();
302
303 if (mflag) {
304 /*
305 * Figure out the block size and
306 * file system size and print the information
307 */
308 if (isfs)
309 dump_fscmd(fsys, fsi);
310 else
311 (void) printf(gettext(
312 "[not currently a valid file system]\n"));
313 exit(0);
314 }
315
316 /*
317 * Get the disk size from the drive or VTOC for the N and N-256
318 * AVDPs and to make sure we don't want to create a file system
319 * bigger than the partition.
320 */
321 disk_size = get_last_block();
322
323 if (argc < 2 && disk_size == 0 || argc < 1) {
324 usage();
325 }
326
327 if (argc < 2) {
328 (void) printf(gettext("No size specified, entire partition "
329 "of %u sectors used\n"), disk_size);
330 fssize = disk_size;
331 } else {
332 string = argv[1];
333 number_flags = 0;
334 fssize = number(BIG, "size");
335 }
336
337 if (fssize < 0) {
338 (void) fprintf(stderr,
339 gettext("Negative number of sectors(%d) not allowed\n"),
340 fssize);
341 exit(32);
342 }
343
344 if (fssize < (512 * sectorsize / DEV_BSIZE)) {
345 (void) fprintf(stdout,
346 gettext("size should be at least %d sectors\n"),
347 (512 * sectorsize / DEV_BSIZE));
348 exit(32);
349 }
350
351 if (disk_size != 0) {
352 if (fssize > disk_size) {
353 (void) fprintf(stderr, gettext("Invalid size: %d "
354 "larger than the partition size\n"), fssize);
355 exit(32);
356 } else if (fssize < disk_size) {
357 unused = disk_size - fssize;
358 (void) printf(
359 gettext("File system size %d smaller than "
360 "partition, %u sectors unused\n"),
361 fssize, unused);
362 }
363 } else {
364 /* Use passed-in size */
365 disk_size = fssize;
366 }
367
368 if (!Nflag) {
369 special = getfullblkname(fsys);
370
371 /*
372 * If we found the block device name,
373 * then check the mount table.
374 * if mounted, write lock the file system
375 *
376 */
377 if ((special != NULL) && (*special != '\0')) {
378 mnttab = fopen(MNTTAB, "r");
379 while ((getmntent(mnttab, &mntp)) == 0) {
380 if (strcmp(special, mntp.mnt_special) == 0) {
381 (void) fprintf(stdout,
382 gettext("%s is mounted,"
383 " can't mkfs\n"), special);
384 exit(32);
385 }
386 }
387 (void) fclose(mnttab);
388 }
389 if ((bdevismounted) && (ismounted == 0)) {
390 (void) fprintf(stdout,
391 gettext("can't check mount point; "));
392 (void) fprintf(stdout,
393 gettext("%s is mounted but not in mnttab(5)\n"),
394 special);
395 exit(32);
396 }
397 if (directory) {
398 if (ismounted == 0) {
399 (void) fprintf(stdout,
400 gettext("%s is not mounted\n"),
401 special);
402 exit(32);
403 }
404 }
405 fso = creat(fsys, 0666);
406 if (fso < 0) {
407 (void) fprintf(stdout,
408 gettext("%s: cannot create\n"), fsys);
409 exit(32);
410 }
411 if (stat(fsys, &statarea) < 0) {
412 (void) fprintf(stderr,
413 gettext("%s: %s: cannot stat\n"),
414 argv[0], fsys);
415 exit(32);
416 }
417 if (ustat(statarea.st_rdev, &ustatarea) >= 0) {
418 (void) fprintf(stderr,
419 gettext("%s is mounted, can't mkfs\n"), fsys);
420 exit(32);
421 }
422 } else {
423 /*
424 * For the -N case, a file descriptor is needed for the llseek()
425 * in wtfs(). See the comment in wtfs() for more information.
426 *
427 * Get a file descriptor that's read-only so that this code
428 * doesn't accidentally write to the file.
429 */
430 fso = open(fsys, O_RDONLY);
431 if (fso < 0) {
432 (void) fprintf(stderr, gettext("%s: cannot open\n"),
433 fsys);
434 exit(32);
435 }
436 }
437
438
439 /*
440 * Validate the given file system size.
441 * Verify that its last block can actually be accessed.
442 */
443 fssize = fssize / (sectorsize / DEV_BSIZE);
444 if (fssize <= 0) {
445 (void) fprintf(stdout,
446 gettext("preposterous size %d. sectors\n"), fssize);
447 exit(32);
448 }
449 fssize --;
450
451 /*
452 * verify device size
453 */
454 rdfs(fssize - 1, sectorsize, buf);
455
456 if ((sectorsize < DEV_BSIZE) ||
457 (sectorsize > MAXBSIZE)) {
458 (void) fprintf(stdout,
459 gettext("sector size must be"
460 " between 512, 8192 bytes\n"));
461 }
462 if (!POWEROF2(sectorsize)) {
463 (void) fprintf(stdout,
464 gettext("sector size must be a power of 2, not %d\n"),
465 sectorsize);
466 exit(32);
467 }
468 if (Nflag) {
469 exit(0);
470 }
471
472 (void) printf(gettext("Creating file system with sector size of "
473 "%d bytes\n"), sectorsize);
474
475 /*
476 * Set up time stamp values
477 */
478 mkfstime = time(0);
479 (void) localtime_r(&mkfstime, &res);
480 if (res.tm_isdst > 0) {
481 tzone = altzone / 60;
482 } else if (res.tm_isdst == 0) {
483 tzone = tzone / 60;
484 } else {
485 tzone = 2047; /* Unknown */
486 }
487
488 /*
489 * Initialize the volume recognition sequence, the volume descriptor
490 * sequences and the anchor pointer.
491 */
492 volseqinit();
493
494 (void) fsync(fso);
495 (void) close(fsi);
496 (void) close(fso);
497
498 return (0);
499 }
500
501 static void
setstamp(tstamp_t * tp)502 setstamp(tstamp_t *tp)
503 {
504 tp->ts_usec = 0;
505 tp->ts_husec = 0;
506 tp->ts_csec = 0;
507
508 tp->ts_sec = res.tm_sec;
509 tp->ts_min = res.tm_min;
510 tp->ts_hour = res.tm_hour;
511 tp->ts_day = res.tm_mday;
512 tp->ts_month = res.tm_mon + 1;
513 tp->ts_year = 1900 + res.tm_year;
514
515 tp->ts_tzone = 0x1000 + (-tzone & 0xFFF);
516 }
517
518 static void
setextad(extent_ad_t * eap,uint32_t len,uint32_t loc)519 setextad(extent_ad_t *eap, uint32_t len, uint32_t loc)
520 {
521 eap->ext_len = len;
522 eap->ext_loc = loc;
523 }
524
525 static void
setdstring(dstring_t * dp,char * cp,int len)526 setdstring(dstring_t *dp, char *cp, int len)
527 {
528 int32_t length;
529
530 bzero(dp, len);
531 length = strlen(cp);
532 if (length > len - 3) {
533 length = len - 3;
534 }
535 dp[len - 1] = length + 1;
536 *dp++ = 8;
537 (void) strncpy(dp, cp, len-2);
538 }
539
540 static void
wtvolseq(tag_t * tp,daddr_t blk1,daddr_t blk2)541 wtvolseq(tag_t *tp, daddr_t blk1, daddr_t blk2)
542 {
543 static uint32_t vdsn = 0;
544
545 tp->tag_loc = blk1;
546 switch (tp->tag_id) {
547 case UD_PRI_VOL_DESC :
548 ((struct pri_vol_desc *)tp)->pvd_vdsn = vdsn++;
549 break;
550 case UD_VOL_DESC_PTR :
551 ((struct vol_desc_ptr *)tp)->vdp_vdsn = vdsn++;
552 break;
553 case UD_IMPL_USE_DESC :
554 ((struct iuvd_desc *)tp)->iuvd_vdsn = vdsn++;
555 break;
556 case UD_PART_DESC :
557 ((struct part_desc *)tp)->pd_vdsn = vdsn++;
558 break;
559 case UD_LOG_VOL_DESC :
560 ((struct log_vol_desc *)tp)->lvd_vdsn = vdsn++;
561 break;
562 case UD_UNALL_SPA_DESC :
563 ((struct unall_spc_desc *)tp)->ua_vdsn = vdsn++;
564 break;
565 }
566
567 bzero(buf2, sectorsize);
568 /* LINTED */
569 maketag(tp, (struct tag *)buf2);
570
571 /*
572 * Write at Main Volume Descriptor Sequence
573 */
574 wtfs(blk1, sectorsize, buf2);
575
576 tp->tag_loc = blk2;
577 switch (tp->tag_id) {
578 case UD_PRI_VOL_DESC :
579 ((struct pri_vol_desc *)tp)->pvd_vdsn = vdsn++;
580 break;
581 case UD_VOL_DESC_PTR :
582 ((struct vol_desc_ptr *)tp)->vdp_vdsn = vdsn++;
583 break;
584 case UD_IMPL_USE_DESC :
585 ((struct iuvd_desc *)tp)->iuvd_vdsn = vdsn++;
586 break;
587 case UD_PART_DESC :
588 ((struct part_desc *)tp)->pd_vdsn = vdsn++;
589 break;
590 case UD_LOG_VOL_DESC :
591 ((struct log_vol_desc *)tp)->lvd_vdsn = vdsn++;
592 break;
593 case UD_UNALL_SPA_DESC :
594 ((struct unall_spc_desc *)tp)->ua_vdsn = vdsn++;
595 break;
596 }
597 maketag(tp, tp);
598 /*
599 * Write at Reserve Volume Descriptor Sequence
600 */
601 wtfs(blk2, sectorsize, buf);
602 }
603
604 static void
volseqinit(void)605 volseqinit(void)
606 {
607 struct tag *tp;
608 struct nsr_desc *nsp;
609 struct pri_vol_desc *pvdp;
610 struct iuvd_desc *iudp;
611 struct part_desc *pp;
612 struct phdr_desc *php;
613 struct log_vol_desc *lvp;
614 long_ad_t *lap;
615 struct pmap_typ1 *pmp;
616 struct unall_spc_desc *uap;
617 struct log_vol_int_desc *lvip;
618 struct term_desc *tdp;
619 struct anch_vol_desc_ptr *avp;
620 struct lvid_iu *lviup;
621 struct file_set_desc *fsp;
622 struct file_entry *fp;
623 struct icb_tag *icb;
624 struct short_ad *sap;
625 struct file_id *fip;
626 struct space_bmap_desc *sbp;
627 uint8_t *cp;
628 daddr_t nextblock, endblock;
629 int32_t volseq_sectors, nextlogblock, rootfelen, i;
630 uint32_t mvds_loc, rvds_loc;
631
632 bzero(buf, MAXBSIZE);
633
634 /*
635 * Starting from MAXBSIZE, clear out till 256 sectors.
636 */
637 for (i = MAXBSIZE / sectorsize; i < FIRSTAVDP; i++) {
638 wtfs(i, sectorsize, buf);
639 }
640
641 /* Zero out the avdp at N - 257 */
642 wtfs(fssize - 256, sectorsize, buf);
643
644 /*
645 * Leave 1st 32K for O.S.
646 */
647 nextblock = VOLRECSTART / sectorsize;
648
649 /*
650 * Write BEA01/NSR02/TEA01 sequence.
651 * Each one must be 2K bytes in length.
652 */
653 nsp = (struct nsr_desc *)buf;
654 nsp->nsr_str_type = 0;
655 nsp->nsr_ver = 1;
656 (void) strncpy((int8_t *)nsp->nsr_id, "BEA01", 5);
657
658 nsp = (struct nsr_desc *)&buf[2048];
659 nsp->nsr_str_type = 0;
660 nsp->nsr_ver = 1;
661 (void) strncpy((int8_t *)nsp->nsr_id, "NSR02", 5);
662
663 nsp = (struct nsr_desc *)&buf[4096];
664 nsp->nsr_str_type = 0;
665 nsp->nsr_ver = 1;
666 (void) strncpy((int8_t *)nsp->nsr_id, "TEA01", 5);
667
668 wtfs(nextblock, 8192, buf);
669 bzero(buf, MAXBSIZE);
670
671 /*
672 * Minimum length of volume sequences
673 */
674 volseq_sectors = 16;
675
676 /*
677 * Round up to next 32K boundary for
678 * volume descriptor sequences
679 */
680 nextblock = VOLSEQSTART;
681 bzero(buf, sectorsize);
682 mvds_loc = VOLSEQSTART;
683 rvds_loc = mvds_loc + volseq_sectors;
684
685 /*
686 * Primary Volume Descriptor
687 */
688 /* LINTED */
689 pvdp = (struct pri_vol_desc *)buf;
690 tp = &pvdp->pvd_tag;
691 tp->tag_id = UD_PRI_VOL_DESC;
692 tp->tag_desc_ver = ecma_version;
693 tp->tag_sno = serialnum;
694 tp->tag_crc_len = sizeof (struct pri_vol_desc) -
695 sizeof (struct tag);
696 pvdp->pvd_vdsn = 0;
697 pvdp->pvd_pvdn = 0;
698 setdstring(pvdp->pvd_vol_id, udfs_label, 32);
699 pvdp->pvd_vsn = 1;
700 pvdp->pvd_mvsn = 1;
701 pvdp->pvd_il = 2; /* Single-volume */
702 pvdp->pvd_mil = 3; /* Multi-volume */
703 pvdp->pvd_csl = 1; /* CS0 */
704 pvdp->pvd_mcsl = 1; /* CS0 */
705 (void) sprintf(vsibuf, "%08X", SWAP_32((uint32_t)mkfstime));
706 setdstring(pvdp->pvd_vsi, vsibuf, 128);
707 (void) strncpy(pvdp->pvd_vsi + 17, udfs_label, 128 - 17);
708 setcharspec(&pvdp->pvd_desc_cs, 0, osta_unicode);
709 setcharspec(&pvdp->pvd_exp_cs, 0, osta_unicode);
710 setextad(&pvdp->pvd_vol_abs, 0, 0);
711 setextad(&pvdp->pvd_vcn, 0, 0);
712 bzero(&pvdp->pvd_appl_id, sizeof (regid_t));
713 setstamp(&pvdp->pvd_time);
714 bcopy(&sunmicro, &pvdp->pvd_ii, sizeof (regid_t));
715 pvdp->pvd_flags = 0;
716 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
717 nextblock++;
718
719 /*
720 * Implementation Use Descriptor
721 */
722 bzero(buf, sectorsize);
723 /* LINTED */
724 iudp = (struct iuvd_desc *)buf;
725 tp = &iudp->iuvd_tag;
726 tp->tag_id = UD_IMPL_USE_DESC;
727 tp->tag_desc_ver = ecma_version;
728 tp->tag_sno = serialnum;
729 tp->tag_crc_len = sizeof (struct iuvd_desc) -
730 sizeof (struct tag);
731 iudp->iuvd_vdsn = 0;
732 bcopy(&lvinfo, &iudp->iuvd_ii, sizeof (regid_t));
733 setcharspec(&iudp->iuvd_cset, 0, osta_unicode);
734 setdstring(iudp->iuvd_lvi, udfs_label, 128);
735
736 setdstring(iudp->iuvd_ifo1, "", 36);
737 setdstring(iudp->iuvd_ifo2, "", 36);
738 setdstring(iudp->iuvd_ifo3, "", 36);
739
740
741 /*
742 * info1,2,3 = user specified
743 */
744 bcopy(&sunmicro, &iudp->iuvd_iid, sizeof (regid_t));
745 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
746 nextblock++;
747
748 /*
749 * Partition Descriptor
750 */
751 bzero(buf, sectorsize);
752 /* LINTED */
753 pp = (struct part_desc *)buf;
754 tp = &pp->pd_tag;
755 tp->tag_id = UD_PART_DESC;
756 tp->tag_desc_ver = ecma_version;
757 tp->tag_sno = serialnum;
758 tp->tag_crc_len = sizeof (struct part_desc) -
759 sizeof (struct tag);
760 pp->pd_vdsn = 0;
761 pp->pd_pflags = 1; /* Allocated */
762 pp->pd_pnum = 0;
763 bcopy(&partid, &pp->pd_pcontents, sizeof (regid_t));
764
765 part_start = FIRSTAVDP + AVDPLEN;
766 part_len = fssize - part_start;
767 part_bmp_bytes = (part_len + NBBY - 1) / NBBY;
768 part_bmp_sectors = (part_bmp_bytes + SPACEMAP_OFF + sectorsize - 1) /
769 sectorsize;
770
771 pp->pd_part_start = part_start;
772 pp->pd_part_length = part_len;
773
774 pp->pd_acc_type = acctype;
775 nextlogblock = 0;
776
777 /*
778 * Do the partition header
779 */
780 /* LINTED */
781 php = (struct phdr_desc *)&pp->pd_pc_use;
782
783 /*
784 * Set up unallocated space bitmap
785 */
786 if (acctype == PART_ACC_RW || acctype == PART_ACC_OW) {
787 php->phdr_usb.sad_ext_len =
788 (part_bmp_bytes + SPACEMAP_OFF + sectorsize - 1) &
789 (~(sectorsize - 1));
790 php->phdr_usb.sad_ext_loc = nextlogblock;
791 part_unalloc = nextlogblock;
792 nextlogblock += part_bmp_sectors;
793 }
794
795 bcopy(&sunmicro, &pp->pd_ii, sizeof (regid_t));
796 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
797 nextblock++;
798
799 /*
800 * Logical Volume Descriptor
801 */
802 bzero(buf, sectorsize);
803 /* LINTED */
804 lvp = (struct log_vol_desc *)buf;
805 tp = &lvp->lvd_tag;
806 tp->tag_id = UD_LOG_VOL_DESC;
807 tp->tag_desc_ver = ecma_version;
808 tp->tag_sno = serialnum;
809 tp->tag_crc_len = sizeof (struct log_vol_desc) -
810 sizeof (struct tag);
811 lvp->lvd_vdsn = 0;
812 setcharspec(&lvp->lvd_desc_cs, 0, osta_unicode);
813 setdstring(lvp->lvd_lvid, udfs_label, 128);
814 lvp->lvd_log_bsize = sectorsize;
815 bcopy(&udf_compliant, &lvp->lvd_dom_id, sizeof (regid_t));
816 lap = (long_ad_t *)&lvp->lvd_lvcu;
817 lap->lad_ext_len = FILESETLEN * sectorsize;
818 filesetblock = nextlogblock;
819 lap->lad_ext_loc = nextlogblock;
820 lap->lad_ext_prn = 0;
821 lvp->lvd_mtbl_len = 6;
822 lvp->lvd_num_pmaps = 1;
823 bcopy(&sunmicro, &lvp->lvd_ii, sizeof (regid_t));
824 /* LINTED */
825 pmp = (struct pmap_typ1 *)&lvp->lvd_pmaps;
826 pmp->map1_type = 1;
827 pmp->map1_length = 6;
828 pmp->map1_vsn = SWAP_16(1);
829 pmp->map1_pn = 0;
830 tp->tag_crc_len = (char *)(pmp + 1) - buf - sizeof (struct tag);
831 setextad(&lvp->lvd_int_seq_ext, INTSEQLEN, INTSEQSTART);
832 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
833 nextblock++;
834
835 /*
836 * Unallocated Space Descriptor
837 */
838 bzero(buf, sectorsize);
839 /* LINTED */
840 uap = (struct unall_spc_desc *)buf;
841 tp = &uap->ua_tag;
842 tp->tag_id = UD_UNALL_SPA_DESC;
843 tp->tag_desc_ver = ecma_version;
844 tp->tag_sno = serialnum;
845 uap->ua_vdsn = 0;
846 uap->ua_nad = 0;
847 tp->tag_crc_len = (char *)uap->ua_al_dsc - buf - sizeof (struct tag);
848 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
849 nextblock++;
850
851 /*
852 * Terminating Descriptor
853 */
854 bzero(buf, sectorsize);
855 /* LINTED */
856 tdp = (struct term_desc *)buf;
857 tp = &tdp->td_tag;
858 tp->tag_id = UD_TERM_DESC;
859 tp->tag_desc_ver = ecma_version;
860 tp->tag_sno = serialnum;
861 tp->tag_crc_len = sizeof (struct term_desc) -
862 sizeof (struct tag);
863 tp->tag_loc = nextblock;
864 wtvolseq(tp, nextblock, nextblock + volseq_sectors);
865 nextblock++;
866
867 /*
868 * Do the anchor volume descriptor
869 */
870 if (nextblock > FIRSTAVDP) {
871 (void) fprintf(stdout,
872 gettext("Volume integrity sequence"
873 " descriptors too long\n"));
874 exit(32);
875 }
876
877 nextblock = FIRSTAVDP;
878 bzero(buf, sectorsize);
879 /* LINTED */
880 avp = (struct anch_vol_desc_ptr *)buf;
881 tp = &avp->avd_tag;
882 tp->tag_id = UD_ANCH_VOL_DESC;
883 tp->tag_desc_ver = ecma_version;
884 tp->tag_sno = serialnum;
885 tp->tag_crc_len = sizeof (struct anch_vol_desc_ptr) -
886 sizeof (struct tag);
887 tp->tag_loc = nextblock;
888 setextad(&avp->avd_main_vdse,
889 volseq_sectors * sectorsize, mvds_loc);
890 setextad(&avp->avd_res_vdse,
891 volseq_sectors * sectorsize, rvds_loc);
892 bzero(buf2, sectorsize);
893 /* LINTED */
894 maketag(tp, (struct tag *)buf2);
895 wtfs(nextblock, sectorsize, buf2);
896 nextblock++;
897
898 tp->tag_loc = fssize;
899 /* LINTED */
900 maketag(tp, (struct tag *)buf2);
901 wtfs(fssize, sectorsize, buf2);
902
903 /*
904 * File Set Descriptor
905 */
906 bzero(buf, sectorsize);
907 /* LINTED */
908 fsp = (struct file_set_desc *)&buf;
909 tp = &fsp->fsd_tag;
910 tp->tag_id = UD_FILE_SET_DESC;
911 tp->tag_desc_ver = ecma_version;
912 tp->tag_sno = serialnum;
913 tp->tag_crc_len = sizeof (struct file_set_desc) -
914 sizeof (struct tag);
915 tp->tag_loc = nextlogblock;
916 setstamp(&fsp->fsd_time);
917 fsp->fsd_ilevel = 3;
918 fsp->fsd_mi_level = 3;
919 fsp->fsd_cs_list = 1;
920 fsp->fsd_mcs_list = 1;
921 fsp->fsd_fs_no = 0;
922 fsp->fsd_fsd_no = 0;
923 setcharspec(&fsp->fsd_lvidcs, 0, osta_unicode);
924 setdstring(fsp->fsd_lvid, udfs_label, 128);
925 setcharspec(&fsp->fsd_fscs, 0, osta_unicode);
926 setdstring(fsp->fsd_fsi, udfs_label, 32);
927 setdstring(fsp->fsd_cfi, "", 32);
928 setdstring(fsp->fsd_afi, "", 32);
929 lap = (long_ad_t *)&fsp->fsd_root_icb;
930 lap->lad_ext_len = sectorsize;
931 lap->lad_ext_loc = filesetblock + FILESETLEN;
932 lap->lad_ext_prn = 0;
933 bcopy(&udf_compliant, &fsp->fsd_did, sizeof (regid_t));
934 maketag(tp, tp);
935 wtfs(nextlogblock + part_start, sectorsize, (char *)tp);
936 nextlogblock++;
937
938 /*
939 * Terminating Descriptor
940 */
941 bzero(buf, sectorsize);
942 /* LINTED */
943 tdp = (struct term_desc *)buf;
944 tp = &tdp->td_tag;
945 tp->tag_id = UD_TERM_DESC;
946 tp->tag_desc_ver = ecma_version;
947 tp->tag_sno = serialnum;
948 tp->tag_crc_len = sizeof (struct term_desc) -
949 sizeof (struct tag);
950 tp->tag_loc = nextlogblock;
951 maketag(tp, tp);
952 wtfs(nextlogblock + part_start, sectorsize, (char *)tp);
953 nextlogblock++;
954
955 if (nextlogblock > filesetblock + FILESETLEN) {
956 (void) fprintf(stdout,
957 gettext("File set descriptor too long\n"));
958 exit(32);
959 }
960 nextlogblock = filesetblock + FILESETLEN;
961
962 /*
963 * Root File Entry
964 */
965 bzero(buf, sectorsize);
966 /* LINTED */
967 fp = (struct file_entry *)&buf;
968 tp = &fp->fe_tag;
969 tp->tag_id = UD_FILE_ENTRY;
970 tp->tag_desc_ver = ecma_version;
971 tp->tag_sno = serialnum;
972 tp->tag_loc = nextlogblock;
973 icb = &fp->fe_icb_tag;
974 icb->itag_prnde = 0;
975 icb->itag_strategy = STRAT_TYPE4;
976 icb->itag_param = 0; /* what does this mean? */
977 icb->itag_max_ent = 1;
978 icb->itag_ftype = FTYPE_DIRECTORY;
979 icb->itag_lb_loc = 0;
980 icb->itag_lb_prn = 0;
981 icb->itag_flags = ICB_FLAG_ARCHIVE;
982 fp->fe_uid = getuid();
983 fp->fe_gid = getgid();
984 fp->fe_perms = (0x1f << 10) | (0x5 << 5) | 0x5;
985 fp->fe_lcount = 1;
986 fp->fe_rec_for = 0;
987 fp->fe_rec_dis = 0;
988 fp->fe_rec_len = 0;
989 fp->fe_info_len = sizeof (struct file_id);
990 fp->fe_lbr = 1;
991 setstamp(&fp->fe_acc_time);
992 setstamp(&fp->fe_mod_time);
993 setstamp(&fp->fe_attr_time);
994 fp->fe_ckpoint = 1;
995 bcopy(&sunmicro, &fp->fe_impl_id, sizeof (regid_t));
996 fp->fe_uniq_id = 0;
997 fp->fe_len_ear = 0;
998 fp->fe_len_adesc = sizeof (short_ad_t);
999
1000 /* LINTED */
1001 sap = (short_ad_t *)(fp->fe_spec + fp->fe_len_ear);
1002 sap->sad_ext_len = sizeof (struct file_id);
1003 sap->sad_ext_loc = nextlogblock + 1;
1004 rootfelen = (char *)(sap + 1) - buf;
1005 tp->tag_crc_len = rootfelen - sizeof (struct tag);
1006 maketag(tp, tp);
1007 wtfs(nextlogblock + part_start, sectorsize, (char *)tp);
1008 nextlogblock++;
1009
1010 /*
1011 * Root Directory
1012 */
1013 bzero(buf, sectorsize);
1014 /* LINTED */
1015 fip = (struct file_id *)&buf;
1016 tp = &fip->fid_tag;
1017 tp->tag_id = UD_FILE_ID_DESC;
1018 tp->tag_desc_ver = ecma_version;
1019 tp->tag_sno = serialnum;
1020 tp->tag_crc_len = sizeof (struct file_id) -
1021 sizeof (struct tag);
1022 tp->tag_loc = nextlogblock;
1023 fip->fid_ver = 1;
1024 fip->fid_flags = FID_DIR | FID_PARENT;
1025 fip->fid_idlen = 0;
1026 fip->fid_iulen = 0;
1027 fip->fid_icb.lad_ext_len = sectorsize; /* rootfelen; */
1028 fip->fid_icb.lad_ext_loc = nextlogblock - 1;
1029 fip->fid_icb.lad_ext_prn = 0;
1030 maketag(tp, tp);
1031 wtfs(nextlogblock + part_start, sectorsize, (char *)tp);
1032 nextlogblock++;
1033
1034 /*
1035 * Now do the space bitmaps
1036 */
1037 if (part_unalloc >= 0) {
1038 int size = sectorsize * part_bmp_sectors;
1039
1040 sbp = (struct space_bmap_desc *)malloc(size);
1041 if (!sbp) {
1042 (void) fprintf(stdout,
1043 gettext("Can't allocate bitmap space\n"));
1044 exit(32);
1045 }
1046 bzero((char *)sbp, sectorsize * part_bmp_sectors);
1047 tp = &sbp->sbd_tag;
1048 tp->tag_id = UD_SPA_BMAP_DESC;
1049 tp->tag_desc_ver = ecma_version;
1050 tp->tag_sno = serialnum;
1051 tp->tag_crc_len = 0; /* Don't do CRCs on bitmaps */
1052 tp->tag_loc = part_unalloc;
1053 sbp->sbd_nbits = part_len;
1054 sbp->sbd_nbytes = part_bmp_bytes;
1055 maketag(tp, tp);
1056 if (part_unalloc >= 0) {
1057 int32_t i;
1058
1059 cp = (uint8_t *)sbp + SPACEMAP_OFF;
1060 i = nextlogblock / NBBY;
1061 cp[i++] = (0xff << (nextlogblock % NBBY)) & 0xff;
1062 while (i < part_bmp_bytes)
1063 cp[i++] = 0xff;
1064 if (part_len % NBBY)
1065 cp[--i] = (unsigned)0xff >>
1066 (NBBY - part_len % NBBY);
1067
1068 wtfs(part_unalloc + part_start, size, (char *)tp);
1069 }
1070 free((char *)sbp);
1071 }
1072
1073 /*
1074 * Volume Integrity Descriptor
1075 */
1076 nextblock = INTSEQSTART;
1077 endblock = nextblock + INTSEQLEN / sectorsize;
1078 /* LINTED */
1079 lvip = (struct log_vol_int_desc *)&lvid;
1080 tp = &lvip->lvid_tag;
1081 tp->tag_id = UD_LOG_VOL_INT;
1082 tp->tag_desc_ver = ecma_version;
1083 tp->tag_sno = serialnum;
1084 tp->tag_loc = nextblock;
1085 setstamp(&lvip->lvid_tstamp);
1086 lvip->lvid_int_type = LOG_VOL_CLOSE_INT;
1087 setextad(&lvip->lvid_nie, 0, 0);
1088 lvip->lvid_npart = 1;
1089 lvip->lvid_liu = 0x2e;
1090 lvip->lvid_uniqid = MAXID + 1;
1091 lvip->lvid_fst[0] = part_len - nextlogblock; /* Free space */
1092 lvip->lvid_fst[1] = part_len; /* Size */
1093 lviup = (struct lvid_iu *)&lvip->lvid_fst[2];
1094 bcopy(&sunmicro, &lviup->lvidiu_regid, sizeof (regid_t));
1095 lviup->lvidiu_nfiles = 0;
1096 lviup->lvidiu_ndirs = 1;
1097 lviup->lvidiu_mread = 0x102;
1098 lviup->lvidiu_mwrite = 0x102;
1099 lviup->lvidiu_maxwr = 0x150;
1100 tp->tag_crc_len = sizeof (struct log_vol_int_desc) + lvip->lvid_liu -
1101 sizeof (struct tag);
1102 maketag(tp, tp);
1103 wtfs(nextblock, sectorsize, (char *)tp);
1104 nextblock++;
1105
1106 /*
1107 * Terminating Descriptor
1108 */
1109 bzero(buf, sectorsize);
1110 /* LINTED */
1111 tdp = (struct term_desc *)buf;
1112 tp = &tdp->td_tag;
1113 tp->tag_id = UD_TERM_DESC;
1114 tp->tag_desc_ver = ecma_version;
1115 tp->tag_sno = serialnum;
1116 tp->tag_crc_len = sizeof (struct term_desc) - sizeof (struct tag);
1117 tp->tag_loc = nextblock;
1118 maketag(tp, tp);
1119 wtfs(nextblock, sectorsize, (char *)tp);
1120 nextblock++;
1121
1122 /* Zero out the rest of the LVI extent */
1123 bzero(buf, sectorsize);
1124 while (nextblock < endblock)
1125 wtfs(nextblock++, sectorsize, buf);
1126 }
1127
1128 /*
1129 * read a block from the file system
1130 */
1131 static void
rdfs(daddr_t bno,int size,char * bf)1132 rdfs(daddr_t bno, int size, char *bf)
1133 {
1134 int n, saverr;
1135
1136 if (llseek(fsi, (offset_t)bno * sectorsize, 0) < 0) {
1137 saverr = errno;
1138 (void) fprintf(stderr,
1139 gettext("seek error on sector %ld: %s\n"),
1140 bno, strerror(saverr));
1141 exit(32);
1142 }
1143 n = read(fsi, bf, size);
1144 if (n != size) {
1145 saverr = errno;
1146 (void) fprintf(stderr,
1147 gettext("read error on sector %ld: %s\n"),
1148 bno, strerror(saverr));
1149 exit(32);
1150 }
1151 }
1152
1153 /*
1154 * write a block to the file system
1155 */
1156 static void
wtfs(daddr_t bno,int size,char * bf)1157 wtfs(daddr_t bno, int size, char *bf)
1158 {
1159 int n, saverr;
1160
1161 if (fso == -1)
1162 return;
1163
1164 if (llseek(fso, (offset_t)bno * sectorsize, 0) < 0) {
1165 saverr = errno;
1166 (void) fprintf(stderr,
1167 gettext("seek error on sector %ld: %s\n"),
1168 bno, strerror(saverr));
1169 exit(32);
1170 }
1171 if (Nflag)
1172 return;
1173 n = write(fso, bf, size);
1174 if (n != size) {
1175 saverr = errno;
1176 (void) fprintf(stderr,
1177 gettext("write error on sector %ld: %s\n"),
1178 bno, strerror(saverr));
1179 exit(32);
1180 }
1181 }
1182
1183 static void
usage(void)1184 usage(void)
1185 {
1186 (void) fprintf(stderr,
1187 gettext("udfs usage: mkfs [-F FSType] [-V]"
1188 " [-m] [-o options] special size(sectors)\n"));
1189 (void) fprintf(stderr,
1190 gettext(" -m : dump fs cmd line used to make"
1191 " this partition\n"));
1192 (void) fprintf(stderr,
1193 gettext(" -V : print this command line and return\n"));
1194 (void) fprintf(stderr,
1195 gettext(" -o : udfs options: :psize=%d:label=%s\n"),
1196 sectorsize, udfs_label);
1197 (void) fprintf(stderr,
1198 gettext("NOTE that all -o suboptions: must"
1199 " be separated only by commas so as to\n"));
1200 (void) fprintf(stderr,
1201 gettext("be parsed as a single argument\n"));
1202 exit(32);
1203 }
1204
1205 /*ARGSUSED*/
1206 static void
dump_fscmd(char * fsys,int fsi)1207 dump_fscmd(char *fsys, int fsi)
1208 {
1209 (void) printf(gettext("mkfs -F udfs -o "));
1210 (void) printf("psize=%d,label=\"%s\" %s %d\n",
1211 sectorsize, oldlabel, fsys, oldfssize);
1212 }
1213
1214 /* number ************************************************************* */
1215 /* */
1216 /* Convert a numeric arg to binary */
1217 /* */
1218 /* Arg: big - maximum valid input number */
1219 /* Global arg: string - pointer to command arg */
1220 /* */
1221 /* Valid forms: 123 | 123k | 123*123 | 123x123 */
1222 /* */
1223 /* Return: converted number */
1224 /* */
1225 /* ******************************************************************** */
1226
1227 static int32_t
number(long big,char * param)1228 number(long big, char *param)
1229 {
1230 char *cs;
1231 int64_t n = 0;
1232 int64_t cut = BIG;
1233 int32_t minus = 0;
1234
1235 #define FOUND_MULT 0x1
1236 #define FOUND_K 0x2
1237
1238 cs = string;
1239 if (*cs == '-') {
1240 minus = 1;
1241 cs++;
1242 }
1243 n = 0;
1244 while ((*cs != ' ') && (*cs != '\0') && (*cs != ',')) {
1245 if ((*cs >= '0') && (*cs <= '9')) {
1246 n = n * 10 + *cs - '0';
1247 cs++;
1248 } else if ((*cs == '*') || (*cs == 'x')) {
1249 if (number_flags & FOUND_MULT) {
1250 (void) fprintf(stderr,
1251 gettext("mkfs: only one \"*\" "
1252 "or \"x\" allowed\n"));
1253 exit(2);
1254 }
1255 number_flags |= FOUND_MULT;
1256 cs++;
1257 string = cs;
1258 n = n * number(big, param);
1259 cs = string;
1260 continue;
1261 } else if (*cs == 'k') {
1262 if (number_flags & FOUND_K) {
1263 (void) fprintf(stderr,
1264 gettext("mkfs: only one \"k\" allowed\n"));
1265 exit(2);
1266 }
1267 number_flags |= FOUND_K;
1268 n = n * 1024;
1269 cs++;
1270 continue;
1271 } else {
1272 (void) fprintf(stderr,
1273 gettext("mkfs: bad numeric arg: \"%s\"\n"),
1274 string);
1275 exit(2);
1276 }
1277 }
1278
1279 if (n > cut) {
1280 (void) fprintf(stderr,
1281 gettext("mkfs: value for %s overflowed\n"), param);
1282 exit(2);
1283 }
1284
1285 if (minus) {
1286 n = -n;
1287 }
1288
1289 if ((n > big) || (n < 0)) {
1290 (void) fprintf(stderr,
1291 gettext("mkfs: argument %s out of range\n"), param);
1292 exit(2);
1293 }
1294
1295 string = cs;
1296 return ((int32_t)n);
1297 }
1298
1299 /* match ************************************************************** */
1300 /* */
1301 /* Compare two text strings for equality */
1302 /* */
1303 /* Arg: s - pointer to string to match with a command arg */
1304 /* Global arg: string - pointer to command arg */
1305 /* */
1306 /* Return: 1 if match, 0 if no match */
1307 /* If match, also reset `string' to point to the text */
1308 /* that follows the matching text. */
1309 /* */
1310 /* ******************************************************************** */
1311
1312 static int
match(char * s)1313 match(char *s)
1314 {
1315 char *cs;
1316
1317 cs = string;
1318 while (*cs++ == *s) {
1319 if (*s++ == '\0') {
1320 goto true;
1321 }
1322 }
1323 if (*s != '\0') {
1324 return (0);
1325 }
1326
1327 true:
1328 cs--;
1329 string = cs;
1330 return (1);
1331 }
1332
1333 static uint32_t
get_bsize(void)1334 get_bsize(void)
1335 {
1336 struct dk_cinfo info;
1337 struct fd_char fd_char;
1338 struct dk_minfo dkminfo;
1339
1340 if (ioctl(fso, DKIOCINFO, &info) < 0) {
1341 perror("mkfs DKIOCINFO ");
1342 (void) fprintf(stdout,
1343 gettext("DKIOCINFO failed using psize = 2048"
1344 " for creating file-system\n"));
1345 return (0);
1346 }
1347
1348 switch (info.dki_ctype) {
1349 case DKC_CDROM :
1350 return (2048);
1351 case DKC_SCSI_CCS :
1352 if (ioctl(fso, DKIOCGMEDIAINFO, &dkminfo) != -1) {
1353 if (dkminfo.dki_lbsize != 0 &&
1354 POWEROF2(dkminfo.dki_lbsize / DEV_BSIZE) &&
1355 dkminfo.dki_lbsize != DEV_BSIZE) {
1356 fprintf(stderr,
1357 gettext("The device sector size "
1358 "%u is not supported by udfs!\n"),
1359 dkminfo.dki_lbsize);
1360 (void) close(fso);
1361 exit(1);
1362 }
1363 }
1364 /* FALLTHROUGH */
1365 case DKC_INTEL82072 :
1366 /* FALLTHROUGH */
1367 case DKC_INTEL82077 :
1368 /* FALLTHROUGH */
1369 case DKC_DIRECT :
1370 if (ioctl(fso, FDIOGCHAR, &fd_char) >= 0) {
1371 return (fd_char.fdc_sec_size);
1372 }
1373 /* FALLTHROUGH */
1374 case DKC_PCMCIA_ATA :
1375 return (512);
1376 default :
1377 return (0);
1378 }
1379 }
1380
1381 /*
1382 * Read in the volume sequences descriptors.
1383 */
1384 static int
readvolseq(void)1385 readvolseq(void)
1386 {
1387 struct tag *tp;
1388 uint8_t *cp, *end;
1389 int err;
1390 struct pri_vol_desc *pvolp;
1391 struct part_desc *partp = NULL;
1392 struct log_vol_desc *logvp = NULL;
1393 struct anch_vol_desc_ptr *avp;
1394 char *main_vdbuf;
1395 uint32_t nextblock;
1396
1397 avp = (struct anch_vol_desc_ptr *)malloc(sectorsize);
1398 rdfs(FIRSTAVDP, sectorsize, (char *)avp);
1399 tp = (struct tag *)avp;
1400 err = verifytag(tp, FIRSTAVDP, tp, UD_ANCH_VOL_DESC);
1401 if (err)
1402 return (0);
1403 main_vdbuf = malloc(avp->avd_main_vdse.ext_len);
1404 if (main_vdbuf == NULL) {
1405 (void) fprintf(stderr, gettext("Cannot allocate space for "
1406 "volume sequences\n"));
1407 exit(32);
1408 }
1409 rdfs(avp->avd_main_vdse.ext_loc, avp->avd_main_vdse.ext_len,
1410 main_vdbuf);
1411 end = (uint8_t *)main_vdbuf + avp->avd_main_vdse.ext_len;
1412
1413 nextblock = avp->avd_main_vdse.ext_loc;
1414 for (cp = (uint8_t *)main_vdbuf; cp < end; cp += sectorsize,
1415 nextblock++) {
1416 /* LINTED */
1417 tp = (struct tag *)cp;
1418 err = verifytag(tp, nextblock, tp, 0);
1419 if (err)
1420 continue;
1421
1422 switch (tp->tag_id) {
1423 case UD_PRI_VOL_DESC:
1424 /* Bump serial number, according to spec. */
1425 serialnum = tp->tag_sno + 1;
1426 pvolp = (struct pri_vol_desc *)tp;
1427 oldlabel = pvolp->pvd_vol_id + 1;
1428 break;
1429 case UD_ANCH_VOL_DESC:
1430 avp = (struct anch_vol_desc_ptr *)tp;
1431 break;
1432 case UD_VOL_DESC_PTR:
1433 break;
1434 case UD_IMPL_USE_DESC:
1435 break;
1436 case UD_PART_DESC:
1437 partp = (struct part_desc *)tp;
1438 part_start = partp->pd_part_start;
1439 part_len = partp->pd_part_length;
1440 oldfssize = part_start + part_len;
1441 break;
1442 case UD_LOG_VOL_DESC:
1443 logvp = (struct log_vol_desc *)tp;
1444 break;
1445 case UD_UNALL_SPA_DESC:
1446 break;
1447 case UD_TERM_DESC:
1448 goto done;
1449 break;
1450 case UD_LOG_VOL_INT:
1451 break;
1452 default:
1453 break;
1454 }
1455 }
1456 done:
1457 if (!partp || !logvp) {
1458 return (0);
1459 }
1460 return (1);
1461 }
1462
1463 uint32_t
get_last_block(void)1464 get_last_block(void)
1465 {
1466 struct vtoc vtoc;
1467 struct dk_cinfo dki_info;
1468
1469 if (ioctl(fsi, DKIOCGVTOC, (intptr_t)&vtoc) != 0) {
1470 (void) fprintf(stderr, gettext("Unable to read VTOC\n"));
1471 return (0);
1472 }
1473
1474 if (vtoc.v_sanity != VTOC_SANE) {
1475 (void) fprintf(stderr, gettext("Vtoc.v_sanity != VTOC_SANE\n"));
1476 return (0);
1477 }
1478
1479 if (ioctl(fsi, DKIOCINFO, (intptr_t)&dki_info) != 0) {
1480 (void) fprintf(stderr,
1481 gettext("Could not get the slice information\n"));
1482 return (0);
1483 }
1484
1485 if (dki_info.dki_partition > V_NUMPAR) {
1486 (void) fprintf(stderr,
1487 gettext("dki_info.dki_partition > V_NUMPAR\n"));
1488 return (0);
1489 }
1490
1491 return ((uint32_t)vtoc.v_part[dki_info.dki_partition].p_size);
1492 }
1493