324 lines
8.4 KiB
C
324 lines
8.4 KiB
C
/* $NetBSD: newfs_udf.c,v 1.24 2022/04/09 09:58:11 riastradh Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2006, 2008, 2013, 2021, 2022 Reinoud Zandijk
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* TODO
|
|
* - implement metadata formatting for BD-R
|
|
* - implement support for a read-only companion partition?
|
|
*/
|
|
|
|
#define _EXPOSE_MMC
|
|
#if 0
|
|
# define DEBUG
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <dirent.h>
|
|
#include <inttypes.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <util.h>
|
|
#include <time.h>
|
|
#include <assert.h>
|
|
#include <err.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/cdio.h>
|
|
#include <sys/disklabel.h>
|
|
#include <sys/dkio.h>
|
|
#include <sys/param.h>
|
|
|
|
#include <fs/udf/udf_mount.h>
|
|
|
|
#include "mountprog.h"
|
|
#include "udf_core.h"
|
|
#include "newfs_udf.h"
|
|
|
|
/* Identifying myself */
|
|
#define IMPL_NAME "*NetBSD newfs_udf 10.0"
|
|
#define APP_VERSION_MAIN 0
|
|
#define APP_VERSION_SUB 5
|
|
|
|
/* prototypes */
|
|
int newfs_udf(int argc, char **argv);
|
|
static void usage(void) __attribute__((__noreturn__));
|
|
|
|
/* global variables describing disc and format requests */
|
|
char *format_str; /* format: string representation */
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static int
|
|
udf_prepare_format_track512(void)
|
|
{
|
|
struct mmc_trackinfo ti;
|
|
struct mmc_op op;
|
|
int error;
|
|
|
|
if (!(context.format_flags & FORMAT_TRACK512))
|
|
return 0;
|
|
|
|
/* get last track (again) */
|
|
ti.tracknr = mmc_discinfo.last_track_last_session;
|
|
error = udf_update_trackinfo(&ti);
|
|
if (error)
|
|
return error;
|
|
|
|
/* Split up the space at 512 for iso cd9660 hooking */
|
|
memset(&op, 0, sizeof(op));
|
|
op.operation = MMC_OP_RESERVETRACK_NWA; /* UPTO nwa */
|
|
op.mmc_profile = mmc_discinfo.mmc_profile;
|
|
op.extent = 512; /* size */
|
|
error = ioctl(dev_fd, MMCOP, &op);
|
|
|
|
return error;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static int
|
|
udf_do_newfs(void)
|
|
{
|
|
int error;
|
|
|
|
error = udf_do_newfs_prefix();
|
|
if (error)
|
|
return error;
|
|
error = udf_do_rootdir();
|
|
if (error)
|
|
return error;
|
|
error = udf_do_newfs_postfix();
|
|
|
|
return error;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
(void)fprintf(stderr, "Usage: %s [-cFM] [-L loglabel] "
|
|
"[-P discid] [-S sectorsize] [-s size] [-p perc] "
|
|
"[-t gmtoff] [-v min_udf] [-V max_udf] special\n", getprogname());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
struct tm *tm;
|
|
time_t now;
|
|
off_t setsize;
|
|
char scrap[255], *colon;
|
|
int ch, req_enable, req_disable;
|
|
int error;
|
|
|
|
setprogname(argv[0]);
|
|
|
|
/* initialise */
|
|
format_str = strdup("");
|
|
req_enable = req_disable = 0;
|
|
setsize = 0;
|
|
|
|
emul_mmc_profile = -1; /* invalid->no emulation */
|
|
emul_packetsize = 1; /* reasonable default */
|
|
emul_sectorsize = 512; /* minimum allowed sector size */
|
|
emul_size = 0; /* empty */
|
|
|
|
srandom((unsigned long) time(NULL));
|
|
udf_init_create_context();
|
|
context.app_name = "*NetBSD UDF";
|
|
context.app_version_main = APP_VERSION_MAIN;
|
|
context.app_version_sub = APP_VERSION_SUB;
|
|
context.impl_name = IMPL_NAME;
|
|
|
|
/* minimum and maximum UDF versions we advise */
|
|
context.min_udf = 0x201;
|
|
context.max_udf = 0x250;
|
|
|
|
/* use user's time zone as default */
|
|
(void)time(&now);
|
|
tm = localtime(&now);
|
|
context.gmtoff = tm->tm_gmtoff;
|
|
|
|
/* process options */
|
|
while ((ch = getopt(argc, argv, "cFL:Mp:P:s:S:B:t:v:V:")) != -1) {
|
|
switch (ch) {
|
|
case 'c' :
|
|
context.check_surface = 1;
|
|
break;
|
|
case 'F' :
|
|
context.create_new_session = 1;
|
|
break;
|
|
case 'L' :
|
|
if (context.logvol_name) free(context.logvol_name);
|
|
context.logvol_name = strdup(optarg);
|
|
break;
|
|
case 'M' :
|
|
req_disable |= FORMAT_META;
|
|
break;
|
|
case 'p' :
|
|
context.meta_perc = a_num(optarg, "meta_perc");
|
|
/* limit to `sensible` values */
|
|
context.meta_perc = MIN(context.meta_perc, 99);
|
|
context.meta_perc = MAX(context.meta_perc, 1);
|
|
break;
|
|
case 'v' :
|
|
context.min_udf = a_udf_version(optarg, "min_udf");
|
|
if (context.min_udf > context.max_udf)
|
|
context.max_udf = context.min_udf;
|
|
break;
|
|
case 'V' :
|
|
context.max_udf = a_udf_version(optarg, "max_udf");
|
|
if (context.min_udf > context.max_udf)
|
|
context.min_udf = context.max_udf;
|
|
break;
|
|
case 'P' :
|
|
/* check if there is a ':' in the name */
|
|
if ((colon = strstr(optarg, ":"))) {
|
|
if (context.volset_name)
|
|
free(context.volset_name);
|
|
*colon = 0;
|
|
context.volset_name = strdup(optarg);
|
|
optarg = colon+1;
|
|
}
|
|
if (context.primary_name)
|
|
free(context.primary_name);
|
|
if ((strstr(optarg, ":")))
|
|
errx(1, "primary name can't have ':' in its name");
|
|
context.primary_name = strdup(optarg);
|
|
break;
|
|
case 's' :
|
|
/* support for files, set file size */
|
|
/* XXX support for formatting recordables on vnd/file? */
|
|
if (dehumanize_number(optarg, &setsize) < 0)
|
|
errx(1, "can't parse size argument");
|
|
setsize = MAX(0, setsize);
|
|
break;
|
|
case 'S' :
|
|
emul_sectorsize = a_num(optarg, "secsize");
|
|
emul_sectorsize = MAX(512, emul_sectorsize);
|
|
break;
|
|
case 'B' :
|
|
emul_packetsize = a_num(optarg,
|
|
"blockingnr, packetsize");
|
|
emul_packetsize = MAX(emul_packetsize, 1);
|
|
emul_packetsize = MIN(emul_packetsize, 32);
|
|
break;
|
|
case 't' :
|
|
/* time zone override */
|
|
context.gmtoff = a_num(optarg, "gmtoff");
|
|
break;
|
|
default :
|
|
usage();
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
|
|
if (optind + 1 != argc)
|
|
usage();
|
|
|
|
/* get device and directory specifier */
|
|
dev_name = argv[optind];
|
|
|
|
emul_size = setsize;
|
|
error = udf_opendisc(dev_name, O_RDWR | O_CREAT | O_TRUNC);
|
|
if (error) {
|
|
udf_closedisc();
|
|
errx(1, "can't open device");
|
|
}
|
|
|
|
/* get 'disc' information */
|
|
error = udf_update_discinfo();
|
|
if (error) {
|
|
udf_closedisc();
|
|
errx(1, "can't retrieve discinfo");
|
|
}
|
|
|
|
/* derive disc identifiers when not specified and check given */
|
|
error = udf_proces_names();
|
|
if (error) {
|
|
/* error message has been printed */
|
|
udf_closedisc();
|
|
errx(1, "bad names given");
|
|
}
|
|
|
|
/* derive newfs disc format from disc profile */
|
|
error = udf_derive_format(req_enable, req_disable);
|
|
if (error) {
|
|
/* error message has been printed */
|
|
udf_closedisc();
|
|
errx(1, "can't derive format from media/settings");
|
|
}
|
|
|
|
udf_dump_discinfo(&mmc_discinfo);
|
|
printf("Formatting disc compatible with UDF version %x to %x\n\n",
|
|
context.min_udf, context.max_udf);
|
|
(void)snprintb(scrap, sizeof(scrap), FORMAT_FLAGBITS,
|
|
(uint64_t) context.format_flags);
|
|
printf("UDF properties %s\n", scrap);
|
|
printf("Volume set `%s'\n", context.volset_name);
|
|
printf("Primary volume `%s`\n", context.primary_name);
|
|
printf("Logical volume `%s`\n", context.logvol_name);
|
|
if (context.format_flags & FORMAT_META)
|
|
printf("Metadata percentage %d %%\n", context.meta_perc);
|
|
printf("\n");
|
|
|
|
/* prepare disc if necessary (recordables mainly) */
|
|
error = udf_prepare_disc();
|
|
if (error) {
|
|
udf_closedisc();
|
|
errx(1, "preparing disc failed");
|
|
}
|
|
error = udf_prepare_format_track512();
|
|
if (error) {
|
|
udf_closedisc();
|
|
errx(1, "reservation for track512 failed");
|
|
}
|
|
|
|
/* perform the newfs itself */
|
|
udf_allow_writing();
|
|
error = udf_do_newfs();
|
|
udf_closedisc();
|
|
|
|
if (error)
|
|
return EXIT_FAILURE;
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|