NetBSD/sys/lib/libsa/ustarfs.c

510 lines
12 KiB
C

/* $NetBSD: ustarfs.c,v 1.5 1998/10/30 16:56:30 matt Exp $ */
/* [Notice revision 2.2]
* Copyright (c) 1997, 1998 Avalon Computer Systems, Inc.
* All rights reserved.
*
* Author: Ross Harvey
*
* 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 and
* author 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.
* 3. Neither the name of Avalon Computer Systems, Inc. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* 4. This copyright will be assigned to The NetBSD Foundation on
* 1/1/2000 unless these terms (including possibly the assignment
* date) are updated in writing by Avalon prior to the latest specified
* assignment date.
*
* THIS SOFTWARE IS PROVIDED BY AVALON COMPUTER SYSTEMS, INC. AND CONTRIBUTORS
* ``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 AVALON OR THE CONTRIBUTORS
* 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.
*/
/*
******************************* USTAR FS *******************************
*/
/*
* Implement an ROFS with an 8K boot area followed by ustar-format data.
* The point: minimal FS overhead, and it's easy (well, `possible') to
* split files over multiple volumes.
*
* XXX - TODO LIST
* --- - ---- ----
* XXX - tag volume numbers and verify that the correct volume is
* inserted after volume swaps.
*
* XXX - stop hardwiring FS metadata for floppies...embed it in a file,
* file name, or something. (Remember __SYMDEF? :-)
*
*/
#ifdef _STANDALONE
#include <lib/libkern/libkern.h>
#else
#include <string.h>
#endif
#include "stand.h"
#include "ustarfs.h"
#define BBSIZE 8192
#define USTAR_NAME_BLOCK 512
/*
* Virtual offset: relative to start of ustar archive
* Logical offset: volume-relative
* Physical offset: the usual meaning
*/
/* virtual offset to volume number */
#define vda2vn(_v,_volsize) ((_v) / (_volsize))
/* conversions between the three different levels of disk addresses */
#define vda2lda(_v,_volsize) ((_v) % (_volsize))
#define lda2vda(_v,_volsize,_volnumber) ((_v) + (_volsize) * (_volnumber))
#define lda2pda(_lda) ((_lda) + ustarfs_mode_offset)
#define pda2lda(_pda) ((_pda) - ustarfs_mode_offset)
/*
* Change this to off_t if you want to support big volumes. If we only use
* ustarfs on floppies it can stay int for libsa code density.
*
* It needs to be signed.
*/
typedef int ustoffs;
typedef struct ustar_struct {
char ust_name[100],
ust_mode[8],
ust_uid[8],
ust_gid[8],
ust_size[12],
ust_misc[12 + 8 + 1 + 100],
ust_magic[6];
/* there is more, but we don't care */
} ustar_t;
/*
* We buffer one even cylindar of data...it's actually only really one
* cyl on a 1.44M floppy, but on other devices it's fast enough with any
* kind of block buffering, so we optimize for the slowest device.
*/
typedef struct ust_active_struct {
ustar_t uas_active;
char uas_1cyl[18 * 2 * 512];
ustoffs uas_volsize; /* XXX this is hardwired now */
ustoffs uas_windowbase; /* relative to volume 0 */
ustoffs uas_filestart; /* relative to volume 0 */
ustoffs uas_fseek; /* relative to file */
ustoffs uas_filesize; /* relative to volume 0 */
int uas_init_window; /* data present in window */
int uas_init_fs; /* ust FS actually found */
int uas_volzerosig; /* ID volume 0 by signature */
int uas_offset; /* amount of cylinder below lba 0 */
} ust_active_t;
static const char formatid[] = "USTARFS",
metaname[] = "USTAR.volsize.";
static int ustarfs_mode_offset = BBSIZE;
static int checksig __P((ust_active_t *));
static int convert __P((const char *, int, int));
static int get_volume __P((struct open_file *, int));
static void setwindow(ust_active_t *, ustoffs, ustoffs);
static int ustarfs_cylinder_read __P((struct open_file *, ustoffs, int));
static void ustarfs_sscanf __P((const char *, const char *, int *));
static int read512block __P((struct open_file *, ustoffs, char block[512]));
static int
convert(f, base, fw)
const char *f;
int base, fw;
{
int i, c, result = 0;
while(fw > 0 && *f == ' ') {
--fw;
++f;
}
for(i = 0; i < fw; ++i) {
c = f[i];
if ('0' <= c && c < '0' + base) {
c -= '0';
result = result * base + c;
} else break;
}
return result;
}
static void
ustarfs_sscanf(s,f,xi)
const char *s,*f;
int *xi;
{
*xi = convert(s, 8, convert(f + 1, 10, 99));
}
static int
ustarfs_cylinder_read(f, seek2, forcelabel)
struct open_file *f;
ustoffs seek2;
{
int e = 0; /* XXX work around gcc warning */
ustoffs lda;
char *xferbase;
ust_active_t *ustf;
size_t xferrqst, xfercount;
ustf = f->f_fsdata;
xferrqst = sizeof ustf->uas_1cyl;
xferbase = ustf->uas_1cyl;
lda = pda2lda(seek2);
if (lda < 0) {
lda = -lda;
ustf->uas_offset = lda;
/*
* don't read the label unless we have to. (Preserve
* sequential block access so tape boot works.)
*/
if (!forcelabel) {
memset(xferbase, 0, lda);
xferrqst -= lda;
xferbase += lda;
seek2 += lda;
}
} else
ustf->uas_offset = 0;
while(xferrqst > 0) {
e = f->f_dev->dv_strategy(f->f_devdata, F_READ, seek2 / 512,
xferrqst, xferbase, &xfercount);
if (e)
break;
if (xfercount != xferrqst)
printf("Warning, unexpected short transfer %d/%d\n",
(int)xfercount, (int)xferrqst);
xferrqst -= xfercount;
xferbase += xfercount;
}
return e;
}
static int
checksig(ustf)
ust_active_t *ustf;
{
int i, rcs;
for(i = rcs = 0; i < sizeof ustf->uas_1cyl; ++i)
rcs += ustf->uas_1cyl[i];
return rcs;
}
static int
get_volume(f, vn)
struct open_file *f;
int vn;
{
int e, needvolume, havevolume;
ust_active_t *ustf;
ustf = f->f_fsdata;
havevolume = vda2vn(ustf->uas_windowbase, ustf->uas_volsize);
needvolume = vn;
while(havevolume != needvolume) {
printf("\nPlease ");
if (havevolume >= 0)
printf("remove disk %d, ", havevolume + 1);
printf("insert disk %d, and type return...",
needvolume + 1);
getchar();
printf("\n");
e = ustarfs_cylinder_read(f, 0, 1);
if (e)
return e;
if(strncmp(formatid, ustf->uas_1cyl, strlen(formatid))) {
/* no magic, might be OK if we want volume 0 */
if (ustf->uas_volzerosig == checksig(ustf)) {
havevolume = 0;
continue;
}
printf("Disk is not from the volume set?!\n");
havevolume = -2;
continue;
}
ustarfs_sscanf(ustf->uas_1cyl + strlen(formatid), "%9o",
&havevolume);
--havevolume;
}
return 0;
}
static void
setwindow(ust_active_t *ustf, ustoffs pda, ustoffs vda)
{
ustf->uas_windowbase = lda2vda(pda2lda(pda), ustf->uas_volsize,
vda2vn(vda, ustf->uas_volsize))
+ ustf->uas_offset;
ustf->uas_init_window = 1;
}
static int
read512block(f, vda, block)
struct open_file *f;
ustoffs vda;
char block[512];
{
ustoffs pda;
ssize_t e;
int dienow;
ust_active_t *ustf;
dienow = 0;
ustf = f->f_fsdata;
if (!ustf->uas_init_window
&& ustf->uas_windowbase == 0) {
/*
* The algorithm doesn't require this, but without it we would
* need some trick to get the cylinder zero signature computed.
* That signature is used to identify volume zero, which we
* don't give a USTARFS label to. (It's platform-dependent.)
*/
e = ustarfs_cylinder_read(f, 0, 0);
if (e)
return e;
ustf->uas_volzerosig = checksig(ustf);
setwindow(ustf, 0, 0);
}
/*
* if (vda in window)
* copy out and return data
* if (vda is on some other disk)
* do disk swap
* get physical disk address
* round down to cylinder boundary
* read cylindar
* set window (in vda space) and try again
* [ there is an implicit assumption that windowbase always identifies
* the current volume, even if initwindow == 0. This way, a
* windowbase of 0 causes the initial volume to be disk 0 ]
*/
tryagain:
if(ustf->uas_init_window
&& ustf->uas_windowbase <= vda && vda <
ustf->uas_windowbase + sizeof ustf->uas_1cyl - ustf->uas_offset) {
memcpy(block, ustf->uas_1cyl
+ (vda - ustf->uas_windowbase)
+ ustf->uas_offset, 512);
return 0;
}
if (dienow++)
panic("ustarfs read512block");
ustf->uas_init_window = 0;
e = get_volume(f, vda2vn(vda, ustf->uas_volsize));
if (e)
return e;
pda = lda2pda(vda2lda(vda, ustf->uas_volsize));
pda-= pda % sizeof ustf->uas_1cyl;
e = ustarfs_cylinder_read(f, pda, 0);
if (e)
return e;
setwindow(ustf, pda, vda);
goto tryagain;
}
int
ustarfs_open(path, f)
char *path;
struct open_file *f;
{
ust_active_t *ustf;
ustoffs offset;
char block[512];
int filesize;
int e, e2;
int newvolblocks;
if (*path == '/')
++path;
e = EINVAL;
f->f_fsdata = ustf = alloc(sizeof *ustf);
memset(ustf, 0, sizeof *ustf);
offset = 0;
/* default to 2880 sector floppy */
ustf->uas_volsize = 80 * 2 * 18 * 512 - lda2pda(0);
ustf->uas_fseek = 0;
for(;;) {
ustf->uas_filestart = offset;
e2 = read512block(f, offset, block);
if (e2) {
e = e2;
break;
}
memcpy(&ustf->uas_active, block, sizeof ustf->uas_active);
if(strncmp(ustf->uas_active.ust_magic, "ustar", 5))
break;
e = ENOENT; /* it must be an actual ustarfs */
ustf->uas_init_fs = 1;
/* if volume metadata is found, use it */
if(strncmp(ustf->uas_active.ust_name, metaname,
strlen(metaname)) == 0) {
ustarfs_sscanf(ustf->uas_active.ust_name
+ strlen(metaname), "%99o", &newvolblocks);
ustf->uas_volsize = newvolblocks * 512
- lda2pda(0);
}
ustarfs_sscanf(ustf->uas_active.ust_size,"%12o",&filesize);
if(strncmp(ustf->uas_active.ust_name, path,
sizeof ustf->uas_active.ust_name) == 0) {
ustf->uas_filesize = filesize;
e = 0;
break;
}
offset += USTAR_NAME_BLOCK + filesize;
filesize %= 512;
if (filesize)
offset += 512 - filesize;
}
if (e) {
free(ustf, sizeof *ustf);
f->f_fsdata = 0;
}
return e;
}
int
ustarfs_write(f, start, size, resid)
struct open_file *f;
void *start;
size_t size;
size_t *resid;
{
return (EROFS);
}
off_t
ustarfs_seek(f, offs, whence)
struct open_file *f;
off_t offs;
int whence;
{
ust_active_t *ustf;
ustf = f->f_fsdata;
switch (whence) {
case SEEK_SET:
ustf->uas_fseek = offs;
break;
case SEEK_CUR:
ustf->uas_fseek += offs;
break;
case SEEK_END:
ustf->uas_fseek = ustf->uas_filesize - offs;
break;
default:
return -1;
}
return ustf->uas_fseek;
}
int
ustarfs_read(f, start, size, resid)
struct open_file *f;
void *start;
size_t size;
size_t *resid;
{
ust_active_t *ustf;
int e;
char *space512;
int blkoffs,
readoffs,
bufferoffset;
size_t seg;
int infile,
inbuffer;
e = 0;
space512 = alloc(512);
ustf = f->f_fsdata;
while(size != 0) {
if (ustf->uas_fseek >= ustf->uas_filesize)
break;
bufferoffset = ustf->uas_fseek % 512;
blkoffs = ustf->uas_fseek - bufferoffset;
readoffs = ustf->uas_filestart + 512 + blkoffs;
e = read512block(f, readoffs, space512);
if (e)
break;
seg = size;
inbuffer = 512 - bufferoffset;
if (inbuffer < seg)
seg = inbuffer;
infile = ustf->uas_filesize - ustf->uas_fseek;
if (infile < seg)
seg = infile;
memcpy(start, space512 + bufferoffset, seg);
ustf->uas_fseek += seg;
start += seg;
size -= seg;
}
if (resid)
*resid = size;
free(space512, 512);
return e;
}
int
ustarfs_stat(f, sb)
struct open_file *f;
struct stat *sb;
{
int mode, uid, gid;
ust_active_t *ustf;
if (f == NULL)
return EINVAL;
ustf = f->f_fsdata;
memset(sb, 0, sizeof *sb);
ustarfs_sscanf(ustf->uas_active.ust_mode, "%8o", &mode);
ustarfs_sscanf(ustf->uas_active.ust_uid, "%8o", &uid);
ustarfs_sscanf(ustf->uas_active.ust_gid, "%8o", &gid);
sb->st_mode = mode;
sb->st_uid = uid;
sb->st_gid = gid;
sb->st_size = ustf->uas_filesize;
return 0;
}
int
ustarfs_close(f)
struct open_file *f;
{
if (f == NULL || f->f_fsdata == NULL)
return EINVAL;
free(f->f_fsdata, sizeof(ust_active_t));
f->f_fsdata = 0;
return 0;
}