minix/servers/fs/utility.c
2005-04-21 14:53:53 +00:00

195 lines
5.4 KiB
C

/* This file contains a few general purpose utility routines.
*
* The entry points into this file are
* clock_time: ask the clock task for the real time
* copy: copy a block of data
* fetch_name: go get a path name from user space
* no_sys: reject a system call that FS does not handle
* panic: something awful has occurred; MINIX cannot continue
* conv2: do byte swapping on a 16-bit int
* conv4: do byte swapping on a 32-bit long
*/
#define STACKINFO 1
#if STACKINFO
#include "symtab.h"
#endif
#include "fs.h"
#include <minix/com.h>
#include <unistd.h>
#include "buf.h"
#include "file.h"
#include "fproc.h"
#include "inode.h"
#include "param.h"
#if STACKINFO
struct i386_frame {
struct i386_frame *next;
int retaddr;
int arg0;
};
PUBLIC void
show_stack(void)
{
unsigned long *s;
int i, t, p = 0;
s = (unsigned long *) &i;
for(i = 0; i < 120; i++, s++) {
char *symname = NULL;
if(!*s) continue;
#define ELEMENTS (sizeof(fs_sym_entries)/sizeof(struct fs_sym_entry))
for(t = 0; t < ELEMENTS-1; t++) {
if(*s >= fs_sym_entries[t].symoffset &&
*s < fs_sym_entries[t+1].symoffset) {
symname = fs_sym_entries[t].symname;
break;
}
}
if(!symname) continue;
if(!(p%7)) printf("\n");
p++;
printf("%-9s ", symname);
}
printf("\n");
}
#endif
PRIVATE int panicking; /* inhibits recursive panics during sync */
/*===========================================================================*
* clock_time *
*===========================================================================*/
PUBLIC time_t clock_time()
{
/* This routine returns the time in seconds since 1.1.1970. MINIX is an
* astrophysically naive system that assumes the earth rotates at a constant
* rate and that such things as leap seconds do not exist.
*/
register int k;
clock_t uptime;
if ( (k=sys_getuptime(&uptime)) != OK) panic("clock_time err", k);
return( (time_t) (boottime + (uptime/HZ)));
}
/*===========================================================================*
* fetch_name *
*===========================================================================*/
PUBLIC int fetch_name(path, len, flag)
char *path; /* pointer to the path in user space */
int len; /* path length, including 0 byte */
int flag; /* M3 means path may be in message */
{
/* Go get path and put it in 'user_path'.
* If 'flag' = M3 and 'len' <= M3_STRING, the path is present in 'message'.
* If it is not, go copy it from user space.
*/
register char *rpu, *rpm;
int r;
/* Check name length for validity. */
if (len <= 0) {
err_code = EINVAL;
return(EGENERIC);
}
if (len > PATH_MAX) {
err_code = ENAMETOOLONG;
return(EGENERIC);
}
if (flag == M3 && len <= M3_STRING) {
/* Just copy the path from the message to 'user_path'. */
rpu = &user_path[0];
rpm = m_in.pathname; /* contained in input message */
do { *rpu++ = *rpm++; } while (--len);
r = OK;
} else {
/* String is not contained in the message. Get it from user space. */
r = sys_datacopy(who, (vir_bytes) path,
FS_PROC_NR, (vir_bytes) user_path, (phys_bytes) len);
}
return(r);
}
/*===========================================================================*
* no_sys *
*===========================================================================*/
PUBLIC int no_sys()
{
/* Somebody has used an illegal system call number */
return(EINVAL);
}
/*===========================================================================*
* panic *
*===========================================================================*/
PUBLIC void panic(format, num)
char *format; /* format string */
int num; /* number to go with format string */
{
/* Something awful has happened. Panics are caused when an internal
* inconsistency is detected, e.g., a programming error or illegal value of a
* defined constant.
*/
int i;
if (panicking) return; /* do not panic during a sync */
panicking = TRUE; /* prevent another panic during the sync */
#if STACKINFO
show_stack();
#endif
printf("File system panic: %s ", format);
if (num != NO_NUM) printf("%d",num);
(void) do_sync(); /* flush everything to the disk */
sys_exit(1);
printf("FS: I'm still alive after exit!\n");
while(1) ;
}
/*===========================================================================*
* conv2 *
*===========================================================================*/
PUBLIC unsigned conv2(norm, w)
int norm; /* TRUE if no swap, FALSE for byte swap */
int w; /* promotion of 16-bit word to be swapped */
{
/* Possibly swap a 16-bit word between 8086 and 68000 byte order. */
if (norm) return( (unsigned) w & 0xFFFF);
return( ((w&BYTE) << 8) | ( (w>>8) & BYTE));
}
/*===========================================================================*
* conv4 *
*===========================================================================*/
PUBLIC long conv4(norm, x)
int norm; /* TRUE if no swap, FALSE for byte swap */
long x; /* 32-bit long to be byte swapped */
{
/* Possibly swap a 32-bit long between 8086 and 68000 byte order. */
unsigned lo, hi;
long l;
if (norm) return(x); /* byte order was already ok */
lo = conv2(FALSE, (int) x & 0xFFFF); /* low-order half, byte swapped */
hi = conv2(FALSE, (int) (x>>16) & 0xFFFF); /* high-order half, swapped */
l = ( (long) lo <<16) | hi;
return(l);
}