socsvn commit: r237134 - soc2012/oleksandr/udf-head/sys/fs/udf2
oleksandr at FreeBSD.org
oleksandr at FreeBSD.org
Tue Jun 5 12:40:33 UTC 2012
Author: oleksandr
Date: Tue Jun 5 12:40:30 2012
New Revision: 237134
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=237134
Log:
Initial change in udf structure and vfs system
Modified:
soc2012/oleksandr/udf-head/sys/fs/udf2/Makefile
soc2012/oleksandr/udf-head/sys/fs/udf2/udf.h
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_allocation.c
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_mount.h
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_osta.c
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_osta.h
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_readwrite.c
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_subr.c
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_subr.h
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_vfsops.c
soc2012/oleksandr/udf-head/sys/fs/udf2/udf_vnops.c
Modified: soc2012/oleksandr/udf-head/sys/fs/udf2/Makefile
==============================================================================
--- soc2012/oleksandr/udf-head/sys/fs/udf2/Makefile Tue Jun 5 11:48:32 2012 (r237133)
+++ soc2012/oleksandr/udf-head/sys/fs/udf2/Makefile Tue Jun 5 12:40:30 2012 (r237134)
@@ -1,7 +1,13 @@
-# $NetBSD: Makefile,v 1.1 2006/02/02 15:19:15 reinoud Exp $
+# $FreeBSD: src/sys/modules/udf/Makefile,v 1.5 2004/01/13 11:28:50 ru Exp $
-INCSDIR= /usr/include/fs/udf
+.PATH: ${.CURDIR}
-INCS= ecma167-udf.h udf_mount.h
+KMOD= udf2
-.include <bsd.kinc.mk>
+SRCS= udf_readwrite.c udf_subr.c udf_allocation.c \
+ udf_osta.c udf_vfsops.c udf_vnops.c udf_filenames.c
+# udf_strat_bootstrap.c udf_strat_direct.c udf_strat_rmw.c udf_strat_sequential.c
+SRCS+= vnode_if.h
+EXPORT_SYMS= udf_iconv
+
+.include <bsd.kmod.mk>
Modified: soc2012/oleksandr/udf-head/sys/fs/udf2/udf.h
==============================================================================
--- soc2012/oleksandr/udf-head/sys/fs/udf2/udf.h Tue Jun 5 11:48:32 2012 (r237133)
+++ soc2012/oleksandr/udf-head/sys/fs/udf2/udf.h Tue Jun 5 12:40:30 2012 (r237134)
@@ -1,6 +1,4 @@
-/* $NetBSD: udf.h,v 1.44 2011/09/27 01:13:16 christos Exp $ */
-
-/*
+/*-
* Copyright (c) 2006, 2008 Reinoud Zandijk
* All rights reserved.
*
@@ -29,71 +27,15 @@
#ifndef _FS_UDF_UDF_H_
#define _FS_UDF_UDF_H_
-#include <sys/queue.h>
-#include <sys/rbtree.h>
-#include <sys/uio.h>
-#include <sys/mutex.h>
-
#include "udf_osta.h"
-#include "ecma167-udf.h"
-#include <sys/cdio.h>
-#include <sys/bufq.h>
-#include <sys/disk.h>
-#include <sys/kthread.h>
-#include <miscfs/genfs/genfs_node.h>
-/* debug section */
-extern int udf_verbose;
+/* lets see debug stuff for now */
+#define DEBUG
+
/* undefine UDF_COMPLETE_DELETE to need `purge'; but purge is not implemented */
#define UDF_COMPLETE_DELETE
-/* debug categories */
-#define UDF_DEBUG_VOLUMES 0x0000001
-#define UDF_DEBUG_LOCKING 0x0000002
-#define UDF_DEBUG_NODE 0x0000004
-#define UDF_DEBUG_LOOKUP 0x0000008
-#define UDF_DEBUG_READDIR 0x0000010
-#define UDF_DEBUG_FIDS 0x0000020
-#define UDF_DEBUG_DESCRIPTOR 0x0000040
-#define UDF_DEBUG_TRANSLATE 0x0000080
-#define UDF_DEBUG_STRATEGY 0x0000100
-#define UDF_DEBUG_READ 0x0000200
-#define UDF_DEBUG_WRITE 0x0000400
-#define UDF_DEBUG_CALL 0x0000800
-#define UDF_DEBUG_ATTR 0x0001000
-#define UDF_DEBUG_EXTATTR 0x0002000
-#define UDF_DEBUG_ALLOC 0x0004000
-#define UDF_DEBUG_ADWLK 0x0008000
-#define UDF_DEBUG_DIRHASH 0x0010000
-#define UDF_DEBUG_NOTIMPL 0x0020000
-#define UDF_DEBUG_SHEDULE 0x0040000
-#define UDF_DEBUG_ECCLINE 0x0080000
-#define UDF_DEBUG_SYNC 0x0100000
-#define UDF_DEBUG_PARANOIA 0x0200000
-#define UDF_DEBUG_PARANOIDADWLK 0x0400000
-#define UDF_DEBUG_NODEDUMP 0x0800000
-#define UDF_DEBUG_RESERVE 0x1000000
-
-/* initial value of udf_verbose */
-#define UDF_DEBUGGING 0
-
-#ifdef DEBUG
-#define DPRINTF(name, arg) { \
- if (udf_verbose & UDF_DEBUG_##name) {\
- printf arg;\
- };\
- }
-#define DPRINTFIF(name, cond, arg) { \
- if (udf_verbose & UDF_DEBUG_##name) { \
- if (cond) printf arg;\
- };\
- }
-#else
-#define DPRINTF(name, arg) {}
-#define DPRINTFIF(name, cond, arg) {}
-#endif
-
/* constants to identify what kind of identifier we are dealing with */
#define UDF_REGID_DOMAIN 1
@@ -111,9 +53,7 @@
/* Configuration values */
-#define UDF_INODE_HASHBITS 10
-#define UDF_INODE_HASHSIZE (1<<UDF_INODE_HASHBITS)
-#define UDF_INODE_HASHMASK (UDF_INODE_HASHSIZE - 1)
+#if 0
#define UDF_ECCBUF_HASHBITS 10
#define UDF_ECCBUF_HASHSIZE (1<<UDF_ECCBUF_HASHBITS)
#define UDF_ECCBUF_HASHMASK (UDF_ECCBUF_HASHSIZE -1)
@@ -122,6 +62,7 @@
#define UDF_ECCLINE_MAXBUSY 100 /* picked, needs calculation */
#define UDF_MAX_MAPPINGS (MAXPHYS/DEV_BSIZE) /* 128 */
+#endif
#define UDF_VAT_CHUNKSIZE (64*1024) /* picked */
#define UDF_SYMLINKBUFLEN (64*1024) /* picked */
@@ -139,7 +80,7 @@
/* constants */
-#define UDF_MAXNAMLEN 255 /* as per SPEC */
+#define UDF_MAX_NAMELEN 255 /* as per SPEC */
#define UDF_TRANS_ZERO ((uint64_t) -1)
#define UDF_TRANS_UNMAPPED ((uint64_t) -2)
#define UDF_TRANS_INTERN ((uint64_t) -3)
@@ -206,11 +147,9 @@
/* malloc pools */
-MALLOC_DECLARE(M_UDFMNT);
-MALLOC_DECLARE(M_UDFVOLD);
MALLOC_DECLARE(M_UDFTEMP);
-struct pool udf_node_pool;
+//struct pool udf_node_pool;
struct udf_node;
struct udf_strategy;
@@ -239,7 +178,7 @@
struct long_ad *icb;
union dscrptr *dscr;
struct buf *nestbuf;
- kauth_cred_t cred;
+/* kauth_cred_t cred; */ /* Not ever used? */
int waitfor;
};
@@ -253,21 +192,42 @@
void (*discstrat_finish) (struct udf_strat_args *args);
};
-extern struct udf_strategy udf_strat_bootstrap;
-extern struct udf_strategy udf_strat_sequential;
-extern struct udf_strategy udf_strat_direct;
-extern struct udf_strategy udf_strat_rmw;
+//extern struct udf_strategy udf_strat_bootstrap;
+//extern struct udf_strategy udf_strat_sequential;
+//extern struct udf_strategy udf_strat_direct;
+//extern struct udf_strategy udf_strat_rmw;
+extern struct udf_strategy udf_strat_readonly;
/* pre cleanup */
struct udf_mount {
struct mount *vfs_mountp;
struct vnode *devvp;
- struct mmc_discinfo discinfo;
- struct udf_args mount_args;
+ struct cdev *dev;
+ struct g_consumer *geomcp;
+ struct bufobj *bo;
+/* struct mmc_discinfo discinfo; */
+ uint32_t sector_size;
+// struct udf_args mount_args;
+ int flags;
+ uid_t anon_uid;
+ gid_t anon_gid;
+ uid_t nobody_uid;
+ gid_t nobody_gid;
+
+ /* iconv */
+ void *iconv_d2l; /* disk to local */
+#if 0
+ void *iconv_l2d; /* local to disk */
+#endif
+
+ /* Used in mounting */
+ uint32_t first_trackblank;
+ uint32_t session_start;
+ uint32_t session_end;
/* format descriptors */
- kmutex_t logvol_mutex;
+/* kmutex_t logvol_mutex; */ /* Who needs locks... */
struct anchor_vdp *anchors[UDF_ANCHORS]; /* anchors to VDS */
struct pri_vol_desc *primary_vol; /* identification */
struct logvol_desc *logical_vol; /* main mapping v->p */
@@ -291,7 +251,7 @@
int vtop_tp[UDF_PMAPS+1]; /* type of trans */
/* disc allocation / writing method */
- kmutex_t allocate_mutex;
+/* kmutex_t allocate_mutex; */
int lvreadwrite; /* error handling */
int vtop_alloc[UDF_PMAPS+1]; /* alloc scheme */
int data_part;
@@ -299,8 +259,8 @@
int fids_part;
/* sequential track info */
- struct mmc_trackinfo data_track;
- struct mmc_trackinfo metadata_track;
+/* struct mmc_trackinfo data_track;
+ struct mmc_trackinfo metadata_track; */
/* VAT */
uint32_t first_possible_vat_location;
@@ -336,18 +296,18 @@
uint8_t metadata_flags;
/* rb tree for lookup icb to udf_node and sorted list for sync */
- kmutex_t ihash_lock;
- kmutex_t get_node_lock;
- struct rb_tree udf_node_tree;
+/* kmutex_t ihash_lock;
+ kmutex_t get_node_lock; */
+/* struct rb_tree udf_node_tree; */
/* syncing */
int syncing; /* are we syncing? */
- kcondvar_t dirtynodes_cv; /* sleeping on sync */
+/* kcondvar_t dirtynodes_cv; */ /* sleeping on sync */
/* late allocation */
int32_t uncommitted_lbs[UDF_PARTITIONS];
- struct long_ad *la_node_ad_cpy; /* issue buf */
- uint64_t *la_lmapping, *la_pmapping; /* issue buf */
+// struct long_ad *la_node_ad_cpy; /* issue buf */
+// uint64_t *la_lmapping, *la_pmapping; /* issue buf */
/* lists */
STAILQ_HEAD(udfmntpts, udf_mount) all_udf_mntpnts;
@@ -357,23 +317,32 @@
void *strategy_private;
};
+#if 0
+#define RBTOUDFNODE(node) \
+ ((node) ? \
+ (void *)((uintptr_t)(node) - offsetof(struct udf_node, rbnode)) \
+ : NULL)
+#endif
+
/*
* UDF node describing a file/directory.
*
* BUGALERT claim node_mutex before reading/writing to prevent inconsistencies !
*/
struct udf_node {
- struct genfs_node i_gnode; /* has to be first */
+/* struct genfs_node i_gnode; */ /* has to be first */
struct vnode *vnode; /* vnode associated */
struct udf_mount *ump;
- kmutex_t node_mutex;
- kcondvar_t node_lock; /* sleeping lock */
+ ino_t hash_id; /* should contain inode */
+ int diroff; /* used in lookup */
+/* kmutex_t node_mutex;
+ kcondvar_t node_lock; */ /* sleeping lock */
char const *lock_fname;
int lock_lineno;
/* rb_node for fast lookup and fast sequential visiting */
- struct rb_node rbnode;
+/* struct rb_node rbnode; */
/* one of `fe' or `efe' can be set, not both (UDF file entry dscr.) */
struct file_entry *fe;
@@ -423,4 +392,10 @@
"\6IN_ACCESSED\7IN_RENAME\10IN_DELETED\11IN_LOCKED\12IN_SYNCED" \
"\13IN_CALLBACK_ULK\14IN_NODE_REBUILD"
+struct udf_fid {
+ u_short len; /* length of data in bytes */
+ u_short padding; /* force longword alignment */
+ ino_t ino;
+};
+
#endif /* !_FS_UDF_UDF_H_ */
Modified: soc2012/oleksandr/udf-head/sys/fs/udf2/udf_allocation.c
==============================================================================
--- soc2012/oleksandr/udf-head/sys/fs/udf2/udf_allocation.c Tue Jun 5 11:48:32 2012 (r237133)
+++ soc2012/oleksandr/udf-head/sys/fs/udf2/udf_allocation.c Tue Jun 5 12:40:30 2012 (r237134)
@@ -1,6 +1,4 @@
-/* $NetBSD: udf_allocation.c,v 1.32 2011/06/16 09:21:02 hannken Exp $ */
-
-/*
+/*-
* Copyright (c) 2006, 2008 Reinoud Zandijk
* All rights reserved.
*
@@ -27,48 +25,18 @@
*/
#include <sys/cdefs.h>
-#ifndef lint
-__KERNEL_RCSID(0, "$NetBSD: udf_allocation.c,v 1.32 2011/06/16 09:21:02 hannken Exp $");
-#endif /* not lint */
-
-
-#if defined(_KERNEL_OPT)
-#include "opt_compat_netbsd.h"
-#endif
-
-/* TODO strip */
+#include <sys/endian.h>
#include <sys/param.h>
#include <sys/systm.h>
-#include <sys/sysctl.h>
-#include <sys/namei.h>
-#include <sys/proc.h>
-#include <sys/kernel.h>
-#include <sys/vnode.h>
-#include <miscfs/genfs/genfs_node.h>
-#include <sys/mount.h>
-#include <sys/buf.h>
-#include <sys/file.h>
-#include <sys/device.h>
-#include <sys/disklabel.h>
-#include <sys/ioctl.h>
+#include <sys/limits.h>
#include <sys/malloc.h>
-#include <sys/dirent.h>
-#include <sys/stat.h>
-#include <sys/conf.h>
-#include <sys/kauth.h>
-#include <sys/kthread.h>
-#include <dev/clock_subr.h>
-
-#include <fs/udf/ecma167-udf.h>
-#include <fs/udf/udf_mount.h>
+#include "ecma167-udf.h"
#include "udf.h"
#include "udf_subr.h"
-#include "udf_bswap.h"
-#define VTOI(vnode) ((struct udf_node *) vnode->v_data)
-
+#if 0
static void udf_record_allocation_in_node(struct udf_mount *ump,
struct buf *buf, uint16_t vpart_num, uint64_t *mapping,
struct long_ad *node_ad_cpy);
@@ -76,10 +44,15 @@
static void udf_collect_free_space_for_vpart(struct udf_mount *ump,
uint16_t vpart_num, uint32_t num_lb);
-static int udf_ads_merge(uint32_t max_len, uint32_t lb_size, struct long_ad *a1, struct long_ad *a2);
static void udf_wipe_adslots(struct udf_node *udf_node);
static void udf_count_alloc_exts(struct udf_node *udf_node);
+/*
+ * IDEA/BUSY: Each udf_node gets its own extentwalker state for all operations;
+ * this will hopefully/likely reduce O(nlog(n)) to O(1) for most functionality
+ * since actions are most likely sequencial and thus seeking doesn't need
+ * searching for the same or adjacent position again.
+ */
/* --------------------------------------------------------------------- */
@@ -101,19 +74,19 @@
if ((udf_verbose & UDF_DEBUG_NODEDUMP) == 0)
return;
- lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
fe = udf_node->fe;
efe = udf_node->efe;
if (fe) {
icbtag = &fe->icbtag;
- inflen = udf_rw64(fe->inf_len);
+ inflen = le64toh(fe->inf_len);
} else {
icbtag = &efe->icbtag;
- inflen = udf_rw64(efe->inf_len);
+ inflen = le64toh(efe->inf_len);
}
- icbflags = udf_rw16(icbtag->flags);
+ icbflags = le16toh(icbtag->flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
printf("udf_node_dump %p :\n", udf_node);
@@ -131,9 +104,9 @@
udf_get_adslot(udf_node, slot, &s_ad, &eof);
if (eof)
break;
- part_num = udf_rw16(s_ad.loc.part_num);
- lb_num = udf_rw32(s_ad.loc.lb_num);
- len = udf_rw32(s_ad.len);
+ part_num = le16toh(s_ad.loc.part_num);
+ lb_num = le32toh(s_ad.loc.lb_num);
+ len = le32toh(s_ad.len);
flags = UDF_EXT_FLAGS(len);
len = UDF_EXT_LEN(len);
@@ -181,7 +154,7 @@
case UDF_VTOP_TYPE_PHYS :
case UDF_VTOP_TYPE_SPARABLE :
/* free space to freed or unallocated space bitmap */
- ptov = udf_rw32(pdesc->start_loc);
+ ptov = le32toh(pdesc->start_loc);
phys_part = ump->vtop[vpart_num];
/* use unallocated bitmap */
@@ -246,35 +219,35 @@
int dscr_size, lb_size, flags, whole_lb;
int i, slot, eof;
-// KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
+ KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
if (1)
udf_node_dump(udf_node);
- lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
fe = udf_node->fe;
efe = udf_node->efe;
if (fe) {
dscr = (union dscrptr *) fe;
icbtag = &fe->icbtag;
- inflen = udf_rw64(fe->inf_len);
+ inflen = le64toh(fe->inf_len);
dscr_size = sizeof(struct file_entry) -1;
- logblksrec = udf_rw64(fe->logblks_rec);
- l_ad = udf_rw32(fe->l_ad);
- l_ea = udf_rw32(fe->l_ea);
+ logblksrec = le64toh(fe->logblks_rec);
+ l_ad = le32toh(fe->l_ad);
+ l_ea = le32toh(fe->l_ea);
} else {
dscr = (union dscrptr *) efe;
icbtag = &efe->icbtag;
- inflen = udf_rw64(efe->inf_len);
+ inflen = le64toh(efe->inf_len);
dscr_size = sizeof(struct extfile_entry) -1;
- logblksrec = udf_rw64(efe->logblks_rec);
- l_ad = udf_rw32(efe->l_ad);
- l_ea = udf_rw32(efe->l_ea);
+ logblksrec = le64toh(efe->logblks_rec);
+ l_ad = le32toh(efe->l_ad);
+ l_ea = le32toh(efe->l_ea);
}
data_pos = (uint8_t *) dscr + dscr_size + l_ea;
max_l_ad = lb_size - dscr_size - l_ea;
- icbflags = udf_rw16(icbtag->flags);
+ icbflags = le16toh(icbtag->flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
/* check if tail is zero */
@@ -305,9 +278,9 @@
break;
KASSERT(whole_lb == 1);
- part_num = udf_rw16(s_ad.loc.part_num);
- lb_num = udf_rw32(s_ad.loc.lb_num);
- len = udf_rw32(s_ad.len);
+ part_num = le16toh(s_ad.loc.part_num);
+ lb_num = le32toh(s_ad.loc.lb_num);
+ len = le32toh(s_ad.len);
flags = UDF_EXT_FLAGS(len);
len = UDF_EXT_LEN(len);
@@ -334,7 +307,7 @@
KASSERT(*cnt_inflen == inflen);
KASSERT(*cnt_logblksrec == logblksrec);
-// KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
+ KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
}
#else
static void
@@ -346,26 +319,26 @@
uint64_t inflen, logblksrec;
int dscr_size, lb_size;
- lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
+ lb_size = le32toh(udf_node->ump->logical_vol->lb_size);
fe = udf_node->fe;
efe = udf_node->efe;
if (fe) {
icbtag = &fe->icbtag;
- inflen = udf_rw64(fe->inf_len);
+ inflen = le64toh(fe->inf_len);
dscr_size = sizeof(struct file_entry) -1;
- logblksrec = udf_rw64(fe->logblks_rec);
+ logblksrec = le64toh(fe->logblks_rec);
} else {
icbtag = &efe->icbtag;
- inflen = udf_rw64(efe->inf_len);
+ inflen = le64toh(efe->inf_len);
dscr_size = sizeof(struct extfile_entry) -1;
- logblksrec = udf_rw64(efe->logblks_rec);
+ logblksrec = le64toh(efe->logblks_rec);
}
*cnt_logblksrec = logblksrec;
*cnt_inflen = inflen;
}
#endif
-
+#endif
/* --------------------------------------------------------------------- */
void
@@ -385,9 +358,10 @@
* We sum all free space up here regardless of type.
*/
- KASSERT(lvid);
- num_vpart = udf_rw32(lvid->num_part);
+/* KASSERT(lvid); */
+ num_vpart = le32toh(lvid->num_part);
+#if 0
if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
/* use track info directly summing if there are 2 open */
/* XXX assumption at most two tracks open */
@@ -396,16 +370,19 @@
*freeblks += ump->metadata_track.free_blocks;
*sizeblks = ump->discinfo.last_possible_lba;
} else {
+#endif
/* free and used space for mountpoint based on logvol integrity */
for (vpart = 0; vpart < num_vpart; vpart++) {
pos1 = &lvid->tables[0] + vpart;
pos2 = &lvid->tables[0] + num_vpart + vpart;
- if (udf_rw32(*pos1) != (uint32_t) -1) {
- *freeblks += udf_rw32(*pos1);
- *sizeblks += udf_rw32(*pos2);
+ if (le32toh(*pos1) != (uint32_t) -1) {
+ *freeblks += le32toh(*pos1);
+ *sizeblks += le32toh(*pos2);
}
}
+#if 0
}
+#endif
/* adjust for accounted uncommitted blocks */
for (vpart = 0; vpart < num_vpart; vpart++)
*freeblks -= ump->uncommitted_lbs[vpart];
@@ -417,7 +394,7 @@
}
}
-
+#if 0
static void
udf_calc_vpart_freespace(struct udf_mount *ump, uint16_t vpart_num, uint64_t *freeblks)
{
@@ -445,8 +422,8 @@
} else {
/* free and used space for mountpoint based on logvol integrity */
pos1 = &lvid->tables[0] + vpart_num;
- if (udf_rw32(*pos1) != (uint32_t) -1)
- *freeblks += udf_rw32(*pos1);
+ if (le32toh(*pos1) != (uint32_t) -1)
+ *freeblks += le32toh(*pos1);
}
/* adjust for accounted uncommitted blocks */
@@ -456,7 +433,7 @@
*freeblks = 0;
}
}
-
+#endif
/* --------------------------------------------------------------------- */
int
@@ -467,16 +444,15 @@
struct spare_map_entry *sme;
struct long_ad s_icb_loc;
uint64_t foffset, end_foffset;
- uint32_t lb_size, len;
- uint32_t lb_num, lb_rel, lb_packet;
+ int rel, part, error, eof, slot, flags;
+ uint32_t lb_size, len, lb_num, lb_rel, lb_packet;
uint32_t udf_rw32_lbmap, ext_offset;
uint16_t vpart;
- int rel, part, error, eof, slot, flags;
- assert(ump && icb_loc && lb_numres);
+ KASSERT(ump && icb_loc && lb_numres,("ump && icb_loc && lb_numres"));
- vpart = udf_rw16(icb_loc->loc.part_num);
- lb_num = udf_rw32(icb_loc->loc.lb_num);
+ vpart = le16toh(icb_loc->loc.part_num);
+ lb_num = le32toh(icb_loc->loc.lb_num);
if (vpart > UDF_VTOP_RAWPART)
return EINVAL;
@@ -492,12 +468,12 @@
return 0;
case UDF_VTOP_TYPE_PHYS :
/* transform into its disc logical block */
- if (lb_num > udf_rw32(pdesc->part_len))
+ if (lb_num > le32toh(pdesc->part_len))
return EINVAL;
- *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
/* extent from here to the end of the partition */
- *extres = udf_rw32(pdesc->part_len) - lb_num;
+ *extres = le32toh(pdesc->part_len) - lb_num;
return 0;
case UDF_VTOP_TYPE_VIRT :
/* only maps one logical block, lookup in VAT */
@@ -505,21 +481,18 @@
return EINVAL;
/* lookup in virtual allocation table file */
- mutex_enter(&ump->allocate_mutex);
error = udf_vat_read(ump->vat_node,
(uint8_t *) &udf_rw32_lbmap, 4,
ump->vat_offset + lb_num * 4);
- mutex_exit(&ump->allocate_mutex);
-
if (error)
return error;
- lb_num = udf_rw32(udf_rw32_lbmap);
+ lb_num = le32toh(udf_rw32_lbmap);
/* transform into its disc logical block */
- if (lb_num > udf_rw32(pdesc->part_len))
+ if (lb_num > le32toh(pdesc->part_len))
return EINVAL;
- *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
/* just one logical block */
*extres = 1;
@@ -529,29 +502,30 @@
lb_packet = lb_num / ump->sparable_packet_size;
lb_rel = lb_num % ump->sparable_packet_size;
- for (rel = 0; rel < udf_rw16(ump->sparing_table->rt_l); rel++) {
+ for (rel = 0; rel < le16toh(ump->sparing_table->rt_l); rel++) {
sme = &ump->sparing_table->entries[rel];
- if (lb_packet == udf_rw32(sme->org)) {
+ if (lb_packet == le32toh(sme->org)) {
/* NOTE maps to absolute disc logical block! */
- *lb_numres = udf_rw32(sme->map) + lb_rel;
+ *lb_numres = le32toh(sme->map) + lb_rel;
*extres = ump->sparable_packet_size - lb_rel;
return 0;
}
}
/* transform into its disc logical block */
- if (lb_num > udf_rw32(pdesc->part_len))
+ if (lb_num > le32toh(pdesc->part_len))
return EINVAL;
- *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
+ *lb_numres = lb_num + le32toh(pdesc->start_loc);
/* rest of block */
*extres = ump->sparable_packet_size - lb_rel;
return 0;
case UDF_VTOP_TYPE_META :
+printf("Metadata Partition Translated\n");
/* we have to look into the file's allocation descriptors */
/* use metadatafile allocation mutex */
- lb_size = udf_rw32(ump->logical_vol->lb_size);
+ lb_size = le32toh(ump->logical_vol->lb_size);
UDF_LOCK_NODE(ump->metadata_node, 0);
@@ -561,21 +535,11 @@
for (;;) {
udf_get_adslot(ump->metadata_node,
slot, &s_icb_loc, &eof);
- DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, "
- "len = %d, lb_num = %d, part = %d\n",
- slot, eof,
- UDF_EXT_FLAGS(udf_rw32(s_icb_loc.len)),
- UDF_EXT_LEN(udf_rw32(s_icb_loc.len)),
- udf_rw32(s_icb_loc.loc.lb_num),
- udf_rw16(s_icb_loc.loc.part_num)));
if (eof) {
- DPRINTF(TRANSLATE,
- ("Meta partition translation "
- "failed: can't seek location\n"));
UDF_UNLOCK_NODE(ump->metadata_node, 0);
return EINVAL;
}
- len = udf_rw32(s_icb_loc.len);
+ len = le32toh(s_icb_loc.len);
flags = UDF_EXT_FLAGS(len);
len = UDF_EXT_LEN(len);
@@ -595,17 +559,14 @@
ext_offset = lb_num * lb_size - foffset;
/* process extent offset */
- lb_num = udf_rw32(s_icb_loc.loc.lb_num);
- vpart = udf_rw16(s_icb_loc.loc.part_num);
+ lb_num = le32toh(s_icb_loc.loc.lb_num);
+ vpart = le16toh(s_icb_loc.loc.part_num);
lb_num += (ext_offset + lb_size -1) / lb_size;
ext_offset = 0;
UDF_UNLOCK_NODE(ump->metadata_node, 0);
- if (flags != UDF_EXT_ALLOCATED) {
- DPRINTF(TRANSLATE, ("Metadata partition translation "
- "failed: not allocated\n"));
+ if (flags != UDF_EXT_ALLOCATED)
return EINVAL;
- }
/*
* vpart and lb_num are updated, translate again since we
@@ -623,6 +584,7 @@
/* XXX provisional primitive braindead version */
/* TODO use ext_res */
+#if 0
void
udf_translate_vtop_list(struct udf_mount *ump, uint32_t sectors,
uint16_t vpart_num, uint64_t *lmapping, uint64_t *pmapping)
@@ -633,22 +595,133 @@
for (sector = 0; sector < sectors; sector++) {
memset(&loc, 0, sizeof(struct long_ad));
- loc.loc.part_num = udf_rw16(vpart_num);
- loc.loc.lb_num = udf_rw32(*lmapping);
+ loc.loc.part_num = le16toh(vpart_num);
+ loc.loc.lb_num = le32toh(*lmapping);
udf_translate_vtop(ump, &loc, &lb_numres, &ext_res);
*pmapping = lb_numres;
lmapping++; pmapping++;
}
}
+#endif
+
+/* --------------------------------------------------------------------- */
+/*
+ *This is a simplified version of the following function. It is used in
+ * bmap.
+ */
+int
+udf_bmap_translate(struct udf_node *udf_node, uint32_t block,
+ uint64_t *lsector, uint32_t *maxblks)
+{
+ struct udf_mount *ump;
+ struct icb_tag *icbtag;
+ struct long_ad t_ad, s_ad;
+ uint64_t foffset, new_foffset;
+ int eof, error, flags, slot, addr_type, icbflags;
+ uint32_t transsec32, lb_size, ext_offset, lb_num, len;
+ uint32_t ext_remain, translen;
+ uint16_t vpart_num;
+
+ if (!udf_node)
+ return ENOENT;
+
+ KASSERT(num_lb > 0,("num_lb > 0"));
+
+ UDF_LOCK_NODE(udf_node, 0);
+
+ /* initialise derivative vars */
+ ump = udf_node->ump;
+ lb_size = le32toh(ump->logical_vol->lb_size);
+
+ if (udf_node->fe) {
+ icbtag = &udf_node->fe->icbtag;
+ } else {
+ icbtag = &udf_node->efe->icbtag;
+ }
+ icbflags = le16toh(icbtag->flags);
+ addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
+
+ /* do the work */
+ if (addr_type == UDF_ICB_INTERN_ALLOC) {
+ *lsector = UDF_TRANS_INTERN;
+ *maxblks = 1;
+ UDF_UNLOCK_NODE(udf_node, 0);
+ return 0;
+ }
+
+ /* find first overlapping extent */
+ foffset = 0;
+ slot = 0;
+ for (;;) {
+ udf_get_adslot(udf_node, slot, &s_ad, &eof);
+ if (eof) {
+ UDF_UNLOCK_NODE(udf_node, 0);
+ return EINVAL;
+ }
+ len = le32toh(s_ad.len);
+ flags = UDF_EXT_FLAGS(len);
+ len = UDF_EXT_LEN(len);
+
+ if (flags == UDF_EXT_REDIRECT) {
+ slot++;
+ continue;
+ }
+
+ new_foffset = foffset + len;
+
+ if (new_foffset > block * lb_size)
+ break; /* found */
+ foffset = new_foffset;
+ slot++;
+ }
+ /* found overlapping slot */
+ lb_num = le32toh(s_ad.loc.lb_num);
+ vpart_num = le16toh(s_ad.loc.part_num);
+
+ ext_offset = block * lb_size - foffset;
+ lb_num += (ext_offset + lb_size -1) / lb_size;
+ ext_remain = (len - ext_offset + lb_size -1) / lb_size;
+ /*
+ * note that the while(){} is nessisary for the extent that
+ * the udf_translate_vtop() returns doens't have to span the
+ * whole extent.
+ */
+ switch (flags) {
+ case UDF_EXT_FREE :
+ case UDF_EXT_ALLOCATED_BUT_NOT_USED :
+ *lsector = UDF_TRANS_ZERO;
+ *maxblks = ext_remain;
+ break;
+ case UDF_EXT_ALLOCATED :
+ t_ad.loc.lb_num = htole32(lb_num);
+ t_ad.loc.part_num = htole16(vpart_num);
+ error = udf_translate_vtop(ump,
+ &t_ad, &transsec32, &translen);
+ if (error) {
+ UDF_UNLOCK_NODE(udf_node, 0);
+ return error;
+ }
+ *lsector = transsec32;
+ *maxblks = MIN(ext_remain, translen);
+ break;
+ default:
+ UDF_UNLOCK_NODE(udf_node, 0);
+ return EINVAL;
+ }
+
+ UDF_UNLOCK_NODE(udf_node, 0);
+
+ return 0;
+}
/* --------------------------------------------------------------------- */
/*
* Translate an extent (in logical_blocks) into logical block numbers; used
* for read and write operations. DOESNT't check extents.
*/
-
+#if 0
int
udf_translate_file_extent(struct udf_node *udf_node,
uint32_t from, uint32_t num_lb,
@@ -677,14 +750,14 @@
/* initialise derivative vars */
ump = udf_node->ump;
- lb_size = udf_rw32(ump->logical_vol->lb_size);
+ lb_size = le32toh(ump->logical_vol->lb_size);
if (udf_node->fe) {
icbtag = &udf_node->fe->icbtag;
} else {
icbtag = &udf_node->efe->icbtag;
}
- icbflags = udf_rw16(icbtag->flags);
+ icbflags = le16toh(icbtag->flags);
addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
/* do the work */
@@ -701,10 +774,10 @@
udf_get_adslot(udf_node, slot, &s_ad, &eof);
DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
"lb_num = %d, part = %d\n", slot, eof,
- UDF_EXT_FLAGS(udf_rw32(s_ad.len)),
- UDF_EXT_LEN(udf_rw32(s_ad.len)),
- udf_rw32(s_ad.loc.lb_num),
- udf_rw16(s_ad.loc.part_num)));
+ UDF_EXT_FLAGS(le32toh(s_ad.len)),
+ UDF_EXT_LEN(le32toh(s_ad.len)),
+ le32toh(s_ad.loc.lb_num),
+ le16toh(s_ad.loc.part_num)));
if (eof) {
DPRINTF(TRANSLATE,
("Translate file extent "
@@ -712,10 +785,10 @@
UDF_UNLOCK_NODE(udf_node, 0);
return EINVAL;
}
- len = udf_rw32(s_ad.len);
+ len = le32toh(s_ad.len);
flags = UDF_EXT_FLAGS(len);
len = UDF_EXT_LEN(len);
- lb_num = udf_rw32(s_ad.loc.lb_num);
+ lb_num = le32toh(s_ad.loc.lb_num);
if (flags == UDF_EXT_REDIRECT) {
slot++;
@@ -736,10 +809,10 @@
udf_get_adslot(udf_node, slot, &s_ad, &eof);
DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
"lb_num = %d, part = %d\n", slot, eof,
- UDF_EXT_FLAGS(udf_rw32(s_ad.len)),
- UDF_EXT_LEN(udf_rw32(s_ad.len)),
- udf_rw32(s_ad.loc.lb_num),
- udf_rw16(s_ad.loc.part_num)));
+ UDF_EXT_FLAGS(le32toh(s_ad.len)),
+ UDF_EXT_LEN(le32toh(s_ad.len)),
+ le32toh(s_ad.loc.lb_num),
+ le16toh(s_ad.loc.part_num)));
if (eof) {
DPRINTF(TRANSLATE,
("Translate file extent "
@@ -748,12 +821,12 @@
return EINVAL;
}
- len = udf_rw32(s_ad.len);
+ len = le32toh(s_ad.len);
flags = UDF_EXT_FLAGS(len);
len = UDF_EXT_LEN(len);
- lb_num = udf_rw32(s_ad.loc.lb_num);
- vpart_num = udf_rw16(s_ad.loc.part_num);
+ lb_num = le32toh(s_ad.loc.lb_num);
+ vpart_num = le16toh(s_ad.loc.part_num);
end_foffset = foffset + len;
@@ -782,8 +855,8 @@
}
break;
case UDF_EXT_ALLOCATED :
- t_ad.loc.lb_num = udf_rw32(lb_num);
- t_ad.loc.part_num = udf_rw16(vpart_num);
+ t_ad.loc.lb_num = le32toh(lb_num);
+ t_ad.loc.part_num = le16toh(vpart_num);
error = udf_translate_vtop(ump,
&t_ad, &transsec32, &translen);
transsec = transsec32;
@@ -829,7 +902,7 @@
KASSERT(ump);
KASSERT(ump->logical_vol);
- lb_size = udf_rw32(ump->logical_vol->lb_size);
+ lb_size = le32toh(ump->logical_vol->lb_size);
blob = malloc(lb_size, M_UDFTEMP, M_WAITOK);
/* TODO static allocation of search chunk */
@@ -852,7 +925,7 @@
/* search this chunk */
for (entry=0; entry < chunk /4; entry++, lb_num++) {
udf_rw32_lbmap = *((uint32_t *) (blob + entry * 4));
- lb_map = udf_rw32(udf_rw32_lbmap);
+ lb_map = le32toh(udf_rw32_lbmap);
if (lb_map == 0xffffffff) {
found = 1;
break;
@@ -872,7 +945,7 @@
}
/* mark entry with initialiser just in case */
- lb_map = udf_rw32(0xfffffffe);
+ lb_map = le32toh(0xfffffffe);
udf_vat_write(ump->vat_node, (uint8_t *) &lb_map, 4,
ump->vat_offset + lb_num *4);
ump->vat_last_free_lb = lb_num;
@@ -928,7 +1001,7 @@
lb_num = offset + bit-1;
*lmappos++ = lb_num;
*num_lb = *num_lb - 1;
- // offset = (offset & ~7);
+ /* offset = (offset & ~7); */
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-soc-all
mailing list