chore: remove mkfs.stpd

This commit is contained in:
d0p1 🏳️‍⚧️ 2024-06-12 13:12:25 +02:00
parent 7260b03fca
commit 8f6f833495
3 changed files with 0 additions and 482 deletions

View file

@ -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);
}

View file

@ -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)

View file

@ -15,9 +15,6 @@ readcoff$(EXEXT): ../bin/readcoff/main.c
parted$(EXEXT): ../sbin/parted/main.c parted$(EXEXT): ../sbin/parted/main.c
$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS) $(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
mkfs.stpd$(EXEXT): ../sbin/mkfs.stpd/main.c
$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
.PHONY: install .PHONY: install
install: $(TARGET) install: $(TARGET)