2 files changed, 242 insertions, 194 deletions

diff --git a/docs/keep_data_small.txt b/docs/keep_data_small.txt
index ec13b4d3f..5137dffc6 100644
--- 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 e9ac9350d..2ba9233df 100644
--- 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");