{
ino_t ino;
struct stat st;
- char name[NAME_MAX+1];
+ char name[MFS_DIRSIZ+1];
if (fsok == -1) fsok= r_super(&block_size) != 0;
if (!fsok) return;
* the way up. (One can't use r_stat while reading a directory.)
*/
{
- char name[NAME_MAX + 1];
+ char name[MFS_DIRSIZ + 1];
ino_t ino, newest;
time_t mtime;
ino_t image_ino;
struct stat st;
- image= strcpy(malloc((strlen(image) + 1 + NAME_MAX + 1)
+ image= strcpy(malloc((strlen(image) + 1 + MFS_DIRSIZ + 1)
* sizeof(char)), image);
fsok= r_super(&block_size) != 0;
if (!S_ISREG(st.st_mode)) {
char *version= image + strlen(image);
- char dots[NAME_MAX + 1];
+ char dots[MFS_DIRSIZ + 1];
if (!S_ISDIR(st.st_mode)) {
printf("%s: %s\n", image, unix_err(ENOTDIR));
#include <minix/type.h>
#include <servers/mfs/const.h>
#include <servers/mfs/type.h>
-#include <servers/mfs/buf.h>
#include <servers/mfs/super.h>
#include <servers/mfs/inode.h>
#include "rawfs.h"
+#include <servers/mfs/buf.h>
void readblock(off_t blockno, char *buf, int);
static unsigned nr_indirects;
static unsigned inodes_per_block;
static int block_size;
-#ifdef FLEX
-#include <dirent.h>
-#define direct _v7_direct
-#else
-#include <sys/dir.h>
-#endif
#if __minix_vmd
static struct v12_super_block super; /* Superblock of file system */
readblock(r_vir2abs(dirpos / block_size), dirbuf, block_size);
}
-#ifdef FLEX
- if (super.s_flags & S_FLEX) {
- struct _fl_direct *dp;
-
- dp= (struct _fl_direct *) (dirbuf + blkpos);
- if ((inum= dp->d_ino) != 0) strcpy(name, dp->d_name);
-
- dirpos+= (1 + dp->d_extent) * FL_DIR_ENTRY_SIZE;
- continue;
- }
-#endif
/* Let dp point to the next entry. */
dp= (struct direct *) (dirbuf + blkpos);
- if ((inum= dp->d_ino) != 0) {
+ if ((inum= dp->mfs_d_ino) != 0) {
/* This entry is occupied, return name. */
- strncpy(name, dp->d_name, sizeof(dp->d_name));
- name[sizeof(dp->d_name)]= 0;
+ strncpy(name, dp->mfs_d_name, sizeof(dp->mfs_d_name));
+ name[sizeof(dp->mfs_d_name)]= 0;
}
dirpos+= DIR_ENTRY_SIZE;
}
* function, it only needs r_stat and r_readdir.
*/
{
- char name[NAME_MAX+1], r_name[NAME_MAX+1];
+ char name[MFS_DIRSIZ+1], r_name[MFS_DIRSIZ+1];
char *n;
struct stat st;
ino_t ino;
n= name;
while (*path != 0 && *path != '/')
- if (n < name + NAME_MAX) *n++ = *path++;
+ if (n < name + MFS_DIRSIZ) *n++ = *path++;
*n= 0;
while ((ino= r_readdir(r_name)) != 0
#ifndef INC_RAWFS_H
#define INC_RAWFS_H
+#include <minix/dirent.h>
+#include <servers/mfs/mfsdir.h>
+
#define ROOT_INO ((ino_t) 1) /* Inode nr of root dir. */
extern off_t r_super(int *);
cat cawf cd cdprobe checkhier chmem \
chmod chown chroot ci cksum cleantmp clear cmp co \
comm compress cp crc cron crontab cut date \
- dd de decomp16 DESCRIBE dev2name devsize df dhcpd \
+ dd decomp16 DESCRIBE dev2name devsize df dhcpd \
dhrystone diff dirname dis386 dis88 diskctl du dumpcore \
ed eject elle elvis env expand factor file \
find finger fingerd fix fold format fortune fsck.mfs \
ping postinstall poweroff pr prep printf printroot \
profile progressbar proto pr_routes ps pwd pwdauth \
ramdisk rarpd rawspeed rcp rdate readall readclock \
- readfs reboot remsync rev rget rlogin rlogind rmdir \
+ reboot remsync rev rget rlogin rlogind rmdir \
rotate rsh rshd sed service setup shar acksize \
sleep slip sort spell split srccrc ackstrip \
stty su sum svclog swifi sync synctree sysenv \
#endif
#include <assert.h>
-#include <sys/dir.h>
-
/* Copy files in this size chunks: */
#if __minix && !__minix_vmd
#define CHUNK (8192 * sizeof(char *))
void path_init(pathname_t *pp)
/* Initialize a pathname to the null string. */
{
- pp->path= allocate(nil, pp->lim= DIRSIZ + 2);
+ pp->path= allocate(nil, pp->lim= NAME_MAX + 2);
pp->path[pp->idx= 0]= 0;
}
+++ /dev/null
-# Makefile for de
-
-PROG= de
-SRCS= de.c de_stdin.c de_stdout.c de_diskio.c de_recover.c
-CPPFLAGS+= -I${MINIXSRCDIR}/servers
-CPPFLAGS+= -D_POSIX_1_SOURCE=2
-MAN=
-
-.include <bsd.prog.mk>
+++ /dev/null
- de - A Minix Disk Editor
-
- Terrence W. Holm, Jan. 1989
-
-
-INTRODUCTION
-
- The de(1) disk editor allows a system administrator to
- look at and modify a Minix file system device. Commands
- allow movement throughout a file system device, displaying
- information in a couple of formats, writing blocks from
- the device onto another file, and rewriting words on the
- disk.
-
- A few changes to the Minix file system aid recovering files.
- I-node numbers are retained in directory entries now (they
- get moved to the end). And all the i-node information is not
- zeroed-out when a file is unlinked. So, after a file is
- accidently rm(1)'ed, you can find the old i-node, and then
- manually (or automatically) go to each of the freed blocks
- and write them to a new file.
-
-
-USES FOR THE DISK EDITOR
-
- 1) EDUCATION. Students can look at a file system in
- a painless manner. For example you don't have to
- use od(1) to look at the zone numbers in i-nodes.
-
- A simple assignment is to change the size of an un-mounted
- floppy disk file system from 360 to 300 blocks. (A more
- difficult assignment is to explain why this works, even
- though fsck(1) and df(1) do not report the correct number
- of free blocks. :-)
-
- 2) ADMINISTRATION. You can visually check inconsistencies
- reported by fsck(1) before letting fsck(1) fix them.
- You can change any word on the disk, this greatly simplifies
- editing file system information. For example, changing the
- size of a block special device is actually fun, no more
- "blind" writing to your partitions.
-
- Bit maps can be displayed with 2048 "bits" per screen,
- (on the IBM/PC console), see how your zones are allocated!
-
- 3) RECOVERING LOST FILES. You can search a disk for an ASCII
- string, once found, the block can be written out to a file.
-
- A one line change to fs/path.c allows users to get the i-node
- number for a file after it has been removed from a directory.
-
- Another couple lines changed in the file system keep the
- i-node information available until the i-node is reused
- (normally this information is zeroed out when an i-node is
- released.) This allows a de(1) user to go to a released
- i-node, get all the block numbers, go to these blocks and
- write them back to a new file.
-
- The whole recovery process is automated by running "de -r file".
- So, IF a file is unlink(2)'ed (eg. "rm file"), AND IF no one
- allocates a new i-node or block in the mean-time, THEN you
- can recover the file.
-
-
-RECOVERY SECURITY
-
- Normally Minix hard disk partitions are r/w only by the super-user,
- and floppy disks are r/w by anyone. This means that only "root"
- can look at hard disk partitions, but others can use de(1) to play
- with their floppy disks.
-
- When recovering files ("de -r file"), a user requires access to
- the major file system partitions. This can be done by:
-
- (a) Give everyone access to the hard disks. DON'T DO THIS, it
- defeats all the file system protection we already have.
-
- (b) Make de(1) set-uid "root". This is the way to go, IF you
- are running a Minix system that has NO ACCESS from the
- outside. This allows anyone to execute "de -r file", but only
- root to use "de /dev/hd3". De(1) does some checking when
- retrieving lost blocks, eg. making sure they really are
- free blocks and making sure the user owned the i-node.
- BUT, file system information has been lost when the file
- was unlink(2)'ed, so de(1) can not be 100% sure that a
- recovered block really belonged to the user. THIS IS A
- SECURITY HOLE. [Since the only access to my machine is from
- observable terminals and their associated humans, I run
- de(1) as set-uid root.]
-
- (c) Keep the disks rw-------, and don't set-uid de(1). This
- means that only the super-user can recover lost files.
- So, if you accidently "rm", you must tell the system
- administrator to "su" and recover your file, (be sure to
- inform the other users to stop whatever they are doing
- until the file is restored).
-
-
-INSTALLATION
-
- - Install de.1 in /usr/man/cat1.
-
- - Install the files: Makefile, README, de.h, de.c, de_stdin.c,
- de_stdout.c, de_diskio.c and de_recover.c in commands/de.
- Add -F and -T. to the Makefile, if necessary.
-
- - "make" de(1). If a header file is not found, don't worry:
- You probably have it somewhere, just link it to what de(1)
- is looking for. This program also requires the subroutine
- tolower(3), see EFTH MINIX report #50, if you don't have it.
-
- - Do you really want set-uid root on de?
-
- - Patch the files fs/path.c, fs/link.c and fs/open.c. If
- you don't patch the file system then the recover option
- "-r" and associated commands ('x' and 'X') will not work,
- but de(1) is still functional and useful.
-
- - "make" a new fs, using -DRECOVER. Rebuild a boot diskette.
-
-
-USING DE(1) FOR THE FIRST TIME
-
- De(1) starts up in "word" mode at block 0 of the specified
- device. Hit the PGDN (or space bar) a few times, observing
- all the information on the screen. Each PGUP/PGDN moves to
- the next 1024 byte block, (de(1) only knows about 1 block per
- zone file systems). Note that "word" mode only displays 32
- bytes at a time, so you are only observing the first 32 bytes
- in the first few blocks when you skip using PGDN.
-
- Now go back to block 3, (zone bit map), using "g 3 ENTER".
- Change to "map" mode "v m", and then use the down arrow key
- to check each 2 Megs in the zone bit map.
-
- Now change to "block" mode using "v b". And go to some data
- block, eg. "g 1000 ENTER". Use PGUP/PGDN to see what data
- is in each nearby block.
-
- Remember 'h' gives you a help page.
-
- Try some more commands, for example: 'END', 'I', '/'.
- (Note: searching through a whole disk under Minix takes a
- long time: 30-60 seconds per megabyte, depending on your
- machine, drive and controller, [Minix is embarrassingly slow].)
-
- Don't worry about looking at a mounted device, you must specify
- the "-w" option before the 's' command is operational, and
- this command is the only one which will try to modify the
- contents of the device.
-
-
-MINIX-ST
-
- Please contact me if you are interesting in attempting a port
- to MINIX-ST.
+++ /dev/null
-/****************************************************************/
-/* */
-/* de.c */
-/* */
-/* Main loop of the "Disk editor". */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-15 Terrence W. Holm */
-/****************************************************************/
-
-
-#include <minix/config.h>
-#include <sys/types.h>
-#include <sys/dir.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <ctype.h>
-#include <errno.h>
-#undef ERROR /* arrgghh, errno.h has this pollution */
-#include <fcntl.h>
-#include <limits.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <minix/const.h>
-#include <minix/type.h>
-#include "mfs/const.h"
-#include "mfs/type.h"
-#include "mfs/inode.h"
-
-#include "de.h"
-
-static char copyright[] = "de (c) Terrence W. Holm 1989";
-
-
-_PROTOTYPE(void Push , (de_state *s ));
-_PROTOTYPE(int Get_Base , (int *base ));
-_PROTOTYPE(int Get_Filename , (de_state *s ));
-_PROTOTYPE(int Get_Count , (char *units , unsigned long *result ));
-_PROTOTYPE(void Exec_Shell , (void));
-_PROTOTYPE(void Sigint , (int));
-
-
-
-/****************************************************************/
-/* */
-/* main() */
-/* */
-/* Initialize. Handle the "-r" recovery option if */
-/* specified, else enter the main processing loop. */
-/* */
-/****************************************************************/
-
-
-int main( argc, argv )
- int argc;
- char *argv[];
-
- {
- static de_state s; /* it is safer not to put it on the stack
- * and some things probably now rely on zero
- * initialization
- */
- char *command_name = argv[0];
- int recover = 0;
-
-
- s.device_mode = O_RDONLY;
-
-
- /* Parse arguments */
-
- if ( argc == 3 && strcmp( argv[1], "-r" ) == 0 )
- {
- recover = 1;
- --argc;
- ++argv;
- }
- else if ( argc == 3 && strcmp( argv[1], "-w" ) == 0 )
- {
- s.device_mode = O_RDWR;
- --argc;
- ++argv;
- }
-
- if ( argc != 2 || *argv[1] == '-' )
- {
- fprintf( stderr, "Usage: %s [-w] /dev/device\n", command_name );
- fprintf( stderr, " %s -r lost_file_name\n", command_name );
- exit( 1 );
- }
-
-
- /* Set the effective id to the real id. This eliminates */
- /* any increase in privilege done by a set-uid bit on the */
- /* executable file. We want to be "root" for recovering */
- /* files, because we must be able to read the device. */
- /* However, in normal usage, de(1) should not let just */
- /* anyone look at a file system, thus we drop the privilege. */
- /* */
- /* NOTE: There is a security hole when using "-r" with a */
- /* set-uid de(1). Do not use set-uid root if there is any */
- /* way to externally access your Minix system. */
-
- if ( ! recover )
- {
- setuid( getuid() );
- setgid( getgid() );
- }
-
-
- /* Set terminal characteristics, and ^C interrupt handler */
-
- Save_Term();
-
- if ( signal( SIGINT, SIG_IGN ) != SIG_IGN )
- {
- signal( SIGINT, Sigint );
- signal( SIGQUIT, Sigint );
- }
-
- Set_Term();
-
- if ( ! Init_Termcap() )
- Error( "Requires a termcap entry" );
-
-
-
- /* Get the device file name. If recovering, also open an output file. */
-
- if ( recover )
- {
- char *dir_name;
- char *file_name;
- struct stat device_stat;
- struct stat tmp_stat;
-
- /* Split the path name into a directory and a file name. */
-
- if ( strlen(argv[1]) > MAX_STRING )
- Error( "Path name too long" );
-
- if ( ! Path_Dir_File( argv[1], &dir_name, &file_name ) )
- Error( "Recover aborted" );
-
- /* Find the device holding the directory. */
-
- if ( (s.device_name = File_Device( dir_name )) == NULL )
- Error( "Recover aborted" );
-
-
- /* The output file will be in /tmp with the same file name. */
-
- strcpy( s.file_name, TMP );
- strcat( s.file_name, "/" );
- strcat( s.file_name, file_name );
-
-
- /* Make sure /tmp is not on the same device as the file we */
- /* are trying to recover (we don't want to use up the free */
- /* i-node and blocks before we get a chance to recover them). */
-
- if ( stat( s.device_name, &device_stat ) == -1 )
- Error( "Can not stat(2) device %s", s.device_name );
-
- if ( stat( TMP, &tmp_stat ) == -1 )
- Error( "Can not stat(2) directory %s", TMP );
-
- if ( device_stat.st_rdev == tmp_stat.st_dev )
- Error( "Will not recover files on the same device as %s", TMP );
-
- if ( access( s.file_name, F_OK ) == 0 )
- Error( "Will not overwrite file %s", s.file_name );
-
-
- /* Open the output file. */
-
- if ( (s.file_f = fopen( s.file_name, "w" )) == NULL )
- Error( "Can not open file %s", s.file_name );
-
- /* Don't let anyone else look at the recovered file */
-
- chmod( s.file_name, 0700 );
-
- /* If running as root then change the owner of the */
- /* restored file. If not running as root then the */
- /* chown(2) will fail. */
-
- chown( s.file_name, getuid(), getgid() );
- }
- else
- {
- s.device_name = argv[1];
- s.file_name[ 0 ] = '\0';
- }
-
-
- /* Open the device file. */
-
- {
- struct stat device_stat;
- off_t size;
-
- if ( stat( s.device_name, &device_stat ) == -1 )
- Error( "Can not find file %s", s.device_name );
-
- if ( (device_stat.st_mode & S_IFMT) != S_IFBLK &&
- (device_stat.st_mode & S_IFMT) != S_IFREG )
- Error( "Can only edit block special or regular files" );
-
-
- if ( (s.device_d = open( s.device_name, s.device_mode )) == -1 )
- Error( "Can not open %s", s.device_name );
-
- if ( (size = lseek( s.device_d, 0L, SEEK_END )) == -1 )
- Error( "Error seeking %s", s.device_name );
-
- if ( size % K != 0 )
- {
- Warning( "Device size is not a multiple of 1024" );
- Warning( "The (partial) last block will not be accessible" );
- }
- }
-
-
- /* Initialize the rest of the state record */
-
- s.mode = WORD;
- s.output_base = 10;
- s.search_string[ 0 ] = '\0';
-
- {
- int i;
-
- for ( i = 0; i < MAX_PREV; ++i )
- {
- s.prev_addr[ i ] = 0L;
- s.prev_mode[ i ] = WORD;
- }
- }
-
-
- sync();
-
- Read_Super_Block( &s );
-
- Read_Bit_Maps( &s );
-
- s.address = 0L;
-
-
-
- /* Recover mode basically performs an 'x' and an 'X' */
-
- if ( recover )
- {
- ino_t inode = Find_Deleted_Entry( &s, argv[1] );
- off_t size;
-
- if ( inode == 0 )
- {
- unlink( s.file_name );
- Error( "Recover aborted" );
- }
-
- s.address = ( (long) s.first_data - s.inode_blocks ) * K
- + (long) (inode - 1) * s.inode_size;
-
- Read_Block( &s, s.buffer );
-
-
- /* Have found the lost i-node, now extract the blocks. */
-
- if ( (size = Recover_Blocks( &s )) == -1L )
- {
- unlink( s.file_name );
- Error( "Recover aborted" );
- }
-
- Reset_Term();
-
- printf( "Recovered %ld bytes, written to file %s\n", size, s.file_name );
-
- exit( 0 );
- }
-
-
- /* Enter the main loop, first time redraw the screen */
- {
- int rc = REDRAW;
-
-
- do
- {
- if ( rc == REDRAW )
- {
- Read_Block( &s, s.buffer );
- Draw_Screen( &s );
- s.last_addr = s.address;
- Draw_Pointers( &s );
- }
-
- else if ( rc == REDRAW_POINTERS )
- {
- s.offset = (unsigned) (s.address & ~ K_MASK);
- Draw_Pointers( &s );
- }
-
- else if ( rc == ERROR )
- {
- Erase_Prompt();
- putchar( BELL );
- }
- } while ( (rc = Process( &s, Arrow_Esc(Get_Char()) )) != EOF );
- }
-
-
- /* If there is an open output file that was never written to */
- /* then remove its directory entry. This occurs when no 'w' */
- /* or 'W' command occurred between a 'c' command and exiting */
- /* the program. */
-
- if ( s.file_name[0] != '\0' && ! s.file_written )
- unlink( s.file_name );
-
-
- Reset_Term(); /* Restore terminal characteristics */
-
- exit( 0 );
- }
-
-
-
-/****************************************************************/
-/* */
-/* Get_Base( base ) */
-/* */
-/* Get a new base value. */
-/* Returns REDRAW or ERROR. */
-/* */
-/****************************************************************/
-
-
-
-int Get_Base( base )
- int *base;
- {
- switch ( Get_Char() )
- {
- case 'h' : *base = 16;
- break;
-
- case 'd' : *base = 10;
- break;
-
- case 'o' : *base = 8;
- break;
-
- case 'b' : *base = 2;
- break;
-
- default : return( ERROR );
- }
-
- return( REDRAW );
- }
-
-
-
-/****************************************************************/
-/* */
-/* Process( state, input_char ) */
-/* */
-/* Determine the function requested by the */
-/* input character. Returns OK, REDRAW, */
-/* REDRAW_POINTERS, ERROR or EOF. */
-/* */
-/****************************************************************/
-
-
-int Process( s, c )
- de_state *s;
- int c;
-
- {
- switch ( c )
- {
- case 'b' : /* Back up one block */
- case ESC_PGUP :
-
- if ( s->address == 0 )
- return( ERROR );
-
- s->address = (s->address - K) & K_MASK;
-
- return( REDRAW );
-
-
- case 'B' : /* Back up to home */
- case ESC_HOME :
-
- if ( s->address == 0 )
- return( OK );
-
- Push( s );
-
- s->address = 0L;
-
- return( REDRAW );
-
-
- case 'c' : /* Change file name */
-
- {
- int rc = Get_Filename( s );
-
- return( rc == OK ? REDRAW : rc );
- }
-
-
- case 'd' : /* Down */
- case ESC_DOWN :
-
- {
- s->last_addr = s->address;
-
- switch ( s->mode )
- {
- case WORD : s->address += 2;
-
- if ( (s->address & PAGE_MASK) == 0 )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case BLOCK : s->address += 64;
-
- if ( (s->last_addr & K_MASK) !=
- (s->address & K_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case MAP : s->address += 256;
-
- return( REDRAW );
-
- default : Error( "Internal fault (mode)" );
- }
- }
-
-
- case 'f' : /* Forward one block */
- case ' ' :
- case ESC_PGDN :
-
- if ( s->block == s->device_size - 1 )
- return( ERROR );
-
- s->address = (s->address + K) & K_MASK;
-
- return( REDRAW );
-
-
- case 'F' : /* Forward to end */
- case ESC_END :
-
- {
- off_t last_block = ( (long) s->device_size - 1 ) * K;
-
- if ( s->address == last_block )
- return( OK );
-
- Push( s );
-
- s->address = last_block;
-
- return( REDRAW );
- }
-
-
- case 'g' : /* Goto block */
-
- {
- unsigned long block;
-
- if ( Get_Count( "Block?", &block ) )
- {
- if ( block >= s->zones )
- {
- Warning( "Block number too large" );
- return( REDRAW );
- }
-
- Push( s );
-
- s->address = (off_t) block * K;
-
- return( REDRAW );
- }
- else
- return( ERROR );
- }
-
-
- case 'G' : /* Goto block indirect */
-
- {
- unsigned block = *( (word_t *) &s->buffer[ s->offset ] );
-
- if ( s->mode != WORD )
- {
- Warning( "Must be in visual mode \"word\"" );
- return( REDRAW );
- }
-
- if ( block >= s->zones )
- {
- Warning( "Block number too large" );
- return( REDRAW );
- }
-
- Push( s );
-
- s->mode = BLOCK;
- s->address = (long) block * K;
-
- return( REDRAW );
- }
-
-
- case 'h' : /* Help */
- case '?' :
-
- Draw_Help_Screen( s );
-
- Wait_For_Key();
-
- return( REDRAW );
-
-
- case 'i' : /* Goto i-node */
-
- {
- unsigned long inode;
-
- if ( Get_Count( "I-node?", &inode ) )
- {
- if ( inode < 1 || inode > s->inodes )
- {
- Warning( "Illegal i-node number" );
- return( REDRAW );
- }
-
- Push( s );
-
- s->mode = WORD;
- s->address = (off_t) (s->first_data - s->inode_blocks) * K
- + (off_t) (inode - 1) * s->inode_size;
-
- return( REDRAW );
- }
- else
- return( ERROR );
- }
-
-
- case 'I' : /* Filename to i-node */
-
- {
- ino_t inode;
- char *filename;
-
- Draw_Prompt( "File name?" );
-
- filename = Get_Line();
-
- if ( filename == NULL || filename[0] == '\0' )
- return( ERROR );
-
- inode = Find_Inode( s, filename );
-
- if ( inode )
- {
- Push( s );
-
- s->mode = WORD;
- s->address = ( (long) s->first_data - s->inode_blocks ) * K
- + (long) (inode - 1) * s->inode_size;
- }
-
- return( REDRAW );
- }
-
-
- case 'l' : /* Left */
- case ESC_LEFT :
-
- {
- s->last_addr = s->address;
-
- switch ( s->mode )
- {
- case WORD : s->address = s->address - 32;
-
- return( REDRAW );
-
- case BLOCK : s->address -= 1;
-
- if ( (s->last_addr & K_MASK) !=
- (s->address & K_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case MAP : s->address -= 4;
-
- if ( (s->last_addr & ~ MAP_MASK) !=
- (s->address & ~ MAP_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- default : Error( "Internal fault (mode)" );
- }
- }
-
-
- case 'm' : /* Invoke a Minix shell */
-
- Reset_Term();
-
- Exec_Shell();
-
- Set_Term();
-
- return( REDRAW );
-
-
- case 'n' : /* Search for next */
-
- {
- off_t addr;
-
- if ( s->search_string[0] == '\0' )
- {
- Warning( "No search string defined" );
- return( REDRAW );
- }
-
- Draw_Prompt( "Searching..." );
-
- if ( (addr = Search( s, s->search_string )) == -1L )
- {
- Warning( "Search string not found" );
-
- Wait_For_Key();
-
- return( REDRAW );
- }
-
- Push( s );
- s->address = addr;
-
- return( REDRAW );
- }
-
-
- case 'o' : /* Set output base */
-
- Draw_Prompt( "Output base?" );
-
- return( Get_Base( &s->output_base ) );
-
-
- case 'p' : /* Previous address */
-
- {
- int i;
-
- s->address = s->prev_addr[ 0 ];
- s->mode = s->prev_mode[ 0 ];
-
- for ( i = 0; i < MAX_PREV - 1; ++i )
- {
- s->prev_addr[ i ] = s->prev_addr[ i + 1 ];
- s->prev_mode[ i ] = s->prev_mode[ i + 1 ];
- }
-
- return( REDRAW );
- }
-
-
- case 'q' : /* Quit */
- case EOF :
- case CTRL_D :
-
- return( EOF );
-
-
- case 'r' : /* Right */
- case ESC_RIGHT :
-
- {
- s->last_addr = s->address;
-
- switch ( s->mode )
- {
- case WORD : s->address += 32;
-
- return( REDRAW );
-
- case BLOCK : s->address += 1;
-
- if ( (s->last_addr & K_MASK) !=
- (s->address & K_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case MAP : s->address += 4;
-
- if ( (s->last_addr & ~ MAP_MASK) !=
- (s->address & ~ MAP_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- default : Error( "Internal fault (mode)" );
- }
- }
-
- case 's' : /* Store word */
-
- {
- unsigned long word;
-
- if ( s->mode != WORD )
- {
- Warning( "Must be in visual mode \"word\"" );
- return( REDRAW );
- }
-
- if ( s->device_mode == O_RDONLY )
- {
- Warning( "Use -w option to open device for writing" );
- return( REDRAW );
- }
-
- if ( Get_Count( "Store word?", &word ) )
- {
- if ( word != (word_t) word )
- {
- Warning( "Word is more than 16 bits" );
- return( REDRAW );
- }
- Write_Word( s, (word_t) word );
-
- return( REDRAW );
- }
- else
- return( ERROR );
- }
-
-
- case 'u' : /* Up */
- case ESC_UP :
-
- {
- s->last_addr = s->address;
-
- switch ( s->mode )
- {
- case WORD : s->address -= 2;
-
- if ( (s->last_addr & PAGE_MASK) == 0 )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case BLOCK : s->address -= 64;
-
- if ( (s->last_addr & K_MASK) !=
- (s->address & K_MASK) )
- return( REDRAW );
-
- return( REDRAW_POINTERS );
-
- case MAP : s->address -= 256;
-
- return( REDRAW );
-
- default : Error( "Internal fault (mode)" );
- }
- }
-
-
- case 'v' : /* Visual mode */
-
- Draw_Prompt( "Visual mode?" );
-
- switch ( Get_Char() )
- {
- case 'w' : s->mode = WORD;
- break;
-
- case 'b' : s->mode = BLOCK;
- break;
-
- case 'm' : {
- /* Assume user knows if map mode is possible
- char *tty = ttyname( 0 );
-
- if ( tty == NULL ||
- strcmp( tty, "/dev/tty0" ) != 0 )
- Warning( "Must be at console" );
- else
- */
- s->mode = MAP;
-
- break;
- }
-
- default : return( ERROR );
- }
-
- return( REDRAW );
-
-
- case 'w' : /* Write ASCII block */
-
- if ( s->file_name[0] == '\0' )
- {
- int rc = Get_Filename( s );
-
- if ( rc != OK )
- return( rc );
- }
-
- /* We have a successfully opened file */
-
- /* Eliminate non-ASCII characters */
- {
- int i;
- char buf[ K ];
- char *from = s->buffer;
- char *to = buf;
-
- for ( i = 0; i < K; ++i, ++from )
- {
- *to = *from & 0x7f;
-
- if ( *to != '\0' && *to != '\177' )
- ++to;
- }
-
- if ( fwrite( buf, 1, (int)(to - buf), s->file_f ) != to - buf )
- Warning( "Problem writing out buffer" );
-
- s->file_written = 1;
-
- return( REDRAW );
- }
-
-
- case 'W' : /* Write block exactly */
-
- if ( s->file_name[0] == '\0' )
- {
- int rc = Get_Filename( s );
-
- if ( rc != OK )
- return( rc );
- }
-
- /* We have a successfully opened file */
-
- if ( fwrite( s->buffer, 1, K, s->file_f ) != K )
- Warning( "Problem writing out buffer" );
-
- s->file_written = 1;
-
- return( REDRAW );
-
-
- case 'x' : /* eXtract lost entry */
-
- {
- ino_t inode;
- char *filename;
-
- Draw_Prompt( "Lost file name?" );
-
- filename = Get_Line();
-
- if ( filename == NULL || filename[0] == '\0' )
- return( ERROR );
-
- inode = Find_Deleted_Entry( s, filename );
-
- if ( inode )
- {
- Push( s );
-
- s->mode = WORD;
- s->address = ( (long) s->first_data - s->inode_blocks ) * K
- + (long) (inode - 1) * s->inode_size;
- }
-
- return( REDRAW );
- }
-
-
- case 'X' : /* eXtract lost blocks */
-
- {
- int rc;
-
- if ( s->mode != WORD )
- {
- Warning( "Must be in visual mode \"word\"" );
- return( REDRAW );
- }
-
-
- /* Force a new output file name. */
-
- if ( (rc = Get_Filename( s )) != OK )
- return( rc );
-
-
- Draw_Strings( s );
-
- Erase_Prompt();
- Draw_Prompt( "Recovering..." );
-
- if ( Recover_Blocks( s ) == -1L )
- unlink( s->file_name );
-
- /* Force closure of output file. */
-
- fclose( s->file_f );
- s->file_name[ 0 ] = '\0';
-
- return( REDRAW );
- }
-
-
- case '/' : /* Search */
- case ESC_PLUS :
-
- {
- off_t addr;
- char *string;
-
- Draw_Prompt( "Search string?" );
-
- string = Get_Line();
-
- if ( string == NULL )
- return( ERROR );
-
- if ( string[0] != '\0' )
- {
- strcpy( s->search_string, string );
- Draw_Strings( s );
- }
-
- else if ( s->search_string[0] == '\0' )
- {
- Warning( "No search string defined" );
- return( REDRAW );
- }
-
- Erase_Prompt();
- Draw_Prompt( "Searching..." );
-
- if ( (addr = Search( s, s->search_string )) == -1L )
- {
- Warning( "Search string not found" );
-
- Wait_For_Key();
-
- return( REDRAW );
- }
-
- Push( s );
-
- s->mode = BLOCK;
- s->address = addr;
-
- return( REDRAW );
- }
-
-
- default:
- return( ERROR );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Push( state ) */
-/* */
-/* Push current address and mode, used by the */
-/* commands B, F, g, G, i, I, n, x and /. This */
-/* information is popped by the 'p' command. */
-/* */
-/****************************************************************/
-
-
-void Push( s )
- de_state *s;
-
- {
- int i;
-
- for ( i = MAX_PREV - 1; i > 0; --i )
- {
- s->prev_addr[ i ] = s->prev_addr[ i - 1 ];
- s->prev_mode[ i ] = s->prev_mode[ i - 1 ];
- }
-
- s->prev_addr[ 0 ] = s->address;
- s->prev_mode[ 0 ] = s->mode;
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Get_Filename( state ) */
-/* */
-/* Read and check a filename. */
-/* */
-/****************************************************************/
-
-
-int Get_Filename( s )
- de_state *s;
-
- {
- char *filename;
- char *name;
- FILE *f;
-
- Draw_Prompt( "File name?" );
-
- filename = Get_Line();
-
- if ( filename == NULL || filename[0] == '\0' )
- return( ERROR );
-
-
- for ( name = filename; *name != '\0'; ++name )
- if ( ! isgraph( *name ) )
- {
- Warning( "File name contains non-graphic characters" );
- return( REDRAW );
- }
-
-
- if ( access( filename, F_OK ) == 0 )
- {
- Warning( "Will not overwrite file %s", filename );
- return( REDRAW );
- }
-
- if ( (f = fopen( filename, "w" )) == NULL )
- {
- Warning( "Can not open file %s", filename );
- return( REDRAW );
- }
-
- /* If there is already an open output file then */
- /* close it. If it was never written to then */
- /* remove its directory entry. */
-
- if ( s->file_name[0] != '\0' )
- {
- if ( ! s->file_written )
- unlink( s->file_name );
-
- fclose( s->file_f );
- }
-
- strcpy( s->file_name, filename );
- s->file_f = f;
- s->file_written = 0;
-
- return( OK );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Get_Count() */
-/* */
-/* Read and check a number. Returns non-zero */
-/* if successful. */
-/* */
-/****************************************************************/
-
-
-int Get_Count( units, result )
- char *units;
- unsigned long *result;
-
- {
- char *number;
-
- Draw_Prompt( units );
-
- number = Get_Line();
-
- if ( number == NULL || number[0] == '\0' )
- return( 0 );
-
- errno = 0;
- *result = strtoul( number, (char **) NULL, 0 );
- return( errno == 0 );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* In_Use( bit, map ) */
-/* */
-/* Is the bit set in the map? */
-/* */
-/****************************************************************/
-
-
-int In_Use( bit, map )
- bit_t bit;
- bitchunk_t *map;
-
- {
- return( map[ (int) (bit / (CHAR_BIT * sizeof (bitchunk_t))) ] &
- (1 << ((unsigned) bit % (CHAR_BIT * sizeof (bitchunk_t)))) );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Find_Inode( state, filename ) */
-/* */
-/* Find the i-node for the given file name. */
-/* */
-/****************************************************************/
-
-
-ino_t Find_Inode( s, filename )
- de_state *s;
- char *filename;
-
- {
- struct stat device_stat;
- struct stat file_stat;
- ino_t inode;
-
-
- if ( fstat( s->device_d, &device_stat ) == -1 )
- Error( "Can not fstat(2) file system device" );
-
-#ifdef S_IFLNK
- if ( lstat( filename, &file_stat ) == -1 )
-#else
- if ( stat( filename, &file_stat ) == -1 )
-#endif
- {
- Warning( "Can not find file %s", filename );
- return( 0 );
- }
-
- if ( device_stat.st_rdev != file_stat.st_dev )
- {
- Warning( "File is not on device %s", s->device_name );
- return( 0 );
- }
-
-
- inode = file_stat.st_ino;
-
- if ( inode < 1 || inode > s->inodes )
- {
- Warning( "Illegal i-node number" );
- return( 0 );
- }
-
- return( inode );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Exec_Shell() */
-/* */
-/* Fork off a sub-process to exec() the shell. */
-/* */
-/****************************************************************/
-
-
-void Exec_Shell()
-
- {
- int pid = fork();
-
- if ( pid == -1 )
- return;
-
-
- if ( pid == 0 )
- {
- /* The child process */
-
- extern char **environ;
- char *shell = getenv( "SHELL" );
-
- if ( shell == NULL )
- shell = "/bin/sh";
-
- execle( shell, shell, (char *) 0, environ );
-
- perror( shell );
- exit( 127 );
- }
-
-
- /* The parent process: ignore signals, wait for sub-process */
-
- signal( SIGINT, SIG_IGN );
- signal( SIGQUIT, SIG_IGN );
-
- {
- int status;
- int w;
-
- while ( (w=wait(&status)) != pid && w != -1 );
- }
-
- signal( SIGINT, Sigint );
- signal( SIGQUIT, Sigint );
-
- return;
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Sigint() */
-/* */
-/* Terminate the program on an interrupt (^C) */
-/* or quit (^\) signal. */
-/* */
-/****************************************************************/
-
-
-void Sigint(n)
-int n;
- {
- Reset_Term(); /* Restore terminal characteristics */
-
- putchar( '\n' );
-
- exit( 1 );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Error( text, ... ) */
-/* */
-/* Print an error message on stderr. */
-/* */
-/****************************************************************/
-
-
-#if __STDC__
-void Error( const char *text, ... )
-#else
-void Error( text )
- char *text;
-#endif
-
- {
- va_list argp;
-
- Reset_Term();
-
- fprintf( stderr, "\nde: " );
- va_start( argp, text );
- vfprintf( stderr, text, argp );
- va_end( argp );
- if ( errno != 0 )
- fprintf( stderr, ": %s", strerror( errno ) );
- fprintf( stderr, "\n" );
-
- exit( 1 );
- }
+++ /dev/null
-/****************************************************************/
-/* */
-/* de.h */
-/* */
-/* Definitions for the "Disk editor". */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-15 Terrence W. Holm */
-/****************************************************************/
-
-
-/****************************************************************/
-/* */
-/* de(1) */
-/* */
-/* This is the MINIX disk editor. It allows the user to */
-/* observe and modify a file system. It can also be used */
-/* to recover unlink(2)'ed files */
-/* */
-/* See the de(1) man page. */
-/* */
-/****************************************************************/
-
-
-/****************************************************************/
-/* */
-/* de Copyright Terrence W. Holm 1989 */
-/* */
-/* This program was written for users of the Minix operating */
-/* system, and in the spirit of other public domain software */
-/* written for said system, this source code is made available */
-/* at no cost to everyone. I assume no responsibility for */
-/* damage to file systems caused by this program. */
-/* */
-/* This program (one .h, five .c's and a "man" page) may be */
-/* copied and/or modified subject to (1) no charge must be */
-/* made for distribution, other than for the medium, (2) all */
-/* modified sources must be clearly marked as such, (3) all */
-/* sources must carry this copyright. */
-/* */
-/****************************************************************/
-
-
-/****************************************************************/
-/* */
-/* files */
-/* */
-/* de.h Definitions */
-/* de.c The main loop */
-/* de_stdin.c Character input routines */
-/* de_stdout.c Output routines */
-/* de_diskio.c File system read/write */
-/* de_recover.c File restoration routines */
-/* */
-/* de.1 "Man" page */
-/* Makefile For "make" */
-/* README Installation help */
-/* */
-/* */
-/* fs/path.c was modified to support the 'x' command. */
-/* fs/link.c and fs/open.c were changed for 'X'. */
-/* */
-/****************************************************************/
-#undef printf
-#include <stdio.h>
-#include <dirent.h>
-
-/* General constants */
-
-#define MAX_STRING 60 /* For all input lines */
-#define MAX_PREV 8 /* For 'p' command */
-#define SEARCH_BUFFER (4*K) /* For '/' and 'n' */
-
-
-/* Files */
-
-#define TMP "/tmp" /* For "-r" output */
-#define DEV "/dev" /* Where devices are */
-
-
-/* a.out header constants (see a.out.h, if you have it) */
-
-#if (_MINIX_CHIP == _CHIP_INTEL)
-#define A_OUT 0x0301
-#define SPLIT 0x0420
-#else
-#error only chip == intel is reasonable.
-#endif
-
-/* Each buffer is 1k. In WORD mode 16 words (32 bytes) can be */
-/* displayed at once. In BLOCK mode 1K bytes can be displayed. */
-/* In MAP mode 2048 bits (256 bytes) are displayed. */
-
-#define K 1024 /* STD_BLK */
-#define K_MASK (~(K-1)) /* Round to K boundary */
-#define K_SHIFT 10 /* Ie. 1<<10 = K */
-#ifdef __NBSD_LIBC
-/* Name pollution with more famous macros describing machine's
- * page size. These defs should be renamed. */
-#undef PAGE_MASK
-#undef PAGE_SHIFT
-#endif /* __NBSD_LIBC */
-#define PAGE_MASK 0x1f /* Word mode: 32 bytes */
-#define PAGE_SHIFT 5 /* Ie. 1<<5 = 32 */
-#define MAP_BITS_PER_BLOCK (8 * K) /* 1k block, 8192 bits */
-#define MAP_MASK 0xff /* 256 bytes/screen */
-
-
-
-/* Terminal i/o codes */
-
-#define CTRL_D '\004' /* ASCII ^D */
-#define BELL '\007' /* ASCII bell code */
-#define BS '\010' /* ASCII back space */
-#define CTRL_U '\025' /* ASCII ^U */
-#define ESCAPE '\033' /* ASCII escape code */
-#define DEL '\177' /* ASCII delete code */
-
-
-/* Input escape codes generated by the Minix console. */
-/* Format: ESC [ X. */
-
-#define ESC_HOME ('H' + 0x80)
-#define ESC_UP ('A' + 0x80)
-#define ESC_PGUP ('V' + 0x80)
-#define ESC_LEFT ('D' + 0x80)
-#define ESC_5 ('G' + 0x80)
-#define ESC_RIGHT ('C' + 0x80)
-#define ESC_END ('Y' + 0x80)
-#define ESC_DOWN ('B' + 0x80)
-#define ESC_PGDN ('U' + 0x80)
-#define ESC_PLUS ('T' + 0x80)
-#define ESC_MINUS ('S' + 0x80)
-
-
-/* Graphic box codes - only applicable for console display */
-/* in visual mode "map". */
-
-#if (CHIP == INTEL)
-#define BOX_CLR ' ' /* Empty box */
-#define BOX_ALL '\333' /* Filled box */
-#define BOX_TOP '\337' /* Filled upper half */
-#define BOX_BOT '\334' /* Filled lower half */
-#endif
-
-/* Move positions for the output display. */
-
-#define STATUS_COLUMN 2
-#define STATUS_LINE 0
-#define BLOCK_COLUMN 4
-#define BLOCK_LINE 4
-#define INFO_COLUMN 30
-#define INFO_LINE BLOCK_LINE
-#define PROMPT_COLUMN 0
-#define PROMPT_LINE 23
-#define WARNING_COLUMN 5
-#define WARNING_LINE 10
-
-
-
-/* Values returned by Process() and Get_Filename() */
-
-#define OK 0 /* No update required */
-#define REDRAW 1 /* Redraw whole screen */
-#define REDRAW_POINTERS 2 /* Redraw just ptrs */
-#define ERROR 3 /* Beep */
-
-
-/* Visual modes */
-
-#define WORD 1
-#define BLOCK 2
-#define MAP 3
-
-typedef unsigned short word_t; /* For most user i/o */
-#if _WORD_SIZE == 2
-typedef unsigned int Word_t; /* What it should always be */
-#else
-typedef int Word_t; /* Unsigned promotion under ANSI C */
-#endif
-
-#ifndef I_MAP_SLOTS
-/* Max number of inode and zone map blocks we can handle. */
-#define I_MAP_SLOTS 8
-#define Z_MAP_SLOTS (sizeof(char *) == 2 ? 16 : 128)
-#endif
-
-typedef struct de_state /* State of disk ed. */
- {
- /* Information from super block */
- /* The types here are mostly promoted types for simplicity */
- /* and efficiency. */
-
- unsigned inodes; /* Number of i-nodes */
- zone_t zones; /* Total # of blocks */
- unsigned inode_maps; /* I-node map blocks */
- unsigned zone_maps; /* Zone map blocks */
- unsigned inode_blocks; /* I-node blocks */
- unsigned first_data; /* Total non-data blks */
- int magic; /* Magic number */
-
- /* Numbers derived from the magic number */
-
- unsigned char is_fs; /* Nonzero for good fs */
- unsigned char v1; /* Nonzero for V1 fs */
- unsigned inode_size; /* Size of disk inode */
- unsigned nr_indirects; /* # indirect blocks */
- unsigned zone_num_size; /* Size of disk z num */
- int block_size; /* FS block size */
-
- /* Other derived numbers */
-
- bit_t inodes_in_map; /* Bits in i-node map */
- bit_t zones_in_map; /* Bits in zone map */
- int ndzones; /* # direct zones in an inode */
-
- /* Information from map blocks */
-
- bitchunk_t inode_map[ I_MAP_SLOTS * K / sizeof (bitchunk_t) ];
- bitchunk_t zone_map[ Z_MAP_SLOTS * K / sizeof (bitchunk_t) ];
-
- /* Information for current block */
-
- off_t address; /* Current address */
- off_t last_addr; /* For erasing ptrs */
- zone_t block; /* Current block (1K) */
- unsigned offset; /* Offset within block */
-
- char buffer[ _MAX_BLOCK_SIZE ];
-
- /* Display state */
-
- int mode; /* WORD, BLOCK or MAP */
- int output_base; /* 2, 8, 10, or 16 */
-
- /* Search information */
-
- char search_string[ MAX_STRING + 1 ]; /* For '/' and 'n' */
- off_t prev_addr[ MAX_PREV ]; /* For 'p' command */
- int prev_mode[ MAX_PREV ];
-
- /* File information */
-
- char *device_name; /* From command line */
- int device_d;
- int device_mode; /* O_RDONLY or O_RDWR */
- zone_t device_size; /* Number of blocks */
-
- char file_name[ MAX_STRING + 1 ]; /* For 'w' and 'W' */
- FILE *file_f;
- int file_written; /* Flag if written to */
-
- } de_state;
-
-
-
-/* Forward references for external routines */
-
-/* de.c */
-
-_PROTOTYPE(int main , (int argc , char *argv []));
-_PROTOTYPE(int Process , (de_state *s , int c ));
-
-#if __STDC__
-void Error( const char *text, ... );
-#else
-void Error();
-#endif
-
-_PROTOTYPE(int In_Use , (bit_t bit , bitchunk_t *map ));
-_PROTOTYPE(ino_t Find_Inode , (de_state *s , char *filename ));
-
-
-/* de_stdin.c */
-
-_PROTOTYPE(void Save_Term , (void));
-_PROTOTYPE(void Set_Term , (void));
-_PROTOTYPE(void Reset_Term , (void));
-_PROTOTYPE(int Get_Char , (void));
-_PROTOTYPE(char *Get_Line , (void));
-_PROTOTYPE(int Arrow_Esc , (int c ));
-
-/* de_stdout.c */
-
-_PROTOTYPE(int Init_Termcap , (void));
-_PROTOTYPE(void Draw_Help_Screen , (de_state *s ));
-_PROTOTYPE(void Wait_For_Key , (void));
-_PROTOTYPE(void Draw_Prompt , (char *string ));
-_PROTOTYPE(void Erase_Prompt , (void));
-
-_PROTOTYPE(void Draw_Screen , (de_state *s ));
-_PROTOTYPE(void Draw_Strings , (de_state *s ));
-_PROTOTYPE(void Draw_Pointers , (de_state *s ));
-_PROTOTYPE(void Print_Ascii , (int c ));
-
-_PROTOTYPE(void Goto , (int column , int line ));
-_PROTOTYPE(void Block_Type , (de_state *s ));
-_PROTOTYPE(void Draw_Words , (de_state *s ));
-_PROTOTYPE(void Draw_Info , (de_state *s ));
-_PROTOTYPE(void Draw_Block , (char *block ));
-_PROTOTYPE(void Draw_Map , (char *block , int max_bits ));
-_PROTOTYPE(void Draw_Offset , (de_state *s ));
-_PROTOTYPE(void Word_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Block_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Map_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Print_Number , (Word_t number , int output_base ));
-_PROTOTYPE(void Draw_Zone_Numbers , (de_state *s , struct inode *inode ,
- int zindex , int zrow ));
-
-#if __STDC__
-void Warning( const char *text, ... );
-#else
-void Warning();
-#endif
-
-
-/* de_diskio.c */
-
-_PROTOTYPE(void Read_Disk , (de_state *s , off_t block_addr , char *buffer ));
-_PROTOTYPE(void Read_Block , (de_state *s , char *buffer ));
-_PROTOTYPE(void Read_Super_Block , (de_state *s ));
-_PROTOTYPE(void Read_Bit_Maps , (de_state *s ));
-_PROTOTYPE(off_t Search , (de_state *s , char *string ));
-_PROTOTYPE(void Write_Word , (de_state *s , Word_t word ));
-
-
-/* de_recover.c */
-
-_PROTOTYPE(int Path_Dir_File , (char *path_name , char **dir_name ,
- char **file_name ));
-_PROTOTYPE(char *File_Device , (char *file_name ));
-_PROTOTYPE(ino_t Find_Deleted_Entry , (de_state *s , char *path_name ));
-_PROTOTYPE(off_t Recover_Blocks , (de_state *s ));
-
-
-#undef printf /* Because fs/const.h */
- /* defines it. */
-
-
-/* Static functions are all pre-declared FORWARD but none are */
-/* declared static yet - this can wait until all functions are */
-/* declared with prototypes. */
-
-#undef FORWARD
-#define FORWARD /* static */
+++ /dev/null
-/****************************************************************/
-/* */
-/* de_diskio.c */
-/* */
-/* Reading and writing to a file system device. */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-15 Terrence W. Holm */
-/****************************************************************/
-
-
-#include <minix/config.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <limits.h>
-#include <string.h>
-#include <dirent.h>
-
-#include <minix/const.h>
-#include <minix/type.h>
-#include "mfs/const.h"
-#include "mfs/type.h"
-#include "mfs/super.h"
-#include "mfs/inode.h"
-#include <minix/fslib.h>
-
-#include "de.h"
-
-
-
-
-/****************************************************************/
-/* */
-/* Read_Disk( state, block_addr, buffer ) */
-/* */
-/* Reads a 1k block at "block_addr" into "buffer". */
-/* */
-/****************************************************************/
-
-
-void Read_Disk( s, block_addr, buffer )
- de_state *s;
- off_t block_addr;
- char *buffer;
-
- {
- if ( lseek( s->device_d, block_addr, SEEK_SET ) == -1 )
- Error( "Error seeking %s", s->device_name );
-
- if ( read( s->device_d, buffer, s->block_size ) != s->block_size )
- Error( "Error reading %s", s->device_name );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Read_Block( state, buffer ) */
-/* */
-/* Reads a 1k block from "state->address" into */
-/* "buffer". Checks "address", and updates */
-/* "block" and "offset". */
-/* */
-/****************************************************************/
-
-
-void Read_Block( s, buffer )
- de_state *s;
- char *buffer;
-
- {
- off_t end_addr;
- off_t block_addr;
- end_addr = (long) s->device_size * s->block_size - 1;
-
- if ( s->address < 0 )
- s->address = 0L;
-
- if ( s->address > end_addr )
- s->address = end_addr;
-
- /* The address must be rounded off for */
- /* certain visual display modes. */
-
- if ( s->mode == WORD )
- s->address &= ~1L;
- else if ( s->mode == MAP )
- s->address &= ~3L;
-
-
- block_addr = s->address & K_MASK;
-
- s->block = (zone_t) (block_addr >> K_SHIFT);
- s->offset = (unsigned) (s->address - block_addr);
-
- Read_Disk( s, block_addr, buffer );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Read_Super_Block( state ) */
-/* */
-/* Read and check the super block. */
-/* */
-/****************************************************************/
-
-
-void Read_Super_Block( s )
- de_state *s;
-
- {
- struct super_block *super = (struct super_block *) s->buffer;
- unsigned inodes_per_block;
- off_t size;
-
- s->block_size = K;
- Read_Disk( s, (long) SUPER_BLOCK_BYTES, s->buffer );
-
- s->magic = super->s_magic;
- if ( s->magic == SUPER_MAGIC )
- {
- s->is_fs = TRUE;
- s->v1 = TRUE;
- s->inode_size = V1_INODE_SIZE;
- inodes_per_block = V1_INODES_PER_BLOCK;
- s->nr_indirects = V1_INDIRECTS;
- s->zone_num_size = V1_ZONE_NUM_SIZE;
- s->zones = super->s_nzones;
- s->ndzones = V1_NR_DZONES;
- s->block_size = _STATIC_BLOCK_SIZE;
- }
- else if ( s->magic == SUPER_V2 || s->magic == SUPER_V3)
- {
- if(s->magic == SUPER_V3)
- s->block_size = super->s_block_size;
- else
- s->block_size = _STATIC_BLOCK_SIZE;
- s->is_fs = TRUE;
- s->v1 = FALSE;
- s->inode_size = V2_INODE_SIZE;
- inodes_per_block = V2_INODES_PER_BLOCK(s->block_size);
- s->nr_indirects = V2_INDIRECTS(s->block_size);
- s->zone_num_size = V2_ZONE_NUM_SIZE;
- s->zones = super->s_zones;
- s->ndzones = V2_NR_DZONES;
- }
- else
- {
- if ( super->s_magic == SUPER_REV )
- Warning( "V1-bytes-swapped file system (?)" );
- else if ( super->s_magic == SUPER_V2_REV )
- Warning( "V2-bytes-swapped file system (?)" );
- else
- Warning( "Not a Minix file system" );
- Warning( "The file system features will not be available" );
- s->zones = 100000L;
- return;
- }
-
- s->inodes = super->s_ninodes;
- s->inode_maps = bitmapsize( (bit_t) s->inodes + 1 , s->block_size);
- if ( s->inode_maps != super->s_imap_blocks )
- {
- if ( s->inode_maps > super->s_imap_blocks )
- Error( "Corrupted inode map count or inode count in super block" );
- else
- Warning( "Count of inode map blocks in super block suspiciously high" );
- s->inode_maps = super->s_imap_blocks;
- }
-
- s->zone_maps = bitmapsize( (bit_t) s->zones , s->block_size);
- if ( s->zone_maps != super->s_zmap_blocks )
- {
- if ( s->zone_maps > super->s_zmap_blocks )
- Error( "Corrupted zone map count or zone count in super block" );
- else
- Warning( "Count of zone map blocks in super block suspiciously high" );
- s->zone_maps = super->s_zmap_blocks;
- }
-
- s->inode_blocks = (s->inodes + inodes_per_block - 1) / inodes_per_block;
- s->first_data = 2 + s->inode_maps + s->zone_maps + s->inode_blocks;
- if ( super->s_firstdatazone_old != 0 &&
- s->first_data != super->s_firstdatazone_old )
- {
- if ( s->first_data > super->s_firstdatazone_old )
- Error( "Corrupted first data zone offset or inode count in super block" );
- else
- Warning( "First data zone in super block suspiciously high" );
- s->first_data = super->s_firstdatazone_old;
- }
-
- s->inodes_in_map = s->inodes + 1;
- s->zones_in_map = s->zones + 1 - s->first_data;
-
- /*
- if ( s->zones != s->device_size )
- Warning( "Zone count does not equal device size" );
- */
-
- s->device_size = s->zones;
-
- if ( super->s_log_zone_size != 0 )
- Error( "Can not handle multiple blocks per zone" );
-}
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Read_Bit_Maps( state ) */
-/* */
-/* Read in the i-node and zone bit maps from the */
-/* specified file system device. */
-/* */
-/****************************************************************/
-
-
-void Read_Bit_Maps( s )
- de_state *s;
-
- {
- int i;
-
- if ( s->inode_maps > I_MAP_SLOTS || s->zone_maps > Z_MAP_SLOTS )
- {
- Warning( "Super block specifies too many bit map blocks" );
- return;
- }
-
- for ( i = 0; i < s->inode_maps; ++i )
- {
- Read_Disk( s, (long) (2 + i) * K,
- (char *) &s->inode_map[ i * K / sizeof (bitchunk_t ) ] );
- }
-
- for ( i = 0; i < s->zone_maps; ++i )
- {
- Read_Disk( s, (long) (2 + s->inode_maps + i) * K,
- (char *) &s->zone_map[ i * K / sizeof (bitchunk_t ) ] );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Search( state, string ) */
-/* */
-/* Search from the current address for the ASCII */
-/* "string" on the device. */
-/* */
-/****************************************************************/
-
-
-off_t Search( s, string )
- de_state *s;
- char *string;
-
- {
- off_t address = s->address + 1;
- off_t last_addr = address;
- char buffer[ SEARCH_BUFFER ];
- int offset;
- int tail_length = strlen( string ) - 1;
- int count = SEARCH_BUFFER;
- int last_offset;
-
-
- for ( ; count == SEARCH_BUFFER; address += SEARCH_BUFFER - tail_length )
- {
- if ( lseek( s->device_d, address, SEEK_SET ) == -1 )
- Error( "Error seeking %s", s->device_name );
-
- if ( (count = read( s->device_d, buffer, SEARCH_BUFFER)) == -1 )
- Error( "Error reading %s", s->device_name );
-
-
- if ( address - last_addr >= 500L * K )
- {
- putchar( '.' );
- fflush( stdout );
-
- last_addr += 500L * K;
- }
-
-
- last_offset = count - tail_length;
-
- for ( offset = 0; offset < last_offset; ++offset )
- {
- register char c = buffer[ offset ];
-
- if ( c == *string )
- {
- char *tail_buffer = &buffer[ offset + 1 ];
- char *tail_string = string + 1;
-
- do
- {
- if ( *tail_string == '\0' )
- return( address + offset );
- }
- while ( *tail_buffer++ == *tail_string++ );
- }
- } /* end for ( offset ) */
- } /* end for ( address ) */
-
- return( -1L );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Write_Word( state, word ) */
-/* */
-/* Write a word at address. */
-/* */
-/****************************************************************/
-
-
-void Write_Word( s, word )
- de_state *s;
- word_t word;
-
- {
- if ( s->address & 01 )
- Error( "Internal fault (unaligned address)" );
-
- if ( lseek( s->device_d, s->address, SEEK_SET ) == -1 )
- Error( "Error seeking %s", s->device_name );
-
- if ( write( s->device_d, (char *) &word, sizeof word ) != sizeof word )
- Error( "Error writing %s", s->device_name );
- }
+++ /dev/null
-/****************************************************************/
-/* */
-/* de_recover.c */
-/* */
-/* File restoration routines. */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-21 Terrence W. Holm */
-/* handle "holes" 1989-Jan-28 Terrence W. Holm */
-/****************************************************************/
-
-
-#include <minix/config.h>
-#include <sys/types.h>
-#include <sys/dir.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <pwd.h>
-#include <string.h>
-#include <unistd.h>
-#include <dirent.h>
-
-#include <minix/const.h>
-#include <minix/type.h>
-#include "mfs/const.h"
-#include "mfs/type.h"
-#include "mfs/inode.h"
-#include <minix/fslib.h>
-
-#include "de.h"
-
-_PROTOTYPE(int Indirect, (de_state *s, zone_t block, off_t *size, int dblind));
-_PROTOTYPE(int Data_Block, (de_state *s, zone_t block, off_t *file_size ));
-_PROTOTYPE(int Free_Block, (de_state *s, zone_t block ));
-
-
-
-
-/****************************************************************/
-/* */
-/* Path_Dir_File( path_name, dir_name, file_name ) */
-/* */
-/* Split "path_name" into a directory name and */
-/* a file name. */
-/* */
-/* Zero is returned on error conditions. */
-/* */
-/****************************************************************/
-
-
-int Path_Dir_File( path_name, dir_name, file_name )
- char *path_name;
- char **dir_name;
- char **file_name;
-
- {
- char *p;
- static char directory[ MAX_STRING + 1 ];
- static char filename[ MAX_STRING + 1 ];
-
-
- if ( (p = strrchr( path_name, '/' )) == NULL )
- {
- strcpy( directory, "." );
- strcpy( filename, path_name );
- }
- else
- {
- *directory = '\0';
- strncat( directory, path_name, p - path_name );
- strcpy( filename, p + 1 );
- }
-
- if ( *directory == '\0' )
- strcpy( directory, "/" );
-
- if ( *filename == '\0' )
- {
- Warning( "A file name must follow the directory name" );
- return( 0 );
- }
-
- *dir_name = directory;
- *file_name = filename;
-
- return( 1 );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* File_Device( file_name ) */
-/* */
-/* Return the name of the file system device */
-/* containing the file "file_name". */
-/* */
-/* This is used if the "-r" option was specified. */
-/* In this case we have only been given a file */
-/* name, and must determine which file system */
-/* device to open. */
-/* */
-/* NULL is returned on error conditions. */
-/* */
-/****************************************************************/
-
-
-
-char *File_Device( file_name )
- char *file_name;
-
- {
- struct stat file_stat;
- struct stat device_stat;
- int dev_d;
- struct direct entry;
- static char device_name[ NAME_MAX + 1 ];
-
-
- if ( access( file_name, R_OK ) != 0 )
- {
- Warning( "Can not find %s", file_name );
- return( NULL );
- }
-
-
- if ( stat( file_name, &file_stat ) == -1 )
- {
- Warning( "Can not stat(2) %s", file_name );
- return( NULL );
- }
-
-
- /* Open /dev for reading */
-
- if ( (dev_d = open( DEV, O_RDONLY )) == -1 )
- {
- Warning( "Can not read %s", DEV );
- return( NULL );
- }
-
-
- while ( read( dev_d, (char *) &entry, sizeof(struct direct) )
- == sizeof(struct direct) )
- {
- if ( entry.d_ino == 0 )
- continue;
-
- strcpy( device_name, DEV );
- strcat( device_name, "/" );
- strncat( device_name, entry.d_name, NAME_MAX );
-
- if ( stat( device_name, &device_stat ) == -1 )
- continue;
-
- if ( (device_stat.st_mode & S_IFMT) != S_IFBLK )
- continue;
-
- if ( file_stat.st_dev == device_stat.st_rdev )
- {
- close( dev_d );
- return( device_name );
- }
- }
-
- close( dev_d );
-
- Warning( "The device containing file %s is not in %s", file_name, DEV );
-
- return( NULL );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Find_Deleted_Entry( state, path_name ) */
-/* */
-/* Split "path_name" into a directory name and */
-/* a file name. Then search the directory for */
-/* an entry that would match the deleted file */
-/* name. (Deleted entries have a zero i-node */
-/* number, but the original i-node number is */
-/* placed at the end of the file name.) */
-/* */
-/* If successful an i-node number is returned, */
-/* else zero is returned. */
-/* */
-/****************************************************************/
-
-
-ino_t Find_Deleted_Entry( s, path_name )
- de_state *s;
- char *path_name;
-
- {
- char *dir_name;
- char *file_name;
-
-
- /* Check if the file exists */
-
- if ( access( path_name, F_OK ) == 0 )
- {
- Warning( "File has not been deleted" );
- return( 0 );
- }
-
-
- /* Split the path name into a directory and a file name */
-
- if ( ! Path_Dir_File( path_name, &dir_name, &file_name ) )
- return( 0 );
-
-
- /* Check to make sure the user has read permission on */
- /* the directory. */
-
- if ( access( dir_name, R_OK ) != 0 )
- {
- Warning( "Can not find %s", dir_name );
- return( 0 );
- }
-
-
- /* Make sure "dir_name" is really a directory. */
- {
- struct stat dir_stat;
-
- if ( stat( dir_name, &dir_stat ) == -1 ||
- (dir_stat.st_mode & S_IFMT) != S_IFDIR )
- {
- Warning( "Can not find directory %s", dir_name );
- return( 0 );
- }
- }
-
-
- /* Make sure the directory is on the current */
- /* file system device. */
-
- if ( Find_Inode( s, dir_name ) == 0 )
- return( 0 );
-
-
- /* Open the directory and search for the lost file name. */
- {
- int dir_d;
- int count;
- struct direct entry;
-
- if ( (dir_d = open( dir_name, O_RDONLY )) == -1 )
- {
- Warning( "Can not read directory %s", dir_name );
- return( 0 );
- }
-
- while ( (count = read( dir_d, (char *) &entry, sizeof(struct direct) ))
- == sizeof(struct direct) )
- {
- if ( entry.d_ino == 0 &&
- strncmp( file_name, entry.d_name, NAME_MAX - sizeof(ino_t) ) == 0 )
- {
- ino_t inode = *( (ino_t *) &entry.d_name[ NAME_MAX - sizeof(ino_t) ] );
-
- close( dir_d );
-
- if ( inode < 1 || inode > s->inodes )
- {
- Warning( "Illegal i-node number" );
- return( 0 );
- }
-
- return( inode );
- }
- }
-
- close( dir_d );
-
- if ( count == 0 )
- Warning( "Can not find a deleted entry for %s", file_name );
- else
- Warning( "Problem reading directory %s", dir_name );
-
- return( 0 );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Recover_Blocks( state ) */
-/* */
-/* Try to recover all the blocks for the i-node */
-/* currently pointed to by "s->address". The */
-/* i-node and all of the blocks must be marked */
-/* as FREE in the bit maps. The owner of the */
-/* i-node must match the current real user name. */
-/* */
-/* "Holes" in the original file are maintained. */
-/* This allows moving sparse files from one device */
-/* to another. */
-/* */
-/* On any error -1L is returned, otherwise the */
-/* size of the recovered file is returned. */
-/* */
-/* */
-/* NOTE: Once a user has read access to a device, */
-/* there is a security hole, as we lose the */
-/* normal file system protection. For convenience, */
-/* de(1) is sometimes set-uid root, this allows */
-/* anyone to use the "-r" option. When recovering, */
-/* Recover_Blocks() can only superficially check */
-/* the validity of a request. */
-/* */
-/****************************************************************/
-
-
-off_t Recover_Blocks( s )
- de_state *s;
-
- {
- struct inode core_inode;
- d1_inode *dip1;
- d2_inode *dip2;
- struct inode *inode = &core_inode;
- bit_t node = (s->address - (s->first_data - s->inode_blocks) * K) /
- s->inode_size + 1;
-
- dip1 = (d1_inode *) &s->buffer[ s->offset & ~ PAGE_MASK ];
- dip2 = (d2_inode *) &s->buffer[ s->offset & ~ PAGE_MASK
- & ~ (V2_INODE_SIZE-1) ];
- conv_inode( inode, dip1, dip2, READING, s->magic );
-
- if ( s->block < s->first_data - s->inode_blocks ||
- s->block >= s->first_data )
- {
- Warning( "Not in an inode block" );
- return( -1L );
- }
-
-
- /* Is this a valid, but free i-node? */
-
- if ( node > s->inodes )
- {
- Warning( "Not an inode" );
- return( -1L );
- }
-
- if ( In_Use(node, s->inode_map) )
- {
- Warning( "I-node is in use" );
- return( -1L );
- }
-
-
- /* Only recover files that belonged to the real user. */
-
- {
- uid_t real_uid = getuid();
- struct passwd *user = getpwuid( real_uid );
-
- if ( real_uid != SU_UID && real_uid != inode->i_uid )
- {
- Warning( "I-node did not belong to user %s", user ? user->pw_name : "" );
- return( -1L );
- }
- }
-
-
- /* Recover all the blocks of the file. */
-
- {
- off_t file_size = inode->i_size;
- int i;
-
-
- /* Up to s->ndzones pointers are stored in the i-node. */
-
- for ( i = 0; i < s->ndzones; ++i )
- {
- if ( file_size == 0 )
- return( inode->i_size );
-
- if ( ! Data_Block( s, inode->i_zone[ i ], &file_size ) )
- return( -1L );
- }
-
- if ( file_size == 0 )
- return( inode->i_size );
-
-
- /* An indirect block can contain up to inode->i_indirects more blk ptrs. */
-
- if ( ! Indirect( s, inode->i_zone[ s->ndzones ], &file_size, 0 ) )
- return( -1L );
-
- if ( file_size == 0 )
- return( inode->i_size );
-
-
- /* A double indirect block can contain up to inode->i_indirects blk ptrs. */
-
- if ( ! Indirect( s, inode->i_zone[ s->ndzones+1 ], &file_size, 1 ) )
- return( -1L );
-
- if ( file_size == 0 )
- return( inode->i_size );
-
- Error( "Internal fault (file_size != 0)" );
- }
-
- /* NOTREACHED */
- return( -1L );
- }
-
-
-
-
-
-
-/* Indirect( state, block, &file_size, double )
- *
- * Recover all the blocks pointed to by the indirect block
- * "block", up to "file_size" bytes. If "double" is true,
- * then "block" is a double-indirect block pointing to
- * V*_INDIRECTS indirect blocks.
- *
- * If a "hole" is encountered, then just seek ahead in the
- * output file.
- */
-
-
-int Indirect( s, block, file_size, dblind )
- de_state *s;
- zone_t block;
- off_t *file_size;
- int dblind;
-
- {
- union
- {
- zone1_t ind1[ V1_INDIRECTS ];
- zone_t ind2[ V2_INDIRECTS(_MAX_BLOCK_SIZE) ];
- } indirect;
- int i;
- zone_t zone;
-
- /* Check for a "hole". */
-
- if ( block == NO_ZONE )
- {
- off_t skip = (off_t) s->nr_indirects * K;
-
- if ( *file_size < skip || dblind )
- {
- Warning( "File has a hole at the end" );
- return( 0 );
- }
-
- if ( fseek( s->file_f, skip, SEEK_CUR ) == -1 )
- {
- Warning( "Problem seeking %s", s->file_name );
- return( 0 );
- }
-
- *file_size -= skip;
- return( 1 );
- }
-
-
- /* Not a "hole". Recover indirect block, if not in use. */
-
- if ( ! Free_Block( s, block ) )
- return( 0 );
-
-
- Read_Disk( s, (long) block << K_SHIFT, (char *) &indirect );
-
- for ( i = 0; i < s->nr_indirects; ++i )
- {
- if ( *file_size == 0 )
- return( 1 );
-
- zone = (s->v1 ? indirect.ind1[ i ] : indirect.ind2[ i ]);
- if ( dblind )
- {
- if ( ! Indirect( s, zone, file_size, 0 ) )
- return( 0 );
- }
- else
- {
- if ( ! Data_Block( s, zone, file_size ) )
- return( 0 );
- }
- }
-
- return( 1 );
- }
-
-
-
-
-
-
-/* Data_Block( state, block, &file_size )
- *
- * If "block" is free then write Min(file_size, k)
- * bytes from it onto the current output file.
- *
- * If "block" is zero, this means that a 1k "hole"
- * is in the file. The recovered file maintains
- * the reduced size by not allocating the block.
- *
- * The file size is decremented accordingly.
- */
-
-
-int Data_Block( s, block, file_size )
- de_state *s;
- zone_t block;
- off_t *file_size;
-
- {
- char buffer[ K ];
- off_t block_size = *file_size > K ? K : *file_size;
-
-
- /* Check for a "hole". */
-
- if ( block == NO_ZONE )
- {
- if ( block_size < K )
- {
- Warning( "File has a hole at the end" );
- return( 0 );
- }
-
- if ( fseek( s->file_f, block_size, SEEK_CUR ) == -1 )
- {
- Warning( "Problem seeking %s", s->file_name );
- return( 0 );
- }
-
- *file_size -= block_size;
- return( 1 );
- }
-
-
- /* Block is not a "hole". Copy it to output file, if not in use. */
-
- if ( ! Free_Block( s, block ) )
- return( 0 );
-
- Read_Disk( s, (long) block << K_SHIFT, buffer );
-
-
- if ( fwrite( buffer, 1, (size_t) block_size, s->file_f )
- != (size_t) block_size )
- {
- Warning( "Problem writing %s", s->file_name );
- return( 0 );
- }
-
- *file_size -= block_size;
- return( 1 );
- }
-
-
-
-
-
-
-/* Free_Block( state, block )
- *
- * Make sure "block" is a valid data block number, and it
- * has not been allocated to another file.
- */
-
-
-int Free_Block( s, block )
- de_state *s;
- zone_t block;
-
- {
- if ( block < s->first_data || block >= s->zones )
- {
- Warning( "Illegal block number" );
- return( 0 );
- }
-
- if ( In_Use( (bit_t) (block - (s->first_data - 1)), s->zone_map ) )
- {
- Warning( "Encountered an \"in use\" data block" );
- return( 0 );
- }
-
- return( 1 );
- }
-
+++ /dev/null
-/****************************************************************/
-/* */
-/* de_stdin.c */
-/* */
-/* Processing input from the "de" user. */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-15 Terrence W. Holm */
-/****************************************************************/
-
-
-#include <sys/types.h>
-#include <termios.h>
-#include <signal.h>
-#include <unistd.h>
-#include <stdio.h>
-
-#include <minix/config.h>
-#include <minix/const.h>
-#include "mfs/const.h"
-#include "mfs/inode.h"
-
-#include "de.h"
-
-FORWARD _PROTOTYPE(int Timed_Get_Char , (int time ));
-FORWARD _PROTOTYPE(void Timed_Out , (int sig));
-
-
-
-
-/****************************************************************/
-/* */
-/* Save_Term() */
-/* */
-/* Save the current terminal characteristics. */
-/* */
-/* */
-/* Set_Term() */
-/* */
-/* Set up the terminal characteristics. */
-/* */
-/* */
-/* Reset_Term() */
-/* */
-/* Restore the terminal characteristics. */
-/* */
-/****************************************************************/
-
-
-static struct termios saved_term;
-
-
-void Save_Term()
-
- {
- tcgetattr( 0, &saved_term );
- }
-
-
-
-
-void Set_Term()
-
- {
- struct termios term;
-
- term = saved_term;
-
-
- /* No tab expansion, no echo, don't map ^M to ^J, cbreak mode */
-
- term.c_iflag &= ~ICRNL;
- term.c_oflag &= ~OPOST;
- term.c_lflag &= ~ICANON & ~ECHO;
-
-
- /* Change the interrupt character to ^C */
-
- term.c_cc[VINTR] = '\003';
-
- tcsetattr( 0, TCSANOW, &term );
- }
-
-
-
-
-void Reset_Term()
-
- {
- tcsetattr( 0, TCSANOW, &saved_term );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Get_Char() */
-/* */
-/* Return the next input character. Escape */
-/* sequences are mapped to special codes. */
-/* */
-/****************************************************************/
-
-
-int Get_Char()
- {
- int c;
- static int unget_char = EOF;
-
-
- /* Flush the output to the screen before waiting */
- /* for input from the user. */
-
- fflush( stdout );
-
- if ( unget_char == EOF )
- {
- while ( (c = Timed_Get_Char( 60 * 60 )) < EOF )
- printf( "%c", BELL );
- }
- else
- {
- c = unget_char;
- unget_char = EOF;
- }
-
- if ( c == EOF )
- return( EOF );
-
- if ( c != ESCAPE )
- return( c );
-
- if ( (c = Timed_Get_Char( 1 )) <= EOF )
- return( ESCAPE );
-
- if ( c != '[' )
- {
- unget_char = c;
- return( ESCAPE );
- }
-
- if ( (c = Timed_Get_Char( 1 )) <= EOF )
- {
- unget_char = '[';
- return( ESCAPE );
- }
-
- return( c | 0x80 ); /* Flag ESC [ x */
- }
-
-
-
-
-
-
-int Timed_Get_Char( time )
- int time;
-
- {
- char c;
- int count;
-
- signal( SIGALRM, Timed_Out );
-
- alarm( time );
- count = read( 0, &c, 1 );
- alarm( 0 );
-
- if ( count <= 0 )
- return( EOF + count );
-
- return( c & 0x7f );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Get_Line() */
-/* */
-/* Read a line from the user. Returns a pointer */
-/* to a local buffer, or NULL if DEL or a non- */
-/* ASCII character was typed. Processes ^H and */
-/* ^U. ^M terminates the input. */
-/* */
-/****************************************************************/
-
-
-char *Get_Line()
-
- {
- int c;
- int i;
- static char line[ MAX_STRING + 1 ];
-
- for ( i = 0; i <= MAX_STRING; ++i )
- {
- c = Get_Char();
-
- if ( c == EOF || c == DEL || (c & 0x80) )
- return( NULL );
-
- if ( c == BS )
- {
- if ( --i >= 0 )
- {
- printf( "\b \b" );
- --i;
- }
- }
-
- else if ( c == CTRL_U )
- {
- for ( --i; i >= 0; --i )
- printf( "\b \b" );
- }
-
- else if ( c == '\r' )
- {
- line[ i ] = '\0';
- return( line );
- }
-
- else if ( i < MAX_STRING )
- {
- line[ i ] = c;
- Print_Ascii( c );
- }
-
- else /* Line buffer is full, don't add any more to it. */
- {
- putchar( BELL );
- --i;
- }
- }
-
- Error( "Internal fault (line buffer overflow)" );
-
- /* NOTREACHED */
- return( NULL );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Arrow_Esc( char ) */
-/* */
-/* If the keyboard does not generate Ansi escape */
-/* codes for the arrow keys, but does generate */
-/* single byte control codes, then map these */
-/* codes to the special characters we are using */
-/* to denote the Ansi escape codes. */
-/* */
-/****************************************************************/
-
-
-extern char Kup; /* (ku) - Up arrow key */
-extern char Kdown; /* (kd) - Down arrow key */
-extern char Kleft; /* (kl) - Left arrow key */
-extern char Kright; /* (kr) - Right arrow key */
-
-
-int Arrow_Esc( c )
- int c;
-
- {
- if ( c == Kup )
- return( ESC_UP );
-
- if ( c == Kdown )
- return( ESC_DOWN );
-
- if ( c == Kleft )
- return( ESC_LEFT );
-
- if ( c == Kright )
- return( ESC_RIGHT );
-
- return( c );
- }
-
-void Timed_Out(sig)
-int sig;
- {}
-
-/*
- * $PchHeader: /mount/hd2/minix/sys/cmd/de/RCS/de_stdin.c,v 1.3 1995/02/10 08:01:30 philip Exp $
- */
+++ /dev/null
-/****************************************************************/
-/* */
-/* de_stdout.c */
-/* */
-/* Displaying information from the "Disk editor". */
-/* */
-/****************************************************************/
-/* origination 1989-Jan-15 Terrence W. Holm */
-/****************************************************************/
-
-
-#include <minix/config.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <grp.h>
-#include <pwd.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <termcap.h>
-#include <time.h>
-#include <unistd.h>
-
-#include <minix/const.h>
-#include <minix/type.h>
-#include "mfs/const.h"
-#include "mfs/type.h"
-#include "mfs/inode.h"
-#include <minix/fslib.h>
-
-#include "de.h"
-
-#ifndef major
-#define major(x) ( (x>>8) & 0377)
-#define minor(x) (x & 0377)
-#endif
-
-/****************************************************************/
-/* Code for handling termcap */
-/****************************************************************/
-
-
-#define TC_BUFFER 1024 /* Size of termcap(3) buffer */
-#define TC_STRINGS 200 /* Enough room for cm,cl,so,se */
-
-
-static char *Tmove; /* (cm) - Format for tgoto */
-static char *Tclr_all; /* (cl) - Clear screen */
-static char *Treverse; /* (so) - Start reverse mode */
-static char *Tnormal; /* (se) - End reverse mode */
-
-char Kup = 0; /* (ku) - Up arrow key */
-char Kdown = 0; /* (kd) - Down arrow key */
-char Kleft = 0; /* (kl) - Left arrow key */
-char Kright = 0; /* (kr) - Right arrow key */
-
-_PROTOTYPE(void Goto , (int column , int line ));
-_PROTOTYPE(void Block_Type , (de_state *s ));
-_PROTOTYPE(void Draw_Words , (de_state *s ));
-_PROTOTYPE(void Draw_Info , (de_state *s ));
-_PROTOTYPE(void Draw_Block , (char *block ));
-_PROTOTYPE(void Draw_Map , (char *block , int max_bits ));
-_PROTOTYPE(void Draw_Offset , (de_state *s ));
-_PROTOTYPE(void Word_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Block_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Map_Pointers , (off_t old_addr , off_t new_addr ));
-_PROTOTYPE(void Print_Number , (Word_t number , int output_base ));
-_PROTOTYPE(void Draw_Zone_Numbers , (de_state *s , struct inode *inode ,
- int zindex , int zrow ));
-
-
-
-/****************************************************************/
-/* */
-/* Init_Termcap() */
-/* */
-/* Initializes the external variables for the */
-/* current terminal. */
-/* */
-/****************************************************************/
-
-
-int Init_Termcap()
-
- {
- char *term;
- char buffer[ TC_BUFFER ];
- static char strings[ TC_STRINGS ];
- char *s = &strings[0];
- char *Kcode;
-
-
- term = getenv( "TERM" );
-
- if ( term == NULL )
- return( 0 );
-
- if ( tgetent( buffer, term ) != 1 )
- return( 0 );
-
-
- if ( (Tmove = tgetstr( "cm", &s )) == NULL )
- return( 0 );
-
- if ( (Tclr_all = tgetstr( "cl", &s )) == NULL )
- return( 0 );
-
- if ( (Treverse = tgetstr( "so", &s )) == NULL )
- {
- Treverse = Tnormal = s;
- *s = '\0';
- ++s;
- }
- else if ( (Tnormal = tgetstr( "se", &s )) == NULL )
- return( 0 );
-
-
- /* See if there are single character arrow key codes */
-
- if ( (Kcode = tgetstr( "ku", &s )) != NULL && strlen( Kcode ) == 1 )
- Kup = Kcode[0];
-
- if ( (Kcode = tgetstr( "kd", &s )) != NULL && strlen( Kcode ) == 1 )
- Kdown = Kcode[0];
-
- if ( (Kcode = tgetstr( "kl", &s )) != NULL && strlen( Kcode ) == 1 )
- Kleft = Kcode[0];
-
- if ( (Kcode = tgetstr( "kr", &s )) != NULL && strlen( Kcode ) == 1 )
- Kright = Kcode[0];
-
-
- return( 1 );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Goto( column, line ) */
-/* */
-/* Use the termcap string to move the cursor. */
-/* */
-/****************************************************************/
-
-
-void Goto( column, line )
- int column;
- int line;
-
- {
- fputs( tgoto( Tmove, column, line ), stdout );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* Output routines */
-/****************************************************************/
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Help_Screen() */
-/* */
-/****************************************************************/
-
-
-void Draw_Help_Screen( s )
- de_state *s;
-
- {
- int down;
- int right;
-
- switch ( s->mode )
- {
- case WORD : down = 2; right = 32; break;
- case BLOCK : down = 64; right = 1; break;
- case MAP : down = 256; right = 4; break;
- }
-
- printf( "%s ", Tclr_all );
- printf( "%sDE COMMANDS%s\r\n\n\n", Treverse, Tnormal );
-
-
- printf( " PGUP b Back one block h Help\r\n" );
- printf( " PGDN f Forward one block q Quit\r\n" );
- printf( " HOME B Goto first block m Minix shell\r\n" );
- printf( " END F Goto last block\r\n" );
- printf( " v Visual mode (w b m)\r\n" );
- printf( " g Goto specified block o Output base (h d o b)\r\n" );
- printf( " G Goto block indirectly\r\n" );
- printf( " i Goto i-node c Change file name\r\n" );
- printf( " I Filename to i-node w Write ASCII block\r\n" );
- printf( " W Write block exactly\r\n" );
- printf( " / Search\r\n" );
- printf( " n Next occurrence x Extract lost entry\r\n" );
- printf( " p Previous address X Extract lost blocks\r\n" );
- printf( " s Store word\r\n" );
- printf( " UP u Move back %d bytes\r\n", down );
- printf( " DOWN d Move forward %d bytes\r\n", down );
- printf( " LEFT l Move back %d byte%s\r\n", right,
- right == 1 ? "" : "s" );
- printf( " RIGHT r Move forward %d byte%s\r\n\n\n", right,
- right == 1 ? "" : "s" );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Wait_For_Key() */
-/* */
-/* The user must press a key to continue. */
-/* */
-/****************************************************************/
-
-
-void Wait_For_Key()
-
- {
- Draw_Prompt( "Press a key to continue..." );
-
- Get_Char();
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Prompt( string ) */
-/* */
-/* Write a message in the "prompt" area. */
-/* */
-/****************************************************************/
-
-
-void Draw_Prompt( string )
- char *string;
-
- {
- Goto( PROMPT_COLUMN, PROMPT_LINE );
-
- printf( "%s%s%s ", Treverse, string, Tnormal );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Erase_Prompt() */
-/* */
-/* Erase the message in the "prompt" area. */
-/* */
-/****************************************************************/
-
-
-void Erase_Prompt()
-
- {
- Goto( PROMPT_COLUMN, PROMPT_LINE );
-
- printf( "%77c", ' ' );
-
- Goto( PROMPT_COLUMN, PROMPT_LINE );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Screen( state ) */
-/* */
-/* Redraw everything, except pointers. */
-/* */
-/****************************************************************/
-
-
-void Draw_Screen( s )
- de_state *s;
-
- {
- fputs( Tclr_all, stdout );
-
- Draw_Strings( s );
- Block_Type( s );
-
- switch ( s->mode )
- {
- case WORD : Draw_Words( s );
- Draw_Info( s );
- break;
-
- case BLOCK : Draw_Block( s->buffer );
- break;
-
- case MAP : {
- int max_bits = 2 * K;
-
- /* Don't display the bits after the end */
- /* of the i-node or zone bit maps. */
-
- if ( s->block == 2 + s->inode_maps - 1 )
- max_bits = (int)
- (s->inodes_in_map
- - CHAR_BIT * K * (ino_t) (s->inode_maps - 1)
- - CHAR_BIT * (ino_t) (s->offset & ~ MAP_MASK));
-
- else if ( s->block == 2 + s->inode_maps + s->zone_maps - 1 )
- max_bits = (int)
- (s->zones_in_map
- - CHAR_BIT * K * (zone_t) (s->zone_maps - 1)
- - CHAR_BIT * (zone_t) (s->offset & ~ MAP_MASK));
-
- if ( max_bits < 0 )
- max_bits = 0;
-
- Draw_Map( &s->buffer[ s->offset & ~ MAP_MASK ], max_bits );
- break;
- }
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Strings( state ) */
-/* */
-/* The first status line contains the device name, */
-/* the current write file name (if one is open) */
-/* and the current search string (if one has */
-/* been defined). */
-/* */
-/* Long strings are truncated. */
-/* */
-/****************************************************************/
-
-
-void Draw_Strings( s )
- de_state *s;
-
- {
- int len;
- int i;
-
- Goto( STATUS_COLUMN, STATUS_LINE );
-
- printf( "Device %s= %-14.14s ",
- s->device_mode == O_RDONLY ? "" : "(w) ", s->device_name );
-
- switch ( s->magic )
- {
- case SUPER_MAGIC : printf( "V1 file system ");
- break;
- case SUPER_REV : printf( "V1-bytes-swapped file system (?) ");
- break;
- case SUPER_V2 : printf( "V2 file system ");
- break;
- case SUPER_V2_REV : printf( "V2-bytes-swapped file system (?) ");
- break;
- case SUPER_V3 : printf( "V3 file system ");
- break;
- default : printf( "not a Minix file system ");
- break;
- }
-
- len = strlen( s->file_name );
-
- if ( len == 0 )
- printf( "%29s", " " );
- else if ( len <= 20 )
- printf( "File = %-20s ", s->file_name );
- else
- printf( "File = ...%17.17s ", s->file_name + len - 17 );
-
-
- len = strlen( s->search_string );
-
- if ( len == 0 )
- printf( "%20s", " " );
- else
- {
- printf( "Search = " );
-
- if ( len <= 11 )
- {
- for ( i = 0; i < len; ++i )
- Print_Ascii( s->search_string[ i ] );
-
- for ( ; i < 11; ++i )
- putchar( ' ' );
- }
- else
- {
- for ( i = 0; i < 8; ++i )
- Print_Ascii( s->search_string[ i ] );
-
- printf( "..." );
- }
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Block_Type( state ) */
-/* */
-/* Display the current block type. */
-/* */
-/****************************************************************/
-
-
-void Block_Type( s )
- de_state *s;
-
- {
- Goto( STATUS_COLUMN, STATUS_LINE + 1 );
-
- printf( "Block = %5u of %-5u ", s->block, s->zones );
-
- if ( !s->is_fs )
- return;
-
- if ( s->block == BOOT_BLOCK )
- printf( "Boot block" );
-
- else if ( s->block == 1 )
- printf( "Super block" );
-
- else if ( s->block < 2 + s->inode_maps )
- printf( "I-node bit map" );
-
- else if ( s->block < 2 + s->inode_maps + s->zone_maps )
- printf( "Zone bit map" );
-
- else if ( s->block < s->first_data )
- printf( "I-nodes" );
-
- else
- printf( "Data block (%sin use)",
- In_Use( (bit_t) (s->block - (s->first_data - 1)), s->zone_map )
- ? "" : "not " );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Words( state ) */
-/* */
-/* Draw a page in word format. */
-/* */
-/****************************************************************/
-
-
-void Draw_Words( s )
- de_state *s;
-
- {
- int line;
- int addr = s->offset & ~ PAGE_MASK;
-
-
- for ( line = 0; line < 16; ++line, addr += 2 )
- {
- Goto( BLOCK_COLUMN, BLOCK_LINE + line );
-
- printf( "%5d ", addr );
-
- Print_Number( *( (word_t *) &s->buffer[ addr ] ), s->output_base );
- }
-
- Goto( BLOCK_COLUMN + 64, BLOCK_LINE );
- printf( "(base %d)", s->output_base );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Info( state ) */
-/* */
-/* Add information to a page drawn in word format. */
-/* The routine recognizes the super block, inodes, */
-/* executables and "ar" archives. If the current */
-/* page is not one of these, then ASCII characters */
-/* are printed from the data words. */
-/* */
-/****************************************************************/
-
-
-char *super_block_info[] = { "number of inodes",
- "V1 number of zones",
- "inode bit map blocks",
- "zone bit map blocks",
- "first data zone",
- "blocks per zone shift & flags",
- "maximum file size",
- "",
- "magic number",
- "fsck magic number",
- "V2 number of zones" };
-
-
-void Draw_Info( s )
- de_state *s;
-
- {
- int i;
- int page = s->offset >> PAGE_SHIFT;
- dev_t dev;
-
-
- if ( s->is_fs && s->block == 1 && page == 0 )
- for ( i = 0; i < 11; ++i )
- {
- Goto( INFO_COLUMN, INFO_LINE + i );
- printf( "%s", super_block_info[ i ] );
- }
-
- else if ( s->is_fs && s->block >= s->first_data - s->inode_blocks &&
- s->block < s->first_data )
- {
- struct inode core_inode;
- d1_inode *dip1;
- d2_inode *dip2;
- struct inode *inode = &core_inode;
- int special = 0;
- int m;
- struct passwd *user;
- struct group *grp;
-
- dip1 = (d1_inode *) &s->buffer[ s->offset & ~ PAGE_MASK ];
- dip2 = (d2_inode *) &s->buffer[ s->offset & ~ PAGE_MASK
- & ~ (V2_INODE_SIZE-1) ];
- conv_inode( inode, dip1, dip2, READING, s->magic );
-
- user = getpwuid( inode->i_uid );
- grp = getgrgid( inode->i_gid );
-
- if ( s->magic != SUPER_MAGIC && page & 1 )
- {
- Draw_Zone_Numbers( s, inode, 2, 0 );
- return;
- }
-
- Goto( INFO_COLUMN, INFO_LINE );
-
- switch( inode->i_mode & S_IFMT )
- {
- case S_IFDIR : printf( "directory " );
- break;
-
- case S_IFCHR : printf( "character " );
- special = 1;
- break;
-
- case S_IFBLK : printf( "block " );
- special = 1;
- break;
-
- case S_IFREG : printf( "regular " );
- break;
-#ifdef S_IFIFO
- case S_IFIFO : printf( "fifo " );
- break;
-#endif
-#ifdef S_IFLNK
- case S_IFLNK : printf( "symlink " );
- break;
-#endif
-#ifdef S_IFSOCK
- case S_IFSOCK: printf( "socket " );
- break;
-#endif
- default : printf( "unknown " );
- }
-
- for ( m = 11; m >= 0; --m )
- putchar( (inode->i_mode & (1<<m)) ? "xwrxwrxwrtgu"[m] : '-' );
-
- if ( s->magic == SUPER_MAGIC )
- {
- /* V1 file system */
- Goto( INFO_COLUMN, INFO_LINE + 1 );
- printf( "user %s", user ? user->pw_name : "" );
-
- Goto( INFO_COLUMN, INFO_LINE + 2 );
- printf( "file size %lu", inode->i_size );
-
- Goto( INFO_COLUMN, INFO_LINE + 4 );
- printf( "m_time %s", ctime( &inode->i_mtime ) );
-
- Goto( INFO_COLUMN, INFO_LINE + 6 );
- printf( "links %d, group %s",
- inode->i_nlinks, grp ? grp->gr_name : "" );
-
- Draw_Zone_Numbers( s, inode, 0, 7 );
- }
- else
- {
- /* V2 file system, even page. */
- Goto( INFO_COLUMN, INFO_LINE + 1 );
- printf( "links %d ", inode->i_nlinks);
-
- Goto( INFO_COLUMN, INFO_LINE + 2 );
- printf( "user %s", user ? user->pw_name : "" );
-
- Goto( INFO_COLUMN, INFO_LINE + 3 );
- printf( "group %s", grp ? grp->gr_name : "" );
-
- Goto( INFO_COLUMN, INFO_LINE + 4 );
- printf( "file size %lu", inode->i_size );
-
- Goto( INFO_COLUMN, INFO_LINE + 6 );
- printf( "a_time %s", ctime( &inode->i_atime ) );
-
- Goto( INFO_COLUMN, INFO_LINE + 8 );
- printf( "m_time %s", ctime( &inode->i_mtime ) );
-
- Goto( INFO_COLUMN, INFO_LINE + 10 );
- printf( "c_time %s", ctime( &inode->i_ctime ) );
-
- Draw_Zone_Numbers( s, inode, 0, 12 );
- }
-
- if ( special )
- {
- Goto( INFO_COLUMN, INFO_LINE + 7 );
- dev = (dev_t) inode->i_zone[0];
- printf( "major %d, minor %d", major(dev), minor(dev) );
- }
- }
-
- else /* Print ASCII characters for each byte in page */
- {
- char *p = &s->buffer[ s->offset & ~ PAGE_MASK ];
-
- for ( i = 0; i < 16; ++i )
- {
- Goto( INFO_COLUMN, INFO_LINE + i );
- Print_Ascii( *p++ );
- Print_Ascii( *p++ );
- }
-
- if ( s->block >= s->first_data && page == 0 )
- {
- unsigned magic = ((s->buffer[1] & 0xff) << 8) | (s->buffer[0] & 0xff);
- unsigned second = ((s->buffer[3] & 0xff) << 8) | (s->buffer[2] & 0xff);
-
- /* Is this block the start of an executable file? */
-
- if ( magic == (unsigned) A_OUT )
- {
- Goto( INFO_COLUMN, INFO_LINE );
- printf( "executable" );
-
- Goto( INFO_COLUMN, INFO_LINE + 1 );
-
- if ( second == (unsigned) SPLIT )
- printf( "separate I & D" );
- else
- printf( "combined I & D" );
- }
- }
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Block( block ) */
-/* */
-/* Redraw a 1k block in character format. */
-/* */
-/****************************************************************/
-
-
-void Draw_Block( block )
- char *block;
-
- {
- int line;
- int column;
- int reverse = 0;
- int msb_flag = 0;
-
-
- for ( line = 0; line < 16; ++line )
- {
- Goto( BLOCK_COLUMN, BLOCK_LINE + line );
-
- for ( column = 0; column < 64; ++column )
- {
- char c = *block++;
-
- if ( c & 0x80 )
- {
- msb_flag = 1;
- c &= 0x7f;
- }
-
- if ( c >= ' ' && c < DEL )
- {
- if ( reverse )
- { fputs( Tnormal, stdout ); reverse = 0; }
-
- putchar( c );
- }
- else
- {
- if ( ! reverse )
- { fputs( Treverse, stdout ); reverse = 1; }
-
- putchar( c == DEL ? '?' : '@' + c );
- }
- } /* end for ( column ) */
- } /* end for ( line ) */
-
- if ( reverse )
- { fputs( Tnormal, stdout ); reverse = 0; }
-
- if ( msb_flag )
- {
- Goto( BLOCK_COLUMN + 68, BLOCK_LINE + 6 );
- fputs( "(MSB)", stdout );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Map( block, max_bits ) */
-/* */
-/* Redraw a block in a bit map format. */
-/* Display min( max_bits, 2048 ) bits. */
-/* */
-/* The 256 bytes in "block" are displayed from */
-/* top to bottom and left to right. Bit 0 of */
-/* a byte is towards the top of the screen. */
-/* */
-/* Special graphic codes are used to generate */
-/* two "bits" per character position. So a 16 */
-/* line by 64 column display is 32 "bits" by */
-/* 64 "bits". Or 4 bytes by 64 bytes. */
-/* */
-/****************************************************************/
-
-
-void Draw_Map( block, max_bits )
- char *block;
- int max_bits;
-
- {
- int line;
- int column;
- int bit_count = 0;
-
- for ( line = 0; line < 16; ++line )
- {
- char *p = &block[ (line & 0xC) >> 2 ];
- int shift = (line & 0x3) << 1;
-
- Goto( BLOCK_COLUMN, BLOCK_LINE + line );
-
- for ( column = 0; column < 64; ++column, p += 4 )
- {
- char c = (*p >> shift) & 0x3;
- int current_bit = ((p - block) << 3) + shift;
-
- /* Don't display bits past "max_bits" */
-
- if ( current_bit >= max_bits )
- break;
-
- /* If "max_bits" occurs in between the two bits */
- /* I am trying to display as one character, then */
- /* zero off the high-order bit. */
-
- if ( current_bit + 1 == max_bits )
- c &= 1;
-
- switch ( c )
- {
- case 0 : putchar( BOX_CLR );
- break;
-
- case 1 : putchar( BOX_TOP );
- ++bit_count;
- break;
-
- case 2 : putchar( BOX_BOT );
- ++bit_count;
- break;
-
- case 3 : putchar( BOX_ALL );
- bit_count += 2;
- break;
- }
- } /* end for ( column ) */
- } /* end for ( line ) */
-
-
- Goto( BLOCK_COLUMN + 68, BLOCK_LINE + 6 );
- printf( "(%d)", bit_count );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Pointers( state ) */
-/* */
-/* Redraw the pointers and the offset field. */
-/* The rest of the screen stays intact. */
-/* */
-/****************************************************************/
-
-
-void Draw_Pointers( s )
- de_state *s;
-
- {
- Draw_Offset( s );
-
- switch ( s->mode )
- {
- case WORD : Word_Pointers( s->last_addr, s->address );
- break;
-
- case BLOCK : Block_Pointers( s->last_addr, s->address );
- break;
-
- case MAP : Map_Pointers( s->last_addr, s->address );
- break;
- }
-
- Goto( PROMPT_COLUMN, PROMPT_LINE );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Draw_Offset( state ) */
-/* */
-/* Display the offset in the current buffer */
-/* and the relative position if within a map */
-/* or i-node block. */
-/* */
-/****************************************************************/
-
-
-void Draw_Offset( s )
- de_state *s;
-
- {
- Goto( STATUS_COLUMN, STATUS_LINE + 2 );
-
- printf( "Offset = %5d ", s->offset );
-
-
- if ( s->block < 2 )
- return;
-
- if ( s->block < 2 + s->inode_maps )
- {
- long bit = (s->address - 2 * K) * 8;
-
- if ( bit < s->inodes_in_map )
- printf( "I-node %ld of %d ", bit, s->inodes );
- else
- printf( "(padding) " );
- }
-
- else if ( s->block < 2 + s->inode_maps + s->zone_maps )
- {
- long bit = (s->address - (2 + s->inode_maps) * K) * 8;
-
- if ( bit < s->zones_in_map )
- printf( "Block %ld of %u ", bit + s->first_data - 1, s->zones );
- else
- printf( "(padding) " );
- }
-
- else if ( s->block < s->first_data )
- {
- bit_t node = (s->address - (2 + s->inode_maps + s->zone_maps) * K) /
- s->inode_size + 1;
-
- if ( node <= s->inodes )
- printf( "I-node %lu of %lu (%sin use) ",
- (unsigned long) node, (unsigned long) s->inodes,
- In_Use( node, s->inode_map ) ? "" : "not " );
- else
- printf( "(padding) " );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Word_Pointers( old_addr, new_addr ) */
-/* */
-/* Block_Pointers( old_addr, new_addr ) */
-/* */
-/* Map_Pointers( old_addr, new_addr ) */
-/* */
-/* Redraw the index pointers for a each type */
-/* of display. The pointer at "old_addr" is */
-/* erased and a new pointer is positioned */
-/* for "new_addr". This makes the screen */
-/* update faster and more pleasant for the user. */
-/* */
-/****************************************************************/
-
-
-void Word_Pointers( old_addr, new_addr )
- off_t old_addr;
- off_t new_addr;
-
- {
- int from = ( (int) old_addr & PAGE_MASK ) >> 1;
- int to = ( (int) new_addr & PAGE_MASK ) >> 1;
-
- Goto( BLOCK_COLUMN - 2, BLOCK_LINE + from );
- putchar( ' ' );
-
- Goto( BLOCK_COLUMN - 2, BLOCK_LINE + to );
- putchar( '>' );
- }
-
-
-
-
-void Block_Pointers( old_addr, new_addr )
- off_t old_addr;
- off_t new_addr;
-
- {
- int from = (int) old_addr & ~K_MASK;
- int to = (int) new_addr & ~K_MASK;
-
- Goto( BLOCK_COLUMN - 2, BLOCK_LINE + from / 64 );
- putchar( ' ' );
-
- Goto( BLOCK_COLUMN - 2, BLOCK_LINE + to / 64 );
- putchar( '>' );
-
- Goto( BLOCK_COLUMN + from % 64, BLOCK_LINE + 17 );
- putchar( ' ' );
-
- Goto( BLOCK_COLUMN + to % 64, BLOCK_LINE + 17 );
- putchar( '^' );
- }
-
-
-
-
-void Map_Pointers( old_addr, new_addr )
- off_t old_addr;
- off_t new_addr;
-
- {
- int from = ( (int) old_addr & MAP_MASK ) >> 2;
- int to = ( (int) new_addr & MAP_MASK ) >> 2;
-
- Goto( BLOCK_COLUMN + from, BLOCK_LINE + 17 );
- putchar( ' ' );
-
- Goto( BLOCK_COLUMN + to, BLOCK_LINE + 17 );
- putchar( '^' );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Print_Number( number, output_base ) */
-/* */
-/* Output "number" in the output base. */
-/* */
-/****************************************************************/
-
-
-void Print_Number( number, output_base )
- word_t number;
- int output_base;
-
- {
- switch ( output_base )
- {
- case 16 : printf( "%5x", number );
- break;
-
- case 10 : printf( "%7u", number );
- break;
-
- case 8 : printf( "%7o", number );
- break;
-
- case 2 : {
- unsigned int mask;
- char pad = ' ';
-
- for ( mask = 0x8000; mask > 1; mask >>= 1 )
- putchar( (mask & number) ? (pad = '0', '1') : pad );
-
- putchar( (0x01 & number) ? '1' : '0' );
-
- break;
- }
-
- default : Error( "Internal fault (output_base)" );
- }
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Print_Ascii( char ) */
-/* */
-/* Display a character in reverse mode if it */
-/* is not a normal printable ASCII character. */
-/* */
-/****************************************************************/
-
-
-void Print_Ascii( c )
- char c;
-
- {
- c &= 0x7f;
-
- if ( c < ' ' )
- printf( "%s%c%s", Treverse, '@' + c, Tnormal );
- else if ( c == DEL )
- printf( "%s?%s", Treverse, Tnormal );
- else
- putchar( c );
- }
-
-
-
-
-
-
-/****************************************************************/
-/* */
-/* Warning( text, arg1, arg2 ) */
-/* */
-/* Display a message for 2 seconds. */
-/* */
-/****************************************************************/
-
-
-#if __STDC__
-void Warning( const char *text, ... )
-#else
-void Warning( text )
- char *text;
-#endif
-
- {
- va_list argp;
-
- printf( "%c%s", BELL, Tclr_all );
-
- Goto( WARNING_COLUMN, WARNING_LINE );
-
- printf( "%s Warning: ", Treverse );
- va_start( argp, text );
- vprintf( text, argp );
- va_end( argp );
- printf( " %s", Tnormal );
-
- fflush(stdout); /* why does everyone forget this? */
-
- sleep( 2 );
- }
-
-
-void Draw_Zone_Numbers( s, inode, zindex, zrow )
- de_state *s;
- struct inode *inode;
- int zindex;
- int zrow;
-
- {
- static char *plurals[] = { "", "double ", "triple " };
- zone_t zone;
-
- for ( ; zrow < 16;
- ++zindex, zrow += s->zone_num_size / sizeof (word_t) )
- {
- Goto( INFO_COLUMN, INFO_LINE + zrow );
- if ( zindex < s->ndzones )
- printf( "zone %d", zindex );
- else
- printf( "%sindirect", plurals[ zindex - s->ndzones ] );
- if ( s->magic != SUPER_MAGIC )
- {
- zone = inode->i_zone[ zindex ];
- if ( zone != (word_t) zone )
- {
- Goto( INFO_COLUMN + 16, INFO_LINE + zrow );
- printf("%ld", (long) zone );
- }
- }
- }
- }
*/
#include <sys/types.h>
-#include <sys/dir.h>
#include <sys/stat.h>
#include <machine/partition.h>
#include <minix/partition.h>
#define bit_nr bit_t
#define block_nr block_t
#define d_inode d2_inode
-#define d_inum d_ino
+#define d_inum mfs_d_ino
#define dir_struct struct direct
#define i_mode d2_mode
#define i_nlinks d2_nlinks
*/
#include <sys/types.h>
-#include <sys/dir.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include "mfs/const.h"
#include "mfs/inode.h"
#include "mfs/type.h"
+#include "mfs/mfsdir.h"
#include <minix/fslib.h>
#include <stdio.h>
#include <sys/stat.h>
void printname(s)
char *s;
{
- register n = NAME_MAX;
+ register n = MFS_NAME_MAX;
int c;
do {
if (sp->st_next != 0) {
printrec(sp->st_next);
putchar('/');
- printname(sp->st_dir->d_name);
+ printname(sp->st_dir->mfs_d_name);
}
}
/* See if the `.' or `..' entry is as expected. */
int chkdots(ino_t ino, off_t pos, dir_struct *dp, ino_t exp)
{
- char printable_name[4 * NAME_MAX + 1];
+ char printable_name[4 * MFS_NAME_MAX + 1];
if (dp->d_inum != exp) {
- make_printable_name(printable_name, dp->d_name, sizeof(dp->d_name));
+ make_printable_name(printable_name, dp->mfs_d_name, sizeof(dp->mfs_d_name));
printf("bad %s in ", printable_name);
printpath(1, 0);
printf("%s is linked to %u ", printable_name, dp->d_inum);
count[exp]++;
return(0);
}
- } else if (pos != (dp->d_name[1] ? DIR_ENTRY_SIZE : 0)) {
- make_printable_name(printable_name, dp->d_name, sizeof(dp->d_name));
+ } else if (pos != (dp->mfs_d_name[1] ? DIR_ENTRY_SIZE : 0)) {
+ make_printable_name(printable_name, dp->mfs_d_name, sizeof(dp->mfs_d_name));
printf("warning: %s has offset %ld in ", printable_name, pos);
printpath(1, 0);
printf("%s is linked to %u)\n", printable_name, dp->d_inum);
/* Check the name in a directory entry. */
int chkname(ino_t ino, dir_struct *dp)
{
- register n = NAME_MAX + 1;
- register char *p = dp->d_name;
+ register n = MFS_NAME_MAX + 1;
+ register char *p = dp->mfs_d_name;
if (*p == '\0') {
printf("null name found in ");
printpath(1, 0);
setbit(spec_imap, (bit_nr) ino);
printf("entry = '");
- printname(dp->d_name);
+ printname(dp->mfs_d_name);
printf("')");
if (Remove(dp)) return(0);
break;
printpath(1, 0);
printf("ino found = %u, ", dp->d_inum);
printf("name = '");
- printname(dp->d_name);
+ printname(dp->mfs_d_name);
printf("')");
if (yes(". remove entry")) {
memset((void *) dp, 0, sizeof(dir_struct));
if ((unsigned) count[dp->d_inum] == SHRT_MAX) {
printf("too many links to ino %u\n", dp->d_inum);
printf("discovered at entry '");
- printname(dp->d_name);
+ printname(dp->mfs_d_name);
printf("' in directory ");
printpath(0, 1);
if (Remove(dp)) return(0);
}
count[dp->d_inum]++;
- if (strcmp(dp->d_name, ".") == 0) {
+ if (strcmp(dp->mfs_d_name, ".") == 0) {
ftop->st_presence |= DOT;
return(chkdots(ino, pos, dp, ino));
}
- if (strcmp(dp->d_name, "..") == 0) {
+ if (strcmp(dp->mfs_d_name, "..") == 0) {
ftop->st_presence |= DOTDOT;
return(chkdots(ino, pos, dp, ino == ROOT_INODE ? ino :
ftop->st_next->st_dir->d_inum));
printf("link to directory discovered in ");
printpath(1, 0);
printf("name = '");
- printname(dp->d_name);
+ printname(dp->mfs_d_name);
printf("', dir ino = %u)", dp->d_inum);
return !Remove(dp);
}
nfreeinode = sb.s_ninodes;
nfreezone = N_DATA;
dir.d_inum = ROOT_INODE;
- dir.d_name[0] = 0;
+ dir.mfs_d_name[0] = 0;
if (!descendtree(&dir)) fatal("bad root inode");
putchar('\n');
}
*/
#include <sys/types.h>
-#include <sys/dir.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <minix/type.h>
#include <minix/minlib.h>
#include "mfs/const.h"
+#include "mfs/mfsdir.h"
#if (MACHINE == IBM_PC)
#include <minix/partition.h>
#include <minix/u64.h>
for (l = 0; l < zone_size; l++) {
get_block((z << zone_shift) + l, (char *) dir_entry);
for (i = 0; i < NR_DIR_ENTRIES(block_size); i++) {
- if (dir_entry[i].d_ino == 0) {
- dir_entry[i].d_ino = child;
+ if (dir_entry[i].mfs_d_ino == 0) {
+ dir_entry[i].mfs_d_ino = child;
p1 = name;
- p2 = dir_entry[i].d_name;
- j = sizeof(dir_entry[i].d_name);
+ p2 = dir_entry[i].mfs_d_name;
+ j = sizeof(dir_entry[i].mfs_d_name);
while (j--) {
*p2++ = *p1;
if (*p1 != 0) p1++;
/* This is a directory */
get_block(inode1[i].d1_zone[0], (char *) dir);
for (j = 0; j < NR_DIR_ENTRIES(block_size); j++)
- if (dir[j].d_ino)
- printf("\tInode %2d: %s\n", dir[j].d_ino, dir[j].d_name);
+ if (dir[j].mfs_d_ino)
+ printf("\tInode %2d: %s\n", dir[j].mfs_d_ino, dir[j].mfs_d_name);
}
} else {
if (inode2[i].d2_mode != 0) {
/* This is a directory */
get_block(inode2[i].d2_zone[0], (char *) dir);
for (j = 0; j < NR_DIR_ENTRIES(block_size); j++)
- if (dir[j].d_ino)
- printf("\tInode %2d: %s\n", dir[j].d_ino, dir[j].d_name);
+ if (dir[j].mfs_d_ino)
+ printf("\tInode %2d: %s\n", dir[j].mfs_d_ino, dir[j].mfs_d_name);
}
}
}
+++ /dev/null
-PROG= readfs
-CPPFLAGS+= -I${MINIXSRCDIR}/servers
-MAN=
-
-.include <bsd.prog.mk>
+++ /dev/null
-/* readfs - read a MINIX file system Author: Paul Polderman */
-
-/* Command: readfs - read and extract a MINIX filesystem.
- *
- * Syntax: readfs [-li] block-special [directory]
- *
- * Flags: -l: Extract files and dirs and produce a mkfs-listing on stdout
- * -i: Information only: give the listing, but do not extract files.
- * -d: Don't extract regular files, just the skeleton please.
- *
- * Examples: readfs /dev/fd1 # extract all files from /dev/fd1.
- * readfs -i /dev/hd2 # see what's on /dev/hd2.
- * readfs -l /dev/at0 rootfs # extract and list the filesystem
- * # of /dev/at0 and put the tree
- * # in the directory `rootfs'.
- *
- * Readfs reads a MINIX filesystem and extracts recursively all directories
- * and files, and (optionally) produces a mkfs-listing of them on stdout.
- * The root directory contents are placed in the current directory, unless
- * a directory is given as argument, in which case the contents are put there.
- * Readfs tries to restore the attributes (mode/uid/gid/time) of the files
- * extracted to those of the original files.
- * Special files are created as ordinary files, but the mkfs-listing
- * enables mkfs to restore them to original.
- */
-
-#include <sys/types.h>
-#include <sys/dir.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <utime.h>
-#include <dirent.h>
-
-#define BLOCK_SIZE _STATIC_BLOCK_SIZE
-
-#include <minix/config.h>
-#include <minix/const.h>
-#include <minix/type.h>
-#include "mfs/const.h"
-#include "mfs/type.h"
-#include "mfs/buf.h"
-#include "mfs/super.h"
-
-#undef printf /* Definition used only in the kernel */
-#include <stdio.h>
-
-/* Compile with -I/user0/ast/minix
- * (i.e. the directory containing the MINIX system sources)
- *
- * Author: Paul Polderman (polder@cs.vu.nl) April 1987
- */
-
-char verbose = 0; /* give a mkfs-listing of the filesystem */
- /* And extracts its contents. */
-char noaction = 0; /* just give a mkfs-listing, do not extract
- * files. */
-char nofiles = 0; /* only extract the skeleton FS structure */
-
-struct super_block sb;
-char pathname[1024];
-int inodes_per_block;
-
-_PROTOTYPE(int main, (int argc, char **argv));
-_PROTOTYPE(void get_flags, (char *flags));
-_PROTOTYPE(void readfs, (char *special_file, char *directory));
-_PROTOTYPE(int get_inode, (int fd, Ino_t inum, d1_inode * ip));
-_PROTOTYPE(void dump_dir, (int special, d1_inode * ip, char *directory));
-_PROTOTYPE(int dump_file, (int special, d1_inode * ip, char *filename));
-_PROTOTYPE(int get_fileblock, (int special, d1_inode * ip, block_t b, struct buf * bp));
-_PROTOTYPE(int get_block, (int fd, block_t block, struct buf * bp, int type));
-_PROTOTYPE(int get_rawblock, (int special, block_t blockno, char *bufp));
-_PROTOTYPE(void restore, (char *name, d1_inode * ip));
-_PROTOTYPE(void show_info, (char *name, d1_inode * ip, char *path));
-_PROTOTYPE(void do_indent, (int i));
-_PROTOTYPE(int Mkdir, (char *directory));
-
-int main(argc, argv)
-int argc;
-char **argv;
-{
- switch (argc) {
- case 2:
- pathname[0] = '\0';
- readfs(argv[1], pathname);
- break;
- case 3:
- if (argv[1][0] == '-') {
- get_flags(&argv[1][1]);
- pathname[0] = '\0';
- readfs(argv[2], pathname);
- } else {
- strcpy(pathname, argv[2]);
- readfs(argv[1], pathname);
- }
- break;
- case 4:
- if (argv[1][0] == '-') {
- get_flags(&argv[1][1]);
- strcpy(pathname, argv[3]);
- readfs(argv[2], pathname);
- break;
- } /* else fall through .. */
- default:
- fprintf(stderr, "Usage: %s [-li] <special> [dirname]\n", argv[0]);
- exit(1);
- }
- return(0);
-}
-
-void get_flags(flags)
-register char *flags;
-{
- while (*flags) {
- switch (*flags) {
- case 'L':
- case 'l': verbose = 1; break;
- case 'I':
- case 'i':
- noaction = 1;
- verbose = 1;
- break;
- case 'D':
- case 'd': nofiles = 1; break;
- default:
- fprintf(stderr, "Bad flag: %c\n", *flags);
- break;
- }
- flags++;
- }
-}
-
-#define zone_shift (sb.s_log_zone_size) /* zone to block ratio */
-
-void readfs(special_file, directory)
-char *special_file, *directory;
-/* Readfs: opens the given special file (with MINIX filesystem),
- * and extracts its contents into the given directory.
- */
-{
- d1_inode root_inode;
- int special, magic;
- off_t super_b;
-
- umask(0);
-
- /* Open the special file */
- if ((special = open(special_file, O_RDONLY)) < 0) {
- fprintf(stderr, "cannot open %s\n", special_file);
- return;
- }
-
- /* Read the superblock */
- super_b = (off_t) 1 *(off_t) BLOCK_SIZE;
- if (lseek(special, super_b, SEEK_SET) != super_b) {
- fprintf(stderr, "cannot seek to superblock\n");
- return;
- }
- if (read(special, (char *) &sb, sizeof(struct super_block))
- != sizeof(struct super_block)) {
- fprintf(stderr, "cannot read superblock\n");
- return;
- }
-
- /* The number of inodes in a block differs in V1 and V2. */
- magic = sb.s_magic;
- if (magic == SUPER_MAGIC || magic == SUPER_REV) {
- inodes_per_block = V1_INODES_PER_BLOCK;
- } else {
- inodes_per_block = V2_INODES_PER_BLOCK(BLOCK_SIZE);
- }
-
- /* Is it really a MINIX filesystem ? */
- if (magic != SUPER_MAGIC && magic != SUPER_V2) {
- fprintf(stderr, "%s is not a valid MINIX filesystem\n", special_file);
- return;
- }
-
- /* Fetch the inode of the root directory */
- if (get_inode(special, (ino_t) ROOT_INODE, &root_inode) < 0) {
- fprintf(stderr, "cannot get inode of root directory\n");
- return;
- }
-
- /* Print number of blocks and inodes */
- if (verbose) printf("boot\n%ld %d\n",
- (block_t) sb.s_nzones << zone_shift, sb.s_ninodes);
-
- /* Extract (recursively) the root directory */
- dump_dir(special, &root_inode, directory);
-}
-
-/* Different type of blocks: (used in routine get_block for caching) */
-
-#define B_INODE 0 /* Cache #0 is the inode cache */
-#define B_INDIRECT 1 /* Cache #1 is the (dbl) indirect block cache */
-#define B_DATA 2 /* No cache for data blocks (only read once) */
-
-int get_inode(fd, inum, ip)
-int fd;
-ino_t inum;
-d1_inode *ip;
-
-/* Get inode `inum' from the MINIX filesystem. (Uses the inode-cache) */
-{
- struct buf bp;
- block_t block;
- block_t ino_block;
- unsigned short ino_offset;
-
- /* Calculate start of i-list */
- block = 1 + 1 + sb.s_imap_blocks + sb.s_zmap_blocks;
-
- /* Calculate block with inode inum */
- ino_block = ((inum - 1) / inodes_per_block);
- ino_offset = ((inum - 1) % inodes_per_block);
- block += ino_block;
-
- /* Fetch the block */
- if (get_block(fd, block, &bp, B_INODE) == 0) {
- memcpy((void *) ip, (void *) &bp.b_v1_ino[ino_offset], sizeof(d1_inode));
- return(0);
- }
-
- /* Oeps, foutje .. */
- fprintf(stderr, "cannot find inode %d\n", inum);
- return(-1);
-}
-
-static int indent = 0; /* current indent (used for mkfs-listing) */
-
-void dump_dir(special, ip, directory)
-int special;
-d1_inode *ip;
-char *directory;
-/* Make the given directory (if non-NULL),
- * and recursively extract its contents.
- */
-{
- register struct direct *dp;
- register int n_entries;
- register char *name;
- block_t b = 0;
- d1_inode dip;
- struct buf bp;
-
- if (verbose) {
- show_info(directory, ip, "");
- indent++;
- }
- if (!noaction && *directory) {
- /* Try to make the directory if not already there */
- if (Mkdir(directory) != 0 || chdir(directory) < 0) {
- fprintf(stderr, "Mkdir %s failed\n", directory);
- return;
- }
- }
- for (name = directory; *name; name++) /* Find end of pathname */
- ;
- *name++ = '/'; /* Add trailing slash */
-
- n_entries = (int) (ip->d1_size / (off_t) sizeof(struct direct));
- while (n_entries > 0) {
-
- /* Read next block of the directory */
- if (get_fileblock(special, ip, b, &bp) < 0) return;
- dp = &bp.b_dir[0];
- if (b++ == (block_t) 0) {
- dp += 2; /* Skip "." and ".." */
- n_entries -= 2;
- }
-
- /* Extract the files/directories listed in the block */
- while (n_entries-- > 0 && dp < &bp.b_dir[NR_DIR_ENTRIES(BLOCK_SIZE)]) {
- if (dp->d_ino != (ino_t) 0) {
- if (get_inode(special, dp->d_ino, &dip) < 0) {
- /* Bad luck */
- dp++;
- continue;
- }
-
- /* Add new pathname-component to `pathname'. */
- strncpy(name, dp->d_name, (size_t) NAME_MAX);
- name[NAME_MAX] = '\0';
-
- /* Call the right routine */
- if ((dip.d1_mode & I_TYPE) == I_DIRECTORY)
- dump_dir(special, &dip, name);
- else
- dump_file(special, &dip, name);
- }
- dp++; /* Next entry, please. */
- }
- }
- *--name = '\0'; /* Restore `pathname' to what it was. */
- if (!noaction && *directory) {
- chdir(".."); /* Go back up. */
- restore(directory, ip); /* Restore mode/owner/accesstime */
- }
- if (verbose) {
- do_indent(--indent); /* Let mkfs know we are done */
- printf("$\n"); /* with this directory. */
- }
-}
-
-int dump_file(special, ip, filename)
-int special;
-d1_inode *ip;
-char *filename;
-/* Extract given filename from the MINIX-filesystem,
- * and store it on the local filesystem.
- */
-{
- int file;
- block_t b = 0;
- struct buf bp;
- off_t size;
-
- if (nofiles && (ip->d1_mode & I_TYPE) == I_REGULAR) return(0);
-
- if (verbose) show_info(filename, ip, pathname);
-
- if (noaction) return(0);
-
- if (access(filename, 0) == 0) {
- /* Should not happen, but just in case .. */
- fprintf(stderr, "Will not create %s: file exists\n", filename);
- return(-1);
- }
- if ((file = creat(filename, (ip->d1_mode & ALL_MODES))) < 0) {
- fprintf(stderr, "cannot create %s\n", filename);
- return(-1);
- }
-
- /* Don't try to extract /dev/hd0 */
- if ((ip->d1_mode & I_TYPE) == I_REGULAR) {
- size = ip->d1_size;
- while (size > (off_t) 0) {
- /* Get next block of file */
- if (get_fileblock(special, ip, b++, &bp) < 0) {
- close(file);
- return(-1);
- }
-
- /* Write it to the file */
- if (size > (off_t) BLOCK_SIZE)
- write(file, bp.b_data, BLOCK_SIZE);
- else
- write(file, bp.b_data, (int) size);
-
- size -= (off_t) BLOCK_SIZE;
- }
- }
- close(file);
- restore(filename, ip); /* Restore mode/owner/filetimes */
- return(0);
-}
-
-int get_fileblock(special, ip, b, bp)
-int special;
-d1_inode *ip;
-block_t b;
-struct buf *bp;
-/* Read the `b'-th block from the file whose inode is `ip'. */
-{
- zone_t zone, ind_zone;
- block_t z, zone_index;
- int r;
-
- /* Calculate zone in which the datablock number is contained */
- zone = (zone_t) (b >> zone_shift);
-
- /* Calculate index of the block number in the zone */
- zone_index = b - ((block_t) zone << zone_shift);
-
- /* Go get the zone */
- if (zone < (zone_t) V1_NR_DZONES) { /* direct block */
- zone = ip->d1_zone[(int) zone];
- z = ((block_t) zone << zone_shift) + zone_index;
- r = get_block(special, z, bp, B_DATA);
- return(r);
- }
-
- /* The zone is not a direct one */
- zone -= (zone_t) V1_NR_DZONES;
-
- /* Is it single indirect ? */
- if (zone < (zone_t) V1_INDIRECTS) { /* single indirect block */
- ind_zone = ip->d1_zone[V1_NR_DZONES];
- } else { /* double indirect block */
- /* Fetch the double indirect block */
- ind_zone = ip->d1_zone[V1_NR_DZONES + 1];
- z = (block_t) ind_zone << zone_shift;
- r = get_block(special, z, bp, B_INDIRECT);
- if (r < 0) return(r);
-
- /* Extract the indirect zone number from it */
- zone -= (zone_t) V1_INDIRECTS;
-
- /* The next line assumes a V1 file system only! */
- ind_zone = bp->b_v1_ind[(int) (zone / V1_INDIRECTS)];
- zone %= (zone_t) V1_INDIRECTS;
- }
-
- /* Extract the datablock number from the indirect zone */
- z = (block_t) ind_zone << zone_shift;
- r = get_block(special, z, bp, B_INDIRECT);
- if (r < 0) return(r);
-
- /* The next line assumes a V1 file system only! */
- zone = bp->b_v1_ind[(int) zone];
-
- /* Calculate datablock number to be fetched */
- z = ((block_t) zone << zone_shift) + zone_index;
- r = get_block(special, z, bp, B_DATA);
- return(r);
-}
-
-/* The following routines simulate a LRU block cache.
- *
- * Definition of a cache block:
- */
-
-struct cache_block {
- block_t b_block; /* block number of block */
- long b_access; /* counter value of last access */
- char b_buf[BLOCK_SIZE]; /* buffer for block */
-};
-
-#define NR_CACHES 2 /* total number of caches */
-#define NR_CBLOCKS 5 /* number of blocks in a cache */
-
-static struct cache_block cache[NR_CACHES][NR_CBLOCKS];
-static long counter = 0L; /* Counter used as a sense of time. */
- /* Incremented after each cache operation. */
-
-int get_block(fd, block, bp, type)
-int fd;
-block_t block;
-struct buf *bp;
-int type;
-/* Get the requested block from the device with filedescriptor fd.
- * If it is in the cache, no (floppy-) disk access is needed,
- * if not, allocate a cache block and read the block into it.
- */
-{
- register int i;
- register struct cache_block *cache_p, *cp;
-
- if (block == (block_t) NO_ZONE) {
- /* Should never happen in a good filesystem. */
- fprintf(stderr, "get_block: NO_ZONE requested !\n");
- return(-1);
- }
- if (type < 0 || type >= NR_CACHES) /* No cache for this type */
- return(get_rawblock(fd, block, (char *) bp));
-
- cache_p = cache[type];
- cp = (struct cache_block *) 0;
-
- /* First find out if block requested is in the cache */
- for (i = 0; i < NR_CBLOCKS; i++) {
- if (cache_p[i].b_block == block) { /* found right block */
- cp = &cache_p[i];
- break;
- }
- }
-
- if (cp == (struct cache_block *) 0) { /* block is not in cache */
- cp = cache_p; /* go find oldest buffer */
- for (i = 0; i < NR_CBLOCKS; i++) {
- if (cache_p[i].b_access < cp->b_access) cp = &cache_p[i];
- }
-
- /* Fill the buffer with the right block */
- if (get_rawblock(fd, block, cp->b_buf) < 0) return(-1);
- }
-
- /* Update/store last access counter */
- cp->b_access = ++counter;
- cp->b_block = block;
- memcpy((void *) bp, (void *) cp->b_buf, BLOCK_SIZE);
- return(0);
-}
-
-int get_rawblock(special, blockno, bufp)
-int special;
-block_t blockno;
-char *bufp;
-/* Read a block from the disk. */
-{
- off_t pos;
-
- /* Calculate the position of the block on the disk */
- pos = (off_t) blockno *(off_t) BLOCK_SIZE;
-
- /* Read the block from the disk */
- if (lseek(special, pos, SEEK_SET) == pos
- && read(special, bufp, BLOCK_SIZE) == BLOCK_SIZE)
- return(0);
-
- /* Should never get here .. */
- fprintf(stderr, "read block %d failed\n", blockno);
- return(-1);
-}
-
-void restore(name, ip)
-char *name;
-d1_inode *ip;
-/* Restores given file's attributes.
- * `ip' contains the attributes of the file on the MINIX filesystem,
- * `name' is the filename of the extracted file on the local filesystem.
- */
-{
- long ttime[2];
-
- chown(name, ip->d1_uid, ip->d1_gid); /* Fails if not superuser */
- chmod(name, (ip->d1_mode & ALL_MODES));
- ttime[0] = ttime[1] = ip->d1_mtime;
- utime(name, (struct utimbuf *) ttime);
-}
-
-/* Characters to use as prefix to `mkfs' mode field */
-
-static char special_chars[] = {
- '-', /* I_REGULAR */
- 'c', /* I_CHAR_SPECIAL */
- 'd', /* I_DIRECTORY */
- 'b' /* I_BLOCK_SPECIAL */
-};
-
-void show_info(name, ip, path)
-char *name;
-d1_inode *ip;
-char *path;
-/* Show information about the given file/dir in `mkfs'-format */
-{
- char c1, c2, c3;
-
- c1 = special_chars[(ip->d1_mode >> 13) & 03];
- c2 = ((ip->d1_mode & ALL_MODES & ~RWX_MODES) == I_SET_UID_BIT) ? 'u' : '-';
- c3 = ((ip->d1_mode & ALL_MODES & ~RWX_MODES) == I_SET_GID_BIT) ? 'g' : '-';
-
- if (*name) {
- do_indent(indent);
- printf("%-14s ", name);
- }
- printf("%c%c%c%03o %d %d", c1, c2, c3,
- (ip->d1_mode & RWX_MODES), ip->d1_uid, ip->d1_gid);
-
- switch (ip->d1_mode & I_TYPE) {
- case I_DIRECTORY:
- break;
- case I_CHAR_SPECIAL: /* Print major and minor dev numbers */
- printf(" %d %d", (ip->d1_zone[0] >> MAJOR) & 0377,
- (ip->d1_zone[0] >> MINOR) & 0377);
- break;
- case I_BLOCK_SPECIAL: /* Print major and minor dev numbers */
- printf(" %d %d", (ip->d1_zone[0] >> MAJOR) & 0377,
- (ip->d1_zone[0] >> MINOR) & 0377);
- /* Also print the number of blocks on the device */
- printf(" %ld", (ip->d1_size / (off_t) BLOCK_SIZE));
- break;
- default: /* Just print the pathname */
- printf(" %s", path);
- break;
- }
- putchar('\n');
-}
-
-#define INDENT_SIZE 4
-
-void do_indent(i)
-int i;
-{
- i *= INDENT_SIZE;
- while (i-- > 0) putchar(' ');
-}
-
-int Mkdir(directory)
-char *directory;
-/* Make a directory, return exit status.
- * This routine is not necessary on systems that
- * have a system call to make directories.
- */
-{
- int pid, status;
-
- if ((pid = fork()) == 0) {
- execl("/bin/Mkdir", "Mkdir", directory, (char *) 0);
- execl("/usr/bin/Mkdir", "Mkdir", directory, (char *) 0);
- exit(1);
- } else if (pid < 0)
- return(-1);
- while (wait(&status) != pid);
- return(status);
-}
#include <sys/types.h>
#include <sys/stat.h>
-#define NAMELEN (DIRSIZ+5)
+#define NAMELEN (NAME_MAX+5)
#define ISONAMELEN 12
#define PLATFORM_80X86 0
INCS+= minix/acpi.h minix/ansi.h minix/audio_fw.h minix/bitmap.h \
minix/callnr.h minix/com.h minix/compiler.h minix/config.h \
minix/const.h minix/cpufeature.h minix/crtso.h minix/debug.h \
- minix/devio.h minix/devman.h minix/dir.h minix/dmap.h \
+ minix/devio.h minix/devman.h minix/dmap.h \
minix/driver.h minix/drivers.h minix/drvlib.h minix/ds.h \
minix/endpoint.h minix/fslib.h minix/gcov.h minix/hash.h \
minix/ioctl.h minix/input.h minix/ipc.h minix/ipcconst.h \
+++ /dev/null
-/* The <dir.h> header gives the layout of a directory. */
-
-#ifndef _DIR_H
-#define _DIR_H
-
-#ifdef __NBSD_LIBC
-#include <sys/cdefs.h>
-#endif
-#include <minix/types.h>
-
-#define DIRBLKSIZ 512 /* size of directory block */
-
-#ifndef DIRSIZ
-#define DIRSIZ 60
-#endif
-
-struct direct {
- ino_t d_ino;
- char d_name[DIRSIZ];
-#ifdef __NBSD_LIBC
-} __packed;
-#else
-};
-#endif
-
-#endif /* _DIR_H */
*/
#endif
-#include <minix/dir.h>
-
/* Minimum sizes required by the POSIX P1003.1 standard (Table 2-3). */
#ifdef _POSIX_SOURCE /* these are only visible for POSIX */
#define _POSIX_ARG_MAX 4096 /* exec() may have 4K worth of args */
#define _POSIX_LINK_MAX 8 /* a file may have 8 links */
#define _POSIX_MAX_CANON 255 /* size of the canonical input queue */
#define _POSIX_MAX_INPUT 255 /* you can type 255 chars ahead */
-#define _POSIX_NAME_MAX DIRSIZ /* max. file name length */
+#define _POSIX_NAME_MAX NAME_MAX /* max. file name length */
#define _POSIX_NGROUPS_MAX 8 /* max. number of supplemental groups */
/* a process may have this many files open */
#endif
#define MAX_CANON 255 /* size of the canonical input queue */
#define MAX_INPUT 255 /* size of the type-ahead buffer */
-#define NAME_MAX DIRSIZ /* # chars in a file name */
+#define NAME_MAX 255 /* system-wide filename limit (up to fs) */
#define PATH_MAX __MINIX_PATH_MAX /* # chars in a path name */
#define PIPE_BUF 32768 /* # bytes in atomic write to a pipe */
#define STREAM_MAX 20 /* must be the same as FOPEN_MAX in stdio.h */
#include <minix/types.h>
#endif
-#include <minix/dir.h>
-
-/* _fl_direct is a flexible directory entry. Actually it's a union of 8
- * characters and the 3 fields defined below.
- */
-
-/* Flexible directory entry: */
-struct _fl_direct { /* First slot in an entry */
- ino_t d_ino;
- unsigned char d_extent;
- char d_name[3]; /* two characters for the shortest name */
-};
-
/* Name of length len needs _EXTENT(len) extra slots. */
#define _EXTENT(len) (((len) + 5) >> 3)
-/* Version 7 directory entry: */
-struct _v7_direct {
- ino_t d_ino;
- char d_name[DIRSIZ];
-};
-
/* The block size must be at least 1024 bytes, because otherwise
* the superblock (at 1024 bytes) overlaps with other filesystem data.
*/
/* This is the block size for the fixed versions of the filesystem (V1/V2) */
#define _STATIC_BLOCK_SIZE 1024
-#define _STATIC_FLEX_PER_BLOCK (_STATIC_BLOCK_SIZE/sizeof(struct _fl_direct))
-#define _FLEX_PER_V7 (_EXTENT(DIRSIZ) + 1)
-#define _FLEX_PER_BLOCK (_STATIC_BLOCK_SIZE/sizeof(struct _fl_direct))
-
/* Definitions for the directory(3) routines: */
typedef struct {
int _fd; /* Filedescriptor of open directory */
#ifndef _MINIX_ANSI_H
#include <minix/ansi.h>
#endif
+#include <minix/types.h>
#include <sys/null.h> /* For NULL */
#define FOPEN_MAX 20
-#include <minix/dir.h>
-#define FILENAME_MAX DIRSIZ
+#define FILENAME_MAX NAME_MAX
#define TMP_MAX 999
#define L_tmpnam (sizeof("/tmp/") + FILENAME_MAX)
INCSDIR= /usr/include.ack/sys
-INCS= asynchio.h dir.h file.h \
+INCS= asynchio.h file.h \
ioctl.h ipc.h jmp_buf.h kbdio.h mman.h \
mount.h mtio.h param.h ptrace.h queue.h resource.h \
select.h sem.h shm.h sigcontext.h signal.h socket.h \
+++ /dev/null
-/*
- * this files resolves conflicts between the file of the host system and
- * the minix specific one. This file is included directly only on Minix
- * and it is an error to do so on any other system
- */
-
-#if !defined(_MINIX) && !defined(__minix) && !defined(__ACK__)
-#error "Including Minix specific file in program targeted for other system"
-#else
-#include <minix/dir.h>
-#endif
mkproto.1 modem.1 mount.1 mt.1 nice.1 nm.1 nohup.1 od.1 \
ossinfo.1 ossmix.1 ossplay.1 ossrecord.1 osstest.1 passwd.1 \
paste.1 ping.1 playwave.1 postmort.1 pr.1 prep.1 \
- profile.1 ps.1 pwd.1 rcp.1 readall.1 readfs.1 recwave.1 \
+ profile.1 ps.1 pwd.1 rcp.1 readall.1 recwave.1 \
ref.1 remsync.1 rget.1 rlogin.1 rmdir.1 rsh.1 rz.1 \
shar.1 acksize.1 sleep.1 sort.1 soundoff.1 soundon.1 spell.1 \
split.1 strip.1 stty.1 su.1 sum.1 svc.1 \
+++ /dev/null
-.TH READFS 1
-.SH NAME
-readfs \- read a MINIX 3 file system
-.SH SYNOPSIS
-\fBreadfs\fR [\fB\-il\fR] \fIblock_special\fR [\fIdir\fR]\fR
-.br
-.de FL
-.TP
-\\fB\\$1\\fR
-\\$2
-..
-.de EX
-.TP 20
-\\fB\\$1\\fR
-# \\$2
-..
-.SH OPTIONS
-.FL "\-i" "Give information about the file, but do not extract files"
-.FL "\-l" "List the files extracted on standard output"
-.SH EXAMPLES
-.EX "readfs \-l /dev/fd0" "List contents of diskette"
-.SH DESCRIPTION
-.PP
-\fIReadfs\fR reads a diskette containing a
-\s-1MINIX 3\s-1
-file system. It can
-extract all the files from it, give a listing of them, or both. The files
-extracted can be put in a user-specified directory (default: current
-directory). If subdirectories are needed, they will be created automatically.
-.SH "SEE ALSO"
-.BR mkproto (1).
-MAN= as.1x awk.1x de.1x dis88.1x elle.1x elvis.1x kermit.1x \
+MAN= as.1x awk.1x dis88.1x elle.1x elvis.1x kermit.1x \
macros.1x mined.1x
.include <bsd.man.mk>
+++ /dev/null
-.so mnx.mac
-.TH DE 1x
-.CD "de \(en disk editor"
-.SX "de\fR [\fB\(enw\fR] \fIblock_device"
-.SX "de \(enr \fIfile
-.FL "\(enr" "Recover a file that has been removed"
-.FL "\(enw" "Enable writing, so device can be modified"
-.EX "de \(enr /usr/ast/prog.c" "Undo the effects of: \fIrm /usr/ast/prog.c\fR"
-.EX "de \(enw /dev/fd0" "Edit \fI/dev/fd0\fR for writing"
-.PP
-The \fIde\fR program allows a system administrator to examine and modify
-a \s-2MINIX\s0 file system device.
-Commands are available to move to any address on the disk
-and display the disk block contents. This information may
-be presented in one of three visual modes: as two-byte words,
-as ASCII characters or as a bit map. The disk may be searched
-for a string of characters. If the \fB\(enw\fR option is given,
-\fIde\fR will open the device for writing and words may be
-modified.
-Without this flag, writing is prohibited.
-Lost blocks and files can be recovered using a variety of
-commands. The \fB\(enr\fR option supports automated recovery of
-files removed by \fIunlink\fR.
-.SS "Positioning"
-.PP
-Disks are divided into blocks (also called \*(OQzones\*(CQ) of 1024
-bytes. \fIDe\fR keeps a current address on the disk as a
-block number and a byte offset within the block. In some
-visual modes the offset is rounded off, for example, in
-\*(OQword\*(CQ mode the offset must be even.
-.PP
-There are different types of blocks on a file system device,
-including a super block, bit maps, i-nodes and data blocks.
-\fIDe\fR knows the type of the current block, but will allow
-most positioning commands and visual modes to function
-anywhere on the disk.
-.PP
-The \fIf\fR command (or PGDN on the keypad) moves forward to the
-next block, similarly \fIb\fR (PGUP) moves backwards one block.
-\fIF\fR (END) moves to the last block and \fIB\fR (HOME) moves to the
-first block.
-.PP
-The arrow keys (or
-\fIu\fR, \fId\fR, \fIl\fR, and \fIr\fR) change the current
-address by small increments. The size of the increment
-depends on the current display mode, as shown below. The
-various sizes suit each display and pointers move on the
-screen to follow each press of an arrow key.
-.HS
-.if t .ta .75iR 1.5iR 2.25iR 3.0iR 3.75iR
-.if n .ta .75i 1.5i 2.25i 3.0i 3.75i
-.nf
-\fB Mode Up Down Left Right\fR
- Word \(mi2 +2 \(mi32 +32
- Block \(mi64 +64 \(mi1 +1
- Map \(mi256 +256 \(mi4 +4
-.fi
-.HS
-The \fIg\fR command allows movement to any specified block.
-Like all commands that take arguments, a prompt and
-subsequent input are written to the bottom line of the
-screen. Numerical entry may be decimal, octal or
-hexadecimal, for example 234, \(mi1, 070, 0xf3, \(miX3C.
-.PP
-While checking an i-node one may want to move to a block
-listed as a zone of the file. The \fIG\fR command takes the
-contents at the current address in the device as a block
-number and indirectly jumps to that block.
-.PP
-The address may be set to the start of any i-node using
-the \fI\fR command and supplying an i-node number. The \fII\fR
-command maps a given file name into an i-node address.
-The file must exist on the current device and this
-device must be mounted.
-.SS "The Display"
-.PP
-The first line of the display contains the device name,
-the name of the current output file (if one is open) and
-the current search string. If \fIde\fR is being run with
-the \fB\(enw\fR option then the device name is flagged with \*(OQ(w).\*(CQ
-If a string is too long to fit on the line it is marked with \*(OQ...\*(CQ.
-.PP
-The second line contains the current block number, the
-total number of blocks, and the type of the current block.
-The types are: boot, super, i-node bit map, zone bit map,
-i-nodes and data block.
-If the current address is
-within a data block then the string \*(OQin use\*(CQ is displayed
-if the block corresponds to a set in the zone bit map.
-.PP
-The third line shows the offset in the current block. If
-the current address is within either the i-node or zone bit
-maps then the i-node or block number corresponding to the
-current bit is shown. If the current address is within an
-i-node then the i-node number and \*(OQin use\*(CQ status is displayed.
-If the address is within a bit map or i-node block, but past
-the last usable entry, then the string \*(OQpadding\*(CQ is shown.
-.PP
-The rest of the screen is used to display data from the
-current block. There are three visual display modes:
-\*(OQword,\*(CQ \*(OQblock,\*(CQ and \*(OQmap.\*(CQ
-The \fIv\fR command followed by
-\fIw\fR, \fIb\fR, or \fIm\fR sets the current display mode.
-.PP
-In \*(OQword\*(CQ mode 16 words, of two bytes each, are shown in
-either base 2, 8, 10 or 16. The current base is displayed
-to the far right of the screen. It can be changed using the
-\fIo\fR command followed by either an \fIh\fR (hexadecimal), \fId\fR
-(decimal), \fIo\fR (octal) or \fIb\fR (binary).
-.PP
-\fIDe\fR knows where i-nodes are, and will display the
-contents in a readable format, including the \fIrwx\fR bits,
-the user name and the time field. If the current page
-is at the beginning of the super block, or an executable
-file or an \fIar\fR archive, then \fIde\fR will also inform
-the user. In all other cases the contents of the 16
-words are shown to the right as equivalent ASCII
-characters.
-.PP
-In \*(OQblock\*(CQ mode a whole block of 1024 bytes is displayed
-as ASCII characters, 64 columns by 16 lines. Control codes
-are shown as highlighted characters. If the high order bit
-is set in any of the 1024 bytes then an \*(OQMSB\*(CQ flag is shown
-on the far right of the screen, but these bytes are not
-individually marked.
-.PP
-In \*(OQmap\*(CQ mode 2048 bits (256 bytes) are displayed from the
-top to the bottom (32 bits) and from the left to the right
-of the screen. Bit zero of a byte is towards the top of the
-screen. This visual mode is generally used to observe
-the bit map blocks. The number of set bits displayed is
-written on the far right of the screen.
-.SS "Searching"
-.PP
-A search for an ASCII string is initiated by the \fI/\fR command.
-Control characters not used for other purposes may be
-entered in the search string, for example CTRL-J is an end-of-line
-character. The search is from the current position to
-the end of the current device.
-.PP
-Once a search string has been defined by a use of \fI/\fR, the
-next search may be initiated with the \fIn\fR command, (a \fI/\fR
-followed immediately by an ENTER is equivalent to an \fIn\fR).
-.PP
-Whenever a search is in progress \fIde\fR will append
-one \fI.\fR to the prompt line for every 500 blocks searched. If the
-string is found between the end of the file system and the
-actual end of the device, then the current address is set to
-the end of the file system.
-.PP
-Some of the positioning commands push the current address
-and visual mode in a stack before going to a new address.
-These commands are
-\fIB\fR, \fIF\fR, \fIg\fR, \fIG\fR, \fIi\fR, \fII\fR, \fIn\fR, \fIx\fR and
-\fI/\fR.
-The \fIp\fR
-(previous) command pops the last address and visual mode
-from the stack. This stack is eight entries deep.
-.SS "Modifying the File System"
-.PP
-The \fIs\fR command will prompt for a data word and store it at
-the current address on the disk. This is used to change
-information that can not be easily changed by any other
-means.
-.PP
-The data word is 16 bits wide, it may be entered in decimal,
-octal or hexadecimal. Remember that the \fB\(enw\fR option must
-be specified for the \fIs\fR command to operate. Be careful
-when modifying a mounted file system.
-.SS "Recovering Files"
-.PP
-Any block on the disk may be written to an output file.
-This is used to recover blocks marked as free on the
-disk. A write command will request a file name the first
-time it is used, on subsequent writes the data is appended
-to the current output file.
-.PP
-The name of the current output file is changed using the
-\fIc\fR command. This file should be on a different file system,
-to avoid overwriting an i-node or block before it is
-recovered.
-.PP
-An ASCII block is usually recovered using the \fIw\fR command.
-All bytes will have their most significant bit cleared before
-being written to the output file. Bytes containing '\\0'
-or '\\177' are not copied. The \fIW\fR command writes the current
-block (1024 bytes exactly) to the output file.
-.PP
-When a file is deleted using \fIunlink\fR the i-node number
-in the directory is zeroed, but before its removal, it is
-copied into the end of the file name field. This allows
-the i-node of a deleted file to be found by searching
-through a directory. The \fIx\fR command asks for the path
-name of a lost file, extracts the old i-node number and
-changes the current disk address to the start of the
-i-node.
-.PP
-Once an i-node is found, all of the freed blocks may be
-recovered by checking the i-node zone fields, using 'G'
-to go to a block, writing it back out using 'w', going
-back to the i-node with \fIp\fR and advancing to the next
-block. This file extraction process is automated by using
-the \fIX\fR command, which goes through the i-node, indirect
-and double indirect blocks finding all the block pointers
-and recovering all the blocks of the file.
-.PP
-The \fIX\fR command closes the current output file and asks
-for the name of a new output file. All of the disk blocks
-must be marked as free, if they are not the command stops
-and the file must be recovered manually.
-.PP
-When extracting lost blocks \fIde\fR will maintain \*(OQholes\*(CQ in
-the file. Thus, a recovered sparse file does not allocate
-unused blocks and will keep its efficient storage scheme.
-This property of the \fIX\fR command may be used to move a sparse
-file from one device to another.
-.PP
-Automatic recovery may be initiated by the \fB\(enr\fR option on
-the command line. Also specified is the path name of a
-file just removed by \fIunlink\fR. \fIDe\fR determines which
-mounted file system device held the file and opens it for
-reading. The lost i-node is found and the file extracted by
-automatically performing an \fIx\fR and an \fIX\fR command.
-.PP
-The recovered file will be written to \fI/tmp\fR. \fIDe\fR will
-refuse to automatically recover a file on the same file
-system as \fI/tmp\fR. The lost file must have belonged to the
-user. If automatic recovery will not complete, then manual
-recovery may be performed.
-.SS "Miscellaneous"
-.PP
-The user can terminate a session with \fIde\fR by typing
-\fIq\fR, CTRL-D, or the key associated with SIGQUIT.
-.PP
-The \fIm\fR command invokes the \s-2MINIX\s0 \fIsh\fR shell as a subprocess.
-.PP
-For help while using \fIde\fR use \fIh\fR.
-.SS "Command Summary"
-.LP
-.ta 0.25i 1.0i 1.5i
-.nf
-.sp
- PGUP b Back one block
- PGDN f Forward one block
- HOME B Goto first block
- END F Goto last block
- UP u Move back 2/64/256 bytes
- DOWN d Move forward 2/64/256 bytes
- LEFT l Move back 32/1/4 bytes
- RIGHT r Move forward 32/1/4 bytes
- g Goto specified block
- G Goto block indirectly
- i Goto specified i-node
- I Filename to i-node
- / Search
- n Next occurrence
- p Previous address
- h Help
- EOF q Quit
- m \s-2MINIX\s0 shell
- v Visual mode (w b m)
- o Output base (h d o b)
- c Change file name
- w Write ASCII block
- W Write block exactly
- x Extract lost directory entry
- X Extract lost file blocks
- s Store word
-.fi
-.sp
-NOTES:
-When entering a line in response to a prompt from \fIde\fR
-there are a couple of editing characters available. The
-previous character may be erased by typing CTRL-H and the
-whole line may be erased by typing CTRL-U. ENTER terminates
-the input. If DELETE or a non-ASCII character is typed
-then the command requesting the input is aborted.
-.PP
-The commands \fIG\fR, \fIs\fR and \fIX\fR will only function if
-the current visual display mode is \*(OQword.\*(CQ
-The commands
-\fIi\fR, \fII\fR and \fIx\fR change the mode to \*(OQword\*(CQ on
-completion. The commands \fIG\fR and \fI/\fR change the mode
-to \*(OQblock\*(CQ. These restrictions and automatic mode
-conversions are intended to aid the user.
-.PP
-The \*(OQmap\*(CQ mode uses special graphic characters, and
-only functions if the user is at the console.
-.PP
-\fIDe\fR generates warnings for illegal user input or if
-erroneous data is found on the disk, for example a
-corrupted magic number. Warnings appear in the middle
-of the screen for two seconds, then the current page
-is redrawn. Some minor errors, for example, setting
-an unknown visual mode, simply ring the bell. Major
-errors, for example I/O problems on the file system
-device cause an immediate exit from \fIde\fR.
-.PP
-The i-node and zone bit maps are read from the device
-when \fIde\fR starts up. These determine whether \*(OQin use\*(CQ
-or \*(OQnot in use\*(CQ is displayed in the status field at
-the top of the screen. The bit maps are not re-read
-while using \fIde\fR and will become out-of-date if
-observing a mounted file system.
-.PP
-\fIDe\fR requires termcap definitions for \*(OQcm\*(CQ and \*(OQcl\*(CQ.
-Furthermore, \*(OQso\*(CQ and \*(OQse\*(CQ will also be used if available.
-The ANSI strings generated by the keypad arrows are recognized,
-as well as any single character codes defined by \*(OQku\*(CQ,
-\*(OQkd\*(CQ, \*(OQkl\*(CQ and \*(OQkr\*(CQ.
-.SS "Author"
-.PP
-The \fIde\fR program was written by Terrence Holm.
#if defined(_NETBSD_SOURCE)
-#ifndef __minix
/* definitions for library routines operating on directories. */
#define DIRBLKSIZ 1024
-#endif
/* structure describing an open directory. */
struct _dirdesc {
#define _DIRENT_H
#include <sys/cdefs.h>
-#include <minix/dir.h>
-
-/* _fl_direct is a flexible directory entry. Actually it's a union of 8
- * characters and the 3 fields defined below.
- */
-
-/* Flexible directory entry: */
-struct _fl_direct { /* First slot in an entry */
- ino_t d_ino;
- unsigned char d_extent;
- char d_name[3]; /* two characters for the shortest name */
-};
/* Name of length len needs _EXTENT(len) extra slots. */
#define _EXTENT(len) (((len) + 5) >> 3)
-/* Version 7 directory entry: */
-struct _v7_direct {
- ino_t d_ino;
- char d_name[DIRSIZ];
-};
-
/* The block size must be at least 1024 bytes, because otherwise
* the superblock (at 1024 bytes) overlaps with other filesystem data.
*/
/* This is the block size for the fixed versions of the filesystem (V1/V2) */
#define _STATIC_BLOCK_SIZE 1024
-#define _STATIC_FLEX_PER_BLOCK (_STATIC_BLOCK_SIZE/sizeof(struct _fl_direct))
-#define _FLEX_PER_V7 (_EXTENT(DIRSIZ) + 1)
-#define _FLEX_PER_BLOCK (_STATIC_BLOCK_SIZE/sizeof(struct _fl_direct))
-
#endif /* _DIRENT_H */
INCS+= ansi.h atomic.h \
bitops.h bswap.h \
cdefs.h cdefs_aout.h cdefs_elf.h ctype_bits.h ctype_inline.h \
- dir.h dirent.h exec_elf.h \
+ dirent.h exec_elf.h \
endian.h errno.h \
fcntl.h fd_set.h featuretest.h file.h \
float_ieee754.h gcq.h gmon.h hash.h \
+++ /dev/null
-/*
- * this files resolves conflicts between the file of the host system and
- * the minix specific one. This file is included directly only on Minix
- * and it is an error to do so on any other system
- */
-
-#if !defined(_MINIX) || !defined(__minix)
-#error "Including Minix specific file in program targeted for other system"
-#else
-#include <minix/dir.h>
-#endif
#define LINK_MAX SHRT_MAX /* # links a file may have */
#define MAX_CANON 255 /* size of the canonical input queue */
#define MAX_INPUT 255 /* size of the type-ahead buffer */
-#define NAME_MAX 60 /* # chars in a file name (actually DIRSZ) */
+#define NAME_MAX 255 /* system-wide max # chars in a file name */
#define NGROUPS_MAX 8 /* max. number of supplemental groups */
#define UID_MAX SHRT_MAX /* max value for a uid_t */
#ifndef OPEN_MAX
#ifndef EXT2_BUF_H
#define EXT2_BUF_H
-#include <sys/dir.h> /* need struct direct */
#include <dirent.h>
union fsdata_u {
-#include <sys/dir.h> /* need struct direct */
#include <dirent.h>
PUBLIC struct buf {
- union {
- char b__data[_MAX_BLOCK_SIZE]; /* ordinary user data */
- struct direct b__dir[NR_DIR_ENTRIES(_MAX_BLOCK_SIZE)];/* directory block */
- } b;
-
+ char b_data[_MAX_BLOCK_SIZE]; /* ordinary user data */
block_t b_blocknr; /* block number of its (minor) device */
char b_count; /* number of users of this buffer */
} buf[NR_BUFS];
/* A block is free if b_dev == NO_DEV. */
-
-/* These defs make it possible to use to bp->b_data instead of bp->b.b__data */
-#define b_data b.b__data
-#define b_dir b.b__dir
-
#define INODE_BLOCK 0 /* inode block */
#define DIRECTORY_BLOCK 1 /* directory block */
* will eventually be rewritten to the disk.
*/
-#include <sys/dir.h> /* need struct direct */
#include <dirent.h>
union fsdata_u {
#define INODE_HASH_SIZE ((unsigned long)1<<INODE_HASH_LOG2)
#define INODE_HASH_MASK (((unsigned long)1<<INODE_HASH_LOG2)-1)
+/* Max. filename length */
+#define MFS_NAME_MAX MFS_DIRSIZ
+
/* The type of sizeof may be (unsigned) long. Use the following macro for
* taking the sizes of small objects so that there are no surprises like
#include <minix/syslib.h>
#include <minix/sysutil.h>
+#include "mfsdir.h"
#include "const.h"
#include "type.h"
#include "proto.h"
FORWARD _PROTOTYPE( int freesp_inode, (struct inode *rip, off_t st,
off_t end) );
FORWARD _PROTOTYPE( int remove_dir, (struct inode *rldirp,
- struct inode *rip, char dir_name[NAME_MAX]) );
+ struct inode *rip, char dir_name[MFS_NAME_MAX]) );
FORWARD _PROTOTYPE( int unlink_file, (struct inode *dirp,
- struct inode *rip, char file_name[NAME_MAX]) );
+ struct inode *rip, char file_name[MFS_NAME_MAX]) );
FORWARD _PROTOTYPE( off_t nextblock, (off_t pos, int zone_size) );
FORWARD _PROTOTYPE( void zerozone_half, (struct inode *rip, off_t pos,
int half, int zone_size) );
struct inode *ip, *rip;
register int r;
- char string[NAME_MAX];
+ char string[MFS_NAME_MAX];
struct inode *new_ip;
phys_bytes len;
register struct inode *rip;
struct inode *rldirp;
int r;
- char string[NAME_MAX];
+ char string[MFS_NAME_MAX];
phys_bytes len;
/* Copy the last component */
PRIVATE int remove_dir(rldirp, rip, dir_name)
struct inode *rldirp; /* parent directory */
struct inode *rip; /* directory to be removed */
-char dir_name[NAME_MAX]; /* name of directory to be removed */
+char dir_name[MFS_NAME_MAX]; /* name of directory to be removed */
{
/* A directory file has to be removed. Five conditions have to met:
* - The file must be a directory
PRIVATE int unlink_file(dirp, rip, file_name)
struct inode *dirp; /* parent directory of file */
struct inode *rip; /* inode of file, may be NULL too. */
-char file_name[NAME_MAX]; /* name of file to be removed */
+char file_name[MFS_NAME_MAX]; /* name of file to be removed */
{
/* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
int r = OK; /* error flag; initially no error */
int odir, ndir; /* TRUE iff {old|new} file is dir */
int same_pdir; /* TRUE iff parent dirs are the same */
- char old_name[NAME_MAX], new_name[NAME_MAX];
+ char old_name[MFS_NAME_MAX], new_name[MFS_NAME_MAX];
ino_t numb;
phys_bytes len;
--- /dev/null
+#ifndef _MFSDIR_H
+#define _MFSDIR_H
+
+#ifdef __NBSD_LIBC
+#include <sys/cdefs.h>
+#endif
+#include <minix/types.h>
+
+/* Maximum Minix MFS on-disk directory filename.
+ * MFS uses 'struct direct' to write and parse
+ * directory entries, so this can't be changed
+ * without breaking filesystems.
+ */
+
+#define MFS_DIRSIZ 60
+
+struct direct {
+ ino_t mfs_d_ino;
+ char mfs_d_name[MFS_DIRSIZ];
+#ifdef __NBSD_LIBC
+} __packed;
+#else
+};
+#endif
+
+#endif /* _MFSDIR_H */
struct inode *ldirp;
struct inode *rip;
mode_t omode;
- char lastc[NAME_MAX];
+ char lastc[MFS_NAME_MAX];
/* Read request message */
omode = (mode_t) fs_m_in.REQ_MODE;
PUBLIC int fs_mknod()
{
struct inode *ip, *ldirp;
- char lastc[NAME_MAX];
+ char lastc[MFS_NAME_MAX];
phys_bytes len;
/* Copy the last component and set up caller's user and group id */
int r1, r2; /* status codes */
ino_t dot, dotdot; /* inode numbers for . and .. */
struct inode *rip, *ldirp;
- char lastc[NAME_MAX]; /* last component */
+ char lastc[MFS_NAME_MAX]; /* last component */
phys_bytes len;
/* Copy the last component and set up caller's user and group id */
struct inode *sip; /* inode containing symbolic link */
struct inode *ldirp; /* directory containing link */
register int r; /* error code */
- char string[NAME_MAX]; /* last component of the new dir's path name */
+ char string[MFS_NAME_MAX]; /* last component of the new dir's path name */
struct buf *bp; /* disk buffer for link */
caller_uid = (uid_t) fs_m_in.REQ_UID;
* to an appropriate value (OK or an error code).
*
* The parsed path rest is returned in 'parsed' if parsed is nonzero. It
- * has to hold at least NAME_MAX bytes.
+ * has to hold at least MFS_NAME_MAX bytes.
*/
register struct inode *rip;
PUBLIC char dot1[2] = "."; /* used for search_dir to bypass the access */
PUBLIC char dot2[3] = ".."; /* permissions for . and .. */
-FORWARD _PROTOTYPE( char *get_name, (char *name, char string[NAME_MAX+1]) );
+FORWARD _PROTOTYPE( char *get_name, (char *name, char string[MFS_NAME_MAX+1]) );
FORWARD _PROTOTYPE( int ltraverse, (struct inode *rip, char *suffix) );
FORWARD _PROTOTYPE( int parse_path, (ino_t dir_ino, ino_t root_ino,
int flags, struct inode **res_inop,
int r, leaving_mount;
struct inode *rip, *dir_ip;
char *cp, *next_cp; /* component and next component */
- char component[NAME_MAX+1];
+ char component[MFS_NAME_MAX+1];
/* Start parsing path at the first component in user_path */
cp = user_path;
*===========================================================================*/
PUBLIC struct inode *advance(dirp, string, chk_perm)
struct inode *dirp; /* inode for directory to be searched */
-char string[NAME_MAX]; /* component name to look for */
+char string[MFS_NAME_MAX]; /* component name to look for */
int chk_perm; /* check permissions when string is looked up*/
{
/* Given a directory and a component of a path, look up the component in
*===========================================================================*/
PRIVATE char *get_name(path_name, string)
char *path_name; /* path name to parse */
-char string[NAME_MAX+1]; /* component extracted from 'old_name' */
+char string[MFS_NAME_MAX+1]; /* component extracted from 'old_name' */
{
/* Given a pointer to a path name in fs space, 'path_name', copy the first
* component to 'string' (truncated if necessary, always nul terminated).
len = (size_t) (ep - cp);
- /* Truncate the amount to be copied if it exceeds NAME_MAX */
- if (len > NAME_MAX) len = NAME_MAX;
+ /* Truncate the amount to be copied if it exceeds MFS_NAME_MAX */
+ if (len > MFS_NAME_MAX) len = MFS_NAME_MAX;
/* Special case of the string at cp is empty */
if (len == 0)
*===========================================================================*/
PUBLIC int search_dir(ldir_ptr, string, numb, flag, check_permissions)
register struct inode *ldir_ptr; /* ptr to inode for dir to search */
-char string[NAME_MAX]; /* component to search for */
+char string[MFS_NAME_MAX]; /* component to search for */
ino_t *numb; /* pointer to inode number */
int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
int check_permissions; /* check permissions when flag is !IS_EMPTY */
}
/* Match occurs if string found. */
- if (flag != ENTER && dp->d_ino != NO_ENTRY) {
+ if (flag != ENTER && dp->mfs_d_ino != NO_ENTRY) {
if (flag == IS_EMPTY) {
/* If this test succeeds, dir is not empty. */
- if (strcmp(dp->d_name, "." ) != 0 &&
- strcmp(dp->d_name, "..") != 0) match = 1;
+ if (strcmp(dp->mfs_d_name, "." ) != 0 &&
+ strcmp(dp->mfs_d_name, "..") != 0) match = 1;
} else {
- if (strncmp(dp->d_name, string, NAME_MAX) == 0){
+ if (strncmp(dp->mfs_d_name, string,
+ sizeof(dp->mfs_d_name)) == 0){
match = 1;
}
}
if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) {
/* Save d_ino for recovery. */
- t = NAME_MAX - sizeof(ino_t);
- *((ino_t *) &dp->d_name[t]) = dp->d_ino;
- dp->d_ino = NO_ENTRY; /* erase entry */
+ t = MFS_NAME_MAX - sizeof(ino_t);
+ *((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
+ dp->mfs_d_ino = NO_ENTRY; /* erase entry */
bp->b_dirt = DIRTY;
ldir_ptr->i_update |= CTIME | MTIME;
ldir_ptr->i_dirt = DIRTY;
} else {
sp = ldir_ptr->i_sp; /* 'flag' is LOOK_UP */
*numb = (ino_t) conv4(sp->s_native,
- (int) dp->d_ino);
+ (int) dp->mfs_d_ino);
}
put_block(bp, DIRECTORY_BLOCK);
return(r);
}
/* Check for free slot for the benefit of ENTER. */
- if (flag == ENTER && dp->d_ino == 0) {
+ if (flag == ENTER && dp->mfs_d_ino == 0) {
e_hit = TRUE; /* we found a free slot */
break;
}
}
/* 'bp' now points to a directory block with space. 'dp' points to slot. */
- (void) memset(dp->d_name, 0, (size_t) NAME_MAX); /* clear entry */
- for (i = 0; i < NAME_MAX && string[i]; i++) dp->d_name[i] = string[i];
+ (void) memset(dp->mfs_d_name, 0, (size_t) MFS_NAME_MAX); /* clear entry */
+ for (i = 0; i < MFS_NAME_MAX && string[i]; i++) dp->mfs_d_name[i] = string[i];
sp = ldir_ptr->i_sp;
- dp->d_ino = conv4(sp->s_native, (int) *numb);
+ dp->mfs_d_ino = conv4(sp->s_native, (int) *numb);
bp->b_dirt = DIRTY;
put_block(bp, DIRECTORY_BLOCK);
ldir_ptr->i_update |= CTIME | MTIME; /* mark mtime for update later */
/* path.c */
_PROTOTYPE( int fs_lookup, (void) );
_PROTOTYPE( struct inode *advance, (struct inode *dirp,
- char string[NAME_MAX], int chk_perm) );
+ char string[MFS_NAME_MAX], int chk_perm) );
_PROTOTYPE( int search_dir, (struct inode *ldir_ptr,
- char string [NAME_MAX], ino_t *numb, int flag,
+ char string [MFS_NAME_MAX], ino_t *numb, int flag,
int check_permissions) );
else
dp = &bp->b_dir[0];
for (; dp < &bp->b_dir[NR_DIR_ENTRIES(block_size)]; dp++) {
- if (dp->d_ino == 0)
+ if (dp->mfs_d_ino == 0)
continue; /* Entry is not in use */
/* Compute the length of the name */
- cp = memchr(dp->d_name, '\0', NAME_MAX);
+ cp = memchr(dp->mfs_d_name, '\0', sizeof(dp->mfs_d_name));
if (cp == NULL)
- len = NAME_MAX;
+ len = sizeof(dp->mfs_d_name);
else
- len = cp - (dp->d_name);
+ len = cp - (dp->mfs_d_name);
/* Compute record length */
reclen = offsetof(struct dirent, d_name) + len + 1;
}
dep = (struct dirent *) &getdents_buf[tmpbuf_off];
- dep->d_ino = dp->d_ino;
+ dep->d_ino = dp->mfs_d_ino;
dep->d_off = ent_pos;
dep->d_reclen = (unsigned short) reclen;
- memcpy(dep->d_name, dp->d_name, len);
+ memcpy(dep->d_name, dp->mfs_d_name, len);
dep->d_name[len] = '\0';
tmpbuf_off += reclen;
}
st.f_favail = st.f_ffree;
st.f_fsid = fs_dev;
st.f_flag = (sp->s_rd_only == 1 ? ST_RDONLY : 0);
- st.f_namemax = NAME_MAX;
+ st.f_namemax = MFS_DIRSIZ;
/* Copy the struct to user space. */
r = sys_safecopyto(fs_m_in.m_source, fs_m_in.REQ_GRANT, 0, (vir_bytes) &st,
