* enforced (but it's not much fun on a character device :-).
*/
-#include "internal.h"
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <mntent.h>
-#include <sys/stat.h>
+#include <sys/param.h>
+#include "busybox.h"
-#include <linux/fs.h>
-#include <linux/minix_fs.h>
+
+ typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
-#ifdef MINIX2_SUPER_MAGIC2
-#define HAVE_MINIX2 1
+
+static const int MINIX_ROOT_INO = 1;
+static const int MINIX_LINK_MAX = 250;
+static const int MINIX2_LINK_MAX = 65530;
+
+static const int MINIX_I_MAP_SLOTS = 8;
+static const int MINIX_Z_MAP_SLOTS = 64;
+static const int MINIX_SUPER_MAGIC = 0x137F; /* original minix fs */
+static const int MINIX_SUPER_MAGIC2 = 0x138F; /* minix fs, 30 char names */
+static const int MINIX2_SUPER_MAGIC = 0x2468; /* minix V2 fs */
+static const int MINIX2_SUPER_MAGIC2 = 0x2478; /* minix V2 fs, 30 char names */
+static const int MINIX_VALID_FS = 0x0001; /* Clean fs. */
+static const int MINIX_ERROR_FS = 0x0002; /* fs has errors. */
+
+#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
+#define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
+
+static const int MINIX_V1 = 0x0001; /* original minix fs */
+static const int MINIX_V2 = 0x0002; /* minix V2 fs */
+
+#define INODE_VERSION(inode) inode->i_sb->u.minix_sb.s_version
+
+/*
+ * This is the original minix inode layout on disk.
+ * Note the 8-bit gid and atime and ctime.
+ */
+struct minix_inode {
+ u16 i_mode;
+ u16 i_uid;
+ u32 i_size;
+ u32 i_time;
+ u8 i_gid;
+ u8 i_nlinks;
+ u16 i_zone[9];
+};
+
+/*
+ * The new minix inode has all the time entries, as well as
+ * long block numbers and a third indirect block (7+1+1+1
+ * instead of 7+1+1). Also, some previously 8-bit values are
+ * now 16-bit. The inode is now 64 bytes instead of 32.
+ */
+struct minix2_inode {
+ u16 i_mode;
+ u16 i_nlinks;
+ u16 i_uid;
+ u16 i_gid;
+ u32 i_size;
+ u32 i_atime;
+ u32 i_mtime;
+ u32 i_ctime;
+ u32 i_zone[10];
+};
+
+/*
+ * minix super-block data on disk
+ */
+struct minix_super_block {
+ u16 s_ninodes;
+ u16 s_nzones;
+ u16 s_imap_blocks;
+ u16 s_zmap_blocks;
+ u16 s_firstdatazone;
+ u16 s_log_zone_size;
+ u32 s_max_size;
+ u16 s_magic;
+ u16 s_state;
+ u32 s_zones;
+};
+
+struct minix_dir_entry {
+ u16 inode;
+ char name[0];
+};
+
+#define BLOCK_SIZE_BITS 10
+#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
+
+#define NAME_MAX 255 /* # chars in a file name */
+
+#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
+
+#ifndef BLKGETSIZE
+#define BLKGETSIZE _IO(0x12,96) /* return device size */
#endif
#ifndef __linux__
#define volatile
#endif
-#define ROOT_INO 1
+static const int ROOT_INO = 1;
#define UPPER(size,n) ((size+((n)-1))/(n))
#define INODE_SIZE (sizeof(struct minix_inode))
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
#define INODE_SIZE2 (sizeof(struct minix2_inode))
#define INODE_BLOCKS UPPER(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
: MINIX_INODES_PER_BLOCK))
#define BITS_PER_BLOCK (BLOCK_SIZE<<3)
-static char *program_name = "fsck.minix";
static char *program_version = "1.2 - 11/11/96";
static char *device_name = NULL;
static int IN;
static int termios_set = 0;
/* File-name data */
-#define MAX_DEPTH 32
+static const int MAX_DEPTH = 32;
static int name_depth = 0;
// static char name_list[MAX_DEPTH][BUFSIZ + 1];
static char **name_list = NULL;
#define Super (*(struct minix_super_block *)super_block_buffer)
#define INODES ((unsigned long)Super.s_ninodes)
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
#define ZONES ((unsigned long)(version2 ? Super.s_zones : Super.s_nzones))
#else
#define ZONES ((unsigned long)(Super.s_nzones))
static unsigned char *zone_count = NULL;
static void recursive_check(unsigned int ino);
+#ifdef BB_FEATURE_MINIX2
static void recursive_check2(unsigned int ino);
+#endif
-#define inode_in_use(x) (isset(inode_map,(x)))
-#define zone_in_use(x) (isset(zone_map,(x)-FIRSTZONE+1))
+static inline int bit(char * a,unsigned int i)
+{
+ return (a[i >> 3] & (1<<(i & 7))) != 0;
+}
+#define inode_in_use(x) (bit(inode_map,(x)))
+#define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))
#define mark_inode(x) (setbit(inode_map,(x)),changed=1)
#define unmark_inode(x) (clrbit(inode_map,(x)),changed=1)
exit(status);
}
-static void show_usage(void)
-{
- fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n",
- BB_VER, BB_BT);
- fprintf(stderr, "Usage: %s [-larvsmf] /dev/name\n", program_name);
-#ifndef BB_FEATURE_TRIVIAL_HELP
- fprintf(stderr,
- "\nPerforms a consistency check for MINIX filesystems.\n\n");
- fprintf(stderr, "OPTIONS:\n");
- fprintf(stderr, "\t-l\tLists all filenames\n");
- fprintf(stderr, "\t-r\tPerform interactive repairs\n");
- fprintf(stderr, "\t-a\tPerform automatic repairs\n");
- fprintf(stderr, "\t-v\tverbose\n");
- fprintf(stderr, "\t-s\tOutputs super-block information\n");
- fprintf(stderr,
- "\t-m\tActivates MINIX-like \"mode not cleared\" warnings\n");
- fprintf(stderr, "\t-f\tForce file system check.\n\n");
-#endif
- leave(16);
-}
-
static void die(const char *str)
{
- fprintf(stderr, "%s: %s\n", program_name, str);
+ error_msg("%s", str);
leave(8);
}
return 0;
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static int check_zone_nr2(unsigned int *nr, int *corrected)
{
if (!*nr)
return result;
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static int map_block2(struct minix2_inode *inode, unsigned int blknr)
{
unsigned int ind[BLOCK_SIZE >> 2];
char blk[BLOCK_SIZE];
int size;
-#if HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
if (version2)
block = Inode2[ROOT_INO].i_zone[0];
else
namelen = 30;
dirsize = 32;
version2 = 0;
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
} else if (MAGIC == MINIX2_SUPER_MAGIC) {
namelen = 14;
dirsize = 16;
return inode;
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
struct minix2_inode *get_inode2(unsigned int nr)
{
struct minix2_inode *inode;
die("root inode isn't a directory");
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void check_root2(void)
{
struct minix2_inode *inode = Inode2 + ROOT_INO;
return block;
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static int add_zone2(unsigned int *znr, int *corrected)
{
int result;
write_block(block, blk);
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void add_zone_ind2(unsigned int *znr, int *corrected)
{
static char blk[BLOCK_SIZE];
write_block(block, blk);
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void add_zone_dind2(unsigned int *znr, int *corrected)
{
static char blk[BLOCK_SIZE];
add_zone_dind(8 + inode->i_zone, &changed);
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void check_zones2(unsigned int i)
{
struct minix2_inode *inode;
return;
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void check_file2(struct minix2_inode *dir, unsigned int offset)
{
static char blk[BLOCK_SIZE];
check_file(dir, offset);
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void recursive_check2(unsigned int ino)
{
struct minix2_inode *dir;
}
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void check_counts2(void)
{
int i;
check_counts();
}
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
static void check2(void)
{
memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
name_list[i] = xmalloc(sizeof(char) * BUFSIZ + 1);
}
-#if 0
+#ifdef BB_FEATURE_CLEAN_UP
/* execute this atexit() to deallocate name_list[] */
/* piptigger was here */
static void free_name_list(void)
int retcode = 0;
alloc_name_list();
+#ifdef BB_FEATURE_CLEAN_UP
/* Don't bother to free memory. Exit does
* that automagically, so we can save a few bytes */
- //atexit(free_name_list);
+ atexit(free_name_list);
+#endif
- if (argc && *argv)
- program_name = *argv;
if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE)
die("bad inode size");
-#ifdef HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
die("bad v2 inode size");
#endif
die("need terminal for interactive repairs");
}
IN = open(device_name, repair ? O_RDWR : O_RDONLY);
- if (IN < 0)
- die("unable to open '%s'");
+ if (IN < 0){
+ fprintf(stderr,"unable to open device '%s'.\n",device_name);
+ leave(8);
+ }
for (count = 0; count < 3; count++)
sync();
read_superblock();
* flags and whether or not the -f switch was specified on the
* command line.
*/
- printf("%s, %s\n", program_name, program_version);
+ printf("%s, %s\n", applet_name, program_version);
if (!(Super.s_state & MINIX_ERROR_FS) &&
(Super.s_state & MINIX_VALID_FS) && !force) {
if (repair)
tcsetattr(0, TCSANOW, &tmp);
termios_set = 1;
}
-#if HAVE_MINIX2
+#ifdef BB_FEATURE_MINIX2
if (version2) {
check_root2();
check2();
projects / oweals / busybox.git / blobdiff