175 lines
3.2 KiB
C
175 lines
3.2 KiB
C
#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);
|
|
}
|