/* $NetBSD: newfs_udf.c,v 1.12 2011/05/26 07:59:08 reinoud Exp $ */ /* * Copyright (c) 2006, 2008 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "mountprog.h" #include "udf_create.h" /* general settings */ #define UDF_512_TRACK 0 /* NOT recommended */ #define UDF_META_PERC 20 /* picked */ /* prototypes */ int newfs_udf(int argc, char **argv); static void usage(void) __attribute__((__noreturn__)); int udf_derive_format(int req_en, int req_dis, int force); int udf_proces_names(void); int udf_do_newfs(void); /* Identifying myself */ #define APP_NAME "*NetBSD newfs" #define APP_VERSION_MAIN 0 #define APP_VERSION_SUB 3 #define IMPL_NAME "*NetBSD userland UDF" /* global variables describing disc and format requests */ int fd; /* device: file descriptor */ char *dev; /* device: name */ struct mmc_discinfo mmc_discinfo; /* device: disc info */ char *format_str; /* format: string representation */ int format_flags; /* format: attribute flags */ int media_accesstype; /* derived from current mmc cap */ int check_surface; /* for rewritables */ int wrtrack_skew; int meta_perc = UDF_META_PERC; float meta_fract = (float) UDF_META_PERC / 100.0; /* shared structure between udf_create.c users */ struct udf_create_context context; struct udf_disclayout layout; /* queue for temporary storage of sectors to be written out */ struct wrsect { uint32_t sectornr; uint8_t *sector_data; TAILQ_ENTRY(wrsect) next; }; /* write queue and track blocking skew */ TAILQ_HEAD(wrsect_list, wrsect) write_queue; /* --------------------------------------------------------------------- */ /* * write queue implementation */ static int udf_write_sector(void *sector, uint32_t location) { struct wrsect *pos, *seekpos; /* search location */ TAILQ_FOREACH_REVERSE(seekpos, &write_queue, wrsect_list, next) { if (seekpos->sectornr <= location) break; } if ((seekpos == NULL) || (seekpos->sectornr != location)) { pos = calloc(1, sizeof(struct wrsect)); if (pos == NULL) return ENOMEM; /* allocate space for copy of sector data */ pos->sector_data = calloc(1, context.sector_size); if (pos->sector_data == NULL) return ENOMEM; pos->sectornr = location; if (seekpos) { TAILQ_INSERT_AFTER(&write_queue, seekpos, pos, next); } else { TAILQ_INSERT_HEAD(&write_queue, pos, next); } } else { pos = seekpos; } memcpy(pos->sector_data, sector, context.sector_size); return 0; } /* * Now all write requests are queued in the TAILQ, write them out to the * disc/file image. Special care needs to be taken for devices that are only * strict overwritable i.e. only in packet size chunks * * XXX support for growing vnd? */ static int writeout_write_queue(void) { struct wrsect *pos; uint64_t offset; uint32_t line_len, line_offset; uint32_t line_start, new_line_start, relpos; uint32_t blockingnr; uint8_t *linebuf, *adr; blockingnr = layout.blockingnr; line_len = blockingnr * context.sector_size; line_offset = wrtrack_skew * context.sector_size; linebuf = malloc(line_len); if (linebuf == NULL) return ENOMEM; pos = TAILQ_FIRST(&write_queue); bzero(linebuf, line_len); /* * Always writing out in whole lines now; this is slightly wastefull * on logical overwrite volumes but it reduces complexity and the loss * is near zero compared to disc size. */ line_start = (pos->sectornr - wrtrack_skew) / blockingnr; TAILQ_FOREACH(pos, &write_queue, next) { new_line_start = (pos->sectornr - wrtrack_skew) / blockingnr; if (new_line_start != line_start) { /* write out */ offset = (uint64_t) line_start * line_len + line_offset; #ifdef DEBUG printf("WRITEOUT %08"PRIu64" + %02d -- " "[%08"PRIu64"..%08"PRIu64"]\n", offset / context.sector_size, blockingnr, offset / context.sector_size, offset / context.sector_size + blockingnr-1); #endif if (pwrite(fd, linebuf, line_len, offset) < 0) { perror("Writing failed"); return errno; } line_start = new_line_start; bzero(linebuf, line_len); } relpos = (pos->sectornr - wrtrack_skew) % blockingnr; adr = linebuf + relpos * context.sector_size; memcpy(adr, pos->sector_data, context.sector_size); } /* writeout last chunk */ offset = (uint64_t) line_start * line_len + line_offset; #ifdef DEBUG printf("WRITEOUT %08"PRIu64" + %02d -- [%08"PRIu64"..%08"PRIu64"]\n", offset / context.sector_size, blockingnr, offset / context.sector_size, offset / context.sector_size + blockingnr-1); #endif if (pwrite(fd, linebuf, line_len, offset) < 0) { perror("Writing failed"); return errno; } /* success */ return 0; } /* --------------------------------------------------------------------- */ /* * mmc_discinfo and mmc_trackinfo readers modified from origional in udf main * code in sys/fs/udf/ */ #ifdef DEBUG static void udf_dump_discinfo(struct mmc_discinfo *di) { char bits[128]; printf("Device/media info :\n"); printf("\tMMC profile 0x%02x\n", di->mmc_profile); printf("\tderived class %d\n", di->mmc_class); printf("\tsector size %d\n", di->sector_size); printf("\tdisc state %d\n", di->disc_state); printf("\tlast ses state %d\n", di->last_session_state); printf("\tbg format state %d\n", di->bg_format_state); printf("\tfrst track %d\n", di->first_track); printf("\tfst on last ses %d\n", di->first_track_last_session); printf("\tlst on last ses %d\n", di->last_track_last_session); printf("\tlink block penalty %d\n", di->link_block_penalty); snprintb(bits, sizeof(bits), MMC_DFLAGS_FLAGBITS, (uint64_t) di->disc_flags); printf("\tdisc flags %s\n", bits); printf("\tdisc id %x\n", di->disc_id); printf("\tdisc barcode %"PRIx64"\n", di->disc_barcode); printf("\tnum sessions %d\n", di->num_sessions); printf("\tnum tracks %d\n", di->num_tracks); snprintb(bits, sizeof(bits), MMC_CAP_FLAGBITS, di->mmc_cur); printf("\tcapabilities cur %s\n", bits); snprintb(bits, sizeof(bits), MMC_CAP_FLAGBITS, di->mmc_cap); printf("\tcapabilities cap %s\n", bits); printf("\n"); printf("\tlast_possible_lba %d\n", di->last_possible_lba); printf("\n"); } #else #define udf_dump_discinfo(a); #endif /* --------------------------------------------------------------------- */ static int udf_update_discinfo(struct mmc_discinfo *di) { struct disklabel disklab; struct partition *dp; struct stat st; int partnr, error; memset(di, 0, sizeof(struct mmc_discinfo)); /* check if we're on a MMC capable device, i.e. CD/DVD */ error = ioctl(fd, MMCGETDISCINFO, di); if (error == 0) return 0; /* * disc partition support; note we can't use DIOCGPART in userland so * get disc label and use the stat info to get the partition number. */ if (ioctl(fd, DIOCGDINFO, &disklab) == -1) { /* failed to get disclabel! */ perror("disklabel"); return errno; } /* get disk partition it refers to */ fstat(fd, &st); partnr = DISKPART(st.st_rdev); dp = &disklab.d_partitions[partnr]; /* set up a disc info profile for partitions */ di->mmc_profile = 0x01; /* disc type */ di->mmc_class = MMC_CLASS_DISC; di->disc_state = MMC_STATE_CLOSED; di->last_session_state = MMC_STATE_CLOSED; di->bg_format_state = MMC_BGFSTATE_COMPLETED; di->link_block_penalty = 0; di->mmc_cur = MMC_CAP_RECORDABLE | MMC_CAP_REWRITABLE | MMC_CAP_ZEROLINKBLK | MMC_CAP_HW_DEFECTFREE; di->mmc_cap = di->mmc_cur; di->disc_flags = MMC_DFLAGS_UNRESTRICTED; /* TODO problem with last_possible_lba on resizable VND; request */ if (dp->p_size == 0) { perror("faulty disklabel partition returned, check label\n"); return EIO; } di->last_possible_lba = dp->p_size - 1; di->sector_size = disklab.d_secsize; di->num_sessions = 1; di->num_tracks = 1; di->first_track = 1; di->first_track_last_session = di->last_track_last_session = 1; return 0; } static int udf_update_trackinfo(struct mmc_discinfo *di, struct mmc_trackinfo *ti) { int error, class; class = di->mmc_class; if (class != MMC_CLASS_DISC) { /* tracknr specified in struct ti */ error = ioctl(fd, MMCGETTRACKINFO, ti); return error; } /* discs partition support */ if (ti->tracknr != 1) return EIO; /* create fake ti (TODO check for resized vnds) */ ti->sessionnr = 1; ti->track_mode = 0; /* XXX */ ti->data_mode = 0; /* XXX */ ti->flags = MMC_TRACKINFO_LRA_VALID | MMC_TRACKINFO_NWA_VALID; ti->track_start = 0; ti->packet_size = 1; /* TODO support for resizable vnd */ ti->track_size = di->last_possible_lba; ti->next_writable = di->last_possible_lba; ti->last_recorded = ti->next_writable; ti->free_blocks = 0; return 0; } static int udf_setup_writeparams(struct mmc_discinfo *di) { struct mmc_writeparams mmc_writeparams; int error; if (di->mmc_class == MMC_CLASS_DISC) return 0; /* * only CD burning normally needs setting up, but other disc types * might need other settings to be made. The MMC framework will set up * the nessisary recording parameters according to the disc * characteristics read in. Modifications can be made in the discinfo * structure passed to change the nature of the disc. */ memset(&mmc_writeparams, 0, sizeof(struct mmc_writeparams)); mmc_writeparams.mmc_class = di->mmc_class; mmc_writeparams.mmc_cur = di->mmc_cur; /* * UDF dictates first track to determine track mode for the whole * disc. [UDF 1.50/6.10.1.1, UDF 1.50/6.10.2.1] * To prevent problems with a `reserved' track in front we start with * the 2nd track and if that is not valid, go for the 1st. */ mmc_writeparams.tracknr = 2; mmc_writeparams.data_mode = MMC_DATAMODE_DEFAULT; /* XA disc */ mmc_writeparams.track_mode = MMC_TRACKMODE_DEFAULT; /* data */ error = ioctl(fd, MMCSETUPWRITEPARAMS, &mmc_writeparams); if (error) { mmc_writeparams.tracknr = 1; error = ioctl(fd, MMCSETUPWRITEPARAMS, &mmc_writeparams); } return error; } static void udf_synchronise_caches(void) { struct mmc_op mmc_op; bzero(&mmc_op, sizeof(struct mmc_op)); mmc_op.operation = MMC_OP_SYNCHRONISECACHE; /* this device might not know this ioct, so just be ignorant */ (void) ioctl(fd, MMCOP, &mmc_op); } /* --------------------------------------------------------------------- */ static int udf_write_dscr_phys(union dscrptr *dscr, uint32_t location, uint32_t sects) { uint32_t phys, cnt; uint8_t *bpos; int error; dscr->tag.tag_loc = udf_rw32(location); (void) udf_validate_tag_and_crc_sums(dscr); for (cnt = 0; cnt < sects; cnt++) { bpos = (uint8_t *) dscr; bpos += context.sector_size * cnt; phys = location + cnt; error = udf_write_sector(bpos, phys); if (error) return error; } return 0; } static int udf_write_dscr_virt(union dscrptr *dscr, uint32_t location, uint32_t vpart, uint32_t sects) { struct file_entry *fe; struct extfile_entry *efe; struct extattrhdr_desc *extattrhdr; uint32_t phys, cnt; uint8_t *bpos; int error; extattrhdr = NULL; if (udf_rw16(dscr->tag.id) == TAGID_FENTRY) { fe = (struct file_entry *) dscr; if (udf_rw32(fe->l_ea) > 0) extattrhdr = (struct extattrhdr_desc *) fe->data; } if (udf_rw16(dscr->tag.id) == TAGID_EXTFENTRY) { efe = (struct extfile_entry *) dscr; if (udf_rw32(efe->l_ea) > 0) extattrhdr = (struct extattrhdr_desc *) efe->data; } if (extattrhdr) { extattrhdr->tag.tag_loc = udf_rw32(location); udf_validate_tag_and_crc_sums((union dscrptr *) extattrhdr); } dscr->tag.tag_loc = udf_rw32(location); udf_validate_tag_and_crc_sums(dscr); for (cnt = 0; cnt < sects; cnt++) { bpos = (uint8_t *) dscr; bpos += context.sector_size * cnt; /* NOTE linear mapping assumed in the ranges used */ phys = context.vtop_offset[vpart] + location + cnt; error = udf_write_sector(bpos, phys); if (error) return error; } return 0; } /* --------------------------------------------------------------------- */ /* * udf_derive_format derives the format_flags from the disc's mmc_discinfo. * The resulting flags uniquely define a disc format. Note there are at least * 7 distinct format types defined in UDF. */ #define UDF_VERSION(a) \ (((a) == 0x100) || ((a) == 0x102) || ((a) == 0x150) || ((a) == 0x200) || \ ((a) == 0x201) || ((a) == 0x250) || ((a) == 0x260)) int udf_derive_format(int req_enable, int req_disable, int force) { /* disc writability, formatted, appendable */ if ((mmc_discinfo.mmc_cur & MMC_CAP_RECORDABLE) == 0) { (void)printf("Can't newfs readonly device\n"); return EROFS; } if (mmc_discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) { /* sequentials need sessions appended */ if (mmc_discinfo.disc_state == MMC_STATE_CLOSED) { (void)printf("Can't append session to a closed disc\n"); return EROFS; } if ((mmc_discinfo.disc_state != MMC_STATE_EMPTY) && !force) { (void)printf("Disc not empty! Use -F to force " "initialisation\n"); return EROFS; } } else { /* check if disc (being) formatted or has been started on */ if (mmc_discinfo.disc_state == MMC_STATE_EMPTY) { (void)printf("Disc is not formatted\n"); return EROFS; } } /* determine UDF format */ format_flags = 0; if (mmc_discinfo.mmc_cur & MMC_CAP_REWRITABLE) { /* all rewritable media */ format_flags |= FORMAT_REWRITABLE; if (context.min_udf >= 0x0250) { /* standard dictates meta as default */ format_flags |= FORMAT_META; } if ((mmc_discinfo.mmc_cur & MMC_CAP_HW_DEFECTFREE) == 0) { /* sparables for defect management */ if (context.min_udf >= 0x150) format_flags |= FORMAT_SPARABLE; } } else { /* all once recordable media */ format_flags |= FORMAT_WRITEONCE; if (mmc_discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) { format_flags |= FORMAT_SEQUENTIAL; if (mmc_discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE) { /* logical overwritable */ format_flags |= FORMAT_LOW; } else { /* have to use VAT for overwriting */ format_flags |= FORMAT_VAT; } } else { /* rare WORM devices, but BluRay has one, strat4096 */ format_flags |= FORMAT_WORM; } } /* enable/disable requests */ if (req_disable & FORMAT_META) { format_flags &= ~(FORMAT_META | FORMAT_LOW); req_disable &= ~FORMAT_META; } if (req_disable || req_enable) { (void)printf("Internal error\n"); (void)printf("\tunrecognised enable/disable req.\n"); return EIO; } if ((format_flags & FORMAT_VAT) & UDF_512_TRACK) format_flags |= FORMAT_TRACK512; /* determine partition/media access type */ media_accesstype = UDF_ACCESSTYPE_NOT_SPECIFIED; if (mmc_discinfo.mmc_cur & MMC_CAP_REWRITABLE) { media_accesstype = UDF_ACCESSTYPE_OVERWRITABLE; if (mmc_discinfo.mmc_cur & MMC_CAP_ERASABLE) media_accesstype = UDF_ACCESSTYPE_REWRITEABLE; } else { /* all once recordable media */ media_accesstype = UDF_ACCESSTYPE_WRITE_ONCE; } if (mmc_discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE) media_accesstype = UDF_ACCESSTYPE_PSEUDO_OVERWITE; /* adjust minimum version limits */ if (format_flags & FORMAT_VAT) context.min_udf = MAX(context.min_udf, 0x0150); if (format_flags & FORMAT_SPARABLE) context.min_udf = MAX(context.min_udf, 0x0150); if (format_flags & FORMAT_META) context.min_udf = MAX(context.min_udf, 0x0250); if (format_flags & FORMAT_LOW) context.min_udf = MAX(context.min_udf, 0x0260); /* adjust maximum version limits not to tease or break things */ if (!(format_flags & (FORMAT_META | FORMAT_LOW)) && (context.max_udf > 0x200)) context.max_udf = 0x201; if ((format_flags & (FORMAT_VAT | FORMAT_SPARABLE)) == 0) if (context.max_udf <= 0x150) context.min_udf = 0x102; /* limit Ecma 167 descriptor if possible/needed */ context.dscrver = 3; if ((context.min_udf < 0x200) || (context.max_udf < 0x200)) { context.dscrver = 2; context.max_udf = 0x150; /* last version < 0x200 */ } /* is it possible ? */ if (context.min_udf > context.max_udf) { (void)printf("Initialisation prohibited by specified maximum " "UDF version 0x%04x. Minimum version required 0x%04x\n", context.max_udf, context.min_udf); return EPERM; } if (!UDF_VERSION(context.min_udf) || !UDF_VERSION(context.max_udf)) { printf("Choose UDF version numbers from " "0x102, 0x150, 0x200, 0x201, 0x250 and 0x260\n"); printf("Default version is 0x201\n"); return EPERM; } return 0; } #undef UDF_VERSION /* --------------------------------------------------------------------- */ int udf_proces_names(void) { uint32_t primary_nr; uint64_t volset_nr; if (context.logvol_name == NULL) context.logvol_name = strdup("anonymous"); if (context.primary_name == NULL) { if (mmc_discinfo.disc_flags & MMC_DFLAGS_DISCIDVALID) { primary_nr = mmc_discinfo.disc_id; } else { primary_nr = (uint32_t) random(); } context.primary_name = calloc(32, 1); sprintf(context.primary_name, "%08"PRIx32, primary_nr); } if (context.volset_name == NULL) { if (mmc_discinfo.disc_flags & MMC_DFLAGS_BARCODEVALID) { volset_nr = mmc_discinfo.disc_barcode; } else { volset_nr = (uint32_t) random(); volset_nr |= ((uint64_t) random()) << 32; } context.volset_name = calloc(128,1); sprintf(context.volset_name, "%016"PRIx64, volset_nr); } if (context.fileset_name == NULL) context.fileset_name = strdup("anonymous"); /* check passed/created identifiers */ if (strlen(context.logvol_name) > 128) { (void)printf("Logical volume name too long\n"); return EINVAL; } if (strlen(context.primary_name) > 32) { (void)printf("Primary volume name too long\n"); return EINVAL; } if (strlen(context.volset_name) > 128) { (void)printf("Volume set name too long\n"); return EINVAL; } if (strlen(context.fileset_name) > 32) { (void)printf("Fileset name too long\n"); return EINVAL; } /* signal all OK */ return 0; } /* --------------------------------------------------------------------- */ static int udf_prepare_disc(void) { struct mmc_trackinfo ti; struct mmc_op op; int tracknr, error; /* If the last track is damaged, repair it */ ti.tracknr = mmc_discinfo.last_track_last_session; error = udf_update_trackinfo(&mmc_discinfo, &ti); if (error) return error; if (ti.flags & MMC_TRACKINFO_DAMAGED) { /* * Need to repair last track before anything can be done. * this is an optional command, so ignore its error but report * warning. */ memset(&op, 0, sizeof(op)); op.operation = MMC_OP_REPAIRTRACK; op.mmc_profile = mmc_discinfo.mmc_profile; op.tracknr = ti.tracknr; error = ioctl(fd, MMCOP, &op); if (error) (void)printf("Drive can't explicitly repair last " "damaged track, but it might autorepair\n"); } /* last track (if any) might not be damaged now, operations are ok now */ /* setup write parameters from discinfo */ error = udf_setup_writeparams(&mmc_discinfo); if (error) return error; /* if the drive is not sequential, we're done */ if ((mmc_discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) == 0) return 0; #ifdef notyet /* if last track is not the reserved but an empty track, unreserve it */ if (ti.flags & MMC_TRACKINFO_BLANK) { if (ti.flags & MMC_TRACKINFO_RESERVED == 0) { memset(&op, 0, sizeof(op)); op.operation = MMC_OP_UNRESERVETRACK; op.mmc_profile = mmc_discinfo.mmc_profile; op.tracknr = ti.tracknr; error = ioctl(fd, MMCOP, &op); if (error) return error; /* update discinfo since it changed by the operation */ error = udf_update_discinfo(&mmc_discinfo); if (error) return error; } } #endif /* close the last session if its still open */ if (mmc_discinfo.last_session_state == MMC_STATE_INCOMPLETE) { printf("Closing last open session if present\n"); /* close all associated tracks */ tracknr = mmc_discinfo.first_track_last_session; while (tracknr <= mmc_discinfo.last_track_last_session) { ti.tracknr = tracknr; error = udf_update_trackinfo(&mmc_discinfo, &ti); if (error) return error; printf("\tClosing open track %d\n", tracknr); memset(&op, 0, sizeof(op)); op.operation = MMC_OP_CLOSETRACK; op.mmc_profile = mmc_discinfo.mmc_profile; op.tracknr = tracknr; error = ioctl(fd, MMCOP, &op); if (error) return error; tracknr ++; } printf("Closing session\n"); memset(&op, 0, sizeof(op)); op.operation = MMC_OP_CLOSESESSION; op.mmc_profile = mmc_discinfo.mmc_profile; op.sessionnr = mmc_discinfo.num_sessions; error = ioctl(fd, MMCOP, &op); if (error) return error; /* update discinfo since it changed by the operations */ error = udf_update_discinfo(&mmc_discinfo); if (error) return error; } if (format_flags & FORMAT_TRACK512) { /* get last track again */ ti.tracknr = mmc_discinfo.last_track_last_session; error = udf_update_trackinfo(&mmc_discinfo, &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(fd, MMCOP, &op); if (error) return error; } return 0; } /* --------------------------------------------------------------------- */ static int udf_surface_check(void) { uint32_t loc, block_bytes; uint32_t sector_size, blockingnr, bpos; uint8_t *buffer; int error, num_errors; sector_size = context.sector_size; blockingnr = layout.blockingnr; block_bytes = layout.blockingnr * sector_size; if ((buffer = malloc(block_bytes)) == NULL) return ENOMEM; /* set all one to not kill Flash memory? */ for (bpos = 0; bpos < block_bytes; bpos++) buffer[bpos] = 0x00; printf("\nChecking disc surface : phase 1 - writing\n"); num_errors = 0; loc = layout.first_lba; while (loc <= layout.last_lba) { /* write blockingnr sectors */ error = pwrite(fd, buffer, block_bytes, loc*sector_size); printf(" %08d + %d (%02d %%)\r", loc, blockingnr, (int)((100.0 * loc)/layout.last_lba)); fflush(stdout); if (error == -1) { /* block is bad */ printf("BAD block at %08d + %d \n", loc, layout.blockingnr); if ((error = udf_register_bad_block(loc))) { free(buffer); return error; } num_errors ++; } loc += layout.blockingnr; } printf("\nChecking disc surface : phase 2 - reading\n"); num_errors = 0; loc = layout.first_lba; while (loc <= layout.last_lba) { /* read blockingnr sectors */ error = pread(fd, buffer, block_bytes, loc*sector_size); printf(" %08d + %d (%02d %%)\r", loc, blockingnr, (int)((100.0 * loc)/layout.last_lba)); fflush(stdout); if (error == -1) { /* block is bad */ printf("BAD block at %08d + %d \n", loc, layout.blockingnr); if ((error = udf_register_bad_block(loc))) { free(buffer); return error; } num_errors ++; } loc += layout.blockingnr; } printf("Scan complete : %d bad blocks found\n", num_errors); free(buffer); return 0; } /* --------------------------------------------------------------------- */ static int udf_write_iso9660_vrs(void) { struct vrs_desc *iso9660_vrs_desc; uint32_t pos; int error, cnt, dpos; /* create ISO/Ecma-167 identification descriptors */ if ((iso9660_vrs_desc = calloc(1, context.sector_size)) == NULL) return ENOMEM; /* * All UDF formats should have their ISO/Ecma-167 descriptors written * except when not possible due to track reservation in the case of * VAT */ if ((format_flags & FORMAT_TRACK512) == 0) { dpos = (2048 + context.sector_size - 1) / context.sector_size; /* wipe at least 6 times 2048 byte `sectors' */ for (cnt = 0; cnt < 6 *dpos; cnt++) { pos = layout.iso9660_vrs + cnt; if ((error = udf_write_sector(iso9660_vrs_desc, pos))) { free(iso9660_vrs_desc); return error; } } /* common VRS fields in all written out ISO descriptors */ iso9660_vrs_desc->struct_type = 0; iso9660_vrs_desc->version = 1; pos = layout.iso9660_vrs; /* BEA01, NSR[23], TEA01 */ memcpy(iso9660_vrs_desc->identifier, "BEA01", 5); if ((error = udf_write_sector(iso9660_vrs_desc, pos))) { free(iso9660_vrs_desc); return error; } pos += dpos; if (context.dscrver == 2) memcpy(iso9660_vrs_desc->identifier, "NSR02", 5); else memcpy(iso9660_vrs_desc->identifier, "NSR03", 5); ; if ((error = udf_write_sector(iso9660_vrs_desc, pos))) { free(iso9660_vrs_desc); return error; } pos += dpos; memcpy(iso9660_vrs_desc->identifier, "TEA01", 5); if ((error = udf_write_sector(iso9660_vrs_desc, pos))) { free(iso9660_vrs_desc); return error; } } free(iso9660_vrs_desc); /* return success */ return 0; } /* --------------------------------------------------------------------- */ /* * Main function that creates and writes out disc contents based on the * format_flags's that uniquely define the type of disc to create. */ int udf_do_newfs(void) { union dscrptr *zero_dscr; union dscrptr *terminator_dscr; union dscrptr *root_dscr; union dscrptr *vat_dscr; union dscrptr *dscr; struct mmc_trackinfo ti; uint32_t sparable_blocks; uint32_t sector_size, blockingnr; uint32_t cnt, loc, len; int sectcopy; int error, integrity_type; int data_part, metadata_part; /* init */ sector_size = mmc_discinfo.sector_size; /* determine span/size */ ti.tracknr = mmc_discinfo.first_track_last_session; error = udf_update_trackinfo(&mmc_discinfo, &ti); if (error) return error; if (mmc_discinfo.sector_size < context.sector_size) { fprintf(stderr, "Impossible to format: sectorsize too small\n"); return EIO; } context.sector_size = sector_size; /* determine blockingnr */ blockingnr = ti.packet_size; if (blockingnr <= 1) { /* paranoia on blockingnr */ switch (mmc_discinfo.mmc_profile) { case 0x09 : /* CD-R */ case 0x0a : /* CD-RW */ blockingnr = 32; /* UDF requirement */ break; case 0x11 : /* DVD-R (DL) */ case 0x1b : /* DVD+R */ case 0x2b : /* DVD+R Dual layer */ case 0x13 : /* DVD-RW restricted overwrite */ case 0x14 : /* DVD-RW sequential */ blockingnr = 16; /* SCSI definition */ break; case 0x41 : /* BD-R Sequential recording (SRM) */ case 0x51 : /* HD DVD-R */ blockingnr = 32; /* SCSI definition */ break; default: break; } } if (blockingnr <= 0) { printf("Can't fixup blockingnumber for device " "type %d\n", mmc_discinfo.mmc_profile); printf("Device is not returning valid blocking" " number and media type is unknown.\n"); return EINVAL; } /* setup sector writeout queue's */ TAILQ_INIT(&write_queue); wrtrack_skew = ti.track_start % blockingnr; if (mmc_discinfo.mmc_class == MMC_CLASS_CD) { /* not too much for CD-RW, still 20MiB */ sparable_blocks = 32; } else { /* take a value for DVD*RW mainly, BD is `defect free' */ sparable_blocks = 512; } /* get layout */ error = udf_calculate_disc_layout(format_flags, context.min_udf, wrtrack_skew, ti.track_start, mmc_discinfo.last_possible_lba, sector_size, blockingnr, sparable_blocks, meta_fract); /* cache partition for we need it often */ data_part = context.data_part; metadata_part = context.metadata_part; /* Create sparing table descriptor if applicable */ if (format_flags & FORMAT_SPARABLE) { if ((error = udf_create_sparing_tabled())) return error; if (check_surface) { if ((error = udf_surface_check())) return error; } } /* Create a generic terminator descriptor */ terminator_dscr = calloc(1, sector_size); if (terminator_dscr == NULL) return ENOMEM; udf_create_terminator(terminator_dscr, 0); /* * Start with wipeout of VRS1 upto start of partition. This allows * formatting for sequentials with the track reservation and it * cleans old rubbish on rewritables. For sequentuals without the * track reservation all is wiped from track start. */ if ((zero_dscr = calloc(1, context.sector_size)) == NULL) return ENOMEM; loc = (format_flags & FORMAT_TRACK512) ? layout.vds1 : ti.track_start; for (; loc < layout.part_start_lba; loc++) { if ((error = udf_write_sector(zero_dscr, loc))) { free(zero_dscr); return error; } } free(zero_dscr); /* Create anchors */ for (cnt = 0; cnt < 3; cnt++) { if ((error = udf_create_anchor(cnt))) { return error; } } /* * Create the two Volume Descriptor Sets (VDS) each containing the * following descriptors : primary volume, partition space, * unallocated space, logical volume, implementation use and the * terminator */ /* start of volume recognision sequence building */ context.vds_seq = 0; /* Create primary volume descriptor */ if ((error = udf_create_primaryd())) return error; /* Create partition descriptor */ if ((error = udf_create_partitiond(context.data_part, media_accesstype))) return error; /* Create unallocated space descriptor */ if ((error = udf_create_unalloc_spaced())) return error; /* Create logical volume descriptor */ if ((error = udf_create_logical_dscr(format_flags))) return error; /* Create implementation use descriptor */ /* TODO input of fields 1,2,3 and passing them */ if ((error = udf_create_impvold(NULL, NULL, NULL))) return error; /* write out what we've created so far */ /* writeout iso9660 vrs */ if ((error = udf_write_iso9660_vrs())) return error; /* Writeout anchors */ for (cnt = 0; cnt < 3; cnt++) { dscr = (union dscrptr *) context.anchors[cnt]; loc = layout.anchors[cnt]; if ((error = udf_write_dscr_phys(dscr, loc, 1))) return error; /* sequential media has only one anchor */ if (format_flags & FORMAT_SEQUENTIAL) break; } /* write out main and secondary VRS */ for (sectcopy = 1; sectcopy <= 2; sectcopy++) { loc = (sectcopy == 1) ? layout.vds1 : layout.vds2; /* primary volume descriptor */ dscr = (union dscrptr *) context.primary_vol; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; /* partition descriptor(s) */ for (cnt = 0; cnt < UDF_PARTITIONS; cnt++) { dscr = (union dscrptr *) context.partitions[cnt]; if (dscr) { error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; } } /* unallocated space descriptor */ dscr = (union dscrptr *) context.unallocated; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; /* logical volume descriptor */ dscr = (union dscrptr *) context.logical_vol; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; /* implementation use descriptor */ dscr = (union dscrptr *) context.implementation; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; /* terminator descriptor */ error = udf_write_dscr_phys(terminator_dscr, loc, 1); if (error) return error; loc++; } /* writeout the two sparable table descriptors (if needed) */ if (format_flags & FORMAT_SPARABLE) { for (sectcopy = 1; sectcopy <= 2; sectcopy++) { loc = (sectcopy == 1) ? layout.spt_1 : layout.spt_2; dscr = (union dscrptr *) context.sparing_table; len = layout.sparing_table_dscr_lbas; /* writeout */ error = udf_write_dscr_phys(dscr, loc, len); if (error) return error; } } /* * Create unallocated space bitmap descriptor. Sequential recorded * media report their own free/used space; no free/used space tables * should be recorded for these. */ if ((format_flags & FORMAT_SEQUENTIAL) == 0) { error = udf_create_space_bitmap( layout.alloc_bitmap_dscr_size, layout.part_size_lba, &context.part_unalloc_bits[data_part]); if (error) return error; /* TODO: freed space bitmap if applicable */ /* mark space allocated for the unallocated space bitmap */ udf_mark_allocated(layout.unalloc_space, data_part, layout.alloc_bitmap_dscr_size); } /* * Create metadata partition file entries and allocate and init their * space and free space maps. */ if (format_flags & FORMAT_META) { error = udf_create_space_bitmap( layout.meta_bitmap_dscr_size, layout.meta_part_size_lba, &context.part_unalloc_bits[metadata_part]); if (error) return error; error = udf_create_meta_files(); if (error) return error; /* mark space allocated for meta partition and its bitmap */ udf_mark_allocated(layout.meta_file, data_part, 1); udf_mark_allocated(layout.meta_mirror, data_part, 1); udf_mark_allocated(layout.meta_bitmap, data_part, 1); udf_mark_allocated(layout.meta_part_start_lba, data_part, layout.meta_part_size_lba); /* mark space allocated for the unallocated space bitmap */ udf_mark_allocated(layout.meta_bitmap_space, data_part, layout.meta_bitmap_dscr_size); } /* create logical volume integrity descriptor */ context.num_files = 0; context.num_directories = 0; integrity_type = UDF_INTEGRITY_OPEN; if ((error = udf_create_lvintd(integrity_type))) return error; /* create FSD */ if ((error = udf_create_fsd())) return error; udf_mark_allocated(layout.fsd, metadata_part, 1); /* create root directory */ assert(context.unique_id == 0x10); context.unique_id = 0; if ((error = udf_create_new_rootdir(&root_dscr))) return error; udf_mark_allocated(layout.rootdir, metadata_part, 1); /* writeout FSD + rootdir */ dscr = (union dscrptr *) context.fileset_desc; error = udf_write_dscr_virt(dscr, layout.fsd, metadata_part, 1); if (error) return error; error = udf_write_dscr_virt(root_dscr, layout.rootdir, metadata_part, 1); if (error) return error; /* writeout initial open integrity sequence + terminator */ loc = layout.lvis; dscr = (union dscrptr *) context.logvol_integrity; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; error = udf_write_dscr_phys(terminator_dscr, loc, 1); if (error) return error; /* XXX the place to add more files */ if ((format_flags & FORMAT_SEQUENTIAL) == 0) { /* update lvint and mark it closed */ udf_update_lvintd(UDF_INTEGRITY_CLOSED); /* overwrite initial terminator */ loc = layout.lvis+1; dscr = (union dscrptr *) context.logvol_integrity; error = udf_write_dscr_phys(dscr, loc, 1); if (error) return error; loc++; /* mark end of integrity desciptor sequence again */ error = udf_write_dscr_phys(terminator_dscr, loc, 1); if (error) return error; } /* write out unallocated space bitmap on non sequential media */ if ((format_flags & FORMAT_SEQUENTIAL) == 0) { /* writeout unallocated space bitmap */ loc = layout.unalloc_space; dscr = (union dscrptr *) (context.part_unalloc_bits[data_part]); len = layout.alloc_bitmap_dscr_size; error = udf_write_dscr_virt(dscr, loc, data_part, len); if (error) return error; } if (format_flags & FORMAT_META) { loc = layout.meta_file; dscr = (union dscrptr *) context.meta_file; error = udf_write_dscr_virt(dscr, loc, data_part, 1); if (error) return error; loc = layout.meta_mirror; dscr = (union dscrptr *) context.meta_mirror; error = udf_write_dscr_virt(dscr, loc, data_part, 1); if (error) return error; loc = layout.meta_bitmap; dscr = (union dscrptr *) context.meta_bitmap; error = udf_write_dscr_virt(dscr, loc, data_part, 1); if (error) return error; /* writeout unallocated space bitmap */ loc = layout.meta_bitmap_space; dscr = (union dscrptr *) (context.part_unalloc_bits[metadata_part]); len = layout.meta_bitmap_dscr_size; error = udf_write_dscr_virt(dscr, loc, data_part, len); if (error) return error; } /* create a VAT and account for FSD+root */ vat_dscr = NULL; if (format_flags & FORMAT_VAT) { /* update lvint to reflect the newest values (no writeout) */ udf_update_lvintd(UDF_INTEGRITY_CLOSED); error = udf_create_new_VAT(&vat_dscr); if (error) return error; loc = layout.vat; error = udf_write_dscr_virt(vat_dscr, loc, metadata_part, 1); if (error) return error; } /* write out sectors */ if ((error = writeout_write_queue())) return error; /* done */ return 0; } /* --------------------------------------------------------------------- */ /* version can be specified as 0xabc or a.bc */ static int parse_udfversion(const char *pos, uint32_t *version) { int hex = 0; char c1, c2, c3, c4; *version = 0; if (*pos == '0') { pos++; /* expect hex format */ hex = 1; if (*pos++ != 'x') return 1; } c1 = *pos++; if (c1 < '0' || c1 > '9') return 1; c1 -= '0'; c2 = *pos++; if (!hex) { if (c2 != '.') return 1; c2 = *pos++; } if (c2 < '0' || c2 > '9') return 1; c2 -= '0'; c3 = *pos++; if (c3 < '0' || c3 > '9') return 1; c3 -= '0'; c4 = *pos++; if (c4 != 0) return 1; *version = c1 * 0x100 + c2 * 0x10 + c3; return 0; } static int a_udf_version(const char *s, const char *id_type) { uint32_t version; if (parse_udfversion(s, &version)) errx(1, "unknown %s id %s; specify as hex or float", id_type, s); return version; } /* --------------------------------------------------------------------- */ static void usage(void) { (void)fprintf(stderr, "Usage: %s [-cFM] [-L loglabel] " "[-P discid] [-S setlabel] [-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; struct stat st; time_t now; char scrap[255]; int ch, req_enable, req_disable, force; int error; setprogname(argv[0]); /* initialise */ format_str = strdup(""); req_enable = req_disable = 0; format_flags = FORMAT_INVALID; force = 0; check_surface = 0; srandom((unsigned long) time(NULL)); udf_init_create_context(); context.app_name = APP_NAME; context.impl_name = IMPL_NAME; context.app_version_main = APP_VERSION_MAIN; context.app_version_sub = APP_VERSION_SUB; /* minimum and maximum UDF versions we advise */ context.min_udf = 0x201; context.max_udf = 0x201; /* 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:t:v:V:")) != -1) { switch (ch) { case 'c' : check_surface = 1; break; case 'F' : force = 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' : meta_perc = a_num(optarg, "meta_perc"); /* limit to `sensible` values */ meta_perc = MIN(meta_perc, 99); meta_perc = MAX(meta_perc, 1); meta_fract = (float) meta_perc/100.0; 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' : context.primary_name = strdup(optarg); break; case 's' : /* TODO size argument; recordable emulation */ break; case 'S' : if (context.volset_name) free(context.volset_name); context.volset_name = strdup(optarg); break; case 't' : /* time zone overide */ context.gmtoff = a_num(optarg, "gmtoff"); break; default : usage(); /* NOTREACHED */ } } if (optind + 1 != argc) usage(); /* get device and directory specifier */ dev = argv[optind]; /* open device */ if ((fd = open(dev, O_RDWR, 0)) == -1) { perror("can't open device"); return EXIT_FAILURE; } /* stat the device */ if (fstat(fd, &st) != 0) { perror("can't stat the device"); close(fd); return EXIT_FAILURE; } /* formatting can only be done on raw devices */ if (!S_ISCHR(st.st_mode)) { printf("%s is not a raw device\n", dev); close(fd); return EXIT_FAILURE; } /* just in case something went wrong, synchronise the drive's cache */ udf_synchronise_caches(); /* get disc information */ error = udf_update_discinfo(&mmc_discinfo); if (error) { perror("can't retrieve discinfo"); close(fd); return EXIT_FAILURE; } /* derive disc identifiers when not specified and check given */ error = udf_proces_names(); if (error) { /* error message has been printed */ close(fd); return EXIT_FAILURE; } /* derive newfs disc format from disc profile */ error = udf_derive_format(req_enable, req_disable, force); if (error) { /* error message has been printed */ close(fd); return EXIT_FAILURE; } 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) 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 (format_flags & FORMAT_META) printf("Metadata percentage %d %%\n", meta_perc); printf("\n"); /* prepare disc if nessisary (recordables mainly) */ error = udf_prepare_disc(); if (error) { perror("preparing disc failed"); close(fd); return EXIT_FAILURE; }; /* set up administration */ error = udf_do_newfs(); /* in any case, synchronise the drive's cache to prevent lockups */ udf_synchronise_caches(); close(fd); if (error) return EXIT_FAILURE; return EXIT_SUCCESS; } /* --------------------------------------------------------------------- */