1 /* $NetBSD: udf_subr.c,v 1.132 2015/08/24 08:31:56 hannken Exp $ */
4 * Copyright (c) 2006, 2008 Reinoud Zandijk
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #include <sys/cdefs.h>
32 __KERNEL_RCSID(0, "$NetBSD: udf_subr.c,v 1.132 2015/08/24 08:31:56 hannken Exp $");
36 #if defined(_KERNEL_OPT)
37 #include "opt_compat_netbsd.h"
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/sysctl.h>
43 #include <sys/namei.h>
45 #include <sys/kernel.h>
46 #include <sys/vnode.h>
47 #include <miscfs/genfs/genfs_node.h>
48 #include <sys/mount.h>
51 #include <sys/device.h>
52 #include <sys/disklabel.h>
53 #include <sys/ioctl.h>
54 #include <sys/malloc.h>
55 #include <sys/dirent.h>
58 #include <sys/kauth.h>
59 #include <fs/unicode.h>
60 #include <dev/clock_subr.h>
62 #include <fs/udf/ecma167-udf.h>
63 #include <fs/udf/udf_mount.h>
64 #include <sys/dirhash.h>
68 #include "udf_bswap.h"
71 #define VTOI(vnode) ((struct udf_node *) (vnode)->v_data)
73 #define UDF_SET_SYSTEMFILE(vp) \
74 /* XXXAD Is the vnode locked? */ \
75 (vp)->v_vflag |= VV_SYSTEM; \
79 extern int syncer_maxdelay; /* maximum delay time */
80 extern int (**udf_vnodeop_p
)(void *);
82 /* --------------------------------------------------------------------- */
89 udf_dumpblob(boid
*blob
, uint32_t dlen
)
93 printf("blob = %p\n", blob
);
94 printf("dump of %d bytes\n", dlen
);
96 for (i
= 0; i
< dlen
; i
+ = 16) {
98 for (j
= 0; j
< 16; j
++) {
100 printf("%02x ", blob
[i
+j
]);
105 for (j
= 0; j
< 16; j
++) {
107 if (blob
[i
+j
]>32 && blob
[i
+j
]! = 127) {
108 printf("%c", blob
[i
+j
]);
122 udf_dump_discinfo(struct udf_mount
*ump
)
125 struct mmc_discinfo
*di
= &ump
->discinfo
;
127 if ((udf_verbose
& UDF_DEBUG_VOLUMES
) == 0)
130 printf("Device/media info :\n");
131 printf("\tMMC profile 0x%02x\n", di
->mmc_profile
);
132 printf("\tderived class %d\n", di
->mmc_class
);
133 printf("\tsector size %d\n", di
->sector_size
);
134 printf("\tdisc state %d\n", di
->disc_state
);
135 printf("\tlast ses state %d\n", di
->last_session_state
);
136 printf("\tbg format state %d\n", di
->bg_format_state
);
137 printf("\tfrst track %d\n", di
->first_track
);
138 printf("\tfst on last ses %d\n", di
->first_track_last_session
);
139 printf("\tlst on last ses %d\n", di
->last_track_last_session
);
140 printf("\tlink block penalty %d\n", di
->link_block_penalty
);
141 snprintb(bits
, sizeof(bits
), MMC_DFLAGS_FLAGBITS
, di
->disc_flags
);
142 printf("\tdisc flags %s\n", bits
);
143 printf("\tdisc id %x\n", di
->disc_id
);
144 printf("\tdisc barcode %"PRIx64
"\n", di
->disc_barcode
);
146 printf("\tnum sessions %d\n", di
->num_sessions
);
147 printf("\tnum tracks %d\n", di
->num_tracks
);
149 snprintb(bits
, sizeof(bits
), MMC_CAP_FLAGBITS
, di
->mmc_cur
);
150 printf("\tcapabilities cur %s\n", bits
);
151 snprintb(bits
, sizeof(bits
), MMC_CAP_FLAGBITS
, di
->mmc_cap
);
152 printf("\tcapabilities cap %s\n", bits
);
156 udf_dump_trackinfo(struct mmc_trackinfo
*trackinfo
)
160 if ((udf_verbose
& UDF_DEBUG_VOLUMES
) == 0)
163 printf("Trackinfo for track %d:\n", trackinfo
->tracknr
);
164 printf("\tsessionnr %d\n", trackinfo
->sessionnr
);
165 printf("\ttrack mode %d\n", trackinfo
->track_mode
);
166 printf("\tdata mode %d\n", trackinfo
->data_mode
);
167 snprintb(bits
, sizeof(bits
), MMC_TRACKINFO_FLAGBITS
, trackinfo
->flags
);
168 printf("\tflags %s\n", bits
);
170 printf("\ttrack start %d\n", trackinfo
->track_start
);
171 printf("\tnext_writable %d\n", trackinfo
->next_writable
);
172 printf("\tfree_blocks %d\n", trackinfo
->free_blocks
);
173 printf("\tpacket_size %d\n", trackinfo
->packet_size
);
174 printf("\ttrack size %d\n", trackinfo
->track_size
);
175 printf("\tlast recorded block %d\n", trackinfo
->last_recorded
);
179 #define udf_dump_discinfo(a);
180 #define udf_dump_trackinfo(a);
184 /* --------------------------------------------------------------------- */
186 /* not called often */
188 udf_update_discinfo(struct udf_mount
*ump
)
190 struct vnode
*devvp
= ump
->devvp
;
193 struct mmc_discinfo
*di
;
196 DPRINTF(VOLUMES
, ("read/update disc info\n"));
198 memset(di
, 0, sizeof(struct mmc_discinfo
));
200 /* check if we're on a MMC capable device, i.e. CD/DVD */
201 error
= VOP_IOCTL(devvp
, MMCGETDISCINFO
, di
, FKIOCTL
, NOCRED
);
203 udf_dump_discinfo(ump
);
207 /* disc partition support */
208 error
= getdisksize(devvp
, &psize
, &secsize
);
212 /* set up a disc info profile for partitions */
213 di
->mmc_profile
= 0x01; /* disc type */
214 di
->mmc_class
= MMC_CLASS_DISC
;
215 di
->disc_state
= MMC_STATE_CLOSED
;
216 di
->last_session_state
= MMC_STATE_CLOSED
;
217 di
->bg_format_state
= MMC_BGFSTATE_COMPLETED
;
218 di
->link_block_penalty
= 0;
220 di
->mmc_cur
= MMC_CAP_RECORDABLE
| MMC_CAP_REWRITABLE
|
221 MMC_CAP_ZEROLINKBLK
| MMC_CAP_HW_DEFECTFREE
;
222 di
->mmc_cap
= di
->mmc_cur
;
223 di
->disc_flags
= MMC_DFLAGS_UNRESTRICTED
;
225 /* TODO problem with last_possible_lba on resizable VND; request */
226 di
->last_possible_lba
= psize
;
227 di
->sector_size
= secsize
;
229 di
->num_sessions
= 1;
233 di
->first_track_last_session
= di
->last_track_last_session
= 1;
235 udf_dump_discinfo(ump
);
241 udf_update_trackinfo(struct udf_mount
*ump
, struct mmc_trackinfo
*ti
)
243 struct vnode
*devvp
= ump
->devvp
;
244 struct mmc_discinfo
*di
= &ump
->discinfo
;
247 DPRINTF(VOLUMES
, ("read track info\n"));
249 class = di
->mmc_class
;
250 if (class != MMC_CLASS_DISC
) {
251 /* tracknr specified in struct ti */
252 error
= VOP_IOCTL(devvp
, MMCGETTRACKINFO
, ti
, FKIOCTL
, NOCRED
);
256 /* disc partition support */
257 if (ti
->tracknr
!= 1)
260 /* create fake ti (TODO check for resized vnds) */
263 ti
->track_mode
= 0; /* XXX */
264 ti
->data_mode
= 0; /* XXX */
265 ti
->flags
= MMC_TRACKINFO_LRA_VALID
| MMC_TRACKINFO_NWA_VALID
;
270 /* TODO support for resizable vnd */
271 ti
->track_size
= di
->last_possible_lba
;
272 ti
->next_writable
= di
->last_possible_lba
;
273 ti
->last_recorded
= ti
->next_writable
;
281 udf_setup_writeparams(struct udf_mount
*ump
)
283 struct mmc_writeparams mmc_writeparams
;
286 if (ump
->discinfo
.mmc_class
== MMC_CLASS_DISC
)
290 * only CD burning normally needs setting up, but other disc types
291 * might need other settings to be made. The MMC framework will set up
292 * the nessisary recording parameters according to the disc
293 * characteristics read in. Modifications can be made in the discinfo
294 * structure passed to change the nature of the disc.
297 memset(&mmc_writeparams
, 0, sizeof(struct mmc_writeparams
));
298 mmc_writeparams
.mmc_class
= ump
->discinfo
.mmc_class
;
299 mmc_writeparams
.mmc_cur
= ump
->discinfo
.mmc_cur
;
302 * UDF dictates first track to determine track mode for the whole
303 * disc. [UDF 1.50/6.10.1.1, UDF 1.50/6.10.2.1]
304 * To prevent problems with a `reserved' track in front we start with
305 * the 2nd track and if that is not valid, go for the 1st.
307 mmc_writeparams
.tracknr
= 2;
308 mmc_writeparams
.data_mode
= MMC_DATAMODE_DEFAULT
; /* XA disc */
309 mmc_writeparams
.track_mode
= MMC_TRACKMODE_DEFAULT
; /* data */
311 error
= VOP_IOCTL(ump
->devvp
, MMCSETUPWRITEPARAMS
, &mmc_writeparams
,
314 mmc_writeparams
.tracknr
= 1;
315 error
= VOP_IOCTL(ump
->devvp
, MMCSETUPWRITEPARAMS
,
316 &mmc_writeparams
, FKIOCTL
, NOCRED
);
323 udf_synchronise_caches(struct udf_mount
*ump
)
325 struct mmc_op mmc_op
;
327 DPRINTF(CALL
, ("udf_synchronise_caches()\n"));
329 if (ump
->vfs_mountp
->mnt_flag
& MNT_RDONLY
)
332 /* discs are done now */
333 if (ump
->discinfo
.mmc_class
== MMC_CLASS_DISC
)
336 memset(&mmc_op
, 0, sizeof(struct mmc_op
));
337 mmc_op
.operation
= MMC_OP_SYNCHRONISECACHE
;
339 /* ignore return code */
340 (void) VOP_IOCTL(ump
->devvp
, MMCOP
, &mmc_op
, FKIOCTL
, NOCRED
);
345 /* --------------------------------------------------------------------- */
347 /* track/session searching for mounting */
349 udf_search_tracks(struct udf_mount
*ump
, struct udf_args
*args
,
350 int *first_tracknr
, int *last_tracknr
)
352 struct mmc_trackinfo trackinfo
;
353 uint32_t tracknr
, start_track
, num_tracks
;
356 /* if negative, sessionnr is relative to last session */
357 if (args
->sessionnr
< 0) {
358 args
->sessionnr
+= ump
->discinfo
.num_sessions
;
362 if (args
->sessionnr
< 0)
364 if (args
->sessionnr
> ump
->discinfo
.num_sessions
)
365 args
->sessionnr
= ump
->discinfo
.num_sessions
;
367 /* search the tracks for this session, zero session nr indicates last */
368 if (args
->sessionnr
== 0)
369 args
->sessionnr
= ump
->discinfo
.num_sessions
;
370 if (ump
->discinfo
.last_session_state
== MMC_STATE_EMPTY
)
374 if (args
->sessionnr
< 0)
377 /* search the first and last track of the specified session */
378 num_tracks
= ump
->discinfo
.num_tracks
;
379 start_track
= ump
->discinfo
.first_track
;
381 /* search for first track of this session */
382 for (tracknr
= start_track
; tracknr
<= num_tracks
; tracknr
++) {
384 trackinfo
.tracknr
= tracknr
;
385 error
= udf_update_trackinfo(ump
, &trackinfo
);
389 if (trackinfo
.sessionnr
== args
->sessionnr
)
392 *first_tracknr
= tracknr
;
394 /* search for last track of this session */
395 for (;tracknr
<= num_tracks
; tracknr
++) {
397 trackinfo
.tracknr
= tracknr
;
398 error
= udf_update_trackinfo(ump
, &trackinfo
);
399 if (error
|| (trackinfo
.sessionnr
!= args
->sessionnr
)) {
404 if (tracknr
> num_tracks
)
407 *last_tracknr
= tracknr
;
409 if (*last_tracknr
< *first_tracknr
) {
410 printf( "udf_search_tracks: sanity check on drive+disc failed, "
411 "drive returned garbage\n");
415 assert(*last_tracknr
>= *first_tracknr
);
421 * NOTE: this is the only routine in this file that directly peeks into the
422 * metadata file but since its at a larval state of the mount it can't hurt.
424 * XXX candidate for udf_allocation.c
425 * XXX clean me up!, change to new node reading code.
429 udf_check_track_metadata_overlap(struct udf_mount
*ump
,
430 struct mmc_trackinfo
*trackinfo
)
432 struct part_desc
*part
;
433 struct file_entry
*fe
;
434 struct extfile_entry
*efe
;
435 struct short_ad
*s_ad
;
436 struct long_ad
*l_ad
;
437 uint32_t track_start
, track_end
;
438 uint32_t phys_part_start
, phys_part_end
, part_start
, part_end
;
439 uint32_t sector_size
, len
, alloclen
, plb_num
;
441 int addr_type
, icblen
, icbflags
;
443 /* get our track extents */
444 track_start
= trackinfo
->track_start
;
445 track_end
= track_start
+ trackinfo
->track_size
;
447 /* get our base partition extent */
448 KASSERT(ump
->node_part
== ump
->fids_part
);
449 part
= ump
->partitions
[ump
->vtop
[ump
->node_part
]];
450 phys_part_start
= udf_rw32(part
->start_loc
);
451 phys_part_end
= phys_part_start
+ udf_rw32(part
->part_len
);
453 /* no use if its outside the physical partition */
454 if ((phys_part_start
>= track_end
) || (phys_part_end
< track_start
))
458 * now follow all extents in the fe/efe to see if they refer to this
462 sector_size
= ump
->discinfo
.sector_size
;
464 /* XXX should we claim exclusive access to the metafile ? */
465 /* TODO: move to new node read code */
466 fe
= ump
->metadata_node
->fe
;
467 efe
= ump
->metadata_node
->efe
;
469 alloclen
= udf_rw32(fe
->l_ad
);
470 pos
= &fe
->data
[0] + udf_rw32(fe
->l_ea
);
471 icbflags
= udf_rw16(fe
->icbtag
.flags
);
474 alloclen
= udf_rw32(efe
->l_ad
);
475 pos
= &efe
->data
[0] + udf_rw32(efe
->l_ea
);
476 icbflags
= udf_rw16(efe
->icbtag
.flags
);
478 addr_type
= icbflags
& UDF_ICB_TAG_FLAGS_ALLOC_MASK
;
481 if (addr_type
== UDF_ICB_SHORT_ALLOC
) {
482 icblen
= sizeof(struct short_ad
);
483 s_ad
= (struct short_ad
*) pos
;
484 len
= udf_rw32(s_ad
->len
);
485 plb_num
= udf_rw32(s_ad
->lb_num
);
487 /* should not be present, but why not */
488 icblen
= sizeof(struct long_ad
);
489 l_ad
= (struct long_ad
*) pos
;
490 len
= udf_rw32(l_ad
->len
);
491 plb_num
= udf_rw32(l_ad
->loc
.lb_num
);
492 /* pvpart_num = udf_rw16(l_ad->loc.part_num); */
495 len
= UDF_EXT_LEN(len
);
497 part_start
= phys_part_start
+ plb_num
;
498 part_end
= part_start
+ (len
/ sector_size
);
500 if ((part_start
>= track_start
) && (part_end
<= track_end
)) {
501 /* extent is enclosed within this track */
502 ump
->metadata_track
= *trackinfo
;
513 udf_search_writing_tracks(struct udf_mount
*ump
)
515 struct vnode
*devvp
= ump
->devvp
;
516 struct mmc_trackinfo trackinfo
;
517 struct mmc_op mmc_op
;
518 struct part_desc
*part
;
519 uint32_t tracknr
, start_track
, num_tracks
;
520 uint32_t track_start
, track_end
, part_start
, part_end
;
521 int node_alloc
, error
;
524 * in the CD/(HD)DVD/BD recordable device model a few tracks within
525 * the last session might be open but in the UDF device model at most
526 * three tracks can be open: a reserved track for delayed ISO VRS
527 * writing, a data track and a metadata track. We search here for the
528 * data track and the metadata track. Note that the reserved track is
529 * troublesome but can be detected by its small size of < 512 sectors.
532 /* update discinfo since it might have changed */
533 error
= udf_update_discinfo(ump
);
537 num_tracks
= ump
->discinfo
.num_tracks
;
538 start_track
= ump
->discinfo
.first_track
;
540 /* fetch info on first and possibly only track */
541 trackinfo
.tracknr
= start_track
;
542 error
= udf_update_trackinfo(ump
, &trackinfo
);
546 /* copy results to our mount point */
547 ump
->data_track
= trackinfo
;
548 ump
->metadata_track
= trackinfo
;
550 /* if not sequential, we're done */
554 for (tracknr
= start_track
;tracknr
<= num_tracks
; tracknr
++) {
556 trackinfo
.tracknr
= tracknr
;
557 error
= udf_update_trackinfo(ump
, &trackinfo
);
562 * If this track is marked damaged, ask for repair. This is an
563 * optional command, so ignore its error but report warning.
565 if (trackinfo
.flags
& MMC_TRACKINFO_DAMAGED
) {
566 memset(&mmc_op
, 0, sizeof(mmc_op
));
567 mmc_op
.operation
= MMC_OP_REPAIRTRACK
;
568 mmc_op
.mmc_profile
= ump
->discinfo
.mmc_profile
;
569 mmc_op
.tracknr
= tracknr
;
570 error
= VOP_IOCTL(devvp
, MMCOP
, &mmc_op
, FKIOCTL
, NOCRED
);
572 (void)printf("Drive can't explicitly repair "
573 "damaged track %d, but it might "
574 "autorepair\n", tracknr
);
576 /* reget track info */
577 error
= udf_update_trackinfo(ump
, &trackinfo
);
581 if ((trackinfo
.flags
& MMC_TRACKINFO_NWA_VALID
) == 0)
584 track_start
= trackinfo
.track_start
;
585 track_end
= track_start
+ trackinfo
.track_size
;
587 /* check for overlap on data partition */
588 part
= ump
->partitions
[ump
->data_part
];
589 part_start
= udf_rw32(part
->start_loc
);
590 part_end
= part_start
+ udf_rw32(part
->part_len
);
591 if ((part_start
< track_end
) && (part_end
> track_start
)) {
592 ump
->data_track
= trackinfo
;
593 /* TODO check if UDF partition data_part is writable */
596 /* check for overlap on metadata partition */
597 node_alloc
= ump
->vtop_alloc
[ump
->node_part
];
598 if ((node_alloc
== UDF_ALLOC_METASEQUENTIAL
) ||
599 (node_alloc
== UDF_ALLOC_METABITMAP
)) {
600 udf_check_track_metadata_overlap(ump
, &trackinfo
);
602 ump
->metadata_track
= trackinfo
;
606 if ((ump
->data_track
.flags
& MMC_TRACKINFO_NWA_VALID
) == 0)
609 if ((ump
->metadata_track
.flags
& MMC_TRACKINFO_NWA_VALID
) == 0)
615 /* --------------------------------------------------------------------- */
618 * Check if the blob starts with a good UDF tag. Tags are protected by a
619 * checksum over the reader except one byte at position 4 that is the checksum
624 udf_check_tag(void *blob
)
626 struct desc_tag
*tag
= blob
;
627 uint8_t *pos
, sum
, cnt
;
629 /* check TAG header checksum */
630 pos
= (uint8_t *) tag
;
633 for(cnt
= 0; cnt
< 16; cnt
++) {
638 if (sum
!= tag
->cksum
) {
639 /* bad tag header checksum; this is not a valid tag */
648 * check tag payload will check descriptor CRC as specified.
649 * If the descriptor is too long, it will return EIO otherwise EINVAL.
653 udf_check_tag_payload(void *blob
, uint32_t max_length
)
655 struct desc_tag
*tag
= blob
;
656 uint16_t crc
, crc_len
;
658 crc_len
= udf_rw16(tag
->desc_crc_len
);
660 /* check payload CRC if applicable */
664 if (crc_len
> max_length
)
667 crc
= udf_cksum(((uint8_t *) tag
) + UDF_DESC_TAG_LENGTH
, crc_len
);
668 if (crc
!= udf_rw16(tag
->desc_crc
)) {
669 /* bad payload CRC; this is a broken tag */
678 udf_validate_tag_sum(void *blob
)
680 struct desc_tag
*tag
= blob
;
681 uint8_t *pos
, sum
, cnt
;
683 /* calculate TAG header checksum */
684 pos
= (uint8_t *) tag
;
687 for(cnt
= 0; cnt
< 16; cnt
++) {
688 if (cnt
!= 4) sum
+= *pos
;
691 tag
->cksum
= sum
; /* 8 bit */
695 /* assumes sector number of descriptor to be saved already present */
697 udf_validate_tag_and_crc_sums(void *blob
)
699 struct desc_tag
*tag
= blob
;
700 uint8_t *btag
= (uint8_t *) tag
;
701 uint16_t crc
, crc_len
;
703 crc_len
= udf_rw16(tag
->desc_crc_len
);
705 /* check payload CRC if applicable */
707 crc
= udf_cksum(btag
+ UDF_DESC_TAG_LENGTH
, crc_len
);
708 tag
->desc_crc
= udf_rw16(crc
);
711 /* calculate TAG header checksum */
712 udf_validate_tag_sum(blob
);
715 /* --------------------------------------------------------------------- */
718 * XXX note the different semantics from udfclient: for FIDs it still rounds
719 * up to sectors. Use udf_fidsize() for a correct length.
723 udf_tagsize(union dscrptr
*dscr
, uint32_t lb_size
)
725 uint32_t size
, tag_id
, num_lb
, elmsz
;
727 tag_id
= udf_rw16(dscr
->tag
.id
);
731 size
= sizeof(struct logvol_desc
) - 1;
732 size
+= udf_rw32(dscr
->lvd
.mt_l
);
734 case TAGID_UNALLOC_SPACE
:
735 elmsz
= sizeof(struct extent_ad
);
736 size
= sizeof(struct unalloc_sp_desc
) - elmsz
;
737 size
+= udf_rw32(dscr
->usd
.alloc_desc_num
) * elmsz
;
740 size
= UDF_FID_SIZE
+ dscr
->fid
.l_fi
+ udf_rw16(dscr
->fid
.l_iu
);
741 size
= (size
+ 3) & ~3;
743 case TAGID_LOGVOL_INTEGRITY
:
744 size
= sizeof(struct logvol_int_desc
) - sizeof(uint32_t);
745 size
+= udf_rw32(dscr
->lvid
.l_iu
);
746 size
+= (2 * udf_rw32(dscr
->lvid
.num_part
) * sizeof(uint32_t));
748 case TAGID_SPACE_BITMAP
:
749 size
= sizeof(struct space_bitmap_desc
) - 1;
750 size
+= udf_rw32(dscr
->sbd
.num_bytes
);
752 case TAGID_SPARING_TABLE
:
753 elmsz
= sizeof(struct spare_map_entry
);
754 size
= sizeof(struct udf_sparing_table
) - elmsz
;
755 size
+= udf_rw16(dscr
->spt
.rt_l
) * elmsz
;
758 size
= sizeof(struct file_entry
);
759 size
+= udf_rw32(dscr
->fe
.l_ea
) + udf_rw32(dscr
->fe
.l_ad
)-1;
761 case TAGID_EXTFENTRY
:
762 size
= sizeof(struct extfile_entry
);
763 size
+= udf_rw32(dscr
->efe
.l_ea
) + udf_rw32(dscr
->efe
.l_ad
)-1;
766 size
= sizeof(struct fileset_desc
);
769 size
= sizeof(union dscrptr
);
773 if ((size
== 0) || (lb_size
== 0))
779 /* round up in sectors */
780 num_lb
= (size
+ lb_size
-1) / lb_size
;
781 return num_lb
* lb_size
;
786 udf_fidsize(struct fileid_desc
*fid
)
790 if (udf_rw16(fid
->tag
.id
) != TAGID_FID
)
791 panic("got udf_fidsize on non FID\n");
793 size
= UDF_FID_SIZE
+ fid
->l_fi
+ udf_rw16(fid
->l_iu
);
794 size
= (size
+ 3) & ~3;
799 /* --------------------------------------------------------------------- */
802 udf_lock_node(struct udf_node
*udf_node
, int flag
, char const *fname
, const int lineno
)
806 mutex_enter(&udf_node
->node_mutex
);
807 /* wait until free */
808 while (udf_node
->i_flags
& IN_LOCKED
) {
809 ret
= cv_timedwait(&udf_node
->node_lock
, &udf_node
->node_mutex
, hz
/8);
810 /* TODO check if we should return error; abort */
811 if (ret
== EWOULDBLOCK
) {
812 DPRINTF(LOCKING
, ( "udf_lock_node: udf_node %p would block "
813 "wanted at %s:%d, previously locked at %s:%d\n",
814 udf_node
, fname
, lineno
,
815 udf_node
->lock_fname
, udf_node
->lock_lineno
));
819 udf_node
->i_flags
|= IN_LOCKED
| flag
;
821 udf_node
->lock_fname
= fname
;
822 udf_node
->lock_lineno
= lineno
;
824 mutex_exit(&udf_node
->node_mutex
);
829 udf_unlock_node(struct udf_node
*udf_node
, int flag
)
831 mutex_enter(&udf_node
->node_mutex
);
832 udf_node
->i_flags
&= ~(IN_LOCKED
| flag
);
833 cv_broadcast(&udf_node
->node_lock
);
834 mutex_exit(&udf_node
->node_mutex
);
838 /* --------------------------------------------------------------------- */
841 udf_read_anchor(struct udf_mount
*ump
, uint32_t sector
, struct anchor_vdp
**dst
)
845 error
= udf_read_phys_dscr(ump
, sector
, M_UDFVOLD
,
846 (union dscrptr
**) dst
);
848 /* blank terminator blocks are not allowed here */
851 if (udf_rw16((*dst
)->tag
.id
) != TAGID_ANCHOR
) {
853 free(*dst
, M_UDFVOLD
);
855 DPRINTF(VOLUMES
, ("Not an anchor\n"));
864 udf_read_anchors(struct udf_mount
*ump
)
866 struct udf_args
*args
= &ump
->mount_args
;
867 struct mmc_trackinfo first_track
;
868 struct mmc_trackinfo second_track
;
869 struct mmc_trackinfo last_track
;
870 struct anchor_vdp
**anchorsp
;
871 uint32_t track_start
;
873 uint32_t positions
[4];
874 int first_tracknr
, last_tracknr
;
875 int error
, anch
, ok
, first_anchor
;
877 /* search the first and last track of the specified session */
878 error
= udf_search_tracks(ump
, args
, &first_tracknr
, &last_tracknr
);
880 first_track
.tracknr
= first_tracknr
;
881 error
= udf_update_trackinfo(ump
, &first_track
);
884 last_track
.tracknr
= last_tracknr
;
885 error
= udf_update_trackinfo(ump
, &last_track
);
887 if ((!error
) && (first_tracknr
!= last_tracknr
)) {
888 second_track
.tracknr
= first_tracknr
+1;
889 error
= udf_update_trackinfo(ump
, &second_track
);
892 printf("UDF mount: reading disc geometry failed\n");
896 track_start
= first_track
.track_start
;
898 /* `end' is not as straitforward as start. */
899 track_end
= last_track
.track_start
900 + last_track
.track_size
- last_track
.free_blocks
- 1;
902 if (ump
->discinfo
.mmc_cur
& MMC_CAP_SEQUENTIAL
) {
903 /* end of track is not straitforward here */
904 if (last_track
.flags
& MMC_TRACKINFO_LRA_VALID
)
905 track_end
= last_track
.last_recorded
;
906 else if (last_track
.flags
& MMC_TRACKINFO_NWA_VALID
)
907 track_end
= last_track
.next_writable
908 - ump
->discinfo
.link_block_penalty
;
911 /* its no use reading a blank track */
913 if (first_track
.flags
& MMC_TRACKINFO_BLANK
)
916 /* get our packet size */
917 ump
->packet_size
= first_track
.packet_size
;
918 if (first_track
.flags
& MMC_TRACKINFO_BLANK
)
919 ump
->packet_size
= second_track
.packet_size
;
921 if (ump
->packet_size
<= 1) {
922 /* take max, but not bigger than 64 */
923 ump
->packet_size
= MAXPHYS
/ ump
->discinfo
.sector_size
;
924 ump
->packet_size
= MIN(ump
->packet_size
, 64);
926 KASSERT(ump
->packet_size
>= 1);
928 /* read anchors start+256, start+512, end-256, end */
929 positions
[0] = track_start
+256;
930 positions
[1] = track_end
-256;
931 positions
[2] = track_end
;
932 positions
[3] = track_start
+512; /* [UDF 2.60/6.11.2] */
933 /* XXX shouldn't +512 be prefered above +256 for compat with Roxio CD */
936 anchorsp
= ump
->anchors
;
937 for (anch
= first_anchor
; anch
< 4; anch
++) {
938 DPRINTF(VOLUMES
, ("Read anchor %d at sector %d\n", anch
,
940 error
= udf_read_anchor(ump
, positions
[anch
], anchorsp
);
947 /* VATs are only recorded on sequential media, but initialise */
948 ump
->first_possible_vat_location
= track_start
+ 2;
949 ump
->last_possible_vat_location
= track_end
+ last_track
.packet_size
;
954 /* --------------------------------------------------------------------- */
957 udf_get_c_type(struct udf_node
*udf_node
)
961 isdir
= (udf_node
->vnode
->v_type
== VDIR
);
962 what
= isdir
? UDF_C_FIDS
: UDF_C_USERDATA
;
965 if (udf_node
== udf_node
->ump
->metadatabitmap_node
)
966 what
= UDF_C_METADATA_SBM
;
973 udf_get_record_vpart(struct udf_mount
*ump
, int udf_c_type
)
977 vpart_num
= ump
->data_part
;
978 if (udf_c_type
== UDF_C_NODE
)
979 vpart_num
= ump
->node_part
;
980 if (udf_c_type
== UDF_C_FIDS
)
981 vpart_num
= ump
->fids_part
;
988 * BUGALERT: some rogue implementations use random physical partition
989 * numbers to break other implementations so lookup the number.
993 udf_find_raw_phys(struct udf_mount
*ump
, uint16_t raw_phys_part
)
995 struct part_desc
*part
;
998 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
999 part
= ump
->partitions
[phys_part
];
1002 if (udf_rw16(part
->part_num
) == raw_phys_part
)
1008 /* --------------------------------------------------------------------- */
1010 /* we dont try to be smart; we just record the parts */
1011 #define UDF_UPDATE_DSCR(name, dscr) \
1013 free(name, M_UDFVOLD); \
1017 udf_process_vds_descriptor(struct udf_mount
*ump
, union dscrptr
*dscr
)
1019 uint16_t phys_part
, raw_phys_part
;
1021 DPRINTF(VOLUMES
, ("\tprocessing VDS descr %d\n",
1022 udf_rw16(dscr
->tag
.id
)));
1023 switch (udf_rw16(dscr
->tag
.id
)) {
1024 case TAGID_PRI_VOL
: /* primary partition */
1025 UDF_UPDATE_DSCR(ump
->primary_vol
, &dscr
->pvd
);
1027 case TAGID_LOGVOL
: /* logical volume */
1028 UDF_UPDATE_DSCR(ump
->logical_vol
, &dscr
->lvd
);
1030 case TAGID_UNALLOC_SPACE
: /* unallocated space */
1031 UDF_UPDATE_DSCR(ump
->unallocated
, &dscr
->usd
);
1033 case TAGID_IMP_VOL
: /* implementation */
1034 /* XXX do we care about multiple impl. descr ? */
1035 UDF_UPDATE_DSCR(ump
->implementation
, &dscr
->ivd
);
1037 case TAGID_PARTITION
: /* physical partition */
1038 /* not much use if its not allocated */
1039 if ((udf_rw16(dscr
->pd
.flags
) & UDF_PART_FLAG_ALLOCATED
) == 0) {
1040 free(dscr
, M_UDFVOLD
);
1045 * BUGALERT: some rogue implementations use random physical
1046 * partition numbers to break other implementations so lookup
1049 raw_phys_part
= udf_rw16(dscr
->pd
.part_num
);
1050 phys_part
= udf_find_raw_phys(ump
, raw_phys_part
);
1052 if (phys_part
== UDF_PARTITIONS
) {
1053 free(dscr
, M_UDFVOLD
);
1057 UDF_UPDATE_DSCR(ump
->partitions
[phys_part
], &dscr
->pd
);
1059 case TAGID_VOL
: /* volume space extender; rare */
1060 DPRINTF(VOLUMES
, ("VDS extender ignored\n"));
1061 free(dscr
, M_UDFVOLD
);
1064 DPRINTF(VOLUMES
, ("Unhandled VDS type %d\n",
1065 udf_rw16(dscr
->tag
.id
)));
1066 free(dscr
, M_UDFVOLD
);
1071 #undef UDF_UPDATE_DSCR
1073 /* --------------------------------------------------------------------- */
1076 udf_read_vds_extent(struct udf_mount
*ump
, uint32_t loc
, uint32_t len
)
1078 union dscrptr
*dscr
;
1079 uint32_t sector_size
, dscr_size
;
1082 sector_size
= ump
->discinfo
.sector_size
;
1084 /* loc is sectornr, len is in bytes */
1087 error
= udf_read_phys_dscr(ump
, loc
, M_UDFVOLD
, &dscr
);
1091 /* blank block is a terminator */
1095 /* TERM descriptor is a terminator */
1096 if (udf_rw16(dscr
->tag
.id
) == TAGID_TERM
) {
1097 free(dscr
, M_UDFVOLD
);
1101 /* process all others */
1102 dscr_size
= udf_tagsize(dscr
, sector_size
);
1103 error
= udf_process_vds_descriptor(ump
, dscr
);
1105 free(dscr
, M_UDFVOLD
);
1108 assert((dscr_size
% sector_size
) == 0);
1111 loc
+= dscr_size
/ sector_size
;
1119 udf_read_vds_space(struct udf_mount
*ump
)
1121 /* struct udf_args *args = &ump->mount_args; */
1122 struct anchor_vdp
*anchor
, *anchor2
;
1124 uint32_t main_loc
, main_len
;
1125 uint32_t reserve_loc
, reserve_len
;
1129 * read in VDS space provided by the anchors; if one descriptor read
1130 * fails, try the mirror sector.
1132 * check if 2nd anchor is different from 1st; if so, go for 2nd. This
1133 * avoids the `compatibility features' of DirectCD that may confuse
1137 anchor
= ump
->anchors
[0];
1138 anchor2
= ump
->anchors
[1];
1142 size
= sizeof(struct extent_ad
);
1143 if (memcmp(&anchor
->main_vds_ex
, &anchor2
->main_vds_ex
, size
))
1145 /* reserve is specified to be a literal copy of main */
1148 main_loc
= udf_rw32(anchor
->main_vds_ex
.loc
);
1149 main_len
= udf_rw32(anchor
->main_vds_ex
.len
);
1151 reserve_loc
= udf_rw32(anchor
->reserve_vds_ex
.loc
);
1152 reserve_len
= udf_rw32(anchor
->reserve_vds_ex
.len
);
1154 error
= udf_read_vds_extent(ump
, main_loc
, main_len
);
1156 printf("UDF mount: reading in reserve VDS extent\n");
1157 error
= udf_read_vds_extent(ump
, reserve_loc
, reserve_len
);
1163 /* --------------------------------------------------------------------- */
1166 * Read in the logical volume integrity sequence pointed to by our logical
1167 * volume descriptor. Its a sequence that can be extended using fields in the
1168 * integrity descriptor itself. On sequential media only one is found, on
1169 * rewritable media a sequence of descriptors can be found as a form of
1170 * history keeping and on non sequential write-once media the chain is vital
1171 * to allow more and more descriptors to be written. The last descriptor
1172 * written in an extent needs to claim space for a new extent.
1176 udf_retrieve_lvint(struct udf_mount
*ump
)
1178 union dscrptr
*dscr
;
1179 struct logvol_int_desc
*lvint
;
1180 struct udf_lvintq
*trace
;
1181 uint32_t lb_size
, lbnum
, len
;
1182 int dscr_type
, error
, trace_len
;
1184 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
1185 len
= udf_rw32(ump
->logical_vol
->integrity_seq_loc
.len
);
1186 lbnum
= udf_rw32(ump
->logical_vol
->integrity_seq_loc
.loc
);
1189 memset(ump
->lvint_trace
, 0,
1190 UDF_LVDINT_SEGMENTS
* sizeof(struct udf_lvintq
));
1193 trace
= ump
->lvint_trace
;
1194 trace
->start
= lbnum
;
1195 trace
->end
= lbnum
+ len
/lb_size
;
1203 trace
->pos
= lbnum
- trace
->start
;
1204 trace
->wpos
= trace
->pos
+ 1;
1206 /* read in our integrity descriptor */
1207 error
= udf_read_phys_dscr(ump
, lbnum
, M_UDFVOLD
, &dscr
);
1210 trace
->wpos
= trace
->pos
;
1211 break; /* empty terminates */
1213 dscr_type
= udf_rw16(dscr
->tag
.id
);
1214 if (dscr_type
== TAGID_TERM
) {
1215 trace
->wpos
= trace
->pos
;
1216 break; /* clean terminator */
1218 if (dscr_type
!= TAGID_LOGVOL_INTEGRITY
) {
1219 /* fatal... corrupt disc */
1224 free(lvint
, M_UDFVOLD
);
1225 lvint
= &dscr
->lvid
;
1227 } /* else hope for the best... maybe the next is ok */
1229 DPRINTFIF(VOLUMES
, lvint
, ("logvol integrity read, state %s\n",
1230 udf_rw32(lvint
->integrity_type
) ? "CLOSED" : "OPEN"));
1232 /* proceed sequential */
1236 /* are we linking to a new piece? */
1237 if (dscr
&& lvint
->next_extent
.len
) {
1238 len
= udf_rw32(lvint
->next_extent
.len
);
1239 lbnum
= udf_rw32(lvint
->next_extent
.loc
);
1241 if (trace_len
>= UDF_LVDINT_SEGMENTS
-1) {
1242 /* IEK! segment link full... */
1243 DPRINTF(VOLUMES
, ("lvdint segments full\n"));
1249 trace
->start
= lbnum
;
1250 trace
->end
= lbnum
+ len
/lb_size
;
1257 /* clean up the mess, esp. when there is an error */
1259 free(dscr
, M_UDFVOLD
);
1261 if (error
&& lvint
) {
1262 free(lvint
, M_UDFVOLD
);
1269 ump
->logvol_integrity
= lvint
;
1275 udf_loose_lvint_history(struct udf_mount
*ump
)
1277 union dscrptr
**bufs
, *dscr
, *last_dscr
;
1278 struct udf_lvintq
*trace
, *in_trace
, *out_trace
;
1279 struct logvol_int_desc
*lvint
;
1280 uint32_t in_ext
, in_pos
, in_len
;
1281 uint32_t out_ext
, out_wpos
, out_len
;
1283 uint32_t len
, start
;
1284 int ext
, minext
, extlen
, cnt
, cpy_len
, dscr_type
;
1288 DPRINTF(VOLUMES
, ("need to lose some lvint history\n"));
1290 /* search smallest extent */
1291 trace
= &ump
->lvint_trace
[0];
1292 minext
= trace
->end
- trace
->start
;
1293 for (ext
= 1; ext
< UDF_LVDINT_SEGMENTS
; ext
++) {
1294 trace
= &ump
->lvint_trace
[ext
];
1295 extlen
= trace
->end
- trace
->start
;
1298 minext
= MIN(minext
, extlen
);
1300 losing
= MIN(minext
, UDF_LVINT_LOSSAGE
);
1301 /* no sense wiping all */
1302 if (losing
== minext
)
1305 DPRINTF(VOLUMES
, ("\tlosing %d entries\n", losing
));
1307 /* get buffer for pieces */
1308 bufs
= malloc(UDF_LVDINT_SEGMENTS
* sizeof(void *), M_TEMP
, M_WAITOK
);
1312 in_trace
= &ump
->lvint_trace
[in_ext
];
1313 in_len
= in_trace
->end
- in_trace
->start
;
1316 out_trace
= &ump
->lvint_trace
[out_ext
];
1317 out_len
= out_trace
->end
- out_trace
->start
;
1321 out_trace
->pos
= out_wpos
;
1322 out_trace
->wpos
= out_trace
->pos
;
1323 if (in_pos
>= in_len
) {
1326 in_trace
= &ump
->lvint_trace
[in_ext
];
1327 in_len
= in_trace
->end
- in_trace
->start
;
1329 if (out_wpos
>= out_len
) {
1332 out_trace
= &ump
->lvint_trace
[out_ext
];
1333 out_len
= out_trace
->end
- out_trace
->start
;
1335 /* copy overlap contents */
1336 cpy_len
= MIN(in_len
- in_pos
, out_len
- out_wpos
);
1337 cpy_len
= MIN(cpy_len
, in_len
- in_trace
->pos
);
1342 DPRINTF(VOLUMES
, ("\treading %d lvid descriptors\n", cpy_len
));
1343 for (cnt
= 0; cnt
< cpy_len
; cnt
++) {
1344 /* read in our integrity descriptor */
1345 lb_num
= in_trace
->start
+ in_pos
+ cnt
;
1346 error
= udf_read_phys_dscr(ump
, lb_num
, M_UDFVOLD
,
1355 out_trace
->pos
= out_wpos
+ cnt
;
1356 out_trace
->wpos
= out_trace
->pos
;
1357 break; /* empty terminates */
1359 dscr_type
= udf_rw16(dscr
->tag
.id
);
1360 if (dscr_type
== TAGID_TERM
) {
1361 out_trace
->pos
= out_wpos
+ cnt
;
1362 out_trace
->wpos
= out_trace
->pos
;
1363 break; /* clean terminator */
1365 if (dscr_type
!= TAGID_LOGVOL_INTEGRITY
) {
1366 panic( "UDF integrity sequence "
1367 "corrupted while mounted!\n");
1373 /* patch up if first entry was on error */
1374 if (bufs
[0] == NULL
) {
1375 for (cnt
= 0; cnt
< cpy_len
; cnt
++)
1376 if (bufs
[cnt
] != NULL
)
1378 last_dscr
= bufs
[cnt
];
1379 for (; cnt
> 0; cnt
--) {
1380 bufs
[cnt
] = last_dscr
;
1384 /* glue + write out */
1385 DPRINTF(VOLUMES
, ("\twriting %d lvid descriptors\n", cpy_len
));
1386 for (cnt
= 0; cnt
< cpy_len
; cnt
++) {
1387 lb_num
= out_trace
->start
+ out_wpos
+ cnt
;
1388 lvint
= &bufs
[cnt
]->lvid
;
1390 /* set continuation */
1393 if (out_wpos
+ cnt
== out_len
) {
1394 /* get continuation */
1395 trace
= &ump
->lvint_trace
[out_ext
+1];
1396 len
= trace
->end
- trace
->start
;
1397 start
= trace
->start
;
1399 lvint
->next_extent
.len
= udf_rw32(len
);
1400 lvint
->next_extent
.loc
= udf_rw32(start
);
1402 lb_num
= trace
->start
+ trace
->wpos
;
1403 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_DSCR
,
1404 bufs
[cnt
], lb_num
, lb_num
);
1405 DPRINTFIF(VOLUMES
, error
,
1406 ("error writing lvint lb_num\n"));
1409 /* free non repeating descriptors */
1411 for (cnt
= 0; cnt
< cpy_len
; cnt
++) {
1412 if (bufs
[cnt
] != last_dscr
)
1413 free(bufs
[cnt
], M_UDFVOLD
);
1414 last_dscr
= bufs
[cnt
];
1419 out_wpos
+= cpy_len
;
1429 udf_writeout_lvint(struct udf_mount
*ump
, int lvflag
)
1431 struct udf_lvintq
*trace
;
1432 struct timeval now_v
;
1433 struct timespec now_s
;
1435 int logvol_integrity
;
1438 DPRINTF(VOLUMES
, ("writing out logvol integrity descriptor\n"));
1441 /* get free space in last chunk */
1442 trace
= ump
->lvint_trace
;
1443 while (trace
->wpos
> (trace
->end
- trace
->start
)) {
1444 DPRINTF(VOLUMES
, ("skip : start = %d, end = %d, pos = %d, "
1445 "wpos = %d\n", trace
->start
, trace
->end
,
1446 trace
->pos
, trace
->wpos
));
1450 /* check if there is space to append */
1451 space
= (trace
->end
- trace
->start
) - trace
->wpos
;
1452 DPRINTF(VOLUMES
, ("write start = %d, end = %d, pos = %d, wpos = %d, "
1453 "space = %d\n", trace
->start
, trace
->end
, trace
->pos
,
1454 trace
->wpos
, space
));
1457 logvol_integrity
= udf_rw32(ump
->logvol_integrity
->integrity_type
);
1458 if (logvol_integrity
== UDF_INTEGRITY_CLOSED
) {
1459 if ((space
< 3) && (lvflag
& UDF_APPENDONLY_LVINT
)) {
1460 /* TODO extent LVINT space if possible */
1466 if (lvflag
& UDF_APPENDONLY_LVINT
)
1468 /* loose history by re-writing extents */
1469 error
= udf_loose_lvint_history(ump
);
1475 /* update our integrity descriptor to identify us and timestamp it */
1476 DPRINTF(VOLUMES
, ("updating integrity descriptor\n"));
1478 TIMEVAL_TO_TIMESPEC(&now_v
, &now_s
);
1479 udf_timespec_to_timestamp(&now_s
, &ump
->logvol_integrity
->time
);
1480 udf_set_regid(&ump
->logvol_info
->impl_id
, IMPL_NAME
);
1481 udf_add_impl_regid(ump
, &ump
->logvol_info
->impl_id
);
1483 /* writeout integrity descriptor */
1484 sector
= trace
->start
+ trace
->wpos
;
1485 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_DSCR
,
1486 (union dscrptr
*) ump
->logvol_integrity
,
1488 DPRINTF(VOLUMES
, ("writeout lvint : error = %d\n", error
));
1492 /* advance write position */
1493 trace
->wpos
++; space
--;
1495 /* append terminator */
1496 sector
= trace
->start
+ trace
->wpos
;
1497 error
= udf_write_terminator(ump
, sector
);
1499 DPRINTF(VOLUMES
, ("write terminator : error = %d\n", error
));
1502 space
= (trace
->end
- trace
->start
) - trace
->wpos
;
1503 DPRINTF(VOLUMES
, ("write start = %d, end = %d, pos = %d, wpos = %d, "
1504 "space = %d\n", trace
->start
, trace
->end
, trace
->pos
,
1505 trace
->wpos
, space
));
1506 DPRINTF(VOLUMES
, ("finished writing out logvol integrity descriptor "
1512 /* --------------------------------------------------------------------- */
1515 udf_read_physical_partition_spacetables(struct udf_mount
*ump
)
1517 union dscrptr
*dscr
;
1518 /* struct udf_args *args = &ump->mount_args; */
1519 struct part_desc
*partd
;
1520 struct part_hdr_desc
*parthdr
;
1521 struct udf_bitmap
*bitmap
;
1523 uint32_t lb_num
, len
;
1524 int error
, dscr_type
;
1526 /* unallocated space map */
1527 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1528 partd
= ump
->partitions
[phys_part
];
1531 parthdr
= &partd
->_impl_use
.part_hdr
;
1533 lb_num
= udf_rw32(partd
->start_loc
);
1534 lb_num
+= udf_rw32(parthdr
->unalloc_space_bitmap
.lb_num
);
1535 len
= udf_rw32(parthdr
->unalloc_space_bitmap
.len
);
1539 DPRINTF(VOLUMES
, ("Read unalloc. space bitmap %d\n", lb_num
));
1540 error
= udf_read_phys_dscr(ump
, lb_num
, M_UDFVOLD
, &dscr
);
1541 if (!error
&& dscr
) {
1543 dscr_type
= udf_rw16(dscr
->tag
.id
);
1544 if (dscr_type
== TAGID_SPACE_BITMAP
) {
1545 DPRINTF(VOLUMES
, ("Accepting space bitmap\n"));
1546 ump
->part_unalloc_dscr
[phys_part
] = &dscr
->sbd
;
1548 /* fill in ump->part_unalloc_bits */
1549 bitmap
= &ump
->part_unalloc_bits
[phys_part
];
1550 bitmap
->blob
= (uint8_t *) dscr
;
1551 bitmap
->bits
= dscr
->sbd
.data
;
1552 bitmap
->max_offset
= udf_rw32(dscr
->sbd
.num_bits
);
1553 bitmap
->pages
= NULL
; /* TODO */
1554 bitmap
->data_pos
= 0;
1555 bitmap
->metadata_pos
= 0;
1557 free(dscr
, M_UDFVOLD
);
1559 printf( "UDF mount: error reading unallocated "
1564 /* blank not allowed */
1565 printf("UDF mount: blank unallocated space bitmap\n");
1570 /* unallocated space table (not supported) */
1571 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1572 partd
= ump
->partitions
[phys_part
];
1575 parthdr
= &partd
->_impl_use
.part_hdr
;
1577 len
= udf_rw32(parthdr
->unalloc_space_table
.len
);
1579 printf("UDF mount: space tables not supported\n");
1584 /* freed space map */
1585 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1586 partd
= ump
->partitions
[phys_part
];
1589 parthdr
= &partd
->_impl_use
.part_hdr
;
1591 /* freed space map */
1592 lb_num
= udf_rw32(partd
->start_loc
);
1593 lb_num
+= udf_rw32(parthdr
->freed_space_bitmap
.lb_num
);
1594 len
= udf_rw32(parthdr
->freed_space_bitmap
.len
);
1598 DPRINTF(VOLUMES
, ("Read unalloc. space bitmap %d\n", lb_num
));
1599 error
= udf_read_phys_dscr(ump
, lb_num
, M_UDFVOLD
, &dscr
);
1600 if (!error
&& dscr
) {
1602 dscr_type
= udf_rw16(dscr
->tag
.id
);
1603 if (dscr_type
== TAGID_SPACE_BITMAP
) {
1604 DPRINTF(VOLUMES
, ("Accepting space bitmap\n"));
1605 ump
->part_freed_dscr
[phys_part
] = &dscr
->sbd
;
1607 /* fill in ump->part_freed_bits */
1608 bitmap
= &ump
->part_unalloc_bits
[phys_part
];
1609 bitmap
->blob
= (uint8_t *) dscr
;
1610 bitmap
->bits
= dscr
->sbd
.data
;
1611 bitmap
->max_offset
= udf_rw32(dscr
->sbd
.num_bits
);
1612 bitmap
->pages
= NULL
; /* TODO */
1613 bitmap
->data_pos
= 0;
1614 bitmap
->metadata_pos
= 0;
1616 free(dscr
, M_UDFVOLD
);
1618 printf( "UDF mount: error reading freed "
1623 /* blank not allowed */
1624 printf("UDF mount: blank freed space bitmap\n");
1629 /* freed space table (not supported) */
1630 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1631 partd
= ump
->partitions
[phys_part
];
1634 parthdr
= &partd
->_impl_use
.part_hdr
;
1636 len
= udf_rw32(parthdr
->freed_space_table
.len
);
1638 printf("UDF mount: space tables not supported\n");
1647 /* TODO implement async writeout */
1649 udf_write_physical_partition_spacetables(struct udf_mount
*ump
, int waitfor
)
1651 union dscrptr
*dscr
;
1652 /* struct udf_args *args = &ump->mount_args; */
1653 struct part_desc
*partd
;
1654 struct part_hdr_desc
*parthdr
;
1656 uint32_t lb_num
, len
, ptov
;
1657 int error_all
, error
;
1660 /* unallocated space map */
1661 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1662 partd
= ump
->partitions
[phys_part
];
1665 parthdr
= &partd
->_impl_use
.part_hdr
;
1667 ptov
= udf_rw32(partd
->start_loc
);
1668 lb_num
= udf_rw32(parthdr
->unalloc_space_bitmap
.lb_num
);
1669 len
= udf_rw32(parthdr
->unalloc_space_bitmap
.len
);
1673 DPRINTF(VOLUMES
, ("Write unalloc. space bitmap %d\n",
1675 dscr
= (union dscrptr
*) ump
->part_unalloc_dscr
[phys_part
];
1676 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_DSCR
,
1677 (union dscrptr
*) dscr
,
1678 ptov
+ lb_num
, lb_num
);
1680 DPRINTF(VOLUMES
, ("\tfailed!! (error %d)\n", error
));
1685 /* freed space map */
1686 for (phys_part
= 0; phys_part
< UDF_PARTITIONS
; phys_part
++) {
1687 partd
= ump
->partitions
[phys_part
];
1690 parthdr
= &partd
->_impl_use
.part_hdr
;
1692 /* freed space map */
1693 ptov
= udf_rw32(partd
->start_loc
);
1694 lb_num
= udf_rw32(parthdr
->freed_space_bitmap
.lb_num
);
1695 len
= udf_rw32(parthdr
->freed_space_bitmap
.len
);
1699 DPRINTF(VOLUMES
, ("Write freed space bitmap %d\n",
1701 dscr
= (union dscrptr
*) ump
->part_freed_dscr
[phys_part
];
1702 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_DSCR
,
1703 (union dscrptr
*) dscr
,
1704 ptov
+ lb_num
, lb_num
);
1706 DPRINTF(VOLUMES
, ("\tfailed!! (error %d)\n", error
));
1716 udf_read_metadata_partition_spacetable(struct udf_mount
*ump
)
1718 struct udf_node
*bitmap_node
;
1719 union dscrptr
*dscr
;
1720 struct udf_bitmap
*bitmap
;
1722 int error
, dscr_type
;
1724 bitmap_node
= ump
->metadatabitmap_node
;
1726 /* only read in when metadata bitmap node is read in */
1727 if (bitmap_node
== NULL
)
1730 if (bitmap_node
->fe
) {
1731 inflen
= udf_rw64(bitmap_node
->fe
->inf_len
);
1733 KASSERT(bitmap_node
->efe
);
1734 inflen
= udf_rw64(bitmap_node
->efe
->inf_len
);
1737 DPRINTF(VOLUMES
, ("Reading metadata space bitmap for "
1738 "%"PRIu64
" bytes\n", inflen
));
1740 /* allocate space for bitmap */
1741 dscr
= malloc(inflen
, M_UDFVOLD
, M_CANFAIL
| M_WAITOK
);
1745 /* set vnode type to regular file or we can't read from it! */
1746 bitmap_node
->vnode
->v_type
= VREG
;
1748 /* read in complete metadata bitmap file */
1749 error
= vn_rdwr(UIO_READ
, bitmap_node
->vnode
,
1753 IO_SYNC
| IO_ALTSEMANTICS
, FSCRED
,
1756 DPRINTF(VOLUMES
, ("Error reading metadata space bitmap\n"));
1761 dscr_type
= udf_rw16(dscr
->tag
.id
);
1762 if (dscr_type
== TAGID_SPACE_BITMAP
) {
1763 DPRINTF(VOLUMES
, ("Accepting metadata space bitmap\n"));
1764 ump
->metadata_unalloc_dscr
= &dscr
->sbd
;
1766 /* fill in bitmap bits */
1767 bitmap
= &ump
->metadata_unalloc_bits
;
1768 bitmap
->blob
= (uint8_t *) dscr
;
1769 bitmap
->bits
= dscr
->sbd
.data
;
1770 bitmap
->max_offset
= udf_rw32(dscr
->sbd
.num_bits
);
1771 bitmap
->pages
= NULL
; /* TODO */
1772 bitmap
->data_pos
= 0;
1773 bitmap
->metadata_pos
= 0;
1775 DPRINTF(VOLUMES
, ("No valid bitmap found!\n"));
1782 free(dscr
, M_UDFVOLD
);
1783 printf( "UDF mount: error reading unallocated "
1784 "space bitmap for metadata partition\n");
1790 udf_write_metadata_partition_spacetable(struct udf_mount
*ump
, int waitfor
)
1792 struct udf_node
*bitmap_node
;
1793 union dscrptr
*dscr
;
1794 uint64_t new_inflen
;
1797 bitmap_node
= ump
->metadatabitmap_node
;
1799 /* only write out when metadata bitmap node is known */
1800 if (bitmap_node
== NULL
)
1803 if (!bitmap_node
->fe
) {
1804 KASSERT(bitmap_node
->efe
);
1807 /* reduce length to zero */
1808 dscr
= (union dscrptr
*) ump
->metadata_unalloc_dscr
;
1809 new_inflen
= udf_tagsize(dscr
, 1);
1811 DPRINTF(VOLUMES
, ("Resize and write out metadata space bitmap "
1812 " for %"PRIu64
" bytes\n", new_inflen
));
1814 error
= udf_resize_node(bitmap_node
, new_inflen
, &dummy
);
1816 printf("Error resizing metadata space bitmap\n");
1818 error
= vn_rdwr(UIO_WRITE
, bitmap_node
->vnode
,
1822 IO_ALTSEMANTICS
, FSCRED
,
1825 bitmap_node
->i_flags
|= IN_MODIFIED
;
1826 error
= vflushbuf(bitmap_node
->vnode
, FSYNC_WAIT
);
1828 error
= VOP_FSYNC(bitmap_node
->vnode
,
1829 FSCRED
, FSYNC_WAIT
, 0, 0);
1832 printf( "Error writing out metadata partition unalloced "
1839 /* --------------------------------------------------------------------- */
1842 * Checks if ump's vds information is correct and complete
1846 udf_process_vds(struct udf_mount
*ump
) {
1847 union udf_pmap
*mapping
;
1848 /* struct udf_args *args = &ump->mount_args; */
1849 struct logvol_int_desc
*lvint
;
1850 struct udf_logvol_info
*lvinfo
;
1853 char *domain_name
, *map_name
;
1854 const char *check_name
;
1856 int pmap_stype
, pmap_size
;
1857 int pmap_type
, log_part
, phys_part
, raw_phys_part
, maps_on
;
1858 int n_phys
, n_virt
, n_spar
, n_meta
;
1864 /* we need at least an anchor (trivial, but for safety) */
1865 if (ump
->anchors
[0] == NULL
)
1868 /* we need at least one primary and one logical volume descriptor */
1869 if ((ump
->primary_vol
== NULL
) || (ump
->logical_vol
) == NULL
)
1872 /* we need at least one partition descriptor */
1873 if (ump
->partitions
[0] == NULL
)
1876 /* check logical volume sector size verses device sector size */
1877 if (udf_rw32(ump
->logical_vol
->lb_size
) != ump
->discinfo
.sector_size
) {
1878 printf("UDF mount: format violation, lb_size != sector size\n");
1882 /* check domain name */
1883 domain_name
= ump
->logical_vol
->domain_id
.id
;
1884 if (strncmp(domain_name
, "*OSTA UDF Compliant", 20)) {
1885 printf("mount_udf: disc not OSTA UDF Compliant, aborting\n");
1889 /* retrieve logical volume integrity sequence */
1890 (void)udf_retrieve_lvint(ump
);
1893 * We need at least one logvol integrity descriptor recorded. Note
1894 * that its OK to have an open logical volume integrity here. The VAT
1895 * will close/update the integrity.
1897 if (ump
->logvol_integrity
== NULL
)
1900 /* process derived structures */
1901 n_pm
= udf_rw32(ump
->logical_vol
->n_pm
); /* num partmaps */
1902 lvint
= ump
->logvol_integrity
;
1903 lvinfo
= (struct udf_logvol_info
*) (&lvint
->tables
[2 * n_pm
]);
1904 ump
->logvol_info
= lvinfo
;
1906 /* TODO check udf versions? */
1909 * check logvol mappings: effective virt->log partmap translation
1910 * check and recording of the mapping results. Saves expensive
1911 * strncmp() in tight places.
1913 DPRINTF(VOLUMES
, ("checking logvol mappings\n"));
1914 n_pm
= udf_rw32(ump
->logical_vol
->n_pm
); /* num partmaps */
1915 pmap_pos
= ump
->logical_vol
->maps
;
1917 if (n_pm
> UDF_PMAPS
) {
1918 printf("UDF mount: too many mappings\n");
1922 /* count types and set partition numbers */
1923 ump
->data_part
= ump
->node_part
= ump
->fids_part
= 0;
1924 n_phys
= n_virt
= n_spar
= n_meta
= 0;
1925 for (log_part
= 0; log_part
< n_pm
; log_part
++) {
1926 mapping
= (union udf_pmap
*) pmap_pos
;
1927 pmap_stype
= pmap_pos
[0];
1928 pmap_size
= pmap_pos
[1];
1929 switch (pmap_stype
) {
1930 case 1: /* physical mapping */
1931 /* volseq = udf_rw16(mapping->pm1.vol_seq_num); */
1932 raw_phys_part
= udf_rw16(mapping
->pm1
.part_num
);
1933 pmap_type
= UDF_VTOP_TYPE_PHYS
;
1935 ump
->data_part
= log_part
;
1936 ump
->node_part
= log_part
;
1937 ump
->fids_part
= log_part
;
1939 case 2: /* virtual/sparable/meta mapping */
1940 map_name
= mapping
->pm2
.part_id
.id
;
1941 /* volseq = udf_rw16(mapping->pm2.vol_seq_num); */
1942 raw_phys_part
= udf_rw16(mapping
->pm2
.part_num
);
1943 pmap_type
= UDF_VTOP_TYPE_UNKNOWN
;
1944 len
= UDF_REGID_ID_SIZE
;
1946 check_name
= "*UDF Virtual Partition";
1947 if (strncmp(map_name
, check_name
, len
) == 0) {
1948 pmap_type
= UDF_VTOP_TYPE_VIRT
;
1950 ump
->node_part
= log_part
;
1953 check_name
= "*UDF Sparable Partition";
1954 if (strncmp(map_name
, check_name
, len
) == 0) {
1955 pmap_type
= UDF_VTOP_TYPE_SPARABLE
;
1957 ump
->data_part
= log_part
;
1958 ump
->node_part
= log_part
;
1959 ump
->fids_part
= log_part
;
1962 check_name
= "*UDF Metadata Partition";
1963 if (strncmp(map_name
, check_name
, len
) == 0) {
1964 pmap_type
= UDF_VTOP_TYPE_META
;
1966 ump
->node_part
= log_part
;
1967 ump
->fids_part
= log_part
;
1976 * BUGALERT: some rogue implementations use random physical
1977 * partition numbers to break other implementations so lookup
1980 phys_part
= udf_find_raw_phys(ump
, raw_phys_part
);
1982 DPRINTF(VOLUMES
, ("\t%d -> %d(%d) type %d\n", log_part
,
1983 raw_phys_part
, phys_part
, pmap_type
));
1985 if (phys_part
== UDF_PARTITIONS
)
1987 if (pmap_type
== UDF_VTOP_TYPE_UNKNOWN
)
1990 ump
->vtop
[log_part
] = phys_part
;
1991 ump
->vtop_tp
[log_part
] = pmap_type
;
1993 pmap_pos
+= pmap_size
;
1995 /* not winning the beauty contest */
1996 ump
->vtop_tp
[UDF_VTOP_RAWPART
] = UDF_VTOP_TYPE_RAW
;
1998 /* test some basic UDF assertions/requirements */
1999 if ((n_virt
> 1) || (n_spar
> 1) || (n_meta
> 1))
2003 if ((n_phys
== 0) || n_spar
|| n_meta
)
2006 if (n_spar
+ n_phys
== 0)
2009 /* select allocation type for each logical partition */
2010 for (log_part
= 0; log_part
< n_pm
; log_part
++) {
2011 maps_on
= ump
->vtop
[log_part
];
2012 switch (ump
->vtop_tp
[log_part
]) {
2013 case UDF_VTOP_TYPE_PHYS
:
2014 assert(maps_on
== log_part
);
2015 ump
->vtop_alloc
[log_part
] = UDF_ALLOC_SPACEMAP
;
2017 case UDF_VTOP_TYPE_VIRT
:
2018 ump
->vtop_alloc
[log_part
] = UDF_ALLOC_VAT
;
2019 ump
->vtop_alloc
[maps_on
] = UDF_ALLOC_SEQUENTIAL
;
2021 case UDF_VTOP_TYPE_SPARABLE
:
2022 assert(maps_on
== log_part
);
2023 ump
->vtop_alloc
[log_part
] = UDF_ALLOC_SPACEMAP
;
2025 case UDF_VTOP_TYPE_META
:
2026 ump
->vtop_alloc
[log_part
] = UDF_ALLOC_METABITMAP
;
2027 if (ump
->discinfo
.mmc_cur
& MMC_CAP_PSEUDOOVERWRITE
) {
2028 /* special case for UDF 2.60 */
2029 ump
->vtop_alloc
[log_part
] = UDF_ALLOC_METASEQUENTIAL
;
2030 ump
->vtop_alloc
[maps_on
] = UDF_ALLOC_SEQUENTIAL
;
2034 panic("bad alloction type in udf's ump->vtop\n");
2038 /* determine logical volume open/closure actions */
2041 if (ump
->discinfo
.last_session_state
== MMC_STATE_EMPTY
)
2042 ump
->lvopen
|= UDF_OPEN_SESSION
;
2043 ump
->lvclose
= UDF_WRITE_VAT
;
2044 if (ump
->mount_args
.udfmflags
& UDFMNT_CLOSESESSION
)
2045 ump
->lvclose
|= UDF_CLOSE_SESSION
;
2047 /* `normal' rewritable or non sequential media */
2048 ump
->lvopen
= UDF_WRITE_LVINT
;
2049 ump
->lvclose
= UDF_WRITE_LVINT
;
2050 if ((ump
->discinfo
.mmc_cur
& MMC_CAP_REWRITABLE
) == 0)
2051 ump
->lvopen
|= UDF_APPENDONLY_LVINT
;
2052 if ((ump
->discinfo
.mmc_cur
& MMC_CAP_PSEUDOOVERWRITE
))
2053 ump
->lvopen
&= ~UDF_APPENDONLY_LVINT
;
2057 * Determine sheduler error behaviour. For virtual partitions, update
2058 * the trackinfo; for sparable partitions replace a whole block on the
2059 * sparable table. Allways requeue.
2061 ump
->lvreadwrite
= 0;
2063 ump
->lvreadwrite
= UDF_UPDATE_TRACKINFO
;
2065 ump
->lvreadwrite
= UDF_REMAP_BLOCK
;
2068 * Select our sheduler
2070 ump
->strategy
= &udf_strat_rmw
;
2071 if (n_virt
|| (ump
->discinfo
.mmc_cur
& MMC_CAP_PSEUDOOVERWRITE
))
2072 ump
->strategy
= &udf_strat_sequential
;
2073 if ((ump
->discinfo
.mmc_class
== MMC_CLASS_DISC
) ||
2074 (ump
->discinfo
.mmc_class
== MMC_CLASS_UNKN
))
2075 ump
->strategy
= &udf_strat_direct
;
2077 ump
->strategy
= &udf_strat_rmw
;
2080 /* read-only access won't benefit from the other shedulers */
2081 if (ump
->vfs_mountp
->mnt_flag
& MNT_RDONLY
)
2082 ump
->strategy
= &udf_strat_direct
;
2086 DPRINTF(VOLUMES
, ("\tdata partition %d\n", ump
->data_part
));
2087 DPRINTF(VOLUMES
, ("\t\talloc scheme %d\n", ump
->vtop_alloc
[ump
->data_part
]));
2088 DPRINTF(VOLUMES
, ("\tnode partition %d\n", ump
->node_part
));
2089 DPRINTF(VOLUMES
, ("\t\talloc scheme %d\n", ump
->vtop_alloc
[ump
->node_part
]));
2090 DPRINTF(VOLUMES
, ("\tfids partition %d\n", ump
->fids_part
));
2091 DPRINTF(VOLUMES
, ("\t\talloc scheme %d\n", ump
->vtop_alloc
[ump
->fids_part
]));
2093 snprintb(bits
, sizeof(bits
), UDFLOGVOL_BITS
, ump
->lvopen
);
2094 DPRINTF(VOLUMES
, ("\tactions on logvol open %s\n", bits
));
2095 snprintb(bits
, sizeof(bits
), UDFLOGVOL_BITS
, ump
->lvclose
);
2096 DPRINTF(VOLUMES
, ("\tactions on logvol close %s\n", bits
));
2097 snprintb(bits
, sizeof(bits
), UDFONERROR_BITS
, ump
->lvreadwrite
);
2098 DPRINTF(VOLUMES
, ("\tactions on logvol errors %s\n", bits
));
2100 DPRINTF(VOLUMES
, ("\tselected sheduler `%s`\n",
2101 (ump
->strategy
== &udf_strat_direct
) ? "Direct" :
2102 (ump
->strategy
== &udf_strat_sequential
) ? "Sequential" :
2103 (ump
->strategy
== &udf_strat_rmw
) ? "RMW" : "UNKNOWN!"));
2105 /* signal its OK for now */
2109 /* --------------------------------------------------------------------- */
2112 * Update logical volume name in all structures that keep a record of it. We
2113 * use memmove since each of them might be specified as a source.
2115 * Note that it doesn't update the VAT structure!
2119 udf_update_logvolname(struct udf_mount
*ump
, char *logvol_id
)
2121 struct logvol_desc
*lvd
= NULL
;
2122 struct fileset_desc
*fsd
= NULL
;
2123 struct udf_lv_info
*lvi
= NULL
;
2125 DPRINTF(VOLUMES
, ("Updating logical volume name\n"));
2126 lvd
= ump
->logical_vol
;
2127 fsd
= ump
->fileset_desc
;
2128 if (ump
->implementation
)
2129 lvi
= &ump
->implementation
->_impl_use
.lv_info
;
2131 /* logvol's id might be specified as origional so use memmove here */
2132 memmove(lvd
->logvol_id
, logvol_id
, 128);
2134 memmove(fsd
->logvol_id
, logvol_id
, 128);
2136 memmove(lvi
->logvol_id
, logvol_id
, 128);
2139 /* --------------------------------------------------------------------- */
2142 udf_inittag(struct udf_mount
*ump
, struct desc_tag
*tag
, int tagid
,
2145 assert(ump
->logical_vol
);
2147 tag
->id
= udf_rw16(tagid
);
2148 tag
->descriptor_ver
= ump
->logical_vol
->tag
.descriptor_ver
;
2151 tag
->serial_num
= ump
->logical_vol
->tag
.serial_num
;
2152 tag
->tag_loc
= udf_rw32(sector
);
2157 udf_advance_uniqueid(struct udf_mount
*ump
)
2161 mutex_enter(&ump
->logvol_mutex
);
2162 unique_id
= udf_rw64(ump
->logvol_integrity
->lvint_next_unique_id
);
2163 if (unique_id
< 0x10)
2165 ump
->logvol_integrity
->lvint_next_unique_id
= udf_rw64(unique_id
+ 1);
2166 mutex_exit(&ump
->logvol_mutex
);
2173 udf_adjust_filecount(struct udf_node
*udf_node
, int sign
)
2175 struct udf_mount
*ump
= udf_node
->ump
;
2176 uint32_t num_dirs
, num_files
;
2181 udf_file_type
= udf_node
->fe
->icbtag
.file_type
;
2183 udf_file_type
= udf_node
->efe
->icbtag
.file_type
;
2186 /* adjust file count */
2187 mutex_enter(&ump
->allocate_mutex
);
2188 if (udf_file_type
== UDF_ICB_FILETYPE_DIRECTORY
) {
2189 num_dirs
= udf_rw32(ump
->logvol_info
->num_directories
);
2190 ump
->logvol_info
->num_directories
=
2191 udf_rw32((num_dirs
+ sign
));
2193 num_files
= udf_rw32(ump
->logvol_info
->num_files
);
2194 ump
->logvol_info
->num_files
=
2195 udf_rw32((num_files
+ sign
));
2197 mutex_exit(&ump
->allocate_mutex
);
2202 udf_osta_charset(struct charspec
*charspec
)
2204 memset(charspec
, 0, sizeof(struct charspec
));
2206 strcpy((char *) charspec
->inf
, "OSTA Compressed Unicode");
2210 /* first call udf_set_regid and then the suffix */
2212 udf_set_regid(struct regid
*regid
, char const *name
)
2214 memset(regid
, 0, sizeof(struct regid
));
2215 regid
->flags
= 0; /* not dirty and not protected */
2216 strcpy((char *) regid
->id
, name
);
2221 udf_add_domain_regid(struct udf_mount
*ump
, struct regid
*regid
)
2225 ver
= (uint16_t *) regid
->id_suffix
;
2226 *ver
= ump
->logvol_info
->min_udf_readver
;
2231 udf_add_udf_regid(struct udf_mount
*ump
, struct regid
*regid
)
2235 ver
= (uint16_t *) regid
->id_suffix
;
2236 *ver
= ump
->logvol_info
->min_udf_readver
;
2238 regid
->id_suffix
[2] = 4; /* unix */
2239 regid
->id_suffix
[3] = 8; /* NetBSD */
2244 udf_add_impl_regid(struct udf_mount
*ump
, struct regid
*regid
)
2246 regid
->id_suffix
[0] = 4; /* unix */
2247 regid
->id_suffix
[1] = 8; /* NetBSD */
2252 udf_add_app_regid(struct udf_mount
*ump
, struct regid
*regid
)
2254 regid
->id_suffix
[0] = APP_VERSION_MAIN
;
2255 regid
->id_suffix
[1] = APP_VERSION_SUB
;
2259 udf_create_parentfid(struct udf_mount
*ump
, struct fileid_desc
*fid
,
2260 struct long_ad
*parent
, uint64_t unique_id
)
2262 /* the size of an empty FID is 38 but needs to be a multiple of 4 */
2265 udf_inittag(ump
, &fid
->tag
, TAGID_FID
, udf_rw32(parent
->loc
.lb_num
));
2266 fid
->file_version_num
= udf_rw16(1); /* UDF 2.3.4.1 */
2267 fid
->file_char
= UDF_FILE_CHAR_DIR
| UDF_FILE_CHAR_PAR
;
2269 fid
->icb
.longad_uniqueid
= udf_rw32((uint32_t) unique_id
);
2270 fid
->tag
.desc_crc_len
= udf_rw16(fidsize
- UDF_DESC_TAG_LENGTH
);
2271 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) fid
);
2276 /* --------------------------------------------------------------------- */
2279 * Extended attribute support. UDF knows of 3 places for extended attributes:
2281 * (a) inside the file's (e)fe in the length of the extended attribute area
2282 * before the allocation descriptors/filedata
2284 * (b) in a file referenced by (e)fe->ext_attr_icb and
2286 * (c) in the e(fe)'s associated stream directory that can hold various
2287 * sub-files. In the stream directory a few fixed named subfiles are reserved
2288 * for NT/Unix ACL's and OS/2 attributes.
2290 * NOTE: Extended attributes are read randomly but allways written
2291 * *atomicaly*. For ACL's this interface is propably different but not known
2294 * Order of extended attributes in a space :
2296 * Non block aligned Implementation Use EAs
2297 * Block aligned Implementation Use EAs
2298 * Application Use EAs
2302 udf_impl_extattr_check(struct impl_extattr_entry
*implext
)
2306 if (strncmp(implext
->imp_id
.id
, "*UDF", 4) == 0) {
2307 /* checksum valid? */
2308 DPRINTF(EXTATTR
, ("checking UDF impl. attr checksum\n"));
2309 spos
= (uint16_t *) implext
->data
;
2310 if (udf_rw16(*spos
) != udf_ea_cksum((uint8_t *) implext
))
2317 udf_calc_impl_extattr_checksum(struct impl_extattr_entry
*implext
)
2321 if (strncmp(implext
->imp_id
.id
, "*UDF", 4) == 0) {
2323 spos
= (uint16_t *) implext
->data
;
2324 *spos
= udf_rw16(udf_ea_cksum((uint8_t *) implext
));
2330 udf_extattr_search_intern(struct udf_node
*node
,
2331 uint32_t sattr
, char const *sattrname
,
2332 uint32_t *offsetp
, uint32_t *lengthp
)
2334 struct extattrhdr_desc
*eahdr
;
2335 struct extattr_entry
*attrhdr
;
2336 struct impl_extattr_entry
*implext
;
2337 uint32_t offset
, a_l
, sector_size
;
2342 /* get mountpoint */
2343 sector_size
= node
->ump
->discinfo
.sector_size
;
2345 /* get information from fe/efe */
2347 l_ea
= udf_rw32(node
->fe
->l_ea
);
2348 eahdr
= (struct extattrhdr_desc
*) node
->fe
->data
;
2351 l_ea
= udf_rw32(node
->efe
->l_ea
);
2352 eahdr
= (struct extattrhdr_desc
*) node
->efe
->data
;
2355 /* something recorded here? */
2359 /* check extended attribute tag; what to do if it fails? */
2360 error
= udf_check_tag(eahdr
);
2363 if (udf_rw16(eahdr
->tag
.id
) != TAGID_EXTATTR_HDR
)
2365 error
= udf_check_tag_payload(eahdr
, sizeof(struct extattrhdr_desc
));
2369 DPRINTF(EXTATTR
, ("Found %d bytes of extended attributes\n", l_ea
));
2371 /* looking for Ecma-167 attributes? */
2372 offset
= sizeof(struct extattrhdr_desc
);
2374 /* looking for either implemenation use or application use */
2375 if (sattr
== 2048) { /* [4/48.10.8] */
2376 offset
= udf_rw32(eahdr
->impl_attr_loc
);
2377 if (offset
== UDF_IMPL_ATTR_LOC_NOT_PRESENT
)
2380 if (sattr
== 65536) { /* [4/48.10.9] */
2381 offset
= udf_rw32(eahdr
->appl_attr_loc
);
2382 if (offset
== UDF_APPL_ATTR_LOC_NOT_PRESENT
)
2386 /* paranoia check offset and l_ea */
2387 if (l_ea
+ offset
>= sector_size
- sizeof(struct extattr_entry
))
2390 DPRINTF(EXTATTR
, ("Starting at offset %d\n", offset
));
2392 /* find our extended attribute */
2394 pos
= (uint8_t *) eahdr
+ offset
;
2396 while (l_ea
>= sizeof(struct extattr_entry
)) {
2397 DPRINTF(EXTATTR
, ("%d extended attr bytes left\n", l_ea
));
2398 attrhdr
= (struct extattr_entry
*) pos
;
2399 implext
= (struct impl_extattr_entry
*) pos
;
2401 /* get complete attribute length and check for roque values */
2402 a_l
= udf_rw32(attrhdr
->a_l
);
2403 DPRINTF(EXTATTR
, ("attribute %d:%d, len %d/%d\n",
2404 udf_rw32(attrhdr
->type
),
2405 attrhdr
->subtype
, a_l
, l_ea
));
2406 if ((a_l
== 0) || (a_l
> l_ea
))
2409 if (attrhdr
->type
!= sattr
)
2410 goto next_attribute
;
2412 /* we might have found it! */
2413 if (attrhdr
->type
< 2048) { /* Ecma-167 attribute */
2416 return 0; /* success */
2420 * Implementation use and application use extended attributes
2421 * have a name to identify. They share the same structure only
2422 * UDF implementation use extended attributes have a checksum
2426 DPRINTF(EXTATTR
, ("named attribute %s\n", implext
->imp_id
.id
));
2427 if (strcmp(implext
->imp_id
.id
, sattrname
) == 0) {
2428 /* we have found our appl/implementation attribute */
2431 return 0; /* success */
2435 /* next attribute */
2446 udf_extattr_insert_internal(struct udf_mount
*ump
, union dscrptr
*dscr
,
2447 struct extattr_entry
*extattr
)
2449 struct file_entry
*fe
;
2450 struct extfile_entry
*efe
;
2451 struct extattrhdr_desc
*extattrhdr
;
2452 struct impl_extattr_entry
*implext
;
2453 uint32_t impl_attr_loc
, appl_attr_loc
, l_ea
, a_l
, exthdr_len
;
2454 uint32_t *l_eap
, l_ad
;
2456 uint8_t *bpos
, *data
;
2458 if (udf_rw16(dscr
->tag
.id
) == TAGID_FENTRY
) {
2462 l_ad
= udf_rw32(fe
->l_ad
);
2463 } else if (udf_rw16(dscr
->tag
.id
) == TAGID_EXTFENTRY
) {
2467 l_ad
= udf_rw32(efe
->l_ad
);
2469 panic("Bad tag passed to udf_extattr_insert_internal");
2472 /* can't append already written to file descriptors yet */
2476 /* should have a header! */
2477 extattrhdr
= (struct extattrhdr_desc
*) data
;
2478 l_ea
= udf_rw32(*l_eap
);
2480 /* create empty extended attribute header */
2481 exthdr_len
= sizeof(struct extattrhdr_desc
);
2483 udf_inittag(ump
, &extattrhdr
->tag
, TAGID_EXTATTR_HDR
,
2485 extattrhdr
->impl_attr_loc
= udf_rw32(exthdr_len
);
2486 extattrhdr
->appl_attr_loc
= udf_rw32(exthdr_len
);
2487 extattrhdr
->tag
.desc_crc_len
= udf_rw16(8);
2489 /* record extended attribute header length */
2491 *l_eap
= udf_rw32(l_ea
);
2494 /* extract locations */
2495 impl_attr_loc
= udf_rw32(extattrhdr
->impl_attr_loc
);
2496 appl_attr_loc
= udf_rw32(extattrhdr
->appl_attr_loc
);
2497 if (impl_attr_loc
== UDF_IMPL_ATTR_LOC_NOT_PRESENT
)
2498 impl_attr_loc
= l_ea
;
2499 if (appl_attr_loc
== UDF_IMPL_ATTR_LOC_NOT_PRESENT
)
2500 appl_attr_loc
= l_ea
;
2503 if (udf_rw32(extattr
->type
) < 2048) {
2504 assert(impl_attr_loc
== l_ea
);
2505 assert(appl_attr_loc
== l_ea
);
2508 /* implementation use extended attributes */
2509 if (udf_rw32(extattr
->type
) == 2048) {
2510 assert(appl_attr_loc
== l_ea
);
2512 /* calculate and write extended attribute header checksum */
2513 implext
= (struct impl_extattr_entry
*) extattr
;
2514 assert(udf_rw32(implext
->iu_l
) == 4); /* [UDF 3.3.4.5] */
2515 spos
= (uint16_t *) implext
->data
;
2516 *spos
= udf_rw16(udf_ea_cksum((uint8_t *) implext
));
2519 /* application use extended attributes */
2520 assert(udf_rw32(extattr
->type
) != 65536);
2521 assert(appl_attr_loc
== l_ea
);
2523 /* append the attribute at the end of the current space */
2524 bpos
= data
+ udf_rw32(*l_eap
);
2525 a_l
= udf_rw32(extattr
->a_l
);
2527 /* update impl. attribute locations */
2528 if (udf_rw32(extattr
->type
) < 2048) {
2529 impl_attr_loc
= l_ea
+ a_l
;
2530 appl_attr_loc
= l_ea
+ a_l
;
2532 if (udf_rw32(extattr
->type
) == 2048) {
2533 appl_attr_loc
= l_ea
+ a_l
;
2536 /* copy and advance */
2537 memcpy(bpos
, extattr
, a_l
);
2539 *l_eap
= udf_rw32(l_ea
);
2541 /* do the `dance` again backwards */
2542 if (udf_rw16(ump
->logical_vol
->tag
.descriptor_ver
) != 2) {
2543 if (impl_attr_loc
== l_ea
)
2544 impl_attr_loc
= UDF_IMPL_ATTR_LOC_NOT_PRESENT
;
2545 if (appl_attr_loc
== l_ea
)
2546 appl_attr_loc
= UDF_APPL_ATTR_LOC_NOT_PRESENT
;
2550 extattrhdr
->impl_attr_loc
= udf_rw32(impl_attr_loc
);
2551 extattrhdr
->appl_attr_loc
= udf_rw32(appl_attr_loc
);
2555 /* --------------------------------------------------------------------- */
2558 udf_update_lvid_from_vat_extattr(struct udf_node
*vat_node
)
2560 struct udf_mount
*ump
;
2561 struct udf_logvol_info
*lvinfo
;
2562 struct impl_extattr_entry
*implext
;
2563 struct vatlvext_extattr_entry lvext
;
2564 const char *extstr
= "*UDF VAT LVExtension";
2565 uint64_t vat_uniqueid
;
2566 uint32_t offset
, a_l
;
2567 uint8_t *ea_start
, *lvextpos
;
2570 /* get mountpoint and lvinfo */
2571 ump
= vat_node
->ump
;
2572 lvinfo
= ump
->logvol_info
;
2574 /* get information from fe/efe */
2576 vat_uniqueid
= udf_rw64(vat_node
->fe
->unique_id
);
2577 ea_start
= vat_node
->fe
->data
;
2579 vat_uniqueid
= udf_rw64(vat_node
->efe
->unique_id
);
2580 ea_start
= vat_node
->efe
->data
;
2583 error
= udf_extattr_search_intern(vat_node
, 2048, extstr
, &offset
, &a_l
);
2587 implext
= (struct impl_extattr_entry
*) (ea_start
+ offset
);
2588 error
= udf_impl_extattr_check(implext
);
2593 if (a_l
!= sizeof(*implext
) -1 + udf_rw32(implext
->iu_l
) + sizeof(lvext
)) {
2594 DPRINTF(VOLUMES
, ("VAT LVExtension size doesn't compute\n"));
2599 * we have found our "VAT LVExtension attribute. BUT due to a
2600 * bug in the specification it might not be word aligned so
2601 * copy first to avoid panics on some machines (!!)
2603 DPRINTF(VOLUMES
, ("Found VAT LVExtension attr\n"));
2604 lvextpos
= implext
->data
+ udf_rw32(implext
->iu_l
);
2605 memcpy(&lvext
, lvextpos
, sizeof(lvext
));
2607 /* check if it was updated the last time */
2608 if (udf_rw64(lvext
.unique_id_chk
) == vat_uniqueid
) {
2609 lvinfo
->num_files
= lvext
.num_files
;
2610 lvinfo
->num_directories
= lvext
.num_directories
;
2611 udf_update_logvolname(ump
, lvext
.logvol_id
);
2613 DPRINTF(VOLUMES
, ("VAT LVExtension out of date\n"));
2614 /* replace VAT LVExt by free space EA */
2615 memset(implext
->imp_id
.id
, 0, UDF_REGID_ID_SIZE
);
2616 strcpy(implext
->imp_id
.id
, "*UDF FreeEASpace");
2617 udf_calc_impl_extattr_checksum(implext
);
2625 udf_update_vat_extattr_from_lvid(struct udf_node
*vat_node
)
2627 struct udf_mount
*ump
;
2628 struct udf_logvol_info
*lvinfo
;
2629 struct impl_extattr_entry
*implext
;
2630 struct vatlvext_extattr_entry lvext
;
2631 const char *extstr
= "*UDF VAT LVExtension";
2632 uint64_t vat_uniqueid
;
2633 uint32_t offset
, a_l
;
2634 uint8_t *ea_start
, *lvextpos
;
2637 /* get mountpoint and lvinfo */
2638 ump
= vat_node
->ump
;
2639 lvinfo
= ump
->logvol_info
;
2641 /* get information from fe/efe */
2643 vat_uniqueid
= udf_rw64(vat_node
->fe
->unique_id
);
2644 ea_start
= vat_node
->fe
->data
;
2646 vat_uniqueid
= udf_rw64(vat_node
->efe
->unique_id
);
2647 ea_start
= vat_node
->efe
->data
;
2650 error
= udf_extattr_search_intern(vat_node
, 2048, extstr
, &offset
, &a_l
);
2653 /* found, it existed */
2656 implext
= (struct impl_extattr_entry
*) (ea_start
+ offset
);
2657 error
= udf_impl_extattr_check(implext
);
2659 DPRINTF(VOLUMES
, ("VAT LVExtension bad on update\n"));
2665 * we have found our "VAT LVExtension attribute. BUT due to a
2666 * bug in the specification it might not be word aligned so
2667 * copy first to avoid panics on some machines (!!)
2669 DPRINTF(VOLUMES
, ("Updating VAT LVExtension attr\n"));
2670 lvextpos
= implext
->data
+ udf_rw32(implext
->iu_l
);
2672 lvext
.unique_id_chk
= vat_uniqueid
;
2673 lvext
.num_files
= lvinfo
->num_files
;
2674 lvext
.num_directories
= lvinfo
->num_directories
;
2675 memmove(lvext
.logvol_id
, ump
->logical_vol
->logvol_id
, 128);
2677 memcpy(lvextpos
, &lvext
, sizeof(lvext
));
2682 /* --------------------------------------------------------------------- */
2685 udf_vat_read(struct udf_node
*vat_node
, uint8_t *blob
, int size
, uint32_t offset
)
2687 struct udf_mount
*ump
= vat_node
->ump
;
2689 if (offset
+ size
> ump
->vat_offset
+ ump
->vat_entries
* 4)
2692 memcpy(blob
, ump
->vat_table
+ offset
, size
);
2697 udf_vat_write(struct udf_node
*vat_node
, uint8_t *blob
, int size
, uint32_t offset
)
2699 struct udf_mount
*ump
= vat_node
->ump
;
2700 uint32_t offset_high
;
2701 uint8_t *new_vat_table
;
2703 /* extent VAT allocation if needed */
2704 offset_high
= offset
+ size
;
2705 if (offset_high
>= ump
->vat_table_alloc_len
) {
2707 new_vat_table
= realloc(ump
->vat_table
,
2708 ump
->vat_table_alloc_len
+ UDF_VAT_CHUNKSIZE
,
2709 M_UDFVOLD
, M_WAITOK
| M_CANFAIL
);
2710 if (!new_vat_table
) {
2711 printf("udf_vat_write: can't extent VAT, out of mem\n");
2714 ump
->vat_table
= new_vat_table
;
2715 ump
->vat_table_alloc_len
+= UDF_VAT_CHUNKSIZE
;
2717 ump
->vat_table_len
= MAX(ump
->vat_table_len
, offset_high
);
2719 memcpy(ump
->vat_table
+ offset
, blob
, size
);
2723 /* --------------------------------------------------------------------- */
2725 /* TODO support previous VAT location writeout */
2727 udf_update_vat_descriptor(struct udf_mount
*ump
)
2729 struct udf_node
*vat_node
= ump
->vat_node
;
2730 struct udf_logvol_info
*lvinfo
= ump
->logvol_info
;
2731 struct icb_tag
*icbtag
;
2732 struct udf_oldvat_tail
*oldvat_tl
;
2733 struct udf_vat
*vat
;
2737 int filetype
, error
;
2741 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
2743 /* get our new unique_id */
2744 unique_id
= udf_advance_uniqueid(ump
);
2746 /* get information from fe/efe */
2748 icbtag
= &vat_node
->fe
->icbtag
;
2749 vat_node
->fe
->unique_id
= udf_rw64(unique_id
);
2751 icbtag
= &vat_node
->efe
->icbtag
;
2752 vat_node
->efe
->unique_id
= udf_rw64(unique_id
);
2755 /* Check icb filetype! it has to be 0 or UDF_ICB_FILETYPE_VAT */
2756 filetype
= icbtag
->file_type
;
2757 KASSERT((filetype
== 0) || (filetype
== UDF_ICB_FILETYPE_VAT
));
2759 /* allocate piece to process head or tail of VAT file */
2760 raw_vat
= malloc(lb_size
, M_TEMP
, M_WAITOK
);
2762 if (filetype
== 0) {
2764 * Update "*UDF VAT LVExtension" extended attribute from the
2767 udf_update_vat_extattr_from_lvid(vat_node
);
2769 /* setup identifying regid */
2770 oldvat_tl
= (struct udf_oldvat_tail
*) raw_vat
;
2771 memset(oldvat_tl
, 0, sizeof(struct udf_oldvat_tail
));
2773 udf_set_regid(&oldvat_tl
->id
, "*UDF Virtual Alloc Tbl");
2774 udf_add_udf_regid(ump
, &oldvat_tl
->id
);
2775 oldvat_tl
->prev_vat
= udf_rw32(0xffffffff);
2777 /* write out new tail of virtual allocation table file */
2778 error
= udf_vat_write(vat_node
, raw_vat
,
2779 sizeof(struct udf_oldvat_tail
), ump
->vat_entries
* 4);
2781 /* compose the VAT2 header */
2782 vat
= (struct udf_vat
*) raw_vat
;
2783 memset(vat
, 0, sizeof(struct udf_vat
));
2785 vat
->header_len
= udf_rw16(152); /* as per spec */
2786 vat
->impl_use_len
= udf_rw16(0);
2787 memmove(vat
->logvol_id
, ump
->logical_vol
->logvol_id
, 128);
2788 vat
->prev_vat
= udf_rw32(0xffffffff);
2789 vat
->num_files
= lvinfo
->num_files
;
2790 vat
->num_directories
= lvinfo
->num_directories
;
2791 vat
->min_udf_readver
= lvinfo
->min_udf_readver
;
2792 vat
->min_udf_writever
= lvinfo
->min_udf_writever
;
2793 vat
->max_udf_writever
= lvinfo
->max_udf_writever
;
2795 error
= udf_vat_write(vat_node
, raw_vat
,
2796 sizeof(struct udf_vat
), 0);
2798 free(raw_vat
, M_TEMP
);
2800 return error
; /* success! */
2805 udf_writeout_vat(struct udf_mount
*ump
)
2807 struct udf_node
*vat_node
= ump
->vat_node
;
2812 DPRINTF(CALL
, ("udf_writeout_vat\n"));
2814 // mutex_enter(&ump->allocate_mutex);
2815 udf_update_vat_descriptor(ump
);
2817 /* write out the VAT contents ; TODO intelligent writing */
2818 error
= vn_rdwr(UIO_WRITE
, vat_node
->vnode
,
2819 ump
->vat_table
, ump
->vat_table_len
, 0,
2820 UIO_SYSSPACE
, 0, FSCRED
, NULL
, NULL
);
2822 printf("udf_writeout_vat: failed to write out VAT contents\n");
2826 // mutex_exit(&ump->allocate_mutex);
2828 error
= vflushbuf(ump
->vat_node
->vnode
, FSYNC_WAIT
);
2831 error
= VOP_FSYNC(ump
->vat_node
->vnode
,
2832 FSCRED
, FSYNC_WAIT
, 0, 0);
2834 printf("udf_writeout_vat: error writing VAT node!\n");
2840 /* --------------------------------------------------------------------- */
2843 * Read in relevant pieces of VAT file and check if its indeed a VAT file
2844 * descriptor. If OK, read in complete VAT file.
2848 udf_check_for_vat(struct udf_node
*vat_node
)
2850 struct udf_mount
*ump
;
2851 struct icb_tag
*icbtag
;
2852 struct timestamp
*mtime
;
2853 struct udf_vat
*vat
;
2854 struct udf_oldvat_tail
*oldvat_tl
;
2855 struct udf_logvol_info
*lvinfo
;
2857 uint32_t vat_length
;
2858 uint32_t vat_offset
, vat_entries
, vat_table_alloc_len
;
2859 uint32_t sector_size
;
2866 /* vat_length is really 64 bits though impossible */
2868 DPRINTF(VOLUMES
, ("Checking for VAT\n"));
2872 /* get mount info */
2873 ump
= vat_node
->ump
;
2874 sector_size
= udf_rw32(ump
->logical_vol
->lb_size
);
2876 /* check assertions */
2877 assert(vat_node
->fe
|| vat_node
->efe
);
2878 assert(ump
->logvol_integrity
);
2880 /* set vnode type to regular file or we can't read from it! */
2881 vat_node
->vnode
->v_type
= VREG
;
2883 /* get information from fe/efe */
2885 vat_length
= udf_rw64(vat_node
->fe
->inf_len
);
2886 icbtag
= &vat_node
->fe
->icbtag
;
2887 mtime
= &vat_node
->fe
->mtime
;
2888 unique_id
= udf_rw64(vat_node
->fe
->unique_id
);
2890 vat_length
= udf_rw64(vat_node
->efe
->inf_len
);
2891 icbtag
= &vat_node
->efe
->icbtag
;
2892 mtime
= &vat_node
->efe
->mtime
;
2893 unique_id
= udf_rw64(vat_node
->efe
->unique_id
);
2896 /* Check icb filetype! it has to be 0 or UDF_ICB_FILETYPE_VAT */
2897 filetype
= icbtag
->file_type
;
2898 if ((filetype
!= 0) && (filetype
!= UDF_ICB_FILETYPE_VAT
))
2901 DPRINTF(VOLUMES
, ("\tPossible VAT length %d\n", vat_length
));
2903 vat_table_alloc_len
=
2904 ((vat_length
+ UDF_VAT_CHUNKSIZE
-1) / UDF_VAT_CHUNKSIZE
)
2905 * UDF_VAT_CHUNKSIZE
;
2907 vat_table
= malloc(vat_table_alloc_len
, M_UDFVOLD
,
2908 M_CANFAIL
| M_WAITOK
);
2909 if (vat_table
== NULL
) {
2910 printf("allocation of %d bytes failed for VAT\n",
2911 vat_table_alloc_len
);
2915 /* allocate piece to read in head or tail of VAT file */
2916 raw_vat
= malloc(sector_size
, M_TEMP
, M_WAITOK
);
2919 * check contents of the file if its the old 1.50 VAT table format.
2920 * Its notoriously broken and allthough some implementations support an
2921 * extention as defined in the UDF 1.50 errata document, its doubtfull
2922 * to be useable since a lot of implementations don't maintain it.
2924 lvinfo
= ump
->logvol_info
;
2926 if (filetype
== 0) {
2929 vat_entries
= (vat_length
-36)/4;
2931 /* read in tail of virtual allocation table file */
2932 error
= vn_rdwr(UIO_READ
, vat_node
->vnode
,
2933 (uint8_t *) raw_vat
,
2934 sizeof(struct udf_oldvat_tail
),
2936 UIO_SYSSPACE
, IO_SYNC
| IO_NODELOCKED
, FSCRED
,
2941 /* check 1.50 VAT */
2942 oldvat_tl
= (struct udf_oldvat_tail
*) raw_vat
;
2943 regid_name
= (char *) oldvat_tl
->id
.id
;
2944 error
= strncmp(regid_name
, "*UDF Virtual Alloc Tbl", 22);
2946 DPRINTF(VOLUMES
, ("VAT format 1.50 rejected\n"));
2952 * update LVID from "*UDF VAT LVExtension" extended attribute
2955 udf_update_lvid_from_vat_extattr(vat_node
);
2957 /* read in head of virtual allocation table file */
2958 error
= vn_rdwr(UIO_READ
, vat_node
->vnode
,
2959 (uint8_t *) raw_vat
,
2960 sizeof(struct udf_vat
), 0,
2961 UIO_SYSSPACE
, IO_SYNC
| IO_NODELOCKED
, FSCRED
,
2967 vat
= (struct udf_vat
*) raw_vat
;
2968 vat_offset
= vat
->header_len
;
2969 vat_entries
= (vat_length
- vat_offset
)/4;
2972 lvinfo
->num_files
= vat
->num_files
;
2973 lvinfo
->num_directories
= vat
->num_directories
;
2974 lvinfo
->min_udf_readver
= vat
->min_udf_readver
;
2975 lvinfo
->min_udf_writever
= vat
->min_udf_writever
;
2976 lvinfo
->max_udf_writever
= vat
->max_udf_writever
;
2978 udf_update_logvolname(ump
, vat
->logvol_id
);
2981 /* read in complete VAT file */
2982 error
= vn_rdwr(UIO_READ
, vat_node
->vnode
,
2985 UIO_SYSSPACE
, IO_SYNC
| IO_NODELOCKED
, FSCRED
,
2988 printf("read in of complete VAT file failed (error %d)\n",
2993 DPRINTF(VOLUMES
, ("VAT format accepted, marking it closed\n"));
2994 ump
->logvol_integrity
->lvint_next_unique_id
= udf_rw64(unique_id
);
2995 ump
->logvol_integrity
->integrity_type
= udf_rw32(UDF_INTEGRITY_CLOSED
);
2996 ump
->logvol_integrity
->time
= *mtime
;
2998 ump
->vat_table_len
= vat_length
;
2999 ump
->vat_table_alloc_len
= vat_table_alloc_len
;
3000 ump
->vat_table
= vat_table
;
3001 ump
->vat_offset
= vat_offset
;
3002 ump
->vat_entries
= vat_entries
;
3003 ump
->vat_last_free_lb
= 0; /* start at beginning */
3008 free(vat_table
, M_UDFVOLD
);
3010 free(raw_vat
, M_TEMP
);
3015 /* --------------------------------------------------------------------- */
3018 udf_search_vat(struct udf_mount
*ump
, union udf_pmap
*mapping
)
3020 struct udf_node
*vat_node
;
3021 struct long_ad icb_loc
;
3022 uint32_t early_vat_loc
, vat_loc
;
3025 /* mapping info not needed */
3028 vat_loc
= ump
->last_possible_vat_location
;
3029 early_vat_loc
= vat_loc
- 256; /* 8 blocks of 32 sectors */
3031 DPRINTF(VOLUMES
, ("1) last possible %d, early_vat_loc %d \n",
3032 vat_loc
, early_vat_loc
));
3033 early_vat_loc
= MAX(early_vat_loc
, ump
->first_possible_vat_location
);
3035 DPRINTF(VOLUMES
, ("2) last possible %d, early_vat_loc %d \n",
3036 vat_loc
, early_vat_loc
));
3038 /* start looking from the end of the range */
3040 DPRINTF(VOLUMES
, ("Checking for VAT at sector %d\n", vat_loc
));
3041 icb_loc
.loc
.part_num
= udf_rw16(UDF_VTOP_RAWPART
);
3042 icb_loc
.loc
.lb_num
= udf_rw32(vat_loc
);
3044 error
= udf_get_node(ump
, &icb_loc
, &vat_node
);
3046 error
= udf_check_for_vat(vat_node
);
3047 DPRINTFIF(VOLUMES
, !error
,
3048 ("VAT accepted at %d\n", vat_loc
));
3053 vput(vat_node
->vnode
);
3056 vat_loc
--; /* walk backwards */
3057 } while (vat_loc
>= early_vat_loc
);
3059 /* keep our VAT node around */
3061 UDF_SET_SYSTEMFILE(vat_node
->vnode
);
3062 ump
->vat_node
= vat_node
;
3068 /* --------------------------------------------------------------------- */
3071 udf_read_sparables(struct udf_mount
*ump
, union udf_pmap
*mapping
)
3073 union dscrptr
*dscr
;
3074 struct part_map_spare
*pms
= &mapping
->pms
;
3079 * The partition mapping passed on to us specifies the information we
3080 * need to locate and initialise the sparable partition mapping
3081 * information we need.
3084 DPRINTF(VOLUMES
, ("Read sparable table\n"));
3085 ump
->sparable_packet_size
= udf_rw16(pms
->packet_len
);
3086 KASSERT(ump
->sparable_packet_size
>= ump
->packet_size
); /* XXX */
3088 for (spar
= 0; spar
< pms
->n_st
; spar
++) {
3089 lb_num
= pms
->st_loc
[spar
];
3090 DPRINTF(VOLUMES
, ("Checking for sparing table %d\n", lb_num
));
3091 error
= udf_read_phys_dscr(ump
, lb_num
, M_UDFVOLD
, &dscr
);
3092 if (!error
&& dscr
) {
3093 if (udf_rw16(dscr
->tag
.id
) == TAGID_SPARING_TABLE
) {
3094 if (ump
->sparing_table
)
3095 free(ump
->sparing_table
, M_UDFVOLD
);
3096 ump
->sparing_table
= &dscr
->spt
;
3099 ("Sparing table accepted (%d entries)\n",
3100 udf_rw16(ump
->sparing_table
->rt_l
)));
3101 break; /* we're done */
3105 free(dscr
, M_UDFVOLD
);
3108 if (ump
->sparing_table
)
3114 /* --------------------------------------------------------------------- */
3117 udf_read_metadata_nodes(struct udf_mount
*ump
, union udf_pmap
*mapping
)
3119 struct part_map_meta
*pmm
= &mapping
->pmm
;
3120 struct long_ad icb_loc
;
3122 uint16_t raw_phys_part
, phys_part
;
3126 * BUGALERT: some rogue implementations use random physical
3127 * partition numbers to break other implementations so lookup
3131 /* extract our allocation parameters set up on format */
3132 ump
->metadata_alloc_unit_size
= udf_rw32(mapping
->pmm
.alloc_unit_size
);
3133 ump
->metadata_alignment_unit_size
= udf_rw16(mapping
->pmm
.alignment_unit_size
);
3134 ump
->metadata_flags
= mapping
->pmm
.flags
;
3136 DPRINTF(VOLUMES
, ("Reading in Metadata files\n"));
3137 raw_phys_part
= udf_rw16(pmm
->part_num
);
3138 phys_part
= udf_find_raw_phys(ump
, raw_phys_part
);
3140 icb_loc
.loc
.part_num
= udf_rw16(phys_part
);
3142 DPRINTF(VOLUMES
, ("Metadata file\n"));
3143 icb_loc
.loc
.lb_num
= pmm
->meta_file_lbn
;
3144 error
= udf_get_node(ump
, &icb_loc
, &ump
->metadata_node
);
3145 if (ump
->metadata_node
) {
3146 vp
= ump
->metadata_node
->vnode
;
3147 UDF_SET_SYSTEMFILE(vp
);
3150 icb_loc
.loc
.lb_num
= pmm
->meta_mirror_file_lbn
;
3151 if (icb_loc
.loc
.lb_num
!= -1) {
3152 DPRINTF(VOLUMES
, ("Metadata copy file\n"));
3153 error
= udf_get_node(ump
, &icb_loc
, &ump
->metadatamirror_node
);
3154 if (ump
->metadatamirror_node
) {
3155 vp
= ump
->metadatamirror_node
->vnode
;
3156 UDF_SET_SYSTEMFILE(vp
);
3160 icb_loc
.loc
.lb_num
= pmm
->meta_bitmap_file_lbn
;
3161 if (icb_loc
.loc
.lb_num
!= -1) {
3162 DPRINTF(VOLUMES
, ("Metadata bitmap file\n"));
3163 error
= udf_get_node(ump
, &icb_loc
, &ump
->metadatabitmap_node
);
3164 if (ump
->metadatabitmap_node
) {
3165 vp
= ump
->metadatabitmap_node
->vnode
;
3166 UDF_SET_SYSTEMFILE(vp
);
3170 /* if we're mounting read-only we relax the requirements */
3171 if (ump
->vfs_mountp
->mnt_flag
& MNT_RDONLY
) {
3173 if (ump
->metadata_node
)
3175 if ((ump
->metadata_node
== NULL
) && (ump
->metadatamirror_node
)) {
3176 printf( "udf mount: Metadata file not readable, "
3177 "substituting Metadata copy file\n");
3178 ump
->metadata_node
= ump
->metadatamirror_node
;
3179 ump
->metadatamirror_node
= NULL
;
3183 /* mounting read/write */
3184 /* XXX DISABLED! metadata writing is not working yet XXX */
3188 DPRINTFIF(VOLUMES
, error
, ("udf mount: failed to read "
3189 "metadata files\n"));
3193 /* --------------------------------------------------------------------- */
3196 udf_read_vds_tables(struct udf_mount
*ump
)
3198 union udf_pmap
*mapping
;
3199 /* struct udf_args *args = &ump->mount_args; */
3206 /* Iterate (again) over the part mappings for locations */
3207 n_pm
= udf_rw32(ump
->logical_vol
->n_pm
); /* num partmaps */
3208 pmap_pos
= ump
->logical_vol
->maps
;
3210 for (log_part
= 0; log_part
< n_pm
; log_part
++) {
3211 mapping
= (union udf_pmap
*) pmap_pos
;
3212 switch (ump
->vtop_tp
[log_part
]) {
3213 case UDF_VTOP_TYPE_PHYS
:
3216 case UDF_VTOP_TYPE_VIRT
:
3217 /* search and load VAT */
3218 error
= udf_search_vat(ump
, mapping
);
3222 case UDF_VTOP_TYPE_SPARABLE
:
3223 /* load one of the sparable tables */
3224 error
= udf_read_sparables(ump
, mapping
);
3228 case UDF_VTOP_TYPE_META
:
3229 /* load the associated file descriptors */
3230 error
= udf_read_metadata_nodes(ump
, mapping
);
3237 pmap_size
= pmap_pos
[1];
3238 pmap_pos
+= pmap_size
;
3241 /* read in and check unallocated and free space info if writing */
3242 if ((ump
->vfs_mountp
->mnt_flag
& MNT_RDONLY
) == 0) {
3243 error
= udf_read_physical_partition_spacetables(ump
);
3247 /* also read in metadata partition spacebitmap if defined */
3248 error
= udf_read_metadata_partition_spacetable(ump
);
3255 /* --------------------------------------------------------------------- */
3258 udf_read_rootdirs(struct udf_mount
*ump
)
3260 union dscrptr
*dscr
;
3261 /* struct udf_args *args = &ump->mount_args; */
3262 struct udf_node
*rootdir_node
, *streamdir_node
;
3263 struct long_ad fsd_loc
, *dir_loc
;
3264 uint32_t lb_num
, dummy
;
3269 /* TODO implement FSD reading in separate function like integrity? */
3270 /* get fileset descriptor sequence */
3271 fsd_loc
= ump
->logical_vol
->lv_fsd_loc
;
3272 fsd_len
= udf_rw32(fsd_loc
.len
);
3276 while (fsd_len
|| error
) {
3277 DPRINTF(VOLUMES
, ("fsd_len = %d\n", fsd_len
));
3278 /* translate fsd_loc to lb_num */
3279 error
= udf_translate_vtop(ump
, &fsd_loc
, &lb_num
, &dummy
);
3282 DPRINTF(VOLUMES
, ("Reading FSD at lb %d\n", lb_num
));
3283 error
= udf_read_phys_dscr(ump
, lb_num
, M_UDFVOLD
, &dscr
);
3285 if (error
|| (dscr
== NULL
))
3289 dscr_type
= udf_rw16(dscr
->tag
.id
);
3290 if (dscr_type
== TAGID_TERM
)
3292 if (dscr_type
!= TAGID_FSD
) {
3293 free(dscr
, M_UDFVOLD
);
3298 * TODO check for multiple fileset descriptors; its only
3299 * picking the last now. Also check for FSD
3300 * correctness/interpretability
3304 if (ump
->fileset_desc
) {
3305 free(ump
->fileset_desc
, M_UDFVOLD
);
3307 ump
->fileset_desc
= &dscr
->fsd
;
3310 /* continue to the next fsd */
3311 fsd_len
-= ump
->discinfo
.sector_size
;
3312 fsd_loc
.loc
.lb_num
= udf_rw32(udf_rw32(fsd_loc
.loc
.lb_num
)+1);
3314 /* follow up to fsd->next_ex (long_ad) if its not null */
3315 if (udf_rw32(ump
->fileset_desc
->next_ex
.len
)) {
3316 DPRINTF(VOLUMES
, ("follow up FSD extent\n"));
3317 fsd_loc
= ump
->fileset_desc
->next_ex
;
3318 fsd_len
= udf_rw32(ump
->fileset_desc
->next_ex
.len
);
3322 free(dscr
, M_UDFVOLD
);
3324 /* there has to be one */
3325 if (ump
->fileset_desc
== NULL
)
3328 DPRINTF(VOLUMES
, ("FSD read in fine\n"));
3329 DPRINTF(VOLUMES
, ("Updating fsd logical volume id\n"));
3330 udf_update_logvolname(ump
, ump
->logical_vol
->logvol_id
);
3333 * Now the FSD is known, read in the rootdirectory and if one exists,
3334 * the system stream dir. Some files in the system streamdir are not
3335 * wanted in this implementation since they are not maintained. If
3336 * writing is enabled we'll delete these files if they exist.
3339 rootdir_node
= streamdir_node
= NULL
;
3342 /* try to read in the rootdir */
3343 dir_loc
= &ump
->fileset_desc
->rootdir_icb
;
3344 error
= udf_get_node(ump
, dir_loc
, &rootdir_node
);
3348 /* aparently it read in fine */
3351 * Try the system stream directory; not very likely in the ones we
3352 * test, but for completeness.
3354 dir_loc
= &ump
->fileset_desc
->streamdir_icb
;
3355 if (udf_rw32(dir_loc
->len
)) {
3356 printf("udf_read_rootdirs: streamdir defined ");
3357 error
= udf_get_node(ump
, dir_loc
, &streamdir_node
);
3359 printf("but error in streamdir reading\n");
3361 printf("but ignored\n");
3363 * TODO process streamdir `baddies' i.e. files we dont
3369 DPRINTF(VOLUMES
, ("Rootdir(s) read in fine\n"));
3371 /* release the vnodes again; they'll be auto-recycled later */
3372 if (streamdir_node
) {
3373 vput(streamdir_node
->vnode
);
3376 vput(rootdir_node
->vnode
);
3382 /* --------------------------------------------------------------------- */
3384 /* To make absolutely sure we are NOT returning zero, add one :) */
3387 udf_get_node_id(const struct long_ad
*icbptr
)
3389 /* ought to be enough since each mountpoint has its own chain */
3390 return udf_rw32(icbptr
->loc
.lb_num
) + 1;
3395 udf_compare_icb(const struct long_ad
*a
, const struct long_ad
*b
)
3397 if (udf_rw16(a
->loc
.part_num
) < udf_rw16(b
->loc
.part_num
))
3399 if (udf_rw16(a
->loc
.part_num
) > udf_rw16(b
->loc
.part_num
))
3402 if (udf_rw32(a
->loc
.lb_num
) < udf_rw32(b
->loc
.lb_num
))
3404 if (udf_rw32(a
->loc
.lb_num
) > udf_rw32(b
->loc
.lb_num
))
3412 udf_compare_rbnodes(void *ctx
, const void *a
, const void *b
)
3414 const struct udf_node
*a_node
= a
;
3415 const struct udf_node
*b_node
= b
;
3417 return udf_compare_icb(&a_node
->loc
, &b_node
->loc
);
3422 udf_compare_rbnode_icb(void *ctx
, const void *a
, const void *key
)
3424 const struct udf_node
*a_node
= a
;
3425 const struct long_ad
* const icb
= key
;
3427 return udf_compare_icb(&a_node
->loc
, icb
);
3431 static const rb_tree_ops_t udf_node_rbtree_ops
= {
3432 .rbto_compare_nodes
= udf_compare_rbnodes
,
3433 .rbto_compare_key
= udf_compare_rbnode_icb
,
3434 .rbto_node_offset
= offsetof(struct udf_node
, rbnode
),
3435 .rbto_context
= NULL
3440 udf_init_nodes_tree(struct udf_mount
*ump
)
3443 rb_tree_init(&ump
->udf_node_tree
, &udf_node_rbtree_ops
);
3447 /* --------------------------------------------------------------------- */
3450 udf_validate_session_start(struct udf_mount
*ump
)
3452 struct mmc_trackinfo trackinfo
;
3453 struct vrs_desc
*vrs
;
3454 uint32_t tracknr
, sessionnr
, sector
, sector_size
;
3455 uint32_t iso9660_vrs
, write_track_start
;
3456 uint8_t *buffer
, *blank
, *pos
;
3457 int blks
, max_sectors
, vrs_len
;
3460 /* disc appendable? */
3461 if (ump
->discinfo
.disc_state
== MMC_STATE_FULL
)
3464 /* already written here? if so, there should be an ISO VDS */
3465 if (ump
->discinfo
.last_session_state
== MMC_STATE_INCOMPLETE
)
3469 * Check if the first track of the session is blank and if so, copy or
3470 * create a dummy ISO descriptor so the disc is valid again.
3473 tracknr
= ump
->discinfo
.first_track_last_session
;
3474 memset(&trackinfo
, 0, sizeof(struct mmc_trackinfo
));
3475 trackinfo
.tracknr
= tracknr
;
3476 error
= udf_update_trackinfo(ump
, &trackinfo
);
3480 udf_dump_trackinfo(&trackinfo
);
3481 KASSERT(trackinfo
.flags
& (MMC_TRACKINFO_BLANK
| MMC_TRACKINFO_RESERVED
));
3482 KASSERT(trackinfo
.sessionnr
> 1);
3484 KASSERT(trackinfo
.flags
& MMC_TRACKINFO_NWA_VALID
);
3485 write_track_start
= trackinfo
.next_writable
;
3487 /* we have to copy the ISO VRS from a former session */
3488 DPRINTF(VOLUMES
, ("validate_session_start: "
3489 "blank or reserved track, copying VRS\n"));
3491 /* sessionnr should be the session we're mounting */
3492 sessionnr
= ump
->mount_args
.sessionnr
;
3494 /* start at the first track */
3495 tracknr
= ump
->discinfo
.first_track
;
3496 while (tracknr
<= ump
->discinfo
.num_tracks
) {
3497 trackinfo
.tracknr
= tracknr
;
3498 error
= udf_update_trackinfo(ump
, &trackinfo
);
3500 DPRINTF(VOLUMES
, ("failed to get trackinfo; aborting\n"));
3503 if (trackinfo
.sessionnr
== sessionnr
)
3507 if (trackinfo
.sessionnr
!= sessionnr
) {
3508 DPRINTF(VOLUMES
, ("failed to get trackinfo; aborting\n"));
3512 DPRINTF(VOLUMES
, ("found possible former ISO VRS at\n"));
3513 udf_dump_trackinfo(&trackinfo
);
3516 * location of iso9660 vrs is defined as first sector AFTER 32kb,
3517 * minimum ISO `sector size' 2048
3519 sector_size
= ump
->discinfo
.sector_size
;
3520 iso9660_vrs
= ((32*1024 + sector_size
- 1) / sector_size
)
3521 + trackinfo
.track_start
;
3523 buffer
= malloc(UDF_ISO_VRS_SIZE
, M_TEMP
, M_WAITOK
);
3524 max_sectors
= UDF_ISO_VRS_SIZE
/ sector_size
;
3525 blks
= MAX(1, 2048 / sector_size
);
3528 for (sector
= 0; sector
< max_sectors
; sector
+= blks
) {
3529 pos
= buffer
+ sector
* sector_size
;
3530 error
= udf_read_phys_sectors(ump
, UDF_C_DSCR
, pos
,
3531 iso9660_vrs
+ sector
, blks
);
3534 /* check this ISO descriptor */
3535 vrs
= (struct vrs_desc
*) pos
;
3536 DPRINTF(VOLUMES
, ("got VRS id `%4s`\n", vrs
->identifier
));
3537 if (strncmp(vrs
->identifier
, VRS_CD001
, 5) == 0)
3539 if (strncmp(vrs
->identifier
, VRS_CDW02
, 5) == 0)
3541 if (strncmp(vrs
->identifier
, VRS_BEA01
, 5) == 0)
3543 if (strncmp(vrs
->identifier
, VRS_NSR02
, 5) == 0)
3545 if (strncmp(vrs
->identifier
, VRS_NSR03
, 5) == 0)
3547 if (strncmp(vrs
->identifier
, VRS_TEA01
, 5) == 0)
3549 /* now what? for now, end of sequence */
3552 vrs_len
= sector
+ blks
;
3554 DPRINTF(VOLUMES
, ("error reading old ISO VRS\n"));
3555 DPRINTF(VOLUMES
, ("creating minimal ISO VRS\n"));
3557 memset(buffer
, 0, UDF_ISO_VRS_SIZE
);
3559 vrs
= (struct vrs_desc
*) (buffer
);
3560 vrs
->struct_type
= 0;
3562 memcpy(vrs
->identifier
,VRS_BEA01
, 5);
3564 vrs
= (struct vrs_desc
*) (buffer
+ 2048);
3565 vrs
->struct_type
= 0;
3567 if (udf_rw16(ump
->logical_vol
->tag
.descriptor_ver
) == 2) {
3568 memcpy(vrs
->identifier
,VRS_NSR02
, 5);
3570 memcpy(vrs
->identifier
,VRS_NSR03
, 5);
3573 vrs
= (struct vrs_desc
*) (buffer
+ 4096);
3574 vrs
->struct_type
= 0;
3576 memcpy(vrs
->identifier
, VRS_TEA01
, 5);
3581 DPRINTF(VOLUMES
, ("Got VRS of %d sectors long\n", vrs_len
));
3584 * location of iso9660 vrs is defined as first sector AFTER 32kb,
3585 * minimum ISO `sector size' 2048
3587 sector_size
= ump
->discinfo
.sector_size
;
3588 iso9660_vrs
= ((32*1024 + sector_size
- 1) / sector_size
)
3589 + write_track_start
;
3591 /* write out 32 kb */
3592 blank
= malloc(sector_size
, M_TEMP
, M_WAITOK
);
3593 memset(blank
, 0, sector_size
);
3595 for (sector
= write_track_start
; sector
< iso9660_vrs
; sector
++) {
3596 error
= udf_write_phys_sectors(ump
, UDF_C_ABSOLUTE
,
3602 /* write out our ISO VRS */
3603 KASSERT(sector
== iso9660_vrs
);
3604 error
= udf_write_phys_sectors(ump
, UDF_C_ABSOLUTE
, buffer
,
3609 /* fill upto the first anchor at S+256 */
3610 for (; sector
< write_track_start
+256; sector
++) {
3611 error
= udf_write_phys_sectors(ump
, UDF_C_ABSOLUTE
,
3618 /* write out anchor; write at ABSOLUTE place! */
3619 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_ABSOLUTE
,
3620 (union dscrptr
*) ump
->anchors
[0], sector
, sector
);
3622 printf("writeout of anchor failed!\n");
3625 free(blank
, M_TEMP
);
3626 free(buffer
, M_TEMP
);
3629 printf("udf_open_session: error writing iso vrs! : "
3630 "leaving disc in compromised state!\n");
3632 /* synchronise device caches */
3633 (void) udf_synchronise_caches(ump
);
3640 udf_open_logvol(struct udf_mount
*ump
)
3642 int logvol_integrity
;
3645 /* already/still open? */
3646 logvol_integrity
= udf_rw32(ump
->logvol_integrity
->integrity_type
);
3647 if (logvol_integrity
== UDF_INTEGRITY_OPEN
)
3650 /* can we open it ? */
3651 if (ump
->vfs_mountp
->mnt_flag
& MNT_RDONLY
)
3654 /* setup write parameters */
3655 DPRINTF(VOLUMES
, ("Setting up write parameters\n"));
3656 if ((error
= udf_setup_writeparams(ump
)) != 0)
3659 /* determine data and metadata tracks (most likely same) */
3660 error
= udf_search_writing_tracks(ump
);
3662 /* most likely lack of space */
3663 printf("udf_open_logvol: error searching writing tracks\n");
3667 /* writeout/update lvint on disc or only in memory */
3668 DPRINTF(VOLUMES
, ("Opening logical volume\n"));
3669 if (ump
->lvopen
& UDF_OPEN_SESSION
) {
3670 /* TODO optional track reservation opening */
3671 error
= udf_validate_session_start(ump
);
3675 /* determine data and metadata tracks again */
3676 error
= udf_search_writing_tracks(ump
);
3680 ump
->logvol_integrity
->integrity_type
= udf_rw32(UDF_INTEGRITY_OPEN
);
3682 /* do we need to write it out? */
3683 if (ump
->lvopen
& UDF_WRITE_LVINT
) {
3684 error
= udf_writeout_lvint(ump
, ump
->lvopen
);
3685 /* if we couldn't write it mark it closed again */
3687 ump
->logvol_integrity
->integrity_type
=
3688 udf_rw32(UDF_INTEGRITY_CLOSED
);
3698 udf_close_logvol(struct udf_mount
*ump
, int mntflags
)
3700 struct vnode
*devvp
= ump
->devvp
;
3701 struct mmc_op mmc_op
;
3702 int logvol_integrity
;
3703 int error
= 0, error1
= 0, error2
= 0;
3707 /* already/still closed? */
3708 logvol_integrity
= udf_rw32(ump
->logvol_integrity
->integrity_type
);
3709 if (logvol_integrity
== UDF_INTEGRITY_CLOSED
)
3712 /* writeout/update lvint or write out VAT */
3713 DPRINTF(VOLUMES
, ("udf_close_logvol: closing logical volume\n"));
3715 if (ump
->lvclose
& UDF_CLOSE_SESSION
)
3716 KASSERT(ump
->lvclose
& UDF_WRITE_VAT
);
3719 if (ump
->lvclose
& UDF_WRITE_VAT
) {
3720 DPRINTF(VOLUMES
, ("lvclose & UDF_WRITE_VAT\n"));
3722 /* write out the VAT data and all its descriptors */
3723 DPRINTF(VOLUMES
, ("writeout vat_node\n"));
3724 udf_writeout_vat(ump
);
3725 (void) vflushbuf(ump
->vat_node
->vnode
, FSYNC_WAIT
);
3727 (void) VOP_FSYNC(ump
->vat_node
->vnode
,
3728 FSCRED
, FSYNC_WAIT
, 0, 0);
3730 if (ump
->lvclose
& UDF_CLOSE_SESSION
) {
3731 DPRINTF(VOLUMES
, ("udf_close_logvol: closing session "
3735 /* at least two DVD packets and 3 CD-R packets */
3740 * TODO calculate the available space and if the disc is
3741 * allmost full, write out till end-256-1 with banks, write
3742 * AVDP and fill up with VATs, then close session and close
3745 if (ump
->lvclose
& UDF_FINALISE_DISC
) {
3746 error
= udf_write_phys_dscr_sync(ump
, NULL
,
3748 (union dscrptr
*) ump
->anchors
[0],
3751 printf("writeout of anchor failed!\n");
3753 /* pad space with VAT ICBs */
3758 /* write out a number of VAT nodes */
3760 for (n
= 0; n
< nvats
; n
++) {
3761 /* will now only write last FE/EFE */
3762 ump
->vat_node
->i_flags
|= IN_MODIFIED
;
3763 error
= VOP_FSYNC(ump
->vat_node
->vnode
,
3764 FSCRED
, FSYNC_WAIT
, 0, 0);
3769 /* arbitrary; but at least one or two CD frames */
3770 printf("writeout of at least 14 VATs failed\n");
3775 /* NOTE the disc is in a (minimal) valid state now; no erroring out */
3777 /* finish closing of session */
3778 if (ump
->lvclose
& UDF_CLOSE_SESSION
) {
3779 error
= udf_validate_session_start(ump
);
3783 (void) udf_synchronise_caches(ump
);
3785 /* close all associated tracks */
3786 tracknr
= ump
->discinfo
.first_track_last_session
;
3788 while (tracknr
<= ump
->discinfo
.last_track_last_session
) {
3789 DPRINTF(VOLUMES
, ("\tclosing possible open "
3790 "track %d\n", tracknr
));
3791 memset(&mmc_op
, 0, sizeof(mmc_op
));
3792 mmc_op
.operation
= MMC_OP_CLOSETRACK
;
3793 mmc_op
.mmc_profile
= ump
->discinfo
.mmc_profile
;
3794 mmc_op
.tracknr
= tracknr
;
3795 error
= VOP_IOCTL(devvp
, MMCOP
, &mmc_op
,
3798 printf("udf_close_logvol: closing of "
3799 "track %d failed\n", tracknr
);
3803 DPRINTF(VOLUMES
, ("closing session\n"));
3804 memset(&mmc_op
, 0, sizeof(mmc_op
));
3805 mmc_op
.operation
= MMC_OP_CLOSESESSION
;
3806 mmc_op
.mmc_profile
= ump
->discinfo
.mmc_profile
;
3807 mmc_op
.sessionnr
= ump
->discinfo
.num_sessions
;
3808 error
= VOP_IOCTL(devvp
, MMCOP
, &mmc_op
,
3811 printf("udf_close_logvol: closing of session"
3815 ump
->lvopen
|= UDF_OPEN_SESSION
;
3817 printf("udf_close_logvol: leaving disc as it is\n");
3818 ump
->lvclose
&= ~UDF_FINALISE_DISC
;
3822 if (ump
->lvclose
& UDF_FINALISE_DISC
) {
3823 memset(&mmc_op
, 0, sizeof(mmc_op
));
3824 mmc_op
.operation
= MMC_OP_FINALISEDISC
;
3825 mmc_op
.mmc_profile
= ump
->discinfo
.mmc_profile
;
3826 mmc_op
.sessionnr
= ump
->discinfo
.num_sessions
;
3827 error
= VOP_IOCTL(devvp
, MMCOP
, &mmc_op
,
3830 printf("udf_close_logvol: finalising disc"
3834 /* write out partition bitmaps if requested */
3835 if (ump
->lvclose
& UDF_WRITE_PART_BITMAPS
) {
3836 /* sync writeout metadata spacetable if existing */
3837 error1
= udf_write_metadata_partition_spacetable(ump
, true);
3839 printf( "udf_close_logvol: writeout of metadata space "
3842 /* sync writeout partition spacetables */
3843 error2
= udf_write_physical_partition_spacetables(ump
, true);
3845 printf( "udf_close_logvol: writeout of space tables "
3848 if (error1
|| error2
)
3849 return (error1
| error2
);
3851 ump
->lvclose
&= ~UDF_WRITE_PART_BITMAPS
;
3854 /* write out metadata partition nodes if requested */
3855 if (ump
->lvclose
& UDF_WRITE_METAPART_NODES
) {
3856 /* sync writeout metadata descriptor node */
3857 error1
= udf_writeout_node(ump
->metadata_node
, FSYNC_WAIT
);
3859 printf( "udf_close_logvol: writeout of metadata partition "
3862 /* duplicate metadata partition descriptor if needed */
3863 udf_synchronise_metadatamirror_node(ump
);
3865 /* sync writeout metadatamirror descriptor node */
3866 error2
= udf_writeout_node(ump
->metadatamirror_node
, FSYNC_WAIT
);
3868 printf( "udf_close_logvol: writeout of metadata partition "
3869 "mirror node failed\n");
3871 if (error1
|| error2
)
3872 return (error1
| error2
);
3874 ump
->lvclose
&= ~UDF_WRITE_METAPART_NODES
;
3877 /* mark it closed */
3878 ump
->logvol_integrity
->integrity_type
= udf_rw32(UDF_INTEGRITY_CLOSED
);
3880 /* do we need to write out the logical volume integrity? */
3881 if (ump
->lvclose
& UDF_WRITE_LVINT
)
3882 error
= udf_writeout_lvint(ump
, ump
->lvopen
);
3884 /* HELP now what? mark it open again for now */
3885 ump
->logvol_integrity
->integrity_type
=
3886 udf_rw32(UDF_INTEGRITY_OPEN
);
3890 (void) udf_synchronise_caches(ump
);
3895 /* --------------------------------------------------------------------- */
3900 * static const struct genfs_ops udf_genfsops = {
3901 * .gop_size = genfs_size,
3903 * .gop_alloc = udf_gop_alloc,
3904 * allocate len bytes at offset
3905 * .gop_write = genfs_gop_write,
3906 * putpages interface code
3907 * .gop_markupdate = udf_gop_markupdate,
3908 * set update/modify flags etc.
3913 * Genfs interface. These four functions are the only ones defined though not
3914 * documented... great....
3918 * Called for allocating an extent of the file either by VOP_WRITE() or by
3919 * genfs filling up gaps.
3922 udf_gop_alloc(struct vnode
*vp
, off_t off
,
3923 off_t len
, int flags
, kauth_cred_t cred
)
3925 struct udf_node
*udf_node
= VTOI(vp
);
3926 struct udf_mount
*ump
= udf_node
->ump
;
3927 uint64_t lb_start
, lb_end
;
3928 uint32_t lb_size
, num_lb
;
3929 int udf_c_type
, vpart_num
, can_fail
;
3932 DPRINTF(ALLOC
, ("udf_gop_alloc called for offset %"PRIu64
" for %"PRIu64
" bytes, %s\n",
3933 off
, len
, flags
? "SYNC":"NONE"));
3936 * request the pages of our vnode and see how many pages will need to
3937 * be allocated and reserve that space
3939 lb_size
= udf_rw32(udf_node
->ump
->logical_vol
->lb_size
);
3940 lb_start
= off
/ lb_size
;
3941 lb_end
= (off
+ len
+ lb_size
-1) / lb_size
;
3942 num_lb
= lb_end
- lb_start
;
3944 udf_c_type
= udf_get_c_type(udf_node
);
3945 vpart_num
= udf_get_record_vpart(ump
, udf_c_type
);
3947 /* all requests can fail */
3950 /* fid's (directories) can't fail */
3951 if (udf_c_type
== UDF_C_FIDS
)
3954 /* system files can't fail */
3955 if (vp
->v_vflag
& VV_SYSTEM
)
3958 error
= udf_reserve_space(ump
, udf_node
, udf_c_type
,
3959 vpart_num
, num_lb
, can_fail
);
3961 DPRINTF(ALLOC
, ("\tlb_start %"PRIu64
", lb_end %"PRIu64
", num_lb %d\n",
3962 lb_start
, lb_end
, num_lb
));
3969 * callback from genfs to update our flags
3972 udf_gop_markupdate(struct vnode
*vp
, int flags
)
3974 struct udf_node
*udf_node
= VTOI(vp
);
3977 if ((flags
& GOP_UPDATE_ACCESSED
) != 0) {
3980 if ((flags
& GOP_UPDATE_MODIFIED
) != 0) {
3981 if (vp
->v_type
== VREG
) {
3982 mask
|= IN_CHANGE
| IN_UPDATE
;
3988 udf_node
->i_flags
|= mask
;
3993 static const struct genfs_ops udf_genfsops
= {
3994 .gop_size
= genfs_size
,
3995 .gop_alloc
= udf_gop_alloc
,
3996 .gop_write
= genfs_gop_write_rwmap
,
3997 .gop_markupdate
= udf_gop_markupdate
,
4001 /* --------------------------------------------------------------------- */
4004 udf_write_terminator(struct udf_mount
*ump
, uint32_t sector
)
4006 union dscrptr
*dscr
;
4009 dscr
= malloc(ump
->discinfo
.sector_size
, M_TEMP
, M_WAITOK
|M_ZERO
);
4010 udf_inittag(ump
, &dscr
->tag
, TAGID_TERM
, sector
);
4012 /* CRC length for an anchor is 512 - tag length; defined in Ecma 167 */
4013 dscr
->tag
.desc_crc_len
= udf_rw16(512-UDF_DESC_TAG_LENGTH
);
4014 (void) udf_validate_tag_and_crc_sums(dscr
);
4016 error
= udf_write_phys_dscr_sync(ump
, NULL
, UDF_C_DSCR
,
4017 dscr
, sector
, sector
);
4025 /* --------------------------------------------------------------------- */
4027 /* UDF<->unix converters */
4029 /* --------------------------------------------------------------------- */
4032 udf_perm_to_unix_mode(uint32_t perm
)
4036 mode
= ((perm
& UDF_FENTRY_PERM_USER_MASK
) );
4037 mode
|= ((perm
& UDF_FENTRY_PERM_GRP_MASK
) >> 2);
4038 mode
|= ((perm
& UDF_FENTRY_PERM_OWNER_MASK
) >> 4);
4043 /* --------------------------------------------------------------------- */
4046 unix_mode_to_udf_perm(mode_t mode
)
4050 perm
= ((mode
& S_IRWXO
) );
4051 perm
|= ((mode
& S_IRWXG
) << 2);
4052 perm
|= ((mode
& S_IRWXU
) << 4);
4053 perm
|= ((mode
& S_IWOTH
) << 3);
4054 perm
|= ((mode
& S_IWGRP
) << 5);
4055 perm
|= ((mode
& S_IWUSR
) << 7);
4060 /* --------------------------------------------------------------------- */
4063 udf_icb_to_unix_filetype(uint32_t icbftype
)
4066 case UDF_ICB_FILETYPE_DIRECTORY
:
4067 case UDF_ICB_FILETYPE_STREAMDIR
:
4069 case UDF_ICB_FILETYPE_FIFO
:
4071 case UDF_ICB_FILETYPE_CHARDEVICE
:
4073 case UDF_ICB_FILETYPE_BLOCKDEVICE
:
4075 case UDF_ICB_FILETYPE_RANDOMACCESS
:
4076 case UDF_ICB_FILETYPE_REALTIME
:
4078 case UDF_ICB_FILETYPE_SYMLINK
:
4080 case UDF_ICB_FILETYPE_SOCKET
:
4083 /* no idea what this is */
4087 /* --------------------------------------------------------------------- */
4090 udf_to_unix_name(char *result
, int result_len
, char *id
, int len
,
4091 struct charspec
*chsp
)
4093 uint16_t *raw_name
, *unix_name
;
4094 uint16_t *inchp
, ch
;
4096 const char *osta_id
= "OSTA Compressed Unicode";
4097 int ucode_chars
, nice_uchars
, is_osta_typ0
, nout
;
4099 raw_name
= malloc(2048 * sizeof(uint16_t), M_UDFTEMP
, M_WAITOK
);
4100 unix_name
= raw_name
+ 1024; /* split space in half */
4101 assert(sizeof(char) == sizeof(uint8_t));
4102 outchp
= (uint8_t *) result
;
4104 is_osta_typ0
= (chsp
->type
== 0);
4105 is_osta_typ0
&= (strcmp((char *) chsp
->inf
, osta_id
) == 0);
4108 *raw_name
= *unix_name
= 0;
4109 ucode_chars
= udf_UncompressUnicode(len
, (uint8_t *) id
, raw_name
);
4110 ucode_chars
= MIN(ucode_chars
, UnicodeLength((unicode_t
*) raw_name
));
4111 nice_uchars
= UDFTransName(unix_name
, raw_name
, ucode_chars
);
4113 for (inchp
= unix_name
; nice_uchars
>0; inchp
++, nice_uchars
--) {
4115 nout
= wput_utf8(outchp
, result_len
, ch
);
4116 outchp
+= nout
; result_len
-= nout
;
4121 /* assume 8bit char length byte latin-1 */
4123 assert(strlen((char *) (id
+1)) <= NAME_MAX
);
4124 strncpy((char *) result
, (char *) (id
+1), strlen((char *) (id
+1)));
4126 free(raw_name
, M_UDFTEMP
);
4129 /* --------------------------------------------------------------------- */
4132 unix_to_udf_name(char *result
, uint8_t *result_len
, char const *name
, int name_len
,
4133 struct charspec
*chsp
)
4138 const char *osta_id
= "OSTA Compressed Unicode";
4139 int udf_chars
, is_osta_typ0
, bits
;
4142 /* allocate temporary unicode-16 buffer */
4143 raw_name
= malloc(1024, M_UDFTEMP
, M_WAITOK
);
4145 /* convert utf8 to unicode-16 */
4150 for (cnt
= name_len
, udf_chars
= 0; cnt
;) {
4151 *outchp
= wget_utf8(&inchp
, &cnt
);
4157 /* null terminate just in case */
4160 is_osta_typ0
= (chsp
->type
== 0);
4161 is_osta_typ0
&= (strcmp((char *) chsp
->inf
, osta_id
) == 0);
4163 udf_chars
= udf_CompressUnicode(udf_chars
, bits
,
4164 (unicode_t
*) raw_name
,
4167 printf("unix to udf name: no CHSP0 ?\n");
4168 /* XXX assume 8bit char length byte latin-1 */
4169 *result
++ = 8; udf_chars
= 1;
4170 strncpy(result
, name
+ 1, name_len
);
4171 udf_chars
+= name_len
;
4173 *result_len
= udf_chars
;
4174 free(raw_name
, M_UDFTEMP
);
4177 /* --------------------------------------------------------------------- */
4180 udf_timestamp_to_timespec(struct udf_mount
*ump
,
4181 struct timestamp
*timestamp
,
4182 struct timespec
*timespec
)
4184 struct clock_ymdhms ymdhms
;
4185 uint32_t usecs
, secs
, nsecs
;
4188 /* fill in ymdhms structure from timestamp */
4189 memset(&ymdhms
, 0, sizeof(ymdhms
));
4190 ymdhms
.dt_year
= udf_rw16(timestamp
->year
);
4191 ymdhms
.dt_mon
= timestamp
->month
;
4192 ymdhms
.dt_day
= timestamp
->day
;
4193 ymdhms
.dt_wday
= 0; /* ? */
4194 ymdhms
.dt_hour
= timestamp
->hour
;
4195 ymdhms
.dt_min
= timestamp
->minute
;
4196 ymdhms
.dt_sec
= timestamp
->second
;
4198 secs
= clock_ymdhms_to_secs(&ymdhms
);
4199 usecs
= timestamp
->usec
+
4200 100*timestamp
->hund_usec
+ 10000*timestamp
->centisec
;
4201 nsecs
= usecs
* 1000;
4204 * Calculate the time zone. The timezone is 12 bit signed 2's
4205 * compliment, so we gotta do some extra magic to handle it right.
4207 tz
= udf_rw16(timestamp
->type_tz
);
4208 tz
&= 0x0fff; /* only lower 12 bits are significant */
4209 if (tz
& 0x0800) /* sign extention */
4212 /* TODO check timezone conversion */
4213 /* check if we are specified a timezone to convert */
4214 if (udf_rw16(timestamp
->type_tz
) & 0x1000) {
4215 if ((int16_t) tz
!= -2047)
4216 secs
-= (int16_t) tz
* 60;
4218 secs
-= ump
->mount_args
.gmtoff
;
4221 timespec
->tv_sec
= secs
;
4222 timespec
->tv_nsec
= nsecs
;
4227 udf_timespec_to_timestamp(struct timespec
*timespec
, struct timestamp
*timestamp
)
4229 struct clock_ymdhms ymdhms
;
4230 uint32_t husec
, usec
, csec
;
4232 (void) clock_secs_to_ymdhms(timespec
->tv_sec
, &ymdhms
);
4234 usec
= timespec
->tv_nsec
/ 1000;
4236 usec
-= husec
* 100; /* only 0-99 in usec */
4237 csec
= husec
/ 100; /* only 0-99 in csec */
4238 husec
-= csec
* 100; /* only 0-99 in husec */
4240 /* set method 1 for CUT/GMT */
4241 timestamp
->type_tz
= udf_rw16((1<<12) + 0);
4242 timestamp
->year
= udf_rw16(ymdhms
.dt_year
);
4243 timestamp
->month
= ymdhms
.dt_mon
;
4244 timestamp
->day
= ymdhms
.dt_day
;
4245 timestamp
->hour
= ymdhms
.dt_hour
;
4246 timestamp
->minute
= ymdhms
.dt_min
;
4247 timestamp
->second
= ymdhms
.dt_sec
;
4248 timestamp
->centisec
= csec
;
4249 timestamp
->hund_usec
= husec
;
4250 timestamp
->usec
= usec
;
4253 /* --------------------------------------------------------------------- */
4256 * Attribute and filetypes converters with get/set pairs
4260 udf_getaccessmode(struct udf_node
*udf_node
)
4262 struct file_entry
*fe
= udf_node
->fe
;
4263 struct extfile_entry
*efe
= udf_node
->efe
;
4264 uint32_t udf_perm
, icbftype
;
4265 uint32_t mode
, ftype
;
4268 UDF_LOCK_NODE(udf_node
, 0);
4270 udf_perm
= udf_rw32(fe
->perm
);
4271 icbftype
= fe
->icbtag
.file_type
;
4272 icbflags
= udf_rw16(fe
->icbtag
.flags
);
4274 assert(udf_node
->efe
);
4275 udf_perm
= udf_rw32(efe
->perm
);
4276 icbftype
= efe
->icbtag
.file_type
;
4277 icbflags
= udf_rw16(efe
->icbtag
.flags
);
4280 mode
= udf_perm_to_unix_mode(udf_perm
);
4281 ftype
= udf_icb_to_unix_filetype(icbftype
);
4283 /* set suid, sgid, sticky from flags in fe/efe */
4284 if (icbflags
& UDF_ICB_TAG_FLAGS_SETUID
)
4286 if (icbflags
& UDF_ICB_TAG_FLAGS_SETGID
)
4288 if (icbflags
& UDF_ICB_TAG_FLAGS_STICKY
)
4291 UDF_UNLOCK_NODE(udf_node
, 0);
4293 return mode
| ftype
;
4298 udf_setaccessmode(struct udf_node
*udf_node
, mode_t mode
)
4300 struct file_entry
*fe
= udf_node
->fe
;
4301 struct extfile_entry
*efe
= udf_node
->efe
;
4305 UDF_LOCK_NODE(udf_node
, 0);
4306 udf_perm
= unix_mode_to_udf_perm(mode
& ALLPERMS
);
4308 icbflags
= udf_rw16(fe
->icbtag
.flags
);
4310 icbflags
= udf_rw16(efe
->icbtag
.flags
);
4313 icbflags
&= ~UDF_ICB_TAG_FLAGS_SETUID
;
4314 icbflags
&= ~UDF_ICB_TAG_FLAGS_SETGID
;
4315 icbflags
&= ~UDF_ICB_TAG_FLAGS_STICKY
;
4317 icbflags
|= UDF_ICB_TAG_FLAGS_SETUID
;
4319 icbflags
|= UDF_ICB_TAG_FLAGS_SETGID
;
4321 icbflags
|= UDF_ICB_TAG_FLAGS_STICKY
;
4324 fe
->perm
= udf_rw32(udf_perm
);
4325 fe
->icbtag
.flags
= udf_rw16(icbflags
);
4327 efe
->perm
= udf_rw32(udf_perm
);
4328 efe
->icbtag
.flags
= udf_rw16(icbflags
);
4331 UDF_UNLOCK_NODE(udf_node
, 0);
4336 udf_getownership(struct udf_node
*udf_node
, uid_t
*uidp
, gid_t
*gidp
)
4338 struct udf_mount
*ump
= udf_node
->ump
;
4339 struct file_entry
*fe
= udf_node
->fe
;
4340 struct extfile_entry
*efe
= udf_node
->efe
;
4344 UDF_LOCK_NODE(udf_node
, 0);
4346 uid
= (uid_t
)udf_rw32(fe
->uid
);
4347 gid
= (gid_t
)udf_rw32(fe
->gid
);
4349 assert(udf_node
->efe
);
4350 uid
= (uid_t
)udf_rw32(efe
->uid
);
4351 gid
= (gid_t
)udf_rw32(efe
->gid
);
4354 /* do the uid/gid translation game */
4355 if (uid
== (uid_t
) -1)
4356 uid
= ump
->mount_args
.anon_uid
;
4357 if (gid
== (gid_t
) -1)
4358 gid
= ump
->mount_args
.anon_gid
;
4363 UDF_UNLOCK_NODE(udf_node
, 0);
4368 udf_setownership(struct udf_node
*udf_node
, uid_t uid
, gid_t gid
)
4370 struct udf_mount
*ump
= udf_node
->ump
;
4371 struct file_entry
*fe
= udf_node
->fe
;
4372 struct extfile_entry
*efe
= udf_node
->efe
;
4376 UDF_LOCK_NODE(udf_node
, 0);
4378 /* do the uid/gid translation game */
4379 nobody_uid
= ump
->mount_args
.nobody_uid
;
4380 nobody_gid
= ump
->mount_args
.nobody_gid
;
4381 if (uid
== nobody_uid
)
4383 if (gid
== nobody_gid
)
4387 fe
->uid
= udf_rw32((uint32_t) uid
);
4388 fe
->gid
= udf_rw32((uint32_t) gid
);
4390 efe
->uid
= udf_rw32((uint32_t) uid
);
4391 efe
->gid
= udf_rw32((uint32_t) gid
);
4394 UDF_UNLOCK_NODE(udf_node
, 0);
4398 /* --------------------------------------------------------------------- */
4402 udf_dirhash_fill(struct udf_node
*dir_node
)
4404 struct vnode
*dvp
= dir_node
->vnode
;
4405 struct dirhash
*dirh
;
4406 struct file_entry
*fe
= dir_node
->fe
;
4407 struct extfile_entry
*efe
= dir_node
->efe
;
4408 struct fileid_desc
*fid
;
4409 struct dirent
*dirent
;
4410 uint64_t file_size
, pre_diroffset
, diroffset
;
4414 /* make sure we have a dirhash to work on */
4415 dirh
= dir_node
->dir_hash
;
4417 KASSERT(dirh
->refcnt
> 0);
4419 if (dirh
->flags
& DIRH_BROKEN
)
4421 if (dirh
->flags
& DIRH_COMPLETE
)
4424 /* make sure we have a clean dirhash to add to */
4425 dirhash_purge_entries(dirh
);
4427 /* get directory filesize */
4429 file_size
= udf_rw64(fe
->inf_len
);
4432 file_size
= udf_rw64(efe
->inf_len
);
4435 /* allocate temporary space for fid */
4436 lb_size
= udf_rw32(dir_node
->ump
->logical_vol
->lb_size
);
4437 fid
= malloc(lb_size
, M_UDFTEMP
, M_WAITOK
);
4439 /* allocate temporary space for dirent */
4440 dirent
= malloc(sizeof(struct dirent
), M_UDFTEMP
, M_WAITOK
);
4444 while (diroffset
< file_size
) {
4445 /* transfer a new fid/dirent */
4446 pre_diroffset
= diroffset
;
4447 error
= udf_read_fid_stream(dvp
, &diroffset
, fid
, dirent
);
4449 /* TODO what to do? continue but not add? */
4450 dirh
->flags
|= DIRH_BROKEN
;
4451 dirhash_purge_entries(dirh
);
4455 if ((fid
->file_char
& UDF_FILE_CHAR_DEL
)) {
4456 /* register deleted extent for reuse */
4457 dirhash_enter_freed(dirh
, pre_diroffset
,
4460 /* append to the dirhash */
4461 dirhash_enter(dirh
, dirent
, pre_diroffset
,
4462 udf_fidsize(fid
), 0);
4465 dirh
->flags
|= DIRH_COMPLETE
;
4467 free(fid
, M_UDFTEMP
);
4468 free(dirent
, M_UDFTEMP
);
4474 /* --------------------------------------------------------------------- */
4477 * Directory read and manipulation functions.
4482 udf_lookup_name_in_dir(struct vnode
*vp
, const char *name
, int namelen
,
4483 struct long_ad
*icb_loc
, int *found
)
4485 struct udf_node
*dir_node
= VTOI(vp
);
4486 struct dirhash
*dirh
;
4487 struct dirhash_entry
*dirh_ep
;
4488 struct fileid_desc
*fid
;
4489 struct dirent
*dirent
;
4494 /* set default return */
4497 /* get our dirhash and make sure its read in */
4498 dirhash_get(&dir_node
->dir_hash
);
4499 error
= udf_dirhash_fill(dir_node
);
4501 dirhash_put(dir_node
->dir_hash
);
4504 dirh
= dir_node
->dir_hash
;
4506 /* allocate temporary space for fid */
4507 lb_size
= udf_rw32(dir_node
->ump
->logical_vol
->lb_size
);
4508 fid
= malloc(lb_size
, M_UDFTEMP
, M_WAITOK
);
4509 dirent
= malloc(sizeof(struct dirent
), M_UDFTEMP
, M_WAITOK
);
4511 DPRINTF(DIRHASH
, ("dirhash_lookup looking for `%*.*s`\n",
4512 namelen
, namelen
, name
));
4514 /* search our dirhash hits */
4515 memset(icb_loc
, 0, sizeof(*icb_loc
));
4518 hit
= dirhash_lookup(dirh
, name
, namelen
, &dirh_ep
);
4519 /* if no hit, abort the search */
4523 /* check this hit */
4524 diroffset
= dirh_ep
->offset
;
4526 /* transfer a new fid/dirent */
4527 error
= udf_read_fid_stream(vp
, &diroffset
, fid
, dirent
);
4531 DPRINTF(DIRHASH
, ("dirhash_lookup\tchecking `%*.*s`\n",
4532 dirent
->d_namlen
, dirent
->d_namlen
, dirent
->d_name
));
4534 /* see if its our entry */
4536 if (dirent
->d_namlen
!= namelen
) {
4537 printf("WARNING: dirhash_lookup() returned wrong "
4538 "d_namelen: %d and ought to be %d\n",
4539 dirent
->d_namlen
, namelen
);
4540 printf("\tlooked for `%s' and got `%s'\n",
4541 name
, dirent
->d_name
);
4544 if (strncmp(dirent
->d_name
, name
, namelen
) == 0) {
4546 *icb_loc
= fid
->icb
;
4550 free(fid
, M_UDFTEMP
);
4551 free(dirent
, M_UDFTEMP
);
4553 dirhash_put(dir_node
->dir_hash
);
4558 /* --------------------------------------------------------------------- */
4561 udf_create_new_fe(struct udf_mount
*ump
, struct file_entry
*fe
, int file_type
,
4562 struct long_ad
*node_icb
, struct long_ad
*parent_icb
,
4563 uint64_t parent_unique_id
)
4565 struct timespec now
;
4566 struct icb_tag
*icb
;
4567 struct filetimes_extattr_entry
*ft_extattr
;
4569 uint32_t fidsize
, lb_num
;
4571 int crclen
, attrlen
;
4573 lb_num
= udf_rw32(node_icb
->loc
.lb_num
);
4574 udf_inittag(ump
, &fe
->tag
, TAGID_FENTRY
, lb_num
);
4578 * Always use strategy type 4 unless on WORM wich we don't support
4579 * (yet). Fill in defaults and set for internal allocation of data.
4581 icb
->strat_type
= udf_rw16(4);
4582 icb
->max_num_entries
= udf_rw16(1);
4583 icb
->file_type
= file_type
; /* 8 bit */
4584 icb
->flags
= udf_rw16(UDF_ICB_INTERN_ALLOC
);
4586 fe
->perm
= udf_rw32(0x7fff); /* all is allowed */
4587 fe
->link_cnt
= udf_rw16(0); /* explicit setting */
4589 fe
->ckpoint
= udf_rw32(1); /* user supplied file version */
4591 vfs_timestamp(&now
);
4592 udf_timespec_to_timestamp(&now
, &fe
->atime
);
4593 udf_timespec_to_timestamp(&now
, &fe
->attrtime
);
4594 udf_timespec_to_timestamp(&now
, &fe
->mtime
);
4596 udf_set_regid(&fe
->imp_id
, IMPL_NAME
);
4597 udf_add_impl_regid(ump
, &fe
->imp_id
);
4599 unique_id
= udf_advance_uniqueid(ump
);
4600 fe
->unique_id
= udf_rw64(unique_id
);
4601 fe
->l_ea
= udf_rw32(0);
4603 /* create extended attribute to record our creation time */
4604 attrlen
= UDF_FILETIMES_ATTR_SIZE(1);
4605 ft_extattr
= malloc(attrlen
, M_UDFTEMP
, M_WAITOK
);
4606 memset(ft_extattr
, 0, attrlen
);
4607 ft_extattr
->hdr
.type
= udf_rw32(UDF_FILETIMES_ATTR_NO
);
4608 ft_extattr
->hdr
.subtype
= 1; /* [4/48.10.5] */
4609 ft_extattr
->hdr
.a_l
= udf_rw32(UDF_FILETIMES_ATTR_SIZE(1));
4610 ft_extattr
->d_l
= udf_rw32(UDF_TIMESTAMP_SIZE
); /* one item */
4611 ft_extattr
->existence
= UDF_FILETIMES_FILE_CREATION
;
4612 udf_timespec_to_timestamp(&now
, &ft_extattr
->times
[0]);
4614 udf_extattr_insert_internal(ump
, (union dscrptr
*) fe
,
4615 (struct extattr_entry
*) ft_extattr
);
4616 free(ft_extattr
, M_UDFTEMP
);
4618 /* if its a directory, create '..' */
4619 bpos
= (uint8_t *) fe
->data
+ udf_rw32(fe
->l_ea
);
4621 if (file_type
== UDF_ICB_FILETYPE_DIRECTORY
) {
4622 fidsize
= udf_create_parentfid(ump
,
4623 (struct fileid_desc
*) bpos
, parent_icb
,
4627 /* record fidlength information */
4628 fe
->inf_len
= udf_rw64(fidsize
);
4629 fe
->l_ad
= udf_rw32(fidsize
);
4630 fe
->logblks_rec
= udf_rw64(0); /* intern */
4632 crclen
= sizeof(struct file_entry
) - 1 - UDF_DESC_TAG_LENGTH
;
4633 crclen
+= udf_rw32(fe
->l_ea
) + fidsize
;
4634 fe
->tag
.desc_crc_len
= udf_rw16(crclen
);
4636 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) fe
);
4641 /* --------------------------------------------------------------------- */
4644 udf_create_new_efe(struct udf_mount
*ump
, struct extfile_entry
*efe
,
4645 int file_type
, struct long_ad
*node_icb
, struct long_ad
*parent_icb
,
4646 uint64_t parent_unique_id
)
4648 struct timespec now
;
4649 struct icb_tag
*icb
;
4651 uint32_t fidsize
, lb_num
;
4655 lb_num
= udf_rw32(node_icb
->loc
.lb_num
);
4656 udf_inittag(ump
, &efe
->tag
, TAGID_EXTFENTRY
, lb_num
);
4660 * Always use strategy type 4 unless on WORM wich we don't support
4661 * (yet). Fill in defaults and set for internal allocation of data.
4663 icb
->strat_type
= udf_rw16(4);
4664 icb
->max_num_entries
= udf_rw16(1);
4665 icb
->file_type
= file_type
; /* 8 bit */
4666 icb
->flags
= udf_rw16(UDF_ICB_INTERN_ALLOC
);
4668 efe
->perm
= udf_rw32(0x7fff); /* all is allowed */
4669 efe
->link_cnt
= udf_rw16(0); /* explicit setting */
4671 efe
->ckpoint
= udf_rw32(1); /* user supplied file version */
4673 vfs_timestamp(&now
);
4674 udf_timespec_to_timestamp(&now
, &efe
->ctime
);
4675 udf_timespec_to_timestamp(&now
, &efe
->atime
);
4676 udf_timespec_to_timestamp(&now
, &efe
->attrtime
);
4677 udf_timespec_to_timestamp(&now
, &efe
->mtime
);
4679 udf_set_regid(&efe
->imp_id
, IMPL_NAME
);
4680 udf_add_impl_regid(ump
, &efe
->imp_id
);
4682 unique_id
= udf_advance_uniqueid(ump
);
4683 efe
->unique_id
= udf_rw64(unique_id
);
4684 efe
->l_ea
= udf_rw32(0);
4686 /* if its a directory, create '..' */
4687 bpos
= (uint8_t *) efe
->data
+ udf_rw32(efe
->l_ea
);
4689 if (file_type
== UDF_ICB_FILETYPE_DIRECTORY
) {
4690 fidsize
= udf_create_parentfid(ump
,
4691 (struct fileid_desc
*) bpos
, parent_icb
,
4695 /* record fidlength information */
4696 efe
->obj_size
= udf_rw64(fidsize
);
4697 efe
->inf_len
= udf_rw64(fidsize
);
4698 efe
->l_ad
= udf_rw32(fidsize
);
4699 efe
->logblks_rec
= udf_rw64(0); /* intern */
4701 crclen
= sizeof(struct extfile_entry
) - 1 - UDF_DESC_TAG_LENGTH
;
4702 crclen
+= udf_rw32(efe
->l_ea
) + fidsize
;
4703 efe
->tag
.desc_crc_len
= udf_rw16(crclen
);
4705 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) efe
);
4710 /* --------------------------------------------------------------------- */
4713 udf_dir_detach(struct udf_mount
*ump
, struct udf_node
*dir_node
,
4714 struct udf_node
*udf_node
, struct componentname
*cnp
)
4716 struct vnode
*dvp
= dir_node
->vnode
;
4717 struct dirhash
*dirh
;
4718 struct dirhash_entry
*dirh_ep
;
4719 struct file_entry
*fe
= dir_node
->fe
;
4720 struct fileid_desc
*fid
;
4721 struct dirent
*dirent
;
4723 uint32_t lb_size
, fidsize
;
4725 char const *name
= cnp
->cn_nameptr
;
4726 int namelen
= cnp
->cn_namelen
;
4729 /* get our dirhash and make sure its read in */
4730 dirhash_get(&dir_node
->dir_hash
);
4731 error
= udf_dirhash_fill(dir_node
);
4733 dirhash_put(dir_node
->dir_hash
);
4736 dirh
= dir_node
->dir_hash
;
4738 /* get directory filesize */
4740 assert(dir_node
->efe
);
4743 /* allocate temporary space for fid */
4744 lb_size
= udf_rw32(dir_node
->ump
->logical_vol
->lb_size
);
4745 fid
= malloc(lb_size
, M_UDFTEMP
, M_WAITOK
);
4746 dirent
= malloc(sizeof(struct dirent
), M_UDFTEMP
, M_WAITOK
);
4748 /* search our dirhash hits */
4752 hit
= dirhash_lookup(dirh
, name
, namelen
, &dirh_ep
);
4753 /* if no hit, abort the search */
4757 /* check this hit */
4758 diroffset
= dirh_ep
->offset
;
4760 /* transfer a new fid/dirent */
4761 error
= udf_read_fid_stream(dvp
, &diroffset
, fid
, dirent
);
4765 /* see if its our entry */
4766 KASSERT(dirent
->d_namlen
== namelen
);
4767 if (strncmp(dirent
->d_name
, name
, namelen
) == 0) {
4779 fid
->file_char
|= UDF_FILE_CHAR_DEL
;
4780 #ifdef UDF_COMPLETE_DELETE
4781 memset(&fid
->icb
, 0, sizeof(fid
->icb
));
4783 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) fid
);
4785 /* get size of fid and compensate for the read_fid_stream advance */
4786 fidsize
= udf_fidsize(fid
);
4787 diroffset
-= fidsize
;
4790 error
= vn_rdwr(UIO_WRITE
, dir_node
->vnode
,
4791 fid
, fidsize
, diroffset
,
4792 UIO_SYSSPACE
, IO_ALTSEMANTICS
| IO_NODELOCKED
,
4793 FSCRED
, NULL
, NULL
);
4797 /* get reference count of attached node */
4799 refcnt
= udf_rw16(udf_node
->fe
->link_cnt
);
4801 KASSERT(udf_node
->efe
);
4802 refcnt
= udf_rw16(udf_node
->efe
->link_cnt
);
4804 #ifdef UDF_COMPLETE_DELETE
4805 /* substract reference counter in attached node */
4808 udf_node
->fe
->link_cnt
= udf_rw16(refcnt
);
4810 udf_node
->efe
->link_cnt
= udf_rw16(refcnt
);
4813 /* prevent writeout when refcnt == 0 */
4815 udf_node
->i_flags
|= IN_DELETED
;
4817 if (fid
->file_char
& UDF_FILE_CHAR_DIR
) {
4820 /* substract reference counter in directory node */
4821 /* note subtract 2 (?) for its was also backreferenced */
4823 drefcnt
= udf_rw16(dir_node
->fe
->link_cnt
);
4825 dir_node
->fe
->link_cnt
= udf_rw16(drefcnt
);
4827 KASSERT(dir_node
->efe
);
4828 drefcnt
= udf_rw16(dir_node
->efe
->link_cnt
);
4830 dir_node
->efe
->link_cnt
= udf_rw16(drefcnt
);
4834 udf_node
->i_flags
|= IN_MODIFIED
;
4835 dir_node
->i_flags
|= IN_MODIFIED
;
4837 /* if it is/was a hardlink adjust the file count */
4839 udf_adjust_filecount(udf_node
, -1);
4841 /* remove from the dirhash */
4842 dirhash_remove(dirh
, dirent
, diroffset
,
4846 free(fid
, M_UDFTEMP
);
4847 free(dirent
, M_UDFTEMP
);
4849 dirhash_put(dir_node
->dir_hash
);
4854 /* --------------------------------------------------------------------- */
4857 udf_dir_update_rootentry(struct udf_mount
*ump
, struct udf_node
*dir_node
,
4858 struct udf_node
*new_parent_node
)
4860 struct vnode
*dvp
= dir_node
->vnode
;
4861 struct dirhash
*dirh
;
4862 struct dirhash_entry
*dirh_ep
;
4863 struct file_entry
*fe
;
4864 struct extfile_entry
*efe
;
4865 struct fileid_desc
*fid
;
4866 struct dirent
*dirent
;
4868 uint64_t new_parent_unique_id
;
4869 uint32_t lb_size
, fidsize
;
4871 char const *name
= "..";
4875 /* get our dirhash and make sure its read in */
4876 dirhash_get(&dir_node
->dir_hash
);
4877 error
= udf_dirhash_fill(dir_node
);
4879 dirhash_put(dir_node
->dir_hash
);
4882 dirh
= dir_node
->dir_hash
;
4884 /* get new parent's unique ID */
4885 fe
= new_parent_node
->fe
;
4886 efe
= new_parent_node
->efe
;
4888 new_parent_unique_id
= udf_rw64(fe
->unique_id
);
4891 new_parent_unique_id
= udf_rw64(efe
->unique_id
);
4894 /* get directory filesize */
4896 efe
= dir_node
->efe
;
4901 /* allocate temporary space for fid */
4902 lb_size
= udf_rw32(dir_node
->ump
->logical_vol
->lb_size
);
4903 fid
= malloc(lb_size
, M_UDFTEMP
, M_WAITOK
);
4904 dirent
= malloc(sizeof(struct dirent
), M_UDFTEMP
, M_WAITOK
);
4907 * NOTE the standard does not dictate the FID entry '..' should be
4908 * first, though in practice it will most likely be.
4911 /* search our dirhash hits */
4915 hit
= dirhash_lookup(dirh
, name
, namelen
, &dirh_ep
);
4916 /* if no hit, abort the search */
4920 /* check this hit */
4921 diroffset
= dirh_ep
->offset
;
4923 /* transfer a new fid/dirent */
4924 error
= udf_read_fid_stream(dvp
, &diroffset
, fid
, dirent
);
4928 /* see if its our entry */
4929 KASSERT(dirent
->d_namlen
== namelen
);
4930 if (strncmp(dirent
->d_name
, name
, namelen
) == 0) {
4941 /* update our ICB to the new parent, hit of lower 32 bits of uniqueid */
4942 fid
->icb
= new_parent_node
->write_loc
;
4943 fid
->icb
.longad_uniqueid
= udf_rw32(new_parent_unique_id
);
4945 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) fid
);
4947 /* get size of fid and compensate for the read_fid_stream advance */
4948 fidsize
= udf_fidsize(fid
);
4949 diroffset
-= fidsize
;
4952 error
= vn_rdwr(UIO_WRITE
, dir_node
->vnode
,
4953 fid
, fidsize
, diroffset
,
4954 UIO_SYSSPACE
, IO_ALTSEMANTICS
| IO_NODELOCKED
,
4955 FSCRED
, NULL
, NULL
);
4957 /* nothing to be done in the dirhash */
4960 free(fid
, M_UDFTEMP
);
4961 free(dirent
, M_UDFTEMP
);
4963 dirhash_put(dir_node
->dir_hash
);
4968 /* --------------------------------------------------------------------- */
4971 * We are not allowed to split the fid tag itself over an logical block so
4972 * check the space remaining in the logical block.
4974 * We try to select the smallest candidate for recycling or when none is
4975 * found, append a new one at the end of the directory.
4979 udf_dir_attach(struct udf_mount
*ump
, struct udf_node
*dir_node
,
4980 struct udf_node
*udf_node
, struct vattr
*vap
, struct componentname
*cnp
)
4982 struct vnode
*dvp
= dir_node
->vnode
;
4983 struct dirhash
*dirh
;
4984 struct dirhash_entry
*dirh_ep
;
4985 struct fileid_desc
*fid
;
4986 struct icb_tag
*icbtag
;
4987 struct charspec osta_charspec
;
4988 struct dirent dirent
;
4989 uint64_t unique_id
, dir_size
;
4990 uint64_t fid_pos
, end_fid_pos
, chosen_fid_pos
;
4991 uint32_t chosen_size
, chosen_size_diff
;
4992 int lb_size
, lb_rest
, fidsize
, this_fidsize
, size_diff
;
4993 int file_char
, refcnt
, icbflags
, addr_type
, hit
, error
;
4995 /* get our dirhash and make sure its read in */
4996 dirhash_get(&dir_node
->dir_hash
);
4997 error
= udf_dirhash_fill(dir_node
);
4999 dirhash_put(dir_node
->dir_hash
);
5002 dirh
= dir_node
->dir_hash
;
5005 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
5006 udf_osta_charset(&osta_charspec
);
5009 dir_size
= udf_rw64(dir_node
->fe
->inf_len
);
5010 icbtag
= &dir_node
->fe
->icbtag
;
5012 dir_size
= udf_rw64(dir_node
->efe
->inf_len
);
5013 icbtag
= &dir_node
->efe
->icbtag
;
5016 icbflags
= udf_rw16(icbtag
->flags
);
5017 addr_type
= icbflags
& UDF_ICB_TAG_FLAGS_ALLOC_MASK
;
5020 unique_id
= udf_rw64(udf_node
->fe
->unique_id
);
5021 refcnt
= udf_rw16(udf_node
->fe
->link_cnt
);
5023 unique_id
= udf_rw64(udf_node
->efe
->unique_id
);
5024 refcnt
= udf_rw16(udf_node
->efe
->link_cnt
);
5028 unique_id
= udf_advance_uniqueid(ump
);
5029 udf_adjust_filecount(udf_node
, 1);
5032 /* determine file characteristics */
5033 file_char
= 0; /* visible non deleted file and not stream metadata */
5034 if (vap
->va_type
== VDIR
)
5035 file_char
= UDF_FILE_CHAR_DIR
;
5037 /* malloc scrap buffer */
5038 fid
= malloc(lb_size
, M_TEMP
, M_WAITOK
|M_ZERO
);
5040 /* calculate _minimum_ fid size */
5041 unix_to_udf_name((char *) fid
->data
, &fid
->l_fi
,
5042 cnp
->cn_nameptr
, cnp
->cn_namelen
, &osta_charspec
);
5043 fidsize
= UDF_FID_SIZE
+ fid
->l_fi
;
5044 fidsize
= (fidsize
+ 3) & ~3; /* multiple of 4 */
5046 /* find position that will fit the FID */
5047 chosen_fid_pos
= dir_size
;
5049 chosen_size_diff
= UINT_MAX
;
5052 dirent
.d_namlen
= 0;
5054 /* search our dirhash hits */
5058 hit
= dirhash_lookup_freed(dirh
, fidsize
, &dirh_ep
);
5059 /* if no hit, abort the search */
5063 /* check this hit for size */
5064 this_fidsize
= dirh_ep
->entry_size
;
5066 /* check this hit */
5067 fid_pos
= dirh_ep
->offset
;
5068 end_fid_pos
= fid_pos
+ this_fidsize
;
5069 size_diff
= this_fidsize
- fidsize
;
5070 lb_rest
= lb_size
- (end_fid_pos
% lb_size
);
5072 #ifndef UDF_COMPLETE_DELETE
5073 /* transfer a new fid/dirent */
5074 error
= udf_read_fid_stream(vp
, &fid_pos
, fid
, dirent
);
5078 /* only reuse entries that are wiped */
5079 /* check if the len + loc are marked zero */
5080 if (udf_rw32(fid
->icb
.len
) != 0)
5082 if (udf_rw32(fid
->icb
.loc
.lb_num
) != 0)
5084 if (udf_rw16(fid
->icb
.loc
.part_num
) != 0)
5086 #endif /* UDF_COMPLETE_DELETE */
5088 /* select if not splitting the tag and its smaller */
5089 if ((size_diff
>= 0) &&
5090 (size_diff
< chosen_size_diff
) &&
5091 (lb_rest
>= sizeof(struct desc_tag
)))
5093 /* UDF 2.3.4.2+3 specifies rules for iu size */
5094 if ((size_diff
== 0) || (size_diff
>= 32)) {
5095 chosen_fid_pos
= fid_pos
;
5096 chosen_size
= this_fidsize
;
5097 chosen_size_diff
= size_diff
;
5103 /* extend directory if no other candidate found */
5104 if (chosen_size
== 0) {
5105 chosen_fid_pos
= dir_size
;
5106 chosen_size
= fidsize
;
5107 chosen_size_diff
= 0;
5109 /* special case UDF 2.00+ 2.3.4.4, no splitting up fid tag */
5110 if (addr_type
== UDF_ICB_INTERN_ALLOC
) {
5111 /* pre-grow directory to see if we're to switch */
5112 udf_grow_node(dir_node
, dir_size
+ chosen_size
);
5114 icbflags
= udf_rw16(icbtag
->flags
);
5115 addr_type
= icbflags
& UDF_ICB_TAG_FLAGS_ALLOC_MASK
;
5118 /* make sure the next fid desc_tag won't be splitted */
5119 if (addr_type
!= UDF_ICB_INTERN_ALLOC
) {
5120 end_fid_pos
= chosen_fid_pos
+ chosen_size
;
5121 lb_rest
= lb_size
- (end_fid_pos
% lb_size
);
5123 /* pad with implementation use regid if needed */
5124 if (lb_rest
< sizeof(struct desc_tag
))
5128 chosen_size_diff
= chosen_size
- fidsize
;
5130 /* populate the FID */
5131 memset(fid
, 0, lb_size
);
5132 udf_inittag(ump
, &fid
->tag
, TAGID_FID
, 0);
5133 fid
->file_version_num
= udf_rw16(1); /* UDF 2.3.4.1 */
5134 fid
->file_char
= file_char
;
5135 fid
->icb
= udf_node
->loc
;
5136 fid
->icb
.longad_uniqueid
= udf_rw32((uint32_t) unique_id
);
5137 fid
->l_iu
= udf_rw16(0);
5139 if (chosen_size
> fidsize
) {
5140 /* insert implementation-use regid to space it correctly */
5141 fid
->l_iu
= udf_rw16(chosen_size_diff
);
5143 /* set implementation use */
5144 udf_set_regid((struct regid
*) fid
->data
, IMPL_NAME
);
5145 udf_add_impl_regid(ump
, (struct regid
*) fid
->data
);
5149 unix_to_udf_name((char *) fid
->data
+ udf_rw16(fid
->l_iu
),
5150 &fid
->l_fi
, cnp
->cn_nameptr
, cnp
->cn_namelen
, &osta_charspec
);
5152 fid
->tag
.desc_crc_len
= udf_rw16(chosen_size
- UDF_DESC_TAG_LENGTH
);
5153 (void) udf_validate_tag_and_crc_sums((union dscrptr
*) fid
);
5155 /* writeout FID/update parent directory */
5156 error
= vn_rdwr(UIO_WRITE
, dvp
,
5157 fid
, chosen_size
, chosen_fid_pos
,
5158 UIO_SYSSPACE
, IO_ALTSEMANTICS
| IO_NODELOCKED
,
5159 FSCRED
, NULL
, NULL
);
5164 /* add reference counter in attached node */
5166 refcnt
= udf_rw16(udf_node
->fe
->link_cnt
);
5167 udf_node
->fe
->link_cnt
= udf_rw16(refcnt
+1);
5169 KASSERT(udf_node
->efe
);
5170 refcnt
= udf_rw16(udf_node
->efe
->link_cnt
);
5171 udf_node
->efe
->link_cnt
= udf_rw16(refcnt
+1);
5174 /* mark not deleted if it was... just in case, but do warn */
5175 if (udf_node
->i_flags
& IN_DELETED
) {
5176 printf("udf: warning, marking a file undeleted\n");
5177 udf_node
->i_flags
&= ~IN_DELETED
;
5180 if (file_char
& UDF_FILE_CHAR_DIR
) {
5181 /* add reference counter in directory node for '..' */
5183 refcnt
= udf_rw16(dir_node
->fe
->link_cnt
);
5185 dir_node
->fe
->link_cnt
= udf_rw16(refcnt
);
5187 KASSERT(dir_node
->efe
);
5188 refcnt
= udf_rw16(dir_node
->efe
->link_cnt
);
5190 dir_node
->efe
->link_cnt
= udf_rw16(refcnt
);
5194 /* append to the dirhash */
5195 /* NOTE do not use dirent anymore or it won't match later! */
5196 udf_to_unix_name(dirent
.d_name
, NAME_MAX
,
5197 (char *) fid
->data
+ udf_rw16(fid
->l_iu
), fid
->l_fi
, &osta_charspec
);
5198 dirent
.d_namlen
= strlen(dirent
.d_name
);
5199 dirhash_enter(dirh
, &dirent
, chosen_fid_pos
,
5200 udf_fidsize(fid
), 1);
5203 udf_node
->i_flags
|= IN_CHANGE
| IN_MODIFY
; /* | IN_CREATE? */
5204 /* VN_KNOTE(udf_node, ...) */
5205 udf_update(udf_node
->vnode
, NULL
, NULL
, NULL
, 0);
5210 dirhash_put(dir_node
->dir_hash
);
5215 /* --------------------------------------------------------------------- */
5218 * Each node can have an attached streamdir node though not recursively. These
5219 * are otherwise known as named substreams/named extended attributes that have
5220 * no size limitations.
5222 * `Normal' extended attributes are indicated with a number and are recorded
5223 * in either the fe/efe descriptor itself for small descriptors or recorded in
5224 * the attached extended attribute file. Since these spaces can get
5225 * fragmented, care ought to be taken.
5227 * Since the size of the space reserved for allocation descriptors is limited,
5228 * there is a mechanim provided for extending this space; this is done by a
5229 * special extent to allow schrinking of the allocations without breaking the
5230 * linkage to the allocation extent descriptor.
5234 udf_loadvnode(struct mount
*mp
, struct vnode
*vp
,
5235 const void *key
, size_t key_len
, const void **new_key
)
5237 union dscrptr
*dscr
;
5238 struct udf_mount
*ump
;
5239 struct udf_node
*udf_node
;
5240 struct long_ad node_icb_loc
, icb_loc
, next_icb_loc
, last_fe_icb_loc
;
5242 uint32_t lb_size
, sector
, dummy
;
5243 int udf_file_type
, dscr_type
, strat
, strat4096
, needs_indirect
;
5244 int slot
, eof
, error
;
5245 int num_indir_followed
= 0;
5247 DPRINTF(NODE
, ("udf_loadvnode called\n"));
5251 KASSERT(key_len
== sizeof(node_icb_loc
.loc
));
5252 memset(&node_icb_loc
, 0, sizeof(node_icb_loc
));
5253 node_icb_loc
.len
= ump
->logical_vol
->lb_size
;
5254 memcpy(&node_icb_loc
.loc
, key
, key_len
);
5256 /* garbage check: translate udf_node_icb_loc to sectornr */
5257 error
= udf_translate_vtop(ump
, &node_icb_loc
, §or
, &dummy
);
5259 DPRINTF(NODE
, ("\tcan't translate icb address!\n"));
5260 /* no use, this will fail anyway */
5264 /* build udf_node (do initialise!) */
5265 udf_node
= pool_get(&udf_node_pool
, PR_WAITOK
);
5266 memset(udf_node
, 0, sizeof(struct udf_node
));
5269 vp
->v_op
= udf_vnodeop_p
;
5270 vp
->v_data
= udf_node
;
5272 /* initialise crosslinks, note location of fe/efe for hashing */
5273 udf_node
->ump
= ump
;
5274 udf_node
->vnode
= vp
;
5275 udf_node
->loc
= node_icb_loc
;
5276 udf_node
->lockf
= 0;
5277 mutex_init(&udf_node
->node_mutex
, MUTEX_DEFAULT
, IPL_NONE
);
5278 cv_init(&udf_node
->node_lock
, "udf_nlk");
5279 genfs_node_init(vp
, &udf_genfsops
); /* inititise genfs */
5280 udf_node
->outstanding_bufs
= 0;
5281 udf_node
->outstanding_nodedscr
= 0;
5282 udf_node
->uncommitted_lbs
= 0;
5284 /* check if we're fetching the root */
5285 if (ump
->fileset_desc
)
5286 if (memcmp(&udf_node
->loc
, &ump
->fileset_desc
->rootdir_icb
,
5287 sizeof(struct long_ad
)) == 0)
5288 vp
->v_vflag
|= VV_ROOT
;
5290 icb_loc
= node_icb_loc
;
5293 udf_file_type
= UDF_ICB_FILETYPE_UNKNOWN
;
5295 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
5297 DPRINTF(NODE
, ("\tstart reading descriptors\n"));
5299 /* try to read in fe/efe */
5300 error
= udf_read_logvol_dscr(ump
, &icb_loc
, &dscr
);
5302 /* blank sector marks end of sequence, check this */
5303 if ((dscr
== NULL
) && (!strat4096
))
5306 /* break if read error or blank sector */
5307 if (error
|| (dscr
== NULL
))
5310 /* process descriptor based on the descriptor type */
5311 dscr_type
= udf_rw16(dscr
->tag
.id
);
5312 DPRINTF(NODE
, ("\tread descriptor %d\n", dscr_type
));
5314 /* if dealing with an indirect entry, follow the link */
5315 if (dscr_type
== TAGID_INDIRECTENTRY
) {
5317 next_icb_loc
= dscr
->inde
.indirect_icb
;
5318 udf_free_logvol_dscr(ump
, &icb_loc
, dscr
);
5319 icb_loc
= next_icb_loc
;
5320 if (++num_indir_followed
> UDF_MAX_INDIRS_FOLLOW
) {
5327 /* only file entries and extended file entries allowed here */
5328 if ((dscr_type
!= TAGID_FENTRY
) &&
5329 (dscr_type
!= TAGID_EXTFENTRY
)) {
5330 udf_free_logvol_dscr(ump
, &icb_loc
, dscr
);
5335 KASSERT(udf_tagsize(dscr
, lb_size
) == lb_size
);
5337 /* choose this one */
5338 last_fe_icb_loc
= icb_loc
;
5340 /* record and process/update (ext)fentry */
5341 if (dscr_type
== TAGID_FENTRY
) {
5343 udf_free_logvol_dscr(ump
, &last_fe_icb_loc
,
5345 udf_node
->fe
= &dscr
->fe
;
5346 strat
= udf_rw16(udf_node
->fe
->icbtag
.strat_type
);
5347 udf_file_type
= udf_node
->fe
->icbtag
.file_type
;
5348 file_size
= udf_rw64(udf_node
->fe
->inf_len
);
5351 udf_free_logvol_dscr(ump
, &last_fe_icb_loc
,
5353 udf_node
->efe
= &dscr
->efe
;
5354 strat
= udf_rw16(udf_node
->efe
->icbtag
.strat_type
);
5355 udf_file_type
= udf_node
->efe
->icbtag
.file_type
;
5356 file_size
= udf_rw64(udf_node
->efe
->inf_len
);
5359 /* check recording strategy (structure) */
5362 * Strategy 4096 is a daisy linked chain terminating with an
5363 * unrecorded sector or a TERM descriptor. The next
5364 * descriptor is to be found in the sector that follows the
5367 if (strat
== 4096) {
5371 icb_loc
.loc
.lb_num
= udf_rw32(icb_loc
.loc
.lb_num
) + 1;
5375 * Strategy 4 is the normal strategy and terminates, but if
5376 * we're in strategy 4096, we can't have strategy 4 mixed in
5388 /* first round of cleanup code */
5390 DPRINTF(NODE
, ("\tnode fe/efe failed!\n"));
5391 /* recycle udf_node */
5392 udf_dispose_node(udf_node
);
5394 return EINVAL
; /* error code ok? */
5396 DPRINTF(NODE
, ("\tnode fe/efe read in fine\n"));
5398 /* assert no references to dscr anymore beyong this point */
5399 assert((udf_node
->fe
) || (udf_node
->efe
));
5403 * Remember where to record an updated version of the descriptor. If
5404 * there is a sequence of indirect entries, icb_loc will have been
5405 * updated. Its the write disipline to allocate new space and to make
5406 * sure the chain is maintained.
5408 * `needs_indirect' flags if the next location is to be filled with
5409 * with an indirect entry.
5411 udf_node
->write_loc
= icb_loc
;
5412 udf_node
->needs_indirect
= needs_indirect
;
5415 * Go trough all allocations extents of this descriptor and when
5416 * encountering a redirect read in the allocation extension. These are
5419 UDF_LOCK_NODE(udf_node
, 0);
5420 udf_node
->num_extensions
= 0;
5425 udf_get_adslot(udf_node
, slot
, &icb_loc
, &eof
);
5426 DPRINTF(ADWLK
, ("slot %d, eof = %d, flags = %d, len = %d, "
5427 "lb_num = %d, part = %d\n", slot
, eof
,
5428 UDF_EXT_FLAGS(udf_rw32(icb_loc
.len
)),
5429 UDF_EXT_LEN(udf_rw32(icb_loc
.len
)),
5430 udf_rw32(icb_loc
.loc
.lb_num
),
5431 udf_rw16(icb_loc
.loc
.part_num
)));
5436 if (UDF_EXT_FLAGS(udf_rw32(icb_loc
.len
)) != UDF_EXT_REDIRECT
)
5439 DPRINTF(NODE
, ("\tgot redirect extent\n"));
5440 if (udf_node
->num_extensions
>= UDF_MAX_ALLOC_EXTENTS
) {
5441 DPRINTF(ALLOC
, ("udf_get_node: implementation limit, "
5442 "too many allocation extensions on "
5448 /* length can only be *one* lb : UDF 2.50/2.3.7.1 */
5449 if (UDF_EXT_LEN(udf_rw32(icb_loc
.len
)) != lb_size
) {
5450 DPRINTF(ALLOC
, ("udf_get_node: bad allocation "
5451 "extension size in udf_node\n"));
5456 DPRINTF(NODE
, ("read allocation extent at lb_num %d\n",
5457 UDF_EXT_LEN(udf_rw32(icb_loc
.loc
.lb_num
))));
5458 /* load in allocation extent */
5459 error
= udf_read_logvol_dscr(ump
, &icb_loc
, &dscr
);
5460 if (error
|| (dscr
== NULL
))
5463 /* process read-in descriptor */
5464 dscr_type
= udf_rw16(dscr
->tag
.id
);
5466 if (dscr_type
!= TAGID_ALLOCEXTENT
) {
5467 udf_free_logvol_dscr(ump
, &icb_loc
, dscr
);
5472 DPRINTF(NODE
, ("\trecording redirect extent\n"));
5473 udf_node
->ext
[udf_node
->num_extensions
] = &dscr
->aee
;
5474 udf_node
->ext_loc
[udf_node
->num_extensions
] = icb_loc
;
5476 udf_node
->num_extensions
++;
5479 UDF_UNLOCK_NODE(udf_node
, 0);
5481 /* second round of cleanup code */
5483 /* recycle udf_node */
5484 udf_dispose_node(udf_node
);
5486 return EINVAL
; /* error code ok? */
5489 DPRINTF(NODE
, ("\tnode read in fine\n"));
5492 * Translate UDF filetypes into vnode types.
5494 * Systemfiles like the meta main and mirror files are not treated as
5495 * normal files, so we type them as having no type. UDF dictates that
5496 * they are not allowed to be visible.
5499 switch (udf_file_type
) {
5500 case UDF_ICB_FILETYPE_DIRECTORY
:
5501 case UDF_ICB_FILETYPE_STREAMDIR
:
5504 case UDF_ICB_FILETYPE_BLOCKDEVICE
:
5507 case UDF_ICB_FILETYPE_CHARDEVICE
:
5510 case UDF_ICB_FILETYPE_SOCKET
:
5513 case UDF_ICB_FILETYPE_FIFO
:
5516 case UDF_ICB_FILETYPE_SYMLINK
:
5519 case UDF_ICB_FILETYPE_VAT
:
5520 case UDF_ICB_FILETYPE_META_MAIN
:
5521 case UDF_ICB_FILETYPE_META_MIRROR
:
5524 case UDF_ICB_FILETYPE_RANDOMACCESS
:
5525 case UDF_ICB_FILETYPE_REALTIME
:
5529 /* YIKES, something else */
5533 /* TODO specfs, fifofs etc etc. vnops setting */
5535 /* don't forget to set vnode's v_size */
5536 uvm_vnp_setsize(vp
, file_size
);
5538 /* TODO ext attr and streamdir udf_nodes */
5540 *new_key
= &udf_node
->loc
.loc
;
5546 udf_get_node(struct udf_mount
*ump
, struct long_ad
*node_icb_loc
,
5547 struct udf_node
**udf_noderes
)
5552 error
= vcache_get(ump
->vfs_mountp
, &node_icb_loc
->loc
,
5553 sizeof(node_icb_loc
->loc
), &vp
);
5556 error
= vn_lock(vp
, LK_EXCLUSIVE
);
5561 *udf_noderes
= VTOI(vp
);
5565 /* --------------------------------------------------------------------- */
5568 udf_writeout_node(struct udf_node
*udf_node
, int waitfor
)
5570 union dscrptr
*dscr
;
5571 struct long_ad
*loc
;
5574 DPRINTF(NODE
, ("udf_writeout_node called\n"));
5576 KASSERT(udf_node
->outstanding_bufs
== 0);
5577 KASSERT(udf_node
->outstanding_nodedscr
== 0);
5579 KASSERT(LIST_EMPTY(&udf_node
->vnode
->v_dirtyblkhd
));
5581 if (udf_node
->i_flags
& IN_DELETED
) {
5582 DPRINTF(NODE
, ("\tnode deleted; not writing out\n"));
5583 udf_cleanup_reservation(udf_node
);
5587 /* lock node; unlocked in callback */
5588 UDF_LOCK_NODE(udf_node
, 0);
5590 /* remove pending reservations, we're written out */
5591 udf_cleanup_reservation(udf_node
);
5593 /* at least one descriptor writeout */
5594 udf_node
->outstanding_nodedscr
= 1;
5596 /* we're going to write out the descriptor so clear the flags */
5597 udf_node
->i_flags
&= ~(IN_MODIFIED
| IN_ACCESSED
);
5599 /* if we were rebuild, write out the allocation extents */
5600 if (udf_node
->i_flags
& IN_NODE_REBUILD
) {
5601 /* mark outstanding node descriptors and issue them */
5602 udf_node
->outstanding_nodedscr
+= udf_node
->num_extensions
;
5603 for (extnr
= 0; extnr
< udf_node
->num_extensions
; extnr
++) {
5604 loc
= &udf_node
->ext_loc
[extnr
];
5605 dscr
= (union dscrptr
*) udf_node
->ext
[extnr
];
5606 error
= udf_write_logvol_dscr(udf_node
, dscr
, loc
, 0);
5610 /* mark allocation extents written out */
5611 udf_node
->i_flags
&= ~(IN_NODE_REBUILD
);
5615 KASSERT(udf_node
->efe
== NULL
);
5616 dscr
= (union dscrptr
*) udf_node
->fe
;
5618 KASSERT(udf_node
->efe
);
5619 KASSERT(udf_node
->fe
== NULL
);
5620 dscr
= (union dscrptr
*) udf_node
->efe
;
5624 loc
= &udf_node
->write_loc
;
5625 error
= udf_write_logvol_dscr(udf_node
, dscr
, loc
, waitfor
);
5630 /* --------------------------------------------------------------------- */
5633 udf_dispose_node(struct udf_node
*udf_node
)
5638 DPRINTF(NODE
, ("udf_dispose_node called on node %p\n", udf_node
));
5640 DPRINTF(NODE
, ("UDF: Dispose node on node NULL, ignoring\n"));
5644 vp
= udf_node
->vnode
;
5646 if (vp
->v_numoutput
)
5647 panic("disposing UDF node with pending I/O's, udf_node = %p, "
5648 "v_numoutput = %d", udf_node
, vp
->v_numoutput
);
5651 udf_cleanup_reservation(udf_node
);
5653 /* TODO extended attributes and streamdir */
5655 /* remove dirhash if present */
5656 dirhash_purge(&udf_node
->dir_hash
);
5658 /* destroy our lock */
5659 mutex_destroy(&udf_node
->node_mutex
);
5660 cv_destroy(&udf_node
->node_lock
);
5662 /* dissociate our udf_node from the vnode */
5663 genfs_node_destroy(udf_node
->vnode
);
5664 mutex_enter(vp
->v_interlock
);
5666 mutex_exit(vp
->v_interlock
);
5668 /* free associated memory and the node itself */
5669 for (extnr
= 0; extnr
< udf_node
->num_extensions
; extnr
++) {
5670 udf_free_logvol_dscr(udf_node
->ump
, &udf_node
->ext_loc
[extnr
],
5671 udf_node
->ext
[extnr
]);
5672 udf_node
->ext
[extnr
] = (void *) 0xdeadcccc;
5676 udf_free_logvol_dscr(udf_node
->ump
, &udf_node
->loc
,
5679 udf_free_logvol_dscr(udf_node
->ump
, &udf_node
->loc
,
5682 udf_node
->fe
= (void *) 0xdeadaaaa;
5683 udf_node
->efe
= (void *) 0xdeadbbbb;
5684 udf_node
->ump
= (void *) 0xdeadbeef;
5685 pool_put(&udf_node_pool
, udf_node
);
5693 * create a new node using the specified dvp, vap and cnp.
5694 * This allows special files to be created. Use with care.
5698 udf_newvnode(struct mount
*mp
, struct vnode
*dvp
, struct vnode
*vp
,
5699 struct vattr
*vap
, kauth_cred_t cred
,
5700 size_t *key_len
, const void **new_key
)
5702 union dscrptr
*dscr
;
5703 struct udf_node
*dir_node
= VTOI(dvp
);
5704 struct udf_node
*udf_node
;
5705 struct udf_mount
*ump
= dir_node
->ump
;
5706 struct long_ad node_icb_loc
;
5707 uint64_t parent_unique_id
;
5709 uint32_t lb_size
, lb_num
;
5712 gid_t gid
, parent_gid
;
5713 int (**vnodeops
)(void *);
5714 int udf_file_type
, fid_size
, error
;
5716 vnodeops
= udf_vnodeop_p
;
5717 udf_file_type
= UDF_ICB_FILETYPE_RANDOMACCESS
;
5719 switch (vap
->va_type
) {
5721 udf_file_type
= UDF_ICB_FILETYPE_RANDOMACCESS
;
5724 udf_file_type
= UDF_ICB_FILETYPE_DIRECTORY
;
5727 udf_file_type
= UDF_ICB_FILETYPE_SYMLINK
;
5730 udf_file_type
= UDF_ICB_FILETYPE_BLOCKDEVICE
;
5735 udf_file_type
= UDF_ICB_FILETYPE_CHARDEVICE
;
5740 udf_file_type
= UDF_ICB_FILETYPE_FIFO
;
5745 udf_file_type
= UDF_ICB_FILETYPE_SOCKET
;
5751 /* nothing; can we even create these? */
5755 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
5757 /* reserve space for one logical block */
5758 vpart_num
= ump
->node_part
;
5759 error
= udf_reserve_space(ump
, NULL
, UDF_C_NODE
,
5760 vpart_num
, 1, /* can_fail */ true);
5765 error
= udf_allocate_space(ump
, NULL
, UDF_C_NODE
,
5766 vpart_num
, 1, &lmapping
);
5768 udf_do_unreserve_space(ump
, NULL
, vpart_num
, 1);
5774 /* initialise pointer to location */
5775 memset(&node_icb_loc
, 0, sizeof(struct long_ad
));
5776 node_icb_loc
.len
= udf_rw32(lb_size
);
5777 node_icb_loc
.loc
.lb_num
= udf_rw32(lb_num
);
5778 node_icb_loc
.loc
.part_num
= udf_rw16(vpart_num
);
5780 /* build udf_node (do initialise!) */
5781 udf_node
= pool_get(&udf_node_pool
, PR_WAITOK
);
5782 memset(udf_node
, 0, sizeof(struct udf_node
));
5784 /* initialise crosslinks, note location of fe/efe for hashing */
5785 /* bugalert: synchronise with udf_get_node() */
5786 udf_node
->ump
= ump
;
5787 udf_node
->vnode
= vp
;
5788 vp
->v_data
= udf_node
;
5789 udf_node
->loc
= node_icb_loc
;
5790 udf_node
->write_loc
= node_icb_loc
;
5791 udf_node
->lockf
= 0;
5792 mutex_init(&udf_node
->node_mutex
, MUTEX_DEFAULT
, IPL_NONE
);
5793 cv_init(&udf_node
->node_lock
, "udf_nlk");
5794 udf_node
->outstanding_bufs
= 0;
5795 udf_node
->outstanding_nodedscr
= 0;
5796 udf_node
->uncommitted_lbs
= 0;
5799 vp
->v_op
= vnodeops
;
5801 /* initialise genfs */
5802 genfs_node_init(vp
, &udf_genfsops
);
5804 /* get parent's unique ID for refering '..' if its a directory */
5806 parent_unique_id
= udf_rw64(dir_node
->fe
->unique_id
);
5807 parent_gid
= (gid_t
) udf_rw32(dir_node
->fe
->gid
);
5809 parent_unique_id
= udf_rw64(dir_node
->efe
->unique_id
);
5810 parent_gid
= (gid_t
) udf_rw32(dir_node
->efe
->gid
);
5813 /* get descriptor */
5814 udf_create_logvol_dscr(ump
, udf_node
, &node_icb_loc
, &dscr
);
5816 /* choose a fe or an efe for it */
5817 if (udf_rw16(ump
->logical_vol
->tag
.descriptor_ver
) == 2) {
5818 udf_node
->fe
= &dscr
->fe
;
5819 fid_size
= udf_create_new_fe(ump
, udf_node
->fe
,
5820 udf_file_type
, &udf_node
->loc
,
5821 &dir_node
->loc
, parent_unique_id
);
5822 /* TODO add extended attribute for creation time */
5824 udf_node
->efe
= &dscr
->efe
;
5825 fid_size
= udf_create_new_efe(ump
, udf_node
->efe
,
5826 udf_file_type
, &udf_node
->loc
,
5827 &dir_node
->loc
, parent_unique_id
);
5829 KASSERT(dscr
->tag
.tag_loc
== udf_node
->loc
.loc
.lb_num
);
5831 /* update vnode's size and type */
5832 vp
->v_type
= vap
->va_type
;
5833 uvm_vnp_setsize(vp
, fid_size
);
5835 /* set access mode */
5836 udf_setaccessmode(udf_node
, vap
->va_mode
);
5839 uid
= kauth_cred_geteuid(cred
);
5841 udf_setownership(udf_node
, uid
, gid
);
5843 *key_len
= sizeof(udf_node
->loc
.loc
);;
5844 *new_key
= &udf_node
->loc
.loc
;
5851 udf_create_node(struct vnode
*dvp
, struct vnode
**vpp
, struct vattr
*vap
,
5852 struct componentname
*cnp
)
5854 struct udf_node
*udf_node
, *dir_node
= VTOI(dvp
);
5855 struct udf_mount
*ump
= dir_node
->ump
;
5858 error
= vcache_new(dvp
->v_mount
, dvp
, vap
, cnp
->cn_cred
, vpp
);
5862 udf_node
= VTOI(*vpp
);
5863 error
= udf_dir_attach(ump
, dir_node
, udf_node
, vap
, cnp
);
5865 struct long_ad
*node_icb_loc
= &udf_node
->loc
;
5866 uint32_t lb_num
= udf_rw32(node_icb_loc
->loc
.lb_num
);
5867 uint16_t vpart_num
= udf_rw16(node_icb_loc
->loc
.part_num
);
5869 /* free disc allocation for node */
5870 udf_free_allocated_space(ump
, lb_num
, vpart_num
, 1);
5872 /* recycle udf_node */
5873 udf_dispose_node(udf_node
);
5880 /* adjust file count */
5881 udf_adjust_filecount(udf_node
, 1);
5886 /* --------------------------------------------------------------------- */
5889 udf_free_descriptor_space(struct udf_node
*udf_node
, struct long_ad
*loc
, void *mem
)
5891 struct udf_mount
*ump
= udf_node
->ump
;
5892 uint32_t lb_size
, lb_num
, len
, num_lb
;
5895 /* is there really one? */
5899 /* got a descriptor here */
5900 len
= UDF_EXT_LEN(udf_rw32(loc
->len
));
5901 lb_num
= udf_rw32(loc
->loc
.lb_num
);
5902 vpart_num
= udf_rw16(loc
->loc
.part_num
);
5904 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
5905 num_lb
= (len
+ lb_size
-1) / lb_size
;
5907 udf_free_allocated_space(ump
, lb_num
, vpart_num
, num_lb
);
5911 udf_delete_node(struct udf_node
*udf_node
)
5914 struct long_ad
*loc
;
5915 int extnr
, lvint
, dummy
;
5917 /* paranoia check on integrity; should be open!; we could panic */
5918 lvint
= udf_rw32(udf_node
->ump
->logvol_integrity
->integrity_type
);
5919 if (lvint
== UDF_INTEGRITY_CLOSED
)
5920 printf("\tIntegrity was CLOSED!\n");
5922 /* whatever the node type, change its size to zero */
5923 (void) udf_resize_node(udf_node
, 0, &dummy
);
5925 /* force it to be `clean'; no use writing it out */
5926 udf_node
->i_flags
&= ~(IN_MODIFIED
| IN_ACCESSED
| IN_ACCESS
|
5927 IN_CHANGE
| IN_UPDATE
| IN_MODIFY
);
5929 /* adjust file count */
5930 udf_adjust_filecount(udf_node
, -1);
5933 * Free its allocated descriptors; memory will be released when
5934 * vop_reclaim() is called.
5936 loc
= &udf_node
->loc
;
5938 dscr
= udf_node
->fe
;
5939 udf_free_descriptor_space(udf_node
, loc
, dscr
);
5940 dscr
= udf_node
->efe
;
5941 udf_free_descriptor_space(udf_node
, loc
, dscr
);
5943 for (extnr
= 0; extnr
< UDF_MAX_ALLOC_EXTENTS
; extnr
++) {
5944 dscr
= udf_node
->ext
[extnr
];
5945 loc
= &udf_node
->ext_loc
[extnr
];
5946 udf_free_descriptor_space(udf_node
, loc
, dscr
);
5950 /* --------------------------------------------------------------------- */
5952 /* set new filesize; node but be LOCKED on entry and is locked on exit */
5954 udf_resize_node(struct udf_node
*udf_node
, uint64_t new_size
, int *extended
)
5956 struct file_entry
*fe
= udf_node
->fe
;
5957 struct extfile_entry
*efe
= udf_node
->efe
;
5962 file_size
= udf_rw64(fe
->inf_len
);
5964 assert(udf_node
->efe
);
5965 file_size
= udf_rw64(efe
->inf_len
);
5968 DPRINTF(ATTR
, ("\tchanging file length from %"PRIu64
" to %"PRIu64
"\n",
5969 file_size
, new_size
));
5971 /* if not changing, we're done */
5972 if (file_size
== new_size
)
5975 *extended
= (new_size
> file_size
);
5977 error
= udf_grow_node(udf_node
, new_size
);
5979 error
= udf_shrink_node(udf_node
, new_size
);
5986 /* --------------------------------------------------------------------- */
5989 udf_itimes(struct udf_node
*udf_node
, struct timespec
*acc
,
5990 struct timespec
*mod
, struct timespec
*birth
)
5992 struct timespec now
;
5993 struct file_entry
*fe
;
5994 struct extfile_entry
*efe
;
5995 struct filetimes_extattr_entry
*ft_extattr
;
5996 struct timestamp
*atime
, *mtime
, *attrtime
, *ctime
;
5997 struct timestamp fe_ctime
;
5998 struct timespec cur_birth
;
5999 uint32_t offset
, a_l
;
6003 /* protect against rogue values */
6008 efe
= udf_node
->efe
;
6010 if (!(udf_node
->i_flags
& (IN_ACCESS
|IN_CHANGE
|IN_UPDATE
|IN_MODIFY
)))
6013 /* get descriptor information */
6017 attrtime
= &fe
->attrtime
;
6018 filedata
= fe
->data
;
6020 /* initial save dummy setting */
6023 /* check our extended attribute if present */
6024 error
= udf_extattr_search_intern(udf_node
,
6025 UDF_FILETIMES_ATTR_NO
, "", &offset
, &a_l
);
6027 ft_extattr
= (struct filetimes_extattr_entry
*)
6028 (filedata
+ offset
);
6029 if (ft_extattr
->existence
& UDF_FILETIMES_FILE_CREATION
)
6030 ctime
= &ft_extattr
->times
[0];
6032 /* TODO create the extended attribute if not found ? */
6034 assert(udf_node
->efe
);
6035 atime
= &efe
->atime
;
6036 mtime
= &efe
->mtime
;
6037 attrtime
= &efe
->attrtime
;
6038 ctime
= &efe
->ctime
;
6041 vfs_timestamp(&now
);
6043 /* set access time */
6044 if (udf_node
->i_flags
& IN_ACCESS
) {
6047 udf_timespec_to_timestamp(acc
, atime
);
6050 /* set modification time */
6051 if (udf_node
->i_flags
& (IN_UPDATE
| IN_MODIFY
)) {
6054 udf_timespec_to_timestamp(mod
, mtime
);
6056 /* ensure birthtime is older than set modification! */
6057 udf_timestamp_to_timespec(udf_node
->ump
, ctime
, &cur_birth
);
6058 if ((cur_birth
.tv_sec
> mod
->tv_sec
) ||
6059 ((cur_birth
.tv_sec
== mod
->tv_sec
) &&
6060 (cur_birth
.tv_nsec
> mod
->tv_nsec
))) {
6061 udf_timespec_to_timestamp(mod
, ctime
);
6065 /* update birthtime if specified */
6066 /* XXX we assume here that given birthtime is older than mod */
6067 if (birth
&& (birth
->tv_sec
!= VNOVAL
)) {
6068 udf_timespec_to_timestamp(birth
, ctime
);
6071 /* set change time */
6072 if (udf_node
->i_flags
& (IN_CHANGE
| IN_MODIFY
))
6073 udf_timespec_to_timestamp(&now
, attrtime
);
6075 /* notify updates to the node itself */
6076 if (udf_node
->i_flags
& (IN_ACCESS
| IN_MODIFY
))
6077 udf_node
->i_flags
|= IN_ACCESSED
;
6078 if (udf_node
->i_flags
& (IN_UPDATE
| IN_CHANGE
))
6079 udf_node
->i_flags
|= IN_MODIFIED
;
6081 /* clear modification flags */
6082 udf_node
->i_flags
&= ~(IN_ACCESS
| IN_CHANGE
| IN_UPDATE
| IN_MODIFY
);
6085 /* --------------------------------------------------------------------- */
6088 udf_update(struct vnode
*vp
, struct timespec
*acc
,
6089 struct timespec
*mod
, struct timespec
*birth
, int updflags
)
6091 union dscrptr
*dscrptr
;
6092 struct udf_node
*udf_node
= VTOI(vp
);
6093 struct udf_mount
*ump
= udf_node
->ump
;
6094 struct regid
*impl_id
;
6095 int mnt_async
= (vp
->v_mount
->mnt_flag
& MNT_ASYNC
);
6100 DPRINTF(CALL
, ("udf_update(node, %p, %p, %p, %d)\n", acc
, mod
, birth
,
6102 snprintb(bits
, sizeof(bits
), IN_FLAGBITS
, udf_node
->i_flags
);
6103 DPRINTF(CALL
, ("\tnode flags %s\n", bits
));
6104 DPRINTF(CALL
, ("\t\tmnt_async = %d\n", mnt_async
));
6108 udf_itimes(udf_node
, acc
, mod
, birth
);
6110 /* set our implementation id */
6112 dscrptr
= (union dscrptr
*) udf_node
->fe
;
6113 impl_id
= &udf_node
->fe
->imp_id
;
6115 dscrptr
= (union dscrptr
*) udf_node
->efe
;
6116 impl_id
= &udf_node
->efe
->imp_id
;
6120 udf_set_regid(impl_id
, IMPL_NAME
);
6121 udf_add_impl_regid(ump
, impl_id
);
6123 /* update our crc! on RMW we are not allowed to change a thing */
6124 udf_validate_tag_and_crc_sums(dscrptr
);
6126 /* if called when mounted readonly, never write back */
6127 if (vp
->v_mount
->mnt_flag
& MNT_RDONLY
)
6130 /* check if the node is dirty 'enough'*/
6131 if (updflags
& UPDATE_CLOSE
) {
6132 flags
= udf_node
->i_flags
& (IN_MODIFIED
| IN_ACCESSED
);
6134 flags
= udf_node
->i_flags
& IN_MODIFIED
;
6139 /* determine if we need to write sync or async */
6141 if ((flags
& IN_MODIFIED
) && (mnt_async
== 0)) {
6143 waitfor
= updflags
& UPDATE_WAIT
;
6144 if (updflags
& UPDATE_DIROP
)
6145 waitfor
|= UPDATE_WAIT
;
6148 return VOP_FSYNC(vp
, FSCRED
, FSYNC_WAIT
, 0,0);
6154 /* --------------------------------------------------------------------- */
6158 * Read one fid and process it into a dirent and advance to the next (*fid)
6159 * has to be allocated a logical block in size, (*dirent) struct dirent length
6163 udf_read_fid_stream(struct vnode
*vp
, uint64_t *offset
,
6164 struct fileid_desc
*fid
, struct dirent
*dirent
)
6166 struct udf_node
*dir_node
= VTOI(vp
);
6167 struct udf_mount
*ump
= dir_node
->ump
;
6168 struct file_entry
*fe
= dir_node
->fe
;
6169 struct extfile_entry
*efe
= dir_node
->efe
;
6170 uint32_t fid_size
, lb_size
;
6179 assert(*offset
!= 1);
6181 DPRINTF(FIDS
, ("read_fid_stream called at offset %"PRIu64
"\n", *offset
));
6182 /* check if we're past the end of the directory */
6184 file_size
= udf_rw64(fe
->inf_len
);
6186 assert(dir_node
->efe
);
6187 file_size
= udf_rw64(efe
->inf_len
);
6189 if (*offset
>= file_size
)
6192 /* get maximum length of FID descriptor */
6193 lb_size
= udf_rw32(ump
->logical_vol
->lb_size
);
6195 /* initialise return values */
6197 memset(dirent
, 0, sizeof(struct dirent
));
6198 memset(fid
, 0, lb_size
);
6200 enough
= (file_size
- (*offset
) >= UDF_FID_SIZE
);
6206 error
= vn_rdwr(UIO_READ
, vp
,
6207 fid
, MIN(file_size
- (*offset
), lb_size
), *offset
,
6208 UIO_SYSSPACE
, IO_ALTSEMANTICS
| IO_NODELOCKED
, FSCRED
,
6213 DPRINTF(FIDS
, ("\tfid piece read in fine\n"));
6215 * Check if we got a whole descriptor.
6216 * TODO Try to `resync' directory stream when something is very wrong.
6219 /* check if our FID header is OK */
6220 error
= udf_check_tag(fid
);
6224 DPRINTF(FIDS
, ("\ttag check ok\n"));
6226 if (udf_rw16(fid
->tag
.id
) != TAGID_FID
) {
6230 DPRINTF(FIDS
, ("\ttag checked ok: got TAGID_FID\n"));
6232 /* check for length */
6233 fid_size
= udf_fidsize(fid
);
6234 enough
= (file_size
- (*offset
) >= fid_size
);
6239 DPRINTF(FIDS
, ("\tthe complete fid is read in\n"));
6241 /* check FID contents */
6242 error
= udf_check_tag_payload((union dscrptr
*) fid
, lb_size
);
6245 /* note that is sometimes a bit quick to report */
6246 printf("UDF: BROKEN DIRECTORY ENTRY\n");
6248 /* TODO: use udf_resync_fid_stream */
6251 DPRINTF(FIDS
, ("\tpayload checked ok\n"));
6253 /* we got a whole and valid descriptor! */
6254 DPRINTF(FIDS
, ("\tinterpret FID\n"));
6256 /* create resulting dirent structure */
6257 fid_name
= (char *) fid
->data
+ udf_rw16(fid
->l_iu
);
6258 udf_to_unix_name(dirent
->d_name
, NAME_MAX
,
6259 fid_name
, fid
->l_fi
, &ump
->logical_vol
->desc_charset
);
6261 /* '..' has no name, so provide one */
6262 if (fid
->file_char
& UDF_FILE_CHAR_PAR
)
6263 strcpy(dirent
->d_name
, "..");
6265 dirent
->d_fileno
= udf_get_node_id(&fid
->icb
); /* inode hash XXX */
6266 dirent
->d_namlen
= strlen(dirent
->d_name
);
6267 dirent
->d_reclen
= _DIRENT_SIZE(dirent
);
6270 * Note that its not worth trying to go for the filetypes now... its
6273 dirent
->d_type
= DT_UNKNOWN
;
6275 /* initial guess for filetype we can make */
6276 if (fid
->file_char
& UDF_FILE_CHAR_DIR
)
6277 dirent
->d_type
= DT_DIR
;
6280 *offset
+= fid_size
;
6286 /* --------------------------------------------------------------------- */
6289 udf_sync_pass(struct udf_mount
*ump
, kauth_cred_t cred
, int pass
, int *ndirty
)
6291 struct udf_node
*udf_node
, *n_udf_node
;
6295 KASSERT(mutex_owned(&ump
->sync_lock
));
6297 DPRINTF(SYNC
, ("sync_pass %d\n", pass
));
6298 udf_node
= RB_TREE_MIN(&ump
->udf_node_tree
);
6299 for (;udf_node
; udf_node
= n_udf_node
) {
6300 DPRINTF(SYNC
, ("."));
6302 vp
= udf_node
->vnode
;
6304 n_udf_node
= rb_tree_iterate(&ump
->udf_node_tree
,
6305 udf_node
, RB_DIR_RIGHT
);
6307 error
= vn_lock(vp
, LK_EXCLUSIVE
| LK_NOWAIT
);
6309 KASSERT(error
== EBUSY
);
6316 VOP_FSYNC(vp
, cred
, 0 | FSYNC_DATAONLY
,0,0);
6319 vdirty
= vp
->v_numoutput
;
6320 if (vp
->v_tag
== VT_UDF
)
6321 vdirty
+= udf_node
->outstanding_bufs
+
6322 udf_node
->outstanding_nodedscr
;
6324 VOP_FSYNC(vp
, cred
, 0,0,0);
6328 vdirty
= vp
->v_numoutput
;
6329 if (vp
->v_tag
== VT_UDF
)
6330 vdirty
+= udf_node
->outstanding_bufs
+
6331 udf_node
->outstanding_nodedscr
;
6338 DPRINTF(SYNC
, ("END sync_pass %d\n", pass
));
6343 udf_sync_selector(void *cl
, struct vnode
*vp
)
6345 struct udf_node
*udf_node
= VTOI(vp
);
6347 if (vp
->v_vflag
& VV_SYSTEM
)
6349 if (vp
->v_type
== VNON
)
6351 if (udf_node
== NULL
)
6353 if ((udf_node
->i_flags
& (IN_ACCESSED
| IN_UPDATE
| IN_MODIFIED
)) == 0)
6355 if (LIST_EMPTY(&vp
->v_dirtyblkhd
) && UVM_OBJ_IS_CLEAN(&vp
->v_uobj
))
6362 udf_do_sync(struct udf_mount
*ump
, kauth_cred_t cred
, int waitfor
)
6364 struct vnode_iterator
*marker
;
6366 struct udf_node
*udf_node
, *udf_next_node
;
6369 if (waitfor
== MNT_LAZY
)
6372 mutex_enter(&ump
->sync_lock
);
6374 /* Fill the rbtree with nodes to sync. */
6375 vfs_vnode_iterator_init(ump
->vfs_mountp
, &marker
);
6376 while ((vp
= vfs_vnode_iterator_next(marker
,
6377 udf_sync_selector
, NULL
)) != NULL
) {
6378 udf_node
= VTOI(vp
);
6379 udf_node
->i_flags
|= IN_SYNCED
;
6380 rb_tree_insert_node(&ump
->udf_node_tree
, udf_node
);
6382 vfs_vnode_iterator_destroy(marker
);
6385 DPRINTF(CALL
, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
6386 DPRINTF(SYNC
, ("issue VOP_FSYNC(DATA only) on all nodes\n"));
6387 udf_sync_pass(ump
, cred
, 1, &dummy
);
6389 DPRINTF(CALL
, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
6390 DPRINTF(SYNC
, ("issue VOP_FSYNC(COMPLETE) on all finished nodes\n"));
6391 udf_sync_pass(ump
, cred
, 2, &dummy
);
6393 if (waitfor
== MNT_WAIT
) {
6395 ndirty
= ump
->devvp
->v_numoutput
;
6396 DPRINTF(SYNC
, ("counting pending blocks: on devvp %d\n",
6398 udf_sync_pass(ump
, cred
, 3, &ndirty
);
6399 DPRINTF(SYNC
, ("counted num dirty pending blocks %d\n",
6403 /* 1/4 second wait */
6404 kpause("udfsync2", false, hz
/4, NULL
);
6409 /* Clean the rbtree. */
6410 for (udf_node
= RB_TREE_MIN(&ump
->udf_node_tree
);
6411 udf_node
; udf_node
= udf_next_node
) {
6412 udf_next_node
= rb_tree_iterate(&ump
->udf_node_tree
,
6413 udf_node
, RB_DIR_RIGHT
);
6414 rb_tree_remove_node(&ump
->udf_node_tree
, udf_node
);
6415 udf_node
->i_flags
&= ~IN_SYNCED
;
6416 vrele(udf_node
->vnode
);
6419 mutex_exit(&ump
->sync_lock
);
6422 /* --------------------------------------------------------------------- */
6425 * Read and write file extent in/from the buffer.
6427 * The splitup of the extent into seperate request-buffers is to minimise
6428 * copying around as much as possible.
6430 * block based file reading and writing
6434 udf_read_internal(struct udf_node
*node
, uint8_t *blob
)
6436 struct udf_mount
*ump
;
6437 struct file_entry
*fe
= node
->fe
;
6438 struct extfile_entry
*efe
= node
->efe
;
6440 uint32_t sector_size
;
6442 int icbflags
, addr_type
;
6444 /* get extent and do some paranoia checks */
6446 sector_size
= ump
->discinfo
.sector_size
;
6449 inflen
= udf_rw64(fe
->inf_len
);
6450 pos
= &fe
->data
[0] + udf_rw32(fe
->l_ea
);
6451 icbflags
= udf_rw16(fe
->icbtag
.flags
);
6454 inflen
= udf_rw64(efe
->inf_len
);
6455 pos
= &efe
->data
[0] + udf_rw32(efe
->l_ea
);
6456 icbflags
= udf_rw16(efe
->icbtag
.flags
);
6458 addr_type
= icbflags
& UDF_ICB_TAG_FLAGS_ALLOC_MASK
;
6460 assert(addr_type
== UDF_ICB_INTERN_ALLOC
);
6462 assert(inflen
< sector_size
);
6465 memset(blob
, 0, sector_size
);
6466 memcpy(blob
, pos
, inflen
);
6473 udf_write_internal(struct udf_node
*node
, uint8_t *blob
)
6475 struct udf_mount
*ump
;
6476 struct file_entry
*fe
= node
->fe
;
6477 struct extfile_entry
*efe
= node
->efe
;
6479 uint32_t sector_size
;
6481 int icbflags
, addr_type
;
6483 /* get extent and do some paranoia checks */
6485 sector_size
= ump
->discinfo
.sector_size
;
6488 inflen
= udf_rw64(fe
->inf_len
);
6489 pos
= &fe
->data
[0] + udf_rw32(fe
->l_ea
);
6490 icbflags
= udf_rw16(fe
->icbtag
.flags
);
6493 inflen
= udf_rw64(efe
->inf_len
);
6494 pos
= &efe
->data
[0] + udf_rw32(efe
->l_ea
);
6495 icbflags
= udf_rw16(efe
->icbtag
.flags
);
6497 addr_type
= icbflags
& UDF_ICB_TAG_FLAGS_ALLOC_MASK
;
6499 assert(addr_type
== UDF_ICB_INTERN_ALLOC
);
6501 assert(inflen
< sector_size
);
6505 /* memset(pos, 0, inflen); */
6506 memcpy(pos
, blob
, inflen
);
6513 udf_read_filebuf(struct udf_node
*udf_node
, struct buf
*buf
)
6515 struct buf
*nestbuf
;
6516 struct udf_mount
*ump
= udf_node
->ump
;
6519 uint32_t sector_size
;
6520 uint32_t buf_offset
, sector
, rbuflen
, rblk
;
6521 uint32_t from
, lblkno
;
6524 int error
, run_length
, what
;
6526 sector_size
= udf_node
->ump
->discinfo
.sector_size
;
6528 from
= buf
->b_blkno
;
6529 sectors
= buf
->b_bcount
/ sector_size
;
6531 what
= udf_get_c_type(udf_node
);
6533 /* assure we have enough translation slots */
6534 KASSERT(buf
->b_bcount
/ sector_size
<= UDF_MAX_MAPPINGS
);
6535 KASSERT(MAXPHYS
/ sector_size
<= UDF_MAX_MAPPINGS
);
6537 if (sectors
> UDF_MAX_MAPPINGS
) {
6538 printf("udf_read_filebuf: implementation limit on bufsize\n");
6544 mapping
= malloc(sizeof(*mapping
) * UDF_MAX_MAPPINGS
, M_TEMP
, M_WAITOK
);
6547 DPRINTF(READ
, ("\ttranslate %d-%d\n", from
, sectors
));
6548 error
= udf_translate_file_extent(udf_node
, from
, sectors
, mapping
);
6550 buf
->b_error
= error
;
6554 DPRINTF(READ
, ("\ttranslate extent went OK\n"));
6556 /* pre-check if its an internal */
6557 if (*mapping
== UDF_TRANS_INTERN
) {
6558 error
= udf_read_internal(udf_node
, (uint8_t *) buf
->b_data
);
6560 buf
->b_error
= error
;
6564 DPRINTF(READ
, ("\tnot intern\n"));
6567 if (udf_verbose
& UDF_DEBUG_TRANSLATE
) {
6568 printf("Returned translation table:\n");
6569 for (sector
= 0; sector
< sectors
; sector
++) {
6570 printf("%d : %"PRIu64
"\n", sector
, mapping
[sector
]);
6575 /* request read-in of data from disc sheduler */
6576 buf
->b_resid
= buf
->b_bcount
;
6577 for (sector
= 0; sector
< sectors
; sector
++) {
6578 buf_offset
= sector
* sector_size
;
6579 buf_pos
= (uint8_t *) buf
->b_data
+ buf_offset
;
6580 DPRINTF(READ
, ("\tprocessing rel sector %d\n", sector
));
6582 /* check if its zero or unmapped to stop reading */
6583 switch (mapping
[sector
]) {
6584 case UDF_TRANS_UNMAPPED
:
6585 case UDF_TRANS_ZERO
:
6586 /* copy zero sector TODO runlength like below */
6587 memset(buf_pos
, 0, sector_size
);
6588 DPRINTF(READ
, ("\treturning zero sector\n"));
6589 nestiobuf_done(buf
, sector_size
, 0);
6592 DPRINTF(READ
, ("\tread sector "
6593 "%"PRIu64
"\n", mapping
[sector
]));
6595 lblkno
= from
+ sector
;
6596 run_start
= mapping
[sector
];
6598 while (sector
< sectors
-1) {
6599 if (mapping
[sector
+1] != mapping
[sector
]+1)
6606 * nest an iobuf and mark it for async reading. Since
6607 * we're using nested buffers, they can't be cached by
6610 rbuflen
= run_length
* sector_size
;
6611 rblk
= run_start
* (sector_size
/DEV_BSIZE
);
6613 nestbuf
= getiobuf(NULL
, true);
6614 nestiobuf_setup(buf
, nestbuf
, buf_offset
, rbuflen
);
6615 /* nestbuf is B_ASYNC */
6617 /* identify this nestbuf */
6618 nestbuf
->b_lblkno
= lblkno
;
6619 assert(nestbuf
->b_vp
== udf_node
->vnode
);
6621 /* CD shedules on raw blkno */
6622 nestbuf
->b_blkno
= rblk
;
6623 nestbuf
->b_proc
= NULL
;
6624 nestbuf
->b_rawblkno
= rblk
;
6625 nestbuf
->b_udf_c_type
= what
;
6627 udf_discstrat_queuebuf(ump
, nestbuf
);
6631 /* if we're synchronously reading, wait for the completion */
6632 if ((buf
->b_flags
& B_ASYNC
) == 0)
6635 DPRINTF(READ
, ("\tend of read_filebuf\n"));
6636 free(mapping
, M_TEMP
);
6642 udf_write_filebuf(struct udf_node
*udf_node
, struct buf
*buf
)
6644 struct buf
*nestbuf
;
6645 struct udf_mount
*ump
= udf_node
->ump
;
6649 uint32_t buf_offset
, lb_num
, rbuflen
, rblk
;
6650 uint32_t from
, lblkno
;
6652 int error
, run_length
, what
, s
;
6654 lb_size
= udf_rw32(udf_node
->ump
->logical_vol
->lb_size
);
6656 from
= buf
->b_blkno
;
6657 num_lb
= buf
->b_bcount
/ lb_size
;
6659 what
= udf_get_c_type(udf_node
);
6661 /* assure we have enough translation slots */
6662 KASSERT(buf
->b_bcount
/ lb_size
<= UDF_MAX_MAPPINGS
);
6663 KASSERT(MAXPHYS
/ lb_size
<= UDF_MAX_MAPPINGS
);
6665 if (num_lb
> UDF_MAX_MAPPINGS
) {
6666 printf("udf_write_filebuf: implementation limit on bufsize\n");
6672 mapping
= malloc(sizeof(*mapping
) * UDF_MAX_MAPPINGS
, M_TEMP
, M_WAITOK
);
6675 DPRINTF(WRITE
, ("\ttranslate %d-%d\n", from
, num_lb
));
6676 error
= udf_translate_file_extent(udf_node
, from
, num_lb
, mapping
);
6678 buf
->b_error
= error
;
6682 DPRINTF(WRITE
, ("\ttranslate extent went OK\n"));
6684 /* if its internally mapped, we can write it in the descriptor itself */
6685 if (*mapping
== UDF_TRANS_INTERN
) {
6686 /* TODO paranoia check if we ARE going to have enough space */
6687 error
= udf_write_internal(udf_node
, (uint8_t *) buf
->b_data
);
6689 buf
->b_error
= error
;
6693 DPRINTF(WRITE
, ("\tnot intern\n"));
6695 /* request write out of data to disc sheduler */
6696 buf
->b_resid
= buf
->b_bcount
;
6697 for (lb_num
= 0; lb_num
< num_lb
; lb_num
++) {
6698 buf_offset
= lb_num
* lb_size
;
6699 DPRINTF(WRITE
, ("\tprocessing rel lb_num %d\n", lb_num
));
6702 * Mappings are not that important here. Just before we write
6703 * the lb_num we late-allocate them when needed and update the
6704 * mapping in the udf_node.
6707 /* XXX why not ignore the mapping altogether ? */
6708 DPRINTF(WRITE
, ("\twrite lb_num "
6709 "%"PRIu64
, mapping
[lb_num
]));
6711 lblkno
= from
+ lb_num
;
6712 run_start
= mapping
[lb_num
];
6714 while (lb_num
< num_lb
-1) {
6715 if (mapping
[lb_num
+1] != mapping
[lb_num
]+1)
6716 if (mapping
[lb_num
+1] != mapping
[lb_num
])
6721 DPRINTF(WRITE
, ("+ %d\n", run_length
));
6723 /* nest an iobuf on the master buffer for the extent */
6724 rbuflen
= run_length
* lb_size
;
6725 rblk
= run_start
* (lb_size
/DEV_BSIZE
);
6727 nestbuf
= getiobuf(NULL
, true);
6728 nestiobuf_setup(buf
, nestbuf
, buf_offset
, rbuflen
);
6729 /* nestbuf is B_ASYNC */
6731 /* identify this nestbuf */
6732 nestbuf
->b_lblkno
= lblkno
;
6733 KASSERT(nestbuf
->b_vp
== udf_node
->vnode
);
6735 /* CD shedules on raw blkno */
6736 nestbuf
->b_blkno
= rblk
;
6737 nestbuf
->b_proc
= NULL
;
6738 nestbuf
->b_rawblkno
= rblk
;
6739 nestbuf
->b_udf_c_type
= what
;
6741 /* increment our outstanding bufs counter */
6743 udf_node
->outstanding_bufs
++;
6746 udf_discstrat_queuebuf(ump
, nestbuf
);
6749 /* if we're synchronously writing, wait for the completion */
6750 if ((buf
->b_flags
& B_ASYNC
) == 0)
6753 DPRINTF(WRITE
, ("\tend of write_filebuf\n"));
6754 free(mapping
, M_TEMP
);
6758 /* --------------------------------------------------------------------- */