2 * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * $FreeBSD: src/sys/fs/udf/udf_vfsops.c,v 1.16 2003/11/05 06:56:08 scottl Exp $
27 * $DragonFly: src/sys/vfs/udf/udf_vfsops.c,v 1.28 2008/09/17 21:44:25 dillon Exp $
31 /* Implement the VFS side of things */
34 * Ok, here's how it goes. The UDF specs are pretty clear on how each data
35 * structure is made up, but not very clear on how they relate to each other.
36 * Here is the skinny... This demostrates a filesystem with one file in the
37 * root directory. Subdirectories are treated just as normal files, but they
38 * have File Id Descriptors of their children as their file data. As for the
39 * Anchor Volume Descriptor Pointer, it can exist in two of the following three
40 * places: sector 256, sector n (the max sector of the disk), or sector
41 * n - 256. It's a pretty good bet that one will exist at sector 256 though.
42 * One caveat is unclosed CD media. For that, sector 256 cannot be written,
43 * so the Anchor Volume Descriptor Pointer can exist at sector 512 until the
48 * n: Anchor Volume Descriptor Pointer
51 * |-->Main Volume Descriptor Sequence
54 * | |-->Logical Volume Descriptor
56 * |-->Partition Descriptor |
59 * |-->Fileset Descriptor
62 * |-->Root Dir File Entry
75 #include <sys/types.h>
76 #include <sys/param.h>
77 #include <sys/systm.h>
81 #include <sys/fcntl.h>
82 #include <sys/module.h>
83 #include <sys/kernel.h>
84 #include <sys/malloc.h>
85 #include <sys/mount.h>
86 #include <sys/nlookup.h>
89 #include <sys/queue.h>
90 #include <sys/vnode.h>
92 #include <vfs/udf/ecma167-udf.h>
93 #include <vfs/udf/osta.h>
94 #include <vfs/udf/udf.h>
95 #include <vfs/udf/udf_mount.h>
97 extern struct vop_ops udf_vnode_vops
;
99 MALLOC_DEFINE(M_UDFNODE
, "UDF node", "UDF node structure");
100 MALLOC_DEFINE(M_UDFMOUNT
, "UDF mount", "UDF mount structure");
101 MALLOC_DEFINE(M_UDFFENTRY
, "UDF fentry", "UDF file entry structure");
103 static int udf_mount(struct mount
*, char *, caddr_t
, struct ucred
*);
104 static int udf_unmount(struct mount
*, int);
105 static int udf_root(struct mount
*, struct vnode
**);
106 static int udf_statfs(struct mount
*, struct statfs
*, struct ucred
*);
107 static int udf_fhtovp(struct mount
*, struct vnode
*,
108 struct fid
*, struct vnode
**);
109 static int udf_vptofh(struct vnode
*, struct fid
*);
111 static int udf_find_partmaps(struct udf_mnt
*, struct logvol_desc
*);
113 static struct vfsops udf_vfsops
= {
114 .vfs_mount
= udf_mount
,
115 .vfs_unmount
= udf_unmount
,
116 .vfs_root
= udf_root
,
117 .vfs_statfs
= udf_statfs
,
118 .vfs_sync
= vfs_stdsync
,
119 .vfs_vget
= udf_vget
,
120 .vfs_fhtovp
= udf_fhtovp
,
121 .vfs_vptofh
= udf_vptofh
123 VFS_SET(udf_vfsops
, udf
, VFCF_READONLY
);
125 MODULE_VERSION(udf
, 1);
127 static int udf_mountfs(struct vnode
*, struct mount
*);
130 udf_mount(struct mount
*mp
, char *path
, caddr_t data
, struct ucred
*cred
)
132 struct vnode
*devvp
; /* vnode of the mount device */
133 struct udf_args args
;
134 struct udf_mnt
*imp
= 0;
137 struct nlookupdata nd
;
139 if ((mp
->mnt_flag
& MNT_RDONLY
) == 0)
143 * No root filesystem support. Probably not a big deal, since the
144 * bootloader doesn't understand UDF.
146 if (mp
->mnt_flag
& MNT_ROOTFS
)
149 if ((error
= copyin(data
, (caddr_t
)&args
, sizeof(struct udf_args
))))
152 if (mp
->mnt_flag
& MNT_UPDATE
) {
153 imp
= VFSTOUDFFS(mp
);
154 if (args
.fspec
== NULL
)
155 return(vfs_export(mp
, &imp
->im_export
, &args
.export
));
158 /* Check that the mount device exists */
160 error
= nlookup_init(&nd
, args
.fspec
, UIO_USERSPACE
, NLC_FOLLOW
);
162 error
= nlookup(&nd
);
164 error
= cache_vref(&nd
.nl_nch
, nd
.nl_cred
, &devvp
);
169 if (vn_isdisk(devvp
, &error
) == 0) {
174 /* Check the access rights on the mount device */
175 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
176 error
= VOP_EACCESS(devvp
, VREAD
, cred
);
178 error
= priv_check_cred(cred
, PRIV_ROOT
, 0);
185 if ((error
= udf_mountfs(devvp
, mp
))) {
190 imp
= VFSTOUDFFS(mp
);
192 imp
->im_flags
= args
.flags
;
194 copyinstr(args
.fspec
, mp
->mnt_stat
.f_mntfromname
, MNAMELEN
- 1, &size
);
195 bzero(mp
->mnt_stat
.f_mntfromname
+ size
, MNAMELEN
- size
);
196 udf_statfs(mp
, &mp
->mnt_stat
, cred
);
201 * Check the descriptor tag for both the correct id and correct checksum.
202 * Return zero if all is good, EINVAL if not.
205 udf_checktag(struct desc_tag
*tag
, uint16_t id
)
208 uint8_t i
, cksum
= 0;
210 itag
= (uint8_t *)tag
;
215 for (i
= 0; i
< 15; i
++)
216 cksum
= cksum
+ itag
[i
];
217 cksum
= cksum
- itag
[4];
219 if (cksum
== tag
->cksum
)
226 udf_mountfs(struct vnode
*devvp
, struct mount
*mp
)
228 struct buf
*bp
= NULL
;
229 struct anchor_vdp avdp
;
230 struct udf_mnt
*udfmp
= NULL
;
231 struct part_desc
*pd
;
232 struct logvol_desc
*lvd
;
233 struct fileset_desc
*fsd
;
234 struct file_entry
*root_fentry
;
236 uint32_t sector
, size
, mvds_start
, mvds_end
;
237 uint32_t fsd_offset
= 0;
238 uint16_t part_num
= 0, fsd_part
= 0;
239 int error
= EINVAL
, needclose
= 0;
240 int logvol_found
= 0, part_found
= 0, fsd_found
= 0;
244 * Disallow multiple mounts of the same device. Flush the buffer
245 * cache for the device.
247 if ((error
= vfs_mountedon(devvp
)))
249 if (vcount(devvp
) > 0)
251 if ((error
= vinvalbuf(devvp
, V_SAVE
, 0, 0)))
254 vn_lock(devvp
, LK_EXCLUSIVE
| LK_RETRY
);
255 error
= VOP_OPEN(devvp
, FREAD
, FSCRED
, NULL
);
262 udfmp
= kmalloc(sizeof(*udfmp
), M_UDFMOUNT
, M_WAITOK
| M_ZERO
);
264 mp
->mnt_data
= (qaddr_t
)udfmp
;
265 mp
->mnt_stat
.f_fsid
.val
[0] = dev2udev(dev
);
266 mp
->mnt_stat
.f_fsid
.val
[1] = mp
->mnt_vfc
->vfc_typenum
;
267 mp
->mnt_maxsymlinklen
= 0;
268 mp
->mnt_flag
|= MNT_LOCAL
;
269 udfmp
->im_mountp
= mp
;
271 udfmp
->im_devvp
= devvp
;
273 bsize
= 2048; /* XXX Should probe the media for it's size */
276 * Get the Anchor Volume Descriptor Pointer from sector 256.
277 * XXX Should also check sector n - 256, n, and 512.
280 if ((error
= bread(devvp
, (off_t
)sector
* bsize
, bsize
, &bp
)) != 0)
282 if ((error
= udf_checktag((struct desc_tag
*)bp
->b_data
, TAGID_ANCHOR
)))
285 bcopy(bp
->b_data
, &avdp
, sizeof(struct anchor_vdp
));
290 * Extract the Partition Descriptor and Logical Volume Descriptor
291 * from the Volume Descriptor Sequence.
292 * XXX Should we care about the partition type right now?
293 * XXX What about multiple partitions?
295 mvds_start
= avdp
.main_vds_ex
.loc
;
296 mvds_end
= mvds_start
+ (avdp
.main_vds_ex
.len
- 1) / bsize
;
297 for (sector
= mvds_start
; sector
< mvds_end
; sector
++) {
298 if ((error
= bread(devvp
, (off_t
)sector
* bsize
, bsize
,
300 kprintf("Can't read sector %d of VDS\n", sector
);
303 lvd
= (struct logvol_desc
*)bp
->b_data
;
304 if (!udf_checktag(&lvd
->tag
, TAGID_LOGVOL
)) {
305 udfmp
->bsize
= lvd
->lb_size
;
306 udfmp
->bmask
= udfmp
->bsize
- 1;
307 udfmp
->bshift
= ffs(udfmp
->bsize
) - 1;
308 fsd_part
= lvd
->_lvd_use
.fsd_loc
.loc
.part_num
;
309 fsd_offset
= lvd
->_lvd_use
.fsd_loc
.loc
.lb_num
;
310 if (udf_find_partmaps(udfmp
, lvd
))
314 pd
= (struct part_desc
*)bp
->b_data
;
315 if (!udf_checktag(&pd
->tag
, TAGID_PARTITION
)) {
317 part_num
= pd
->part_num
;
318 udfmp
->part_len
= pd
->part_len
;
319 udfmp
->part_start
= pd
->start_loc
;
324 if ((part_found
) && (logvol_found
))
328 if (!part_found
|| !logvol_found
) {
333 if (fsd_part
!= part_num
) {
334 kprintf("FSD does not lie within the partition!\n");
341 * Grab the Fileset Descriptor
342 * Thanks to Chuck McCrobie <mccrobie@cablespeed.com> for pointing
343 * me in the right direction here.
345 sector
= udfmp
->part_start
+ fsd_offset
;
346 if ((error
= RDSECTOR(devvp
, sector
, udfmp
->bsize
, &bp
)) != 0) {
347 kprintf("Cannot read sector %d of FSD\n", sector
);
350 fsd
= (struct fileset_desc
*)bp
->b_data
;
351 if (!udf_checktag(&fsd
->tag
, TAGID_FSD
)) {
353 bcopy(&fsd
->rootdir_icb
, &udfmp
->root_icb
,
354 sizeof(struct long_ad
));
361 kprintf("Couldn't find the fsd\n");
366 vfs_add_vnodeops(mp
, &udf_vnode_vops
, &mp
->mnt_vn_norm_ops
);
369 * Find the file entry for the root directory.
371 sector
= udfmp
->root_icb
.loc
.lb_num
+ udfmp
->part_start
;
372 size
= udfmp
->root_icb
.len
;
373 if ((error
= udf_readlblks(udfmp
, sector
, size
, &bp
)) != 0) {
374 kprintf("Cannot read sector %d\n", sector
);
378 root_fentry
= (struct file_entry
*)bp
->b_data
;
379 if ((error
= udf_checktag(&root_fentry
->tag
, TAGID_FENTRY
))) {
380 kprintf("Invalid root file entry!\n");
387 lwkt_token_init(&udfmp
->hash_token
);
388 udfmp
->hashtbl
= phashinit(UDF_HASHTBLSIZE
, M_UDFMOUNT
, &udfmp
->hashsz
);
394 kfree(udfmp
, M_UDFMOUNT
);
398 VOP_CLOSE(devvp
, FREAD
);
403 udf_unmount(struct mount
*mp
, int mntflags
)
405 struct udf_mnt
*udfmp
;
406 int error
, flags
= 0;
408 udfmp
= VFSTOUDFFS(mp
);
410 if (mntflags
& MNT_FORCE
)
413 if ((error
= vflush(mp
, 0, flags
)))
416 udfmp
->im_devvp
->v_rdev
->si_mountpoint
= NULL
;
417 error
= VOP_CLOSE(udfmp
->im_devvp
, FREAD
);
418 vrele(udfmp
->im_devvp
);
421 kfree(udfmp
->s_table
, M_UDFMOUNT
);
423 kfree(udfmp
->hashtbl
, M_UDFMOUNT
);
424 kfree(udfmp
, M_UDFMOUNT
);
426 mp
->mnt_data
= (qaddr_t
)0;
427 mp
->mnt_flag
&= ~MNT_LOCAL
;
433 udf_root(struct mount
*mp
, struct vnode
**vpp
)
435 struct udf_mnt
*udfmp
;
440 udfmp
= VFSTOUDFFS(mp
);
442 id
= udf_getid(&udfmp
->root_icb
);
444 error
= udf_vget(mp
, NULL
, id
, vpp
);
456 udf_statfs(struct mount
*mp
, struct statfs
*sbp
, struct ucred
*cred
)
458 struct udf_mnt
*udfmp
;
460 udfmp
= VFSTOUDFFS(mp
);
462 sbp
->f_bsize
= udfmp
->bsize
;
463 sbp
->f_iosize
= udfmp
->bsize
;
464 sbp
->f_blocks
= udfmp
->part_len
;
469 if (sbp
!= &mp
->mnt_stat
) {
470 sbp
->f_type
= mp
->mnt_vfc
->vfc_typenum
;
471 bcopy(mp
->mnt_stat
.f_mntfromname
, sbp
->f_mntfromname
, MNAMELEN
);
478 udf_vget(struct mount
*mp
, struct vnode
*dvp
, ino_t ino
, struct vnode
**vpp
)
482 struct udf_mnt
*udfmp
;
485 struct udf_node
*unode
;
486 struct file_entry
*fe
;
487 int error
, sector
, size
;
490 udfmp
= VFSTOUDFFS(mp
);
492 /* See if we already have this in the cache */
493 if ((error
= udf_hashlookup(udfmp
, ino
, vpp
)) != 0)
500 * Allocate memory and check the tag id's before grabbing a new
501 * vnode, since it's hard to roll back if there is a problem.
503 unode
= kmalloc(sizeof(*unode
), M_UDFNODE
, M_WAITOK
| M_ZERO
);
506 * Copy in the file entry. Per the spec, the size can only be 1 block.
508 sector
= ino
+ udfmp
->part_start
;
509 devvp
= udfmp
->im_devvp
;
510 if ((error
= RDSECTOR(devvp
, sector
, udfmp
->bsize
, &bp
)) != 0) {
511 kprintf("Cannot read sector %d\n", sector
);
512 kfree(unode
, M_UDFNODE
);
516 fe
= (struct file_entry
*)bp
->b_data
;
517 if (udf_checktag(&fe
->tag
, TAGID_FENTRY
)) {
518 kprintf("Invalid file entry!\n");
519 kfree(unode
, M_UDFNODE
);
523 size
= UDF_FENTRY_SIZE
+ fe
->l_ea
+ fe
->l_ad
;
524 unode
->fentry
= kmalloc(size
, M_UDFFENTRY
, M_WAITOK
| M_ZERO
);
526 bcopy(bp
->b_data
, unode
->fentry
, size
);
531 if ((error
= udf_allocv(mp
, &vp
))) {
532 kprintf("Error from udf_allocv\n");
533 kfree(unode
, M_UDFNODE
);
538 unode
->hash_id
= ino
;
539 unode
->i_devvp
= udfmp
->im_devvp
;
540 unode
->i_dev
= udfmp
->im_dev
;
541 unode
->udfmp
= udfmp
;
543 vref(udfmp
->im_devvp
);
546 switch (unode
->fentry
->icbtag
.file_type
) {
573 * Locked and refd vnode returned
588 udf_fhtovp(struct mount
*mp
, struct vnode
*rootvp
,
589 struct fid
*fhp
, struct vnode
**vpp
)
595 ifhp
= (struct ifid
*)fhp
;
597 if ((error
= VFS_VGET(mp
, NULL
, ifhp
->ifid_ino
, &nvp
)) != 0) {
607 udf_vptofh (struct vnode
*vp
, struct fid
*fhp
)
609 struct udf_node
*node
;
613 ifhp
= (struct ifid
*)fhp
;
614 ifhp
->ifid_len
= sizeof(struct ifid
);
615 ifhp
->ifid_ino
= node
->hash_id
;
621 udf_find_partmaps(struct udf_mnt
*udfmp
, struct logvol_desc
*lvd
)
623 union udf_pmap
*pmap
;
624 struct part_map_spare
*pms
;
625 struct regid
*pmap_id
;
627 unsigned char regid_id
[UDF_REGID_ID_SIZE
+ 1];
628 int ptype
, psize
, error
;
631 for (i
= 0; i
< lvd
->n_pm
; i
++) {
632 pmap
= (union udf_pmap
*)&lvd
->maps
[i
* UDF_PMAP_SIZE
];
633 ptype
= pmap
->data
[0];
634 psize
= pmap
->data
[1];
635 if (((ptype
!= 1) && (ptype
!= 2)) ||
636 ((psize
!= UDF_PMAP_SIZE
) && (psize
!= 6))) {
637 kprintf("Invalid partition map found\n");
642 /* Type 1 map. We don't care */
646 /* Type 2 map. Gotta find out the details */
647 pmap_id
= (struct regid
*)&pmap
->data
[4];
648 bzero(®id_id
[0], UDF_REGID_ID_SIZE
);
649 bcopy(&pmap_id
->id
[0], ®id_id
[0], UDF_REGID_ID_SIZE
);
651 if (bcmp(®id_id
[0], "*UDF Sparable Partition",
652 UDF_REGID_ID_SIZE
)) {
653 kprintf("Unsupported partition map: %s\n", ®id_id
[0]);
658 udfmp
->s_table
= kmalloc(pms
->st_size
, M_UDFMOUNT
,
661 /* Calculate the number of sectors per packet. */
662 /* XXX Logical or physical? */
663 udfmp
->p_sectors
= pms
->packet_len
/ udfmp
->bsize
;
666 * XXX If reading the first Sparing Table fails, should look
669 if ((error
= udf_readlblks(udfmp
, pms
->st_loc
[0], pms
->st_size
,
673 kprintf("Failed to read Sparing Table at sector %d\n",
677 bcopy(bp
->b_data
, udfmp
->s_table
, pms
->st_size
);
680 if (udf_checktag(&udfmp
->s_table
->tag
, 0)) {
681 kprintf("Invalid sparing table found\n");
685 /* See how many valid entries there are here. The list is
686 * supposed to be sorted. 0xfffffff0 and higher are not valid
688 for (i
= 0; i
< udfmp
->s_table
->rt_l
; i
++) {
689 udfmp
->s_table_entries
= i
;
690 if (udfmp
->s_table
->entries
[i
].org
>= 0xfffffff0)