chore: remove mkfs.stpd
This commit is contained in:
parent
7260b03fca
commit
8f6f833495
|
|
@ -1,175 +0,0 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#define MAGIC 0x44505453
|
||||
|
||||
#define BLOCK_SIZE 512
|
||||
|
||||
struct superblock {
|
||||
uint32_t magic;
|
||||
uint32_t isize;
|
||||
uint32_t fsize;
|
||||
uint32_t free[100];
|
||||
uint8_t nfree;
|
||||
uint8_t flock;
|
||||
uint8_t ilock;
|
||||
uint8_t fmod;
|
||||
uint32_t time[2];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct inode {
|
||||
uint16_t mode;
|
||||
uint8_t nlink;
|
||||
uint8_t uid;
|
||||
uint8_t gid;
|
||||
uint32_t size;
|
||||
uint16_t addr[8];
|
||||
uint32_t actime[2];
|
||||
uint32_t modtime[2];
|
||||
} __attribute__((packed));
|
||||
|
||||
#define INODE_SIZE sizeof(struct inode)
|
||||
|
||||
struct file {
|
||||
unsigned short inode;
|
||||
char filename[14];
|
||||
};
|
||||
|
||||
static const char *prg_name = NULL;
|
||||
static int verbose = 0;
|
||||
static const char *device = NULL;
|
||||
static int devfd = 0;
|
||||
static off_t device_size = 0;
|
||||
|
||||
static int
|
||||
write_sector(size_t secnum, const uint8_t *data, size_t buff_size)
|
||||
{
|
||||
uint8_t buffer[BLOCK_SIZE];
|
||||
|
||||
if (lseek(devfd, secnum * BLOCK_SIZE, SEEK_SET) != (secnum * BLOCK_SIZE))
|
||||
{
|
||||
fprintf(stderr, "%s: %s\n", device, strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
memset(buffer, 0, BLOCK_SIZE);
|
||||
memcpy(buffer, data, buff_size);
|
||||
|
||||
if (write(devfd, buffer, BLOCK_SIZE) != BLOCK_SIZE)
|
||||
{
|
||||
fprintf(stderr, "%s: x %s\n", device, strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
usage(int retcode)
|
||||
{
|
||||
if (retcode == EXIT_FAILURE)
|
||||
{
|
||||
fprintf(stderr, "Try '%s -h' for more informations.\n", prg_name);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("Usage: %s [-hVv] disk\n", prg_name);
|
||||
printf("\t-h\tdisplay this help and exit\n");
|
||||
printf("\t-V\toutput version information.\n");
|
||||
printf("\nReport bugs to <%s>\n", MK_BUGREPORT);
|
||||
}
|
||||
|
||||
exit(retcode);
|
||||
}
|
||||
|
||||
static void
|
||||
version(void)
|
||||
{
|
||||
printf("%s commit %s\n", prg_name, MK_COMMIT);
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
struct stat inf;
|
||||
int idx;
|
||||
uint8_t buffer[BLOCK_SIZE];
|
||||
struct superblock sb;
|
||||
|
||||
prg_name = argv[0];
|
||||
|
||||
while ((argc > 1) && (argv[1][0]) == '-')
|
||||
{
|
||||
switch (argv[1][1])
|
||||
{
|
||||
case 'h':
|
||||
usage(EXIT_SUCCESS);
|
||||
break;
|
||||
case 'V':
|
||||
version();
|
||||
break;
|
||||
case 'v':
|
||||
verbose=1;
|
||||
break;
|
||||
default:
|
||||
usage(EXIT_FAILURE);
|
||||
}
|
||||
argv++;
|
||||
argc--;
|
||||
}
|
||||
|
||||
if (argc <= 1) usage(EXIT_FAILURE);
|
||||
|
||||
device = argv[1];
|
||||
|
||||
if (stat(device, &inf) != 0)
|
||||
{
|
||||
fprintf(stderr, "%s: %s\n", device, strerror(errno));
|
||||
return (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
device_size = inf.st_size;
|
||||
|
||||
if (verbose) printf("Device size: %ld (%ld blocks)\n", device_size, device_size/BLOCK_SIZE);
|
||||
|
||||
/*if (device_size/BLOCK_SIZE > 0x7fff)
|
||||
{
|
||||
fprintf(stderr, "%s: File too large\n", device);
|
||||
return (EXIT_FAILURE);
|
||||
}*/
|
||||
|
||||
/* */
|
||||
|
||||
devfd = open(device, O_WRONLY);
|
||||
if (devfd < 0)
|
||||
{
|
||||
fprintf(stderr, "%s: %s\n", device, strerror(errno));
|
||||
return (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
memset(buffer, 0, BLOCK_SIZE);
|
||||
for (idx = 0; idx < device_size/BLOCK_SIZE; idx++)
|
||||
{
|
||||
write_sector(idx, buffer, BLOCK_SIZE);
|
||||
}
|
||||
if (verbose) printf("Write %ld (%ld bytes)\n", device_size/BLOCK_SIZE, device_size);
|
||||
|
||||
memset(&sb, 0, sizeof(struct superblock));
|
||||
|
||||
sb.magic = MAGIC;
|
||||
sb.fsize = device_size/BLOCK_SIZE;
|
||||
|
||||
write_sector(1, (uint8_t *)&sb, sizeof(struct superblock));
|
||||
|
||||
//sb.ninode = (device_size/BLOCK_SIZE) / 8;
|
||||
|
||||
printf("sizeof %lu %lu\n", sizeof(struct superblock), sizeof(struct inode));
|
||||
|
||||
close(devfd);
|
||||
|
||||
return (EXIT_SUCCESS);
|
||||
}
|
||||
|
|
@ -1,304 +0,0 @@
|
|||
|
||||
V6/usr/man/man5/fs.5
|
||||
Compare this file to the similar file:
|
||||
|
||||
Show the results in this format:
|
||||
|
||||
.TH "FILE SYSTEM" V 2/9/75
|
||||
.SH NAME
|
||||
fs \*- format of file system volume
|
||||
.SH DESCRIPTION
|
||||
Every
|
||||
file system storage volume
|
||||
(e.g. RF disk, RK disk, RP disk, DECtape reel)
|
||||
has a common format for certain vital information.
|
||||
Every such volume is divided into a certain number
|
||||
of 256 word (512 byte) blocks.
|
||||
Block 0 is unused and is available to contain
|
||||
a bootstrap program, pack label, or other information.
|
||||
.s3
|
||||
Block 1 is the
|
||||
.IB "super block."
|
||||
Starting from its first word, the format of a super-block is
|
||||
.s3
|
||||
.nf
|
||||
struct {
|
||||
int isize;
|
||||
int fsize;
|
||||
int nfree;
|
||||
int free[100];
|
||||
int ninode;
|
||||
int inode[100];
|
||||
char flock;
|
||||
char ilock;
|
||||
char fmod;
|
||||
int time[2];
|
||||
};
|
||||
.s3
|
||||
.fi
|
||||
.IP Isize
|
||||
is the number of blocks devoted to the i-list,
|
||||
which starts just after the super-block, in block 2.
|
||||
.IP Fsize
|
||||
is the first block not potentially available for allocation
|
||||
to a file.
|
||||
These numbers are used by the system to
|
||||
check for bad block numbers;
|
||||
if an ``impossible'' block number is allocated from the free list
|
||||
or is freed,
|
||||
a diagnostic is written on the on-line console.
|
||||
Moreover, the free array is cleared, so as to prevent further
|
||||
allocation from a presumably corrupted free list.
|
||||
.s3
|
||||
The free list for each volume is maintained as
|
||||
follows.
|
||||
The
|
||||
.IB free
|
||||
array contains, in
|
||||
.IB "free[1], ... , free[nfree\*-1],"
|
||||
up to 99 numbers of free blocks.
|
||||
.IB Free[0]
|
||||
is the block number of the head
|
||||
of a chain of blocks constituting the free list.
|
||||
The first word in each free-chain block is the number
|
||||
(up to 100) of free-block numbers listed in the
|
||||
next 100 words of this chain member.
|
||||
The first of these 100 blocks is the link to the
|
||||
next member of the chain.
|
||||
To allocate a block:
|
||||
decrement
|
||||
.IB nfree,
|
||||
and the new block is
|
||||
.IB free[nfree].
|
||||
If the new block number is 0,
|
||||
there are no blocks left, so give an error.
|
||||
If
|
||||
.IB nfree
|
||||
became 0,
|
||||
read in the block named by the new block number,
|
||||
replace
|
||||
.IB nfree
|
||||
by its first word,
|
||||
and copy the block numbers in the next 100 words into the
|
||||
.IB free
|
||||
array.
|
||||
To free a block, check if
|
||||
.IB nfree
|
||||
is 100; if so,
|
||||
copy
|
||||
.IB nfree
|
||||
and the
|
||||
.IB free
|
||||
array into it,
|
||||
write it out, and set
|
||||
.IB nfree
|
||||
to 0.
|
||||
In any event set
|
||||
.IB free[nfree]
|
||||
to the freed block's number and
|
||||
increment
|
||||
.IB nfree.
|
||||
.s3
|
||||
.IB Ninode
|
||||
is the number of free i-numbers in the
|
||||
.IB inode
|
||||
array.
|
||||
To allocate an i-node:
|
||||
if
|
||||
.IB ninode
|
||||
is greater than 0,
|
||||
decrement it and return
|
||||
.IB inode[ninode].
|
||||
If it was 0, read the i-list
|
||||
and place the numbers of all free inodes
|
||||
(up to 100) into the
|
||||
.IB inode
|
||||
array,
|
||||
then try again.
|
||||
To free an i-node,
|
||||
provided
|
||||
.IB ninode
|
||||
is less than 100,
|
||||
place its number into
|
||||
.IB inode[ninode]
|
||||
and increment
|
||||
.IB ninode.
|
||||
If
|
||||
.IB ninode
|
||||
is already 100, don't bother to enter the freed i-node into any table.
|
||||
This list of i-nodes is only to speed
|
||||
up the allocation process; the information
|
||||
as to whether the inode is really free
|
||||
or not is maintained in the inode itself.
|
||||
.s3
|
||||
.IB Flock
|
||||
and
|
||||
.IB ilock
|
||||
are flags maintained in the core
|
||||
copy of the file system
|
||||
while it is mounted
|
||||
and their values on disk are immaterial.
|
||||
The value of
|
||||
.IB fmod
|
||||
on disk is likewise immaterial;
|
||||
it is used as a flag to indicate that the super-block has
|
||||
changed and should be copied to
|
||||
the disk during the next periodic update of file
|
||||
system information.
|
||||
.s3
|
||||
.IB Time
|
||||
is the last time the super-block of the file system was changed,
|
||||
and is a double-precision representation
|
||||
of the number of seconds that have elapsed
|
||||
since
|
||||
0000 Jan. 1 1970 (GMT).
|
||||
During a reboot, the
|
||||
.IB time
|
||||
of the super-block for the root file system
|
||||
is used to set the system's idea of the time.
|
||||
.s3
|
||||
I-numbers begin at 1, and the storage for i-nodes
|
||||
begins in block 2.
|
||||
.tr |
|
||||
Also, i-nodes are 32 bytes long, so 16 of them fit into a block.
|
||||
Therefore, i-node
|
||||
.IB i
|
||||
is located in block (\fIi\fR|+|31)|/|16, and begins
|
||||
32\u\fB.\fR\d((\fIi\fR|+|31)|(mod 16) bytes from its start.
|
||||
I-node 1 is reserved for the root directory of the file
|
||||
system, but no other i-number has a built-in
|
||||
meaning.
|
||||
Each i-node represents one file.
|
||||
The format of an i-node is as follows.
|
||||
.s3
|
||||
.nf
|
||||
.if t .ta .5i 1.i 2.5i
|
||||
struct {
|
||||
int flags; /* +0: see below */
|
||||
char nlinks; /* +2: number of links to file */
|
||||
char uid; /* +3: user ID of owner */
|
||||
char gid; /* +4: group ID of owner */
|
||||
char size0; /* +5: high byte of 24-bit size */
|
||||
int size1; /* +6: low word of 24-bit size */
|
||||
int addr[8]; /* +8: block numbers or device number */
|
||||
int actime[2]; /* +24: time of last access */
|
||||
int modtime[2]; /* +28: time of last modification */
|
||||
};
|
||||
.dt
|
||||
.fi
|
||||
.s3
|
||||
The flags are as follows:
|
||||
.s3
|
||||
.lp +10 9
|
||||
100000 i-node is allocated
|
||||
.lp +10 9
|
||||
060000 2-bit file type:
|
||||
.lp +15 9
|
||||
000000 plain file
|
||||
.lp +15 9
|
||||
040000 directory
|
||||
.lp +15 9
|
||||
020000 character-type special file
|
||||
.lp +15 9
|
||||
060000 block-type special file.
|
||||
.lp +10 9
|
||||
010000 large file
|
||||
.lp +10 9
|
||||
004000 set user-ID on execution
|
||||
.lp +10 9
|
||||
002000 set group-ID on execution
|
||||
.lp +10 9
|
||||
000400 read (owner)
|
||||
.lp +10 9
|
||||
000200 write (owner)
|
||||
.lp +10 9
|
||||
000100 execute (owner)
|
||||
.lp +10 9
|
||||
000070 read, write, execute (group)
|
||||
.lp +10 9
|
||||
000007 read, write, execute (others)
|
||||
.s3
|
||||
.i0
|
||||
Special files are recognized by their flags
|
||||
and not by i-number.
|
||||
A block-type special file is basically one which
|
||||
can potentially be mounted as a file system;
|
||||
a character-type special file cannot, though it is
|
||||
not necessarily character-oriented.
|
||||
For special files the high byte of the first address word
|
||||
specifies the type of device; the low byte specifies
|
||||
one of several devices of
|
||||
that type.
|
||||
The device type numbers
|
||||
of block and character special files overlap.
|
||||
.s3
|
||||
The address words of ordinary files and directories
|
||||
contain the numbers of the blocks in the
|
||||
file (if it is small)
|
||||
or the numbers of indirect blocks (if the file
|
||||
is large).
|
||||
Byte number
|
||||
.IB n
|
||||
of a file is accessed as follows.
|
||||
.IB N
|
||||
is divided by 512 to find its logical block number
|
||||
(say
|
||||
.IB b
|
||||
)
|
||||
in the file.
|
||||
If the file is small (flag 010000 is 0),
|
||||
then
|
||||
.IB b
|
||||
must be less than 8, and the physical
|
||||
block number is
|
||||
.IB addr[b].
|
||||
.s3
|
||||
If the file is large,
|
||||
.IB b
|
||||
is divided by 256 to yield
|
||||
.IB i.
|
||||
If
|
||||
.IB i
|
||||
is less than 7, then
|
||||
.IB addr[i]
|
||||
is the physical block number of
|
||||
the indirect block.
|
||||
The remainder from the division
|
||||
yields the word in the indirect block
|
||||
which contains the number of the block for
|
||||
the sought-for byte.
|
||||
.s3
|
||||
If
|
||||
.IB i
|
||||
is equal to 7,
|
||||
then the file has become extra-large (huge),
|
||||
and
|
||||
.IB addr[7]
|
||||
is the address of a first indirect block.
|
||||
Each word in this block
|
||||
is the number of a second-level indirect block;
|
||||
each word in the second-level indirect blocks points to a data block.
|
||||
Notice that extra-large files are not marked by any mode
|
||||
bit, but only by having
|
||||
.IB addr[7]
|
||||
non-zero;
|
||||
and that although this scheme allows for more than
|
||||
256\*X256\*X512 = 33,554,432 bytes per file,
|
||||
the length of files is stored in 24 bits
|
||||
so in practice a file can be at most
|
||||
16,777,216 bytes long.
|
||||
.s3
|
||||
For block
|
||||
.IB b
|
||||
in a file to exist,
|
||||
it
|
||||
is not necessary that all blocks less than
|
||||
.IB b
|
||||
exist.
|
||||
A zero block number either in the address words of
|
||||
the i-node or in an indirect block indicates that the
|
||||
corresponding block has never been allocated.
|
||||
Such a missing block reads as if it contained all zero words.
|
||||
.SH "SEE ALSO"
|
||||
icheck, dcheck (VIII)
|
||||
|
||||
|
|
@ -15,9 +15,6 @@ readcoff$(EXEXT): ../bin/readcoff/main.c
|
|||
parted$(EXEXT): ../sbin/parted/main.c
|
||||
$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
|
||||
|
||||
mkfs.stpd$(EXEXT): ../sbin/mkfs.stpd/main.c
|
||||
$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
|
||||
|
||||
.PHONY: install
|
||||
install: $(TARGET)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue