#include <sys/cdefs.h>
#ifndef lint
__KERNEL_RCSID(0, "$NetBSD: udf_subr.c,v 1.178 2025/11/22 21:27:08 andvar Exp $");
#endif
#if defined(_KERNEL_OPT)
#include "opt_compat_netbsd.h"
#endif
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sysctl.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <miscfs/genfs/genfs_node.h>
#include <sys/mount.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/device.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/dirent.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/kauth.h>
#include <fs/unicode.h>
#include <dev/clock_subr.h>
#include <fs/udf/ecma167-udf.h>
#include <fs/udf/udf_mount.h>
#include <sys/dirhash.h>
#include "udf.h"
#include "udf_subr.h"
#include "udf_bswap.h"
#define VTOI(vnode) ((struct udf_node *) (vnode)->v_data)
#define UDF_SET_SYSTEMFILE(vp) \
\
(vp)->v_vflag |= VV_SYSTEM; \
vref((vp)); \
vput((vp)); \
extern int syncer_maxdelay;
extern int (**udf_vnodeop_p)(void *);
#if 1
#if 0
static void
udf_dumpblob(boid *blob, uint32_t dlen)
{
int i, j;
printf("blob = %p\n", blob);
printf("dump of %d bytes\n", dlen);
for (i = 0; i < dlen; i+ = 16) {
printf("%04x ", i);
for (j = 0; j < 16; j++) {
if (i+j < dlen) {
printf("%02x ", blob[i+j]);
} else {
printf(" ");
}
}
for (j = 0; j < 16; j++) {
if (i+j < dlen) {
if (blob[i+j]>32 && blob[i+j]! = 127) {
printf("%c", blob[i+j]);
} else {
printf(".");
}
}
}
printf("\n");
}
printf("\n");
Debugger();
}
#endif
static void
udf_dump_discinfo(struct udf_mount *ump)
{
char bits[128];
struct mmc_discinfo *di = &ump->discinfo;
if ((udf_verbose & UDF_DEBUG_VOLUMES) == 0)
return;
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, 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);
}
static void
udf_dump_trackinfo(struct mmc_trackinfo *trackinfo)
{
char bits[128];
if ((udf_verbose & UDF_DEBUG_VOLUMES) == 0)
return;
printf("Trackinfo for track %d:\n", trackinfo->tracknr);
printf("\tsessionnr %d\n", trackinfo->sessionnr);
printf("\ttrack mode %d\n", trackinfo->track_mode);
printf("\tdata mode %d\n", trackinfo->data_mode);
snprintb(bits, sizeof(bits), MMC_TRACKINFO_FLAGBITS, trackinfo->flags);
printf("\tflags %s\n", bits);
printf("\ttrack start %d\n", trackinfo->track_start);
printf("\tnext_writable %d\n", trackinfo->next_writable);
printf("\tfree_blocks %d\n", trackinfo->free_blocks);
printf("\tpacket_size %d\n", trackinfo->packet_size);
printf("\ttrack size %d\n", trackinfo->track_size);
printf("\tlast recorded block %d\n", trackinfo->last_recorded);
}
#else
#define udf_dump_discinfo(a);
#define udf_dump_trackinfo(a);
#endif
int
udf_update_discinfo(struct udf_mount *ump)
{
struct vnode *devvp = ump->devvp;
uint64_t psize;
unsigned secsize;
struct mmc_discinfo *di;
int error;
DPRINTF(VOLUMES, ("read/update disc info\n"));
di = &ump->discinfo;
memset(di, 0, sizeof(struct mmc_discinfo));
error = VOP_IOCTL(devvp, MMCGETDISCINFO, di, FKIOCTL, NOCRED);
if (error == 0) {
udf_dump_discinfo(ump);
return 0;
}
error = getdisksize(devvp, &psize, &secsize);
if (error)
return error;
di->mmc_profile = 0x01;
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;
di->last_possible_lba = psize;
di->sector_size = secsize;
di->num_sessions = 1;
di->num_tracks = 1;
di->first_track = 1;
di->first_track_last_session = di->last_track_last_session = 1;
udf_dump_discinfo(ump);
return 0;
}
int
udf_update_trackinfo(struct udf_mount *ump, struct mmc_trackinfo *ti)
{
struct vnode *devvp = ump->devvp;
struct mmc_discinfo *di = &ump->discinfo;
int error, class;
DPRINTF(VOLUMES, ("read track info\n"));
class = di->mmc_class;
if (class != MMC_CLASS_DISC) {
error = VOP_IOCTL(devvp, MMCGETTRACKINFO, ti, FKIOCTL, NOCRED);
return error;
}
if (ti->tracknr != 1)
return EIO;
ti->sessionnr = 1;
ti->track_mode = 0;
ti->data_mode = 0;
ti->flags = MMC_TRACKINFO_LRA_VALID | MMC_TRACKINFO_NWA_VALID;
ti->track_start = 0;
ti->packet_size = 1;
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;
}
int
udf_setup_writeparams(struct udf_mount *ump)
{
struct mmc_writeparams mmc_writeparams;
int error;
if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
return 0;
memset(&mmc_writeparams, 0, sizeof(struct mmc_writeparams));
mmc_writeparams.mmc_class = ump->discinfo.mmc_class;
mmc_writeparams.mmc_cur = ump->discinfo.mmc_cur;
mmc_writeparams.tracknr = 2;
mmc_writeparams.data_mode = MMC_DATAMODE_DEFAULT;
mmc_writeparams.track_mode = MMC_TRACKMODE_DEFAULT;
error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS, &mmc_writeparams,
FKIOCTL, NOCRED);
if (error) {
mmc_writeparams.tracknr = 1;
error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS,
&mmc_writeparams, FKIOCTL, NOCRED);
}
return error;
}
void
udf_mmc_synchronise_caches(struct udf_mount *ump)
{
struct mmc_op mmc_op;
DPRINTF(CALL, ("udf_mcc_synchronise_caches()\n"));
if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
return;
if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
return;
memset(&mmc_op, 0, sizeof(struct mmc_op));
mmc_op.operation = MMC_OP_SYNCHRONISECACHE;
(void) VOP_IOCTL(ump->devvp, MMCOP, &mmc_op, FKIOCTL, NOCRED);
}
int
udf_search_tracks(struct udf_mount *ump, struct udf_args *args,
int *first_tracknr, int *last_tracknr)
{
struct mmc_trackinfo trackinfo;
uint32_t tracknr, start_track, num_tracks;
int error;
if (args->sessionnr < 0) {
args->sessionnr += ump->discinfo.num_sessions;
}
if (args->sessionnr < 0)
args->sessionnr = 0;
if (args->sessionnr > ump->discinfo.num_sessions)
args->sessionnr = ump->discinfo.num_sessions;
if (args->sessionnr == 0)
args->sessionnr = ump->discinfo.num_sessions;
if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
args->sessionnr--;
if (args->sessionnr < 0)
args->sessionnr = 0;
num_tracks = ump->discinfo.num_tracks;
start_track = ump->discinfo.first_track;
for (tracknr = start_track; tracknr <= num_tracks; tracknr++) {
trackinfo.tracknr = tracknr;
error = udf_update_trackinfo(ump, &trackinfo);
if (error)
return error;
if (trackinfo.sessionnr == args->sessionnr)
break;
}
*first_tracknr = tracknr;
for (;tracknr <= num_tracks; tracknr++) {
trackinfo.tracknr = tracknr;
error = udf_update_trackinfo(ump, &trackinfo);
if (error || (trackinfo.sessionnr != args->sessionnr)) {
tracknr--;
break;
}
}
if (tracknr > num_tracks)
tracknr--;
*last_tracknr = tracknr;
if (*last_tracknr < *first_tracknr) {
printf( "udf_search_tracks: sanity check on drive+disc failed, "
"drive returned garbage\n");
return EINVAL;
}
assert(*last_tracknr >= *first_tracknr);
return 0;
}
static void
udf_check_track_metadata_overlap(struct udf_mount *ump,
struct mmc_trackinfo *trackinfo)
{
struct part_desc *part;
struct file_entry *fe;
struct extfile_entry *efe;
struct short_ad *s_ad;
struct long_ad *l_ad;
uint32_t track_start, track_end;
uint32_t phys_part_start, phys_part_end, part_start, part_end;
uint32_t sector_size, len, alloclen, plb_num;
uint8_t *pos;
int addr_type, icblen, icbflags;
track_start = trackinfo->track_start;
track_end = track_start + trackinfo->track_size;
KASSERT(ump->node_part == ump->fids_part);
part = ump->partitions[ump->vtop[ump->node_part]];
phys_part_start = udf_rw32(part->start_loc);
phys_part_end = phys_part_start + udf_rw32(part->part_len);
if ((phys_part_start >= track_end) || (phys_part_end < track_start))
return;
sector_size = ump->discinfo.sector_size;
fe = ump->metadata_node->fe;
efe = ump->metadata_node->efe;
if (fe) {
alloclen = udf_rw32(fe->l_ad);
pos = &fe->data[0] + udf_rw32(fe->l_ea);
icbflags = udf_rw16(fe->icbtag.flags);
} else {
assert(efe);
alloclen = udf_rw32(efe->l_ad);
pos = &efe->data[0] + udf_rw32(efe->l_ea);
icbflags = udf_rw16(efe->icbtag.flags);
}
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
while (alloclen) {
if (addr_type == UDF_ICB_SHORT_ALLOC) {
icblen = sizeof(struct short_ad);
s_ad = (struct short_ad *) pos;
len = udf_rw32(s_ad->len);
plb_num = udf_rw32(s_ad->lb_num);
} else {
icblen = sizeof(struct long_ad);
l_ad = (struct long_ad *) pos;
len = udf_rw32(l_ad->len);
plb_num = udf_rw32(l_ad->loc.lb_num);
}
len = UDF_EXT_LEN(len);
part_start = phys_part_start + plb_num;
part_end = part_start + (len / sector_size);
if ((part_start >= track_start) && (part_end <= track_end)) {
ump->metadata_track = *trackinfo;
return;
}
pos += icblen;
alloclen -= icblen;
}
}
int
udf_search_writing_tracks(struct udf_mount *ump)
{
struct vnode *devvp = ump->devvp;
struct mmc_trackinfo trackinfo;
struct mmc_op mmc_op;
struct part_desc *part;
uint32_t tracknr, start_track, num_tracks;
uint32_t track_start, track_end, part_start, part_end;
int node_alloc, error;
error = udf_update_discinfo(ump);
if (error)
return error;
num_tracks = ump->discinfo.num_tracks;
start_track = ump->discinfo.first_track;
trackinfo.tracknr = start_track;
error = udf_update_trackinfo(ump, &trackinfo);
if (error)
return error;
ump->data_track = trackinfo;
ump->metadata_track = trackinfo;
if (num_tracks == 1)
return 0;
for (tracknr = start_track;tracknr <= num_tracks; tracknr++) {
trackinfo.tracknr = tracknr;
error = udf_update_trackinfo(ump, &trackinfo);
if (error)
return error;
if (trackinfo.flags & MMC_TRACKINFO_DAMAGED) {
memset(&mmc_op, 0, sizeof(mmc_op));
mmc_op.operation = MMC_OP_REPAIRTRACK;
mmc_op.mmc_profile = ump->discinfo.mmc_profile;
mmc_op.tracknr = tracknr;
error = VOP_IOCTL(devvp, MMCOP, &mmc_op, FKIOCTL, NOCRED);
if (error)
(void)printf("Drive can't explicitly repair "
"damaged track %d, but it might "
"autorepair\n", tracknr);
error = udf_update_trackinfo(ump, &trackinfo);
if (error)
return error;
}
if ((trackinfo.flags & MMC_TRACKINFO_NWA_VALID) == 0)
continue;
track_start = trackinfo.track_start;
track_end = track_start + trackinfo.track_size;
part = ump->partitions[ump->data_part];
part_start = udf_rw32(part->start_loc);
part_end = part_start + udf_rw32(part->part_len);
if ((part_start < track_end) && (part_end > track_start)) {
ump->data_track = trackinfo;
}
node_alloc = ump->vtop_alloc[ump->node_part];
if ((node_alloc == UDF_ALLOC_METASEQUENTIAL) ||
(node_alloc == UDF_ALLOC_METABITMAP)) {
udf_check_track_metadata_overlap(ump, &trackinfo);
} else {
ump->metadata_track = trackinfo;
}
}
if ((ump->data_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
return EROFS;
if ((ump->metadata_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
return EROFS;
return 0;
}
int
udf_check_tag(void *blob)
{
struct desc_tag *tag = blob;
uint8_t *pos, sum, cnt;
pos = (uint8_t *) tag;
sum = 0;
for(cnt = 0; cnt < 16; cnt++) {
if (cnt != 4)
sum += *pos;
pos++;
}
if (sum != tag->cksum) {
return EINVAL;
}
return 0;
}
int
udf_check_tag_payload(void *blob, uint32_t max_length)
{
struct desc_tag *tag = blob;
uint16_t crc, crc_len;
crc_len = udf_rw16(tag->desc_crc_len);
if (crc_len == 0)
return 0;
if (crc_len > max_length)
return EIO;
crc = udf_cksum(((uint8_t *) tag) + UDF_DESC_TAG_LENGTH, crc_len);
if (crc != udf_rw16(tag->desc_crc)) {
return EINVAL;
}
return 0;
}
void
udf_validate_tag_sum(void *blob)
{
struct desc_tag *tag = blob;
uint8_t *pos, sum, cnt;
pos = (uint8_t *) tag;
sum = 0;
for(cnt = 0; cnt < 16; cnt++) {
if (cnt != 4) sum += *pos;
pos++;
}
tag->cksum = sum;
}
void
udf_validate_tag_and_crc_sums(void *blob)
{
struct desc_tag *tag = blob;
uint8_t *btag = (uint8_t *) tag;
uint16_t crc, crc_len;
crc_len = udf_rw16(tag->desc_crc_len);
if (crc_len > 0) {
crc = udf_cksum(btag + UDF_DESC_TAG_LENGTH, crc_len);
tag->desc_crc = udf_rw16(crc);
}
udf_validate_tag_sum(blob);
}
int
udf_tagsize(union dscrptr *dscr, uint32_t lb_size)
{
uint32_t size, tag_id, num_lb, elmsz;
tag_id = udf_rw16(dscr->tag.id);
switch (tag_id) {
case TAGID_LOGVOL :
size = sizeof(struct logvol_desc) - 1;
size += udf_rw32(dscr->lvd.mt_l);
break;
case TAGID_UNALLOC_SPACE :
elmsz = sizeof(struct extent_ad);
size = sizeof(struct unalloc_sp_desc) - elmsz;
size += udf_rw32(dscr->usd.alloc_desc_num) * elmsz;
break;
case TAGID_FID :
size = UDF_FID_SIZE + dscr->fid.l_fi + udf_rw16(dscr->fid.l_iu);
size = (size + 3) & ~3;
break;
case TAGID_LOGVOL_INTEGRITY :
size = sizeof(struct logvol_int_desc) - sizeof(uint32_t);
size += udf_rw32(dscr->lvid.l_iu);
size += (2 * udf_rw32(dscr->lvid.num_part) * sizeof(uint32_t));
break;
case TAGID_SPACE_BITMAP :
size = sizeof(struct space_bitmap_desc) - 1;
size += udf_rw32(dscr->sbd.num_bytes);
break;
case TAGID_SPARING_TABLE :
elmsz = sizeof(struct spare_map_entry);
size = sizeof(struct udf_sparing_table) - elmsz;
size += udf_rw16(dscr->spt.rt_l) * elmsz;
break;
case TAGID_FENTRY :
size = sizeof(struct file_entry);
size += udf_rw32(dscr->fe.l_ea) + udf_rw32(dscr->fe.l_ad)-1;
break;
case TAGID_EXTFENTRY :
size = sizeof(struct extfile_entry);
size += udf_rw32(dscr->efe.l_ea) + udf_rw32(dscr->efe.l_ad)-1;
break;
case TAGID_FSD :
size = sizeof(struct fileset_desc);
break;
default :
size = sizeof(union dscrptr);
break;
}
if ((size == 0) || (lb_size == 0))
return 0;
if (lb_size == 1)
return size;
num_lb = (size + lb_size -1) / lb_size;
return num_lb * lb_size;
}
int
udf_fidsize(struct fileid_desc *fid)
{
uint32_t size;
if (udf_rw16(fid->tag.id) != TAGID_FID)
panic("got udf_fidsize on non FID\n");
size = UDF_FID_SIZE + fid->l_fi + udf_rw16(fid->l_iu);
size = (size + 3) & ~3;
return size;
}
void
udf_lock_node(struct udf_node *udf_node, int flag, char const *fname, const int lineno)
{
int ret;
mutex_enter(&udf_node->node_mutex);
while (udf_node->i_flags & IN_LOCKED) {
ret = cv_timedwait(&udf_node->node_lock, &udf_node->node_mutex, hz/8);
if (ret == EWOULDBLOCK) {
DPRINTF(LOCKING, ( "udf_lock_node: udf_node %p would block "
"wanted at %s:%d, previously locked at %s:%d\n",
udf_node, fname, lineno,
udf_node->lock_fname, udf_node->lock_lineno));
}
}
udf_node->i_flags |= IN_LOCKED | flag;
udf_node->lock_fname = fname;
udf_node->lock_lineno = lineno;
mutex_exit(&udf_node->node_mutex);
}
void
udf_unlock_node(struct udf_node *udf_node, int flag)
{
mutex_enter(&udf_node->node_mutex);
udf_node->i_flags &= ~(IN_LOCKED | flag);
cv_broadcast(&udf_node->node_lock);
mutex_exit(&udf_node->node_mutex);
}
static int
udf_read_anchor(struct udf_mount *ump, uint32_t sector, struct anchor_vdp **dst)
{
int error;
error = udf_read_phys_dscr(ump, sector, M_UDFVOLD,
(union dscrptr **) dst);
if (!error) {
if (*dst == NULL)
return ENOENT;
if (udf_rw16((*dst)->tag.id) != TAGID_ANCHOR) {
error = ENOENT;
free(*dst, M_UDFVOLD);
*dst = NULL;
DPRINTF(VOLUMES, ("Not an anchor\n"));
}
}
return error;
}
int
udf_read_anchors(struct udf_mount *ump)
{
struct udf_args *args = &ump->mount_args;
struct mmc_trackinfo first_track;
struct mmc_trackinfo second_track;
struct mmc_trackinfo last_track;
struct anchor_vdp **anchorsp;
uint32_t track_start;
uint32_t track_end;
uint32_t positions[4];
int first_tracknr, last_tracknr;
int error, anch, ok, first_anchor;
error = udf_search_tracks(ump, args, &first_tracknr, &last_tracknr);
if (!error) {
first_track.tracknr = first_tracknr;
error = udf_update_trackinfo(ump, &first_track);
}
if (!error) {
last_track.tracknr = last_tracknr;
error = udf_update_trackinfo(ump, &last_track);
}
if ((!error) && (first_tracknr != last_tracknr)) {
second_track.tracknr = first_tracknr+1;
error = udf_update_trackinfo(ump, &second_track);
}
if (error) {
printf("UDF mount: reading disc geometry failed\n");
return 0;
}
track_start = first_track.track_start;
track_end = last_track.track_start
+ last_track.track_size - last_track.free_blocks - 1;
if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
if (last_track.flags & MMC_TRACKINFO_LRA_VALID)
track_end = last_track.last_recorded;
else if (last_track.flags & MMC_TRACKINFO_NWA_VALID)
track_end = last_track.next_writable
- ump->discinfo.link_block_penalty;
}
first_anchor = 0;
if (first_track.flags & MMC_TRACKINFO_BLANK)
first_anchor = 1;
ump->packet_size = first_track.packet_size;
if (first_track.flags & MMC_TRACKINFO_BLANK)
ump->packet_size = second_track.packet_size;
if (ump->packet_size <= 1) {
ump->packet_size = MAXPHYS / ump->discinfo.sector_size;
ump->packet_size = MIN(ump->packet_size, 64);
}
KASSERT(ump->packet_size >= 1);
positions[0] = track_start+256;
positions[1] = track_end-256;
positions[2] = track_end;
positions[3] = track_start+512;
ok = 0;
anchorsp = ump->anchors;
for (anch = first_anchor; anch < 4; anch++) {
DPRINTF(VOLUMES, ("Read anchor %d at sector %d\n", anch,
positions[anch]));
error = udf_read_anchor(ump, positions[anch], anchorsp);
if (!error) {
anchorsp++;
ok++;
}
}
ump->first_possible_vat_location = track_start + 2;
ump->last_possible_vat_location = track_end;
return ok;
}
int
udf_get_c_type(struct udf_node *udf_node)
{
int isdir, what;
isdir = (udf_node->vnode->v_type == VDIR);
what = isdir ? UDF_C_FIDS : UDF_C_USERDATA;
if (udf_node->ump)
if (udf_node == udf_node->ump->metadatabitmap_node)
what = UDF_C_METADATA_SBM;
return what;
}
int
udf_get_record_vpart(struct udf_mount *ump, int udf_c_type)
{
int vpart_num;
vpart_num = ump->data_part;
if (udf_c_type == UDF_C_NODE)
vpart_num = ump->node_part;
if (udf_c_type == UDF_C_FIDS)
vpart_num = ump->fids_part;
return vpart_num;
}
static uint16_t
udf_find_raw_phys(struct udf_mount *ump, uint16_t raw_phys_part)
{
struct part_desc *part;
uint16_t phys_part;
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
part = ump->partitions[phys_part];
if (part == NULL)
break;
if (udf_rw16(part->part_num) == raw_phys_part)
break;
}
return phys_part;
}
#define UDF_UPDATE_DSCR(name, dscr) \
if (name) \
free(name, M_UDFVOLD); \
name = dscr;
static int
udf_process_vds_descriptor(struct udf_mount *ump, union dscrptr *dscr)
{
uint16_t phys_part, raw_phys_part;
DPRINTF(VOLUMES, ("\tprocessing VDS descr %d\n",
udf_rw16(dscr->tag.id)));
switch (udf_rw16(dscr->tag.id)) {
case TAGID_PRI_VOL :
UDF_UPDATE_DSCR(ump->primary_vol, &dscr->pvd);
break;
case TAGID_LOGVOL :
UDF_UPDATE_DSCR(ump->logical_vol, &dscr->lvd);
break;
case TAGID_UNALLOC_SPACE :
UDF_UPDATE_DSCR(ump->unallocated, &dscr->usd);
break;
case TAGID_IMP_VOL :
UDF_UPDATE_DSCR(ump->implementation, &dscr->ivd);
break;
case TAGID_PARTITION :
if ((udf_rw16(dscr->pd.flags) & UDF_PART_FLAG_ALLOCATED) == 0) {
free(dscr, M_UDFVOLD);
break;
}
raw_phys_part = udf_rw16(dscr->pd.part_num);
phys_part = udf_find_raw_phys(ump, raw_phys_part);
if (phys_part == UDF_PARTITIONS) {
free(dscr, M_UDFVOLD);
return EINVAL;
}
UDF_UPDATE_DSCR(ump->partitions[phys_part], &dscr->pd);
break;
case TAGID_VOL :
DPRINTF(VOLUMES, ("VDS extender ignored\n"));
free(dscr, M_UDFVOLD);
break;
default :
DPRINTF(VOLUMES, ("Unhandled VDS type %d\n",
udf_rw16(dscr->tag.id)));
free(dscr, M_UDFVOLD);
}
return 0;
}
#undef UDF_UPDATE_DSCR
static int
udf_read_vds_extent(struct udf_mount *ump, uint32_t loc, uint32_t len)
{
union dscrptr *dscr;
uint32_t sector_size, dscr_size;
int error;
sector_size = ump->discinfo.sector_size;
error = EIO;
while (len) {
error = udf_read_phys_dscr(ump, loc, M_UDFVOLD, &dscr);
if (error)
return error;
if (dscr == NULL)
return 0;
if (udf_rw16(dscr->tag.id) == TAGID_TERM) {
free(dscr, M_UDFVOLD);
return 0;
}
dscr_size = udf_tagsize(dscr, sector_size);
error = udf_process_vds_descriptor(ump, dscr);
if (error) {
free(dscr, M_UDFVOLD);
break;
}
assert((dscr_size % sector_size) == 0);
len -= dscr_size;
loc += dscr_size / sector_size;
}
return error;
}
int
udf_read_vds_space(struct udf_mount *ump)
{
struct anchor_vdp *anchor, *anchor2;
size_t size;
uint32_t main_loc, main_len;
uint32_t reserve_loc, reserve_len;
int error;
anchor = ump->anchors[0];
anchor2 = ump->anchors[1];
assert(anchor);
if (anchor2) {
size = sizeof(struct extent_ad);
if (memcmp(&anchor->main_vds_ex, &anchor2->main_vds_ex, size))
anchor = anchor2;
}
main_loc = udf_rw32(anchor->main_vds_ex.loc);
main_len = udf_rw32(anchor->main_vds_ex.len);
reserve_loc = udf_rw32(anchor->reserve_vds_ex.loc);
reserve_len = udf_rw32(anchor->reserve_vds_ex.len);
error = udf_read_vds_extent(ump, main_loc, main_len);
if (error) {
printf("UDF mount: reading in reserve VDS extent\n");
error = udf_read_vds_extent(ump, reserve_loc, reserve_len);
}
return error;
}
static int
udf_retrieve_lvint(struct udf_mount *ump)
{
union dscrptr *dscr;
struct logvol_int_desc *lvint;
struct udf_lvintq *trace;
uint32_t lb_size, lbnum, len;
int dscr_type, error, trace_len;
lb_size = udf_rw32(ump->logical_vol->lb_size);
len = udf_rw32(ump->logical_vol->integrity_seq_loc.len);
lbnum = udf_rw32(ump->logical_vol->integrity_seq_loc.loc);
memset(ump->lvint_trace, 0,
UDF_LVDINT_SEGMENTS * sizeof(struct udf_lvintq));
trace_len = 0;
trace = ump->lvint_trace;
trace->start = lbnum;
trace->end = lbnum + len/lb_size;
trace->pos = 0;
trace->wpos = 0;
lvint = NULL;
dscr = NULL;
error = 0;
while (len) {
trace->pos = lbnum - trace->start;
trace->wpos = trace->pos + 1;
error = udf_read_phys_dscr(ump, lbnum, M_UDFVOLD, &dscr);
if (!error) {
if (dscr == NULL) {
trace->wpos = trace->pos;
break;
}
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_TERM) {
trace->wpos = trace->pos;
break;
}
if (dscr_type != TAGID_LOGVOL_INTEGRITY) {
error = ENOENT;
break;
}
if (lvint)
free(lvint, M_UDFVOLD);
lvint = &dscr->lvid;
dscr = NULL;
}
DPRINTFIF(VOLUMES, lvint, ("logvol integrity read, state %s\n",
udf_rw32(lvint->integrity_type) ? "CLOSED" : "OPEN"));
lbnum += 1;
len -= lb_size;
if (dscr && lvint->next_extent.len) {
len = udf_rw32(lvint->next_extent.len);
lbnum = udf_rw32(lvint->next_extent.loc);
if (trace_len >= UDF_LVDINT_SEGMENTS-1) {
DPRINTF(VOLUMES, ("lvdint segments full\n"));
error = EINVAL;
} else {
trace++;
trace_len++;
trace->start = lbnum;
trace->end = lbnum + len/lb_size;
trace->pos = 0;
trace->wpos = 0;
}
}
}
if (dscr)
free(dscr, M_UDFVOLD);
if (error && lvint) {
free(lvint, M_UDFVOLD);
lvint = NULL;
}
if (!lvint)
error = ENOENT;
ump->logvol_integrity = lvint;
return error;
}
static int
udf_loose_lvint_history(struct udf_mount *ump)
{
union dscrptr **bufs, *dscr, *last_dscr;
struct udf_lvintq *trace, *in_trace, *out_trace;
struct logvol_int_desc *lvint;
uint32_t in_ext, in_pos, in_len;
uint32_t out_ext, out_wpos, out_len;
uint32_t lb_num;
uint32_t len, start;
int ext, sumext, extlen, cnt, cpy_len, dscr_type;
int losing;
int error;
DPRINTF(VOLUMES, ("need to lose some lvint history\n"));
trace = &ump->lvint_trace[0];
sumext = trace->end - trace->start;
for (ext = 1; ext < UDF_LVDINT_SEGMENTS; ext++) {
trace = &ump->lvint_trace[ext];
extlen = trace->end - trace->start;
if (extlen == 0)
break;
sumext += extlen;
}
if (sumext == 1) {
DPRINTF(VOLUMES, ("\tLinux bugcompat overwriting sole entry\n"));
trace = &ump->lvint_trace[0];
trace->wpos = 0;
return 0;
}
losing = MIN(sumext, UDF_LVINT_LOSSAGE);
if (sumext == UDF_LVINT_LOSSAGE)
losing = UDF_LVINT_LOSSAGE/2;
DPRINTF(VOLUMES, ("\tlosing %d entries\n", losing));
bufs = malloc(UDF_LVDINT_SEGMENTS * sizeof(void *), M_TEMP, M_WAITOK);
in_ext = 0;
in_pos = losing;
in_trace = &ump->lvint_trace[in_ext];
in_len = in_trace->end - in_trace->start;
out_ext = 0;
out_wpos = 0;
out_trace = &ump->lvint_trace[out_ext];
out_len = out_trace->end - out_trace->start;
last_dscr = NULL;
for(;;) {
out_trace->pos = out_wpos;
out_trace->wpos = out_trace->pos;
if (in_pos >= in_len) {
in_ext++;
in_pos = 0;
in_trace = &ump->lvint_trace[in_ext];
in_len = in_trace->end - in_trace->start;
}
if (out_wpos >= out_len) {
out_ext++;
out_wpos = 0;
out_trace = &ump->lvint_trace[out_ext];
out_len = out_trace->end - out_trace->start;
}
cpy_len = MIN(in_len - in_pos, out_len - out_wpos);
cpy_len = MIN(cpy_len, in_len - in_trace->pos);
if (cpy_len == 0)
break;
DPRINTF(VOLUMES, ("\treading %d lvid descriptors\n", cpy_len));
for (cnt = 0; cnt < cpy_len; cnt++) {
lb_num = in_trace->start + in_pos + cnt;
error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD,
&dscr);
if (error) {
dscr = last_dscr;
}
bufs[cnt] = dscr;
if (!error) {
if (dscr == NULL) {
out_trace->pos = out_wpos + cnt;
out_trace->wpos = out_trace->pos;
break;
}
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_TERM) {
out_trace->pos = out_wpos + cnt;
out_trace->wpos = out_trace->pos;
break;
}
if (dscr_type != TAGID_LOGVOL_INTEGRITY) {
panic( "UDF integrity sequence "
"corrupted while mounted!\n");
}
last_dscr = dscr;
}
}
if (bufs[0] == NULL) {
for (cnt = 0; cnt < cpy_len; cnt++)
if (bufs[cnt] != NULL)
break;
last_dscr = bufs[cnt];
for (; cnt > 0; cnt--) {
bufs[cnt] = last_dscr;
}
}
DPRINTF(VOLUMES, ("\twriting %d lvid descriptors\n", cpy_len));
for (cnt = 0; cnt < cpy_len; cnt++) {
lb_num = out_trace->start + out_wpos + cnt;
lvint = &bufs[cnt]->lvid;
len = 0;
start = 0;
if (out_wpos + cnt == out_len) {
trace = &ump->lvint_trace[out_ext+1];
len = trace->end - trace->start;
start = trace->start;
}
lvint->next_extent.len = udf_rw32(len);
lvint->next_extent.loc = udf_rw32(start);
lb_num = trace->start + trace->wpos;
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
bufs[cnt], lb_num, lb_num);
DPRINTFIF(VOLUMES, error,
("error writing lvint lb_num\n"));
}
last_dscr = NULL;
for (cnt = 0; cnt < cpy_len; cnt++) {
if (bufs[cnt] != last_dscr)
free(bufs[cnt], M_UDFVOLD);
last_dscr = bufs[cnt];
}
in_pos += cpy_len;
out_wpos += cpy_len;
}
free(bufs, M_TEMP);
return 0;
}
static int
udf_writeout_lvint(struct udf_mount *ump, int lvflag)
{
struct udf_lvintq *trace;
struct timeval now_v;
struct timespec now_s;
uint32_t sector;
int logvol_integrity;
int space, error;
DPRINTF(VOLUMES, ("writing out logvol integrity descriptor\n"));
trace = ump->lvint_trace;
while (trace->wpos > (trace->end - trace->start)) {
DPRINTF(VOLUMES, ("skip : start = %d, end = %d, pos = %d, "
"wpos = %d\n", trace->start, trace->end,
trace->pos, trace->wpos));
trace++;
}
space = (trace->end - trace->start) - trace->wpos;
DPRINTF(VOLUMES, ("write start = %d, end = %d, pos = %d, wpos = %d, "
"space = %d\n", trace->start, trace->end, trace->pos,
trace->wpos, space));
logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
if (logvol_integrity == UDF_INTEGRITY_CLOSED) {
if ((space < 3) && (lvflag & UDF_APPENDONLY_LVINT)) {
return EROFS;
}
}
if (space < 1) {
if (lvflag & UDF_APPENDONLY_LVINT)
return EROFS;
error = udf_loose_lvint_history(ump);
if (error)
return error;
trace = ump->lvint_trace;
while (trace->wpos > (trace->end - trace->start))
trace++;
space = (trace->end - trace->start) - trace->wpos;
DPRINTF(VOLUMES, ("new try: write start = %d, end = %d, "
"pos = %d, wpos = %d, "
"space = %d\n", trace->start, trace->end,
trace->pos, trace->wpos, space));
}
DPRINTF(VOLUMES, ("updating integrity descriptor\n"));
microtime(&now_v);
TIMEVAL_TO_TIMESPEC(&now_v, &now_s);
udf_timespec_to_timestamp(&now_s, &ump->logvol_integrity->time);
udf_set_regid(&ump->logvol_info->impl_id, IMPL_NAME);
udf_add_impl_regid(ump, &ump->logvol_info->impl_id);
sector = trace->start + trace->wpos;
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
(union dscrptr *) ump->logvol_integrity,
sector, sector);
DPRINTF(VOLUMES, ("writeout lvint : error = %d\n", error));
if (error)
return error;
trace->wpos++; space--;
if (space >= 1) {
sector = trace->start + trace->wpos;
error = udf_write_terminator(ump, sector);
DPRINTF(VOLUMES, ("write terminator : error = %d\n", error));
}
space = (trace->end - trace->start) - trace->wpos;
DPRINTF(VOLUMES, ("write start = %d, end = %d, pos = %d, wpos = %d, "
"space = %d\n", trace->start, trace->end, trace->pos,
trace->wpos, space));
DPRINTF(VOLUMES, ("finished writing out logvol integrity descriptor "
"successfully\n"));
return error;
}
static int
udf_read_physical_partition_spacetables(struct udf_mount *ump)
{
union dscrptr *dscr;
struct part_desc *partd;
struct part_hdr_desc *parthdr;
struct udf_bitmap *bitmap;
uint32_t phys_part;
uint32_t lb_num, len;
int error, dscr_type;
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
lb_num = udf_rw32(partd->start_loc);
lb_num += udf_rw32(parthdr->unalloc_space_bitmap.lb_num);
len = udf_rw32(parthdr->unalloc_space_bitmap.len);
if (len == 0)
continue;
DPRINTF(VOLUMES, ("Read unalloc. space bitmap %d\n", lb_num));
error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
if (!error && dscr) {
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_SPACE_BITMAP) {
DPRINTF(VOLUMES, ("Accepting space bitmap\n"));
ump->part_unalloc_dscr[phys_part] = &dscr->sbd;
bitmap = &ump->part_unalloc_bits[phys_part];
bitmap->blob = (uint8_t *) dscr;
bitmap->bits = dscr->sbd.data;
bitmap->max_offset = udf_rw32(dscr->sbd.num_bits);
bitmap->pages = NULL;
bitmap->data_pos = 0;
bitmap->metadata_pos = 0;
} else {
free(dscr, M_UDFVOLD);
printf( "UDF mount: error reading unallocated "
"space bitmap\n");
return EROFS;
}
} else {
printf("UDF mount: blank unallocated space bitmap\n");
return EROFS;
}
}
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
len = udf_rw32(parthdr->unalloc_space_table.len);
if (len) {
printf("UDF mount: space tables not supported\n");
return EROFS;
}
}
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
lb_num = udf_rw32(partd->start_loc);
lb_num += udf_rw32(parthdr->freed_space_bitmap.lb_num);
len = udf_rw32(parthdr->freed_space_bitmap.len);
if (len == 0)
continue;
DPRINTF(VOLUMES, ("Read unalloc. space bitmap %d\n", lb_num));
error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
if (!error && dscr) {
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_SPACE_BITMAP) {
DPRINTF(VOLUMES, ("Accepting space bitmap\n"));
ump->part_freed_dscr[phys_part] = &dscr->sbd;
bitmap = &ump->part_unalloc_bits[phys_part];
bitmap->blob = (uint8_t *) dscr;
bitmap->bits = dscr->sbd.data;
bitmap->max_offset = udf_rw32(dscr->sbd.num_bits);
bitmap->pages = NULL;
bitmap->data_pos = 0;
bitmap->metadata_pos = 0;
} else {
free(dscr, M_UDFVOLD);
printf( "UDF mount: error reading freed "
"space bitmap\n");
return EROFS;
}
} else {
printf("UDF mount: blank freed space bitmap\n");
return EROFS;
}
}
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
len = udf_rw32(parthdr->freed_space_table.len);
if (len) {
printf("UDF mount: space tables not supported\n");
return EROFS;
}
}
return 0;
}
int
udf_write_physical_partition_spacetables(struct udf_mount *ump, int waitfor)
{
union dscrptr *dscr;
struct part_desc *partd;
struct part_hdr_desc *parthdr;
uint32_t phys_part;
uint32_t lb_num, len, ptov;
int error_all, error;
error_all = 0;
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
ptov = udf_rw32(partd->start_loc);
lb_num = udf_rw32(parthdr->unalloc_space_bitmap.lb_num);
len = udf_rw32(parthdr->unalloc_space_bitmap.len);
if (len == 0)
continue;
DPRINTF(VOLUMES, ("Write unalloc. space bitmap %d\n",
lb_num + ptov));
dscr = (union dscrptr *) ump->part_unalloc_dscr[phys_part];
KASSERT(udf_rw16(dscr->sbd.tag.id) == TAGID_SPACE_BITMAP);
if (udf_rw16(dscr->sbd.tag.desc_crc_len) == 0)
dscr->sbd.tag.desc_crc_len = udf_rw16(8);
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
(union dscrptr *) dscr,
ptov + lb_num, lb_num);
if (error) {
DPRINTF(VOLUMES, ("\tfailed!! (error %d)\n", error));
error_all = error;
}
}
for (phys_part = 0; phys_part < UDF_PARTITIONS; phys_part++) {
partd = ump->partitions[phys_part];
if (partd == NULL)
continue;
parthdr = &partd->_impl_use.part_hdr;
ptov = udf_rw32(partd->start_loc);
lb_num = udf_rw32(parthdr->freed_space_bitmap.lb_num);
len = udf_rw32(parthdr->freed_space_bitmap.len);
if (len == 0)
continue;
DPRINTF(VOLUMES, ("Write freed space bitmap %d\n",
lb_num + ptov));
dscr = (union dscrptr *) ump->part_freed_dscr[phys_part];
KASSERT(udf_rw16(dscr->sbd.tag.id) == TAGID_SPACE_BITMAP);
if (udf_rw16(dscr->sbd.tag.desc_crc_len) == 0)
dscr->sbd.tag.desc_crc_len = udf_rw16(8);
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
(union dscrptr *) dscr,
ptov + lb_num, lb_num);
if (error) {
DPRINTF(VOLUMES, ("\tfailed!! (error %d)\n", error));
error_all = error;
}
}
return error_all;
}
static int
udf_read_metadata_partition_spacetable(struct udf_mount *ump)
{
struct udf_node *bitmap_node;
union dscrptr *dscr;
struct udf_bitmap *bitmap;
uint64_t inflen;
int error, dscr_type;
bitmap_node = ump->metadatabitmap_node;
if (bitmap_node == NULL)
return 0;
if (bitmap_node->fe) {
inflen = udf_rw64(bitmap_node->fe->inf_len);
} else {
KASSERT(bitmap_node->efe);
inflen = udf_rw64(bitmap_node->efe->inf_len);
}
DPRINTF(VOLUMES, ("Reading metadata space bitmap for "
"%"PRIu64" bytes\n", inflen));
dscr = malloc(inflen, M_UDFVOLD, M_WAITOK);
if (!dscr)
return ENOMEM;
bitmap_node->vnode->v_type = VREG;
error = vn_rdwr(UIO_READ, bitmap_node->vnode,
dscr,
inflen, 0,
UIO_SYSSPACE,
IO_SYNC | IO_ALTSEMANTICS, FSCRED,
NULL, NULL);
if (error) {
DPRINTF(VOLUMES, ("Error reading metadata space bitmap\n"));
goto errorout;
}
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_SPACE_BITMAP) {
DPRINTF(VOLUMES, ("Accepting metadata space bitmap\n"));
ump->metadata_unalloc_dscr = &dscr->sbd;
bitmap = &ump->metadata_unalloc_bits;
bitmap->blob = (uint8_t *) dscr;
bitmap->bits = dscr->sbd.data;
bitmap->max_offset = udf_rw32(dscr->sbd.num_bits);
bitmap->pages = NULL;
bitmap->data_pos = 0;
bitmap->metadata_pos = 0;
} else {
DPRINTF(VOLUMES, ("No valid bitmap found!\n"));
goto errorout;
}
return 0;
errorout:
free(dscr, M_UDFVOLD);
printf( "UDF mount: error reading unallocated "
"space bitmap for metadata partition\n");
return EROFS;
}
int
udf_write_metadata_partition_spacetable(struct udf_mount *ump, int waitfor)
{
struct udf_node *bitmap_node;
union dscrptr *dscr;
uint64_t new_inflen;
int dummy, error;
bitmap_node = ump->metadatabitmap_node;
if (bitmap_node == NULL)
return 0;
if (!bitmap_node->fe) {
KASSERT(bitmap_node->efe);
}
dscr = (union dscrptr *) ump->metadata_unalloc_dscr;
new_inflen = udf_tagsize(dscr, 1);
DPRINTF(VOLUMES, ("Resize and write out metadata space bitmap "
" for %"PRIu64" bytes\n", new_inflen));
error = udf_resize_node(bitmap_node, new_inflen, &dummy);
if (error)
printf("Error resizing metadata space bitmap\n");
error = vn_rdwr(UIO_WRITE, bitmap_node->vnode,
dscr,
new_inflen, 0,
UIO_SYSSPACE,
IO_ALTSEMANTICS, FSCRED,
NULL, NULL);
bitmap_node->i_flags |= IN_MODIFIED;
error = vflushbuf(bitmap_node->vnode, FSYNC_WAIT);
if (error == 0)
error = VOP_FSYNC(bitmap_node->vnode,
FSCRED, FSYNC_WAIT, 0, 0);
if (error)
printf( "Error writing out metadata partition unalloced "
"space bitmap!\n");
return error;
}
int
udf_process_vds(struct udf_mount *ump) {
union udf_pmap *mapping;
struct logvol_int_desc *lvint;
struct udf_logvol_info *lvinfo;
uint32_t n_pm;
uint8_t *pmap_pos;
char *domain_name, *map_name;
const char *check_name;
char bits[128];
int pmap_stype, pmap_size;
int pmap_type, log_part, phys_part, raw_phys_part, maps_on;
int n_phys, n_virt, n_spar, n_meta;
int len;
if (ump == NULL)
return ENOENT;
if (ump->anchors[0] == NULL)
return EINVAL;
if ((ump->primary_vol == NULL) || (ump->logical_vol) == NULL)
return EINVAL;
if (ump->partitions[0] == NULL)
return EINVAL;
if (udf_rw32(ump->logical_vol->lb_size) != ump->discinfo.sector_size) {
printf("UDF mount: format violation, lb_size != sector size\n");
return EINVAL;
}
domain_name = ump->logical_vol->domain_id.id;
if (strncmp(domain_name, "*OSTA UDF Compliant", 20)) {
printf("mount_udf: disc not OSTA UDF Compliant, aborting\n");
return EINVAL;
}
(void)udf_retrieve_lvint(ump);
if (ump->logvol_integrity == NULL)
return EINVAL;
n_pm = udf_rw32(ump->logical_vol->n_pm);
lvint = ump->logvol_integrity;
lvinfo = (struct udf_logvol_info *) (&lvint->tables[2 * n_pm]);
ump->logvol_info = lvinfo;
DPRINTF(VOLUMES, ("checking logvol mappings\n"));
n_pm = udf_rw32(ump->logical_vol->n_pm);
pmap_pos = ump->logical_vol->maps;
if (n_pm > UDF_PMAPS) {
printf("UDF mount: too many mappings\n");
return EINVAL;
}
ump->data_part = ump->node_part = ump->fids_part = 0;
n_phys = n_virt = n_spar = n_meta = 0;
for (log_part = 0; log_part < n_pm; log_part++) {
mapping = (union udf_pmap *) pmap_pos;
pmap_stype = pmap_pos[0];
pmap_size = pmap_pos[1];
switch (pmap_stype) {
case 1:
raw_phys_part = udf_rw16(mapping->pm1.part_num);
pmap_type = UDF_VTOP_TYPE_PHYS;
n_phys++;
ump->data_part = log_part;
ump->node_part = log_part;
ump->fids_part = log_part;
break;
case 2:
map_name = mapping->pm2.part_id.id;
raw_phys_part = udf_rw16(mapping->pm2.part_num);
pmap_type = UDF_VTOP_TYPE_UNKNOWN;
len = UDF_REGID_ID_SIZE;
check_name = "*UDF Virtual Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_VIRT;
n_virt++;
ump->node_part = log_part;
break;
}
check_name = "*UDF Sparable Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_SPARABLE;
n_spar++;
ump->data_part = log_part;
ump->node_part = log_part;
ump->fids_part = log_part;
break;
}
check_name = "*UDF Metadata Partition";
if (strncmp(map_name, check_name, len) == 0) {
pmap_type = UDF_VTOP_TYPE_META;
n_meta++;
ump->node_part = log_part;
ump->fids_part = log_part;
break;
}
break;
default:
return EINVAL;
}
phys_part = udf_find_raw_phys(ump, raw_phys_part);
DPRINTF(VOLUMES, ("\t%d -> %d(%d) type %d\n", log_part,
raw_phys_part, phys_part, pmap_type));
if (phys_part == UDF_PARTITIONS)
return EINVAL;
if (pmap_type == UDF_VTOP_TYPE_UNKNOWN)
return EINVAL;
ump->vtop [log_part] = phys_part;
ump->vtop_tp[log_part] = pmap_type;
pmap_pos += pmap_size;
}
ump->vtop_tp[UDF_VTOP_RAWPART] = UDF_VTOP_TYPE_RAW;
if ((n_virt > 1) || (n_spar > 1) || (n_meta > 1))
return EINVAL;
if (n_virt) {
if ((n_phys == 0) || n_spar || n_meta)
return EINVAL;
}
if (n_spar + n_phys == 0)
return EINVAL;
for (log_part = 0; log_part < n_pm; log_part++) {
maps_on = ump->vtop[log_part];
switch (ump->vtop_tp[log_part]) {
case UDF_VTOP_TYPE_PHYS :
assert(maps_on == log_part);
ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
break;
case UDF_VTOP_TYPE_VIRT :
ump->vtop_alloc[log_part] = UDF_ALLOC_VAT;
ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
break;
case UDF_VTOP_TYPE_SPARABLE :
assert(maps_on == log_part);
ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
break;
case UDF_VTOP_TYPE_META :
ump->vtop_alloc[log_part] = UDF_ALLOC_METABITMAP;
if (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE) {
ump->vtop_alloc[log_part] = UDF_ALLOC_METASEQUENTIAL;
ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
}
break;
default:
panic("bad allocation type in udf's ump->vtop\n");
}
}
if (n_virt) {
ump->lvopen = 0;
if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
ump->lvopen |= UDF_OPEN_SESSION ;
ump->lvclose = UDF_WRITE_VAT;
if (ump->mount_args.udfmflags & UDFMNT_CLOSESESSION)
ump->lvclose |= UDF_CLOSE_SESSION;
} else {
ump->lvopen = UDF_WRITE_LVINT;
ump->lvclose = UDF_WRITE_LVINT;
if ((ump->discinfo.mmc_cur & MMC_CAP_REWRITABLE) == 0)
ump->lvopen |= UDF_APPENDONLY_LVINT;
if ((ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE))
ump->lvopen &= ~UDF_APPENDONLY_LVINT;
}
ump->lvreadwrite = 0;
if (n_virt)
ump->lvreadwrite = UDF_UPDATE_TRACKINFO;
if (n_spar)
ump->lvreadwrite = UDF_REMAP_BLOCK;
ump->strategy = &udf_strat_rmw;
if (n_virt || (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE))
ump->strategy = &udf_strat_sequential;
if ((ump->discinfo.mmc_class == MMC_CLASS_DISC) ||
(ump->discinfo.mmc_class == MMC_CLASS_UNKN))
ump->strategy = &udf_strat_direct;
if (n_spar)
ump->strategy = &udf_strat_rmw;
#if 0
if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
ump->strategy = &udf_strat_direct;
#endif
DPRINTF(VOLUMES, ("\tdata partition %d\n", ump->data_part));
DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->data_part]));
DPRINTF(VOLUMES, ("\tnode partition %d\n", ump->node_part));
DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->node_part]));
DPRINTF(VOLUMES, ("\tfids partition %d\n", ump->fids_part));
DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->fids_part]));
snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvopen);
DPRINTF(VOLUMES, ("\tactions on logvol open %s\n", bits));
snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvclose);
DPRINTF(VOLUMES, ("\tactions on logvol close %s\n", bits));
snprintb(bits, sizeof(bits), UDFONERROR_BITS, ump->lvreadwrite);
DPRINTF(VOLUMES, ("\tactions on logvol errors %s\n", bits));
DPRINTF(VOLUMES, ("\tselected scheduler `%s`\n",
(ump->strategy == &udf_strat_direct) ? "Direct" :
(ump->strategy == &udf_strat_sequential) ? "Sequential" :
(ump->strategy == &udf_strat_rmw) ? "RMW" : "UNKNOWN!"));
return 0;
}
static void
udf_update_logvolname(struct udf_mount *ump, char *logvol_id)
{
struct logvol_desc *lvd = NULL;
struct fileset_desc *fsd = NULL;
struct udf_lv_info *lvi = NULL;
DPRINTF(VOLUMES, ("Updating logical volume name\n"));
lvd = ump->logical_vol;
fsd = ump->fileset_desc;
if (ump->implementation)
lvi = &ump->implementation->_impl_use.lv_info;
memmove(lvd->logvol_id, logvol_id, 128);
if (fsd)
memmove(fsd->logvol_id, logvol_id, 128);
if (lvi)
memmove(lvi->logvol_id, logvol_id, 128);
}
void
udf_inittag(struct udf_mount *ump, struct desc_tag *tag, int tagid,
uint32_t sector)
{
assert(ump->logical_vol);
tag->id = udf_rw16(tagid);
tag->descriptor_ver = ump->logical_vol->tag.descriptor_ver;
tag->cksum = 0;
tag->reserved = 0;
tag->serial_num = ump->logical_vol->tag.serial_num;
tag->tag_loc = udf_rw32(sector);
}
uint64_t
udf_advance_uniqueid(struct udf_mount *ump)
{
uint64_t unique_id;
mutex_enter(&ump->logvol_mutex);
unique_id = udf_rw64(ump->logvol_integrity->lvint_next_unique_id);
if (unique_id < 0x10)
unique_id = 0x10;
ump->logvol_integrity->lvint_next_unique_id = udf_rw64(unique_id + 1);
mutex_exit(&ump->logvol_mutex);
return unique_id;
}
static void
udf_adjust_filecount(struct udf_node *udf_node, int sign)
{
struct udf_mount *ump = udf_node->ump;
uint32_t num_dirs, num_files;
int udf_file_type;
if (udf_node->fe) {
udf_file_type = udf_node->fe->icbtag.file_type;
} else {
udf_file_type = udf_node->efe->icbtag.file_type;
}
mutex_enter(&ump->allocate_mutex);
if (udf_file_type == UDF_ICB_FILETYPE_DIRECTORY) {
num_dirs = udf_rw32(ump->logvol_info->num_directories);
ump->logvol_info->num_directories =
udf_rw32((num_dirs + sign));
} else {
num_files = udf_rw32(ump->logvol_info->num_files);
ump->logvol_info->num_files =
udf_rw32((num_files + sign));
}
mutex_exit(&ump->allocate_mutex);
}
void
udf_osta_charset(struct charspec *charspec)
{
memset(charspec, 0, sizeof(struct charspec));
charspec->type = 0;
strcpy((char *) charspec->inf, "OSTA Compressed Unicode");
}
void
udf_set_regid(struct regid *regid, char const *name)
{
memset(regid, 0, sizeof(struct regid));
regid->flags = 0;
strcpy((char *) regid->id, name);
}
void
udf_add_domain_regid(struct udf_mount *ump, struct regid *regid)
{
uint16_t *ver;
ver = (uint16_t *) regid->id_suffix;
*ver = ump->logvol_info->min_udf_readver;
}
void
udf_add_udf_regid(struct udf_mount *ump, struct regid *regid)
{
uint16_t *ver;
ver = (uint16_t *) regid->id_suffix;
*ver = ump->logvol_info->min_udf_readver;
regid->id_suffix[2] = 4;
regid->id_suffix[3] = 8;
}
void
udf_add_impl_regid(struct udf_mount *ump, struct regid *regid)
{
regid->id_suffix[0] = 4;
regid->id_suffix[1] = 8;
}
void
udf_add_app_regid(struct udf_mount *ump, struct regid *regid)
{
regid->id_suffix[0] = APP_VERSION_MAIN;
regid->id_suffix[1] = APP_VERSION_SUB;
}
static int
udf_create_parentfid(struct udf_mount *ump, struct fileid_desc *fid,
struct long_ad *parent, uint64_t unique_id)
{
int fidsize = 40;
udf_inittag(ump, &fid->tag, TAGID_FID, udf_rw32(parent->loc.lb_num));
fid->file_version_num = udf_rw16(1);
fid->file_char = UDF_FILE_CHAR_DIR | UDF_FILE_CHAR_PAR;
fid->icb = *parent;
fid->icb.longad_uniqueid = udf_rw32((uint32_t) unique_id);
fid->tag.desc_crc_len = udf_rw16(fidsize - UDF_DESC_TAG_LENGTH);
(void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
return fidsize;
}
static int
udf_impl_extattr_check(struct impl_extattr_entry *implext)
{
uint16_t *spos;
if (strncmp(implext->imp_id.id, "*UDF", 4) == 0) {
DPRINTF(EXTATTR, ("checking UDF impl. attr checksum\n"));
spos = (uint16_t *) implext->data;
if (udf_rw16(*spos) != udf_ea_cksum((uint8_t *) implext))
return EINVAL;
}
return 0;
}
static void
udf_calc_impl_extattr_checksum(struct impl_extattr_entry *implext)
{
uint16_t *spos;
if (strncmp(implext->imp_id.id, "*UDF", 4) == 0) {
spos = (uint16_t *) implext->data;
*spos = udf_rw16(udf_ea_cksum((uint8_t *) implext));
}
}
int
udf_extattr_search_intern(struct udf_node *node,
uint32_t sattr, char const *sattrname,
uint32_t *offsetp, uint32_t *lengthp)
{
struct extattrhdr_desc *eahdr;
struct extattr_entry *attrhdr;
struct impl_extattr_entry *implext;
uint32_t offset, a_l, sector_size;
int32_t l_ea;
uint8_t *pos;
int error;
sector_size = node->ump->discinfo.sector_size;
if (node->fe) {
l_ea = udf_rw32(node->fe->l_ea);
eahdr = (struct extattrhdr_desc *) node->fe->data;
} else {
assert(node->efe);
l_ea = udf_rw32(node->efe->l_ea);
eahdr = (struct extattrhdr_desc *) node->efe->data;
}
if (l_ea == 0)
return ENOENT;
error = udf_check_tag(eahdr);
if (error)
return EINVAL;
if (udf_rw16(eahdr->tag.id) != TAGID_EXTATTR_HDR)
return EINVAL;
error = udf_check_tag_payload(eahdr, sizeof(struct extattrhdr_desc));
if (error)
return EINVAL;
DPRINTF(EXTATTR, ("Found %d bytes of extended attributes\n", l_ea));
offset = sizeof(struct extattrhdr_desc);
if (sattr == 2048) {
offset = udf_rw32(eahdr->impl_attr_loc);
if (offset == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
return ENOENT;
}
if (sattr == 65536) {
offset = udf_rw32(eahdr->appl_attr_loc);
if (offset == UDF_APPL_ATTR_LOC_NOT_PRESENT)
return ENOENT;
}
if (l_ea + offset >= sector_size - sizeof(struct extattr_entry))
return EINVAL;
DPRINTF(EXTATTR, ("Starting at offset %d\n", offset));
l_ea -= offset;
pos = (uint8_t *) eahdr + offset;
while (l_ea >= sizeof(struct extattr_entry)) {
DPRINTF(EXTATTR, ("%d extended attr bytes left\n", l_ea));
attrhdr = (struct extattr_entry *) pos;
implext = (struct impl_extattr_entry *) pos;
a_l = udf_rw32(attrhdr->a_l);
DPRINTF(EXTATTR, ("attribute %d:%d, len %d/%d\n",
udf_rw32(attrhdr->type),
attrhdr->subtype, a_l, l_ea));
if ((a_l == 0) || (a_l > l_ea))
return EINVAL;
if (udf_rw32(attrhdr->type) != sattr)
goto next_attribute;
if (udf_rw32(attrhdr->type) < 2048) {
*offsetp = offset;
*lengthp = a_l;
return 0;
}
DPRINTF(EXTATTR, ("named attribute %s\n", implext->imp_id.id));
if (strcmp(implext->imp_id.id, sattrname) == 0) {
*offsetp = offset;
*lengthp = a_l;
return 0;
}
next_attribute:
pos += a_l;
l_ea -= a_l;
offset += a_l;
}
return ENOENT;
}
static void
udf_extattr_insert_internal(struct udf_mount *ump, union dscrptr *dscr,
struct extattr_entry *extattr)
{
struct file_entry *fe;
struct extfile_entry *efe;
struct extattrhdr_desc *extattrhdr;
struct impl_extattr_entry *implext;
uint32_t impl_attr_loc, appl_attr_loc, l_ea, a_l, exthdr_len;
uint32_t *l_eap, l_ad;
uint16_t *spos;
uint8_t *bpos, *data;
if (udf_rw16(dscr->tag.id) == TAGID_FENTRY) {
fe = &dscr->fe;
data = fe->data;
l_eap = &fe->l_ea;
l_ad = udf_rw32(fe->l_ad);
} else if (udf_rw16(dscr->tag.id) == TAGID_EXTFENTRY) {
efe = &dscr->efe;
data = efe->data;
l_eap = &efe->l_ea;
l_ad = udf_rw32(efe->l_ad);
} else {
panic("Bad tag passed to udf_extattr_insert_internal");
}
assert(l_ad == 0);
__USE(l_ad);
extattrhdr = (struct extattrhdr_desc *) data;
l_ea = udf_rw32(*l_eap);
if (l_ea == 0) {
exthdr_len = sizeof(struct extattrhdr_desc);
udf_inittag(ump, &extattrhdr->tag, TAGID_EXTATTR_HDR,
0);
extattrhdr->impl_attr_loc = udf_rw32(exthdr_len);
extattrhdr->appl_attr_loc = udf_rw32(exthdr_len);
extattrhdr->tag.desc_crc_len = udf_rw16(8);
l_ea = exthdr_len;
*l_eap = udf_rw32(l_ea);
}
impl_attr_loc = udf_rw32(extattrhdr->impl_attr_loc);
appl_attr_loc = udf_rw32(extattrhdr->appl_attr_loc);
if (impl_attr_loc == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
impl_attr_loc = l_ea;
if (appl_attr_loc == UDF_IMPL_ATTR_LOC_NOT_PRESENT)
appl_attr_loc = l_ea;
if (udf_rw32(extattr->type) < 2048) {
assert(impl_attr_loc == l_ea);
assert(appl_attr_loc == l_ea);
}
if (udf_rw32(extattr->type) == 2048) {
assert(appl_attr_loc == l_ea);
implext = (struct impl_extattr_entry *) extattr;
assert(udf_rw32(implext->iu_l) == 4);
spos = (uint16_t *) implext->data;
*spos = udf_rw16(udf_ea_cksum((uint8_t *) implext));
}
assert(udf_rw32(extattr->type) != 65536);
assert(appl_attr_loc == l_ea);
bpos = data + udf_rw32(*l_eap);
a_l = udf_rw32(extattr->a_l);
if (udf_rw32(extattr->type) < 2048) {
impl_attr_loc = l_ea + a_l;
appl_attr_loc = l_ea + a_l;
}
if (udf_rw32(extattr->type) == 2048) {
appl_attr_loc = l_ea + a_l;
}
memcpy(bpos, extattr, a_l);
l_ea += a_l;
*l_eap = udf_rw32(l_ea);
if (udf_rw16(ump->logical_vol->tag.descriptor_ver) != 2) {
if (impl_attr_loc == l_ea)
impl_attr_loc = UDF_IMPL_ATTR_LOC_NOT_PRESENT;
if (appl_attr_loc == l_ea)
appl_attr_loc = UDF_APPL_ATTR_LOC_NOT_PRESENT;
}
extattrhdr->impl_attr_loc = udf_rw32(impl_attr_loc);
extattrhdr->appl_attr_loc = udf_rw32(appl_attr_loc);
}
static int
udf_update_lvid_from_vat_extattr(struct udf_node *vat_node)
{
struct udf_mount *ump;
struct udf_logvol_info *lvinfo;
struct impl_extattr_entry *implext;
struct vatlvext_extattr_entry lvext;
const char *extstr = "*UDF VAT LVExtension";
uint64_t vat_uniqueid;
uint32_t offset, a_l;
uint8_t *ea_start, *lvextpos;
int error;
ump = vat_node->ump;
lvinfo = ump->logvol_info;
if (vat_node->fe) {
vat_uniqueid = udf_rw64(vat_node->fe->unique_id);
ea_start = vat_node->fe->data;
} else {
vat_uniqueid = udf_rw64(vat_node->efe->unique_id);
ea_start = vat_node->efe->data;
}
error = udf_extattr_search_intern(vat_node, 2048, extstr, &offset, &a_l);
if (error)
return error;
implext = (struct impl_extattr_entry *) (ea_start + offset);
error = udf_impl_extattr_check(implext);
if (error)
return error;
if (a_l != sizeof(*implext) -2 + udf_rw32(implext->iu_l) + sizeof(lvext)) {
DPRINTF(VOLUMES, ("VAT LVExtension size doesn't compute\n"));
return EINVAL;
}
DPRINTF(VOLUMES, ("Found VAT LVExtension attr\n"));
lvextpos = implext->data + udf_rw32(implext->iu_l);
memcpy(&lvext, lvextpos, sizeof(lvext));
if (udf_rw64(lvext.unique_id_chk) == vat_uniqueid) {
lvinfo->num_files = lvext.num_files;
lvinfo->num_directories = lvext.num_directories;
udf_update_logvolname(ump, lvext.logvol_id);
} else {
DPRINTF(VOLUMES, ("VAT LVExtension out of date\n"));
memset(implext->imp_id.id, 0, UDF_REGID_ID_SIZE);
strcpy(implext->imp_id.id, "*UDF FreeEASpace");
udf_calc_impl_extattr_checksum(implext);
}
return 0;
}
static int
udf_update_vat_extattr_from_lvid(struct udf_node *vat_node)
{
struct udf_mount *ump;
struct udf_logvol_info *lvinfo;
struct impl_extattr_entry *implext;
struct vatlvext_extattr_entry lvext;
const char *extstr = "*UDF VAT LVExtension";
uint64_t vat_uniqueid;
uint32_t offset, a_l;
uint8_t *ea_start;
uintptr_t lvextpos;
int error;
ump = vat_node->ump;
lvinfo = ump->logvol_info;
if (vat_node->fe) {
vat_uniqueid = udf_rw64(vat_node->fe->unique_id);
ea_start = vat_node->fe->data;
} else {
vat_uniqueid = udf_rw64(vat_node->efe->unique_id);
ea_start = vat_node->efe->data;
}
error = udf_extattr_search_intern(vat_node, 2048, extstr, &offset, &a_l);
if (error)
return error;
implext = (struct impl_extattr_entry *) (ea_start + offset);
error = udf_impl_extattr_check(implext);
if (error) {
DPRINTF(VOLUMES, ("VAT LVExtension bad on update\n"));
return error;
}
DPRINTF(VOLUMES, ("Updating VAT LVExtension attr\n"));
lvextpos = (uintptr_t)implext->data + udf_rw32(implext->iu_l);
lvext.unique_id_chk = vat_uniqueid;
lvext.num_files = lvinfo->num_files;
lvext.num_directories = lvinfo->num_directories;
memmove(lvext.logvol_id, ump->logical_vol->logvol_id, 128);
memcpy((void *)lvextpos, &lvext, sizeof(lvext));
return 0;
}
int
udf_vat_read(struct udf_node *vat_node, uint8_t *blob, int size, uint32_t offset)
{
struct udf_mount *ump = vat_node->ump;
if (offset + size > ump->vat_offset + ump->vat_entries * 4)
return EINVAL;
memcpy(blob, ump->vat_table + offset, size);
return 0;
}
int
udf_vat_write(struct udf_node *vat_node, uint8_t *blob, int size, uint32_t offset)
{
struct udf_mount *ump = vat_node->ump;
uint32_t offset_high;
uint8_t *new_vat_table;
offset_high = offset + size;
if (offset_high >= ump->vat_table_alloc_len) {
new_vat_table = realloc(ump->vat_table,
ump->vat_table_alloc_len + UDF_VAT_CHUNKSIZE,
M_UDFVOLD, M_WAITOK);
if (!new_vat_table) {
printf("udf_vat_write: can't extent VAT, out of mem\n");
return ENOMEM;
}
ump->vat_table = new_vat_table;
ump->vat_table_alloc_len += UDF_VAT_CHUNKSIZE;
}
ump->vat_table_len = MAX(ump->vat_table_len, offset_high);
memcpy(ump->vat_table + offset, blob, size);
return 0;
}
static int
udf_update_vat_descriptor(struct udf_mount *ump)
{
struct udf_node *vat_node = ump->vat_node;
struct udf_logvol_info *lvinfo = ump->logvol_info;
struct icb_tag *icbtag;
struct udf_oldvat_tail *oldvat_tl;
struct udf_vat *vat;
struct regid *regid;
uint64_t unique_id;
uint32_t lb_size;
uint8_t *raw_vat;
int vat_length, impl_use_len, filetype, error;
KASSERT(vat_node);
KASSERT(lvinfo);
lb_size = udf_rw32(ump->logical_vol->lb_size);
unique_id = udf_advance_uniqueid(ump);
if (vat_node->fe) {
icbtag = &vat_node->fe->icbtag;
vat_node->fe->unique_id = udf_rw64(unique_id);
} else {
icbtag = &vat_node->efe->icbtag;
vat_node->efe->unique_id = udf_rw64(unique_id);
}
filetype = icbtag->file_type;
KASSERT((filetype == 0) || (filetype == UDF_ICB_FILETYPE_VAT));
raw_vat = malloc(lb_size, M_TEMP, M_WAITOK);
if (filetype == 0) {
udf_update_vat_extattr_from_lvid(vat_node);
oldvat_tl = (struct udf_oldvat_tail *) raw_vat;
memset(oldvat_tl, 0, sizeof(struct udf_oldvat_tail));
udf_set_regid(&oldvat_tl->id, "*UDF Virtual Alloc Tbl");
udf_add_udf_regid(ump, &oldvat_tl->id);
oldvat_tl->prev_vat = udf_rw32(0xffffffff);
error = udf_vat_write(vat_node, raw_vat,
sizeof(struct udf_oldvat_tail), ump->vat_entries * 4);
} else {
vat_length = sizeof(struct udf_vat);
vat = (struct udf_vat *) raw_vat;
error = udf_vat_read(vat_node, raw_vat, vat_length, 0);
if (error)
goto errout;
impl_use_len = udf_rw16(vat->impl_use_len);
vat_length += impl_use_len;
error = udf_vat_read(vat_node, raw_vat, vat_length, 0);
if (error)
goto errout;
memmove(vat->logvol_id, ump->logical_vol->logvol_id, 128);
vat->prev_vat = udf_rw32(0xffffffff);
vat->num_files = lvinfo->num_files;
vat->num_directories = lvinfo->num_directories;
vat->min_udf_readver = lvinfo->min_udf_readver;
vat->min_udf_writever = lvinfo->min_udf_writever;
vat->max_udf_writever = lvinfo->max_udf_writever;
if (impl_use_len >= sizeof(struct regid)) {
memset(vat->data, 0, impl_use_len);
regid = (struct regid *) vat->data;
udf_set_regid(regid, IMPL_NAME);
udf_add_app_regid(ump, regid);
} else {
if (impl_use_len)
memset(vat->data, 0, impl_use_len);
vat->impl_use_len = 0;
}
error = udf_vat_write(vat_node, raw_vat, vat_length, 0);
}
errout:
free(raw_vat, M_TEMP);
return error;
}
int
udf_writeout_vat(struct udf_mount *ump)
{
struct udf_node *vat_node = ump->vat_node;
int error;
KASSERT(vat_node);
DPRINTF(CALL, ("udf_writeout_vat\n"));
udf_update_vat_descriptor(ump);
error = vn_rdwr(UIO_WRITE, vat_node->vnode,
ump->vat_table, ump->vat_table_len, 0,
UIO_SYSSPACE, 0, FSCRED, NULL, NULL);
if (error) {
printf("udf_writeout_vat: failed to write out VAT contents\n");
goto out;
}
error = vflushbuf(ump->vat_node->vnode, FSYNC_WAIT);
if (error)
goto out;
error = VOP_FSYNC(ump->vat_node->vnode,
FSCRED, FSYNC_WAIT, 0, 0);
if (error)
printf("udf_writeout_vat: error writing VAT node!\n");
out:
return error;
}
static int
udf_check_for_vat(struct udf_node *vat_node)
{
struct udf_mount *ump;
struct icb_tag *icbtag;
struct timestamp *mtime;
struct udf_vat *vat;
struct udf_oldvat_tail *oldvat_tl;
struct udf_logvol_info *lvinfo;
uint64_t unique_id;
uint32_t vat_length;
uint32_t vat_offset, vat_entries, vat_table_alloc_len;
uint32_t sector_size;
uint32_t *raw_vat;
uint8_t *vat_table;
char *regid_name;
int filetype;
int error;
DPRINTF(VOLUMES, ("Checking for VAT\n"));
if (!vat_node)
return ENOENT;
ump = vat_node->ump;
sector_size = udf_rw32(ump->logical_vol->lb_size);
assert(vat_node->fe || vat_node->efe);
assert(ump->logvol_integrity);
vat_node->vnode->v_type = VREG;
if (vat_node->fe) {
vat_length = udf_rw64(vat_node->fe->inf_len);
icbtag = &vat_node->fe->icbtag;
mtime = &vat_node->fe->mtime;
unique_id = udf_rw64(vat_node->fe->unique_id);
} else {
vat_length = udf_rw64(vat_node->efe->inf_len);
icbtag = &vat_node->efe->icbtag;
mtime = &vat_node->efe->mtime;
unique_id = udf_rw64(vat_node->efe->unique_id);
}
filetype = icbtag->file_type;
if ((filetype != 0) && (filetype != UDF_ICB_FILETYPE_VAT))
return ENOENT;
DPRINTF(VOLUMES, ("\tPossible VAT length %d\n", vat_length));
vat_table_alloc_len =
((vat_length + UDF_VAT_CHUNKSIZE-1) / UDF_VAT_CHUNKSIZE)
* UDF_VAT_CHUNKSIZE;
vat_table = malloc(vat_table_alloc_len, M_UDFVOLD, M_WAITOK);
if (vat_table == NULL) {
printf("allocation of %d bytes failed for VAT\n",
vat_table_alloc_len);
return ENOMEM;
}
raw_vat = malloc(sector_size, M_TEMP, M_WAITOK);
lvinfo = ump->logvol_info;
if (filetype == 0) {
vat_offset = 0;
vat_entries = (vat_length-36)/4;
error = vn_rdwr(UIO_READ, vat_node->vnode,
(uint8_t *) raw_vat,
sizeof(struct udf_oldvat_tail),
vat_entries * 4,
UIO_SYSSPACE, IO_SYNC | IO_NODELOCKED, FSCRED,
NULL, NULL);
if (error)
goto out;
oldvat_tl = (struct udf_oldvat_tail *) raw_vat;
regid_name = (char *) oldvat_tl->id.id;
error = strncmp(regid_name, "*UDF Virtual Alloc Tbl", 22);
if (error) {
DPRINTF(VOLUMES, ("VAT format 1.50 rejected\n"));
error = ENOENT;
goto out;
}
udf_update_lvid_from_vat_extattr(vat_node);
} else {
error = vn_rdwr(UIO_READ, vat_node->vnode,
(uint8_t *) raw_vat,
sizeof(struct udf_vat), 0,
UIO_SYSSPACE, IO_SYNC | IO_NODELOCKED, FSCRED,
NULL, NULL);
if (error)
goto out;
vat = (struct udf_vat *) raw_vat;
vat_offset = udf_rw16(vat->header_len);
vat_entries = (vat_length - vat_offset)/4;
assert(lvinfo);
lvinfo->num_files = vat->num_files;
lvinfo->num_directories = vat->num_directories;
lvinfo->min_udf_readver = vat->min_udf_readver;
lvinfo->min_udf_writever = vat->min_udf_writever;
lvinfo->max_udf_writever = vat->max_udf_writever;
udf_update_logvolname(ump, vat->logvol_id);
}
error = vn_rdwr(UIO_READ, vat_node->vnode,
vat_table,
vat_length, 0,
UIO_SYSSPACE, IO_SYNC | IO_NODELOCKED, FSCRED,
NULL, NULL);
if (error)
printf("read in of complete VAT file failed (error %d)\n",
error);
if (error)
goto out;
DPRINTF(VOLUMES, ("VAT format accepted, marking it closed\n"));
ump->logvol_integrity->lvint_next_unique_id = udf_rw64(unique_id);
ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_CLOSED);
ump->logvol_integrity->time = *mtime;
if (ump->vat_table)
free(ump->vat_table, M_UDFVOLD);
ump->vat_table_len = vat_length;
ump->vat_table_alloc_len = vat_table_alloc_len;
ump->vat_table = vat_table;
ump->vat_offset = vat_offset;
ump->vat_entries = vat_entries;
ump->vat_last_free_lb = 0;
out:
if (error) {
if (vat_table)
free(vat_table, M_UDFVOLD);
}
free(raw_vat, M_TEMP);
return error;
}
static int
udf_search_vat(struct udf_mount *ump, union udf_pmap *mapping)
{
struct udf_node *vat_node, *accepted_vat_node;
struct long_ad icb_loc;
uint32_t early_vat_loc, late_vat_loc, vat_loc;
int error;
mapping = mapping;
DPRINTF(VOLUMES, ("Searching VAT\n"));
late_vat_loc = ump->last_possible_vat_location;
early_vat_loc = MAX(late_vat_loc - 64, ump->first_possible_vat_location);
DPRINTF(VOLUMES, ("\tfull range %d to %d\n", early_vat_loc, late_vat_loc));
accepted_vat_node = NULL;
do {
vat_loc = early_vat_loc;
DPRINTF(VOLUMES, ("\tchecking range %d to %d\n",
early_vat_loc, late_vat_loc));
do {
DPRINTF(VOLUMES, ("\t\tChecking for VAT at sector %d\n",
vat_loc));
icb_loc.loc.part_num = udf_rw16(UDF_VTOP_RAWPART);
icb_loc.loc.lb_num = udf_rw32(vat_loc);
error = udf_get_node(ump, &icb_loc, &vat_node,
LK_EXCLUSIVE);
if (!error) {
error = udf_check_for_vat(vat_node);
vat_node->i_flags = 0;
}
if (!error) {
DPRINTFIF(VOLUMES, !error,
("VAT candidate accepted at %d\n",
vat_loc));
if (accepted_vat_node)
vput(accepted_vat_node->vnode);
accepted_vat_node = vat_node;
accepted_vat_node->i_flags |= IN_NO_DELETE;
vat_node = NULL;
}
if (vat_node)
vput(vat_node->vnode);
vat_loc++;
} while (vat_loc <= late_vat_loc);
if (accepted_vat_node)
break;
early_vat_loc = MAX(early_vat_loc - 64, ump->first_possible_vat_location);
late_vat_loc = MIN(early_vat_loc + 64, ump->last_possible_vat_location);
} while (late_vat_loc > ump->first_possible_vat_location);
if (accepted_vat_node) {
accepted_vat_node->i_flags &= ~IN_NO_DELETE;
UDF_SET_SYSTEMFILE(accepted_vat_node->vnode);
ump->vat_node = accepted_vat_node;
return 0;
}
return error;
}
static int
udf_read_sparables(struct udf_mount *ump, union udf_pmap *mapping)
{
union dscrptr *dscr;
struct part_map_spare *pms = &mapping->pms;
uint32_t lb_num;
int spar, error;
DPRINTF(VOLUMES, ("Read sparable table\n"));
ump->sparable_packet_size = udf_rw16(pms->packet_len);
KASSERT(ump->sparable_packet_size >= ump->packet_size);
for (spar = 0; spar < pms->n_st; spar++) {
lb_num = pms->st_loc[spar];
DPRINTF(VOLUMES, ("Checking for sparing table %d\n", lb_num));
error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
if (!error && dscr) {
if (udf_rw16(dscr->tag.id) == TAGID_SPARING_TABLE) {
if (ump->sparing_table)
free(ump->sparing_table, M_UDFVOLD);
ump->sparing_table = &dscr->spt;
dscr = NULL;
DPRINTF(VOLUMES,
("Sparing table accepted (%d entries)\n",
udf_rw16(ump->sparing_table->rt_l)));
break;
}
}
if (dscr)
free(dscr, M_UDFVOLD);
}
if (ump->sparing_table)
return 0;
return ENOENT;
}
static int
udf_read_metadata_nodes(struct udf_mount *ump, union udf_pmap *mapping)
{
struct part_map_meta *pmm = &mapping->pmm;
struct long_ad icb_loc;
struct vnode *vp;
uint16_t raw_phys_part, phys_part;
int error;
ump->metadata_alloc_unit_size = udf_rw32(mapping->pmm.alloc_unit_size);
ump->metadata_alignment_unit_size = udf_rw16(mapping->pmm.alignment_unit_size);
ump->metadata_flags = mapping->pmm.flags;
DPRINTF(VOLUMES, ("Reading in Metadata files\n"));
raw_phys_part = udf_rw16(pmm->part_num);
phys_part = udf_find_raw_phys(ump, raw_phys_part);
icb_loc.loc.part_num = udf_rw16(phys_part);
DPRINTF(VOLUMES, ("Metadata file\n"));
icb_loc.loc.lb_num = pmm->meta_file_lbn;
error = udf_get_node(ump, &icb_loc, &ump->metadata_node,
LK_EXCLUSIVE);
if (ump->metadata_node) {
vp = ump->metadata_node->vnode;
UDF_SET_SYSTEMFILE(vp);
}
icb_loc.loc.lb_num = pmm->meta_mirror_file_lbn;
if (icb_loc.loc.lb_num != -1) {
DPRINTF(VOLUMES, ("Metadata copy file\n"));
error = udf_get_node(ump, &icb_loc, &ump->metadatamirror_node,
LK_EXCLUSIVE);
if (ump->metadatamirror_node) {
vp = ump->metadatamirror_node->vnode;
UDF_SET_SYSTEMFILE(vp);
}
}
icb_loc.loc.lb_num = pmm->meta_bitmap_file_lbn;
if (icb_loc.loc.lb_num != -1) {
DPRINTF(VOLUMES, ("Metadata bitmap file\n"));
error = udf_get_node(ump, &icb_loc, &ump->metadatabitmap_node,
LK_EXCLUSIVE);
if (ump->metadatabitmap_node) {
vp = ump->metadatabitmap_node->vnode;
UDF_SET_SYSTEMFILE(vp);
}
}
if (ump->vfs_mountp->mnt_flag & MNT_RDONLY) {
error = EFAULT;
if (ump->metadata_node)
error = 0;
if ((ump->metadata_node == NULL) && (ump->metadatamirror_node)) {
printf( "udf mount: Metadata file not readable, "
"substituting Metadata copy file\n");
ump->metadata_node = ump->metadatamirror_node;
ump->metadatamirror_node = NULL;
error = 0;
}
} else {
if (error)
error = EROFS;
}
DPRINTFIF(VOLUMES, error, ("udf mount: failed to read "
"metadata files\n"));
return error;
}
int
udf_read_vds_tables(struct udf_mount *ump)
{
union udf_pmap *mapping;
uint32_t n_pm;
uint32_t log_part;
uint8_t *pmap_pos;
int pmap_size;
int error;
n_pm = udf_rw32(ump->logical_vol->n_pm);
pmap_pos = ump->logical_vol->maps;
for (log_part = 0; log_part < n_pm; log_part++) {
mapping = (union udf_pmap *) pmap_pos;
switch (ump->vtop_tp[log_part]) {
case UDF_VTOP_TYPE_PHYS :
break;
case UDF_VTOP_TYPE_VIRT :
error = udf_search_vat(ump, mapping);
if (error)
return ENOENT;
break;
case UDF_VTOP_TYPE_SPARABLE :
error = udf_read_sparables(ump, mapping);
if (error)
return ENOENT;
break;
case UDF_VTOP_TYPE_META :
error = udf_read_metadata_nodes(ump, mapping);
if (error)
return ENOENT;
break;
default:
break;
}
pmap_size = pmap_pos[1];
pmap_pos += pmap_size;
}
if ((ump->vfs_mountp->mnt_flag & MNT_RDONLY) == 0) {
error = udf_read_physical_partition_spacetables(ump);
if (error)
return error;
error = udf_read_metadata_partition_spacetable(ump);
return error;
}
return 0;
}
int
udf_read_rootdirs(struct udf_mount *ump)
{
union dscrptr *dscr;
struct udf_node *rootdir_node, *streamdir_node;
struct long_ad fsd_loc, *dir_loc;
uint32_t lb_num, dummy;
uint32_t fsd_len;
int dscr_type;
int error;
fsd_loc = ump->logical_vol->lv_fsd_loc;
fsd_len = udf_rw32(fsd_loc.len);
dscr = NULL;
error = 0;
while (fsd_len || error) {
DPRINTF(VOLUMES, ("fsd_len = %d\n", fsd_len));
error = udf_translate_vtop(ump, &fsd_loc, &lb_num, &dummy);
if (error)
break;
DPRINTF(VOLUMES, ("Reading FSD at lb %d\n", lb_num));
error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
if (error || (dscr == NULL))
break;
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type == TAGID_TERM)
break;
if (dscr_type != TAGID_FSD) {
free(dscr, M_UDFVOLD);
return ENOENT;
}
if (ump->fileset_desc) {
free(ump->fileset_desc, M_UDFVOLD);
}
ump->fileset_desc = &dscr->fsd;
dscr = NULL;
fsd_len -= ump->discinfo.sector_size;
fsd_loc.loc.lb_num = udf_rw32(udf_rw32(fsd_loc.loc.lb_num)+1);
if (udf_rw32(ump->fileset_desc->next_ex.len)) {
DPRINTF(VOLUMES, ("follow up FSD extent\n"));
fsd_loc = ump->fileset_desc->next_ex;
fsd_len = udf_rw32(ump->fileset_desc->next_ex.len);
}
}
if (dscr)
free(dscr, M_UDFVOLD);
if (ump->fileset_desc == NULL)
return ENOENT;
DPRINTF(VOLUMES, ("FSD read in fine\n"));
DPRINTF(VOLUMES, ("Updating fsd logical volume id\n"));
udf_update_logvolname(ump, ump->logical_vol->logvol_id);
rootdir_node = streamdir_node = NULL;
dir_loc = NULL;
dir_loc = &ump->fileset_desc->rootdir_icb;
error = udf_get_node(ump, dir_loc, &rootdir_node, LK_EXCLUSIVE);
if (error)
return ENOENT;
dir_loc = &ump->fileset_desc->streamdir_icb;
if (udf_rw32(dir_loc->len)) {
printf("udf_read_rootdirs: streamdir defined ");
error = udf_get_node(ump, dir_loc, &streamdir_node,
LK_EXCLUSIVE);
if (error) {
printf("but error in streamdir reading\n");
} else {
printf("but ignored\n");
}
}
DPRINTF(VOLUMES, ("Rootdir(s) read in fine\n"));
if (streamdir_node) {
vput(streamdir_node->vnode);
}
if (rootdir_node) {
vput(rootdir_node->vnode);
}
return 0;
}
long
udf_get_node_id(const struct long_ad *icbptr)
{
return udf_rw32(icbptr->loc.lb_num) + 1;
}
int
udf_compare_icb(const struct long_ad *a, const struct long_ad *b)
{
if (udf_rw16(a->loc.part_num) < udf_rw16(b->loc.part_num))
return -1;
if (udf_rw16(a->loc.part_num) > udf_rw16(b->loc.part_num))
return 1;
if (udf_rw32(a->loc.lb_num) < udf_rw32(b->loc.lb_num))
return -1;
if (udf_rw32(a->loc.lb_num) > udf_rw32(b->loc.lb_num))
return 1;
return 0;
}
static int
udf_compare_rbnodes(void *ctx, const void *a, const void *b)
{
const struct udf_node *a_node = a;
const struct udf_node *b_node = b;
return udf_compare_icb(&a_node->loc, &b_node->loc);
}
static int
udf_compare_rbnode_icb(void *ctx, const void *a, const void *key)
{
const struct udf_node *a_node = a;
const struct long_ad * const icb = key;
return udf_compare_icb(&a_node->loc, icb);
}
static const rb_tree_ops_t udf_node_rbtree_ops = {
.rbto_compare_nodes = udf_compare_rbnodes,
.rbto_compare_key = udf_compare_rbnode_icb,
.rbto_node_offset = offsetof(struct udf_node, rbnode),
.rbto_context = NULL
};
void
udf_init_nodes_tree(struct udf_mount *ump)
{
rb_tree_init(&ump->udf_node_tree, &udf_node_rbtree_ops);
}
static int
udf_validate_session_start(struct udf_mount *ump)
{
struct mmc_trackinfo trackinfo;
struct vrs_desc *vrs;
uint32_t tracknr, sessionnr, sector, sector_size;
uint32_t iso9660_vrs, write_track_start;
uint8_t *buffer, *blank, *pos;
int blks, max_sectors, vrs_len;
int error;
if (ump->discinfo.disc_state == MMC_STATE_FULL)
return EROFS;
if (ump->discinfo.last_session_state == MMC_STATE_INCOMPLETE)
return 0;
tracknr = ump->discinfo.first_track_last_session;
memset(&trackinfo, 0, sizeof(struct mmc_trackinfo));
trackinfo.tracknr = tracknr;
error = udf_update_trackinfo(ump, &trackinfo);
if (error)
return error;
udf_dump_trackinfo(&trackinfo);
KASSERT(trackinfo.flags & (MMC_TRACKINFO_BLANK | MMC_TRACKINFO_RESERVED));
KASSERT(trackinfo.sessionnr > 1);
KASSERT(trackinfo.flags & MMC_TRACKINFO_NWA_VALID);
write_track_start = trackinfo.next_writable;
DPRINTF(VOLUMES, ("validate_session_start: "
"blank or reserved track, copying VRS\n"));
sessionnr = ump->mount_args.sessionnr;
tracknr = ump->discinfo.first_track;
while (tracknr <= ump->discinfo.num_tracks) {
trackinfo.tracknr = tracknr;
error = udf_update_trackinfo(ump, &trackinfo);
if (error) {
DPRINTF(VOLUMES, ("failed to get trackinfo; aborting\n"));
return error;
}
if (trackinfo.sessionnr == sessionnr)
break;
tracknr++;
}
if (trackinfo.sessionnr != sessionnr) {
DPRINTF(VOLUMES, ("failed to get trackinfo; aborting\n"));
return ENOENT;
}
DPRINTF(VOLUMES, ("found possible former ISO VRS at\n"));
udf_dump_trackinfo(&trackinfo);
sector_size = ump->discinfo.sector_size;
iso9660_vrs = ((32*1024 + sector_size - 1) / sector_size)
+ trackinfo.track_start;
buffer = malloc(UDF_ISO_VRS_SIZE, M_TEMP, M_WAITOK);
max_sectors = UDF_ISO_VRS_SIZE / sector_size;
blks = MAX(1, 2048 / sector_size);
error = 0;
for (sector = 0; sector < max_sectors; sector += blks) {
pos = buffer + sector * sector_size;
error = udf_read_phys_sectors(ump, UDF_C_DSCR, pos,
iso9660_vrs + sector, blks);
if (error)
break;
vrs = (struct vrs_desc *) pos;
DPRINTF(VOLUMES, ("got VRS id `%4s`\n", vrs->identifier));
if (strncmp(vrs->identifier, VRS_CD001, 5) == 0)
continue;
if (strncmp(vrs->identifier, VRS_CDW02, 5) == 0)
continue;
if (strncmp(vrs->identifier, VRS_BEA01, 5) == 0)
continue;
if (strncmp(vrs->identifier, VRS_NSR02, 5) == 0)
continue;
if (strncmp(vrs->identifier, VRS_NSR03, 5) == 0)
continue;
if (strncmp(vrs->identifier, VRS_TEA01, 5) == 0)
break;
break;
}
vrs_len = sector + blks;
if (error) {
DPRINTF(VOLUMES, ("error reading old ISO VRS\n"));
DPRINTF(VOLUMES, ("creating minimal ISO VRS\n"));
memset(buffer, 0, UDF_ISO_VRS_SIZE);
vrs = (struct vrs_desc *) (buffer);
vrs->struct_type = 0;
vrs->version = 1;
memcpy(vrs->identifier,VRS_BEA01, 5);
vrs = (struct vrs_desc *) (buffer + 2048);
vrs->struct_type = 0;
vrs->version = 1;
if (udf_rw16(ump->logical_vol->tag.descriptor_ver) == 2) {
memcpy(vrs->identifier,VRS_NSR02, 5);
} else {
memcpy(vrs->identifier,VRS_NSR03, 5);
}
vrs = (struct vrs_desc *) (buffer + 4096);
vrs->struct_type = 0;
vrs->version = 1;
memcpy(vrs->identifier, VRS_TEA01, 5);
vrs_len = 3*blks;
}
DPRINTF(VOLUMES, ("Got VRS of %d sectors long\n", vrs_len));
sector_size = ump->discinfo.sector_size;
iso9660_vrs = ((32*1024 + sector_size - 1) / sector_size)
+ write_track_start;
blank = malloc(sector_size, M_TEMP, M_WAITOK);
memset(blank, 0, sector_size);
error = 0;
for (sector = write_track_start; sector < iso9660_vrs; sector ++) {
error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
blank, sector, 1);
if (error)
break;
}
if (!error) {
KASSERT(sector == iso9660_vrs);
error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE, buffer,
sector, vrs_len);
sector += vrs_len;
}
if (!error) {
for (; sector < write_track_start+256; sector++) {
error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
blank, sector, 1);
if (error)
break;
}
}
if (!error) {
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_ABSOLUTE,
(union dscrptr *) ump->anchors[0], sector, sector);
if (error)
printf("writeout of anchor failed!\n");
}
free(blank, M_TEMP);
free(buffer, M_TEMP);
if (error)
printf("udf_open_session: error writing iso vrs! : "
"leaving disc in compromised state!\n");
(void) udf_synchronise_caches(ump);
return error;
}
int
udf_open_logvol(struct udf_mount *ump)
{
int logvol_integrity;
int error;
logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
if (logvol_integrity == UDF_INTEGRITY_OPEN)
return 0;
if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
return EROFS;
DPRINTF(VOLUMES, ("Setting up write parameters\n"));
if ((error = udf_setup_writeparams(ump)) != 0)
return error;
error = udf_search_writing_tracks(ump);
if (error) {
printf("udf_open_logvol: error searching writing tracks\n");
return EROFS;
}
DPRINTF(VOLUMES, ("Opening logical volume\n"));
if (ump->lvopen & UDF_OPEN_SESSION) {
error = udf_validate_session_start(ump);
if (error)
return error;
error = udf_search_writing_tracks(ump);
if (ump->lvclose & UDF_WRITE_VAT) {
DPRINTF(VOLUMES, ("lvclose & UDF_WRITE_VAT\n"));
DPRINTF(VOLUMES, ("writeout vat_node\n"));
udf_writeout_vat(ump);
(void) udf_synchronise_caches(ump);
}
}
ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_OPEN);
if (ump->lvopen & UDF_WRITE_LVINT) {
error = udf_writeout_lvint(ump, ump->lvopen);
if (error) {
ump->logvol_integrity->integrity_type =
udf_rw32(UDF_INTEGRITY_CLOSED);
return error;
}
}
return 0;
}
int
udf_close_logvol(struct udf_mount *ump, int mntflags)
{
struct vnode *devvp = ump->devvp;
struct mmc_op mmc_op;
uint32_t phys;
int logvol_integrity;
int error = 0, error1 = 0, error2 = 0;
int tracknr;
int nvats, n, relblk, wrtrack_skew, nok;
logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
if (logvol_integrity == UDF_INTEGRITY_CLOSED)
return 0;
DPRINTF(VOLUMES, ("udf_close_logvol: closing logical volume\n"));
#ifdef DIAGNOSTIC
if (ump->lvclose & UDF_CLOSE_SESSION)
KASSERT(ump->lvclose & UDF_WRITE_VAT);
#endif
if (ump->lvclose & UDF_WRITE_VAT) {
DPRINTF(VOLUMES, ("lvclose & UDF_WRITE_VAT\n"));
DPRINTF(VOLUMES, ("writeout vat_node\n"));
udf_writeout_vat(ump);
phys = ump->data_track.track_start;
wrtrack_skew = phys % 32;
phys = ump->data_track.next_writable;
relblk = phys % 32;
nvats = 32 + 32 - (relblk - wrtrack_skew);
#if notyet
if (ump->lvclose & UDF_FINALISE_DISC) {
error = udf_write_phys_dscr_sync(ump, NULL,
UDF_C_FLOAT_DSCR,
(union dscrptr *) ump->anchors[0],
0, 0);
if (error)
printf("writeout of anchor failed!\n");
nvats = 256;
}
#endif
nok = 0;
for (n = 0; n < nvats; n++) {
ump->vat_node->i_flags |= IN_MODIFIED;
error = VOP_FSYNC(ump->vat_node->vnode,
FSCRED, FSYNC_WAIT, 0, 0);
if (!error)
nok++;
}
(void) udf_synchronise_caches(ump);
if (nok < 14) {
printf("writeout of at least 14 VATs failed\n");
return error;
}
}
if (ump->lvclose & UDF_CLOSE_SESSION) {
DPRINTF(VOLUMES, ("udf_close_logvol: closing session "
"as requested\n"));
error = udf_validate_session_start(ump);
if (error)
return error;
(void) udf_synchronise_caches(ump);
tracknr = ump->discinfo.first_track_last_session;
error = 0;
while (tracknr <= ump->discinfo.last_track_last_session) {
DPRINTF(VOLUMES, ("\tclosing possible open "
"track %d\n", tracknr));
memset(&mmc_op, 0, sizeof(mmc_op));
mmc_op.operation = MMC_OP_CLOSETRACK;
mmc_op.mmc_profile = ump->discinfo.mmc_profile;
mmc_op.tracknr = tracknr;
error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
FKIOCTL, NOCRED);
if (error)
printf("udf_close_logvol: closing of "
"track %d failed\n", tracknr);
tracknr ++;
}
if (!error) {
DPRINTF(VOLUMES, ("closing session\n"));
memset(&mmc_op, 0, sizeof(mmc_op));
mmc_op.operation = MMC_OP_CLOSESESSION;
mmc_op.mmc_profile = ump->discinfo.mmc_profile;
mmc_op.sessionnr = ump->discinfo.num_sessions;
error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
FKIOCTL, NOCRED);
if (error)
printf("udf_close_logvol: closing of session"
"failed\n");
}
if (!error)
ump->lvopen |= UDF_OPEN_SESSION;
if (error) {
printf("udf_close_logvol: leaving disc as it is\n");
ump->lvclose &= ~UDF_FINALISE_DISC;
}
}
if (ump->lvclose & UDF_FINALISE_DISC) {
memset(&mmc_op, 0, sizeof(mmc_op));
mmc_op.operation = MMC_OP_FINALISEDISC;
mmc_op.mmc_profile = ump->discinfo.mmc_profile;
mmc_op.sessionnr = ump->discinfo.num_sessions;
error = VOP_IOCTL(devvp, MMCOP, &mmc_op,
FKIOCTL, NOCRED);
if (error)
printf("udf_close_logvol: finalising disc"
"failed\n");
}
if (ump->lvclose & UDF_WRITE_PART_BITMAPS) {
error1 = udf_write_metadata_partition_spacetable(ump, true);
if (error1)
printf( "udf_close_logvol: writeout of metadata space "
"bitmap failed\n");
error2 = udf_write_physical_partition_spacetables(ump, true);
if (error2)
printf( "udf_close_logvol: writeout of space tables "
"failed\n");
if (error1 || error2)
return (error1 | error2);
ump->lvclose &= ~UDF_WRITE_PART_BITMAPS;
}
if (ump->lvclose & UDF_WRITE_METAPART_NODES) {
error1 = udf_writeout_node(ump->metadata_node, FSYNC_WAIT);
if (error1)
printf( "udf_close_logvol: writeout of metadata partition "
"node failed\n");
udf_synchronise_metadatamirror_node(ump);
error2 = udf_writeout_node(ump->metadatamirror_node, FSYNC_WAIT);
if (error2)
printf( "udf_close_logvol: writeout of metadata partition "
"mirror node failed\n");
if (error1 || error2)
return (error1 | error2);
ump->lvclose &= ~UDF_WRITE_METAPART_NODES;
}
ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_CLOSED);
if (ump->lvclose & UDF_WRITE_LVINT)
error = udf_writeout_lvint(ump, ump->lvopen);
if (error) {
ump->logvol_integrity->integrity_type =
udf_rw32(UDF_INTEGRITY_OPEN);
return error;
}
(void) udf_synchronise_caches(ump);
return 0;
}
static int
udf_gop_alloc(struct vnode *vp, off_t off,
off_t len, int flags, kauth_cred_t cred)
{
struct udf_node *udf_node = VTOI(vp);
struct udf_mount *ump = udf_node->ump;
uint64_t lb_start, lb_end;
uint32_t lb_size, num_lb;
int udf_c_type, vpart_num, can_fail;
int error;
DPRINTF(ALLOC, ("udf_gop_alloc called for offset %"PRIu64" for %"PRIu64" bytes, %s\n",
off, len, flags? "SYNC":"NONE"));
lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
lb_start = off / lb_size;
lb_end = (off + len + lb_size -1) / lb_size;
num_lb = lb_end - lb_start;
udf_c_type = udf_get_c_type(udf_node);
vpart_num = udf_get_record_vpart(ump, udf_c_type);
can_fail = true;
if (udf_c_type == UDF_C_FIDS)
can_fail = false;
if (vp->v_vflag & VV_SYSTEM)
can_fail = false;
error = udf_reserve_space(ump, udf_node, udf_c_type,
vpart_num, num_lb, can_fail);
DPRINTF(ALLOC, ("\tlb_start %"PRIu64", lb_end %"PRIu64", num_lb %d\n",
lb_start, lb_end, num_lb));
return error;
}
static void
udf_gop_markupdate(struct vnode *vp, int flags)
{
struct udf_node *udf_node = VTOI(vp);
u_long mask = 0;
if ((flags & GOP_UPDATE_ACCESSED) != 0) {
mask = IN_ACCESS;
}
if ((flags & GOP_UPDATE_MODIFIED) != 0) {
if (vp->v_type == VREG) {
mask |= IN_CHANGE | IN_UPDATE;
} else {
mask |= IN_MODIFY;
}
}
if (mask) {
udf_node->i_flags |= mask;
}
}
static const struct genfs_ops udf_genfsops = {
.gop_size = genfs_size,
.gop_alloc = udf_gop_alloc,
.gop_write = genfs_gop_write_rwmap,
.gop_markupdate = udf_gop_markupdate,
.gop_putrange = genfs_gop_putrange,
};
int
udf_write_terminator(struct udf_mount *ump, uint32_t sector)
{
union dscrptr *dscr;
int error;
dscr = malloc(ump->discinfo.sector_size, M_TEMP, M_WAITOK|M_ZERO);
udf_inittag(ump, &dscr->tag, TAGID_TERM, sector);
dscr->tag.desc_crc_len = udf_rw16(512-UDF_DESC_TAG_LENGTH);
(void) udf_validate_tag_and_crc_sums(dscr);
error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
dscr, sector, sector);
free(dscr, M_TEMP);
return error;
}
static mode_t
udf_perm_to_unix_mode(uint32_t perm)
{
mode_t mode;
mode = ((perm & UDF_FENTRY_PERM_USER_MASK) );
mode |= ((perm & UDF_FENTRY_PERM_GRP_MASK ) >> 2);
mode |= ((perm & UDF_FENTRY_PERM_OWNER_MASK) >> 4);
return mode;
}
static uint32_t
unix_mode_to_udf_perm(mode_t mode)
{
uint32_t perm;
perm = ((mode & S_IRWXO) );
perm |= ((mode & S_IRWXG) << 2);
perm |= ((mode & S_IRWXU) << 4);
perm |= ((mode & S_IWOTH) << 3);
perm |= ((mode & S_IWGRP) << 5);
perm |= ((mode & S_IWUSR) << 7);
return perm;
}
static uint32_t
udf_icb_to_unix_filetype(uint32_t icbftype)
{
switch (icbftype) {
case UDF_ICB_FILETYPE_DIRECTORY :
case UDF_ICB_FILETYPE_STREAMDIR :
return S_IFDIR;
case UDF_ICB_FILETYPE_FIFO :
return S_IFIFO;
case UDF_ICB_FILETYPE_CHARDEVICE :
return S_IFCHR;
case UDF_ICB_FILETYPE_BLOCKDEVICE :
return S_IFBLK;
case UDF_ICB_FILETYPE_RANDOMACCESS :
case UDF_ICB_FILETYPE_REALTIME :
return S_IFREG;
case UDF_ICB_FILETYPE_SYMLINK :
return S_IFLNK;
case UDF_ICB_FILETYPE_SOCKET :
return S_IFSOCK;
}
return 0;
}
void
udf_to_unix_name(char *result, int result_len, char *id, int len,
struct charspec *chsp)
{
uint16_t *raw_name, *unix_name;
uint16_t *inchp, ch;
uint8_t *outchp;
const char *osta_id = "OSTA Compressed Unicode";
int ucode_chars, nice_uchars, is_osta_typ0, nout;
raw_name = malloc(2048 * sizeof(uint16_t), M_UDFTEMP, M_WAITOK);
unix_name = raw_name + 1024;
assert(sizeof(char) == sizeof(uint8_t));
outchp = (uint8_t *) result;
is_osta_typ0 = (chsp->type == 0);
is_osta_typ0 &= (strcmp((char *) chsp->inf, osta_id) == 0);
if (is_osta_typ0) {
*raw_name = *unix_name = 0;
ucode_chars = udf_UncompressUnicode(len, (uint8_t *) id, raw_name);
ucode_chars = MIN(ucode_chars, UnicodeLength((unicode_t *) raw_name));
nice_uchars = UDFTransName(unix_name, raw_name, ucode_chars);
for (inchp = unix_name; nice_uchars>0; inchp++, nice_uchars--) {
ch = *inchp;
nout = wput_utf8(outchp, result_len, ch);
outchp += nout; result_len -= nout;
if (!ch) break;
}
*outchp++ = 0;
} else {
assert(*id == 8);
assert(strlen((char *) (id+1)) <= NAME_MAX);
strncpy((char *) result, (char *) (id+1), strlen((char *) (id+1)));
}
free(raw_name, M_UDFTEMP);
}
void
unix_to_udf_name(char *result, uint8_t *result_len, char const *name, int name_len,
struct charspec *chsp)
{
uint16_t *raw_name;
uint16_t *outchp;
const char *inchp;
const char *osta_id = "OSTA Compressed Unicode";
int udf_chars, is_osta_typ0, bits;
size_t cnt;
raw_name = malloc(1024, M_UDFTEMP, M_WAITOK);
*raw_name = 0;
inchp = name;
outchp = raw_name;
bits = 8;
for (cnt = name_len, udf_chars = 0; cnt;) {
*outchp = wget_utf8(&inchp, &cnt);
if (*outchp > 0xff)
bits=16;
outchp++;
udf_chars++;
}
*outchp++ = 0;
is_osta_typ0 = (chsp->type == 0);
is_osta_typ0 &= (strcmp((char *) chsp->inf, osta_id) == 0);
if (is_osta_typ0) {
udf_chars = udf_CompressUnicode(udf_chars, bits,
(unicode_t *) raw_name,
(byte *) result);
} else {
printf("unix to udf name: no CHSP0 ?\n");
*result++ = 8; udf_chars = 1;
strncpy(result, name + 1, name_len);
udf_chars += name_len;
}
*result_len = udf_chars;
free(raw_name, M_UDFTEMP);
}
void
udf_timestamp_to_timespec(struct udf_mount *ump,
struct timestamp *timestamp,
struct timespec *timespec)
{
struct clock_ymdhms ymdhms;
uint32_t usecs, secs, nsecs;
uint16_t tz;
memset(&ymdhms, 0, sizeof(ymdhms));
ymdhms.dt_year = udf_rw16(timestamp->year);
ymdhms.dt_mon = timestamp->month;
ymdhms.dt_day = timestamp->day;
ymdhms.dt_wday = 0;
ymdhms.dt_hour = timestamp->hour;
ymdhms.dt_min = timestamp->minute;
ymdhms.dt_sec = timestamp->second;
secs = clock_ymdhms_to_secs(&ymdhms);
usecs = timestamp->usec +
100*timestamp->hund_usec + 10000*timestamp->centisec;
nsecs = usecs * 1000;
tz = udf_rw16(timestamp->type_tz);
tz &= 0x0fff;
if (tz & 0x0800)
tz |= 0xf000;
if (udf_rw16(timestamp->type_tz) & 0x1000) {
if ((int16_t) tz != -2047)
secs -= (int16_t) tz * 60;
} else {
secs -= ump->mount_args.gmtoff;
}
timespec->tv_sec = secs;
timespec->tv_nsec = nsecs;
}
void
udf_timespec_to_timestamp(struct timespec *timespec, struct timestamp *timestamp)
{
struct clock_ymdhms ymdhms;
uint32_t husec, usec, csec;
(void) clock_secs_to_ymdhms(timespec->tv_sec, &ymdhms);
usec = timespec->tv_nsec / 1000;
husec = usec / 100;
usec -= husec * 100;
csec = husec / 100;
husec -= csec * 100;
timestamp->type_tz = udf_rw16((1<<12) + 0);
timestamp->year = udf_rw16(ymdhms.dt_year);
timestamp->month = ymdhms.dt_mon;
timestamp->day = ymdhms.dt_day;
timestamp->hour = ymdhms.dt_hour;
timestamp->minute = ymdhms.dt_min;
timestamp->second = ymdhms.dt_sec;
timestamp->centisec = csec;
timestamp->hund_usec = husec;
timestamp->usec = usec;
}
uint32_t
udf_getaccessmode(struct udf_node *udf_node)
{
struct file_entry *fe = udf_node->fe;
struct extfile_entry *efe = udf_node->efe;
uint32_t udf_perm, icbftype;
uint32_t mode, ftype;
uint16_t icbflags;
UDF_LOCK_NODE(udf_node, 0);
if (fe) {
udf_perm = udf_rw32(fe->perm);
icbftype = fe->icbtag.file_type;
icbflags = udf_rw16(fe->icbtag.flags);
} else {
assert(udf_node->efe);
udf_perm = udf_rw32(efe->perm);
icbftype = efe->icbtag.file_type;
icbflags = udf_rw16(efe->icbtag.flags);
}
mode = udf_perm_to_unix_mode(udf_perm);
ftype = udf_icb_to_unix_filetype(icbftype);
if (icbflags & UDF_ICB_TAG_FLAGS_SETUID)
mode |= S_ISUID;
if (icbflags & UDF_ICB_TAG_FLAGS_SETGID)
mode |= S_ISGID;
if (icbflags & UDF_ICB_TAG_FLAGS_STICKY)
mode |= S_ISVTX;
UDF_UNLOCK_NODE(udf_node, 0);
return mode | ftype;
}
void
udf_setaccessmode(struct udf_node *udf_node, mode_t mode)
{
struct file_entry *fe = udf_node->fe;
struct extfile_entry *efe = udf_node->efe;
uint32_t udf_perm;
uint16_t icbflags;
UDF_LOCK_NODE(udf_node, 0);
udf_perm = unix_mode_to_udf_perm(mode & ALLPERMS);
if (fe) {
icbflags = udf_rw16(fe->icbtag.flags);
} else {
icbflags = udf_rw16(efe->icbtag.flags);
}
icbflags &= ~UDF_ICB_TAG_FLAGS_SETUID;
icbflags &= ~UDF_ICB_TAG_FLAGS_SETGID;
icbflags &= ~UDF_ICB_TAG_FLAGS_STICKY;
if (mode & S_ISUID)
icbflags |= UDF_ICB_TAG_FLAGS_SETUID;
if (mode & S_ISGID)
icbflags |= UDF_ICB_TAG_FLAGS_SETGID;
if (mode & S_ISVTX)
icbflags |= UDF_ICB_TAG_FLAGS_STICKY;
if (fe) {
fe->perm = udf_rw32(udf_perm);
fe->icbtag.flags = udf_rw16(icbflags);
} else {
efe->perm = udf_rw32(udf_perm);
efe->icbtag.flags = udf_rw16(icbflags);
}
UDF_UNLOCK_NODE(udf_node, 0);
}
void
udf_getownership(struct udf_node *udf_node, uid_t *uidp, gid_t *gidp)
{
struct udf_mount *ump = udf_node->ump;
struct file_entry *fe = udf_node->fe;
struct extfile_entry *efe = udf_node->efe;
uid_t uid;
gid_t gid;
UDF_LOCK_NODE(udf_node, 0);
if (fe) {
uid = (uid_t)udf_rw32(fe->uid);
gid = (gid_t)udf_rw32(fe->gid);
} else {
assert(udf_node->efe);
uid = (uid_t)udf_rw32(efe->uid);
gid = (gid_t)udf_rw32(efe->gid);
}
if (uid == (uid_t) -1)
uid = ump->mount_args.anon_uid;
if (gid == (gid_t) -1)
gid = ump->mount_args.anon_gid;
*uidp = uid;
*gidp = gid;
UDF_UNLOCK_NODE(udf_node, 0);
}
void
udf_setownership(struct udf_node *udf_node, uid_t uid, gid_t gid)
{
struct udf_mount *ump = udf_node->ump;
struct file_entry *fe = udf_node->fe;
struct extfile_entry *efe = udf_node->efe;
uid_t nobody_uid;
gid_t nobody_gid;
UDF_LOCK_NODE(udf_node, 0);
nobody_uid = ump->mount_args.nobody_uid;
nobody_gid = ump->mount_args.nobody_gid;
if (uid == nobody_uid)
uid = (uid_t) -1;
if (gid == nobody_gid)
gid = (gid_t) -1;
if (fe) {
fe->uid = udf_rw32((uint32_t) uid);
fe->gid = udf_rw32((uint32_t) gid);
} else {
efe->uid = udf_rw32((uint32_t) uid);
efe->gid = udf_rw32((uint32_t) gid);
}
UDF_UNLOCK_NODE(udf_node, 0);
}
int
udf_dirhash_fill(struct udf_node *dir_node)
{
struct vnode *dvp = dir_node->vnode;
struct dirhash *dirh;
struct file_entry *fe = dir_node->fe;
struct extfile_entry *efe = dir_node->efe;
struct fileid_desc *fid;
struct dirent *dirent;
uint64_t file_size, pre_diroffset, diroffset;
uint32_t lb_size;
int error;
dirh = dir_node->dir_hash;
KASSERT(dirh);
KASSERT(dirh->refcnt > 0);
if (dirh->flags & DIRH_BROKEN)
return EIO;
if (dirh->flags & DIRH_COMPLETE)
return 0;
dirhash_purge_entries(dirh);
if (fe) {
file_size = udf_rw64(fe->inf_len);
} else {
assert(efe);
file_size = udf_rw64(efe->inf_len);
}
lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
error = 0;
diroffset = 0;
while (diroffset < file_size) {
pre_diroffset = diroffset;
error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
if (error) {
dirh->flags |= DIRH_BROKEN;
dirhash_purge_entries(dirh);
break;
}
if ((fid->file_char & UDF_FILE_CHAR_DEL)) {
dirhash_enter_freed(dirh, pre_diroffset,
udf_fidsize(fid));
} else {
dirhash_enter(dirh, dirent, pre_diroffset,
udf_fidsize(fid), 0);
}
}
dirh->flags |= DIRH_COMPLETE;
free(fid, M_UDFTEMP);
free(dirent, M_UDFTEMP);
return error;
}
int
udf_lookup_name_in_dir(struct vnode *vp, const char *name, int namelen,
struct long_ad *icb_loc, int *found)
{
struct udf_node *dir_node = VTOI(vp);
struct dirhash *dirh;
struct dirhash_entry *dirh_ep;
struct fileid_desc *fid;
struct dirent *dirent, *s_dirent;
struct charspec osta_charspec;
uint64_t diroffset;
uint32_t lb_size;
int hit, error;
*found = 0;
dirhash_get(&dir_node->dir_hash);
error = udf_dirhash_fill(dir_node);
if (error) {
dirhash_put(dir_node->dir_hash);
return error;
}
dirh = dir_node->dir_hash;
lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
s_dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
DPRINTF(DIRHASH, ("dirhash_lookup looking for `%*.*s`\n",
namelen, namelen, name));
udf_osta_charset(&osta_charspec);
unix_to_udf_name((char *) fid->data, &fid->l_fi,
name, namelen, &osta_charspec);
udf_to_unix_name(s_dirent->d_name, NAME_MAX,
(char *) fid->data, fid->l_fi,
&osta_charspec);
s_dirent->d_namlen = strlen(s_dirent->d_name);
memset(icb_loc, 0, sizeof(*icb_loc));
dirh_ep = NULL;
for (;;) {
hit = dirhash_lookup(dirh, s_dirent->d_name, s_dirent->d_namlen, &dirh_ep);
if (!hit)
break;
diroffset = dirh_ep->offset;
error = udf_read_fid_stream(vp, &diroffset, fid, dirent);
if (error)
break;
DPRINTF(DIRHASH, ("dirhash_lookup\tchecking `%*.*s`\n",
dirent->d_namlen, dirent->d_namlen, dirent->d_name));
if (strncmp(dirent->d_name, s_dirent->d_name, s_dirent->d_namlen) == 0) {
*found = 1;
*icb_loc = fid->icb;
break;
}
}
free(fid, M_UDFTEMP);
free(dirent, M_UDFTEMP);
free(s_dirent, M_UDFTEMP);
dirhash_put(dir_node->dir_hash);
return error;
}
static int
udf_create_new_fe(struct udf_mount *ump, struct file_entry *fe, int file_type,
struct long_ad *node_icb, struct long_ad *parent_icb,
uint64_t parent_unique_id)
{
struct timespec now;
struct icb_tag *icb;
struct filetimes_extattr_entry *ft_extattr;
uint64_t unique_id;
uint32_t fidsize, lb_num;
uint8_t *bpos;
int crclen, attrlen;
lb_num = udf_rw32(node_icb->loc.lb_num);
udf_inittag(ump, &fe->tag, TAGID_FENTRY, lb_num);
icb = &fe->icbtag;
icb->strat_type = udf_rw16(4);
icb->max_num_entries = udf_rw16(1);
icb->file_type = file_type;
icb->flags = udf_rw16(UDF_ICB_INTERN_ALLOC);
fe->perm = udf_rw32(0x7fff);
fe->link_cnt = udf_rw16(0);
fe->ckpoint = udf_rw32(1);
vfs_timestamp(&now);
udf_timespec_to_timestamp(&now, &fe->atime);
udf_timespec_to_timestamp(&now, &fe->attrtime);
udf_timespec_to_timestamp(&now, &fe->mtime);
udf_set_regid(&fe->imp_id, IMPL_NAME);
udf_add_impl_regid(ump, &fe->imp_id);
unique_id = udf_advance_uniqueid(ump);
fe->unique_id = udf_rw64(unique_id);
fe->l_ea = udf_rw32(0);
attrlen = UDF_FILETIMES_ATTR_SIZE(1);
ft_extattr = malloc(attrlen, M_UDFTEMP, M_WAITOK);
memset(ft_extattr, 0, attrlen);
ft_extattr->hdr.type = udf_rw32(UDF_FILETIMES_ATTR_NO);
ft_extattr->hdr.subtype = 1;
ft_extattr->hdr.a_l = udf_rw32(UDF_FILETIMES_ATTR_SIZE(1));
ft_extattr->d_l = udf_rw32(UDF_TIMESTAMP_SIZE);
ft_extattr->existence = UDF_FILETIMES_FILE_CREATION;
udf_timespec_to_timestamp(&now, &ft_extattr->times[0]);
udf_extattr_insert_internal(ump, (union dscrptr *) fe,
(struct extattr_entry *) ft_extattr);
free(ft_extattr, M_UDFTEMP);
bpos = (uint8_t *) fe->data + udf_rw32(fe->l_ea);
fidsize = 0;
if (file_type == UDF_ICB_FILETYPE_DIRECTORY) {
fidsize = udf_create_parentfid(ump,
(struct fileid_desc *) bpos, parent_icb,
parent_unique_id);
}
fe->inf_len = udf_rw64(fidsize);
fe->l_ad = udf_rw32(fidsize);
fe->logblks_rec = udf_rw64(0);
crclen = sizeof(struct file_entry) - 1 - UDF_DESC_TAG_LENGTH;
crclen += udf_rw32(fe->l_ea) + fidsize;
fe->tag.desc_crc_len = udf_rw16(crclen);
(void) udf_validate_tag_and_crc_sums((union dscrptr *) fe);
return fidsize;
}
static int
udf_create_new_efe(struct udf_mount *ump, struct extfile_entry *efe,
int file_type, struct long_ad *node_icb, struct long_ad *parent_icb,
uint64_t parent_unique_id)
{
struct timespec now;
struct icb_tag *icb;
uint64_t unique_id;
uint32_t fidsize, lb_num;
uint8_t *bpos;
int crclen;
lb_num = udf_rw32(node_icb->loc.lb_num);
udf_inittag(ump, &efe->tag, TAGID_EXTFENTRY, lb_num);
icb = &efe->icbtag;
icb->strat_type = udf_rw16(4);
icb->max_num_entries = udf_rw16(1);
icb->file_type = file_type;
icb->flags = udf_rw16(UDF_ICB_INTERN_ALLOC);
efe->perm = udf_rw32(0x7fff);
efe->link_cnt = udf_rw16(0);
efe->ckpoint = udf_rw32(1);
vfs_timestamp(&now);
udf_timespec_to_timestamp(&now, &efe->ctime);
udf_timespec_to_timestamp(&now, &efe->atime);
udf_timespec_to_timestamp(&now, &efe->attrtime);
udf_timespec_to_timestamp(&now, &efe->mtime);
udf_set_regid(&efe->imp_id, IMPL_NAME);
udf_add_impl_regid(ump, &efe->imp_id);
unique_id = udf_advance_uniqueid(ump);
efe->unique_id = udf_rw64(unique_id);
efe->l_ea = udf_rw32(0);
bpos = (uint8_t *) efe->data + udf_rw32(efe->l_ea);
fidsize = 0;
if (file_type == UDF_ICB_FILETYPE_DIRECTORY) {
fidsize = udf_create_parentfid(ump,
(struct fileid_desc *) bpos, parent_icb,
parent_unique_id);
}
efe->obj_size = udf_rw64(fidsize);
efe->inf_len = udf_rw64(fidsize);
efe->l_ad = udf_rw32(fidsize);
efe->logblks_rec = udf_rw64(0);
crclen = sizeof(struct extfile_entry) - 1 - UDF_DESC_TAG_LENGTH;
crclen += udf_rw32(efe->l_ea) + fidsize;
efe->tag.desc_crc_len = udf_rw16(crclen);
(void) udf_validate_tag_and_crc_sums((union dscrptr *) efe);
return fidsize;
}
int
udf_dir_detach(struct udf_mount *ump, struct udf_node *dir_node,
struct udf_node *udf_node, struct componentname *cnp)
{
struct vnode *dvp = dir_node->vnode;
struct dirhash *dirh;
struct dirhash_entry *dirh_ep;
struct file_entry *fe = dir_node->fe;
struct fileid_desc *fid;
struct dirent *dirent, *s_dirent;
struct charspec osta_charspec;
uint64_t diroffset;
uint32_t lb_size, fidsize;
int found, error;
int hit, refcnt;
dirhash_get(&dir_node->dir_hash);
error = udf_dirhash_fill(dir_node);
if (error) {
dirhash_put(dir_node->dir_hash);
return error;
}
dirh = dir_node->dir_hash;
if (!fe) {
assert(dir_node->efe);
}
lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
s_dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
udf_osta_charset(&osta_charspec);
unix_to_udf_name((char *) fid->data, &fid->l_fi,
cnp->cn_nameptr, cnp->cn_namelen, &osta_charspec);
udf_to_unix_name(s_dirent->d_name, NAME_MAX,
(char *) fid->data, fid->l_fi,
&osta_charspec);
s_dirent->d_namlen = strlen(s_dirent->d_name);
found = 0;
dirh_ep = NULL;
for (;;) {
hit = dirhash_lookup(dirh, s_dirent->d_name, s_dirent->d_namlen, &dirh_ep);
if (!hit)
break;
diroffset = dirh_ep->offset;
error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
if (error)
break;
KASSERT(dirent->d_namlen == s_dirent->d_namlen);
if (strncmp(dirent->d_name, s_dirent->d_name, s_dirent->d_namlen) == 0) {
found = 1;
break;
}
}
if (!found)
error = ENOENT;
if (error)
goto error_out;
fid->file_char |= UDF_FILE_CHAR_DEL;
#ifdef UDF_COMPLETE_DELETE
memset(&fid->icb, 0, sizeof(fid->icb));
#endif
(void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
fidsize = udf_fidsize(fid);
diroffset -= fidsize;
error = vn_rdwr(UIO_WRITE, dir_node->vnode,
fid, fidsize, diroffset,
UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED,
FSCRED, NULL, NULL);
if (error)
goto error_out;
if (udf_node->fe) {
refcnt = udf_rw16(udf_node->fe->link_cnt);
} else {
KASSERT(udf_node->efe);
refcnt = udf_rw16(udf_node->efe->link_cnt);
}
#ifdef UDF_COMPLETE_DELETE
refcnt -= 1;
if (udf_node->fe) {
udf_node->fe->link_cnt = udf_rw16(refcnt);
} else {
udf_node->efe->link_cnt = udf_rw16(refcnt);
}
if (refcnt == 0)
udf_node->i_flags |= IN_DELETED;
if (fid->file_char & UDF_FILE_CHAR_DIR) {
int drefcnt;
if (dir_node->fe) {
drefcnt = udf_rw16(dir_node->fe->link_cnt);
drefcnt -= 1;
dir_node->fe->link_cnt = udf_rw16(drefcnt);
} else {
KASSERT(dir_node->efe);
drefcnt = udf_rw16(dir_node->efe->link_cnt);
drefcnt -= 1;
dir_node->efe->link_cnt = udf_rw16(drefcnt);
}
}
udf_node->i_flags |= IN_MODIFIED;
dir_node->i_flags |= IN_MODIFIED;
#endif
if (refcnt > 0)
udf_adjust_filecount(udf_node, -1);
dirhash_remove(dirh, dirent, diroffset,
udf_fidsize(fid));
error_out:
free(fid, M_UDFTEMP);
free(dirent, M_UDFTEMP);
free(s_dirent, M_UDFTEMP);
dirhash_put(dir_node->dir_hash);
return error;
}
int
udf_dir_update_rootentry(struct udf_mount *ump, struct udf_node *dir_node,
struct udf_node *new_parent_node)
{
struct vnode *dvp = dir_node->vnode;
struct dirhash *dirh;
struct dirhash_entry *dirh_ep;
struct file_entry *fe;
struct extfile_entry *efe;
struct fileid_desc *fid;
struct dirent *dirent;
uint64_t diroffset;
uint64_t new_parent_unique_id;
uint32_t lb_size, fidsize;
int found, error;
char const *name = "..";
int namelen = 2;
int hit;
dirhash_get(&dir_node->dir_hash);
error = udf_dirhash_fill(dir_node);
if (error) {
dirhash_put(dir_node->dir_hash);
return error;
}
dirh = dir_node->dir_hash;
fe = new_parent_node->fe;
efe = new_parent_node->efe;
if (fe) {
new_parent_unique_id = udf_rw64(fe->unique_id);
} else {
assert(efe);
new_parent_unique_id = udf_rw64(efe->unique_id);
}
fe = dir_node->fe;
efe = dir_node->efe;
if (!fe) {
assert(efe);
}
lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK);
found = 0;
dirh_ep = NULL;
for (;;) {
hit = dirhash_lookup(dirh, name, namelen, &dirh_ep);
if (!hit)
break;
diroffset = dirh_ep->offset;
error = udf_read_fid_stream(dvp, &diroffset, fid, dirent);
if (error)
break;
KASSERT(dirent->d_namlen == namelen);
if (strncmp(dirent->d_name, name, namelen) == 0) {
found = 1;
break;
}
}
if (!found)
error = ENOENT;
if (error)
goto error_out;
fid->icb = new_parent_node->write_loc;
fid->icb.longad_uniqueid = udf_rw32(new_parent_unique_id);
(void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
fidsize = udf_fidsize(fid);
diroffset -= fidsize;
error = vn_rdwr(UIO_WRITE, dir_node->vnode,
fid, fidsize, diroffset,
UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED,
FSCRED, NULL, NULL);
error_out:
free(fid, M_UDFTEMP);
free(dirent, M_UDFTEMP);
dirhash_put(dir_node->dir_hash);
return error;
}
int
udf_dir_attach(struct udf_mount *ump, struct udf_node *dir_node,
struct udf_node *udf_node, struct vattr *vap, struct componentname *cnp)
{
struct vnode *dvp = dir_node->vnode;
struct dirhash *dirh;
struct dirhash_entry *dirh_ep;
struct fileid_desc *fid;
struct icb_tag *icbtag;
struct charspec osta_charspec;
struct dirent dirent;
uint64_t unique_id, dir_size;
uint64_t fid_pos, end_fid_pos, chosen_fid_pos;
uint32_t chosen_size, chosen_size_diff;
int lb_size, lb_rest, fidsize, this_fidsize, size_diff;
int file_char, refcnt, icbflags, addr_type, hit, error;
dirhash_get(&dir_node->dir_hash);
error = udf_dirhash_fill(dir_node);
if (error) {
dirhash_put(dir_node->dir_hash);
return error;
}
dirh = dir_node->dir_hash;
lb_size = udf_rw32(ump->logical_vol->lb_size);
udf_osta_charset(&osta_charspec);
if (dir_node->fe) {
dir_size = udf_rw64(dir_node->fe->inf_len);
icbtag = &dir_node->fe->icbtag;
} else {
dir_size = udf_rw64(dir_node->efe->inf_len);
icbtag = &dir_node->efe->icbtag;
}
icbflags = udf_rw16(icbtag->flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
if (udf_node->fe) {
unique_id = udf_rw64(udf_node->fe->unique_id);
refcnt = udf_rw16(udf_node->fe->link_cnt);
} else {
unique_id = udf_rw64(udf_node->efe->unique_id);
refcnt = udf_rw16(udf_node->efe->link_cnt);
}
if (refcnt > 0) {
unique_id = udf_advance_uniqueid(ump);
udf_adjust_filecount(udf_node, 1);
}
file_char = 0;
if (vap->va_type == VDIR)
file_char = UDF_FILE_CHAR_DIR;
fid = malloc(lb_size, M_TEMP, M_WAITOK|M_ZERO);
unix_to_udf_name((char *) fid->data, &fid->l_fi,
cnp->cn_nameptr, cnp->cn_namelen, &osta_charspec);
fidsize = UDF_FID_SIZE + fid->l_fi;
fidsize = (fidsize + 3) & ~3;
chosen_fid_pos = dir_size;
chosen_size = 0;
chosen_size_diff = UINT_MAX;
dirent.d_namlen = 0;
error = 0;
dirh_ep = NULL;
for (;;) {
hit = dirhash_lookup_freed(dirh, fidsize, &dirh_ep);
if (!hit)
break;
this_fidsize = dirh_ep->entry_size;
fid_pos = dirh_ep->offset;
end_fid_pos = fid_pos + this_fidsize;
size_diff = this_fidsize - fidsize;
lb_rest = lb_size - (end_fid_pos % lb_size);
#ifndef UDF_COMPLETE_DELETE
error = udf_read_fid_stream(vp, &fid_pos, fid, dirent);
if (error)
goto error_out;
if (udf_rw32(fid->icb.len) != 0)
continue;
if (udf_rw32(fid->icb.loc.lb_num) != 0)
continue;
if (udf_rw16(fid->icb.loc.part_num) != 0)
continue;
#endif
if ((size_diff >= 0) &&
(size_diff < chosen_size_diff) &&
(lb_rest >= sizeof(struct desc_tag)))
{
if ((size_diff == 0) || (size_diff >= 32)) {
chosen_fid_pos = fid_pos;
chosen_size = this_fidsize;
chosen_size_diff = size_diff;
}
}
}
if (chosen_size == 0) {
chosen_fid_pos = dir_size;
chosen_size = fidsize;
chosen_size_diff = 0;
if (addr_type == UDF_ICB_INTERN_ALLOC) {
udf_grow_node(dir_node, dir_size + chosen_size);
icbflags = udf_rw16(icbtag->flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
}
if (addr_type != UDF_ICB_INTERN_ALLOC) {
end_fid_pos = chosen_fid_pos + chosen_size;
lb_rest = lb_size - (end_fid_pos % lb_size);
if (lb_rest < sizeof(struct desc_tag))
chosen_size += 32;
}
}
chosen_size_diff = chosen_size - fidsize;
memset(fid, 0, lb_size);
udf_inittag(ump, &fid->tag, TAGID_FID, 0);
fid->file_version_num = udf_rw16(1);
fid->file_char = file_char;
fid->icb = udf_node->loc;
fid->icb.longad_uniqueid = udf_rw32((uint32_t) unique_id);
fid->l_iu = udf_rw16(0);
if (chosen_size > fidsize) {
fid->l_iu = udf_rw16(chosen_size_diff);
udf_set_regid((struct regid *) fid->data, IMPL_NAME);
udf_add_impl_regid(ump, (struct regid *) fid->data);
}
unix_to_udf_name((char *) fid->data + udf_rw16(fid->l_iu),
&fid->l_fi, cnp->cn_nameptr, cnp->cn_namelen, &osta_charspec);
fid->tag.desc_crc_len = udf_rw16(chosen_size - UDF_DESC_TAG_LENGTH);
(void) udf_validate_tag_and_crc_sums((union dscrptr *) fid);
error = vn_rdwr(UIO_WRITE, dvp,
fid, chosen_size, chosen_fid_pos,
UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED,
FSCRED, NULL, NULL);
if (error)
goto error_out;
if (udf_node->fe) {
refcnt = udf_rw16(udf_node->fe->link_cnt);
udf_node->fe->link_cnt = udf_rw16(refcnt+1);
} else {
KASSERT(udf_node->efe);
refcnt = udf_rw16(udf_node->efe->link_cnt);
udf_node->efe->link_cnt = udf_rw16(refcnt+1);
}
if (udf_node->i_flags & IN_DELETED) {
printf("udf: warning, marking a file undeleted\n");
udf_node->i_flags &= ~IN_DELETED;
}
if (file_char & UDF_FILE_CHAR_DIR) {
if (dir_node->fe) {
refcnt = udf_rw16(dir_node->fe->link_cnt);
refcnt++;
dir_node->fe->link_cnt = udf_rw16(refcnt);
} else {
KASSERT(dir_node->efe);
refcnt = udf_rw16(dir_node->efe->link_cnt);
refcnt++;
dir_node->efe->link_cnt = udf_rw16(refcnt);
}
}
udf_to_unix_name(dirent.d_name, NAME_MAX,
(char *) fid->data + udf_rw16(fid->l_iu), fid->l_fi, &osta_charspec);
dirent.d_namlen = strlen(dirent.d_name);
dirhash_enter(dirh, &dirent, chosen_fid_pos,
udf_fidsize(fid), 1);
udf_node->i_flags |= IN_CHANGE | IN_MODIFY;
udf_update(udf_node->vnode, NULL, NULL, NULL, 0);
error_out:
free(fid, M_TEMP);
dirhash_put(dir_node->dir_hash);
return error;
}
int
udf_loadvnode(struct mount *mp, struct vnode *vp,
const void *key, size_t key_len, const void **new_key)
{
union dscrptr *dscr;
struct udf_mount *ump;
struct udf_node *udf_node;
struct long_ad node_icb_loc, icb_loc, next_icb_loc, last_fe_icb_loc;
uint64_t file_size;
uint32_t lb_size, sector, dummy;
int udf_file_type, dscr_type, strat, strat4096, needs_indirect;
int slot, eof, error;
int num_indir_followed = 0;
DPRINTF(NODE, ("udf_loadvnode called\n"));
udf_node = NULL;
ump = VFSTOUDF(mp);
KASSERT(key_len == sizeof(node_icb_loc.loc));
memset(&node_icb_loc, 0, sizeof(node_icb_loc));
node_icb_loc.len = ump->logical_vol->lb_size;
memcpy(&node_icb_loc.loc, key, key_len);
error = udf_translate_vtop(ump, &node_icb_loc, §or, &dummy);
if (error) {
DPRINTF(NODE, ("\tcan't translate icb address!\n"));
return EINVAL;
}
udf_node = pool_get(&udf_node_pool, PR_WAITOK);
memset(udf_node, 0, sizeof(struct udf_node));
vp->v_tag = VT_UDF;
vp->v_op = udf_vnodeop_p;
vp->v_data = udf_node;
udf_node->ump = ump;
udf_node->vnode = vp;
udf_node->loc = node_icb_loc;
udf_node->lockf = 0;
mutex_init(&udf_node->node_mutex, MUTEX_DEFAULT, IPL_NONE);
cv_init(&udf_node->node_lock, "udf_nlk");
genfs_node_init(vp, &udf_genfsops);
udf_node->outstanding_bufs = 0;
udf_node->outstanding_nodedscr = 0;
udf_node->uncommitted_lbs = 0;
if (ump->fileset_desc)
if (memcmp(&udf_node->loc, &ump->fileset_desc->rootdir_icb,
sizeof(struct long_ad)) == 0)
vp->v_vflag |= VV_ROOT;
icb_loc = node_icb_loc;
needs_indirect = 0;
strat4096 = 0;
udf_file_type = UDF_ICB_FILETYPE_UNKNOWN;
file_size = 0;
lb_size = udf_rw32(ump->logical_vol->lb_size);
DPRINTF(NODE, ("\tstart reading descriptors\n"));
do {
error = udf_read_logvol_dscr(ump, &icb_loc, &dscr);
if ((dscr == NULL) && (!strat4096))
error = ENOENT;
if (error || (dscr == NULL))
break;
dscr_type = udf_rw16(dscr->tag.id);
DPRINTF(NODE, ("\tread descriptor %d\n", dscr_type));
if (dscr_type == TAGID_INDIRECTENTRY) {
needs_indirect = 0;
next_icb_loc = dscr->inde.indirect_icb;
udf_free_logvol_dscr(ump, &icb_loc, dscr);
icb_loc = next_icb_loc;
if (++num_indir_followed > UDF_MAX_INDIRS_FOLLOW) {
error = EMLINK;
break;
}
continue;
}
if ((dscr_type != TAGID_FENTRY) &&
(dscr_type != TAGID_EXTFENTRY)) {
udf_free_logvol_dscr(ump, &icb_loc, dscr);
error = ENOENT;
break;
}
KASSERT(udf_tagsize(dscr, lb_size) == lb_size);
last_fe_icb_loc = icb_loc;
if (dscr_type == TAGID_FENTRY) {
if (udf_node->fe)
udf_free_logvol_dscr(ump, &last_fe_icb_loc,
udf_node->fe);
udf_node->fe = &dscr->fe;
strat = udf_rw16(udf_node->fe->icbtag.strat_type);
udf_file_type = udf_node->fe->icbtag.file_type;
file_size = udf_rw64(udf_node->fe->inf_len);
} else {
if (udf_node->efe)
udf_free_logvol_dscr(ump, &last_fe_icb_loc,
udf_node->efe);
udf_node->efe = &dscr->efe;
strat = udf_rw16(udf_node->efe->icbtag.strat_type);
udf_file_type = udf_node->efe->icbtag.file_type;
file_size = udf_rw64(udf_node->efe->inf_len);
}
if (strat == 4096) {
strat4096 = 1;
needs_indirect = 1;
icb_loc.loc.lb_num = udf_rw32(icb_loc.loc.lb_num) + 1;
}
if (strat == 4) {
if (strat4096) {
error = EINVAL;
break;
}
break;
}
} while (!error);
if (error) {
DPRINTF(NODE, ("\tnode fe/efe failed!\n"));
udf_dispose_node(udf_node);
return EINVAL;
}
DPRINTF(NODE, ("\tnode fe/efe read in fine\n"));
assert((udf_node->fe) || (udf_node->efe));
dscr = NULL;
udf_node->write_loc = icb_loc;
udf_node->needs_indirect = needs_indirect;
UDF_LOCK_NODE(udf_node, 0);
udf_node->num_extensions = 0;
error = 0;
slot = 0;
for (;;) {
udf_get_adslot(udf_node, slot, &icb_loc, &eof);
DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
"lb_num = %d, part = %d\n", slot, eof,
UDF_EXT_FLAGS(udf_rw32(icb_loc.len)),
UDF_EXT_LEN(udf_rw32(icb_loc.len)),
udf_rw32(icb_loc.loc.lb_num),
udf_rw16(icb_loc.loc.part_num)));
if (eof)
break;
slot++;
if (UDF_EXT_FLAGS(udf_rw32(icb_loc.len)) != UDF_EXT_REDIRECT)
continue;
DPRINTF(NODE, ("\tgot redirect extent\n"));
if (udf_node->num_extensions >= UDF_MAX_ALLOC_EXTENTS) {
DPRINTF(ALLOC, ("udf_get_node: implementation limit, "
"too many allocation extensions on "
"udf_node\n"));
error = EINVAL;
break;
}
if (UDF_EXT_LEN(udf_rw32(icb_loc.len)) != lb_size) {
DPRINTF(ALLOC, ("udf_get_node: bad allocation "
"extension size in udf_node\n"));
error = EINVAL;
break;
}
DPRINTF(NODE, ("read allocation extent at lb_num %d\n",
UDF_EXT_LEN(udf_rw32(icb_loc.loc.lb_num))));
error = udf_read_logvol_dscr(ump, &icb_loc, &dscr);
if (error || (dscr == NULL))
break;
dscr_type = udf_rw16(dscr->tag.id);
if (dscr_type != TAGID_ALLOCEXTENT) {
udf_free_logvol_dscr(ump, &icb_loc, dscr);
error = ENOENT;
break;
}
DPRINTF(NODE, ("\trecording redirect extent\n"));
udf_node->ext[udf_node->num_extensions] = &dscr->aee;
udf_node->ext_loc[udf_node->num_extensions] = icb_loc;
udf_node->num_extensions++;
}
UDF_UNLOCK_NODE(udf_node, 0);
if (error) {
udf_dispose_node(udf_node);
return EINVAL;
}
DPRINTF(NODE, ("\tnode read in fine\n"));
switch (udf_file_type) {
case UDF_ICB_FILETYPE_DIRECTORY :
case UDF_ICB_FILETYPE_STREAMDIR :
vp->v_type = VDIR;
break;
case UDF_ICB_FILETYPE_BLOCKDEVICE :
vp->v_type = VBLK;
break;
case UDF_ICB_FILETYPE_CHARDEVICE :
vp->v_type = VCHR;
break;
case UDF_ICB_FILETYPE_SOCKET :
vp->v_type = VSOCK;
break;
case UDF_ICB_FILETYPE_FIFO :
vp->v_type = VFIFO;
break;
case UDF_ICB_FILETYPE_SYMLINK :
vp->v_type = VLNK;
break;
case UDF_ICB_FILETYPE_VAT :
case UDF_ICB_FILETYPE_META_MAIN :
case UDF_ICB_FILETYPE_META_MIRROR :
vp->v_type = VNON;
break;
case UDF_ICB_FILETYPE_RANDOMACCESS :
case UDF_ICB_FILETYPE_REALTIME :
vp->v_type = VREG;
break;
default:
vp->v_type = VNON;
}
uvm_vnp_setsize(vp, file_size);
*new_key = &udf_node->loc.loc;
return 0;
}
int
udf_get_node(struct udf_mount *ump, struct long_ad *node_icb_loc,
struct udf_node **udf_noderes, int lktype)
{
int error;
struct vnode *vp;
*udf_noderes = NULL;
error = vcache_get(ump->vfs_mountp, &node_icb_loc->loc,
sizeof(node_icb_loc->loc), &vp);
if (error)
return error;
error = vn_lock(vp, lktype);
if (error) {
vrele(vp);
return error;
}
*udf_noderes = VTOI(vp);
return 0;
}
int
udf_writeout_node(struct udf_node *udf_node, int waitfor)
{
union dscrptr *dscr;
struct long_ad *loc;
int extnr, error;
DPRINTF(NODE, ("udf_writeout_node called\n"));
KASSERT(udf_node->outstanding_bufs == 0);
KASSERT(udf_node->outstanding_nodedscr == 0);
KASSERT(LIST_EMPTY(&udf_node->vnode->v_dirtyblkhd));
if (udf_node->i_flags & IN_DELETED) {
DPRINTF(NODE, ("\tnode deleted; not writing out\n"));
udf_cleanup_reservation(udf_node);
return 0;
}
UDF_LOCK_NODE(udf_node, 0);
udf_cleanup_reservation(udf_node);
udf_node->outstanding_nodedscr = 1;
udf_node->i_flags &= ~(IN_MODIFIED | IN_ACCESSED);
if (udf_node->i_flags & IN_NODE_REBUILD) {
udf_node->outstanding_nodedscr += udf_node->num_extensions;
for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
loc = &udf_node->ext_loc[extnr];
dscr = (union dscrptr *) udf_node->ext[extnr];
error = udf_write_logvol_dscr(udf_node, dscr, loc, 0);
if (error)
return error;
}
udf_node->i_flags &= ~(IN_NODE_REBUILD);
}
if (udf_node->fe) {
KASSERT(udf_node->efe == NULL);
dscr = (union dscrptr *) udf_node->fe;
} else {
KASSERT(udf_node->efe);
KASSERT(udf_node->fe == NULL);
dscr = (union dscrptr *) udf_node->efe;
}
KASSERT(dscr);
loc = &udf_node->write_loc;
error = udf_write_logvol_dscr(udf_node, dscr, loc, waitfor);
return error;
}
int
udf_dispose_node(struct udf_node *udf_node)
{
struct vnode *vp;
int extnr;
DPRINTF(NODE, ("udf_dispose_node called on node %p\n", udf_node));
if (!udf_node) {
DPRINTF(NODE, ("UDF: Dispose node on node NULL, ignoring\n"));
return 0;
}
vp = udf_node->vnode;
#ifdef DIAGNOSTIC
if (vp->v_numoutput)
panic("disposing UDF node with pending I/O's, udf_node = %p, "
"v_numoutput = %d", udf_node, vp->v_numoutput);
#endif
udf_cleanup_reservation(udf_node);
dirhash_purge(&udf_node->dir_hash);
mutex_destroy(&udf_node->node_mutex);
cv_destroy(&udf_node->node_lock);
genfs_node_destroy(udf_node->vnode);
mutex_enter(vp->v_interlock);
vp->v_data = NULL;
mutex_exit(vp->v_interlock);
for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
udf_free_logvol_dscr(udf_node->ump, &udf_node->ext_loc[extnr],
udf_node->ext[extnr]);
udf_node->ext[extnr] = (void *) 0xdeadcccc;
}
if (udf_node->fe)
udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
udf_node->fe);
if (udf_node->efe)
udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
udf_node->efe);
udf_node->fe = (void *) 0xdeadaaaa;
udf_node->efe = (void *) 0xdeadbbbb;
udf_node->ump = (void *) 0xdeadbeef;
pool_put(&udf_node_pool, udf_node);
return 0;
}
int
udf_newvnode(struct mount *mp, struct vnode *dvp, struct vnode *vp,
struct vattr *vap, kauth_cred_t cred, void *extra,
size_t *key_len, const void **new_key)
{
union dscrptr *dscr;
struct udf_node *dir_node = VTOI(dvp);
struct udf_node *udf_node;
struct udf_mount *ump = dir_node->ump;
struct long_ad node_icb_loc;
uint64_t parent_unique_id;
uint64_t lmapping;
uint32_t lb_size, lb_num;
uint16_t vpart_num;
uid_t uid;
gid_t gid, parent_gid;
int (**vnodeops)(void *);
int udf_file_type, fid_size, error;
vnodeops = udf_vnodeop_p;
udf_file_type = UDF_ICB_FILETYPE_RANDOMACCESS;
switch (vap->va_type) {
case VREG :
udf_file_type = UDF_ICB_FILETYPE_RANDOMACCESS;
break;
case VDIR :
udf_file_type = UDF_ICB_FILETYPE_DIRECTORY;
break;
case VLNK :
udf_file_type = UDF_ICB_FILETYPE_SYMLINK;
break;
case VBLK :
udf_file_type = UDF_ICB_FILETYPE_BLOCKDEVICE;
return ENOTSUP;
break;
case VCHR :
udf_file_type = UDF_ICB_FILETYPE_CHARDEVICE;
return ENOTSUP;
break;
case VFIFO :
udf_file_type = UDF_ICB_FILETYPE_FIFO;
return ENOTSUP;
break;
case VSOCK :
udf_file_type = UDF_ICB_FILETYPE_SOCKET;
return ENOTSUP;
break;
case VNON :
case VBAD :
default :
return EINVAL;
}
lb_size = udf_rw32(ump->logical_vol->lb_size);
vpart_num = ump->node_part;
error = udf_reserve_space(ump, NULL, UDF_C_NODE,
vpart_num, 1, true);
if (error)
return error;
error = udf_allocate_space(ump, NULL, UDF_C_NODE,
vpart_num, 1, &lmapping);
if (error) {
udf_do_unreserve_space(ump, NULL, vpart_num, 1);
return error;
}
lb_num = lmapping;
memset(&node_icb_loc, 0, sizeof(struct long_ad));
node_icb_loc.len = udf_rw32(lb_size);
node_icb_loc.loc.lb_num = udf_rw32(lb_num);
node_icb_loc.loc.part_num = udf_rw16(vpart_num);
udf_node = pool_get(&udf_node_pool, PR_WAITOK);
memset(udf_node, 0, sizeof(struct udf_node));
udf_node->ump = ump;
udf_node->vnode = vp;
vp->v_data = udf_node;
udf_node->loc = node_icb_loc;
udf_node->write_loc = node_icb_loc;
udf_node->lockf = 0;
mutex_init(&udf_node->node_mutex, MUTEX_DEFAULT, IPL_NONE);
cv_init(&udf_node->node_lock, "udf_nlk");
udf_node->outstanding_bufs = 0;
udf_node->outstanding_nodedscr = 0;
udf_node->uncommitted_lbs = 0;
vp->v_tag = VT_UDF;
vp->v_op = vnodeops;
genfs_node_init(vp, &udf_genfsops);
if (dir_node->fe) {
parent_unique_id = udf_rw64(dir_node->fe->unique_id);
parent_gid = (gid_t) udf_rw32(dir_node->fe->gid);
} else {
parent_unique_id = udf_rw64(dir_node->efe->unique_id);
parent_gid = (gid_t) udf_rw32(dir_node->efe->gid);
}
udf_create_logvol_dscr(ump, udf_node, &node_icb_loc, &dscr);
if (udf_rw16(ump->logical_vol->tag.descriptor_ver) == 2) {
udf_node->fe = &dscr->fe;
fid_size = udf_create_new_fe(ump, udf_node->fe,
udf_file_type, &udf_node->loc,
&dir_node->loc, parent_unique_id);
} else {
udf_node->efe = &dscr->efe;
fid_size = udf_create_new_efe(ump, udf_node->efe,
udf_file_type, &udf_node->loc,
&dir_node->loc, parent_unique_id);
}
KASSERT(dscr->tag.tag_loc == udf_node->loc.loc.lb_num);
vp->v_type = vap->va_type;
uvm_vnp_setsize(vp, fid_size);
udf_setaccessmode(udf_node, vap->va_mode);
uid = kauth_cred_geteuid(cred);
gid = parent_gid;
udf_setownership(udf_node, uid, gid);
*key_len = sizeof(udf_node->loc.loc);
*new_key = &udf_node->loc.loc;
return 0;
}
int
udf_create_node(struct vnode *dvp, struct vnode **vpp, struct vattr *vap,
struct componentname *cnp)
{
struct udf_node *udf_node, *dir_node = VTOI(dvp);
struct udf_mount *ump = dir_node->ump;
int error;
error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, NULL, vpp);
if (error)
return error;
udf_node = VTOI(*vpp);
error = udf_dir_attach(ump, dir_node, udf_node, vap, cnp);
if (error) {
struct long_ad *node_icb_loc = &udf_node->loc;
uint32_t lb_num = udf_rw32(node_icb_loc->loc.lb_num);
uint16_t vpart_num = udf_rw16(node_icb_loc->loc.part_num);
udf_free_allocated_space(ump, lb_num, vpart_num, 1);
udf_dispose_node(udf_node);
vrele(*vpp);
*vpp = NULL;
return error;
}
udf_adjust_filecount(udf_node, 1);
cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
return 0;
}
static void
udf_free_descriptor_space(struct udf_node *udf_node, struct long_ad *loc, void *mem)
{
struct udf_mount *ump = udf_node->ump;
uint32_t lb_size, lb_num, len, num_lb;
uint16_t vpart_num;
if (mem == NULL)
return;
len = UDF_EXT_LEN(udf_rw32(loc->len));
lb_num = udf_rw32(loc->loc.lb_num);
vpart_num = udf_rw16(loc->loc.part_num);
lb_size = udf_rw32(ump->logical_vol->lb_size);
num_lb = (len + lb_size -1) / lb_size;
udf_free_allocated_space(ump, lb_num, vpart_num, num_lb);
}
void
udf_delete_node(struct udf_node *udf_node)
{
void *dscr;
struct long_ad *loc;
int extnr, lvint, dummy;
if (udf_node->i_flags & IN_NO_DELETE)
return;
lvint = udf_rw32(udf_node->ump->logvol_integrity->integrity_type);
if (lvint == UDF_INTEGRITY_CLOSED)
printf("\tIntegrity was CLOSED!\n");
(void) udf_resize_node(udf_node, 0, &dummy);
udf_node->i_flags &= ~(IN_MODIFIED | IN_ACCESSED | IN_ACCESS |
IN_CHANGE | IN_UPDATE | IN_MODIFY);
udf_adjust_filecount(udf_node, -1);
loc = &udf_node->loc;
dscr = udf_node->fe;
udf_free_descriptor_space(udf_node, loc, dscr);
dscr = udf_node->efe;
udf_free_descriptor_space(udf_node, loc, dscr);
for (extnr = 0; extnr < UDF_MAX_ALLOC_EXTENTS; extnr++) {
dscr = udf_node->ext[extnr];
loc = &udf_node->ext_loc[extnr];
udf_free_descriptor_space(udf_node, loc, dscr);
}
}
int
udf_resize_node(struct udf_node *udf_node, uint64_t new_size, int *extended)
{
struct file_entry *fe = udf_node->fe;
struct extfile_entry *efe = udf_node->efe;
uint64_t file_size;
int error;
if (fe) {
file_size = udf_rw64(fe->inf_len);
} else {
assert(udf_node->efe);
file_size = udf_rw64(efe->inf_len);
}
DPRINTF(ATTR, ("\tchanging file length from %"PRIu64" to %"PRIu64"\n",
file_size, new_size));
if (file_size == new_size)
return 0;
*extended = (new_size > file_size);
if (*extended) {
error = udf_grow_node(udf_node, new_size);
} else {
error = udf_shrink_node(udf_node, new_size);
}
return error;
}
void
udf_itimes(struct udf_node *udf_node, struct timespec *acc,
struct timespec *mod, struct timespec *birth)
{
struct timespec now;
struct file_entry *fe;
struct extfile_entry *efe;
struct filetimes_extattr_entry *ft_extattr;
struct timestamp *atime, *mtime, *attrtime, *ctime;
struct timestamp fe_ctime;
struct timespec cur_birth;
uint32_t offset, a_l;
uint8_t *filedata;
int error;
if (!udf_node)
return;
fe = udf_node->fe;
efe = udf_node->efe;
if (!(udf_node->i_flags & (IN_ACCESS|IN_CHANGE|IN_UPDATE|IN_MODIFY)))
return;
if (fe) {
atime = &fe->atime;
mtime = &fe->mtime;
attrtime = &fe->attrtime;
filedata = fe->data;
ctime = &fe_ctime;
error = udf_extattr_search_intern(udf_node,
UDF_FILETIMES_ATTR_NO, "", &offset, &a_l);
if (!error) {
ft_extattr = (struct filetimes_extattr_entry *)
(filedata + offset);
if (ft_extattr->existence & UDF_FILETIMES_FILE_CREATION)
ctime = &ft_extattr->times[0];
}
} else {
assert(udf_node->efe);
atime = &efe->atime;
mtime = &efe->mtime;
attrtime = &efe->attrtime;
ctime = &efe->ctime;
}
vfs_timestamp(&now);
if (udf_node->i_flags & IN_ACCESS) {
if (acc == NULL)
acc = &now;
udf_timespec_to_timestamp(acc, atime);
}
if (udf_node->i_flags & (IN_UPDATE | IN_MODIFY)) {
if (mod == NULL)
mod = &now;
udf_timespec_to_timestamp(mod, mtime);
udf_timestamp_to_timespec(udf_node->ump, ctime, &cur_birth);
if ((cur_birth.tv_sec > mod->tv_sec) ||
((cur_birth.tv_sec == mod->tv_sec) &&
(cur_birth.tv_nsec > mod->tv_nsec))) {
udf_timespec_to_timestamp(mod, ctime);
}
}
if (birth && (birth->tv_sec != VNOVAL)) {
udf_timespec_to_timestamp(birth, ctime);
}
if (udf_node->i_flags & (IN_CHANGE | IN_MODIFY))
udf_timespec_to_timestamp(&now, attrtime);
if (udf_node->i_flags & (IN_ACCESS | IN_MODIFY))
udf_node->i_flags |= IN_ACCESSED;
if (udf_node->i_flags & (IN_UPDATE | IN_CHANGE))
udf_node->i_flags |= IN_MODIFIED;
udf_node->i_flags &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY);
}
int
udf_update(struct vnode *vp, struct timespec *acc,
struct timespec *mod, struct timespec *birth, int updflags)
{
union dscrptr *dscrptr;
struct udf_node *udf_node = VTOI(vp);
struct udf_mount *ump = udf_node->ump;
struct regid *impl_id;
int mnt_async = (vp->v_mount->mnt_flag & MNT_ASYNC);
int waitfor, flags;
#ifdef DEBUG
char bits[128];
DPRINTF(CALL, ("udf_update(node, %p, %p, %p, %d)\n", acc, mod, birth,
updflags));
snprintb(bits, sizeof(bits), IN_FLAGBITS, udf_node->i_flags);
DPRINTF(CALL, ("\tnode flags %s\n", bits));
DPRINTF(CALL, ("\t\tmnt_async = %d\n", mnt_async));
#endif
udf_itimes(udf_node, acc, mod, birth);
if (udf_node->fe) {
dscrptr = (union dscrptr *) udf_node->fe;
impl_id = &udf_node->fe->imp_id;
} else {
dscrptr = (union dscrptr *) udf_node->efe;
impl_id = &udf_node->efe->imp_id;
}
udf_set_regid(impl_id, IMPL_NAME);
udf_add_impl_regid(ump, impl_id);
udf_validate_tag_and_crc_sums(dscrptr);
if (vp->v_mount->mnt_flag & MNT_RDONLY)
return 0;
if (updflags & UPDATE_CLOSE) {
flags = udf_node->i_flags & (IN_MODIFIED | IN_ACCESSED);
} else {
flags = udf_node->i_flags & IN_MODIFIED;
}
if (flags == 0)
return 0;
waitfor = 0;
if ((flags & IN_MODIFIED) && (mnt_async == 0)) {
waitfor = updflags & UPDATE_WAIT;
if (updflags & UPDATE_DIROP)
waitfor |= UPDATE_WAIT;
}
if (waitfor)
return VOP_FSYNC(vp, FSCRED, FSYNC_WAIT, 0,0);
return 0;
}
int
udf_read_fid_stream(struct vnode *vp, uint64_t *offset,
struct fileid_desc *fid, struct dirent *dirent)
{
struct udf_node *dir_node = VTOI(vp);
struct udf_mount *ump = dir_node->ump;
struct file_entry *fe = dir_node->fe;
struct extfile_entry *efe = dir_node->efe;
uint32_t fid_size, lb_size;
uint64_t file_size;
char *fid_name;
int enough, error;
assert(fid);
assert(dirent);
assert(dir_node);
assert(offset);
assert(*offset != 1);
DPRINTF(FIDS, ("read_fid_stream called at offset %"PRIu64"\n", *offset));
if (fe) {
file_size = udf_rw64(fe->inf_len);
} else {
assert(dir_node->efe);
file_size = udf_rw64(efe->inf_len);
}
if (*offset >= file_size)
return EINVAL;
lb_size = udf_rw32(ump->logical_vol->lb_size);
fid_size = 0;
memset(dirent, 0, sizeof(struct dirent));
memset(fid, 0, lb_size);
enough = (file_size - (*offset) >= UDF_FID_SIZE);
if (!enough) {
return EIO;
}
error = vn_rdwr(UIO_READ, vp,
fid, MIN(file_size - (*offset), lb_size), *offset,
UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED, FSCRED,
NULL, NULL);
if (error)
return error;
DPRINTF(FIDS, ("\tfid piece read in fine\n"));
error = udf_check_tag(fid);
if (error) {
goto brokendir;
}
DPRINTF(FIDS, ("\ttag check ok\n"));
if (udf_rw16(fid->tag.id) != TAGID_FID) {
error = EIO;
goto brokendir;
}
DPRINTF(FIDS, ("\ttag checked ok: got TAGID_FID\n"));
fid_size = udf_fidsize(fid);
enough = (file_size - (*offset) >= fid_size);
if (!enough) {
error = EIO;
goto brokendir;
}
DPRINTF(FIDS, ("\tthe complete fid is read in\n"));
error = udf_check_tag_payload((union dscrptr *) fid, lb_size);
brokendir:
if (error) {
printf("UDF: BROKEN DIRECTORY ENTRY\n");
return EIO;
}
DPRINTF(FIDS, ("\tpayload checked ok\n"));
DPRINTF(FIDS, ("\tinterpret FID\n"));
fid_name = (char *) fid->data + udf_rw16(fid->l_iu);
udf_to_unix_name(dirent->d_name, NAME_MAX,
fid_name, fid->l_fi, &ump->logical_vol->desc_charset);
if (fid->file_char & UDF_FILE_CHAR_PAR)
strcpy(dirent->d_name, "..");
dirent->d_fileno = udf_get_node_id(&fid->icb);
dirent->d_namlen = strlen(dirent->d_name);
dirent->d_reclen = _DIRENT_SIZE(dirent);
dirent->d_type = DT_UNKNOWN;
if (fid->file_char & UDF_FILE_CHAR_DIR)
dirent->d_type = DT_DIR;
*offset += fid_size;
return error;
}
static void
udf_sync_pass(struct udf_mount *ump, kauth_cred_t cred, int pass, int *ndirty)
{
struct udf_node *udf_node, *n_udf_node;
struct vnode *vp;
int vdirty, error;
KASSERT(mutex_owned(&ump->sync_lock));
DPRINTF(SYNC, ("sync_pass %d\n", pass));
udf_node = RB_TREE_MIN(&ump->udf_node_tree);
for (;udf_node; udf_node = n_udf_node) {
DPRINTF(SYNC, ("."));
vp = udf_node->vnode;
n_udf_node = rb_tree_iterate(&ump->udf_node_tree,
udf_node, RB_DIR_RIGHT);
error = vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT);
if (error) {
KASSERT(error == EBUSY);
*ndirty += 1;
continue;
}
switch (pass) {
case 1:
VOP_FSYNC(vp, cred, 0 | FSYNC_DATAONLY,0,0);
break;
case 2:
vdirty = vp->v_numoutput;
if (vp->v_tag == VT_UDF)
vdirty += udf_node->outstanding_bufs +
udf_node->outstanding_nodedscr;
if (vdirty == 0)
VOP_FSYNC(vp, cred, 0,0,0);
*ndirty += vdirty;
break;
case 3:
vdirty = vp->v_numoutput;
if (vp->v_tag == VT_UDF)
vdirty += udf_node->outstanding_bufs +
udf_node->outstanding_nodedscr;
*ndirty += vdirty;
break;
}
VOP_UNLOCK(vp);
}
DPRINTF(SYNC, ("END sync_pass %d\n", pass));
}
static bool
udf_sync_selector(void *cl, struct vnode *vp)
{
struct udf_node *udf_node;
KASSERT(mutex_owned(vp->v_interlock));
udf_node = VTOI(vp);
if (vp->v_vflag & VV_SYSTEM)
return false;
if (vp->v_type == VNON)
return false;
if (udf_node == NULL)
return false;
if ((udf_node->i_flags & (IN_ACCESSED | IN_UPDATE | IN_MODIFIED)) == 0)
return false;
if (LIST_EMPTY(&vp->v_dirtyblkhd) && (vp->v_iflag & VI_ONWORKLST) == 0)
return false;
return true;
}
void
udf_do_sync(struct udf_mount *ump, kauth_cred_t cred, int waitfor)
{
struct vnode_iterator *marker;
struct vnode *vp;
struct udf_node *udf_node, *udf_next_node;
int dummy, ndirty;
if (waitfor == MNT_LAZY)
return;
mutex_enter(&ump->sync_lock);
vfs_vnode_iterator_init(ump->vfs_mountp, &marker);
while ((vp = vfs_vnode_iterator_next(marker,
udf_sync_selector, NULL)) != NULL) {
udf_node = VTOI(vp);
udf_node->i_flags |= IN_SYNCED;
rb_tree_insert_node(&ump->udf_node_tree, udf_node);
}
vfs_vnode_iterator_destroy(marker);
dummy = 0;
DPRINTF(CALL, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
DPRINTF(SYNC, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
udf_sync_pass(ump, cred, 1, &dummy);
DPRINTF(CALL, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
DPRINTF(SYNC, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
udf_sync_pass(ump, cred, 2, &dummy);
if (waitfor == MNT_WAIT) {
recount:
ndirty = ump->devvp->v_numoutput;
DPRINTF(SYNC, ("counting pending blocks: on devvp %d\n",
ndirty));
udf_sync_pass(ump, cred, 3, &ndirty);
DPRINTF(SYNC, ("counted num dirty pending blocks %d\n",
ndirty));
if (ndirty) {
kpause("udfsync2", false, hz/4, NULL);
goto recount;
}
}
for (udf_node = RB_TREE_MIN(&ump->udf_node_tree);
udf_node; udf_node = udf_next_node) {
udf_next_node = rb_tree_iterate(&ump->udf_node_tree,
udf_node, RB_DIR_RIGHT);
rb_tree_remove_node(&ump->udf_node_tree, udf_node);
udf_node->i_flags &= ~IN_SYNCED;
vrele(udf_node->vnode);
}
mutex_exit(&ump->sync_lock);
}
static int
udf_read_internal(struct udf_node *node, uint8_t *blob)
{
struct udf_mount *ump;
struct file_entry *fe = node->fe;
struct extfile_entry *efe = node->efe;
uint64_t inflen;
uint32_t sector_size;
uint8_t *srcpos;
int icbflags, addr_type;
ump = node->ump;
sector_size = ump->discinfo.sector_size;
if (fe) {
inflen = udf_rw64(fe->inf_len);
srcpos = &fe->data[0] + udf_rw32(fe->l_ea);
icbflags = udf_rw16(fe->icbtag.flags);
} else {
assert(node->efe);
inflen = udf_rw64(efe->inf_len);
srcpos = &efe->data[0] + udf_rw32(efe->l_ea);
icbflags = udf_rw16(efe->icbtag.flags);
}
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
assert(addr_type == UDF_ICB_INTERN_ALLOC);
__USE(addr_type);
assert(inflen < sector_size);
memcpy(blob, srcpos, inflen);
memset(&blob[inflen], 0, sector_size - inflen);
return 0;
}
static int
udf_write_internal(struct udf_node *node, uint8_t *blob)
{
struct udf_mount *ump;
struct file_entry *fe = node->fe;
struct extfile_entry *efe = node->efe;
uint64_t inflen;
uint32_t sector_size;
uint8_t *pos;
int icbflags, addr_type;
ump = node->ump;
sector_size = ump->discinfo.sector_size;
if (fe) {
inflen = udf_rw64(fe->inf_len);
pos = &fe->data[0] + udf_rw32(fe->l_ea);
icbflags = udf_rw16(fe->icbtag.flags);
} else {
assert(node->efe);
inflen = udf_rw64(efe->inf_len);
pos = &efe->data[0] + udf_rw32(efe->l_ea);
icbflags = udf_rw16(efe->icbtag.flags);
}
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
assert(addr_type == UDF_ICB_INTERN_ALLOC);
__USE(addr_type);
assert(inflen < sector_size);
__USE(sector_size);
memcpy(pos, blob, inflen);
return 0;
}
void
udf_read_filebuf(struct udf_node *udf_node, struct buf *buf)
{
struct buf *nestbuf;
struct udf_mount *ump = udf_node->ump;
uint64_t *mapping;
uint64_t run_start;
uint32_t sector_size;
uint32_t buf_offset, sector, rbuflen, rblk;
uint32_t from, lblkno;
uint32_t sectors;
uint8_t *buf_pos;
int error, run_length, what;
sector_size = udf_node->ump->discinfo.sector_size;
from = buf->b_blkno;
sectors = buf->b_bcount / sector_size;
what = udf_get_c_type(udf_node);
KASSERT(buf->b_bcount / sector_size <= UDF_MAX_MAPPINGS);
KASSERT(MAXPHYS / sector_size <= UDF_MAX_MAPPINGS);
if (sectors > UDF_MAX_MAPPINGS) {
printf("udf_read_filebuf: implementation limit on bufsize\n");
buf->b_error = EIO;
biodone(buf);
return;
}
mapping = malloc(sizeof(*mapping) * UDF_MAX_MAPPINGS, M_TEMP, M_WAITOK);
error = 0;
DPRINTF(READ, ("\ttranslate %d-%d\n", from, sectors));
error = udf_translate_file_extent(udf_node, from, sectors, mapping);
if (error) {
buf->b_error = error;
biodone(buf);
goto out;
}
DPRINTF(READ, ("\ttranslate extent went OK\n"));
if (*mapping == UDF_TRANS_INTERN) {
error = udf_read_internal(udf_node, (uint8_t *) buf->b_data);
if (error)
buf->b_error = error;
biodone(buf);
goto out;
}
DPRINTF(READ, ("\tnot intern\n"));
#ifdef DEBUG
if (udf_verbose & UDF_DEBUG_TRANSLATE) {
printf("Returned translation table:\n");
for (sector = 0; sector < sectors; sector++) {
printf("%d : %"PRIu64"\n", sector, mapping[sector]);
}
}
#endif
buf->b_resid = buf->b_bcount;
for (sector = 0; sector < sectors; sector++) {
buf_offset = sector * sector_size;
buf_pos = (uint8_t *) buf->b_data + buf_offset;
DPRINTF(READ, ("\tprocessing rel sector %d\n", sector));
switch (mapping[sector]) {
case UDF_TRANS_UNMAPPED:
case UDF_TRANS_ZERO:
memset(buf_pos, 0, sector_size);
DPRINTF(READ, ("\treturning zero sector\n"));
nestiobuf_done(buf, sector_size, 0);
break;
default :
DPRINTF(READ, ("\tread sector "
"%"PRIu64"\n", mapping[sector]));
lblkno = from + sector;
run_start = mapping[sector];
run_length = 1;
while (sector < sectors-1) {
if (mapping[sector+1] != mapping[sector]+1)
break;
run_length++;
sector++;
}
rbuflen = run_length * sector_size;
rblk = run_start * (sector_size/DEV_BSIZE);
nestbuf = getiobuf(NULL, true);
nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen);
nestbuf->b_lblkno = lblkno;
assert(nestbuf->b_vp == udf_node->vnode);
nestbuf->b_blkno = rblk;
nestbuf->b_proc = NULL;
nestbuf->b_rawblkno = rblk;
nestbuf->b_udf_c_type = what;
udf_discstrat_queuebuf(ump, nestbuf);
}
}
out:
if ((buf->b_flags & B_ASYNC) == 0)
biowait(buf);
DPRINTF(READ, ("\tend of read_filebuf\n"));
free(mapping, M_TEMP);
return;
}
void
udf_write_filebuf(struct udf_node *udf_node, struct buf *buf)
{
struct buf *nestbuf;
struct udf_mount *ump = udf_node->ump;
uint64_t *mapping;
uint64_t run_start;
uint32_t lb_size;
uint32_t buf_offset, lb_num, rbuflen, rblk;
uint32_t from, lblkno;
uint32_t num_lb;
int error, run_length, what, s;
lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
from = buf->b_blkno;
num_lb = buf->b_bcount / lb_size;
what = udf_get_c_type(udf_node);
KASSERT(buf->b_bcount / lb_size <= UDF_MAX_MAPPINGS);
KASSERT(MAXPHYS / lb_size <= UDF_MAX_MAPPINGS);
if (num_lb > UDF_MAX_MAPPINGS) {
printf("udf_write_filebuf: implementation limit on bufsize\n");
buf->b_error = EIO;
biodone(buf);
return;
}
mapping = malloc(sizeof(*mapping) * UDF_MAX_MAPPINGS, M_TEMP, M_WAITOK);
error = 0;
DPRINTF(WRITE, ("\ttranslate %d-%d\n", from, num_lb));
error = udf_translate_file_extent(udf_node, from, num_lb, mapping);
if (error) {
buf->b_error = error;
biodone(buf);
goto out;
}
DPRINTF(WRITE, ("\ttranslate extent went OK\n"));
if (*mapping == UDF_TRANS_INTERN) {
error = udf_write_internal(udf_node, (uint8_t *) buf->b_data);
if (error)
buf->b_error = error;
biodone(buf);
goto out;
}
DPRINTF(WRITE, ("\tnot intern\n"));
buf->b_resid = buf->b_bcount;
for (lb_num = 0; lb_num < num_lb; lb_num++) {
buf_offset = lb_num * lb_size;
DPRINTF(WRITE, ("\tprocessing rel lb_num %d\n", lb_num));
DPRINTF(WRITE, ("\twrite lb_num "
"%"PRIu64, mapping[lb_num]));
lblkno = from + lb_num;
run_start = mapping[lb_num];
run_length = 1;
while (lb_num < num_lb-1) {
if (mapping[lb_num+1] != mapping[lb_num]+1)
if (mapping[lb_num+1] != mapping[lb_num])
break;
run_length++;
lb_num++;
}
DPRINTF(WRITE, ("+ %d\n", run_length));
rbuflen = run_length * lb_size;
rblk = run_start * (lb_size/DEV_BSIZE);
nestbuf = getiobuf(NULL, true);
nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen);
nestbuf->b_lblkno = lblkno;
KASSERT(nestbuf->b_vp == udf_node->vnode);
nestbuf->b_blkno = rblk;
nestbuf->b_proc = NULL;
nestbuf->b_rawblkno = rblk;
nestbuf->b_udf_c_type = what;
s = splbio();
udf_node->outstanding_bufs++;
splx(s);
udf_discstrat_queuebuf(ump, nestbuf);
}
out:
if ((buf->b_flags & B_ASYNC) == 0)
biowait(buf);
DPRINTF(WRITE, ("\tend of write_filebuf\n"));
free(mapping, M_TEMP);
return;
}
