NetBSD-5.0.2/sys/fs/udf/udf_readwrite.c
/* $NetBSD: udf_readwrite.c,v 1.8.4.1 2009/02/18 00:51:27 snj Exp $ */
/*
* Copyright (c) 2007, 2008 Reinoud Zandijk
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <sys/cdefs.h>
#ifndef lint
__KERNEL_RCSID(0, "$NetBSD: udf_readwrite.c,v 1.8.4.1 2009/02/18 00:51:27 snj Exp $");
#endif /* not lint */
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
#include "opt_compat_netbsd.h"
#endif
#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/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 "udf.h"
#include "udf_subr.h"
#include "udf_bswap.h"
#define VTOI(vnode) ((struct udf_node *) vnode->v_data)
/* --------------------------------------------------------------------- */
void
udf_fixup_fid_block(uint8_t *blob, int lb_size,
int rfix_pos, int max_rfix_pos, uint32_t lb_num)
{
struct fileid_desc *fid;
uint8_t *fid_pos;
int fid_len, found;
/* needs to be word aligned */
KASSERT(rfix_pos % 4 == 0);
/* first resync with the FID stream !!! */
found = 0;
while (rfix_pos + sizeof(struct desc_tag) <= max_rfix_pos) {
fid_pos = blob + rfix_pos;
fid = (struct fileid_desc *) fid_pos;
if (udf_rw16(fid->tag.id) == TAGID_FID) {
if (udf_check_tag((union dscrptr *) fid) == 0)
found = 1;
}
if (found)
break;
/* try next location; can only be 4 bytes aligned */
rfix_pos += 4;
}
/* walk over the fids */
fid_pos = blob + rfix_pos;
while (rfix_pos + sizeof(struct desc_tag) <= max_rfix_pos) {
fid = (struct fileid_desc *) fid_pos;
if (udf_rw16(fid->tag.id) != TAGID_FID) {
/* end of FID stream; end of directory or currupted */
break;
}
/* update sector number and recalculate checkum */
fid->tag.tag_loc = udf_rw32(lb_num);
udf_validate_tag_sum((union dscrptr *) fid);
/* if the FID crosses the memory, we're done! */
if (rfix_pos + UDF_FID_SIZE >= max_rfix_pos)
break;
fid_len = udf_fidsize(fid);
fid_pos += fid_len;
rfix_pos += fid_len;
}
}
void
udf_fixup_internal_extattr(uint8_t *blob, uint32_t lb_num)
{
struct desc_tag *tag;
struct file_entry *fe;
struct extfile_entry *efe;
struct extattrhdr_desc *eahdr;
int l_ea;
/* get information from fe/efe */
tag = (struct desc_tag *) blob;
switch (udf_rw16(tag->id)) {
case TAGID_FENTRY :
fe = (struct file_entry *) blob;
l_ea = udf_rw32(fe->l_ea);
eahdr = (struct extattrhdr_desc *) fe->data;
break;
case TAGID_EXTFENTRY :
efe = (struct extfile_entry *) blob;
l_ea = udf_rw32(efe->l_ea);
eahdr = (struct extattrhdr_desc *) efe->data;
break;
case TAGID_INDIRECTENTRY :
case TAGID_ALLOCEXTENT :
case TAGID_EXTATTR_HDR :
return;
default:
panic("%s: passed bad tag\n", __func__);
}
/* something recorded here? (why am i called?) */
if (l_ea == 0)
return;
#if 0
/* check extended attribute tag */
/* TODO XXX what to do when we encounter an error here? */
error = udf_check_tag(eahdr);
if (error)
return; /* for now */
if (udf_rw16(eahdr->tag.id) != TAGID_EXTATTR_HDR)
return; /* for now */
error = udf_check_tag_payload(eahdr, sizeof(struct extattrhdr_desc));
if (error)
return; /* for now */
#endif
DPRINTF(EXTATTR, ("node fixup: found %d bytes of extended attributes\n",
l_ea));
/* fixup eahdr tag */
eahdr->tag.tag_loc = udf_rw32(lb_num);
udf_validate_tag_and_crc_sums((union dscrptr *) eahdr);
}
void
udf_fixup_node_internals(struct udf_mount *ump, uint8_t *blob, int udf_c_type)
{
struct desc_tag *tag, *sbm_tag;
struct file_entry *fe;
struct extfile_entry *efe;
struct alloc_ext_entry *ext;
uint32_t lb_size, lb_num;
uint32_t intern_pos, max_intern_pos;
int icbflags, addr_type, file_type, intern, has_fids, has_sbm, l_ea;
lb_size = udf_rw32(ump->logical_vol->lb_size);
/* if its not a node we're done */
if (udf_c_type != UDF_C_NODE)
return;
/* NOTE this could also be done in write_internal */
/* start of a descriptor */
l_ea = 0;
has_fids = 0;
has_sbm = 0;
intern = 0;
file_type = 0;
max_intern_pos = intern_pos = lb_num = 0; /* shut up gcc! */
tag = (struct desc_tag *) blob;
switch (udf_rw16(tag->id)) {
case TAGID_FENTRY :
fe = (struct file_entry *) tag;
l_ea = udf_rw32(fe->l_ea);
icbflags = udf_rw16(fe->icbtag.flags);
addr_type = (icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK);
file_type = fe->icbtag.file_type;
intern = (addr_type == UDF_ICB_INTERN_ALLOC);
intern_pos = UDF_FENTRY_SIZE + l_ea;
max_intern_pos = intern_pos + udf_rw64(fe->inf_len);
lb_num = udf_rw32(fe->tag.tag_loc);
break;
case TAGID_EXTFENTRY :
efe = (struct extfile_entry *) tag;
l_ea = udf_rw32(efe->l_ea);
icbflags = udf_rw16(efe->icbtag.flags);
addr_type = (icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK);
file_type = efe->icbtag.file_type;
intern = (addr_type == UDF_ICB_INTERN_ALLOC);
intern_pos = UDF_EXTFENTRY_SIZE + l_ea;
max_intern_pos = intern_pos + udf_rw64(efe->inf_len);
lb_num = udf_rw32(efe->tag.tag_loc);
break;
case TAGID_INDIRECTENTRY :
case TAGID_EXTATTR_HDR :
break;
case TAGID_ALLOCEXTENT :
/* force crclen to 8 for UDF version < 2.01 */
ext = (struct alloc_ext_entry *) tag;
if (udf_rw16(ump->logvol_info->min_udf_readver) <= 0x200)
ext->tag.desc_crc_len = udf_rw16(8);
break;
default:
panic("%s: passed bad tag\n", __func__);
break;
}
/* determine what to fix if its internally recorded */
if (intern) {
has_fids = (file_type == UDF_ICB_FILETYPE_DIRECTORY) ||
(file_type == UDF_ICB_FILETYPE_STREAMDIR);
has_sbm = (file_type == UDF_ICB_FILETYPE_META_BITMAP);
}
/* fixup internal extended attributes if present */
if (l_ea)
udf_fixup_internal_extattr(blob, lb_num);
/* fixup fids lb numbers */
if (has_fids)
udf_fixup_fid_block(blob, lb_size, intern_pos,
max_intern_pos, lb_num);
/* fixup space bitmap descriptor */
if (has_sbm) {
sbm_tag = (struct desc_tag *) (blob + intern_pos);
sbm_tag->tag_loc = tag->tag_loc;
udf_validate_tag_and_crc_sums((uint8_t *) sbm_tag);
}
udf_validate_tag_and_crc_sums(blob);
}
/* --------------------------------------------------------------------- */
/*
* Set of generic descriptor readers and writers and their helper functions.
* Descriptors inside `logical space' i.e. inside logically mapped partitions
* can never be longer than one logical sector.
*
* NOTE that these functions *can* be used by the sheduler backends to read
* node descriptors too.
*
* For reading, the size of allocated piece is returned in multiple of sector
* size due to udf_calc_udf_malloc_size().
*/
/* SYNC reading of n blocks from specified sector */
int
udf_read_phys_sectors(struct udf_mount *ump, int what, void *blob,
uint32_t start, uint32_t sectors)
{
struct buf *buf, *nestbuf;
uint32_t buf_offset;
off_t lblkno, rblkno;
int sector_size = ump->discinfo.sector_size;
int blks = sector_size / DEV_BSIZE;
int piece;
int error;
DPRINTF(READ, ("udf_intbreadn() : sectors = %d, sector_size = %d\n",
sectors, sector_size));
buf = getiobuf(ump->devvp, true);
buf->b_flags = B_READ;
buf->b_cflags = BC_BUSY; /* needed? */
buf->b_iodone = NULL;
buf->b_data = blob;
buf->b_bcount = sectors * sector_size;
buf->b_resid = buf->b_bcount;
buf->b_bufsize = buf->b_bcount;
buf->b_private = NULL; /* not needed yet */
BIO_SETPRIO(buf, BPRIO_DEFAULT);
buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks;
buf->b_proc = NULL;
error = 0;
buf_offset = 0;
rblkno = start;
lblkno = 0;
while ((sectors > 0) && (error == 0)) {
piece = MIN(MAXPHYS/sector_size, sectors);
DPRINTF(READ, ("read in %d + %d\n", (uint32_t) rblkno, piece));
nestbuf = getiobuf(NULL, true);
nestiobuf_setup(buf, nestbuf, buf_offset, piece * sector_size);
/* nestbuf is B_ASYNC */
/* identify this nestbuf */
nestbuf->b_lblkno = lblkno;
/* CD shedules on raw blkno */
nestbuf->b_blkno = rblkno * blks;
nestbuf->b_proc = NULL;
nestbuf->b_rawblkno = rblkno * blks;
nestbuf->b_udf_c_type = what;
udf_discstrat_queuebuf(ump, nestbuf);
lblkno += piece;
rblkno += piece;
buf_offset += piece * sector_size;
sectors -= piece;
}
error = biowait(buf);
putiobuf(buf);
return error;
}
/* synchronous generic descriptor read */
int
udf_read_phys_dscr(struct udf_mount *ump, uint32_t sector,
struct malloc_type *mtype, union dscrptr **dstp)
{
union dscrptr *dst, *new_dst;
uint8_t *pos;
int sectors, dscrlen;
int i, error, sector_size;
sector_size = ump->discinfo.sector_size;
*dstp = dst = NULL;
dscrlen = sector_size;
/* read initial piece */
dst = malloc(sector_size, mtype, M_WAITOK);
error = udf_read_phys_sectors(ump, UDF_C_DSCR, dst, sector, 1);
DPRINTFIF(DESCRIPTOR, error, ("read error (%d)\n", error));
if (!error) {
/* check if its a valid tag */
error = udf_check_tag(dst);
if (error) {
/* check if its an empty block */
pos = (uint8_t *) dst;
for (i = 0; i < sector_size; i++, pos++) {
if (*pos) break;
}
if (i == sector_size) {
/* return no error but with no dscrptr */
/* dispose first block */
free(dst, mtype);
return 0;
}
}
/* calculate descriptor size */
dscrlen = udf_tagsize(dst, sector_size);
}
DPRINTFIF(DESCRIPTOR, error, ("bad tag checksum\n"));
if (!error && (dscrlen > sector_size)) {
DPRINTF(DESCRIPTOR, ("multi block descriptor read\n"));
/*
* Read the rest of descriptor. Since it is only used at mount
* time its overdone to define and use a specific udf_intbreadn
* for this alone.
*/
new_dst = realloc(dst, dscrlen, mtype, M_WAITOK);
if (new_dst == NULL) {
free(dst, mtype);
return ENOMEM;
}
dst = new_dst;
sectors = (dscrlen + sector_size -1) / sector_size;
DPRINTF(DESCRIPTOR, ("dscrlen = %d (%d blk)\n", dscrlen, sectors));
pos = (uint8_t *) dst + sector_size;
error = udf_read_phys_sectors(ump, UDF_C_DSCR, pos,
sector + 1, sectors-1);
DPRINTFIF(DESCRIPTOR, error, ("read error on multi (%d)\n",
error));
}
if (!error) {
error = udf_check_tag_payload(dst, dscrlen);
DPRINTFIF(DESCRIPTOR, error, ("bad payload check sum\n"));
}
if (error && dst) {
free(dst, mtype);
dst = NULL;
}
*dstp = dst;
return error;
}
static void
udf_write_phys_buf(struct udf_mount *ump, int what, struct buf *buf)
{
struct buf *nestbuf;
uint32_t buf_offset;
off_t lblkno, rblkno;
int sector_size = ump->discinfo.sector_size;
int blks = sector_size / DEV_BSIZE;
uint32_t sectors;
int piece;
int error;
sectors = buf->b_bcount / sector_size;
DPRINTF(WRITE, ("udf_intbwriten() : sectors = %d, sector_size = %d\n",
sectors, sector_size));
/* don't forget to increase pending count for the bwrite itself */
/* panic("NO WRITING\n"); */
if (buf->b_vp) {
mutex_enter(&buf->b_vp->v_interlock);
buf->b_vp->v_numoutput++;
mutex_exit(&buf->b_vp->v_interlock);
}
error = 0;
buf_offset = 0;
rblkno = buf->b_blkno / blks;
lblkno = 0;
while ((sectors > 0) && (error == 0)) {
piece = MIN(MAXPHYS/sector_size, sectors);
DPRINTF(WRITE, ("write out %d + %d\n",
(uint32_t) rblkno, piece));
nestbuf = getiobuf(NULL, true);
nestiobuf_setup(buf, nestbuf, buf_offset, piece * sector_size);
/* nestbuf is B_ASYNC */
/* identify this nestbuf */
nestbuf->b_lblkno = lblkno;
/* CD shedules on raw blkno */
nestbuf->b_blkno = rblkno * blks;
nestbuf->b_proc = NULL;
nestbuf->b_rawblkno = rblkno * blks;
nestbuf->b_udf_c_type = what;
udf_discstrat_queuebuf(ump, nestbuf);
lblkno += piece;
rblkno += piece;
buf_offset += piece * sector_size;
sectors -= piece;
}
}
/* SYNC writing of n blocks from specified sector */
int
udf_write_phys_sectors(struct udf_mount *ump, int what, void *blob,
uint32_t start, uint32_t sectors)
{
struct vnode *vp;
struct buf *buf;
int sector_size = ump->discinfo.sector_size;
int blks = sector_size / DEV_BSIZE;
int error;
/* get transfer buffer */
vp = ump->devvp;
buf = getiobuf(vp, true);
buf->b_flags = B_WRITE;
buf->b_cflags = BC_BUSY; /* needed? */
buf->b_iodone = NULL;
buf->b_data = blob;
buf->b_bcount = sectors * sector_size;
buf->b_resid = buf->b_bcount;
buf->b_bufsize = buf->b_bcount;
buf->b_private = NULL; /* not needed yet */
BIO_SETPRIO(buf, BPRIO_DEFAULT);
buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks;
buf->b_proc = NULL;
/* do the write, wait and return error */
udf_write_phys_buf(ump, what, buf);
error = biowait(buf);
putiobuf(buf);
return error;
}
/* synchronous generic descriptor write */
int
udf_write_phys_dscr_sync(struct udf_mount *ump, struct udf_node *udf_node, int what,
union dscrptr *dscr, uint32_t sector, uint32_t logsector)
{
struct vnode *vp;
struct buf *buf;
int sector_size = ump->discinfo.sector_size;
int blks = sector_size / DEV_BSIZE;
int dscrlen;
int error;
/* set sector number in the descriptor and validate */
dscr->tag.tag_loc = udf_rw32(logsector);
udf_validate_tag_and_crc_sums(dscr);
/* calculate descriptor size */
dscrlen = udf_tagsize(dscr, sector_size);
/* get transfer buffer */
vp = udf_node ? udf_node->vnode : ump->devvp;
buf = getiobuf(vp, true);
buf->b_flags = B_WRITE;
buf->b_cflags = BC_BUSY; /* needed? */
buf->b_iodone = NULL;
buf->b_data = (void *) dscr;
buf->b_bcount = dscrlen;
buf->b_resid = buf->b_bcount;
buf->b_bufsize = buf->b_bcount;
buf->b_private = NULL; /* not needed yet */
BIO_SETPRIO(buf, BPRIO_DEFAULT);
buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = sector * blks;
buf->b_proc = NULL;
/* do the write, wait and return error */
udf_write_phys_buf(ump, what, buf);
error = biowait(buf);
putiobuf(buf);
return error;
}
/* asynchronous generic descriptor write */
int
udf_write_phys_dscr_async(struct udf_mount *ump, struct udf_node *udf_node,
int what, union dscrptr *dscr,
uint32_t sector, uint32_t logsector,
void (*dscrwr_callback)(struct buf *))
{
struct vnode *vp;
struct buf *buf;
int dscrlen;
int sector_size = ump->discinfo.sector_size;
int blks = sector_size / DEV_BSIZE;
KASSERT(dscrwr_callback);
DPRINTF(NODE, ("udf_write_phys_dscr_async() called\n"));
/* set sector number in the descriptor and validate */
dscr->tag.tag_loc = udf_rw32(logsector);
udf_validate_tag_and_crc_sums(dscr);
/* calculate descriptor size */
dscrlen = udf_tagsize(dscr, sector_size);
/* get transfer buffer */
vp = udf_node ? udf_node->vnode : ump->devvp;
buf = getiobuf(vp, true);
buf->b_flags = B_WRITE; // | B_ASYNC;
buf->b_cflags = BC_BUSY;
buf->b_iodone = dscrwr_callback;
buf->b_data = dscr;
buf->b_bcount = dscrlen;
buf->b_resid = buf->b_bcount;
buf->b_bufsize = buf->b_bcount;
buf->b_private = NULL; /* not needed yet */
BIO_SETPRIO(buf, BPRIO_DEFAULT);
buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = sector * blks;
buf->b_proc = NULL;
/* do the write and return no error */
udf_write_phys_buf(ump, what, buf);
return 0;
}
/* --------------------------------------------------------------------- */
/* disc strategy dispatchers */
int
udf_create_logvol_dscr(struct udf_mount *ump, struct udf_node *udf_node, struct long_ad *icb,
union dscrptr **dscrptr)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
int error;
KASSERT(strategy);
args.ump = ump;
args.udf_node = udf_node;
args.icb = icb;
args.dscr = NULL;
error = (strategy->create_logvol_dscr)(&args);
*dscrptr = args.dscr;
return error;
}
void
udf_free_logvol_dscr(struct udf_mount *ump, struct long_ad *icb,
void *dscr)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
KASSERT(strategy);
args.ump = ump;
args.icb = icb;
args.dscr = dscr;
(strategy->free_logvol_dscr)(&args);
}
int
udf_read_logvol_dscr(struct udf_mount *ump, struct long_ad *icb,
union dscrptr **dscrptr)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
int error;
KASSERT(strategy);
args.ump = ump;
args.icb = icb;
args.dscr = NULL;
error = (strategy->read_logvol_dscr)(&args);
*dscrptr = args.dscr;
return error;
}
int
udf_write_logvol_dscr(struct udf_node *udf_node, union dscrptr *dscr,
struct long_ad *icb, int waitfor)
{
struct udf_strategy *strategy = udf_node->ump->strategy;
struct udf_strat_args args;
int error;
KASSERT(strategy);
args.ump = udf_node->ump;
args.udf_node = udf_node;
args.icb = icb;
args.dscr = dscr;
args.waitfor = waitfor;
error = (strategy->write_logvol_dscr)(&args);
return error;
}
void
udf_discstrat_queuebuf(struct udf_mount *ump, struct buf *nestbuf)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
KASSERT(strategy);
args.ump = ump;
args.nestbuf = nestbuf;
(strategy->queuebuf)(&args);
}
void
udf_discstrat_init(struct udf_mount *ump)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
KASSERT(strategy);
args.ump = ump;
(strategy->discstrat_init)(&args);
}
void udf_discstrat_finish(struct udf_mount *ump)
{
struct udf_strategy *strategy = ump->strategy;
struct udf_strat_args args;
/* strategy might not have been set, so ignore if not set */
if (strategy) {
args.ump = ump;
(strategy->discstrat_finish)(&args);
}
}
/* --------------------------------------------------------------------- */