Date: Tue, 05 Jun 2012 12:40:31 +0000 From: oleksandr@FreeBSD.org To: svn-soc-all@FreeBSD.org Subject: socsvn commit: r237134 - soc2012/oleksandr/udf-head/sys/fs/udf2 Message-ID: <20120605124031.880C01065678@hub.freebsd.org>
next in thread | raw e-mail | index | archive | help
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 ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20120605124031.880C01065678>