mkfs_minix: stop using lots of bss/data.

data -3500 bytes, code -300 bytes
keep_data_small: expand/fix

diff --git a/docs/keep_data_small.txt b/docs/keep_data_small.txt
index ec13b4d3f86163083892834684a8989977bbae7a..5137dffc69832d47882c1a3d7e59b293c93279d1 100644 (file)
--- a/docs/keep_data_small.txt
+++ b/docs/keep_data_small.txt
@@ -1,4 +1,4 @@
-       Keeping data small
+               Keeping data small
 
 When many applets are compiled into busybox, all rw data and
 bss for each applet are concatenated. Including those from libc,
@@ -10,6 +10,11 @@ On nommu it's probably bites the most, actually using real
 RAM for rwdata and bss. On i386, bss is lazily allocated
 by COWed zero pages. Not sure about rwdata - also COW?
 
+In order to keep bbox NOMMU and small-mem systems friendly
+we should avoid large global data in our applets, and should
+minimize usage of libc functions which implicitly use
+such structures in libc.
+
 Small experiment measures "parasitic" bbox memory consumption.
 Here we start 1000 "busybox sleep 10" in parallel.
 bbox binary is practically allyesconfig static one,
@@ -34,14 +39,10 @@ bash-3.2# nmeter '%t %c %b %m %p %[pn]'
 23:17:43 ..........    0    0 168M    0  147
 
 This requires 55M of memory. Thus 1 trivial busybox applet
-takes 55k of userspace memory (nmeter doesn't account for kernel-side
-allocations). Definitely can be improved.
+takes 55k of memory.
 
-Thus we should avoid large global data in our applets,
-and should minimize usage of libc functions which implicitly use
-such structures in libc.
 
-       Example 1
+               Example 1
 
 One example how to reduce global data usage is in
 archival/libunarchive/decompress_unzip.c:
@@ -57,12 +58,15 @@ archival/libunarchive/decompress_unzip.c:
 #define STATE_IN_BSS 0
 #define STATE_IN_MALLOC 1
 
+(see the rest of the file to get the idea)
+
 This example completely eliminates globals in that module.
 Required memory is allocated in inflate_gunzip() [its main module]
 and then passed down to all subroutines which need to access 'globals'
 as a parameter.
 
-       Example 2
+
+               Example 2
 
 In case you don't want to pass this additional parameter everywhere,
 take a look at archival/gzip.c. Here all global data is replaced by
@@ -70,7 +74,7 @@ single global pointer (ptr_to_globals) to allocated storage.
 
 In order to not duplicate ptr_to_globals in every applet, you can
 reuse single common one. It is defined in libbb/messages.c
-as struct globals *ptr_to_globals, but the struct globals is
+as struct globals *const ptr_to_globals, but the struct globals is
 NOT defined in libbb.h. You first define your own struct:
 
 struct globals { int a; char buf[1000]; };
@@ -79,13 +83,45 @@ and then declare that ptr_to_globals is a pointer to it:
 
 #define G (*ptr_to_globals)
 
-Linker magic ensures that these two merge into single pointer object.
-Now initialize it in <applet>_main():
+ptr_to_globals is declared as constant pointer.
+This helps gcc understand that it won't change, resulting in noticeably
+smaller code. In order to assign it, use PTR_TO_GLOBALS macro:
+
+       PTR_TO_GLOBALS = xzalloc(sizeof(G));
+
+Typically it is done in <applet>_main().
+
+Now you can reference "globals" by G.a, G.buf and so on, in any function.
+
+
+               bb_common_bufsiz1
+
+There is one big common buffer in bss - bb_common_bufsiz1. It is a much
+earlier mechanism to reduce bss usage. Each applet can use it for
+its needs. Library functions are prohibited from using it.
+
+'G.' trick can be done using bb_common_bufsiz1 instead of malloced buffer:
+
+#define G (*(struct globals*)&bb_common_bufsiz1)
+
+Be careful, though, and use it only if
+sizeof(struct globals) <= sizeof(bb_common_bufsiz1).
+
+
+               Drawbacks
+
+You have to initialize it by hand. xzalloc() can be helpful in clearing
+allocated storage to 0, but anything more must be done by hand.
+
+All global variables are prefixed by 'G.' now. If this makes code
+less readable, use #defines:
+
+#define dev_fd (G.dev_fd)
+#define sector (G.sector)
 
-       ptr_to_globals = xzalloc(sizeof(G));
 
-and you can reference "globals" by G.a, G.buf and so on, in any function.
+               Word of caution
 
-The drawback is that now you have to initialize it by hand. xzalloc()
-can be helpful in clearing allocated storage to 0, but anything more
-must be done by hand.
+If applet doesn't use much of global data, converting it to using
+one of above methods is not worth resulting code obfuscation.
+If you have less that ~300 bytes of global data - don't bother.

diff --git a/util-linux/mkfs_minix.c b/util-linux/mkfs_minix.c
index e9ac9350d2b6e1d30772e980eb49798842c0f499..2ba9233df3152cc085672ab8e9915f8fcfc19096 100644 (file)
--- a/util-linux/mkfs_minix.c
+++ b/util-linux/mkfs_minix.c
@@ -85,42 +85,49 @@ enum {
        TEST_BUFFER_BLOCKS      = 16,
 };
 
-#if ENABLE_FEATURE_MINIX2
-static int version2;
-#else
+#if !ENABLE_FEATURE_MINIX2
 enum { version2 = 0 };
 #endif
 
-static char *device_name;
-static int dev_fd = -1;
-static uint32_t total_blocks;
-static int badblocks;
-/* default (changed to 30, per Linus's suggestion, Sun Nov 21 08:05:07 1993) */
-static int namelen = 30;
-static int dirsize = 32;
-static int magic = MINIX1_SUPER_MAGIC2;
+struct globals {
 
-static char root_block[BLOCK_SIZE];
-static char super_block_buffer[BLOCK_SIZE];
-static char boot_block_buffer[512];
-static char *inode_buffer;
+       int dev_fd;
 
-static char *inode_map;
-static char *zone_map;
+#if ENABLE_FEATURE_MINIX2
+       int version2;
+#define version2 G.version2
+#endif
+       char *device_name;
+       uint32_t total_blocks;
+       int badblocks;
+       int namelen;
+       int dirsize;
+       int magic;
+       char *inode_buffer;
+       char *inode_map;
+       char *zone_map;
+       int used_good_blocks;
+       unsigned long req_nr_inodes;
+       unsigned currently_testing;
+
+
+       char root_block[BLOCK_SIZE];
+       char super_block_buffer[BLOCK_SIZE];
+       char boot_block_buffer[512];
+       unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
+};
 
-static int used_good_blocks;
-static unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
-static unsigned long req_nr_inodes;
+#define G (*ptr_to_globals)
 
 static ATTRIBUTE_ALWAYS_INLINE unsigned div_roundup(unsigned size, unsigned n)
 {
        return (size + n-1) / n;
 }
 
-#define INODE_BUF1              (((struct minix1_inode*)inode_buffer) - 1)
-#define INODE_BUF2              (((struct minix2_inode*)inode_buffer) - 1)
+#define INODE_BUF1              (((struct minix1_inode*)G.inode_buffer) - 1)
+#define INODE_BUF2              (((struct minix2_inode*)G.inode_buffer) - 1)
 
-#define SB                      (*(struct minix_super_block*)super_block_buffer)
+#define SB                      (*(struct minix_super_block*)G.super_block_buffer)
 
 #define SB_INODES               (SB.s_ninodes)
 #define SB_IMAPS                (SB.s_imap_blocks)
@@ -160,13 +167,13 @@ static void minix_clrbit(char *a, unsigned i)
 }
 
 /* Note: do not assume 0/1, it is 0/nonzero */
-#define zone_in_use(x)  minix_bit(zone_map,(x)-SB_FIRSTZONE+1)
-/*#define inode_in_use(x) minix_bit(inode_map,(x))*/
+#define zone_in_use(x)  minix_bit(G.zone_map,(x)-SB_FIRSTZONE+1)
+/*#define inode_in_use(x) minix_bit(G.inode_map,(x))*/
 
-#define mark_inode(x)   minix_setbit(inode_map,(x))
-#define unmark_inode(x) minix_clrbit(inode_map,(x))
-#define mark_zone(x)    minix_setbit(zone_map,(x)-SB_FIRSTZONE+1)
-#define unmark_zone(x)  minix_clrbit(zone_map,(x)-SB_FIRSTZONE+1)
+#define mark_inode(x)   minix_setbit(G.inode_map,(x))
+#define unmark_inode(x) minix_clrbit(G.inode_map,(x))
+#define mark_zone(x)    minix_setbit(G.zone_map,(x)-SB_FIRSTZONE+1)
+#define unmark_zone(x)  minix_clrbit(G.zone_map,(x)-SB_FIRSTZONE+1)
 
 #ifndef BLKGETSIZE
 # define BLKGETSIZE     _IO(0x12,96)    /* return device size */
@@ -227,51 +234,51 @@ static void write_tables(void)
        SB.s_state &= ~MINIX_ERROR_FS;
 
        msg_eol = "seek to 0 failed";
-       xlseek(dev_fd, 0, SEEK_SET);
+       xlseek(G.dev_fd, 0, SEEK_SET);
 
        msg_eol = "cannot clear boot sector";
-       xwrite(dev_fd, boot_block_buffer, 512);
+       xwrite(G.dev_fd, G.boot_block_buffer, 512);
 
        msg_eol = "seek to BLOCK_SIZE failed";
-       xlseek(dev_fd, BLOCK_SIZE, SEEK_SET);
+       xlseek(G.dev_fd, BLOCK_SIZE, SEEK_SET);
 
        msg_eol = "cannot write superblock";
-       xwrite(dev_fd, super_block_buffer, BLOCK_SIZE);
+       xwrite(G.dev_fd, G.super_block_buffer, BLOCK_SIZE);
 
        msg_eol = "cannot write inode map";
-       xwrite(dev_fd, inode_map, SB_IMAPS * BLOCK_SIZE);
+       xwrite(G.dev_fd, G.inode_map, SB_IMAPS * BLOCK_SIZE);
 
        msg_eol = "cannot write zone map";
-       xwrite(dev_fd, zone_map, SB_ZMAPS * BLOCK_SIZE);
+       xwrite(G.dev_fd, G.zone_map, SB_ZMAPS * BLOCK_SIZE);
 
        msg_eol = "cannot write inodes";
-       xwrite(dev_fd, inode_buffer, INODE_BUFFER_SIZE);
+       xwrite(G.dev_fd, G.inode_buffer, INODE_BUFFER_SIZE);
 
        msg_eol = "\n";
 }
 
 static void write_block(int blk, char *buffer)
 {
-       xlseek(dev_fd, blk * BLOCK_SIZE, SEEK_SET);
-       xwrite(dev_fd, buffer, BLOCK_SIZE);
+       xlseek(G.dev_fd, blk * BLOCK_SIZE, SEEK_SET);
+       xwrite(G.dev_fd, buffer, BLOCK_SIZE);
 }
 
 static int get_free_block(void)
 {
        int blk;
 
-       if (used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
+       if (G.used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
                bb_error_msg_and_die("too many bad blocks");
-       if (used_good_blocks)
-               blk = good_blocks_table[used_good_blocks - 1] + 1;
+       if (G.used_good_blocks)
+               blk = G.good_blocks_table[G.used_good_blocks - 1] + 1;
        else
                blk = SB_FIRSTZONE;
        while (blk < SB_ZONES && zone_in_use(blk))
                blk++;
        if (blk >= SB_ZONES)
                bb_error_msg_and_die("not enough good blocks");
-       good_blocks_table[used_good_blocks] = blk;
-       used_good_blocks++;
+       G.good_blocks_table[G.used_good_blocks] = blk;
+       G.used_good_blocks++;
        return blk;
 }
 
@@ -279,8 +286,8 @@ static void mark_good_blocks(void)
 {
        int blk;
 
-       for (blk = 0; blk < used_good_blocks; blk++)
-               mark_zone(good_blocks_table[blk]);
+       for (blk = 0; blk < G.used_good_blocks; blk++)
+               mark_zone(G.good_blocks_table[blk]);
 }
 
 static int next(int zone)
@@ -303,7 +310,7 @@ static void make_bad_inode(void)
 
 #define NEXT_BAD (zone = next(zone))
 
-       if (!badblocks)
+       if (!G.badblocks)
                return;
        mark_inode(MINIX_BAD_INO);
        inode->i_nlinks = 1;
@@ -311,7 +318,7 @@ static void make_bad_inode(void)
        /* it's harder to check for bugs then - diff isn't helpful :(... */
        inode->i_time = CUR_TIME;
        inode->i_mode = S_IFREG + 0000;
-       inode->i_size = badblocks * BLOCK_SIZE;
+       inode->i_size = G.badblocks * BLOCK_SIZE;
        zone = next(0);
        for (i = 0; i < 7; i++) {
                inode->i_zone[i] = zone;
@@ -354,13 +361,13 @@ static void make_bad_inode2(void)
        unsigned long ind_block[BLOCK_SIZE >> 2];
        unsigned long dind_block[BLOCK_SIZE >> 2];
 
-       if (!badblocks)
+       if (!G.badblocks)
                return;
        mark_inode(MINIX_BAD_INO);
        inode->i_nlinks = 1;
        inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
        inode->i_mode = S_IFREG + 0000;
-       inode->i_size = badblocks * BLOCK_SIZE;
+       inode->i_size = G.badblocks * BLOCK_SIZE;
        zone = next(0);
        for (i = 0; i < 7; i++) {
                inode->i_zone[i] = zone;
@@ -406,18 +413,18 @@ static void make_root_inode(void)
        inode->i_zone[0] = get_free_block();
        inode->i_nlinks = 2;
        inode->i_time = CUR_TIME;
-       if (badblocks)
-               inode->i_size = 3 * dirsize;
+       if (G.badblocks)
+               inode->i_size = 3 * G.dirsize;
        else {
-               root_block[2 * dirsize] = '\0';
-               root_block[2 * dirsize + 1] = '\0';
-               inode->i_size = 2 * dirsize;
+               G.root_block[2 * G.dirsize] = '\0';
+               G.root_block[2 * G.dirsize + 1] = '\0';
+               inode->i_size = 2 * G.dirsize;
        }
        inode->i_mode = S_IFDIR + 0755;
        inode->i_uid = GETUID;
        if (inode->i_uid)
                inode->i_gid = GETGID;
-       write_block(inode->i_zone[0], root_block);
+       write_block(inode->i_zone[0], G.root_block);
 }
 
 #if ENABLE_FEATURE_MINIX2
@@ -429,94 +436,23 @@ static void make_root_inode2(void)
        inode->i_zone[0] = get_free_block();
        inode->i_nlinks = 2;
        inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
-       if (badblocks)
-               inode->i_size = 3 * dirsize;
+       if (G.badblocks)
+               inode->i_size = 3 * G.dirsize;
        else {
-               root_block[2 * dirsize] = '\0';
-               root_block[2 * dirsize + 1] = '\0';
-               inode->i_size = 2 * dirsize;
+               G.root_block[2 * G.dirsize] = '\0';
+               G.root_block[2 * G.dirsize + 1] = '\0';
+               inode->i_size = 2 * G.dirsize;
        }
        inode->i_mode = S_IFDIR + 0755;
        inode->i_uid = GETUID;
        if (inode->i_uid)
                inode->i_gid = GETGID;
-       write_block(inode->i_zone[0], root_block);
+       write_block(inode->i_zone[0], G.root_block);
 }
 #else
 void make_root_inode2(void);
 #endif
 
-static void setup_tables(void)
-{
-       unsigned long inodes;
-       unsigned norm_firstzone;
-       unsigned sb_zmaps;
-       unsigned i;
-
-       memset(super_block_buffer, 0, BLOCK_SIZE);
-       memset(boot_block_buffer, 0, 512);
-       SB_MAGIC = magic;
-       SB_ZONE_SIZE = 0;
-       SB_MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024;
-       if (version2)
-               SB.s_zones = total_blocks;
-       else
-               SB.s_nzones = total_blocks;
-
-       /* some magic nrs: 1 inode / 3 blocks */
-       if (req_nr_inodes == 0)
-               inodes = total_blocks / 3;
-       else
-               inodes = req_nr_inodes;
-       /* Round up inode count to fill block size */
-       if (version2)
-               inodes = (inodes + MINIX2_INODES_PER_BLOCK - 1) &
-                                ~(MINIX2_INODES_PER_BLOCK - 1);
-       else
-               inodes = (inodes + MINIX1_INODES_PER_BLOCK - 1) &
-                                ~(MINIX1_INODES_PER_BLOCK - 1);
-       if (inodes > 65535)
-               inodes = 65535;
-       SB_INODES = inodes;
-       SB_IMAPS = div_roundup(SB_INODES + 1, BITS_PER_BLOCK);
-
-       /* Real bad hack but overwise mkfs.minix can be thrown
-        * in infinite loop...
-        * try:
-        * dd if=/dev/zero of=test.fs count=10 bs=1024
-        * mkfs.minix -i 200 test.fs
-        */
-       /* This code is not insane: NORM_FIRSTZONE is not a constant,
-        * it is calculated from SB_INODES, SB_IMAPS and SB_ZMAPS */
-       i = 999;
-       SB_ZMAPS = 0;
-       do {
-               norm_firstzone = NORM_FIRSTZONE;
-               sb_zmaps = div_roundup(total_blocks - norm_firstzone + 1, BITS_PER_BLOCK);
-               if (SB_ZMAPS == sb_zmaps) goto got_it;
-               SB_ZMAPS = sb_zmaps;
-               /* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */
-       } while (--i);
-       bb_error_msg_and_die("incompatible size/inode count, try different -i N");
- got_it:
-
-       SB_FIRSTZONE = norm_firstzone;
-       inode_map = xmalloc(SB_IMAPS * BLOCK_SIZE);
-       zone_map = xmalloc(SB_ZMAPS * BLOCK_SIZE);
-       memset(inode_map, 0xff, SB_IMAPS * BLOCK_SIZE);
-       memset(zone_map, 0xff, SB_ZMAPS * BLOCK_SIZE);
-       for (i = SB_FIRSTZONE; i < SB_ZONES; i++)
-               unmark_zone(i);
-       for (i = MINIX_ROOT_INO; i <= SB_INODES; i++)
-               unmark_inode(i);
-       inode_buffer = xzalloc(INODE_BUFFER_SIZE);
-       printf("%ld inodes\n", (long)SB_INODES);
-       printf("%ld blocks\n", (long)SB_ZONES);
-       printf("Firstdatazone=%ld (%ld)\n", (long)SB_FIRSTZONE, (long)norm_firstzone);
-       printf("Zonesize=%d\n", BLOCK_SIZE << SB_ZONE_SIZE);
-       printf("Maxsize=%ld\n", (long)SB_MAXSIZE);
-}
-
 /*
  * Perform a test of a block; return the number of
  * blocks readable.
@@ -527,11 +463,11 @@ static size_t do_check(char *buffer, size_t try, unsigned current_block)
 
        /* Seek to the correct loc. */
        msg_eol = "seek failed during testing of blocks";
-       xlseek(dev_fd, current_block * BLOCK_SIZE, SEEK_SET);
+       xlseek(G.dev_fd, current_block * BLOCK_SIZE, SEEK_SET);
        msg_eol = "\n";
 
        /* Try the read */
-       got = read(dev_fd, buffer, try * BLOCK_SIZE);
+       got = read(G.dev_fd, buffer, try * BLOCK_SIZE);
        if (got < 0)
                got = 0;
        try = ((size_t)got) / BLOCK_SIZE;
@@ -541,17 +477,15 @@ static size_t do_check(char *buffer, size_t try, unsigned current_block)
        return try;
 }
 
-static unsigned currently_testing;
-
 static void alarm_intr(int alnum)
 {
-       if (currently_testing >= SB_ZONES)
+       if (G.currently_testing >= SB_ZONES)
                return;
        signal(SIGALRM, alarm_intr);
        alarm(5);
-       if (!currently_testing)
+       if (!G.currently_testing)
                return;
-       printf("%d ...", currently_testing);
+       printf("%d ...", G.currently_testing);
        fflush(stdout);
 }
 
@@ -561,28 +495,29 @@ static void check_blocks(void)
        /* buffer[] was the biggest static in entire bbox */
        char *buffer = xmalloc(BLOCK_SIZE * TEST_BUFFER_BLOCKS);
 
-       currently_testing = 0;
+       G.currently_testing = 0;
        signal(SIGALRM, alarm_intr);
        alarm(5);
-       while (currently_testing < SB_ZONES) {
+       while (G.currently_testing < SB_ZONES) {
                msg_eol = "seek failed in check_blocks";
-               xlseek(dev_fd, currently_testing * BLOCK_SIZE, SEEK_SET);
+               xlseek(G.dev_fd, G.currently_testing * BLOCK_SIZE, SEEK_SET);
                msg_eol = "\n";
                try = TEST_BUFFER_BLOCKS;
-               if (currently_testing + try > SB_ZONES)
-                       try = SB_ZONES - currently_testing;
-               got = do_check(buffer, try, currently_testing);
-               currently_testing += got;
+               if (G.currently_testing + try > SB_ZONES)
+                       try = SB_ZONES - G.currently_testing;
+               got = do_check(buffer, try, G.currently_testing);
+               G.currently_testing += got;
                if (got == try)
                        continue;
-               if (currently_testing < SB_FIRSTZONE)
+               if (G.currently_testing < SB_FIRSTZONE)
                        bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
-               mark_zone(currently_testing);
-               badblocks++;
-               currently_testing++;
+               mark_zone(G.currently_testing);
+               G.badblocks++;
+               G.currently_testing++;
        }
+       alarm(0);
        free(buffer);
-       printf("%d bad block(s)\n", badblocks);
+       printf("%d bad block(s)\n", G.badblocks);
 }
 
 static void get_list_blocks(char *filename)
@@ -594,9 +529,80 @@ static void get_list_blocks(char *filename)
        while (!feof(listfile)) {
                fscanf(listfile, "%ld\n", &blockno);
                mark_zone(blockno);
-               badblocks++;
+               G.badblocks++;
        }
-       printf("%d bad block(s)\n", badblocks);
+       printf("%d bad block(s)\n", G.badblocks);
+}
+
+static void setup_tables(void)
+{
+       unsigned long inodes;
+       unsigned norm_firstzone;
+       unsigned sb_zmaps;
+       unsigned i;
+
+       /* memset(G.super_block_buffer, 0, BLOCK_SIZE); */
+       /* memset(G.boot_block_buffer, 0, 512); */
+       SB_MAGIC = G.magic;
+       SB_ZONE_SIZE = 0;
+       SB_MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024;
+       if (version2)
+               SB.s_zones = G.total_blocks;
+       else
+               SB.s_nzones = G.total_blocks;
+
+       /* some magic nrs: 1 inode / 3 blocks */
+       if (G.req_nr_inodes == 0)
+               inodes = G.total_blocks / 3;
+       else
+               inodes = G.req_nr_inodes;
+       /* Round up inode count to fill block size */
+       if (version2)
+               inodes = (inodes + MINIX2_INODES_PER_BLOCK - 1) &
+                                ~(MINIX2_INODES_PER_BLOCK - 1);
+       else
+               inodes = (inodes + MINIX1_INODES_PER_BLOCK - 1) &
+                                ~(MINIX1_INODES_PER_BLOCK - 1);
+       if (inodes > 65535)
+               inodes = 65535;
+       SB_INODES = inodes;
+       SB_IMAPS = div_roundup(SB_INODES + 1, BITS_PER_BLOCK);
+
+       /* Real bad hack but overwise mkfs.minix can be thrown
+        * in infinite loop...
+        * try:
+        * dd if=/dev/zero of=test.fs count=10 bs=1024
+        * mkfs.minix -i 200 test.fs
+        */
+       /* This code is not insane: NORM_FIRSTZONE is not a constant,
+        * it is calculated from SB_INODES, SB_IMAPS and SB_ZMAPS */
+       i = 999;
+       SB_ZMAPS = 0;
+       do {
+               norm_firstzone = NORM_FIRSTZONE;
+               sb_zmaps = div_roundup(G.total_blocks - norm_firstzone + 1, BITS_PER_BLOCK);
+               if (SB_ZMAPS == sb_zmaps) goto got_it;
+               SB_ZMAPS = sb_zmaps;
+               /* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */
+       } while (--i);
+       bb_error_msg_and_die("incompatible size/inode count, try different -i N");
+ got_it:
+
+       SB_FIRSTZONE = norm_firstzone;
+       G.inode_map = xmalloc(SB_IMAPS * BLOCK_SIZE);
+       G.zone_map = xmalloc(SB_ZMAPS * BLOCK_SIZE);
+       memset(G.inode_map, 0xff, SB_IMAPS * BLOCK_SIZE);
+       memset(G.zone_map, 0xff, SB_ZMAPS * BLOCK_SIZE);
+       for (i = SB_FIRSTZONE; i < SB_ZONES; i++)
+               unmark_zone(i);
+       for (i = MINIX_ROOT_INO; i <= SB_INODES; i++)
+               unmark_inode(i);
+       G.inode_buffer = xzalloc(INODE_BUFFER_SIZE);
+       printf("%ld inodes\n", (long)SB_INODES);
+       printf("%ld blocks\n", (long)SB_ZONES);
+       printf("Firstdatazone=%ld (%ld)\n", (long)SB_FIRSTZONE, (long)norm_firstzone);
+       printf("Zonesize=%d\n", BLOCK_SIZE << SB_ZONE_SIZE);
+       printf("Maxsize=%ld\n", (long)SB_MAXSIZE);
 }
 
 int mkfs_minix_main(int argc, char **argv);
@@ -609,6 +615,12 @@ int mkfs_minix_main(int argc, char **argv)
        char *str_i, *str_n;
        char *listfile = NULL;
 
+       PTR_TO_GLOBALS = xzalloc(sizeof(G));
+/* default (changed to 30, per Linus's suggestion, Sun Nov 21 08:05:07 1993) */
+       G.namelen = 30;
+       G.dirsize = 32;
+       G.magic = MINIX1_SUPER_MAGIC2;
+
        if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE)
                bb_error_msg_and_die("bad inode size");
 #if ENABLE_FEATURE_MINIX2
@@ -619,14 +631,14 @@ int mkfs_minix_main(int argc, char **argv)
        opt = getopt32(argc, argv, "ci:l:n:v", &str_i, &listfile, &str_n);
        argv += optind;
        //if (opt & 1) -c
-       if (opt & 2) req_nr_inodes = xatoul(str_i); // -i
+       if (opt & 2) G.req_nr_inodes = xatoul(str_i); // -i
        //if (opt & 4) -l
        if (opt & 8) { // -n
-               namelen = xatoi_u(str_n);
-               if (namelen == 14) magic = MINIX1_SUPER_MAGIC;
-               else if (namelen == 30) magic = MINIX1_SUPER_MAGIC2;
+               G.namelen = xatoi_u(str_n);
+               if (G.namelen == 14) G.magic = MINIX1_SUPER_MAGIC;
+               else if (G.namelen == 30) G.magic = MINIX1_SUPER_MAGIC2;
                else bb_show_usage();
-               dirsize = namelen + 2;
+               G.dirsize = G.namelen + 2;
        }
        if (opt & 0x10) { // -v
 #if ENABLE_FEATURE_MINIX2
@@ -636,34 +648,34 @@ int mkfs_minix_main(int argc, char **argv)
 #endif
        }
 
-       device_name = *argv++;
-       if (!device_name)
+       G.device_name = *argv++;
+       if (!G.device_name)
                bb_show_usage();
        if (*argv)
-               total_blocks = xatou32(*argv);
+               G.total_blocks = xatou32(*argv);
        else
-               total_blocks = get_size(device_name) / 1024;
+               G.total_blocks = get_size(G.device_name) / 1024;
 
-       if (total_blocks < 10)
+       if (G.total_blocks < 10)
                bb_error_msg_and_die("must have at least 10 blocks");
 
        if (version2) {
-               magic = MINIX2_SUPER_MAGIC2;
-               if (namelen == 14)
-                       magic = MINIX2_SUPER_MAGIC;
-       } else if (total_blocks > 65535)
-               total_blocks = 65535;
+               G.magic = MINIX2_SUPER_MAGIC2;
+               if (G.namelen == 14)
+                       G.magic = MINIX2_SUPER_MAGIC;
+       } else if (G.total_blocks > 65535)
+               G.total_blocks = 65535;
 
        /* Check if it is mounted */
-       mp = find_mount_point(device_name, NULL);
-       if (mp && strcmp(device_name, mp->mnt_fsname) == 0)
+       mp = find_mount_point(G.device_name, NULL);
+       if (mp && strcmp(G.device_name, mp->mnt_fsname) == 0)
                bb_error_msg_and_die("%s is mounted on %s; "
                                "refusing to make a filesystem",
-                               device_name, mp->mnt_dir);
+                               G.device_name, mp->mnt_dir);
 
-       dev_fd = xopen(device_name, O_RDWR);
-       if (fstat(dev_fd, &statbuf) < 0)
-               bb_error_msg_and_die("cannot stat %s", device_name);
+       G.dev_fd = xopen(G.device_name, O_RDWR);
+       if (fstat(G.dev_fd, &statbuf) < 0)
+               bb_error_msg_and_die("cannot stat %s", G.device_name);
        if (!S_ISBLK(statbuf.st_mode))
                opt &= ~1; // clear -c (check)
 
@@ -673,16 +685,16 @@ int mkfs_minix_main(int argc, char **argv)
        else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
                /* what is this? */
                bb_error_msg_and_die("will not try "
-                       "to make filesystem on '%s'", device_name);
+                       "to make filesystem on '%s'", G.device_name);
 #endif
 
-       tmp = root_block;
+       tmp = G.root_block;
        *(short *) tmp = 1;
        strcpy(tmp + 2, ".");
-       tmp += dirsize;
+       tmp += G.dirsize;
        *(short *) tmp = 1;
        strcpy(tmp + 2, "..");
-       tmp += dirsize;
+       tmp += G.dirsize;
        *(short *) tmp = 2;
        strcpy(tmp + 2, ".badblocks");