Home | History | Annotate | Line # | Download | only in hfs
hfs_subr.c revision 1.8.8.1
      1  1.8.8.1   yamt /*	$NetBSD: hfs_subr.c,v 1.8.8.1 2008/05/18 12:34:59 yamt Exp $	*/
      2      1.1  dillo 
      3      1.1  dillo /*-
      4      1.1  dillo  * Copyright (c) 2005, 2007 The NetBSD Foundation, Inc.
      5      1.1  dillo  * All rights reserved.
      6      1.1  dillo  *
      7      1.1  dillo  * This code is derived from software contributed to The NetBSD Foundation
      8      1.1  dillo  * by Yevgeny Binder and Dieter Baron.
      9      1.1  dillo  *
     10      1.1  dillo  * Redistribution and use in source and binary forms, with or without
     11      1.1  dillo  * modification, are permitted provided that the following conditions
     12      1.1  dillo  * are met:
     13      1.1  dillo  * 1. Redistributions of source code must retain the above copyright
     14      1.1  dillo  *    notice, this list of conditions and the following disclaimer.
     15      1.1  dillo  * 2. Redistributions in binary form must reproduce the above copyright
     16      1.1  dillo  *    notice, this list of conditions and the following disclaimer in the
     17      1.1  dillo  *    documentation and/or other materials provided with the distribution.
     18      1.1  dillo  *
     19      1.1  dillo  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20      1.1  dillo  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21      1.1  dillo  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22      1.1  dillo  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23      1.1  dillo  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24      1.1  dillo  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25      1.1  dillo  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26      1.1  dillo  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27      1.1  dillo  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28      1.1  dillo  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29      1.1  dillo  * POSSIBILITY OF SUCH DAMAGE.
     30      1.1  dillo  */
     31      1.1  dillo 
     32      1.1  dillo #include <sys/cdefs.h>
     33  1.8.8.1   yamt __KERNEL_RCSID(0, "$NetBSD: hfs_subr.c,v 1.8.8.1 2008/05/18 12:34:59 yamt Exp $");
     34      1.1  dillo 
     35      1.1  dillo #include <sys/param.h>
     36      1.1  dillo #include <sys/systm.h>
     37      1.1  dillo #include <sys/time.h>
     38      1.1  dillo #include <sys/kernel.h>
     39      1.1  dillo #include <sys/proc.h>
     40      1.1  dillo #include <sys/vnode.h>
     41      1.1  dillo #include <sys/malloc.h>
     42      1.1  dillo #include <sys/stat.h>
     43      1.1  dillo #include <sys/file.h>
     44      1.1  dillo #include <sys/filedesc.h>
     45      1.1  dillo #include <sys/mount.h>
     46      1.1  dillo #include <sys/disklabel.h>
     47      1.1  dillo #include <sys/conf.h>
     48      1.1  dillo #include <sys/kauth.h>
     49      1.1  dillo 
     50      1.2  dillo #include <fs/hfs/hfs.h>
     51      1.1  dillo 
     52      1.8     ad #include <miscfs/specfs/specdev.h>
     53      1.8     ad 
     54      1.1  dillo /*
     55      1.2  dillo  * Initialize the vnode associated with a new hfsnode.
     56      1.1  dillo  */
     57      1.1  dillo void
     58      1.2  dillo hfs_vinit(struct mount *mp, int (**specops)(void *), int (**fifoops)(void *),
     59      1.1  dillo 	   struct vnode **vpp)
     60      1.1  dillo {
     61      1.2  dillo 	struct hfsnode	*hp;
     62      1.1  dillo 	struct vnode	*vp;
     63      1.1  dillo 
     64      1.1  dillo 	vp = *vpp;
     65      1.1  dillo 	hp = VTOH(vp);
     66      1.1  dillo 
     67      1.2  dillo 	vp->v_type = hfs_catalog_keyed_record_vtype(
     68      1.2  dillo 		(hfs_catalog_keyed_record_t *)&hp->h_rec);
     69      1.1  dillo 
     70      1.1  dillo 	switch(vp->v_type) {
     71      1.1  dillo 		case VCHR:
     72      1.1  dillo 		case VBLK:
     73      1.1  dillo 			vp->v_op = specops;
     74      1.8     ad 			spec_node_init(vp,
     75      1.8     ad 			    HFS_CONVERT_RDEV(hp->h_rec.file.bsd.special.raw_device));
     76      1.1  dillo 			break;
     77      1.1  dillo 		case VFIFO:
     78      1.1  dillo 			vp->v_op = fifoops;
     79      1.1  dillo 			break;
     80      1.1  dillo 
     81      1.1  dillo 		case VNON:
     82      1.1  dillo 		case VBAD:
     83      1.1  dillo 		case VSOCK:
     84      1.1  dillo 		case VDIR:
     85      1.1  dillo 		case VREG:
     86      1.1  dillo 		case VLNK:
     87      1.1  dillo 			break;
     88      1.1  dillo 	}
     89      1.1  dillo 
     90      1.2  dillo 	if (hp->h_rec.cnid == HFS_CNID_ROOT_FOLDER)
     91      1.5     ad 		vp->v_vflag |= VV_ROOT;
     92      1.1  dillo 
     93      1.1  dillo 	*vpp = vp;
     94      1.1  dillo }
     95      1.1  dillo 
     96      1.1  dillo /*
     97      1.2  dillo  * Callbacks for libhfs
     98      1.1  dillo  */
     99      1.1  dillo 
    100      1.1  dillo void
    101      1.2  dillo hfs_libcb_error(
    102      1.1  dillo 	const char* format,
    103      1.1  dillo 	const char* file,
    104      1.1  dillo 	int line,
    105      1.1  dillo 	va_list args)
    106      1.1  dillo {
    107      1.2  dillo #ifdef HFS_DEBUG
    108      1.1  dillo 	if (file != NULL)
    109      1.1  dillo 		printf("%s:%i: ", file, line);
    110      1.1  dillo 	else
    111      1.2  dillo 		printf("hfs: ");
    112      1.1  dillo #else
    113      1.2  dillo 	printf("hfs: ");
    114      1.1  dillo #endif
    115      1.1  dillo 
    116      1.1  dillo 	/* XXX Should we really display this if debugging is off? */
    117      1.1  dillo 	vprintf(format, args);
    118      1.1  dillo 	printf("\n");
    119      1.1  dillo }
    120      1.1  dillo 
    121      1.1  dillo /* XXX change malloc/realloc/free to use pools */
    122      1.1  dillo 
    123      1.1  dillo void*
    124      1.2  dillo hfs_libcb_malloc(size_t size, hfs_callback_args* cbargs)
    125      1.1  dillo {
    126      1.2  dillo 	return malloc(size, /*M_HFSMNT*/ M_TEMP, M_WAITOK);
    127      1.1  dillo }
    128      1.1  dillo 
    129      1.1  dillo void*
    130      1.2  dillo hfs_libcb_realloc(void* ptr, size_t size, hfs_callback_args* cbargs)
    131      1.1  dillo {
    132      1.2  dillo 	return realloc(ptr, size, /*M_HFSMNT*/ M_TEMP, M_WAITOK);
    133      1.1  dillo }
    134      1.1  dillo 
    135      1.1  dillo void
    136      1.2  dillo hfs_libcb_free(void* ptr, hfs_callback_args* cbargs)
    137      1.1  dillo {
    138      1.2  dillo 	free(ptr, /*M_HFSMNT*/ M_TEMP);
    139      1.1  dillo }
    140      1.1  dillo 
    141      1.1  dillo /*
    142      1.2  dillo  * hfs_libcb_opendev()
    143      1.1  dillo  *
    144      1.2  dillo  * hfslib uses this callback to open a volume's device node by name. However,
    145      1.1  dillo  * by the time this is called here, the device node has already been opened by
    146      1.1  dillo  * VFS. So we are passed the vnode to this volume's block device and use that
    147      1.1  dillo  * instead of the device's name.
    148      1.1  dillo  */
    149      1.1  dillo int
    150      1.2  dillo hfs_libcb_opendev(
    151      1.2  dillo 	hfs_volume* vol,
    152      1.1  dillo 	const char* devname,
    153      1.2  dillo 	hfs_callback_args* cbargs)
    154      1.1  dillo {
    155      1.2  dillo 	hfs_libcb_data* cbdata = NULL;
    156      1.2  dillo 	hfs_libcb_argsopen* args;
    157      1.1  dillo 	struct partinfo dpart;
    158      1.1  dillo 	int result;
    159      1.1  dillo 
    160      1.1  dillo 	result = 0;
    161      1.2  dillo 	args = (hfs_libcb_argsopen*)(cbargs->openvol);
    162      1.1  dillo 
    163      1.1  dillo 	if (vol == NULL || devname == NULL) {
    164      1.1  dillo 		result = EINVAL;
    165      1.1  dillo 		goto error;
    166      1.1  dillo 	}
    167      1.1  dillo 
    168      1.2  dillo 	cbdata = malloc(sizeof(hfs_libcb_data), M_HFSMNT, M_WAITOK);
    169      1.1  dillo 	if (cbdata == NULL) {
    170      1.1  dillo 		result = ENOMEM;
    171      1.1  dillo 		goto error;
    172      1.1  dillo 	}
    173      1.1  dillo 	vol->cbdata = cbdata;
    174      1.1  dillo 
    175      1.1  dillo 	cbdata->devvp = NULL;
    176      1.1  dillo 
    177      1.1  dillo 	/* Open the device node. */
    178      1.1  dillo 	if ((result = VOP_OPEN(args->devvp, vol->readonly? FREAD : FREAD|FWRITE,
    179      1.6  pooka 		FSCRED)) != 0)
    180      1.1  dillo 		goto error;
    181      1.1  dillo 
    182      1.1  dillo 	/* Flush out any old buffers remaining from a previous use. */
    183      1.1  dillo 	vn_lock(args->devvp, LK_EXCLUSIVE | LK_RETRY);
    184      1.1  dillo 	result = vinvalbuf(args->devvp, V_SAVE, args->cred, args->l, 0, 0);
    185      1.1  dillo 	VOP_UNLOCK(args->devvp, 0);
    186      1.1  dillo 	if (result != 0)
    187      1.1  dillo 		goto error;
    188      1.1  dillo 
    189      1.1  dillo 	cbdata->devvp = args->devvp;
    190      1.1  dillo 
    191      1.1  dillo 	/* Determine the device's block size. Default to DEV_BSIZE if unavailable.*/
    192      1.6  pooka 	if (VOP_IOCTL(args->devvp, DIOCGPART, &dpart, FREAD, args->cred)
    193      1.1  dillo 		!= 0)
    194      1.1  dillo 		cbdata->devblksz = DEV_BSIZE;
    195      1.1  dillo 	else
    196      1.1  dillo 		cbdata->devblksz = dpart.disklab->d_secsize;
    197      1.1  dillo 
    198      1.1  dillo 	return 0;
    199      1.1  dillo 
    200      1.1  dillo error:
    201      1.1  dillo 	if (cbdata != NULL) {
    202      1.1  dillo 		if (cbdata->devvp != NULL) {
    203      1.1  dillo 			vn_lock(cbdata->devvp, LK_EXCLUSIVE | LK_RETRY);
    204      1.1  dillo 			(void)VOP_CLOSE(cbdata->devvp, vol->readonly ? FREAD :
    205      1.6  pooka 				FREAD | FWRITE, NOCRED);
    206      1.1  dillo 			VOP_UNLOCK(cbdata->devvp, 0);
    207      1.1  dillo 		}
    208      1.2  dillo 		free(cbdata, M_HFSMNT);
    209      1.1  dillo 		vol->cbdata = NULL;
    210      1.1  dillo 	}
    211      1.1  dillo 
    212      1.1  dillo 	return result;
    213      1.1  dillo }
    214      1.1  dillo 
    215      1.1  dillo void
    216      1.2  dillo hfs_libcb_closedev(hfs_volume* in_vol, hfs_callback_args* cbargs)
    217      1.1  dillo {
    218      1.1  dillo 	struct vnode *devvp;
    219      1.1  dillo 
    220      1.1  dillo 	if (in_vol == NULL)
    221      1.1  dillo 		return;
    222      1.1  dillo 
    223      1.1  dillo 	if (in_vol->cbdata != NULL) {
    224      1.2  dillo 		devvp = ((hfs_libcb_data*)in_vol->cbdata)->devvp;
    225      1.1  dillo 		if (devvp != NULL) {
    226      1.1  dillo 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    227      1.6  pooka 			(void)VOP_CLOSE(devvp,
    228      1.6  pooka 			    in_vol->readonly ? FREAD : FREAD | FWRITE, NOCRED);
    229      1.1  dillo 			/* XXX do we need a VOP_UNLOCK() here? */
    230      1.1  dillo 		}
    231      1.1  dillo 
    232      1.2  dillo 		free(in_vol->cbdata, M_HFSMNT);
    233      1.1  dillo 		in_vol->cbdata = NULL;
    234      1.1  dillo 	}
    235      1.1  dillo }
    236      1.1  dillo 
    237      1.1  dillo int
    238      1.2  dillo hfs_libcb_read(
    239      1.2  dillo 	hfs_volume* vol,
    240      1.1  dillo 	void* outbytes,
    241      1.1  dillo 	uint64_t length,
    242      1.1  dillo 	uint64_t offset,
    243      1.2  dillo 	hfs_callback_args* cbargs)
    244      1.1  dillo {
    245      1.2  dillo 	hfs_libcb_data *cbdata;
    246      1.2  dillo 	hfs_libcb_argsread* argsread;
    247      1.1  dillo 	kauth_cred_t cred;
    248      1.1  dillo 	uint64_t physoffset; /* physical offset from start of device(?) */
    249      1.1  dillo 
    250      1.1  dillo 	if (vol == NULL || outbytes == NULL)
    251      1.1  dillo 		return -1;
    252      1.1  dillo 
    253      1.2  dillo 	cbdata = (hfs_libcb_data*)vol->cbdata;
    254      1.1  dillo 
    255      1.1  dillo 	if (cbargs != NULL
    256      1.2  dillo 		&& (argsread = (hfs_libcb_argsread*)cbargs->read) != NULL
    257      1.1  dillo 		&& argsread->cred != NULL)
    258      1.1  dillo 		cred = argsread->cred;
    259      1.1  dillo 	else
    260      1.1  dillo 		cred = NOCRED;
    261      1.1  dillo 
    262      1.1  dillo 	/*
    263      1.1  dillo 	 * Since bread() only reads data in terms of integral blocks, it may have
    264      1.1  dillo 	 * read some data before and/or after our desired offset & length. So when
    265      1.1  dillo 	 * copying that data into the outgoing buffer, start at the actual desired
    266      1.1  dillo 	 * offset and only copy the desired length.
    267      1.1  dillo 	 */
    268      1.3  dillo 	physoffset = offset + vol->offset;
    269      1.1  dillo 
    270      1.2  dillo 	return hfs_pread(cbdata->devvp, outbytes, cbdata->devblksz, physoffset,
    271      1.1  dillo 			length, cred);
    272      1.1  dillo }
    273      1.1  dillo 
    274      1.1  dillo /*
    275      1.1  dillo  * So it turns out that bread() is pretty shoddy. It not only requires the size
    276      1.1  dillo  * parameter to be an integral multiple of the device's block size, but also
    277      1.1  dillo  * requires the block number to be on a boundary of that same block size -- and
    278      1.1  dillo  * yet be given as an integral multiple of DEV_BSIZE! So after much toil and
    279      1.2  dillo  * bloodshed, hfs_pread() was written as a convenience (and a model of how sane
    280      1.1  dillo  * people take their bread()). Returns 0 on success.
    281      1.1  dillo  */
    282      1.1  dillo int
    283      1.2  dillo hfs_pread(struct vnode *vp, void *buf, size_t secsz, uint64_t off,
    284      1.1  dillo 	uint64_t len, kauth_cred_t cred)
    285      1.1  dillo {
    286      1.1  dillo 	struct buf *bp;
    287      1.1  dillo 	uint64_t curoff; /* relative to 'start' variable */
    288      1.1  dillo 	uint64_t start;
    289      1.1  dillo 	int error;
    290      1.1  dillo 
    291      1.1  dillo 	if (vp == NULL || buf == NULL)
    292      1.1  dillo 		return EINVAL;
    293      1.1  dillo 
    294      1.1  dillo 	if (len == 0)
    295      1.1  dillo 		return 0;
    296      1.1  dillo 
    297      1.1  dillo 	curoff = 0;
    298      1.1  dillo 	error = 0;
    299      1.1  dillo 
    300      1.1  dillo /* align offset to highest preceding sector boundary */
    301      1.1  dillo #define ABSZ(x, bsz) (((x)/(bsz))*(bsz))
    302      1.1  dillo 
    303      1.1  dillo /* round size up to integral # of block sizes */
    304      1.1  dillo #define RBSZ(x, bsz) (((x) + (bsz) - 1) & ~((bsz) - 1))
    305      1.1  dillo 
    306      1.1  dillo 	start = ABSZ(off, secsz);
    307      1.1  dillo 	while (start + curoff < off + len)
    308      1.1  dillo 	{
    309      1.1  dillo 		bp = NULL;
    310      1.1  dillo 
    311      1.1  dillo 		/* XXX  Does the algorithm always do what's intended here when
    312      1.1  dillo 		 * XXX  start != off? Need to test this. */
    313      1.1  dillo 
    314      1.1  dillo 		error = bread(vp, (start + curoff) / DEV_BSIZE,/* no rounding involved*/
    315  1.8.8.1   yamt 		   RBSZ(min(len - curoff + (off - start), MAXBSIZE), secsz),
    316  1.8.8.1   yamt 		   cred, 0, &bp);
    317      1.1  dillo 
    318      1.1  dillo 		if (error == 0)
    319      1.1  dillo 			memcpy((uint8_t*)buf + curoff, (uint8_t*)bp->b_data +
    320      1.1  dillo 				(off - start), min(len - curoff, MAXBSIZE - (off - start)));
    321      1.1  dillo 
    322      1.1  dillo 		if (bp != NULL)
    323      1.4     ad 			brelse(bp, 0);
    324      1.1  dillo 		if (error != 0)
    325      1.1  dillo 			return error;
    326      1.1  dillo 
    327      1.1  dillo 		curoff += MAXBSIZE;
    328      1.1  dillo 	}
    329      1.1  dillo #undef ABSZ
    330      1.1  dillo #undef RBSZ
    331      1.1  dillo 
    332      1.1  dillo 	return 0;
    333      1.1  dillo }
    334      1.1  dillo 
    335      1.1  dillo /* XXX Provide a routine to take a catalog record and return its proper BSD file
    336      1.1  dillo  * XXX or directory mode value */
    337      1.1  dillo 
    338      1.1  dillo 
    339      1.1  dillo /* Convert from HFS+ time representation to UNIX time since epoch. */
    340      1.1  dillo void
    341      1.2  dillo hfs_time_to_timespec(uint32_t hfstime, struct timespec *unixtime)
    342      1.1  dillo {
    343      1.1  dillo 	/*
    344      1.1  dillo 	 * HFS+ time is calculated in seconds since midnight, Jan 1st, 1904.
    345      1.1  dillo 	 * struct timespec counts from midnight, Jan 1st, 1970. Thus, there is
    346      1.1  dillo 	 * precisely a 66 year difference between them, which is equal to
    347      1.1  dillo 	 * 2,082,844,800 seconds. No, I didn't count them by hand.
    348      1.1  dillo 	 */
    349      1.1  dillo 
    350      1.1  dillo 	if (hfstime < 2082844800)
    351      1.1  dillo 		unixtime->tv_sec = 0; /* dates before 1970 are bs anyway, so use epoch*/
    352      1.1  dillo 	else
    353      1.1  dillo 		unixtime->tv_sec = hfstime - 2082844800;
    354      1.1  dillo 
    355      1.1  dillo 	unixtime->tv_nsec = 0; /* we don't have nanosecond resolution */
    356      1.1  dillo }
    357      1.1  dillo 
    358      1.1  dillo /*
    359      1.1  dillo  * Endian conversion with automatic pointer incrementation.
    360      1.1  dillo  */
    361      1.1  dillo 
    362      1.1  dillo uint16_t be16tohp(void** inout_ptr)
    363      1.1  dillo {
    364      1.1  dillo 	uint16_t	result;
    365      1.1  dillo 	uint16_t *ptr;
    366      1.1  dillo 
    367      1.1  dillo 	if(inout_ptr==NULL)
    368      1.1  dillo 		return 0;
    369      1.1  dillo 
    370      1.1  dillo 	ptr = *inout_ptr;
    371      1.1  dillo 
    372      1.1  dillo 	result = be16toh(*ptr);
    373      1.1  dillo 
    374      1.1  dillo 	ptr++;
    375      1.1  dillo 	*inout_ptr = ptr;
    376      1.1  dillo 
    377      1.1  dillo 	return result;
    378      1.1  dillo }
    379      1.1  dillo 
    380      1.1  dillo uint32_t be32tohp(void** inout_ptr)
    381      1.1  dillo {
    382      1.1  dillo 	uint32_t	result;
    383      1.1  dillo 	uint32_t *ptr;
    384      1.1  dillo 
    385      1.1  dillo 	if(inout_ptr==NULL)
    386      1.1  dillo 		return 0;
    387      1.1  dillo 
    388      1.1  dillo 	ptr = *inout_ptr;
    389      1.1  dillo 
    390      1.1  dillo 	result = be32toh(*ptr);
    391      1.1  dillo 
    392      1.1  dillo 	ptr++;
    393      1.1  dillo 	*inout_ptr = ptr;
    394      1.1  dillo 
    395      1.1  dillo 	return result;
    396      1.1  dillo }
    397      1.1  dillo 
    398      1.1  dillo uint64_t be64tohp(void** inout_ptr)
    399      1.1  dillo {
    400      1.1  dillo 	uint64_t	result;
    401      1.1  dillo 	uint64_t *ptr;
    402      1.1  dillo 
    403      1.1  dillo 	if(inout_ptr==NULL)
    404      1.1  dillo 		return 0;
    405      1.1  dillo 
    406      1.1  dillo 	ptr = *inout_ptr;
    407      1.1  dillo 
    408      1.1  dillo 	result = be64toh(*ptr);
    409      1.1  dillo 
    410      1.1  dillo 	ptr++;
    411      1.1  dillo 	*inout_ptr = ptr;
    412      1.1  dillo 
    413      1.1  dillo 	return result;
    414      1.1  dillo }
    415      1.1  dillo 
    416      1.1  dillo enum vtype
    417      1.2  dillo hfs_catalog_keyed_record_vtype(const hfs_catalog_keyed_record_t *rec)
    418      1.1  dillo {
    419      1.2  dillo     	if (rec->type == HFS_REC_FILE) {
    420      1.1  dillo 		uint32_t mode;
    421      1.1  dillo 
    422      1.2  dillo 		mode = ((const hfs_file_record_t *)rec)->bsd.file_mode;
    423      1.1  dillo 		if (mode != 0)
    424      1.1  dillo 			return IFTOVT(mode);
    425      1.1  dillo 		else
    426      1.1  dillo 			return VREG;
    427      1.1  dillo 	}
    428      1.1  dillo 	else
    429      1.1  dillo 		return VDIR;
    430      1.1  dillo }
    431