/* [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.
*/
/*
* 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? :-)
*
* XXX Does not currently implement:
* XXX
* XXX LIBSA_NO_FS_CLOSE
* XXX LIBSA_NO_FS_SEEK
* XXX LIBSA_NO_FS_WRITE
* XXX LIBSA_NO_FS_SYMLINK (does this even make sense?)
* XXX LIBSA_FS_SINGLECOMPONENT
*/
#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 */
ust_pad[1]; /* make it aligned */
} ustar_t;
/*
* We buffer one even cylinder 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[USTAR_SECT_PER_CYL * 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_sigdone; /* did sig already */
int uas_offset; /* amount of cylinder below lba 0 */
} ust_active_t;
static int checksig(ust_active_t *);
static int convert(const char *, int, int);
static int get_volume(struct open_file *, int);
static void setwindow(ust_active_t *, ustoffs, ustoffs);
static int real_fs_cylinder_read(struct open_file *, ustoffs, int);
static int ustarfs_cylinder_read(struct open_file *, ustoffs, int);
static void ustarfs_sscanf(const char *, const char *, int *);
static int read512block(struct open_file *, ustoffs, char block[512]);
static int init_volzero_sig(struct open_file *);
#ifdef HAVE_CHANGEDISK_HOOK
/*
* Called when the next volume is prompted.
* Machine dependent code can eject the medium etc.
* The new medium must be ready when this hook returns.
*/
void changedisk_hook(struct open_file *);
#endif
static int
convert(const char *f, int base, int 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 int
ustarfs_cylinder_read(struct open_file *f, ustoffs seek2, int forcelabel)
{
int i, e;
for (i = 0; i < 3; ++i) {
e = real_fs_cylinder_read(f, seek2, forcelabel);
if (e == 0)
return 0;
}
return e;
}
static int
real_fs_cylinder_read(struct open_file *f, ustoffs seek2, int forcelabel)
{
int i;
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) {
#if !defined(LIBSA_NO_TWIDDLE)
twiddle();
#endif
for (i = 0; i < 3; ++i) {
e = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
seek2 / 512, xferrqst, xferbase, &xfercount);
if (e == 0)
break;
printf("@");
}
if (e)
break;
if (xfercount != xferrqst)
printf("Warning, unexpected short transfer %d/%d\n",
(int)xfercount, (int)xferrqst);
xferrqst -= xfercount;
xferbase += xfercount;
seek2 += xfercount;
}
return e;
}
static int
checksig(ust_active_t *ustf)
{
int i, rcs;
static int
read512block(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 (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 cylinder
* 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 +
(int)(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;
}
static int
init_volzero_sig(struct open_file *f)
{
int e;
ust_active_t *ustf;
ustf = f->f_fsdata;
if (!ustf->uas_sigdone) {
e = ustarfs_cylinder_read(f, 0, 0);
if (e)
return e;
ustf->uas_volzerosig = checksig(ustf);
setwindow(ustf, 0, 0);
}
return 0;
}
/*
* XXX Hack alert. GCC 8.3 mis-compiles this function and calls
* strncmp() with the wrong second pointer, as seen in PR#54703.
*
* Until the real cause is located, work around it by using -O1
* for this function.
*/
#if defined(__i386__) && !defined(__clang__)
__attribute__((__optimize__("O1")))
#endif
__compactcall int
ustarfs_open(const 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;
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;
e = init_volzero_sig(f);
if (e)
return e;
e2 = EINVAL;
for(;;) {
ustf->uas_filestart = offset;
e = read512block(f, offset, block);
if (e)
break;
memcpy(&ustf->uas_active, block, sizeof ustf->uas_active);
if(strncmp(ustf->uas_active.ust_magic, "ustar", 5)) {
e = e2;
break;
}
e2 = 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;
break;
}
offset += USTAR_NAME_BLOCK + filesize;
filesize %= 512;
if (filesize)
offset += 512 - filesize;
}
if (e) {
dealloc(ustf, sizeof *ustf);
f->f_fsdata = 0;
}
return e;
}
