From e49d5ecbbe51718fa925b6890a735e5937cc2aa2 Mon Sep 17 00:00:00 2001 From: Erik Andersen Date: Tue, 8 Feb 2000 19:58:47 +0000 Subject: Some formatting updates (ran the code through indent) -Erik --- util-linux/dmesg.c | 160 +++++---- util-linux/fbset.c | 360 ++++++++++--------- util-linux/fdflush.c | 36 +- util-linux/fsck_minix.c | 716 +++++++++++++++++++------------------ util-linux/mkfs_minix.c | 499 +++++++++++++------------- util-linux/mkswap.c | 197 +++++----- util-linux/more.c | 199 ++++++----- util-linux/mount.c | 581 +++++++++++++++--------------- util-linux/nfsmount.c | 933 ++++++++++++++++++++++++------------------------ util-linux/nfsmount.h | 1 + util-linux/swaponoff.c | 131 +++---- util-linux/umount.c | 291 +++++++-------- 12 files changed, 2091 insertions(+), 2013 deletions(-) (limited to 'util-linux') diff --git a/util-linux/dmesg.c b/util-linux/dmesg.c index e38fd5555..bbed8221a 100644 --- a/util-linux/dmesg.c +++ b/util-linux/dmesg.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* dmesg.c -- Print out the contents of the kernel ring buffer * Created: Sat Oct 9 16:19:47 1993 * Revised: Thu Oct 28 21:52:17 1993 by faith@cs.unc.edu @@ -24,8 +25,8 @@ #ifndef __alpha__ # define __NR_klogctl __NR_syslog - static inline _syscall3(int, klogctl, int, type, char *, b, int, len); -#else /* __alpha__ */ +static inline _syscall3(int, klogctl, int, type, char *, b, int, len); +#else /* __alpha__ */ #define klogctl syslog #endif @@ -35,90 +36,91 @@ static const char dmesg_usage[] = "dmesg [-c] [-n level] [-s bufsize]\n"; -int dmesg_main( int argc, char** argv ) +int dmesg_main(int argc, char **argv) { - char *buf; - int bufsize=8196; - int i; - int n; - int level = 0; - int lastc; - int cmd = 3; - int stopDoingThat; + char *buf; + int bufsize = 8196; + int i; + int n; + int level = 0; + int lastc; + int cmd = 3; + int stopDoingThat; - argc--; - argv++; + argc--; + argv++; - /* Parse any options */ - while (argc && **argv == '-') { - stopDoingThat = FALSE; - while (stopDoingThat == FALSE && *++(*argv)) { - switch (**argv) { - case 'c': - cmd = 4; - break; - case 'n': - cmd = 8; - if (--argc == 0) - goto end; - level = atoi (*(++argv)); - if (--argc > 0) - ++argv; - stopDoingThat = TRUE; - break; - case 's': - if (--argc == 0) - goto end; - bufsize = atoi (*(++argv)); - if (--argc > 0) - ++argv; - stopDoingThat = TRUE; - break; - default: + /* Parse any options */ + while (argc && **argv == '-') { + stopDoingThat = FALSE; + while (stopDoingThat == FALSE && *++(*argv)) { + switch (**argv) { + case 'c': + cmd = 4; + break; + case 'n': + cmd = 8; + if (--argc == 0) + goto end; + level = atoi(*(++argv)); + if (--argc > 0) + ++argv; + stopDoingThat = TRUE; + break; + case 's': + if (--argc == 0) + goto end; + bufsize = atoi(*(++argv)); + if (--argc > 0) + ++argv; + stopDoingThat = TRUE; + break; + default: + goto end; + } + } + } + + if (argc > 1) { goto end; - } } - } - - if (argc > 1) { - goto end; - } - if (cmd == 8) { - n = klogctl( cmd, NULL, level ); - if (n < 0) { - goto klogctl_error; - } - exit( TRUE ); - } + if (cmd == 8) { + n = klogctl(cmd, NULL, level); + if (n < 0) { + goto klogctl_error; + } + exit(TRUE); + } - if (bufsize < 4096) bufsize = 4096; - buf = (char*)malloc(bufsize); - n = klogctl( cmd, buf, bufsize ); - if (n < 0) { - goto klogctl_error; - } + if (bufsize < 4096) + bufsize = 4096; + buf = (char *) malloc(bufsize); + n = klogctl(cmd, buf, bufsize); + if (n < 0) { + goto klogctl_error; + } - lastc = '\n'; - for (i = 0; i < n; i++) { - if ((i == 0 || buf[i - 1] == '\n') && buf[i] == '<') { - i++; - while (buf[i] >= '0' && buf[i] <= '9') - i++; - if (buf[i] == '>') - i++; - } - lastc = buf[i]; - putchar( lastc ); - } - if (lastc != '\n') - putchar( '\n' ); - exit( TRUE); -end: - usage( dmesg_usage); - exit (FALSE); -klogctl_error: - perror( "klogctl" ); - exit( FALSE ); + lastc = '\n'; + for (i = 0; i < n; i++) { + if ((i == 0 || buf[i - 1] == '\n') && buf[i] == '<') { + i++; + while (buf[i] >= '0' && buf[i] <= '9') + i++; + if (buf[i] == '>') + i++; + } + lastc = buf[i]; + putchar(lastc); + } + if (lastc != '\n') + putchar('\n'); + exit(TRUE); + end: + usage(dmesg_usage); + exit(FALSE); + klogctl_error: + perror("klogctl"); + exit(FALSE); } diff --git a/util-linux/fbset.c b/util-linux/fbset.c index c29145e51..a75e431db 100644 --- a/util-linux/fbset.c +++ b/util-linux/fbset.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini fbset implementation for busybox * @@ -48,7 +49,7 @@ #define OPT_READMODE (1 << 2) #define CMD_HELP 0 -#define CMD_FB 1 +#define CMD_FB 1 #define CMD_DB 2 #define CMD_GEOMETRY 3 #define CMD_TIMING 4 @@ -87,213 +88,242 @@ static unsigned int g_options = 0; struct cmdoptions_t { - char *name; - unsigned char param_count; - unsigned char code; + char *name; + unsigned char param_count; + unsigned char code; } g_cmdoptions[] = { - { "-h", 0, CMD_HELP }, - { "-fb", 1, CMD_FB }, - { "-db", 1, CMD_DB }, - { "-a", 0, CMD_ALL }, - { "-i", 0, CMD_INFO }, - { "-g", 5, CMD_GEOMETRY }, - { "-t", 7, CMD_TIMING }, - { "-accel", 1, CMD_ACCEL }, - { "-hsync", 1, CMD_HSYNC }, - { "-vsync", 1, CMD_VSYNC }, - { "-laced", 1, CMD_LACED }, - { "-double", 1, CMD_DOUBLE }, - + { + "-h", 0, CMD_HELP}, { + "-fb", 1, CMD_FB}, { + "-db", 1, CMD_DB}, { + "-a", 0, CMD_ALL}, { + "-i", 0, CMD_INFO}, { + "-g", 5, CMD_GEOMETRY}, { + "-t", 7, CMD_TIMING}, { + "-accel", 1, CMD_ACCEL}, { + "-hsync", 1, CMD_HSYNC}, { + "-vsync", 1, CMD_VSYNC}, { + "-laced", 1, CMD_LACED}, { + "-double", 1, CMD_DOUBLE}, #ifdef BB_FBSET_FANCY - { "--help", 0, CMD_HELP }, - { "-all", 0, CMD_ALL }, - { "-xres", 1, CMD_XRES }, - { "-yres", 1, CMD_YRES }, - { "-vxres", 1, CMD_VXRES }, - { "-vyres", 1, CMD_VYRES }, - { "-depth", 1, CMD_DEPTH }, - { "-match", 0, CMD_MATCH }, - { "--geometry", 5, CMD_GEOMETRY }, - - { "-pixclock", 1, CMD_PIXCLOCK }, - { "-left", 1, CMD_LEFT }, - { "-right", 1, CMD_RIGHT }, - { "-upper", 1, CMD_UPPER }, - { "-lower", 1, CMD_LOWER }, - { "-hslen", 1, CMD_HSLEN }, - { "-vslen", 1, CMD_VSLEN }, - { "--timings", 7, CMD_TIMING }, - - { "-csync", 1, CMD_CSYNC }, - { "-gsync", 1, CMD_GSYNC }, - { "-extsync", 1, CMD_EXTSYNC }, - { "-bcast", 1, CMD_BCAST }, - { "-rgba", 1, CMD_RGBA }, - { "-step", 1, CMD_STEP }, - { "-move", 1, CMD_MOVE }, + { + "--help", 0, CMD_HELP}, { + "-all", 0, CMD_ALL}, { + "-xres", 1, CMD_XRES}, { + "-yres", 1, CMD_YRES}, { + "-vxres", 1, CMD_VXRES}, { + "-vyres", 1, CMD_VYRES}, { + "-depth", 1, CMD_DEPTH}, { + "-match", 0, CMD_MATCH}, { + "--geometry", 5, CMD_GEOMETRY}, { + "-pixclock", 1, CMD_PIXCLOCK}, { + "-left", 1, CMD_LEFT}, { + "-right", 1, CMD_RIGHT}, { + "-upper", 1, CMD_UPPER}, { + "-lower", 1, CMD_LOWER}, { + "-hslen", 1, CMD_HSLEN}, { + "-vslen", 1, CMD_VSLEN}, { + "--timings", 7, CMD_TIMING}, { + "-csync", 1, CMD_CSYNC}, { + "-gsync", 1, CMD_GSYNC}, { + "-extsync", 1, CMD_EXTSYNC}, { + "-bcast", 1, CMD_BCAST}, { + "-rgba", 1, CMD_RGBA}, { + "-step", 1, CMD_STEP}, { + "-move", 1, CMD_MOVE}, #endif - { 0, 0, 0 } + { + 0, 0, 0} }; static int readmode(struct fb_var_screeninfo *base, const char *fn, - const char *mode) + const char *mode) { #ifdef BB_FBSET_READMODE - FILE *f; - char buf[256]; - char *p = buf; - - if ((f = fopen(fn, "r")) == NULL) PERROR("readmode(fopen)"); - while (!feof(f)) { - fgets(buf, sizeof(buf), f); - if ((p = strstr(buf, "mode ")) || (p = strstr(buf, "mode\t"))) { - p += 5; - if ((p = strstr(buf, mode))) { - p += strlen(mode); - if (!isspace(*p) && (*p != 0) && (*p != '"') && (*p != '\r') - && (*p != '\n')) continue; /* almost, but not quite */ - while (!feof(f)) { - fgets(buf, sizeof(buf), f); - if (!strstr(buf, "endmode")) return 1; + FILE *f; + char buf[256]; + char *p = buf; + + if ((f = fopen(fn, "r")) == NULL) + PERROR("readmode(fopen)"); + while (!feof(f)) { + fgets(buf, sizeof(buf), f); + if ((p = strstr(buf, "mode ")) || (p = strstr(buf, "mode\t"))) { + p += 5; + if ((p = strstr(buf, mode))) { + p += strlen(mode); + if (!isspace(*p) && (*p != 0) && (*p != '"') + && (*p != '\r') && (*p != '\n')) + continue; /* almost, but not quite */ + while (!feof(f)) { + fgets(buf, sizeof(buf), f); + if (!strstr(buf, "endmode")) + return 1; + } + } } - } } - } #else - fprintf(stderr, "W: mode reading was disabled on this copy of fbset; ignoring request\n"); + fprintf(stderr, + "W: mode reading was disabled on this copy of fbset; ignoring request\n"); #endif - return 0; + return 0; } -static void setmode(struct fb_var_screeninfo *base, - struct fb_var_screeninfo *set) +static void setmode(struct fb_var_screeninfo *base, + struct fb_var_screeninfo *set) { - if ((int)set->xres > 0) base->xres = set->xres; - if ((int)set->yres > 0) base->yres = set->yres; - if ((int)set->xres_virtual > 0) base->xres_virtual = set->xres_virtual; - if ((int)set->yres_virtual > 0) base->yres_virtual = set->yres_virtual; - if ((int)set->bits_per_pixel > 0) base->bits_per_pixel = set->bits_per_pixel; + if ((int) set->xres > 0) + base->xres = set->xres; + if ((int) set->yres > 0) + base->yres = set->yres; + if ((int) set->xres_virtual > 0) + base->xres_virtual = set->xres_virtual; + if ((int) set->yres_virtual > 0) + base->yres_virtual = set->yres_virtual; + if ((int) set->bits_per_pixel > 0) + base->bits_per_pixel = set->bits_per_pixel; } static void showmode(struct fb_var_screeninfo *v) { - double drate = 0, hrate = 0, vrate = 0; - if (v->pixclock) { - drate = 1e12 / v->pixclock; - hrate = drate / (v->left_margin+v->xres+v->right_margin+v->hsync_len); - vrate = hrate / (v->upper_margin+v->yres+v->lower_margin+v->vsync_len); - } - printf("\nmode \"%ux%u-%u\"\n", v->xres, v->yres, (int)(vrate+0.5)); + double drate = 0, hrate = 0, vrate = 0; + + if (v->pixclock) { + drate = 1e12 / v->pixclock; + hrate = + drate / (v->left_margin + v->xres + v->right_margin + + v->hsync_len); + vrate = + hrate / (v->upper_margin + v->yres + v->lower_margin + + v->vsync_len); + } + printf("\nmode \"%ux%u-%u\"\n", v->xres, v->yres, (int) (vrate + 0.5)); #ifdef BB_FBSET_FANCY - printf("\t# D: %.3f MHz, H: %.3f kHz, V: %.3f Hz\n", drate/1e6, hrate/1e3, - vrate); + printf("\t# D: %.3f MHz, H: %.3f kHz, V: %.3f Hz\n", drate / 1e6, + hrate / 1e3, vrate); #endif - printf("\tgeometry %u %u %u %u %u\n", v->xres, v->yres, - v->xres_virtual, v->yres_virtual, v->bits_per_pixel); + printf("\tgeometry %u %u %u %u %u\n", v->xres, v->yres, + v->xres_virtual, v->yres_virtual, v->bits_per_pixel); #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) - printf("\ttimings %u %u %u %u %u %u %u\n", v->pixclock, v->left_margin, - v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len, - v->vsync_len); - printf("\taccel %s\n", (v->accel_flags > 0 ? "true" : "false")); + printf("\ttimings %u %u %u %u %u %u %u\n", v->pixclock, v->left_margin, + v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len, + v->vsync_len); + printf("\taccel %s\n", (v->accel_flags > 0 ? "true" : "false")); #else - printf("\ttimings %lu %lu %lu %lu %lu %lu %lu\n", v->pixclock, v->left_margin, - v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len, - v->vsync_len); + printf("\ttimings %lu %lu %lu %lu %lu %lu %lu\n", v->pixclock, + v->left_margin, v->right_margin, v->upper_margin, + v->lower_margin, v->hsync_len, v->vsync_len); #endif - printf("\trgba %u/%u,%u/%u,%u/%u,%u/%u\n", v->red.length, v->red.offset, - v->green.length, v->green.offset, v->blue.length, v->blue.offset, - v->transp.length, v->transp.offset); - printf("endmode\n"); + printf("\trgba %u/%u,%u/%u,%u/%u,%u/%u\n", v->red.length, + v->red.offset, v->green.length, v->green.offset, v->blue.length, + v->blue.offset, v->transp.length, v->transp.offset); + printf("endmode\n"); } static void fbset_usage(void) { - int i; + int i; + #ifndef STANDALONE - fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT); + fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", + BB_VER, BB_BT); #endif - fprintf(stderr, "Usage: fbset [options] [mode]\n"); - fprintf(stderr, "\tThe following options are recognized:\n"); - for (i = 0; g_cmdoptions[i].name; i++) - fprintf(stderr, "\t\t%s\n", g_cmdoptions[i].name); - exit(-1); + fprintf(stderr, "Usage: fbset [options] [mode]\n"); + fprintf(stderr, "\tThe following options are recognized:\n"); + for (i = 0; g_cmdoptions[i].name; i++) + fprintf(stderr, "\t\t%s\n", g_cmdoptions[i].name); + exit(-1); } #ifdef STANDALONE int main(int argc, char **argv) -#else +#else extern int fbset_main(int argc, char **argv) #endif { - struct fb_var_screeninfo var, varset; - int fh, i; - char *fbdev = DEFAULTFBDEV; - char *modefile = DEFAULTFBMODE; - char *thisarg, *mode = NULL; + struct fb_var_screeninfo var, varset; + int fh, i; + char *fbdev = DEFAULTFBDEV; + char *modefile = DEFAULTFBMODE; + char *thisarg, *mode = NULL; + + memset(&varset, 0xFF, sizeof(varset)); - memset(&varset, 0xFF, sizeof(varset)); - - /* parse cmd args.... why do they have to make things so difficult? */ - argv++; argc--; - for (; argc > 0 && (thisarg = *argv); argc--, argv++) { - for (i = 0; g_cmdoptions[i].name; i++) { - if (!strcmp(thisarg, g_cmdoptions[i].name)) { - if (argc - 1 < g_cmdoptions[i].param_count) fbset_usage(); - switch (g_cmdoptions[i].code) { - case CMD_HELP: fbset_usage(); - case CMD_FB: fbdev = argv[1]; break; - case CMD_DB: modefile = argv[1]; break; - case CMD_GEOMETRY: - varset.xres = strtoul(argv[1],0,0); - varset.yres = strtoul(argv[2],0,0); - varset.xres_virtual = strtoul(argv[3],0,0); - varset.yres_virtual = strtoul(argv[4],0,0); - varset.bits_per_pixel = strtoul(argv[5],0,0); - break; - case CMD_TIMING: - varset.pixclock = strtoul(argv[1],0,0); - varset.left_margin = strtoul(argv[2],0,0); - varset.right_margin = strtoul(argv[3],0,0); - varset.upper_margin = strtoul(argv[4],0,0); - varset.lower_margin = strtoul(argv[5],0,0); - varset.hsync_len = strtoul(argv[6],0,0); - varset.vsync_len = strtoul(argv[7],0,0); - break; + /* parse cmd args.... why do they have to make things so difficult? */ + argv++; + argc--; + for (; argc > 0 && (thisarg = *argv); argc--, argv++) { + for (i = 0; g_cmdoptions[i].name; i++) { + if (!strcmp(thisarg, g_cmdoptions[i].name)) { + if (argc - 1 < g_cmdoptions[i].param_count) + fbset_usage(); + switch (g_cmdoptions[i].code) { + case CMD_HELP: + fbset_usage(); + case CMD_FB: + fbdev = argv[1]; + break; + case CMD_DB: + modefile = argv[1]; + break; + case CMD_GEOMETRY: + varset.xres = strtoul(argv[1], 0, 0); + varset.yres = strtoul(argv[2], 0, 0); + varset.xres_virtual = strtoul(argv[3], 0, 0); + varset.yres_virtual = strtoul(argv[4], 0, 0); + varset.bits_per_pixel = strtoul(argv[5], 0, 0); + break; + case CMD_TIMING: + varset.pixclock = strtoul(argv[1], 0, 0); + varset.left_margin = strtoul(argv[2], 0, 0); + varset.right_margin = strtoul(argv[3], 0, 0); + varset.upper_margin = strtoul(argv[4], 0, 0); + varset.lower_margin = strtoul(argv[5], 0, 0); + varset.hsync_len = strtoul(argv[6], 0, 0); + varset.vsync_len = strtoul(argv[7], 0, 0); + break; #ifdef BB_FBSET_FANCY - case CMD_XRES: varset.xres = strtoul(argv[1],0,0); break; - case CMD_YRES: varset.yres = strtoul(argv[1],0,0); break; + case CMD_XRES: + varset.xres = strtoul(argv[1], 0, 0); + break; + case CMD_YRES: + varset.yres = strtoul(argv[1], 0, 0); + break; #endif + } + argc -= g_cmdoptions[i].param_count; + argv += g_cmdoptions[i].param_count; + break; + } + } + if (!g_cmdoptions[i].name) { + if (argc == 1) { + mode = *argv; + g_options |= OPT_READMODE; + } else { + fbset_usage(); + } } - argc -= g_cmdoptions[i].param_count; - argv += g_cmdoptions[i].param_count; - break; - } - } - if (!g_cmdoptions[i].name) { - if (argc == 1) { - mode = *argv; - g_options |= OPT_READMODE; - } else { - fbset_usage(); - } } - } - if ((fh = open(fbdev, O_RDONLY)) < 0) PERROR("fbset(open)"); - if (ioctl(fh, FBIOGET_VSCREENINFO, &var)) PERROR("fbset(ioctl)"); - if (g_options & OPT_READMODE) { - if (!readmode(&var, modefile, mode)) { - fprintf(stderr, "Unknown video mode `%s'\n", mode); - exit(1); + if ((fh = open(fbdev, O_RDONLY)) < 0) + PERROR("fbset(open)"); + if (ioctl(fh, FBIOGET_VSCREENINFO, &var)) + PERROR("fbset(ioctl)"); + if (g_options & OPT_READMODE) { + if (!readmode(&var, modefile, mode)) { + fprintf(stderr, "Unknown video mode `%s'\n", mode); + exit(1); + } } - } - setmode(&var, &varset); - if (g_options & OPT_CHANGE) - if (ioctl(fh, FBIOPUT_VSCREENINFO, &var)) PERROR("fbset(ioctl)"); - showmode(&var); - close(fh); - - return(TRUE); -} + setmode(&var, &varset); + if (g_options & OPT_CHANGE) + if (ioctl(fh, FBIOPUT_VSCREENINFO, &var)) + PERROR("fbset(ioctl)"); + showmode(&var); + close(fh); + return (TRUE); +} diff --git a/util-linux/fdflush.c b/util-linux/fdflush.c index a244e8def..0b154c8a6 100644 --- a/util-linux/fdflush.c +++ b/util-linux/fdflush.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini fdflush implementation for busybox * @@ -29,24 +30,25 @@ extern int fdflush_main(int argc, char **argv) { - int value; - int fd; - if ( argc <= 1 || **(argv++) == '-' ) { - usage( "fdflush device\n"); - } + int value; + int fd; - fd = open(*argv, 0); - if ( fd < 0 ) { - perror(*argv); - exit(FALSE); - } + if (argc <= 1 || **(argv++) == '-') { + usage("fdflush device\n"); + } - value = ioctl(fd, FDFLUSH, 0); - close(fd); + fd = open(*argv, 0); + if (fd < 0) { + perror(*argv); + exit(FALSE); + } - if ( value ) { - perror(*argv); - exit(FALSE); - } - exit (TRUE); + value = ioctl(fd, FDFLUSH, 0); + close(fd); + + if (value) { + perror(*argv); + exit(FALSE); + } + exit(TRUE); } diff --git a/util-linux/fsck_minix.c b/util-linux/fsck_minix.c index 09111c5dc..084c76d36 100644 --- a/util-linux/fsck_minix.c +++ b/util-linux/fsck_minix.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * fsck.c - a file system consistency checker for Linux. * @@ -96,7 +97,7 @@ #include #include #include -#include /* for PATH_MAX */ +#include /* for PATH_MAX */ #include #include @@ -124,17 +125,17 @@ #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 char *program_name = "fsck.minix"; +static char *program_version = "1.2 - 11/11/96"; +static char *device_name = NULL; static int IN; -static int repair=0, automatic=0, verbose=0, list=0, show=0, warn_mode=0, - force=0; -static int directory=0, regular=0, blockdev=0, chardev=0, links=0, - symlinks=0, total=0; +static int repair = 0, automatic = 0, verbose = 0, list = 0, show = + 0, warn_mode = 0, force = 0; +static int directory = 0, regular = 0, blockdev = 0, chardev = 0, links = + 0, symlinks = 0, total = 0; -static int changed = 0; /* flags if the filesystem has been changed */ -static int errors_uncorrected = 0; /* flag if some error was not corrected */ +static int changed = 0; /* flags if the filesystem has been changed */ +static int errors_uncorrected = 0; /* flag if some error was not corrected */ static int dirsize = 16; static int namelen = 14; static int version2 = 0; @@ -146,10 +147,12 @@ static int termios_set = 0; static int name_depth = 0; static char name_list[MAX_DEPTH][PATH_MAX + 1]; -static char * inode_buffer = NULL; +static char *inode_buffer = NULL; + #define Inode (((struct minix_inode *) inode_buffer)-1) #define Inode2 (((struct minix2_inode *) inode_buffer)-1) static char super_block_buffer[BLOCK_SIZE]; + #define Super (*(struct minix_super_block *)super_block_buffer) #define INODES ((unsigned long)Super.s_ninodes) #ifdef HAVE_MINIX2 @@ -168,8 +171,8 @@ static char super_block_buffer[BLOCK_SIZE]; static char *inode_map; static char *zone_map; -static unsigned char * inode_count = NULL; -static unsigned char * zone_count = NULL; +static unsigned char *inode_count = NULL; +static unsigned char *zone_count = NULL; static void recursive_check(unsigned int ino); static void recursive_check2(unsigned int ino); @@ -191,22 +194,27 @@ static void leave(int status) exit(status); } -static void show_usage(void) { - fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT); +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\n", program_name); - fprintf(stderr, "Performs a consistency check for MINIX filesystems.\n\n"); + fprintf(stderr, + "Performs 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-m\tActivates MINIX-like \"mode not cleared\" warnings\n"); fprintf(stderr, "\t-f\tForce file system check.\n\n"); leave(16); } -static void die(const char *str) { +static void die(const char *str) +{ fprintf(stderr, "%s: %s\n", program_name, str); leave(8); } @@ -217,15 +225,15 @@ static void die(const char *str) { */ static void print_current_name(void) { - int i=0; + int i = 0; - while (imnt_fsname) == 0) + while ((mnt = getmntent(f)) != NULL) + if (strcmp(device_name, mnt->mnt_fsname) == 0) break; - endmntent (f); + endmntent(f); if (!mnt) return; @@ -298,15 +306,15 @@ static void check_mount(void) return; else close(fd); - - printf ("%s is mounted. ", device_name); + + printf("%s is mounted. ", device_name); if (isatty(0) && isatty(1)) cont = ask("Do you really want to continue", 0); else cont = 0; if (!cont) { - printf ("check aborted.\n"); - exit (0); + printf("check aborted.\n"); + exit(0); } return; } @@ -317,7 +325,7 @@ static void check_mount(void) * if an error was corrected, and returns the zone (0 for no zone * or a bad zone-number). */ -static int check_zone_nr(unsigned short * nr, int * corrected) +static int check_zone_nr(unsigned short *nr, int *corrected) { if (!*nr) return 0; @@ -329,7 +337,7 @@ static int check_zone_nr(unsigned short * nr, int * corrected) return *nr; print_current_name(); printf("'."); - if (ask("Remove block",1)) { + if (ask("Remove block", 1)) { *nr = 0; *corrected = 1; } @@ -337,19 +345,19 @@ static int check_zone_nr(unsigned short * nr, int * corrected) } #ifdef HAVE_MINIX2 -static int check_zone_nr2 (unsigned int *nr, int *corrected) +static int check_zone_nr2(unsigned int *nr, int *corrected) { if (!*nr) return 0; if (*nr < FIRSTZONE) - printf ("Zone nr < FIRSTZONE in file `"); + printf("Zone nr < FIRSTZONE in file `"); else if (*nr >= ZONES) - printf ("Zone nr >= ZONES in file `"); + printf("Zone nr >= ZONES in file `"); else return *nr; - print_current_name (); - printf ("'."); - if (ask ("Remove block", 1)) { + print_current_name(); + printf("'."); + if (ask("Remove block", 1)) { *nr = 0; *corrected = 1; } @@ -360,23 +368,23 @@ static int check_zone_nr2 (unsigned int *nr, int *corrected) /* * read-block reads block nr into the buffer at addr. */ -static void read_block(unsigned int nr, char * addr) +static void read_block(unsigned int nr, char *addr) { if (!nr) { - memset(addr,0,BLOCK_SIZE); + memset(addr, 0, BLOCK_SIZE); return; } - if (BLOCK_SIZE*nr != lseek(IN, BLOCK_SIZE*nr, SEEK_SET)) { + if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET)) { printf("Read error: unable to seek to block in file '"); print_current_name(); printf("'\n"); - memset(addr,0,BLOCK_SIZE); + memset(addr, 0, BLOCK_SIZE); errors_uncorrected = 1; } else if (BLOCK_SIZE != read(IN, addr, BLOCK_SIZE)) { printf("Read error: bad block in file '"); print_current_name(); printf("'\n"); - memset(addr,0,BLOCK_SIZE); + memset(addr, 0, BLOCK_SIZE); errors_uncorrected = 1; } } @@ -384,17 +392,17 @@ static void read_block(unsigned int nr, char * addr) /* * write_block writes block nr to disk. */ -static void write_block(unsigned int nr, char * addr) +static void write_block(unsigned int nr, char *addr) { if (!nr) return; if (nr < FIRSTZONE || nr >= ZONES) { printf("Internal error: trying to write bad block\n" - "Write request ignored\n"); + "Write request ignored\n"); errors_uncorrected = 1; return; } - if (BLOCK_SIZE*nr != lseek(IN, BLOCK_SIZE*nr, SEEK_SET)) + if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET)) die("seek failed in write_block"); if (BLOCK_SIZE != write(IN, addr, BLOCK_SIZE)) { printf("Write error: bad block in file '"); @@ -409,16 +417,16 @@ static void write_block(unsigned int nr, char * addr) * It sets 'changed' if the inode has needed changing, and re-writes * any indirect blocks with errors. */ -static int map_block(struct minix_inode * inode, unsigned int blknr) +static int map_block(struct minix_inode *inode, unsigned int blknr) { - unsigned short ind[BLOCK_SIZE>>1]; - unsigned short dind[BLOCK_SIZE>>1]; + unsigned short ind[BLOCK_SIZE >> 1]; + unsigned short dind[BLOCK_SIZE >> 1]; int blk_chg, block, result; - if (blknr<7) + if (blknr < 7) return check_zone_nr(inode->i_zone + blknr, &changed); blknr -= 7; - if (blknr<512) { + if (blknr < 512) { block = check_zone_nr(inode->i_zone + 7, &changed); read_block(block, (char *) ind); blk_chg = 0; @@ -431,73 +439,73 @@ static int map_block(struct minix_inode * inode, unsigned int blknr) block = check_zone_nr(inode->i_zone + 8, &changed); read_block(block, (char *) dind); blk_chg = 0; - result = check_zone_nr(dind + (blknr/512), &blk_chg); + result = check_zone_nr(dind + (blknr / 512), &blk_chg); if (blk_chg) write_block(block, (char *) dind); block = result; read_block(block, (char *) ind); blk_chg = 0; - result = check_zone_nr(ind + (blknr%512), &blk_chg); + result = check_zone_nr(ind + (blknr % 512), &blk_chg); if (blk_chg) write_block(block, (char *) ind); return result; } #ifdef HAVE_MINIX2 -static int map_block2 (struct minix2_inode *inode, unsigned int blknr) +static int map_block2(struct minix2_inode *inode, unsigned int blknr) { - unsigned int ind[BLOCK_SIZE >> 2]; + unsigned int ind[BLOCK_SIZE >> 2]; unsigned int dind[BLOCK_SIZE >> 2]; unsigned int tind[BLOCK_SIZE >> 2]; int blk_chg, block, result; if (blknr < 7) - return check_zone_nr2 (inode->i_zone + blknr, &changed); + return check_zone_nr2(inode->i_zone + blknr, &changed); blknr -= 7; if (blknr < 256) { - block = check_zone_nr2 (inode->i_zone + 7, &changed); - read_block (block, (char *) ind); + block = check_zone_nr2(inode->i_zone + 7, &changed); + read_block(block, (char *) ind); blk_chg = 0; - result = check_zone_nr2 (blknr + ind, &blk_chg); + result = check_zone_nr2(blknr + ind, &blk_chg); if (blk_chg) - write_block (block, (char *) ind); + write_block(block, (char *) ind); return result; } blknr -= 256; if (blknr >= 256 * 256) { - block = check_zone_nr2 (inode->i_zone + 8, &changed); - read_block (block, (char *) dind); + block = check_zone_nr2(inode->i_zone + 8, &changed); + read_block(block, (char *) dind); blk_chg = 0; - result = check_zone_nr2 (dind + blknr / 256, &blk_chg); + result = check_zone_nr2(dind + blknr / 256, &blk_chg); if (blk_chg) - write_block (block, (char *) dind); + write_block(block, (char *) dind); block = result; - read_block (block, (char *) ind); + read_block(block, (char *) ind); blk_chg = 0; - result = check_zone_nr2 (ind + blknr % 256, &blk_chg); + result = check_zone_nr2(ind + blknr % 256, &blk_chg); if (blk_chg) - write_block (block, (char *) ind); + write_block(block, (char *) ind); return result; } blknr -= 256 * 256; - block = check_zone_nr2 (inode->i_zone + 9, &changed); - read_block (block, (char *) tind); + block = check_zone_nr2(inode->i_zone + 9, &changed); + read_block(block, (char *) tind); blk_chg = 0; - result = check_zone_nr2 (tind + blknr / (256 * 256), &blk_chg); + result = check_zone_nr2(tind + blknr / (256 * 256), &blk_chg); if (blk_chg) - write_block (block, (char *) tind); + write_block(block, (char *) tind); block = result; - read_block (block, (char *) dind); + read_block(block, (char *) dind); blk_chg = 0; - result = check_zone_nr2 (dind + (blknr / 256) % 256, &blk_chg); + result = check_zone_nr2(dind + (blknr / 256) % 256, &blk_chg); if (blk_chg) - write_block (block, (char *) dind); + write_block(block, (char *) dind); block = result; - read_block (block, (char *) ind); + read_block(block, (char *) ind); blk_chg = 0; - result = check_zone_nr2 (ind + blknr % 256, &blk_chg); + result = check_zone_nr2(ind + blknr % 256, &blk_chg); if (blk_chg) - write_block (block, (char *) ind); + write_block(block, (char *) ind); return result; } #endif @@ -510,11 +518,11 @@ static void write_super_block(void) * unconditionally set if we get this far. */ Super.s_state |= MINIX_VALID_FS; - if ( errors_uncorrected ) + if (errors_uncorrected) Super.s_state |= MINIX_ERROR_FS; else Super.s_state &= ~MINIX_ERROR_FS; - + if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET)) die("seek failed in write_super_block"); if (BLOCK_SIZE != write(IN, super_block_buffer, BLOCK_SIZE)) @@ -527,15 +535,15 @@ static void write_tables(void) { write_super_block(); - if (IMAPS*BLOCK_SIZE != write(IN,inode_map,IMAPS*BLOCK_SIZE)) + if (IMAPS * BLOCK_SIZE != write(IN, inode_map, IMAPS * BLOCK_SIZE)) die("Unable to write inode map"); - if (ZMAPS*BLOCK_SIZE != write(IN,zone_map,ZMAPS*BLOCK_SIZE)) + if (ZMAPS * BLOCK_SIZE != write(IN, zone_map, ZMAPS * BLOCK_SIZE)) die("Unable to write zone map"); - if (INODE_BUFFER_SIZE != write(IN,inode_buffer,INODE_BUFFER_SIZE)) + if (INODE_BUFFER_SIZE != write(IN, inode_buffer, INODE_BUFFER_SIZE)) die("Unable to write inodes"); } -static void get_dirsize (void) +static void get_dirsize(void) { int block; char blk[BLOCK_SIZE]; @@ -547,9 +555,9 @@ static void get_dirsize (void) else #endif block = Inode[ROOT_INO].i_zone[0]; - read_block (block, blk); + read_block(block, blk); for (size = 16; size < BLOCK_SIZE; size <<= 1) { - if (strcmp (blk + size + 2, "..") == 0) { + if (strcmp(blk + size + 2, "..") == 0) { dirsize = size; namelen = size - 2; return; @@ -600,8 +608,8 @@ static void read_tables(void) zone_map = malloc(ZMAPS * BLOCK_SIZE); if (!inode_map) die("Unable to allocate buffer for zone map"); - memset(inode_map,0,sizeof(inode_map)); - memset(zone_map,0,sizeof(zone_map)); + memset(inode_map, 0, sizeof(inode_map)); + memset(zone_map, 0, sizeof(zone_map)); inode_buffer = malloc(INODE_BUFFER_SIZE); if (!inode_buffer) die("Unable to allocate buffer for inodes"); @@ -611,31 +619,31 @@ static void read_tables(void) zone_count = malloc(ZONES); if (!zone_count) die("Unable to allocate buffer for zone count"); - if (IMAPS*BLOCK_SIZE != read(IN,inode_map,IMAPS*BLOCK_SIZE)) + if (IMAPS * BLOCK_SIZE != read(IN, inode_map, IMAPS * BLOCK_SIZE)) die("Unable to read inode map"); - if (ZMAPS*BLOCK_SIZE != read(IN,zone_map,ZMAPS*BLOCK_SIZE)) + if (ZMAPS * BLOCK_SIZE != read(IN, zone_map, ZMAPS * BLOCK_SIZE)) die("Unable to read zone map"); - if (INODE_BUFFER_SIZE != read(IN,inode_buffer,INODE_BUFFER_SIZE)) + if (INODE_BUFFER_SIZE != read(IN, inode_buffer, INODE_BUFFER_SIZE)) die("Unable to read inodes"); if (NORM_FIRSTZONE != FIRSTZONE) { printf("Warning: Firstzone != Norm_firstzone\n"); errors_uncorrected = 1; } - get_dirsize (); + get_dirsize(); if (show) { - printf("%ld inodes\n",INODES); - printf("%ld blocks\n",ZONES); - printf("Firstdatazone=%ld (%ld)\n",FIRSTZONE,NORM_FIRSTZONE); - printf("Zonesize=%d\n",BLOCK_SIZE< INODES) return NULL; @@ -643,15 +651,14 @@ struct minix_inode * get_inode(unsigned int nr) inode = Inode + nr; if (!inode_count[nr]) { if (!inode_in_use(nr)) { - printf("Inode %d marked not used, but used for file '", - nr); + printf("Inode %d marked not used, but used for file '", nr); print_current_name(); printf("'\n"); if (repair) { - if (ask("Mark in use",1)) + if (ask("Mark in use", 1)) mark_inode(nr); } else { - errors_uncorrected = 1; + errors_uncorrected = 1; } } if (S_ISDIR(inode->i_mode)) @@ -664,14 +671,12 @@ struct minix_inode * get_inode(unsigned int nr) blockdev++; else if (S_ISLNK(inode->i_mode)) symlinks++; - else if (S_ISSOCK(inode->i_mode)) - ; - else if (S_ISFIFO(inode->i_mode)) - ; + else if (S_ISSOCK(inode->i_mode)); + else if (S_ISFIFO(inode->i_mode)); else { - print_current_name(); - printf(" has mode %05o\n",inode->i_mode); - } + print_current_name(); + printf(" has mode %05o\n", inode->i_mode); + } } else links++; @@ -684,8 +689,7 @@ struct minix_inode * get_inode(unsigned int nr) } #ifdef HAVE_MINIX2 -struct minix2_inode * -get_inode2 (unsigned int nr) +struct minix2_inode *get_inode2(unsigned int nr) { struct minix2_inode *inode; @@ -694,37 +698,37 @@ get_inode2 (unsigned int nr) total++; inode = Inode2 + nr; if (!inode_count[nr]) { - if (!inode_in_use (nr)) { - printf ("Inode %d marked not used, but used for file '", nr); - print_current_name (); - printf ("'\n"); + if (!inode_in_use(nr)) { + printf("Inode %d marked not used, but used for file '", nr); + print_current_name(); + printf("'\n"); if (repair) { - if (ask ("Mark in use", 1)) - mark_inode (nr); + if (ask("Mark in use", 1)) + mark_inode(nr); else errors_uncorrected = 1; } } - if (S_ISDIR (inode->i_mode)) + if (S_ISDIR(inode->i_mode)) directory++; - else if (S_ISREG (inode->i_mode)) + else if (S_ISREG(inode->i_mode)) regular++; - else if (S_ISCHR (inode->i_mode)) + else if (S_ISCHR(inode->i_mode)) chardev++; - else if (S_ISBLK (inode->i_mode)) + else if (S_ISBLK(inode->i_mode)) blockdev++; - else if (S_ISLNK (inode->i_mode)) + else if (S_ISLNK(inode->i_mode)) symlinks++; - else if (S_ISSOCK (inode->i_mode)); - else if (S_ISFIFO (inode->i_mode)); + else if (S_ISSOCK(inode->i_mode)); + else if (S_ISFIFO(inode->i_mode)); else { - print_current_name (); - printf (" has mode %05o\n", inode->i_mode); + print_current_name(); + printf(" has mode %05o\n", inode->i_mode); } } else links++; if (!++inode_count[nr]) { - printf ("Warning: inode count too big.\n"); + printf("Warning: inode count too big.\n"); inode_count[nr]--; errors_uncorrected = 1; } @@ -734,23 +738,23 @@ get_inode2 (unsigned int nr) static void check_root(void) { - struct minix_inode * inode = Inode + ROOT_INO; + struct minix_inode *inode = Inode + ROOT_INO; if (!inode || !S_ISDIR(inode->i_mode)) die("root inode isn't a directory"); } #ifdef HAVE_MINIX2 -static void check_root2 (void) +static void check_root2(void) { struct minix2_inode *inode = Inode2 + ROOT_INO; - if (!inode || !S_ISDIR (inode->i_mode)) - die ("root inode isn't a directory"); + if (!inode || !S_ISDIR(inode->i_mode)) + die("root inode isn't a directory"); } #endif -static int add_zone(unsigned short * znr, int * corrected) +static int add_zone(unsigned short *znr, int *corrected) { int result; int block; @@ -763,7 +767,7 @@ static int add_zone(unsigned short * znr, int * corrected) printf("Block has been used before. Now in file `"); print_current_name(); printf("'."); - if (ask("Clear",1)) { + if (ask("Clear", 1)) { *znr = 0; block = 0; *corrected = 1; @@ -772,10 +776,10 @@ static int add_zone(unsigned short * znr, int * corrected) if (!block) return 0; if (!zone_in_use(block)) { - printf("Block %d in file `",block); + printf("Block %d in file `", block); print_current_name(); printf("' is marked not in use."); - if (ask("Correct",1)) + if (ask("Correct", 1)) mark_zone(block); } if (!++zone_count[block]) @@ -784,20 +788,20 @@ static int add_zone(unsigned short * znr, int * corrected) } #ifdef HAVE_MINIX2 -static int add_zone2 (unsigned int *znr, int *corrected) +static int add_zone2(unsigned int *znr, int *corrected) { int result; int block; result = 0; - block = check_zone_nr2 (znr, corrected); + block = check_zone_nr2(znr, corrected); if (!block) return 0; if (zone_count[block]) { - printf ("Block has been used before. Now in file `"); - print_current_name (); - printf ("'."); - if (ask ("Clear", 1)) { + printf("Block has been used before. Now in file `"); + print_current_name(); + printf("'."); + if (ask("Clear", 1)) { *znr = 0; block = 0; *corrected = 1; @@ -805,12 +809,12 @@ static int add_zone2 (unsigned int *znr, int *corrected) } if (!block) return 0; - if (!zone_in_use (block)) { - printf ("Block %d in file `", block); - print_current_name (); - printf ("' is marked not in use."); - if (ask ("Correct", 1)) - mark_zone (block); + if (!zone_in_use(block)) { + printf("Block %d in file `", block); + print_current_name(); + printf("' is marked not in use."); + if (ask("Correct", 1)) + mark_zone(block); } if (!++zone_count[block]) zone_count[block]--; @@ -818,182 +822,179 @@ static int add_zone2 (unsigned int *znr, int *corrected) } #endif -static void add_zone_ind(unsigned short * znr, int * corrected) +static void add_zone_ind(unsigned short *znr, int *corrected) { static char blk[BLOCK_SIZE]; - int i, chg_blk=0; + int i, chg_blk = 0; int block; block = add_zone(znr, corrected); if (!block) return; read_block(block, blk); - for (i=0 ; i < (BLOCK_SIZE>>1) ; i++) + for (i = 0; i < (BLOCK_SIZE >> 1); i++) add_zone(i + (unsigned short *) blk, &chg_blk); if (chg_blk) write_block(block, blk); } #ifdef HAVE_MINIX2 -static void -add_zone_ind2 (unsigned int *znr, int *corrected) +static void add_zone_ind2(unsigned int *znr, int *corrected) { static char blk[BLOCK_SIZE]; int i, chg_blk = 0; int block; - block = add_zone2 (znr, corrected); + block = add_zone2(znr, corrected); if (!block) return; - read_block (block, blk); + read_block(block, blk); for (i = 0; i < BLOCK_SIZE >> 2; i++) - add_zone2 (i + (unsigned int *) blk, &chg_blk); + add_zone2(i + (unsigned int *) blk, &chg_blk); if (chg_blk) - write_block (block, blk); + write_block(block, blk); } #endif -static void add_zone_dind(unsigned short * znr, int * corrected) +static void add_zone_dind(unsigned short *znr, int *corrected) { static char blk[BLOCK_SIZE]; - int i, blk_chg=0; + int i, blk_chg = 0; int block; block = add_zone(znr, corrected); if (!block) return; read_block(block, blk); - for (i=0 ; i < (BLOCK_SIZE>>1) ; i++) + for (i = 0; i < (BLOCK_SIZE >> 1); i++) add_zone_ind(i + (unsigned short *) blk, &blk_chg); if (blk_chg) write_block(block, blk); } #ifdef HAVE_MINIX2 -static void -add_zone_dind2 (unsigned int *znr, int *corrected) +static void add_zone_dind2(unsigned int *znr, int *corrected) { static char blk[BLOCK_SIZE]; int i, blk_chg = 0; int block; - block = add_zone2 (znr, corrected); + block = add_zone2(znr, corrected); if (!block) return; - read_block (block, blk); + read_block(block, blk); for (i = 0; i < BLOCK_SIZE >> 2; i++) - add_zone_ind2 (i + (unsigned int *) blk, &blk_chg); + add_zone_ind2(i + (unsigned int *) blk, &blk_chg); if (blk_chg) - write_block (block, blk); + write_block(block, blk); } -static void -add_zone_tind2 (unsigned int *znr, int *corrected) +static void add_zone_tind2(unsigned int *znr, int *corrected) { static char blk[BLOCK_SIZE]; int i, blk_chg = 0; int block; - block = add_zone2 (znr, corrected); + block = add_zone2(znr, corrected); if (!block) return; - read_block (block, blk); + read_block(block, blk); for (i = 0; i < BLOCK_SIZE >> 2; i++) - add_zone_dind2 (i + (unsigned int *) blk, &blk_chg); + add_zone_dind2(i + (unsigned int *) blk, &blk_chg); if (blk_chg) - write_block (block, blk); + write_block(block, blk); } #endif static void check_zones(unsigned int i) { - struct minix_inode * inode; + struct minix_inode *inode; if (!i || i > INODES) return; - if (inode_count[i] > 1) /* have we counted this file already? */ + if (inode_count[i] > 1) /* have we counted this file already? */ return; inode = Inode + i; if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) && - !S_ISLNK(inode->i_mode)) - return; - for (i=0 ; i<7 ; i++) + !S_ISLNK(inode->i_mode)) return; + for (i = 0; i < 7; i++) add_zone(i + inode->i_zone, &changed); add_zone_ind(7 + inode->i_zone, &changed); add_zone_dind(8 + inode->i_zone, &changed); } #ifdef HAVE_MINIX2 -static void -check_zones2 (unsigned int i) +static void check_zones2(unsigned int i) { struct minix2_inode *inode; if (!i || i > INODES) return; - if (inode_count[i] > 1) /* have we counted this file already? */ + if (inode_count[i] > 1) /* have we counted this file already? */ return; inode = Inode2 + i; - if (!S_ISDIR (inode->i_mode) && !S_ISREG (inode->i_mode) - && !S_ISLNK (inode->i_mode)) + if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) + && !S_ISLNK(inode->i_mode)) return; for (i = 0; i < 7; i++) - add_zone2 (i + inode->i_zone, &changed); - add_zone_ind2 (7 + inode->i_zone, &changed); - add_zone_dind2 (8 + inode->i_zone, &changed); - add_zone_tind2 (9 + inode->i_zone, &changed); + add_zone2(i + inode->i_zone, &changed); + add_zone_ind2(7 + inode->i_zone, &changed); + add_zone_dind2(8 + inode->i_zone, &changed); + add_zone_tind2(9 + inode->i_zone, &changed); } #endif -static void check_file(struct minix_inode * dir, unsigned int offset) +static void check_file(struct minix_inode *dir, unsigned int offset) { static char blk[BLOCK_SIZE]; - struct minix_inode * inode; + struct minix_inode *inode; int ino; - char * name; + char *name; int block; - block = map_block(dir,offset/BLOCK_SIZE); + block = map_block(dir, offset / BLOCK_SIZE); read_block(block, blk); name = blk + (offset % BLOCK_SIZE) + 2; - ino = * (unsigned short *) (name-2); + ino = *(unsigned short *) (name - 2); if (ino > INODES) { print_current_name(); printf(" contains a bad inode number for file '"); - printf("%.*s'.",namelen,name); - if (ask(" Remove",1)) { - *(unsigned short *)(name-2) = 0; + printf("%.*s'.", namelen, name); + if (ask(" Remove", 1)) { + *(unsigned short *) (name - 2) = 0; write_block(block, blk); } ino = 0; - } + } if (name_depth < MAX_DEPTH) - strncpy (name_list[name_depth], name, namelen); + strncpy(name_list[name_depth], name, namelen); name_depth++; inode = get_inode(ino); name_depth--; if (!offset) { - if (!inode || strcmp(".",name)) { + if (!inode || strcmp(".", name)) { print_current_name(); printf(": bad directory: '.' isn't first\n"); errors_uncorrected = 1; - } else return; + } else + return; } if (offset == dirsize) { - if (!inode || strcmp("..",name)) { + if (!inode || strcmp("..", name)) { print_current_name(); printf(": bad directory: '..' isn't second\n"); errors_uncorrected = 1; - } else return; + } else + return; } if (!inode) return; if (name_depth < MAX_DEPTH) - strncpy(name_list[name_depth],name,namelen); - name_depth++; + strncpy(name_list[name_depth], name, namelen); + name_depth++; if (list) { if (verbose) - printf("%6d %07o %3d ",ino,inode->i_mode,inode->i_nlinks); + printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks); print_current_name(); if (S_ISDIR(inode->i_mode)) printf(":\n"); @@ -1008,8 +1009,7 @@ static void check_file(struct minix_inode * dir, unsigned int offset) } #ifdef HAVE_MINIX2 -static void -check_file2 (struct minix2_inode *dir, unsigned int offset) +static void check_file2(struct minix2_inode *dir, unsigned int offset) { static char blk[BLOCK_SIZE]; struct minix2_inode *inode; @@ -1017,37 +1017,37 @@ check_file2 (struct minix2_inode *dir, unsigned int offset) char *name; int block; - block = map_block2 (dir, offset / BLOCK_SIZE); - read_block (block, blk); + block = map_block2(dir, offset / BLOCK_SIZE); + read_block(block, blk); name = blk + (offset % BLOCK_SIZE) + 2; ino = *(unsigned short *) (name - 2); if (ino > INODES) { - print_current_name (); - printf (" contains a bad inode number for file '"); - printf ("%.*s'.", namelen, name); - if (ask (" Remove", 1)) { + print_current_name(); + printf(" contains a bad inode number for file '"); + printf("%.*s'.", namelen, name); + if (ask(" Remove", 1)) { *(unsigned short *) (name - 2) = 0; - write_block (block, blk); + write_block(block, blk); } ino = 0; } if (name_depth < MAX_DEPTH) - strncpy (name_list[name_depth], name, namelen); + strncpy(name_list[name_depth], name, namelen); name_depth++; - inode = get_inode2 (ino); + inode = get_inode2(ino); name_depth--; if (!offset) { - if (!inode || strcmp (".", name)) { - print_current_name (); - printf (": bad directory: '.' isn't first\n"); + if (!inode || strcmp(".", name)) { + print_current_name(); + printf(": bad directory: '.' isn't first\n"); errors_uncorrected = 1; } else return; } if (offset == dirsize) { - if (!inode || strcmp ("..", name)) { - print_current_name (); - printf (": bad directory: '..' isn't second\n"); + if (!inode || strcmp("..", name)) { + print_current_name(); + printf(": bad directory: '..' isn't second\n"); errors_uncorrected = 1; } else return; @@ -1057,16 +1057,16 @@ check_file2 (struct minix2_inode *dir, unsigned int offset) name_depth++; if (list) { if (verbose) - printf ("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks); - print_current_name (); - if (S_ISDIR (inode->i_mode)) - printf (":\n"); + printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks); + print_current_name(); + if (S_ISDIR(inode->i_mode)) + printf(":\n"); else - printf ("\n"); + printf("\n"); } - check_zones2 (ino); - if (inode && S_ISDIR (inode->i_mode)) - recursive_check2 (ino); + check_zones2(ino); + if (inode && S_ISDIR(inode->i_mode)) + recursive_check2(ino); name_depth--; return; } @@ -1074,7 +1074,7 @@ check_file2 (struct minix2_inode *dir, unsigned int offset) static void recursive_check(unsigned int ino) { - struct minix_inode * dir; + struct minix_inode *dir; unsigned int offset; dir = Inode + ino; @@ -1085,27 +1085,26 @@ static void recursive_check(unsigned int ino) printf(": bad directory: size<32"); errors_uncorrected = 1; } - for (offset = 0 ; offset < dir->i_size ; offset += dirsize) - check_file(dir,offset); + for (offset = 0; offset < dir->i_size; offset += dirsize) + check_file(dir, offset); } #ifdef HAVE_MINIX2 -static void -recursive_check2 (unsigned int ino) +static void recursive_check2(unsigned int ino) { struct minix2_inode *dir; unsigned int offset; dir = Inode2 + ino; - if (!S_ISDIR (dir->i_mode)) - die ("internal error"); + if (!S_ISDIR(dir->i_mode)) + die("internal error"); if (dir->i_size < 2 * dirsize) { - print_current_name (); - printf (": bad directory: size < 32"); + print_current_name(); + printf(": bad directory: size < 32"); errors_uncorrected = 1; } for (offset = 0; offset < dir->i_size; offset += dirsize) - check_file2 (dir, offset); + check_file2(dir, offset); } #endif @@ -1113,7 +1112,7 @@ static int bad_zone(int i) { char buffer[1024]; - if (BLOCK_SIZE*i != lseek(IN, BLOCK_SIZE*i, SEEK_SET)) + if (BLOCK_SIZE * i != lseek(IN, BLOCK_SIZE * i, SEEK_SET)) die("seek failed in bad_zone"); return (BLOCK_SIZE != read(IN, buffer, BLOCK_SIZE)); } @@ -1122,10 +1121,10 @@ static void check_counts(void) { int i; - for (i=1 ; i <= INODES ; i++) { + for (i = 1; i <= INODES; i++) { if (!inode_in_use(i) && Inode[i].i_mode && warn_mode) { - printf("Inode %d mode not cleared.",i); - if (ask("Clear",1)) { + printf("Inode %d mode not cleared.", i); + if (ask("Clear", 1)) { Inode[i].i_mode = 0; changed = 1; } @@ -1133,117 +1132,115 @@ static void check_counts(void) if (!inode_count[i]) { if (!inode_in_use(i)) continue; - printf("Inode %d not used, marked used in the bitmap.",i); - if (ask("Clear",1)) + printf("Inode %d not used, marked used in the bitmap.", i); + if (ask("Clear", 1)) unmark_inode(i); continue; } if (!inode_in_use(i)) { printf("Inode %d used, marked unused in the bitmap.", i); - if (ask("Set",1)) + if (ask("Set", 1)) mark_inode(i); } if (Inode[i].i_nlinks != inode_count[i]) { printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.", - i,Inode[i].i_mode,Inode[i].i_nlinks,inode_count[i]); - if (ask("Set i_nlinks to count",1)) { - Inode[i].i_nlinks=inode_count[i]; - changed=1; + i, Inode[i].i_mode, Inode[i].i_nlinks, inode_count[i]); + if (ask("Set i_nlinks to count", 1)) { + Inode[i].i_nlinks = inode_count[i]; + changed = 1; } } } - for (i=FIRSTZONE ; i < ZONES ; i++) { + for (i = FIRSTZONE; i < ZONES; i++) { if (zone_in_use(i) == zone_count[i]) continue; if (!zone_count[i]) { if (bad_zone(i)) continue; - printf("Zone %d: marked in use, no file uses it.",i); - if (ask("Unmark",1)) + printf("Zone %d: marked in use, no file uses it.", i); + if (ask("Unmark", 1)) unmark_zone(i); continue; } - printf("Zone %d: %sin use, counted=%d\n", - i,zone_in_use(i)?"":"not ",zone_count[i]); + printf("Zone %d: %sin use, counted=%d\n", + i, zone_in_use(i) ? "" : "not ", zone_count[i]); } } #ifdef HAVE_MINIX2 -static void -check_counts2 (void) +static void check_counts2(void) { int i; for (i = 1; i <= INODES; i++) { - if (!inode_in_use (i) && Inode2[i].i_mode && warn_mode) { - printf ("Inode %d mode not cleared.", i); - if (ask ("Clear", 1)) { + if (!inode_in_use(i) && Inode2[i].i_mode && warn_mode) { + printf("Inode %d mode not cleared.", i); + if (ask("Clear", 1)) { Inode2[i].i_mode = 0; changed = 1; } } if (!inode_count[i]) { - if (!inode_in_use (i)) + if (!inode_in_use(i)) continue; - printf ("Inode %d not used, marked used in the bitmap.", i); - if (ask ("Clear", 1)) - unmark_inode (i); + printf("Inode %d not used, marked used in the bitmap.", i); + if (ask("Clear", 1)) + unmark_inode(i); continue; } - if (!inode_in_use (i)) { - printf ("Inode %d used, marked unused in the bitmap.", i); - if (ask ("Set", 1)) - mark_inode (i); + if (!inode_in_use(i)) { + printf("Inode %d used, marked unused in the bitmap.", i); + if (ask("Set", 1)) + mark_inode(i); } if (Inode2[i].i_nlinks != inode_count[i]) { - printf ("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.", - i, Inode2[i].i_mode, Inode2[i].i_nlinks, inode_count[i]); - if (ask ("Set i_nlinks to count", 1)) { + printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.", + i, Inode2[i].i_mode, Inode2[i].i_nlinks, + inode_count[i]); + if (ask("Set i_nlinks to count", 1)) { Inode2[i].i_nlinks = inode_count[i]; changed = 1; } } } for (i = FIRSTZONE; i < ZONES; i++) { - if (zone_in_use (i) == zone_count[i]) + if (zone_in_use(i) == zone_count[i]) continue; if (!zone_count[i]) { - if (bad_zone (i)) + if (bad_zone(i)) continue; - printf ("Zone %d: marked in use, no file uses it.", i); - if (ask ("Unmark", 1)) - unmark_zone (i); + printf("Zone %d: marked in use, no file uses it.", i); + if (ask("Unmark", 1)) + unmark_zone(i); continue; } - printf ("Zone %d: %sin use, counted=%d\n", - i, zone_in_use (i) ? "" : "not ", zone_count[i]); + printf("Zone %d: %sin use, counted=%d\n", + i, zone_in_use(i) ? "" : "not ", zone_count[i]); } } #endif static void check(void) { - memset(inode_count,0,(INODES + 1) * sizeof(*inode_count)); - memset(zone_count,0,ZONES*sizeof(*zone_count)); + memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count)); + memset(zone_count, 0, ZONES * sizeof(*zone_count)); check_zones(ROOT_INO); recursive_check(ROOT_INO); check_counts(); } #ifdef HAVE_MINIX2 -static void -check2 (void) +static void check2(void) { - memset (inode_count, 0, (INODES + 1) * sizeof (*inode_count)); - memset (zone_count, 0, ZONES * sizeof (*zone_count)); - check_zones2 (ROOT_INO); - recursive_check2 (ROOT_INO); - check_counts2 (); + memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count)); + memset(zone_count, 0, ZONES * sizeof(*zone_count)); + check_zones2(ROOT_INO); + recursive_check2(ROOT_INO); + check_counts2(); } #endif -extern int -fsck_minix_main(int argc, char ** argv) +extern int fsck_minix_main(int argc, char **argv) { struct termios tmp; int count; @@ -1264,29 +1261,47 @@ fsck_minix_main(int argc, char ** argv) show_usage(); else device_name = argv[0]; - } else while (*++argv[0]) - switch (argv[0][0]) { - case 'l': list=1; break; - case 'a': automatic=1; repair=1; break; - case 'r': automatic=0; repair=1; break; - case 'v': verbose=1; break; - case 's': show=1; break; - case 'm': warn_mode=1; break; - case 'f': force=1; break; - default: show_usage(); - } + } else + while (*++argv[0]) + switch (argv[0][0]) { + case 'l': + list = 1; + break; + case 'a': + automatic = 1; + repair = 1; + break; + case 'r': + automatic = 0; + repair = 1; + break; + case 'v': + verbose = 1; + break; + case 's': + show = 1; + break; + case 'm': + warn_mode = 1; + break; + case 'f': + force = 1; + break; + default: + show_usage(); + } } if (!device_name) show_usage(); - check_mount(); /* trying to check a mounted filesystem? */ + check_mount(); /* trying to check a mounted filesystem? */ if (repair && !automatic) { if (!isatty(0) || !isatty(1)) die("need terminal for interactive repairs"); } - IN = open(device_name,repair?O_RDWR:O_RDONLY); + IN = open(device_name, repair ? O_RDWR : O_RDONLY); if (IN < 0) die("unable to open '%s'"); - for (count=0 ; count<3 ; count++) + for (count = 0; count < 3; count++) sync(); read_superblock(); @@ -1297,80 +1312,77 @@ fsck_minix_main(int argc, char ** argv) * command line. */ printf("%s, %s\n", program_name, program_version); - if ( !(Super.s_state & MINIX_ERROR_FS) && - (Super.s_state & MINIX_VALID_FS) && - !force ) { + if (!(Super.s_state & MINIX_ERROR_FS) && + (Super.s_state & MINIX_VALID_FS) && !force) { if (repair) printf("%s is clean, no check.\n", device_name); return retcode; - } - else if (force) + } else if (force) printf("Forcing filesystem check on %s.\n", device_name); else if (repair) - printf("Filesystem on %s is dirty, needs checking.\n",\ - device_name); + printf("Filesystem on %s is dirty, needs checking.\n", + device_name); read_tables(); if (repair && !automatic) { - tcgetattr(0,&termios); + tcgetattr(0, &termios); tmp = termios; - tmp.c_lflag &= ~(ICANON|ECHO); - tcsetattr(0,TCSANOW,&tmp); + tmp.c_lflag &= ~(ICANON | ECHO); + tcsetattr(0, TCSANOW, &tmp); termios_set = 1; } - #if HAVE_MINIX2 if (version2) { - check_root2 (); - check2 (); - } else + check_root2(); + check2(); + } else #endif - { + { check_root(); check(); } if (verbose) { int i, free; - for (i=1,free=0 ; i <= INODES ; i++) + for (i = 1, free = 0; i <= INODES; i++) if (!inode_in_use(i)) free++; - printf("\n%6ld inodes used (%ld%%)\n",(INODES-free), - 100*(INODES-free)/INODES); - for (i=FIRSTZONE,free=0 ; i < ZONES ; i++) + printf("\n%6ld inodes used (%ld%%)\n", (INODES - free), + 100 * (INODES - free) / INODES); + for (i = FIRSTZONE, free = 0; i < ZONES; i++) if (!zone_in_use(i)) free++; - printf("%6ld zones used (%ld%%)\n",(ZONES-free), - 100*(ZONES-free)/ZONES); + printf("%6ld zones used (%ld%%)\n", (ZONES - free), + 100 * (ZONES - free) / ZONES); printf("\n%6d regular files\n" - "%6d directories\n" - "%6d character device files\n" - "%6d block device files\n" - "%6d links\n" - "%6d symbolic links\n" - "------\n" - "%6d files\n", - regular,directory,chardev,blockdev, - links-2*directory+1,symlinks,total-2*directory+1); + "%6d directories\n" + "%6d character device files\n" + "%6d block device files\n" + "%6d links\n" + "%6d symbolic links\n" + "------\n" + "%6d files\n", + regular, directory, chardev, blockdev, + links - 2 * directory + 1, symlinks, + total - 2 * directory + 1); } if (changed) { write_tables(); - printf( "----------------------------\n" - "FILE SYSTEM HAS BEEN CHANGED\n" - "----------------------------\n"); - for (count=0 ; count<3 ; count++) + printf("----------------------------\n" + "FILE SYSTEM HAS BEEN CHANGED\n" + "----------------------------\n"); + for (count = 0; count < 3; count++) sync(); - } - else if ( repair ) + } else if (repair) write_super_block(); - + if (repair && !automatic) - tcsetattr(0,TCSANOW,&termios); + tcsetattr(0, TCSANOW, &termios); if (changed) - retcode += 3; + retcode += 3; if (errors_uncorrected) - retcode += 4; + retcode += 4; return retcode; } diff --git a/util-linux/mkfs_minix.c b/util-linux/mkfs_minix.c index b90d3a700..4435cb64a 100644 --- a/util-linux/mkfs_minix.c +++ b/util-linux/mkfs_minix.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * mkfs.c - make a linux (minix) file-system. * @@ -107,27 +108,30 @@ #define BITS_PER_BLOCK (BLOCK_SIZE<<3) -static char * program_name = "mkfs"; -static char * device_name = NULL; +static char *program_name = "mkfs"; +static char *device_name = NULL; static int DEV = -1; static long BLOCKS = 0; static int check = 0; static int badblocks = 0; -static int namelen = 30; /* default (changed to 30, per Linus's - suggestion, Sun Nov 21 08:05:07 1993) */ +static int namelen = 30; /* default (changed to 30, per Linus's + + suggestion, Sun Nov 21 08:05:07 1993) */ static int dirsize = 32; static int magic = MINIX_SUPER_MAGIC2; static int version2 = 0; static char root_block[BLOCK_SIZE] = "\0"; -static char * inode_buffer = NULL; +static char *inode_buffer = NULL; + #define Inode (((struct minix_inode *) inode_buffer)-1) #ifdef HAVE_MINIX2 #define Inode2 (((struct minix2_inode *) inode_buffer)-1) #endif static char super_block_buffer[BLOCK_SIZE]; static char boot_block_buffer[512]; + #define Super (*(struct minix_super_block *)super_block_buffer) #define INODES ((unsigned long)Super.s_ninodes) #ifdef HAVE_MINIX2 @@ -164,21 +168,28 @@ static unsigned long req_nr_inodes = 0; * to compile this under minix, volatile gives a warning, as * exit() isn't defined as volatile under minix. */ -static volatile void die(char *str) { +static volatile void die(char *str) +{ fprintf(stderr, "%s: %s\n", program_name, str); exit(8); } static volatile void show_usage() { - fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT); - fprintf(stderr, "Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]\n\n", program_name); + fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", + BB_VER, BB_BT); + fprintf(stderr, + "Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]\n\n", + program_name); fprintf(stderr, "Make a MINIX filesystem.\n\n"); fprintf(stderr, "OPTIONS:\n"); fprintf(stderr, "\t-c\t\tCheck the device for bad blocks\n"); - fprintf(stderr, "\t-n [14|30]\tSpecify the maximum length of filenames\n"); - fprintf(stderr, "\t-i\t\tSpecify the number of inodes for the filesystem\n"); - fprintf(stderr, "\t-l FILENAME\tRead the bad blocks list from FILENAME\n"); + fprintf(stderr, + "\t-n [14|30]\tSpecify the maximum length of filenames\n"); + fprintf(stderr, + "\t-i\t\tSpecify the number of inodes for the filesystem\n"); + fprintf(stderr, + "\t-l FILENAME\tRead the bad blocks list from FILENAME\n"); fprintf(stderr, "\t-v\t\tMake a Minix version 2 filesystem\n\n"); exit(16); } @@ -190,56 +201,55 @@ static volatile void show_usage() */ static void check_mount(void) { - FILE * f; - struct mntent * mnt; + FILE *f; + struct mntent *mnt; - if ((f = setmntent (MOUNTED, "r")) == NULL) + if ((f = setmntent(MOUNTED, "r")) == NULL) return; - while ((mnt = getmntent (f)) != NULL) - if (strcmp (device_name, mnt->mnt_fsname) == 0) + while ((mnt = getmntent(f)) != NULL) + if (strcmp(device_name, mnt->mnt_fsname) == 0) break; - endmntent (f); + endmntent(f); if (!mnt) return; die("%s is mounted; will not make a filesystem here!"); } -static long valid_offset (int fd, int offset) +static long valid_offset(int fd, int offset) { char ch; - if (lseek (fd, offset, 0) < 0) + if (lseek(fd, offset, 0) < 0) return 0; - if (read (fd, &ch, 1) < 1) + if (read(fd, &ch, 1) < 1) return 0; return 1; } -static int count_blocks (int fd) +static int count_blocks(int fd) { int high, low; low = 0; - for (high = 1; valid_offset (fd, high); high *= 2) + for (high = 1; valid_offset(fd, high); high *= 2) low = high; - while (low < high - 1) - { + while (low < high - 1) { const int mid = (low + high) / 2; - if (valid_offset (fd, mid)) + if (valid_offset(fd, mid)) low = mid; else high = mid; } - valid_offset (fd, 0); + valid_offset(fd, 0); return (low + 1); } -static int get_size(const char *file) +static int get_size(const char *file) { - int fd; - long size; + int fd; + long size; fd = open(file, O_RDWR); if (fd < 0) { @@ -250,7 +260,7 @@ static int get_size(const char *file) close(fd); return (size * 512); } - + size = count_blocks(fd); close(fd); return size; @@ -270,18 +280,18 @@ static void write_tables(void) die("seek failed in write_tables"); if (BLOCK_SIZE != write(DEV, super_block_buffer, BLOCK_SIZE)) die("unable to write super-block"); - if (IMAPS*BLOCK_SIZE != write(DEV,inode_map,IMAPS*BLOCK_SIZE)) + if (IMAPS * BLOCK_SIZE != write(DEV, inode_map, IMAPS * BLOCK_SIZE)) die("unable to write inode map"); - if (ZMAPS*BLOCK_SIZE != write(DEV,zone_map,ZMAPS*BLOCK_SIZE)) + if (ZMAPS * BLOCK_SIZE != write(DEV, zone_map, ZMAPS * BLOCK_SIZE)) die("unable to write zone map"); - if (INODE_BUFFER_SIZE != write(DEV,inode_buffer,INODE_BUFFER_SIZE)) + if (INODE_BUFFER_SIZE != write(DEV, inode_buffer, INODE_BUFFER_SIZE)) die("unable to write inodes"); - + } -static void write_block(int blk, char * buffer) +static void write_block(int blk, char *buffer) { - if (blk*BLOCK_SIZE != lseek(DEV, blk*BLOCK_SIZE, SEEK_SET)) + if (blk * BLOCK_SIZE != lseek(DEV, blk * BLOCK_SIZE, SEEK_SET)) die("seek failed in write_block"); if (BLOCK_SIZE != write(DEV, buffer, BLOCK_SIZE)) die("write failed in write_block"); @@ -291,10 +301,10 @@ static int get_free_block(void) { int blk; - if (used_good_blocks+1 >= MAX_GOOD_BLOCKS) + if (used_good_blocks + 1 >= MAX_GOOD_BLOCKS) die("too many bad blocks"); if (used_good_blocks) - blk = good_blocks_table[used_good_blocks-1]+1; + blk = good_blocks_table[used_good_blocks - 1] + 1; else blk = FIRSTZONE; while (blk < ZONES && zone_in_use(blk)) @@ -310,14 +320,14 @@ static void mark_good_blocks(void) { int blk; - for (blk=0 ; blk < used_good_blocks ; blk++) + for (blk = 0; blk < used_good_blocks; blk++) mark_zone(good_blocks_table[blk]); } inline int next(int zone) { if (!zone) - zone = FIRSTZONE-1; + zone = FIRSTZONE - 1; while (++zone < ZONES) if (zone_in_use(zone)) return zone; @@ -326,11 +336,11 @@ inline int next(int zone) static void make_bad_inode(void) { - struct minix_inode * inode = &Inode[MINIX_BAD_INO]; - int i,j,zone; - int ind=0,dind=0; - unsigned short ind_block[BLOCK_SIZE>>1]; - unsigned short dind_block[BLOCK_SIZE>>1]; + struct minix_inode *inode = &Inode[MINIX_BAD_INO]; + int i, j, zone; + int ind = 0, dind = 0; + unsigned short ind_block[BLOCK_SIZE >> 1]; + unsigned short dind_block[BLOCK_SIZE >> 1]; #define NEXT_BAD (zone = next(zone)) @@ -340,34 +350,34 @@ static void make_bad_inode(void) inode->i_nlinks = 1; inode->i_time = time(NULL); inode->i_mode = S_IFREG + 0000; - inode->i_size = badblocks*BLOCK_SIZE; + inode->i_size = badblocks * BLOCK_SIZE; zone = next(0); - for (i=0 ; i<7 ; i++) { + for (i = 0; i < 7; i++) { inode->i_zone[i] = zone; if (!NEXT_BAD) goto end_bad; } inode->i_zone[7] = ind = get_free_block(); - memset(ind_block,0,BLOCK_SIZE); - for (i=0 ; i<512 ; i++) { + memset(ind_block, 0, BLOCK_SIZE); + for (i = 0; i < 512; i++) { ind_block[i] = zone; if (!NEXT_BAD) goto end_bad; } inode->i_zone[8] = dind = get_free_block(); - memset(dind_block,0,BLOCK_SIZE); - for (i=0 ; i<512 ; i++) { - write_block(ind,(char *) ind_block); + memset(dind_block, 0, BLOCK_SIZE); + for (i = 0; i < 512; i++) { + write_block(ind, (char *) ind_block); dind_block[i] = ind = get_free_block(); - memset(ind_block,0,BLOCK_SIZE); - for (j=0 ; j<512 ; j++) { + memset(ind_block, 0, BLOCK_SIZE); + for (j = 0; j < 512; j++) { ind_block[j] = zone; if (!NEXT_BAD) goto end_bad; } } die("too many bad blocks"); -end_bad: + end_bad: if (ind) write_block(ind, (char *) ind_block); if (dind) @@ -375,8 +385,7 @@ end_bad: } #ifdef HAVE_MINIX2 -static void -make_bad_inode2 (void) +static void make_bad_inode2(void) { struct minix2_inode *inode = &Inode2[MINIX_BAD_INO]; int i, j, zone; @@ -386,30 +395,30 @@ make_bad_inode2 (void) if (!badblocks) return; - mark_inode (MINIX_BAD_INO); + mark_inode(MINIX_BAD_INO); inode->i_nlinks = 1; - inode->i_atime = inode->i_mtime = inode->i_ctime = time (NULL); + inode->i_atime = inode->i_mtime = inode->i_ctime = time(NULL); inode->i_mode = S_IFREG + 0000; inode->i_size = badblocks * BLOCK_SIZE; - zone = next (0); + zone = next(0); for (i = 0; i < 7; i++) { inode->i_zone[i] = zone; if (!NEXT_BAD) goto end_bad; } - inode->i_zone[7] = ind = get_free_block (); - memset (ind_block, 0, BLOCK_SIZE); + inode->i_zone[7] = ind = get_free_block(); + memset(ind_block, 0, BLOCK_SIZE); for (i = 0; i < 256; i++) { ind_block[i] = zone; if (!NEXT_BAD) goto end_bad; } - inode->i_zone[8] = dind = get_free_block (); - memset (dind_block, 0, BLOCK_SIZE); + inode->i_zone[8] = dind = get_free_block(); + memset(dind_block, 0, BLOCK_SIZE); for (i = 0; i < 256; i++) { - write_block (ind, (char *) ind_block); - dind_block[i] = ind = get_free_block (); - memset (ind_block, 0, BLOCK_SIZE); + write_block(ind, (char *) ind_block); + dind_block[i] = ind = get_free_block(); + memset(ind_block, 0, BLOCK_SIZE); for (j = 0; j < 256; j++) { ind_block[j] = zone; if (!NEXT_BAD) @@ -417,47 +426,46 @@ make_bad_inode2 (void) } } /* Could make triple indirect block here */ - die ("too many bad blocks"); - end_bad: + die("too many bad blocks"); + end_bad: if (ind) - write_block (ind, (char *) ind_block); + write_block(ind, (char *) ind_block); if (dind) - write_block (dind, (char *) dind_block); + write_block(dind, (char *) dind_block); } #endif static void make_root_inode(void) { - struct minix_inode * inode = &Inode[MINIX_ROOT_INO]; + struct minix_inode *inode = &Inode[MINIX_ROOT_INO]; mark_inode(MINIX_ROOT_INO); inode->i_zone[0] = get_free_block(); inode->i_nlinks = 2; inode->i_time = time(NULL); if (badblocks) - inode->i_size = 3*dirsize; + inode->i_size = 3 * dirsize; else { - root_block[2*dirsize] = '\0'; - root_block[2*dirsize+1] = '\0'; - inode->i_size = 2*dirsize; + root_block[2 * dirsize] = '\0'; + root_block[2 * dirsize + 1] = '\0'; + inode->i_size = 2 * 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], root_block); } #ifdef HAVE_MINIX2 -static void -make_root_inode2 (void) +static void make_root_inode2(void) { struct minix2_inode *inode = &Inode2[MINIX_ROOT_INO]; - mark_inode (MINIX_ROOT_INO); - inode->i_zone[0] = get_free_block (); + mark_inode(MINIX_ROOT_INO); + inode->i_zone[0] = get_free_block(); inode->i_nlinks = 2; - inode->i_atime = inode->i_mtime = inode->i_ctime = time (NULL); + inode->i_atime = inode->i_mtime = inode->i_ctime = time(NULL); if (badblocks) inode->i_size = 3 * dirsize; else { @@ -469,7 +477,7 @@ make_root_inode2 (void) 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], root_block); } #endif @@ -478,34 +486,38 @@ static void setup_tables(void) int i; unsigned long inodes; - memset(super_block_buffer,0,BLOCK_SIZE); - memset(boot_block_buffer,0,512); + memset(super_block_buffer, 0, BLOCK_SIZE); + memset(boot_block_buffer, 0, 512); MAGIC = magic; ZONESIZE = 0; - MAXSIZE = version2 ? 0x7fffffff : (7+512+512*512)*1024; + MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024; ZONES = BLOCKS; /* some magic nrs: 1 inode / 3 blocks */ - if ( req_nr_inodes == 0 ) - inodes = BLOCKS/3; + if (req_nr_inodes == 0) + inodes = BLOCKS / 3; else inodes = req_nr_inodes; /* Round up inode count to fill block size */ #ifdef HAVE_MINIX2 if (version2) inodes = ((inodes + MINIX2_INODES_PER_BLOCK - 1) & - ~(MINIX2_INODES_PER_BLOCK - 1)); + ~(MINIX2_INODES_PER_BLOCK - 1)); else #endif inodes = ((inodes + MINIX_INODES_PER_BLOCK - 1) & - ~(MINIX_INODES_PER_BLOCK - 1)); + ~(MINIX_INODES_PER_BLOCK - 1)); if (inodes > 65535) inodes = 65535; INODES = inodes; - IMAPS = UPPER(INODES + 1,BITS_PER_BLOCK); + IMAPS = UPPER(INODES + 1, BITS_PER_BLOCK); ZMAPS = 0; - i=0; - while (ZMAPS != UPPER(BLOCKS - (2+IMAPS+ZMAPS+INODE_BLOCKS) + 1,BITS_PER_BLOCK) && i<1000) { - ZMAPS = UPPER(BLOCKS - (2+IMAPS+ZMAPS+INODE_BLOCKS) + 1,BITS_PER_BLOCK); + i = 0; + while (ZMAPS != + UPPER(BLOCKS - (2 + IMAPS + ZMAPS + INODE_BLOCKS) + 1, + BITS_PER_BLOCK) && i < 1000) { + ZMAPS = + UPPER(BLOCKS - (2 + IMAPS + ZMAPS + INODE_BLOCKS) + 1, + BITS_PER_BLOCK); i++; } /* Real bad hack but overwise mkfs.minix can be thrown @@ -514,50 +526,51 @@ static void setup_tables(void) * dd if=/dev/zero of=test.fs count=10 bs=1024 * /sbin/mkfs.minix -i 200 test.fs * */ - if (i>=999) { - die ("unable to allocate buffers for maps"); + if (i >= 999) { + die("unable to allocate buffers for maps"); } FIRSTZONE = NORM_FIRSTZONE; inode_map = malloc(IMAPS * BLOCK_SIZE); zone_map = malloc(ZMAPS * BLOCK_SIZE); if (!inode_map || !zone_map) die("unable to allocate buffers for maps"); - memset(inode_map,0xff,IMAPS * BLOCK_SIZE); - memset(zone_map,0xff,ZMAPS * BLOCK_SIZE); - for (i = FIRSTZONE ; i= ZONES) return; - signal(SIGALRM,alarm_intr); + signal(SIGALRM, alarm_intr); alarm(5); if (!currently_testing) return; @@ -580,19 +593,19 @@ static void alarm_intr(int alnum) static void check_blocks(void) { - int try,got; + int try, got; static char buffer[BLOCK_SIZE * TEST_BUFFER_BLOCKS]; - currently_testing=0; - signal(SIGALRM,alarm_intr); + currently_testing = 0; + signal(SIGALRM, alarm_intr); alarm(5); while (currently_testing < ZONES) { - if (lseek(DEV,currently_testing*BLOCK_SIZE,SEEK_SET) != - currently_testing*BLOCK_SIZE) + if (lseek(DEV, currently_testing * BLOCK_SIZE, SEEK_SET) != + currently_testing * BLOCK_SIZE) die("seek failed in check_blocks"); try = TEST_BUFFER_BLOCKS; if (currently_testing + try > ZONES) - try = ZONES-currently_testing; + try = ZONES - currently_testing; got = do_check(buffer, try, currently_testing); currently_testing += got; if (got == try) @@ -613,139 +626,141 @@ static void get_list_blocks(filename) char *filename; { - FILE *listfile; - unsigned long blockno; - - listfile=fopen(filename,"r"); - if(listfile == (FILE *)NULL) { - die("can't open file of bad blocks"); - } - while(!feof(listfile)) { - fscanf(listfile,"%ld\n", &blockno); - mark_zone(blockno); - badblocks++; - } - if(badblocks > 1) - printf("%d bad blocks\n", badblocks); - else if (badblocks == 1) - printf("one bad block\n"); + FILE *listfile; + unsigned long blockno; + + listfile = fopen(filename, "r"); + if (listfile == (FILE *) NULL) { + die("can't open file of bad blocks"); + } + while (!feof(listfile)) { + fscanf(listfile, "%ld\n", &blockno); + mark_zone(blockno); + badblocks++; + } + if (badblocks > 1) + printf("%d bad blocks\n", badblocks); + else if (badblocks == 1) + printf("one bad block\n"); } -extern int -mkfs_minix_main(int argc, char ** argv) +extern int mkfs_minix_main(int argc, char **argv) { - int i; - char * tmp; - struct stat statbuf; - char * listfile = NULL; - - if (argc && *argv) - program_name = *argv; - if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE) - die("bad inode size"); + int i; + char *tmp; + struct stat statbuf; + char *listfile = NULL; + + if (argc && *argv) + program_name = *argv; + if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE) + die("bad inode size"); #ifdef HAVE_MINIX2 - if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE) - die("bad inode size"); + if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE) + die("bad inode size"); #endif - opterr = 0; - while ((i = getopt(argc, argv, "ci:l:n:v")) != EOF) - switch (i) { - case 'c': - check=1; break; - case 'i': - req_nr_inodes = (unsigned long) atol(optarg); - break; - case 'l': - listfile = optarg; break; - case 'n': - i = strtoul(optarg,&tmp,0); - if (*tmp) - show_usage(); - if (i == 14) - magic = MINIX_SUPER_MAGIC; - else if (i == 30) - magic = MINIX_SUPER_MAGIC2; - else - show_usage(); - namelen = i; - dirsize = i+2; - break; - case 'v': + opterr = 0; + while ((i = getopt(argc, argv, "ci:l:n:v")) != EOF) + switch (i) { + case 'c': + check = 1; + break; + case 'i': + req_nr_inodes = (unsigned long) atol(optarg); + break; + case 'l': + listfile = optarg; + break; + case 'n': + i = strtoul(optarg, &tmp, 0); + if (*tmp) + show_usage(); + if (i == 14) + magic = MINIX_SUPER_MAGIC; + else if (i == 30) + magic = MINIX_SUPER_MAGIC2; + else + show_usage(); + namelen = i; + dirsize = i + 2; + break; + case 'v': #ifdef HAVE_MINIX2 - version2 = 1; + version2 = 1; #else - fprintf(stderr,"%s: not compiled with minix v2 support\n",program_name,device_name); - exit(-1); + fprintf(stderr, "%s: not compiled with minix v2 support\n", + program_name, device_name); + exit(-1); #endif - break; - default: - show_usage(); - } - argc -= optind; - argv += optind; - if (argc > 0 && !device_name) { - device_name = argv[0]; - argc--; - argv++; - } - if (argc > 0) { - BLOCKS = strtol(argv[0],&tmp,0); - if (*tmp) { - printf("strtol error: number of blocks not specified"); - show_usage(); - } - } - - if (device_name && !BLOCKS) - BLOCKS = get_size (device_name) / 1024; - if (!device_name || BLOCKS<10) { - show_usage(); - } + break; + default: + show_usage(); + } + argc -= optind; + argv += optind; + if (argc > 0 && !device_name) { + device_name = argv[0]; + argc--; + argv++; + } + if (argc > 0) { + BLOCKS = strtol(argv[0], &tmp, 0); + if (*tmp) { + printf("strtol error: number of blocks not specified"); + show_usage(); + } + } + + if (device_name && !BLOCKS) + BLOCKS = get_size(device_name) / 1024; + if (!device_name || BLOCKS < 10) { + show_usage(); + } #ifdef HAVE_MINIX2 - if (version2) { - if (namelen == 14) - magic = MINIX2_SUPER_MAGIC; - else - magic = MINIX2_SUPER_MAGIC2; - } else + if (version2) { + if (namelen == 14) + magic = MINIX2_SUPER_MAGIC; + else + magic = MINIX2_SUPER_MAGIC2; + } else #endif - if (BLOCKS > 65535) - BLOCKS = 65535; - check_mount(); /* is it already mounted? */ - tmp = root_block; - *(short *)tmp = 1; - strcpy(tmp+2,"."); - tmp += dirsize; - *(short *)tmp = 1; - strcpy(tmp+2,".."); - tmp += dirsize; - *(short *)tmp = 2; - strcpy(tmp+2,".badblocks"); - DEV = open(device_name,O_RDWR ); - if (DEV<0) - die("unable to open %s"); - if (fstat(DEV,&statbuf)<0) - die("unable to stat %s"); - if (!S_ISBLK(statbuf.st_mode)) - check=0; - else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) - die("will not try to make filesystem on '%s'"); - setup_tables(); - if (check) - check_blocks(); - else if (listfile) - get_list_blocks(listfile); + if (BLOCKS > 65535) + BLOCKS = 65535; + check_mount(); /* is it already mounted? */ + tmp = root_block; + *(short *) tmp = 1; + strcpy(tmp + 2, "."); + tmp += dirsize; + *(short *) tmp = 1; + strcpy(tmp + 2, ".."); + tmp += dirsize; + *(short *) tmp = 2; + strcpy(tmp + 2, ".badblocks"); + DEV = open(device_name, O_RDWR); + if (DEV < 0) + die("unable to open %s"); + if (fstat(DEV, &statbuf) < 0) + die("unable to stat %s"); + if (!S_ISBLK(statbuf.st_mode)) + check = 0; + else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) + die("will not try to make filesystem on '%s'"); + setup_tables(); + if (check) + check_blocks(); + else if (listfile) + get_list_blocks(listfile); #ifdef HAVE_MINIX2 - if (version2) { - make_root_inode2 (); - make_bad_inode2 (); - } else + if (version2) { + make_root_inode2(); + make_bad_inode2(); + } else #endif - { - make_root_inode(); - make_bad_inode(); - } - mark_good_blocks(); - write_tables(); - return 0; + { + make_root_inode(); + make_bad_inode(); + } + mark_good_blocks(); + write_tables(); + return 0; } diff --git a/util-linux/mkswap.c b/util-linux/mkswap.c index 601188f86..130d24162 100644 --- a/util-linux/mkswap.c +++ b/util-linux/mkswap.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * mkswap.c - set up a linux swap device * @@ -40,20 +41,21 @@ #include #include #include -#include /* for _IO */ +#include /* for _IO */ #include #include -#include /* for PAGE_SIZE and PAGE_SHIFT */ +#include /* for PAGE_SIZE and PAGE_SHIFT */ /* we also get PAGE_SIZE via getpagesize() */ -static const char mkswap_usage[] = "mkswap [-c] [-v0|-v1] device [block-count]\n\n" -"Prepare a disk partition to be used as a swap partition.\n\n" -"Options:\n" -"\t-c\t\tCheck for read-ability.\n" -"\t-v0\t\tMake version 0 swap [max 128 Megs].\n" -"\t-v1\t\tMake version 1 swap [big!] (default for kernels > 2.1.117).\n" -"\tblock-count\tNumber of block to use (default is entire partition).\n"; +static const char mkswap_usage[] = + "mkswap [-c] [-v0|-v1] device [block-count]\n\n" + "Prepare a disk partition to be used as a swap partition.\n\n" + "Options:\n" "\t-c\t\tCheck for read-ability.\n" + "\t-v0\t\tMake version 0 swap [max 128 Megs].\n" + "\t-v1\t\tMake version 1 swap [big!] (default for kernels > 2.1.117).\n" + + "\tblock-count\tNumber of block to use (default is entire partition).\n"; #ifndef _IO @@ -64,8 +66,8 @@ static const char mkswap_usage[] = "mkswap [-c] [-v0|-v1] device [block-count]\n #define BLKGETSIZE _IO(0x12,96) #endif -static char * program_name = "mkswap"; -static char * device_name = NULL; +static char *program_name = "mkswap"; +static char *device_name = NULL; static int DEV = -1; static long PAGES = 0; static int check = 0; @@ -74,8 +76,8 @@ static int version = -1; #define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r)) -static int -linux_version_code(void) { +static int linux_version_code(void) +{ struct utsname my_utsname; int p, q, r; @@ -83,7 +85,7 @@ linux_version_code(void) { p = atoi(strtok(my_utsname.release, ".")); q = atoi(strtok(NULL, ".")); r = atoi(strtok(NULL, ".")); - return MAKE_VERSION(p,q,r); + return MAKE_VERSION(p, q, r); } return 0; } @@ -98,7 +100,7 @@ static int pagesize; static int *signature_page; struct swap_header_v1 { - char bootbits[1024]; /* Space for disklabel etc. */ + char bootbits[1024]; /* Space for disklabel etc. */ unsigned int version; unsigned int last_page; unsigned int nr_badpages; @@ -106,8 +108,8 @@ struct swap_header_v1 { unsigned int badpages[1]; } *p; -static void -init_signature_page() { +static void init_signature_page() +{ pagesize = getpagesize(); #ifdef PAGE_SIZE @@ -115,15 +117,15 @@ init_signature_page() { fprintf(stderr, "Assuming pages of size %d\n", pagesize); #endif signature_page = (int *) malloc(pagesize); - memset(signature_page,0,pagesize); + memset(signature_page, 0, pagesize); p = (struct swap_header_v1 *) signature_page; } -static void -write_signature(char *sig) { +static void write_signature(char *sig) +{ char *sp = (char *) signature_page; - strncpy(sp+pagesize-10, sig, 10); + strncpy(sp + pagesize - 10, sig, 10); } #define V0_MAX_PAGES (8 * (pagesize - 10)) @@ -172,42 +174,46 @@ It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips, #define MAX_BADPAGES ((pagesize-1024-128*sizeof(int)-10)/sizeof(int)) -static void bit_set (unsigned int *addr, unsigned int nr) +static void bit_set(unsigned int *addr, unsigned int nr) { unsigned int r, m; addr += nr / (8 * sizeof(int)); + r = *addr; m = 1 << (nr & (8 * sizeof(int) - 1)); + *addr = r | m; } -static int bit_test_and_clear (unsigned int *addr, unsigned int nr) +static int bit_test_and_clear(unsigned int *addr, unsigned int nr) { unsigned int r, m; addr += nr / (8 * sizeof(int)); + r = *addr; m = 1 << (nr & (8 * sizeof(int) - 1)); + *addr = r & ~m; return (r & m) != 0; } -void -die(const char *str) { +void die(const char *str) +{ fprintf(stderr, "%s: %s\n", program_name, str); - exit( FALSE); + exit(FALSE); } -void -page_ok(int page) { - if (version==0) +void page_ok(int page) +{ + if (version == 0) bit_set(signature_page, page); } -void -page_bad(int page) { +void page_bad(int page) +{ if (version == 0) bit_test_and_clear(signature_page, page); else { @@ -218,8 +224,8 @@ page_bad(int page) { badpages++; } -void -check_blocks(void) { +void check_blocks(void) +{ unsigned int current_page; int do_seek = 1; char *buffer; @@ -233,8 +239,8 @@ check_blocks(void) { page_ok(current_page++); continue; } - if (do_seek && lseek(DEV,current_page*pagesize,SEEK_SET) != - current_page*pagesize) + if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) != + current_page * pagesize) die("seek failed in check_blocks"); if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) { page_bad(current_page++); @@ -248,30 +254,28 @@ check_blocks(void) { printf("%d bad pages\n", badpages); } -static long valid_offset (int fd, int offset) +static long valid_offset(int fd, int offset) { char ch; - if (lseek (fd, offset, 0) < 0) + if (lseek(fd, offset, 0) < 0) return 0; - if (read (fd, &ch, 1) < 1) + if (read(fd, &ch, 1) < 1) return 0; return 1; } -static int -find_size (int fd) +static int find_size(int fd) { unsigned int high, low; low = 0; - for (high = 1; high > 0 && valid_offset (fd, high); high *= 2) + for (high = 1; high > 0 && valid_offset(fd, high); high *= 2) low = high; - while (low < high - 1) - { + while (low < high - 1) { const int mid = (low + high) / 2; - if (valid_offset (fd, mid)) + if (valid_offset(fd, mid)) low = mid; else high = mid; @@ -280,11 +284,10 @@ find_size (int fd) } /* return size in pages, to avoid integer overflow */ -static long -get_size(const char *file) +static long get_size(const char *file) { - int fd; - long size; + int fd; + long size; fd = open(file, O_RDONLY); if (fd < 0) { @@ -292,7 +295,8 @@ get_size(const char *file) exit(1); } if (ioctl(fd, BLKGETSIZE, &size) >= 0) { - int sectors_per_page = pagesize/512; + int sectors_per_page = pagesize / 512; + size /= sectors_per_page; } else { size = find_size(fd) / pagesize; @@ -301,9 +305,9 @@ get_size(const char *file) return size; } -int mkswap_main(int argc, char ** argv) +int mkswap_main(int argc, char **argv) { - char * tmp; + char *tmp; struct stat statbuf; int sz; int maxpages; @@ -314,56 +318,56 @@ int mkswap_main(int argc, char ** argv) if (argc && *argv) program_name = *argv; - init_signature_page(); /* get pagesize */ + init_signature_page(); /* get pagesize */ while (argc-- > 1) { argv++; if (argv[0][0] != '-') { if (device_name) { - int blocks_per_page = pagesize/1024; - PAGES = strtol(argv[0],&tmp,0)/blocks_per_page; + int blocks_per_page = pagesize / 1024; + + PAGES = strtol(argv[0], &tmp, 0) / blocks_per_page; if (*tmp) - usage( mkswap_usage); + usage(mkswap_usage); } else device_name = argv[0]; } else { switch (argv[0][1]) { - case 'c': - check=1; - break; - case 'f': - force=1; - break; - case 'v': - version=atoi(argv[0]+2); - break; - default: - usage( mkswap_usage); + case 'c': + check = 1; + break; + case 'f': + force = 1; + break; + case 'v': + version = atoi(argv[0] + 2); + break; + default: + usage(mkswap_usage); } } } if (!device_name) { fprintf(stderr, - "%s: error: Nowhere to set up swap on?\n", - program_name); - usage( mkswap_usage); + "%s: error: Nowhere to set up swap on?\n", program_name); + usage(mkswap_usage); } sz = get_size(device_name); if (!PAGES) { PAGES = sz; } else if (PAGES > sz && !force) { fprintf(stderr, - "%s: error: " - "size %ld is larger than device size %d\n", - program_name, - PAGES*(pagesize/1024), sz*(pagesize/1024)); - exit( FALSE); + "%s: error: " + "size %ld is larger than device size %d\n", + program_name, + PAGES * (pagesize / 1024), sz * (pagesize / 1024)); + exit(FALSE); } if (version == -1) { if (PAGES <= V0_MAX_PAGES) version = 0; - else if (linux_version_code() < MAKE_VERSION(2,1,117)) + else if (linux_version_code() < MAKE_VERSION(2, 1, 117)) version = 0; else if (pagesize < 2048) version = 0; @@ -372,21 +376,21 @@ int mkswap_main(int argc, char ** argv) } if (version != 0 && version != 1) { fprintf(stderr, "%s: error: unknown version %d\n", - program_name, version); - usage( mkswap_usage); + program_name, version); + usage(mkswap_usage); } if (PAGES < 10) { fprintf(stderr, - "%s: error: swap area needs to be at least %ldkB\n", - program_name, (long)(10 * pagesize / 1024)); - usage( mkswap_usage); + "%s: error: swap area needs to be at least %ldkB\n", + program_name, (long) (10 * pagesize / 1024)); + usage(mkswap_usage); } #if 0 maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES); #else if (!version) maxpages = V0_MAX_PAGES; - else if (linux_version_code() >= MAKE_VERSION(2,2,1)) + else if (linux_version_code() >= MAKE_VERSION(2, 2, 1)) maxpages = V1_MAX_PAGES; else { maxpages = V1_OLD_MAX_PAGES; @@ -397,29 +401,29 @@ int mkswap_main(int argc, char ** argv) if (PAGES > maxpages) { PAGES = maxpages; fprintf(stderr, "%s: warning: truncating swap area to %ldkB\n", - program_name, PAGES * pagesize / 1024); + program_name, PAGES * pagesize / 1024); } - DEV = open(device_name,O_RDWR); + DEV = open(device_name, O_RDWR); if (DEV < 0 || fstat(DEV, &statbuf) < 0) { perror(device_name); - exit( FALSE); + exit(FALSE); } if (!S_ISBLK(statbuf.st_mode)) - check=0; + check = 0; else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) die("Will not try to make swapdevice on '%s'"); #ifdef __sparc__ if (!force && version == 0) { /* Don't overwrite partition table unless forced */ - unsigned char *buffer = (unsigned char *)signature_page; + unsigned char *buffer = (unsigned char *) signature_page; unsigned short *q, sum; if (read(DEV, buffer, 512) != 512) die("fatal: first page unreadable"); if (buffer[508] == 0xDA && buffer[509] == 0xBE) { - q = (unsigned short *)(buffer + 510); + q = (unsigned short *) (buffer + 510); for (sum = 0; q >= (unsigned short *) buffer;) sum ^= *q--; if (!sum) { @@ -427,9 +431,8 @@ int mkswap_main(int argc, char ** argv) %s: Device '%s' contains a valid Sun disklabel.\n\ This probably means creating v0 swap would destroy your partition table\n\ No swap created. If you really want to create swap v0 on that device, use\n\ -the -f option to force it.\n", - program_name, device_name); - exit( FALSE); +the -f option to force it.\n", program_name, device_name); + exit(FALSE); } } } @@ -437,11 +440,11 @@ the -f option to force it.\n", if (version == 0 || check) check_blocks(); - if (version == 0 && !bit_test_and_clear(signature_page,0)) + if (version == 0 && !bit_test_and_clear(signature_page, 0)) die("fatal: first page unreadable"); if (version == 1) { p->version = version; - p->last_page = PAGES-1; + p->last_page = PAGES - 1; p->nr_badpages = badpages; } @@ -449,14 +452,14 @@ the -f option to force it.\n", if (goodpages <= 0) die("Unable to set up swap-space: unreadable"); printf("Setting up swapspace version %d, size = %ld bytes\n", - version, (long)(goodpages*pagesize)); + version, (long) (goodpages * pagesize)); write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2"); offset = ((version == 0) ? 0 : 1024); if (lseek(DEV, offset, SEEK_SET) != offset) die("unable to rewind swap-device"); - if (write(DEV,(char*)signature_page+offset, pagesize-offset) - != pagesize-offset) + if (write(DEV, (char *) signature_page + offset, pagesize - offset) + != pagesize - offset) die("unable to write signature page"); /* @@ -464,6 +467,6 @@ the -f option to force it.\n", * is not actually on disk. (This is a kernel bug.) */ if (fsync(DEV)) - die("fsync failed"); - exit ( TRUE); + die("fsync failed"); + exit(TRUE); } diff --git a/util-linux/more.c b/util-linux/more.c index 821427dda..d5711aa2f 100644 --- a/util-linux/more.c +++ b/util-linux/more.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini more implementation for busybox * @@ -45,19 +46,20 @@ static const char more_usage[] = "more [file ...]\n"; # define stty(fd,argp) tcsetattr(fd,TCSANOW,argp) #endif - FILE *cin; - struct termios initial_settings, new_settings; +FILE *cin; +struct termios initial_settings, new_settings; - void gotsig(int sig) { - stty(fileno(cin), &initial_settings); - fprintf(stdout, "\n"); - exit( TRUE); - } +void gotsig(int sig) +{ + stty(fileno(cin), &initial_settings); + fprintf(stdout, "\n"); + exit(TRUE); +} #endif -#define TERMINAL_WIDTH 79 /* not 80 in case terminal has linefold bug */ +#define TERMINAL_WIDTH 79 /* not 80 in case terminal has linefold bug */ #define TERMINAL_HEIGHT 24 @@ -72,118 +74,121 @@ static int terminal_width = 0, terminal_height = 0; extern int more_main(int argc, char **argv) { - int c, lines=0, input=0; - int next_page=0; - struct stat st; - FILE *file; + int c, lines = 0, input = 0; + int next_page = 0; + struct stat st; + FILE *file; + #ifdef BB_FEATURE_AUTOWIDTH - struct winsize win = {0,0}; + struct winsize win = { 0, 0 }; #endif - argc--; - argv++; - - if ( argc > 0 && (strcmp(*argv,"--help")==0 || strcmp(*argv,"-h")==0) ) { - usage (more_usage); - } - do { - if (argc==0) { - file = stdin; - } - else - file = fopen(*argv, "r"); + argc--; + argv++; - if (file == NULL) { - perror(*argv); - exit(FALSE); + if (argc > 0 + && (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0)) { + usage(more_usage); } - fstat(fileno(file), &st); + do { + if (argc == 0) { + file = stdin; + } else + file = fopen(*argv, "r"); + + if (file == NULL) { + perror(*argv); + exit(FALSE); + } + fstat(fileno(file), &st); #ifdef BB_FEATURE_USE_TERMIOS - cin = fopen("/dev/tty", "r"); - if (!cin) - cin = fopen("/dev/console", "r"); + cin = fopen("/dev/tty", "r"); + if (!cin) + cin = fopen("/dev/console", "r"); #ifdef USE_OLD_TERMIO - ioctl(fileno(cin),TCGETA,&initial_settings); + ioctl(fileno(cin), TCGETA, &initial_settings); #else - tcgetattr(fileno(cin),&initial_settings); + tcgetattr(fileno(cin), &initial_settings); #endif - new_settings = initial_settings; - new_settings.c_lflag &= ~ICANON; - new_settings.c_lflag &= ~ECHO; - stty(fileno(cin), &new_settings); - -#ifdef BB_FEATURE_AUTOWIDTH - ioctl(fileno(stdout), TIOCGWINSZ, &win); - if (win.ws_row > 4) - terminal_height = win.ws_row - 2; - if (win.ws_col > 0) - terminal_width = win.ws_col - 1; + new_settings = initial_settings; + new_settings.c_lflag &= ~ICANON; + new_settings.c_lflag &= ~ECHO; + stty(fileno(cin), &new_settings); + +#ifdef BB_FEATURE_AUTOWIDTH + ioctl(fileno(stdout), TIOCGWINSZ, &win); + if (win.ws_row > 4) + terminal_height = win.ws_row - 2; + if (win.ws_col > 0) + terminal_width = win.ws_col - 1; #endif - (void) signal(SIGINT, gotsig); - (void) signal(SIGQUIT, gotsig); - (void) signal(SIGTERM, gotsig); + (void) signal(SIGINT, gotsig); + (void) signal(SIGQUIT, gotsig); + (void) signal(SIGTERM, gotsig); #endif - while ((c = getc(file)) != EOF) { - if ( next_page ) { - int len=0; - next_page = 0; - lines=0; - len = fprintf(stdout, "--More-- "); - if (file != stdin) { - len += fprintf(stdout, "(%d%% of %ld bytes)", - (int) (100*( (double) ftell(file) / (double) st.st_size )), - st.st_size); - } - len += fprintf(stdout, "%s", + while ((c = getc(file)) != EOF) { + if (next_page) { + int len = 0; + + next_page = 0; + lines = 0; + len = fprintf(stdout, "--More-- "); + if (file != stdin) { + len += fprintf(stdout, "(%d%% of %ld bytes)", + (int) (100 * + ((double) ftell(file) / + (double) st.st_size)), + st.st_size); + } + len += fprintf(stdout, "%s", #ifdef BB_FEATURE_USE_TERMIOS - "" + "" #else - "\n" + "\n" #endif - ); + ); - fflush(stdout); - input = getc( cin); + fflush(stdout); + input = getc(cin); #ifdef BB_FEATURE_USE_TERMIOS - /* Erase the "More" message */ - while(--len >= 0) - putc('\b', stdout); - while(++len <= terminal_width) - putc(' ', stdout); - while(--len >= 0) - putc('\b', stdout); - fflush(stdout); + /* Erase the "More" message */ + while (--len >= 0) + putc('\b', stdout); + while (++len <= terminal_width) + putc(' ', stdout); + while (--len >= 0) + putc('\b', stdout); + fflush(stdout); #endif - } - if (c == '\n' ) { - switch(input) { - case 'q': - goto end; - case '\n': - /* increment by just one line if we are at - * the end of this line*/ - next_page = 1; - break; + } + if (c == '\n') { + switch (input) { + case 'q': + goto end; + case '\n': + /* increment by just one line if we are at + * the end of this line*/ + next_page = 1; + break; + } + if (++lines == terminal_height) + next_page = 1; + } + putc(c, stdout); } - if ( ++lines == terminal_height ) - next_page = 1; - } - putc(c, stdout); - } - fclose(file); - fflush(stdout); + fclose(file); + fflush(stdout); - argv++; - } while (--argc > 0); -end: + argv++; + } while (--argc > 0); + end: #ifdef BB_FEATURE_USE_TERMIOS - gotsig(0); -#endif - exit(TRUE); + gotsig(0); +#endif + exit(TRUE); } - diff --git a/util-linux/mount.c b/util-linux/mount.c index 4c9e77be0..c3e3bbd75 100644 --- a/util-linux/mount.c +++ b/util-linux/mount.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini mount implementation for busybox * @@ -55,357 +56,371 @@ static int use_loop = 0; #endif -extern const char mtab_file[]; /* Defined in utility.c */ +extern const char mtab_file[]; /* Defined in utility.c */ static const char mount_usage[] = "\tmount [flags]\n" - "\tmount [flags] device directory [-o options,more-options]\n" - "\n" - "Flags:\n" - "\t-a:\tMount all file systems in fstab.\n" + "\tmount [flags] device directory [-o options,more-options]\n" + "\n" "Flags:\n" "\t-a:\tMount all file systems in fstab.\n" #ifdef BB_MTAB - "\t-f:\t\"Fake\" mount. Add entry to mount table but don't mount it.\n" - "\t-n:\tDon't write a mount table entry.\n" + "\t-f:\t\"Fake\" mount. Add entry to mount table but don't mount it.\n" + "\t-n:\tDon't write a mount table entry.\n" #endif - "\t-o option:\tOne of many filesystem options, listed below.\n" - "\t-r:\tMount the filesystem read-only.\n" - "\t-t filesystem-type:\tSpecify the filesystem type.\n" - "\t-w:\tMount for reading and writing (default).\n" - "\n" - "Options for use with the \"-o\" flag:\n" - "\tasync / sync:\tWrites are asynchronous / synchronous.\n" - "\tdev / nodev:\tAllow use of special device files / disallow them.\n" - "\texec / noexec:\tAllow use of executable files / disallow them.\n" + "\t-o option:\tOne of many filesystem options, listed below.\n" + "\t-r:\tMount the filesystem read-only.\n" + "\t-t filesystem-type:\tSpecify the filesystem type.\n" + "\t-w:\tMount for reading and writing (default).\n" + "\n" + "Options for use with the \"-o\" flag:\n" + "\tasync / sync:\tWrites are asynchronous / synchronous.\n" + "\tdev / nodev:\tAllow use of special device files / disallow them.\n" + "\texec / noexec:\tAllow use of executable files / disallow them.\n" #if defined BB_FEATURE_MOUNT_LOOP - "\tloop: Mounts a file via loop device.\n" + "\tloop: Mounts a file via loop device.\n" #endif - "\tsuid / nosuid:\tAllow set-user-id-root programs / disallow them.\n" - "\tremount: Re-mount a currently-mounted filesystem, changing its flags.\n" - "\tro / rw: Mount for read-only / read-write.\n" - "\t" - "There are EVEN MORE flags that are specific to each filesystem.\n" - "You'll have to see the written documentation for those.\n"; + "\tsuid / nosuid:\tAllow set-user-id-root programs / disallow them.\n" + "\tremount: Re-mount a currently-mounted filesystem, changing its flags.\n" + "\tro / rw: Mount for read-only / read-write.\n" + "\t" + + "There are EVEN MORE flags that are specific to each filesystem.\n" + "You'll have to see the written documentation for those.\n"; struct mount_options { - const char *name; - unsigned long and; - unsigned long or; + const char *name; + unsigned long and; + unsigned long or; }; static const struct mount_options mount_options[] = { - {"async", ~MS_SYNCHRONOUS, 0}, - {"defaults", ~0, 0}, - {"dev", ~MS_NODEV, 0}, - {"exec", ~MS_NOEXEC, 0}, - {"nodev", ~0, MS_NODEV}, - {"noexec", ~0, MS_NOEXEC}, - {"nosuid", ~0, MS_NOSUID}, - {"remount", ~0, MS_REMOUNT}, - {"ro", ~0, MS_RDONLY}, - {"rw", ~MS_RDONLY, 0}, - {"suid", ~MS_NOSUID, 0}, - {"sync", ~0, MS_SYNCHRONOUS}, - {0, 0, 0} + {"async", ~MS_SYNCHRONOUS, 0}, + {"defaults", ~0, 0}, + {"dev", ~MS_NODEV, 0}, + {"exec", ~MS_NOEXEC, 0}, + {"nodev", ~0, MS_NODEV}, + {"noexec", ~0, MS_NOEXEC}, + {"nosuid", ~0, MS_NOSUID}, + {"remount", ~0, MS_REMOUNT}, + {"ro", ~0, MS_RDONLY}, + {"rw", ~MS_RDONLY, 0}, + {"suid", ~MS_NOSUID, 0}, + {"sync", ~0, MS_SYNCHRONOUS}, + {0, 0, 0} }; static int -do_mount(char* specialfile, char* dir, char* filesystemtype, - long flags, void* string_flags, int useMtab, int fakeIt, char* mtab_opts) +do_mount(char *specialfile, char *dir, char *filesystemtype, + long flags, void *string_flags, int useMtab, int fakeIt, + char *mtab_opts) { - int status=0; + int status = 0; #if defined BB_MTAB - if (fakeIt==FALSE) + if (fakeIt == FALSE) #endif - { + { #if defined BB_FEATURE_MOUNT_LOOP - if (use_loop) { - int loro = flags & MS_RDONLY; - char *lofile = specialfile; - specialfile = find_unused_loop_device(); - if (specialfile == NULL) { - fprintf(stderr, "Could not find a spare loop device\n"); - return( FALSE); - } - if (set_loop (specialfile, lofile, 0, &loro)) { - fprintf(stderr, "Could not setup loop device\n"); - return( FALSE); - } - if (!(flags & MS_RDONLY) && loro) { /* loop is ro, but wanted rw */ - fprintf(stderr, "WARNING: loop device is read-only\n"); - flags &= ~MS_RDONLY; - } - } + if (use_loop) { + int loro = flags & MS_RDONLY; + char *lofile = specialfile; + + specialfile = find_unused_loop_device(); + if (specialfile == NULL) { + fprintf(stderr, "Could not find a spare loop device\n"); + return (FALSE); + } + if (set_loop(specialfile, lofile, 0, &loro)) { + fprintf(stderr, "Could not setup loop device\n"); + return (FALSE); + } + if (!(flags & MS_RDONLY) && loro) { /* loop is ro, but wanted rw */ + fprintf(stderr, "WARNING: loop device is read-only\n"); + flags &= ~MS_RDONLY; + } + } #endif - status=mount(specialfile, dir, filesystemtype, flags, string_flags); - } + status = + mount(specialfile, dir, filesystemtype, flags, string_flags); + } - /* If the mount was sucessful, do anything needed, then return TRUE */ - if (status == 0) { + /* If the mount was sucessful, do anything needed, then return TRUE */ + if (status == 0) { #if defined BB_MTAB - if (useMtab==TRUE) { - write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts); - } + if (useMtab == TRUE) { + write_mtab(specialfile, dir, filesystemtype, flags, mtab_opts); + } #endif - return( TRUE); - } + return (TRUE); + } - /* Bummer. mount failed. Clean up */ + /* Bummer. mount failed. Clean up */ #if defined BB_FEATURE_MOUNT_LOOP - if (specialfile != NULL) { - del_loop(specialfile); - } + if (specialfile != NULL) { + del_loop(specialfile); + } #endif - return( FALSE); + return (FALSE); } #if defined BB_MTAB -#define whine_if_fstab_is_missing() {} +#define whine_if_fstab_is_missing() {} #else extern void whine_if_fstab_is_missing() { - struct stat statBuf; - if (stat("/etc/fstab", &statBuf) < 0) - fprintf(stderr, "/etc/fstab file missing -- install one to name /dev/root.\n\n"); + struct stat statBuf; + + if (stat("/etc/fstab", &statBuf) < 0) + fprintf(stderr, + "/etc/fstab file missing -- install one to name /dev/root.\n\n"); } #endif /* Seperate standard mount options from the nonstandard string options */ static void -parse_mount_options ( char *options, unsigned long *flags, char *strflags) +parse_mount_options(char *options, unsigned long *flags, char *strflags) { - while (options) { - int gotone=FALSE; - char *comma = strchr (options, ','); - const struct mount_options* f = mount_options; - if (comma) - *comma = '\0'; - - while (f->name != 0) { - if (strcasecmp (f->name, options) == 0) { - - *flags &= f->and; - *flags |= f->or; - gotone=TRUE; - break; - } - f++; - } + while (options) { + int gotone = FALSE; + char *comma = strchr(options, ','); + const struct mount_options *f = mount_options; + + if (comma) + *comma = '\0'; + + while (f->name != 0) { + if (strcasecmp(f->name, options) == 0) { + + *flags &= f->and; + *flags |= f->or; + gotone = TRUE; + break; + } + f++; + } #if defined BB_FEATURE_MOUNT_LOOP - if (gotone==FALSE && !strcasecmp ("loop", options)) { /* loop device support */ - use_loop = 1; - gotone=TRUE; - } + if (gotone == FALSE && !strcasecmp("loop", options)) { /* loop device support */ + use_loop = 1; + gotone = TRUE; + } #endif - if (*strflags && strflags!= '\0' && gotone==FALSE) { - char *temp=strflags; - temp += strlen (strflags); - *temp++ = ','; - *temp++ = '\0'; - } - if (gotone==FALSE) - strcat (strflags, options); - if (comma) { - *comma = ','; - options = ++comma; - } else { - break; + if (*strflags && strflags != '\0' && gotone == FALSE) { + char *temp = strflags; + + temp += strlen(strflags); + *temp++ = ','; + *temp++ = '\0'; + } + if (gotone == FALSE) + strcat(strflags, options); + if (comma) { + *comma = ','; + options = ++comma; + } else { + break; + } } - } } int mount_one(char *blockDevice, char *directory, char *filesystemType, - unsigned long flags, char *string_flags, int useMtab, int fakeIt, char *mtab_opts) + unsigned long flags, char *string_flags, int useMtab, int fakeIt, + char *mtab_opts) { - int status = 0; + int status = 0; - char buf[255]; + char buf[255]; #if defined BB_FEATURE_USE_PROCFS - if (strcmp(filesystemType, "auto") == 0) { - FILE *f = fopen ("/proc/filesystems", "r"); - - if (f == NULL) - return( FALSE); - - while (fgets (buf, sizeof (buf), f) != NULL) { - filesystemType = buf; - if (*filesystemType == '\t') { // Not a nodev filesystem - - // Add NULL termination to each line - while (*filesystemType && *filesystemType != '\n') - filesystemType++; - *filesystemType = '\0'; - - filesystemType = buf; - filesystemType++; // hop past tab - - status = do_mount (blockDevice, directory, filesystemType, - flags | MS_MGC_VAL, string_flags, useMtab, - fakeIt, mtab_opts); - if (status == TRUE) - break; - } - } - fclose (f); - } else + if (strcmp(filesystemType, "auto") == 0) { + FILE *f = fopen("/proc/filesystems", "r"); + + if (f == NULL) + return (FALSE); + + while (fgets(buf, sizeof(buf), f) != NULL) { + filesystemType = buf; + if (*filesystemType == '\t') { // Not a nodev filesystem + + // Add NULL termination to each line + while (*filesystemType && *filesystemType != '\n') + filesystemType++; + *filesystemType = '\0'; + + filesystemType = buf; + filesystemType++; // hop past tab + + status = do_mount(blockDevice, directory, filesystemType, + flags | MS_MGC_VAL, string_flags, + useMtab, fakeIt, mtab_opts); + if (status == TRUE) + break; + } + } + fclose(f); + } else #endif - { - status = do_mount (blockDevice, directory, filesystemType, - flags | MS_MGC_VAL, string_flags, useMtab, - fakeIt, mtab_opts); - } - - if (status==FALSE) { - fprintf (stderr, "Mounting %s on %s failed: %s\n", - blockDevice, directory, strerror(errno)); - return (FALSE); - } - return (TRUE); + { + status = do_mount(blockDevice, directory, filesystemType, + flags | MS_MGC_VAL, string_flags, useMtab, + fakeIt, mtab_opts); + } + + if (status == FALSE) { + fprintf(stderr, "Mounting %s on %s failed: %s\n", + blockDevice, directory, strerror(errno)); + return (FALSE); + } + return (TRUE); } -extern int mount_main (int argc, char **argv) +extern int mount_main(int argc, char **argv) { - char string_flags_buf[1024]=""; - char *string_flags = string_flags_buf; - char *extra_opts = string_flags_buf; - unsigned long flags = 0; - char *filesystemType = "auto"; - char *device = NULL; - char *directory = NULL; - int all = FALSE; - int fakeIt = FALSE; - int useMtab = TRUE; - int i; - - /* Only compiled in if BB_MTAB is not defined */ - whine_if_fstab_is_missing(); - - if (argc == 1) { - FILE *mountTable = setmntent (mtab_file, "r"); - if (mountTable) { - struct mntent *m; - while ((m = getmntent (mountTable)) != 0) { - struct fstab* fstabItem; - char *blockDevice = m->mnt_fsname; - /* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */ - if (strcmp (blockDevice, "/dev/root") == 0) { - fstabItem = getfsfile ("/"); - if (fstabItem != NULL) - blockDevice = fstabItem->fs_spec; + char string_flags_buf[1024] = ""; + char *string_flags = string_flags_buf; + char *extra_opts = string_flags_buf; + unsigned long flags = 0; + char *filesystemType = "auto"; + char *device = NULL; + char *directory = NULL; + int all = FALSE; + int fakeIt = FALSE; + int useMtab = TRUE; + int i; + + /* Only compiled in if BB_MTAB is not defined */ + whine_if_fstab_is_missing(); + + if (argc == 1) { + FILE *mountTable = setmntent(mtab_file, "r"); + + if (mountTable) { + struct mntent *m; + + while ((m = getmntent(mountTable)) != 0) { + struct fstab *fstabItem; + char *blockDevice = m->mnt_fsname; + + /* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */ + if (strcmp(blockDevice, "/dev/root") == 0) { + fstabItem = getfsfile("/"); + if (fstabItem != NULL) + blockDevice = fstabItem->fs_spec; + } + printf("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir, + m->mnt_type, m->mnt_opts); + } + endmntent(mountTable); + } else { + perror(mtab_file); } - printf ("%s on %s type %s (%s)\n", blockDevice, m->mnt_dir, - m->mnt_type, m->mnt_opts); - } - endmntent (mountTable); - } else { - perror(mtab_file); + exit(TRUE); } - exit( TRUE); - } - - - /* Parse options */ - i = --argc; - argv++; - while (i > 0 && **argv) { - if (**argv == '-') { - char *opt = *argv; - while (i>0 && *++opt) switch (*opt) { - case 'o': - if (--i == 0) { - goto goodbye; - } - parse_mount_options (*(++argv), &flags, string_flags); - break; - case 'r': - flags |= MS_RDONLY; - break; - case 't': - if (--i == 0) { - goto goodbye; - } - filesystemType = *(++argv); - break; - case 'w': - flags &= ~MS_RDONLY; - break; - case 'a': - all = TRUE; - break; + + + /* Parse options */ + i = --argc; + argv++; + while (i > 0 && **argv) { + if (**argv == '-') { + char *opt = *argv; + + while (i > 0 && *++opt) + switch (*opt) { + case 'o': + if (--i == 0) { + goto goodbye; + } + parse_mount_options(*(++argv), &flags, string_flags); + break; + case 'r': + flags |= MS_RDONLY; + break; + case 't': + if (--i == 0) { + goto goodbye; + } + filesystemType = *(++argv); + break; + case 'w': + flags &= ~MS_RDONLY; + break; + case 'a': + all = TRUE; + break; #ifdef BB_MTAB - case 'f': - fakeIt = TRUE; - break; - case 'n': - useMtab = FALSE; - break; + case 'f': + fakeIt = TRUE; + break; + case 'n': + useMtab = FALSE; + break; #endif - case 'v': - case 'h': - case '-': - goto goodbye; - } - } else { - if (device == NULL) - device = *argv; - else if (directory == NULL) - directory = *argv; - else { - goto goodbye; - } + case 'v': + case 'h': + case '-': + goto goodbye; + } + } else { + if (device == NULL) + device = *argv; + else if (directory == NULL) + directory = *argv; + else { + goto goodbye; + } + } + i--; + argv++; } - i--; - argv++; - } - if (all == TRUE) { - struct mntent *m; - FILE *f = setmntent ("/etc/fstab", "r"); + if (all == TRUE) { + struct mntent *m; + FILE *f = setmntent("/etc/fstab", "r"); - if (f == NULL) { - perror("/etc/fstab"); - exit( FALSE); - } - while ((m = getmntent (f)) != NULL) { - // If the file system isn't noauto, and isn't mounted on /, - // and isn't swap or nfs, then mount it - if ((!strstr (m->mnt_opts, "noauto")) && - (m->mnt_dir[1] != '\0') && - (!strstr (m->mnt_type, "swap")) && - (!strstr (m->mnt_type, "nfs"))) - { - flags = 0; - *string_flags = '\0'; - parse_mount_options(m->mnt_opts, &flags, string_flags); - mount_one (m->mnt_fsname, m->mnt_dir, m->mnt_type, - flags, string_flags, useMtab, fakeIt, extra_opts); - } - } - endmntent (f); - } else { - if (device && directory) { + if (f == NULL) { + perror("/etc/fstab"); + exit(FALSE); + } + while ((m = getmntent(f)) != NULL) { + // If the file system isn't noauto, and isn't mounted on /, + // and isn't swap or nfs, then mount it + if ((!strstr(m->mnt_opts, "noauto")) && + (m->mnt_dir[1] != '\0') && + (!strstr(m->mnt_type, "swap")) && + (!strstr(m->mnt_type, "nfs"))) { + flags = 0; + *string_flags = '\0'; + parse_mount_options(m->mnt_opts, &flags, string_flags); + mount_one(m->mnt_fsname, m->mnt_dir, m->mnt_type, + flags, string_flags, useMtab, fakeIt, + extra_opts); + } + } + endmntent(f); + } else { + if (device && directory) { #ifdef BB_NFSMOUNT - if (strcmp(filesystemType, "nfs") == 0) { - if (nfsmount(device, directory, &flags, &extra_opts, &string_flags, 1) != 0) - exit(FALSE); - } + if (strcmp(filesystemType, "nfs") == 0) { + if (nfsmount + (device, directory, &flags, &extra_opts, &string_flags, + 1) != 0) + exit(FALSE); + } #endif - exit (mount_one (device, directory, filesystemType, - flags, string_flags, useMtab, fakeIt, extra_opts)); - } else { - goto goodbye; + exit(mount_one(device, directory, filesystemType, + flags, string_flags, useMtab, fakeIt, + extra_opts)); + } else { + goto goodbye; + } } - } - exit( TRUE); + exit(TRUE); -goodbye: - usage( mount_usage); + goodbye: + usage(mount_usage); } - diff --git a/util-linux/nfsmount.c b/util-linux/nfsmount.c index f2bd2f49c..03ce58447 100644 --- a/util-linux/nfsmount.c +++ b/util-linux/nfsmount.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * nfsmount.c -- Linux NFS mount * Copyright (C) 1993 Rick Sladkey @@ -53,7 +54,7 @@ #define _ #define HAVE_inet_aton -#define MS_REMOUNT 32 /* Alter flags of a mounted FS */ +#define MS_REMOUNT 32 /* Alter flags of a mounted FS */ #define sloppy 0 #define EX_FAIL 1 #define EX_BG 1 @@ -65,8 +66,8 @@ static char *nfs_strerror(int stat); #define MAKE_VERSION(p,q,r) (65536*(p) + 256*(q) + (r)) -static int -linux_version_code(void) { +static int linux_version_code(void) +{ struct utsname my_utsname; int p, q, r; @@ -74,7 +75,7 @@ linux_version_code(void) { p = atoi(strtok(my_utsname.release, ".")); q = atoi(strtok(NULL, ".")); r = atoi(strtok(NULL, ".")); - return MAKE_VERSION(p,q,r); + return MAKE_VERSION(p, q, r); } return 0; } @@ -95,22 +96,22 @@ static int nfs_mount_version = NFS_MOUNT_VERSION; * NFS_MOUNT_VERSION: these nfsmount sources at compile time * nfs_mount_version: version this source and running kernel can handle */ -static void -find_kernel_nfs_mount_version(void) { +static void find_kernel_nfs_mount_version(void) +{ int kernel_version = linux_version_code(); if (kernel_version) { - if (kernel_version < MAKE_VERSION(2,1,32)) - nfs_mount_version = 1; - else - nfs_mount_version = 3; + if (kernel_version < MAKE_VERSION(2, 1, 32)) + nfs_mount_version = 1; + else + nfs_mount_version = 3; } if (nfs_mount_version > NFS_MOUNT_VERSION) - nfs_mount_version = NFS_MOUNT_VERSION; + nfs_mount_version = NFS_MOUNT_VERSION; } int nfsmount(const char *spec, const char *node, unsigned long *flags, - char **extra_opts, char **mount_opts, int running_bg) + char **extra_opts, char **mount_opts, int running_bg) { static char *prev_bg_host; char hostdir[1024]; @@ -118,7 +119,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, char *hostname; char *dirname; char *old_opts; - char *mounthost=NULL; + char *mounthost = NULL; char new_opts[1024]; fhandle root_fhandle; struct timeval total_timeout; @@ -161,7 +162,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, mclient = NULL; if (strlen(spec) >= sizeof(hostdir)) { fprintf(stderr, _("mount: " - "excessively long host:dir argument\n")); + "excessively long host:dir argument\n")); goto fail; } strcpy(hostdir, spec); @@ -174,11 +175,11 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, if ((s = strchr(hostdir, ','))) { *s = '\0'; fprintf(stderr, _("mount: warning: " - "multiple hostnames not supported\n")); + "multiple hostnames not supported\n")); } } else { fprintf(stderr, _("mount: " - "directory to mount not in host:dir format\n")); + "directory to mount not in host:dir format\n")); goto fail; } @@ -189,20 +190,18 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, { if ((hp = gethostbyname(hostname)) == NULL) { fprintf(stderr, _("mount: can't get address for %s\n"), - hostname); + hostname); goto fail; } else { if (hp->h_length > sizeof(struct in_addr)) { - fprintf(stderr, - _("mount: got bad hp->h_length\n")); + fprintf(stderr, _("mount: got bad hp->h_length\n")); hp->h_length = sizeof(struct in_addr); } - memcpy(&server_addr.sin_addr, - hp->h_addr, hp->h_length); + memcpy(&server_addr.sin_addr, hp->h_addr, hp->h_length); } } - memcpy (&mount_server_addr, &server_addr, sizeof (mount_server_addr)); + memcpy(&mount_server_addr, &server_addr, sizeof(mount_server_addr)); /* add IP address to mtab options for use when unmounting */ @@ -211,12 +210,10 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, if (!old_opts) old_opts = ""; if (strlen(old_opts) + strlen(s) + 10 >= sizeof(new_opts)) { - fprintf(stderr, _("mount: " - "excessively long option argument\n")); + fprintf(stderr, _("mount: " "excessively long option argument\n")); goto fail; } - sprintf(new_opts, "%s%saddr=%s", - old_opts, *old_opts ? "," : "", s); + sprintf(new_opts, "%s%saddr=%s", old_opts, *old_opts ? "," : "", s); *extra_opts = xstrdup(new_opts); /* Set default options. @@ -224,13 +221,13 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, * let the kernel decide. * timeo is filled in after we know whether it'll be TCP or UDP. */ memset(&data, 0, sizeof(data)); - data.retrans = 3; - data.acregmin = 3; - data.acregmax = 60; - data.acdirmin = 30; - data.acdirmax = 60; + data.retrans = 3; + data.acregmin = 3; + data.acregmax = 60; + data.acdirmin = 30; + data.acdirmax = 60; #if NFS_MOUNT_VERSION >= 2 - data.namlen = NAME_MAX; + data.namlen = NAME_MAX; #endif bg = 0; @@ -240,7 +237,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, nocto = 0; nolock = 0; noac = 0; - retry = 10000; /* 10000 minutes ~ 1 week */ + retry = 10000; /* 10000 minutes ~ 1 week */ tcp = 0; mountprog = MOUNTPROG; @@ -254,7 +251,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, for (opt = strtok(old_opts, ","); opt; opt = strtok(NULL, ",")) { if ((opteq = strchr(opt, '='))) { - val = atoi(opteq + 1); + val = atoi(opteq + 1); *opteq = '\0'; if (!strcmp(opt, "rsize")) data.rsize = val; @@ -277,29 +274,27 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, data.acregmax = val; data.acdirmin = val; data.acdirmax = val; - } - else if (!strcmp(opt, "retry")) + } else if (!strcmp(opt, "retry")) retry = val; else if (!strcmp(opt, "port")) port = val; else if (!strcmp(opt, "mountport")) - mountport = val; + mountport = val; else if (!strcmp(opt, "mounthost")) - mounthost=xstrndup(opteq+1, - strcspn(opteq+1," \t\n\r,")); + mounthost = xstrndup(opteq + 1, + strcspn(opteq + 1, " \t\n\r,")); else if (!strcmp(opt, "mountprog")) mountprog = val; else if (!strcmp(opt, "mountvers")) mountvers = val; else if (!strcmp(opt, "nfsprog")) nfsprog = val; - else if (!strcmp(opt, "nfsvers") || - !strcmp(opt, "vers")) + else if (!strcmp(opt, "nfsvers") || !strcmp(opt, "vers")) nfsvers = val; else if (!strcmp(opt, "proto")) { - if (!strncmp(opteq+1, "tcp", 3)) + if (!strncmp(opteq + 1, "tcp", 3)) tcp = 1; - else if (!strncmp(opteq+1, "udp", 3)) + else if (!strncmp(opteq + 1, "udp", 3)) tcp = 0; else printf(_("Warning: Unrecognized proto= option.\n")); @@ -309,24 +304,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, data.namlen = val; else #endif - printf(_("Warning: Option namlen is not supported.\n")); + printf(_ + ("Warning: Option namlen is not supported.\n")); } else if (!strcmp(opt, "addr")) - /* ignore */; + /* ignore */ ; else { printf(_("unknown nfs mount parameter: " - "%s=%d\n"), opt, val); + "%s=%d\n"), opt, val); goto fail; } - } - else { + } else { val = 1; if (!strncmp(opt, "no", 2)) { val = 0; opt += 2; } - if (!strcmp(opt, "bg")) + if (!strcmp(opt, "bg")) bg = val; - else if (!strcmp(opt, "fg")) + else if (!strcmp(opt, "fg")) bg = !val; else if (!strcmp(opt, "soft")) soft = val; @@ -348,11 +343,12 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, if (nfs_mount_version >= 3) nolock = !val; else - printf(_("Warning: option nolock is not supported.\n")); + printf(_ + ("Warning: option nolock is not supported.\n")); } else { if (!sloppy) { printf(_("unknown nfs mount option: " - "%s%s\n"), val ? "" : "no", opt); + "%s%s\n"), val ? "" : "no", opt); goto fail; } } @@ -378,22 +374,21 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, #ifdef NFS_MOUNT_DEBUG printf("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n", - data.rsize, data.wsize, data.timeo, data.retrans); + data.rsize, data.wsize, data.timeo, data.retrans); printf("acreg (min, max) = (%d, %d), acdir (min, max) = (%d, %d)\n", - data.acregmin, data.acregmax, data.acdirmin, data.acdirmax); + data.acregmin, data.acregmax, data.acdirmin, data.acdirmax); printf("port = %d, bg = %d, retry = %d, flags = %.8x\n", - port, bg, retry, data.flags); + port, bg, retry, data.flags); printf("mountprog = %d, mountvers = %d, nfsprog = %d, nfsvers = %d\n", - mountprog, mountvers, nfsprog, nfsvers); + mountprog, mountvers, nfsprog, nfsvers); printf("soft = %d, intr = %d, posix = %d, nocto = %d, noac = %d\n", - (data.flags & NFS_MOUNT_SOFT) != 0, - (data.flags & NFS_MOUNT_INTR) != 0, - (data.flags & NFS_MOUNT_POSIX) != 0, - (data.flags & NFS_MOUNT_NOCTO) != 0, - (data.flags & NFS_MOUNT_NOAC) != 0); + (data.flags & NFS_MOUNT_SOFT) != 0, + (data.flags & NFS_MOUNT_INTR) != 0, + (data.flags & NFS_MOUNT_POSIX) != 0, + (data.flags & NFS_MOUNT_NOCTO) != 0, + (data.flags & NFS_MOUNT_NOAC) != 0); #if NFS_MOUNT_VERSION >= 2 - printf("tcp = %d\n", - (data.flags & NFS_MOUNT_TCP) != 0); + printf("tcp = %d\n", (data.flags & NFS_MOUNT_TCP) != 0); #endif #endif @@ -409,7 +404,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, * give up immediately, to avoid the initial timeout. */ if (bg && !running_bg && - prev_bg_host && strcmp(hostname, prev_bg_host) == 0) { + prev_bg_host && strcmp(hostname, prev_bg_host) == 0) { if (retry > 0) retval = EX_BG; return retval; @@ -418,25 +413,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, /* create mount deamon client */ /* See if the nfs host = mount host. */ if (mounthost) { - if (mounthost[0] >= '0' && mounthost[0] <= '9') { - mount_server_addr.sin_family = AF_INET; - mount_server_addr.sin_addr.s_addr = inet_addr(hostname); - } else { - if ((hp = gethostbyname(mounthost)) == NULL) { - fprintf(stderr, _("mount: can't get address for %s\n"), - hostname); - goto fail; - } else { - if (hp->h_length > sizeof(struct in_addr)) { - fprintf(stderr, - _("mount: got bad hp->h_length?\n")); - hp->h_length = sizeof(struct in_addr); - } - mount_server_addr.sin_family = AF_INET; - memcpy(&mount_server_addr.sin_addr, - hp->h_addr, hp->h_length); - } - } + if (mounthost[0] >= '0' && mounthost[0] <= '9') { + mount_server_addr.sin_family = AF_INET; + mount_server_addr.sin_addr.s_addr = inet_addr(hostname); + } else { + if ((hp = gethostbyname(mounthost)) == NULL) { + fprintf(stderr, _("mount: can't get address for %s\n"), + hostname); + goto fail; + } else { + if (hp->h_length > sizeof(struct in_addr)) { + fprintf(stderr, _("mount: got bad hp->h_length?\n")); + hp->h_length = sizeof(struct in_addr); + } + mount_server_addr.sin_family = AF_INET; + memcpy(&mount_server_addr.sin_addr, + hp->h_addr, hp->h_length); + } + } } /* @@ -466,7 +460,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, for (;;) { if (bg && stat(node, &statbuf) == -1) { if (running_bg) { - sleep(val); /* 1, 2, 4, 8, 16, 30, ... */ + sleep(val); /* 1, 2, 4, 8, 16, 30, ... */ val *= 2; if (val > 30) val = 30; @@ -480,24 +474,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, mount_server_addr.sin_port = htons(mountport); msock = RPC_ANYSOCK; mclient = clnttcp_create(&mount_server_addr, - mountprog, mountvers, - &msock, 0, 0); + mountprog, mountvers, &msock, 0, 0); /* if this fails, contact the mount daemon via UDP */ if (!mclient) { mount_server_addr.sin_port = htons(mountport); msock = RPC_ANYSOCK; mclient = clntudp_create(&mount_server_addr, - mountprog, mountvers, - retry_timeout, &msock); + mountprog, mountvers, + retry_timeout, &msock); } if (mclient) { /* try to mount hostname:dirname */ mclient->cl_auth = authunix_create_default(); clnt_stat = clnt_call(mclient, MOUNTPROC_MNT, - (xdrproc_t) xdr_dirpath, (caddr_t) &dirname, - (xdrproc_t) xdr_fhstatus, (caddr_t) &status, - total_timeout); + (xdrproc_t) xdr_dirpath, + (caddr_t) & dirname, + (xdrproc_t) xdr_fhstatus, + (caddr_t) & status, total_timeout); if (clnt_stat == RPC_SUCCESS) break; /* we're done */ if (errno != ECONNREFUSED) { @@ -517,7 +511,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, prevt = t; } if (!bg) - goto fail; + goto fail; if (!running_bg) { prev_bg_host = xstrdup(hostname); if (retry > 0) @@ -531,18 +525,18 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, if (status.fhs_status != 0) { fprintf(stderr, - _("mount: %s:%s failed, reason given by server: %s\n"), - hostname, dirname, nfs_strerror(status.fhs_status)); + _("mount: %s:%s failed, reason given by server: %s\n"), + hostname, dirname, nfs_strerror(status.fhs_status)); goto fail; } memcpy((char *) &root_fhandle, (char *) status.fhstatus_u.fhs_fhandle, - sizeof (root_fhandle)); + sizeof(root_fhandle)); /* create nfs socket for kernel */ if (tcp) { if (nfs_mount_version < 3) { - printf(_("NFS over TCP is not supported.\n")); + printf(_("NFS over TCP is not supported.\n")); goto fail; } fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); @@ -559,7 +553,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, if (port == 0) { server_addr.sin_port = PMAPPORT; port = pmap_getport(&server_addr, nfsprog, nfsvers, - tcp ? IPPROTO_TCP : IPPROTO_UDP); + tcp ? IPPROTO_TCP : IPPROTO_UDP); if (port == 0) port = NFS_PORT; #ifdef NFS_MOUNT_DEBUG @@ -571,14 +565,14 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, printf(_("using port %d for nfs deamon\n"), port); #endif server_addr.sin_port = htons(port); - /* - * connect() the socket for kernels 1.3.10 and below only, - * to avoid problems with multihomed hosts. - * --Swen - */ + /* + * connect() the socket for kernels 1.3.10 and below only, + * to avoid problems with multihomed hosts. + * --Swen + */ if (linux_version_code() <= 66314 - && connect(fsock, (struct sockaddr *) &server_addr, - sizeof (server_addr)) < 0) { + && connect(fsock, (struct sockaddr *) &server_addr, + sizeof(server_addr)) < 0) { perror(_("nfs connect")); goto fail; } @@ -587,7 +581,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, data.fd = fsock; memcpy((char *) &data.root, (char *) &root_fhandle, - sizeof (root_fhandle)); + sizeof(root_fhandle)); memcpy((char *) &data.addr, (char *) &server_addr, sizeof(data.addr)); strncpy(data.hostname, hostname, sizeof(data.hostname)); @@ -600,7 +594,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags, /* abort */ -fail: + fail: if (msock != -1) { if (mclient) { auth_destroy(mclient->cl_auth); @@ -611,7 +605,7 @@ fail: if (fsock != -1) close(fsock); return retval; -} +} /* * We need to translate between nfs status return values and @@ -630,33 +624,37 @@ static struct { enum nfs_stat stat; int errnum; } nfs_errtbl[] = { - { NFS_OK, 0 }, - { NFSERR_PERM, EPERM }, - { NFSERR_NOENT, ENOENT }, - { NFSERR_IO, EIO }, - { NFSERR_NXIO, ENXIO }, - { NFSERR_ACCES, EACCES }, - { NFSERR_EXIST, EEXIST }, - { NFSERR_NODEV, ENODEV }, - { NFSERR_NOTDIR, ENOTDIR }, - { NFSERR_ISDIR, EISDIR }, + { + NFS_OK, 0}, { + NFSERR_PERM, EPERM}, { + NFSERR_NOENT, ENOENT}, { + NFSERR_IO, EIO}, { + NFSERR_NXIO, ENXIO}, { + NFSERR_ACCES, EACCES}, { + NFSERR_EXIST, EEXIST}, { + NFSERR_NODEV, ENODEV}, { + NFSERR_NOTDIR, ENOTDIR}, { + NFSERR_ISDIR, EISDIR}, #ifdef NFSERR_INVAL - { NFSERR_INVAL, EINVAL }, /* that Sun forgot */ + { + NFSERR_INVAL, EINVAL}, /* that Sun forgot */ #endif - { NFSERR_FBIG, EFBIG }, - { NFSERR_NOSPC, ENOSPC }, - { NFSERR_ROFS, EROFS }, - { NFSERR_NAMETOOLONG, ENAMETOOLONG }, - { NFSERR_NOTEMPTY, ENOTEMPTY }, - { NFSERR_DQUOT, EDQUOT }, - { NFSERR_STALE, ESTALE }, + { + NFSERR_FBIG, EFBIG}, { + NFSERR_NOSPC, ENOSPC}, { + NFSERR_ROFS, EROFS}, { + NFSERR_NAMETOOLONG, ENAMETOOLONG}, { + NFSERR_NOTEMPTY, ENOTEMPTY}, { + NFSERR_DQUOT, EDQUOT}, { + NFSERR_STALE, ESTALE}, #ifdef EWFLUSH - { NFSERR_WFLUSH, EWFLUSH }, + { + NFSERR_WFLUSH, EWFLUSH}, #endif - /* Throw in some NFSv3 values for even more fun (HP returns these) */ - { 71, EREMOTE }, - - { -1, EIO } + /* Throw in some NFSv3 values for even more fun (HP returns these) */ + { + 71, EREMOTE}, { + -1, EIO} }; static char *nfs_strerror(int stat) @@ -673,33 +671,32 @@ static char *nfs_strerror(int stat) } #if 0 -int -my_getport(struct in_addr server, struct timeval *timeo, ...) +int my_getport(struct in_addr server, struct timeval *timeo, ...) { - struct sockaddr_in sin; - struct pmap pmap; - CLIENT *clnt; - int sock = RPC_ANYSOCK, port; - - pmap.pm_prog = prog; - pmap.pm_vers = vers; - pmap.pm_prot = prot; - pmap.pm_port = 0; - sin.sin_family = AF_INET; - sin.sin_addr = server; - sin.sin_port = htons(111); - clnt = clntudp_create(&sin, 100000, 2, *timeo, &sock); - status = clnt_call(clnt, PMAP_GETPORT, - &pmap, (xdrproc_t) xdr_pmap, - &port, (xdrproc_t) xdr_uint); - if (status != SUCCESS) { - /* natter */ - port = 0; - } - - clnt_destroy(clnt); - close(sock); - return port; + struct sockaddr_in sin; + struct pmap pmap; + CLIENT *clnt; + int sock = RPC_ANYSOCK, port; + + pmap.pm_prog = prog; + pmap.pm_vers = vers; + pmap.pm_prot = prot; + pmap.pm_port = 0; + sin.sin_family = AF_INET; + sin.sin_addr = server; + sin.sin_port = htons(111); + clnt = clntudp_create(&sin, 100000, 2, *timeo, &sock); + status = clnt_call(clnt, PMAP_GETPORT, + &pmap, (xdrproc_t) xdr_pmap, + &port, (xdrproc_t) xdr_uint); + if (status != SUCCESS) { + /* natter */ + port = 0; + } + + clnt_destroy(clnt); + close(sock); + return port; } #endif @@ -756,28 +753,26 @@ my_getport(struct in_addr server, struct timeval *timeo, ...) /* from @(#)mount.x 1.3 91/03/11 TIRPC 1.0 */ -bool_t -xdr_fhandle(XDR *xdrs, fhandle objp) +bool_t xdr_fhandle(XDR * xdrs, fhandle objp) { - if (!xdr_opaque(xdrs, objp, FHSIZE)) { - return (FALSE); - } + if (!xdr_opaque(xdrs, objp, FHSIZE)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_fhstatus(XDR *xdrs, fhstatus *objp) +bool_t xdr_fhstatus(XDR * xdrs, fhstatus * objp) { - if (!xdr_u_int(xdrs, &objp->fhs_status)) { - return (FALSE); - } + if (!xdr_u_int(xdrs, &objp->fhs_status)) { + return (FALSE); + } switch (objp->fhs_status) { case 0: - if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle)) { - return (FALSE); - } + if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle)) { + return (FALSE); + } break; default: break; @@ -785,245 +780,246 @@ xdr_fhstatus(XDR *xdrs, fhstatus *objp) return (TRUE); } -bool_t -xdr_dirpath(XDR *xdrs, dirpath *objp) +bool_t xdr_dirpath(XDR * xdrs, dirpath * objp) { - if (!xdr_string(xdrs, objp, MNTPATHLEN)) { - return (FALSE); - } + if (!xdr_string(xdrs, objp, MNTPATHLEN)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_name(XDR *xdrs, name *objp) +bool_t xdr_name(XDR * xdrs, name * objp) { - if (!xdr_string(xdrs, objp, MNTNAMLEN)) { - return (FALSE); - } + if (!xdr_string(xdrs, objp, MNTNAMLEN)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_mountlist(XDR *xdrs, mountlist *objp) +bool_t xdr_mountlist(XDR * xdrs, mountlist * objp) { - if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mountbody), (xdrproc_t)xdr_mountbody)) { - return (FALSE); - } + if (!xdr_pointer + (xdrs, (char **) objp, sizeof(struct mountbody), + (xdrproc_t) xdr_mountbody)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_mountbody(XDR *xdrs, mountbody *objp) +bool_t xdr_mountbody(XDR * xdrs, mountbody * objp) { - if (!xdr_name(xdrs, &objp->ml_hostname)) { - return (FALSE); - } - if (!xdr_dirpath(xdrs, &objp->ml_directory)) { - return (FALSE); - } - if (!xdr_mountlist(xdrs, &objp->ml_next)) { - return (FALSE); - } + if (!xdr_name(xdrs, &objp->ml_hostname)) { + return (FALSE); + } + if (!xdr_dirpath(xdrs, &objp->ml_directory)) { + return (FALSE); + } + if (!xdr_mountlist(xdrs, &objp->ml_next)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_groups(XDR *xdrs, groups *objp) +bool_t xdr_groups(XDR * xdrs, groups * objp) { - if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct groupnode), (xdrproc_t)xdr_groupnode)) { - return (FALSE); - } + if (!xdr_pointer + (xdrs, (char **) objp, sizeof(struct groupnode), + (xdrproc_t) xdr_groupnode)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_groupnode(XDR *xdrs, groupnode *objp) +bool_t xdr_groupnode(XDR * xdrs, groupnode * objp) { - if (!xdr_name(xdrs, &objp->gr_name)) { - return (FALSE); - } - if (!xdr_groups(xdrs, &objp->gr_next)) { - return (FALSE); - } + if (!xdr_name(xdrs, &objp->gr_name)) { + return (FALSE); + } + if (!xdr_groups(xdrs, &objp->gr_next)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_exports(XDR *xdrs, exports *objp) +bool_t xdr_exports(XDR * xdrs, exports * objp) { - if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct exportnode), (xdrproc_t)xdr_exportnode)) { - return (FALSE); - } + if (!xdr_pointer + (xdrs, (char **) objp, sizeof(struct exportnode), + (xdrproc_t) xdr_exportnode)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_exportnode(XDR *xdrs, exportnode *objp) +bool_t xdr_exportnode(XDR * xdrs, exportnode * objp) { - if (!xdr_dirpath(xdrs, &objp->ex_dir)) { - return (FALSE); - } - if (!xdr_groups(xdrs, &objp->ex_groups)) { - return (FALSE); - } - if (!xdr_exports(xdrs, &objp->ex_next)) { - return (FALSE); - } + if (!xdr_dirpath(xdrs, &objp->ex_dir)) { + return (FALSE); + } + if (!xdr_groups(xdrs, &objp->ex_groups)) { + return (FALSE); + } + if (!xdr_exports(xdrs, &objp->ex_next)) { + return (FALSE); + } return (TRUE); } -bool_t -xdr_ppathcnf(XDR *xdrs, ppathcnf *objp) +bool_t xdr_ppathcnf(XDR * xdrs, ppathcnf * objp) { - register long *buf; - - int i; - - if (xdrs->x_op == XDR_ENCODE) { - buf = (long*)XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int(xdrs, &objp->pc_link_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_canon)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_input)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_name_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_path_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { - return (FALSE); - } - - } - else { - IXDR_PUT_LONG(buf,objp->pc_link_max); - IXDR_PUT_SHORT(buf,objp->pc_max_canon); - IXDR_PUT_SHORT(buf,objp->pc_max_input); - IXDR_PUT_SHORT(buf,objp->pc_name_max); - IXDR_PUT_SHORT(buf,objp->pc_path_max); - IXDR_PUT_SHORT(buf,objp->pc_pipe_buf); - } - if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { - return (FALSE); - } - if (!xdr_char(xdrs, &objp->pc_xxx)) { - return (FALSE); - } - buf = (long*)XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT); + register long *buf; + + int i; + + if (xdrs->x_op == XDR_ENCODE) { + buf = (long *) XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT); if (buf == NULL) { - if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) { - return (FALSE); - } - - } - else { - { register short *genp; - for ( i = 0,genp=objp->pc_mask; - i < 2; i++){ - IXDR_PUT_SHORT(buf,*genp++); - } - }; - } - - return (TRUE); + if (!xdr_int(xdrs, &objp->pc_link_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_canon)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_input)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_name_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_path_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { + return (FALSE); + } + + } else { + IXDR_PUT_LONG(buf, objp->pc_link_max); + IXDR_PUT_SHORT(buf, objp->pc_max_canon); + IXDR_PUT_SHORT(buf, objp->pc_max_input); + IXDR_PUT_SHORT(buf, objp->pc_name_max); + IXDR_PUT_SHORT(buf, objp->pc_path_max); + IXDR_PUT_SHORT(buf, objp->pc_pipe_buf); + } + if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { + return (FALSE); + } + if (!xdr_char(xdrs, &objp->pc_xxx)) { + return (FALSE); + } + buf = (long *) XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_vector + (xdrs, (char *) objp->pc_mask, 2, sizeof(short), + (xdrproc_t) xdr_short)) { + return (FALSE); + } + + } else { + { + register short *genp; + + for (i = 0, genp = objp->pc_mask; i < 2; i++) { + IXDR_PUT_SHORT(buf, *genp++); + } + }; + } + + return (TRUE); } else if (xdrs->x_op == XDR_DECODE) { - buf = (long*)XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int(xdrs, &objp->pc_link_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_canon)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_input)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_name_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_path_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { - return (FALSE); - } - - } - else { - objp->pc_link_max = IXDR_GET_LONG(buf); - objp->pc_max_canon = IXDR_GET_SHORT(buf); - objp->pc_max_input = IXDR_GET_SHORT(buf); - objp->pc_name_max = IXDR_GET_SHORT(buf); - objp->pc_path_max = IXDR_GET_SHORT(buf); - objp->pc_pipe_buf = IXDR_GET_SHORT(buf); - } - if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { - return (FALSE); - } - if (!xdr_char(xdrs, &objp->pc_xxx)) { - return (FALSE); - } - buf = (long*)XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT); + buf = (long *) XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_int(xdrs, &objp->pc_link_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_canon)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_input)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_name_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_path_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { + return (FALSE); + } + + } else { + objp->pc_link_max = IXDR_GET_LONG(buf); + objp->pc_max_canon = IXDR_GET_SHORT(buf); + objp->pc_max_input = IXDR_GET_SHORT(buf); + objp->pc_name_max = IXDR_GET_SHORT(buf); + objp->pc_path_max = IXDR_GET_SHORT(buf); + objp->pc_pipe_buf = IXDR_GET_SHORT(buf); + } + if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { + return (FALSE); + } + if (!xdr_char(xdrs, &objp->pc_xxx)) { + return (FALSE); + } + buf = (long *) XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT); if (buf == NULL) { - if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) { - return (FALSE); - } - - } - else { - { register short *genp; - for ( i = 0,genp=objp->pc_mask; - i < 2; i++){ - *genp++ = IXDR_GET_SHORT(buf); - } - }; - } - return(TRUE); + if (!xdr_vector + (xdrs, (char *) objp->pc_mask, 2, sizeof(short), + (xdrproc_t) xdr_short)) { + return (FALSE); + } + + } else { + { + register short *genp; + + for (i = 0, genp = objp->pc_mask; i < 2; i++) { + *genp++ = IXDR_GET_SHORT(buf); + } + }; + } + return (TRUE); } - if (!xdr_int(xdrs, &objp->pc_link_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_canon)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_max_input)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_name_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_path_max)) { - return (FALSE); - } - if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { - return (FALSE); - } - if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { - return (FALSE); - } - if (!xdr_char(xdrs, &objp->pc_xxx)) { - return (FALSE); - } - if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) { - return (FALSE); - } + if (!xdr_int(xdrs, &objp->pc_link_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_canon)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_max_input)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_name_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_path_max)) { + return (FALSE); + } + if (!xdr_short(xdrs, &objp->pc_pipe_buf)) { + return (FALSE); + } + if (!xdr_u_char(xdrs, &objp->pc_vdisable)) { + return (FALSE); + } + if (!xdr_char(xdrs, &objp->pc_xxx)) { + return (FALSE); + } + if (!xdr_vector + (xdrs, (char *) objp->pc_mask, 2, sizeof(short), + (xdrproc_t) xdr_short)) { + return (FALSE); + } return (TRUE); } @@ -1063,247 +1059,232 @@ xdr_ppathcnf(XDR *xdrs, ppathcnf *objp) /* from @(#)mount.x 1.3 91/03/11 TIRPC 1.0 */ -#include /* for memset() */ +#include /* for memset() */ /* Default timeout can be changed using clnt_control() */ static struct timeval TIMEOUT = { 25, 0 }; -void * -mountproc_null_1(argp, clnt) - void *argp; - CLIENT *clnt; +void *mountproc_null_1(argp, clnt) +void *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); - if (clnt_call(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) { + memset((char *) &clnt_res, 0, sizeof(clnt_res)); + if (clnt_call + (clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, + (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -fhstatus * -mountproc_mnt_1(argp, clnt) - dirpath *argp; - CLIENT *clnt; +fhstatus *mountproc_mnt_1(argp, clnt) +dirpath *argp; +CLIENT *clnt; { static fhstatus clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_MNT, (xdrproc_t) xdr_dirpath, - (caddr_t) argp, (xdrproc_t) xdr_fhstatus, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_fhstatus, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -mountlist * -mountproc_dump_1(argp, clnt) - void *argp; - CLIENT *clnt; +mountlist *mountproc_dump_1(argp, clnt) +void *argp; +CLIENT *clnt; { static mountlist clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_DUMP, (xdrproc_t) xdr_void, - (caddr_t) argp, (xdrproc_t) xdr_mountlist, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_mountlist, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -void * -mountproc_umnt_1(argp, clnt) - dirpath *argp; - CLIENT *clnt; +void *mountproc_umnt_1(argp, clnt) +dirpath *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_UMNT, (xdrproc_t) xdr_dirpath, - (caddr_t) argp, (xdrproc_t) xdr_void, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_void, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -void * -mountproc_umntall_1(argp, clnt) - void *argp; - CLIENT *clnt; +void *mountproc_umntall_1(argp, clnt) +void *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_UMNTALL, (xdrproc_t) xdr_void, - (caddr_t) argp, (xdrproc_t) xdr_void, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_void, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -exports * -mountproc_export_1(argp, clnt) - void *argp; - CLIENT *clnt; +exports *mountproc_export_1(argp, clnt) +void *argp; +CLIENT *clnt; { static exports clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_EXPORT, (xdrproc_t) xdr_void, - (caddr_t) argp, (xdrproc_t) xdr_exports, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_exports, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -exports * -mountproc_exportall_1(argp, clnt) - void *argp; - CLIENT *clnt; +exports *mountproc_exportall_1(argp, clnt) +void *argp; +CLIENT *clnt; { static exports clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_EXPORTALL, (xdrproc_t) xdr_void, - (caddr_t) argp, (xdrproc_t) xdr_exports, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { - return (NULL); + (caddr_t) argp, (xdrproc_t) xdr_exports, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { + return (NULL); } return (&clnt_res); } -void * -mountproc_null_2(argp, clnt) - void *argp; - CLIENT *clnt; +void *mountproc_null_2(argp, clnt) +void *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); - if (clnt_call(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) { + memset((char *) &clnt_res, 0, sizeof(clnt_res)); + if (clnt_call + (clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, + (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -fhstatus * -mountproc_mnt_2(argp, clnt) - dirpath *argp; - CLIENT *clnt; +fhstatus *mountproc_mnt_2(argp, clnt) +dirpath *argp; +CLIENT *clnt; { static fhstatus clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_MNT, (xdrproc_t) xdr_dirpath, - (caddr_t) argp, (xdrproc_t) xdr_fhstatus, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_fhstatus, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -mountlist * -mountproc_dump_2(argp, clnt) - void *argp; - CLIENT *clnt; +mountlist *mountproc_dump_2(argp, clnt) +void *argp; +CLIENT *clnt; { static mountlist clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_DUMP, (xdrproc_t) xdr_void, argp, - (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res, - TIMEOUT) != RPC_SUCCESS) { + (xdrproc_t) xdr_mountlist, (caddr_t) & clnt_res, + TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -void * -mountproc_umnt_2(argp, clnt) - dirpath *argp; - CLIENT *clnt; +void *mountproc_umnt_2(argp, clnt) +dirpath *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_UMNT, (xdrproc_t) xdr_dirpath, - (caddr_t) argp, (xdrproc_t) xdr_void, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_void, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -void * -mountproc_umntall_2(argp, clnt) - void *argp; - CLIENT *clnt; +void *mountproc_umntall_2(argp, clnt) +void *argp; +CLIENT *clnt; { static char clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_UMNTALL, (xdrproc_t) xdr_void, - (caddr_t) argp, (xdrproc_t) xdr_void, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_void, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } - return ((void *)&clnt_res); + return ((void *) &clnt_res); } -exports * -mountproc_export_2(argp, clnt) - void *argp; - CLIENT *clnt; +exports *mountproc_export_2(argp, clnt) +void *argp; +CLIENT *clnt; { static exports clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_EXPORT, (xdrproc_t) xdr_void, - argp, (xdrproc_t) xdr_exports, (caddr_t) &clnt_res, - TIMEOUT) != RPC_SUCCESS) { + argp, (xdrproc_t) xdr_exports, (caddr_t) & clnt_res, + TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -exports * -mountproc_exportall_2(argp, clnt) - void *argp; - CLIENT *clnt; +exports *mountproc_exportall_2(argp, clnt) +void *argp; +CLIENT *clnt; { static exports clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_EXPORTALL, (xdrproc_t) xdr_void, argp, - (xdrproc_t) xdr_exports, (caddr_t) &clnt_res, - TIMEOUT) != RPC_SUCCESS) { + (xdrproc_t) xdr_exports, (caddr_t) & clnt_res, + TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } -ppathcnf * -mountproc_pathconf_2(argp, clnt) - dirpath *argp; - CLIENT *clnt; +ppathcnf *mountproc_pathconf_2(argp, clnt) +dirpath *argp; +CLIENT *clnt; { static ppathcnf clnt_res; - memset((char *)&clnt_res, 0, sizeof(clnt_res)); + memset((char *) &clnt_res, 0, sizeof(clnt_res)); if (clnt_call(clnt, MOUNTPROC_PATHCONF, (xdrproc_t) xdr_dirpath, - (caddr_t) argp, (xdrproc_t) xdr_ppathcnf, - (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { + (caddr_t) argp, (xdrproc_t) xdr_ppathcnf, + (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } return (&clnt_res); } - - - - diff --git a/util-linux/nfsmount.h b/util-linux/nfsmount.h index 73c71fc68..64ac617c0 100644 --- a/util-linux/nfsmount.h +++ b/util-linux/nfsmount.h @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Please do not edit this file. * It was generated using rpcgen. diff --git a/util-linux/swaponoff.c b/util-linux/swaponoff.c index 3c02bdd42..6bda22277 100644 --- a/util-linux/swaponoff.c +++ b/util-linux/swaponoff.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini swapon/swapoff implementation for busybox * @@ -32,91 +33,93 @@ static int whichApp; -static const char* appName; +static const char *appName; -static const char swapoff_usage[] = -"swapoff device\n" -"\nStop swapping virtual memory pages on the given device.\n"; -static const char swapon_usage[] = -"swapon device\n" -"\nStart swapping virtual memory pages on the given device.\n"; +static const char swapoff_usage[] = + + "swapoff device\n" + "\nStop swapping virtual memory pages on the given device.\n"; +static const char swapon_usage[] = + + "swapon device\n" + "\nStart swapping virtual memory pages on the given device.\n"; #define SWAPON_APP 1 #define SWAPOFF_APP 2 -static void -swap_enable_disable( char *device) +static void swap_enable_disable(char *device) { - int status; - if ( whichApp == SWAPON_APP ) - status = swapon(device, 0); - else - status = swapoff(device); - - if ( status != 0 ) { - perror(appName); - exit( FALSE); - } + int status; + + if (whichApp == SWAPON_APP) + status = swapon(device, 0); + else + status = swapoff(device); + + if (status != 0) { + perror(appName); + exit(FALSE); + } } -static void -do_em_all() +static void do_em_all() { struct mntent *m; - FILE *f = setmntent ("/etc/fstab", "r"); + FILE *f = setmntent("/etc/fstab", "r"); if (f == NULL) { - perror("/etc/fstab"); - exit( FALSE); + perror("/etc/fstab"); + exit(FALSE); } - while ((m = getmntent (f)) != NULL) { - if (!strstr (m->mnt_type, MNTTYPE_SWAP)) { - swap_enable_disable( m->mnt_fsname); - } + while ((m = getmntent(f)) != NULL) { + if (!strstr(m->mnt_type, MNTTYPE_SWAP)) { + swap_enable_disable(m->mnt_fsname); + } } - endmntent (f); - exit( TRUE); + endmntent(f); + exit(TRUE); } -extern int -swap_on_off_main(int argc, char * * argv) +extern int swap_on_off_main(int argc, char **argv) { - struct stat statBuf; - if (stat("/etc/fstab", &statBuf) < 0) - fprintf(stderr, "/etc/fstab file missing -- Please install one.\n\n"); - - if (strcmp(*argv, "swapon")==0) { - appName = *argv; - whichApp = SWAPON_APP; - - } else { - appName = *argv; - whichApp = SWAPOFF_APP; - } - - if (argc < 2) - goto usage_and_exit; - argc--; - argv++; - - /* Parse any options */ - while (**argv == '-') { - while (*++(*argv)) switch (**argv) { - case 'a': - do_em_all(); - break; - default: + struct stat statBuf; + + if (stat("/etc/fstab", &statBuf) < 0) + fprintf(stderr, + "/etc/fstab file missing -- Please install one.\n\n"); + + if (strcmp(*argv, "swapon") == 0) { + appName = *argv; + whichApp = SWAPON_APP; + + } else { + appName = *argv; + whichApp = SWAPOFF_APP; + } + + if (argc < 2) goto usage_and_exit; + argc--; + argv++; + + /* Parse any options */ + while (**argv == '-') { + while (*++(*argv)) + switch (**argv) { + case 'a': + do_em_all(); + break; + default: + goto usage_and_exit; + } } - } - swap_enable_disable(*argv); - exit( TRUE); + swap_enable_disable(*argv); + exit(TRUE); -usage_and_exit: - usage( (whichApp==SWAPON_APP)? swapon_usage : swapoff_usage); - exit( FALSE); + usage_and_exit: + usage((whichApp == SWAPON_APP) ? swapon_usage : swapoff_usage); + exit(FALSE); } - diff --git a/util-linux/umount.c b/util-linux/umount.c index b65caf76e..a2ca8c74a 100644 --- a/util-linux/umount.c +++ b/util-linux/umount.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini umount implementation for busybox * @@ -28,24 +29,23 @@ #include #include -static const char umount_usage[] = -"umount [flags] filesystem|directory\n\n" -"Flags:\n" -"\t-a:\tUnmount all file systems" +static const char umount_usage[] = + "umount [flags] filesystem|directory\n\n" + "Flags:\n" "\t-a:\tUnmount all file systems" #ifdef BB_MTAB -" in /etc/mtab\n\t-n:\tDon't erase /etc/mtab entries\n" + " in /etc/mtab\n\t-n:\tDon't erase /etc/mtab entries\n" #else -"\n" + "\n" #endif #ifdef BB_FEATURE_REMOUNT -"\t-r:\tTry to remount devices as read-only if mount is busy\n" + "\t-r:\tTry to remount devices as read-only if mount is busy\n" #endif ; struct _mtab_entry_t { - char *device; - char *mountpt; - struct _mtab_entry_t *next; + char *device; + char *mountpt; + struct _mtab_entry_t *next; }; static struct _mtab_entry_t *mtab_cache = NULL; @@ -55,113 +55,112 @@ static struct _mtab_entry_t *mtab_cache = NULL; static int useMtab = TRUE; static int umountAll = FALSE; static int doRemount = FALSE; -extern const char mtab_file[]; /* Defined in utility.c */ +extern const char mtab_file[]; /* Defined in utility.c */ #define MIN(x,y) (x > y ? x : y) -static int -do_umount(const char* name, int useMtab) +static int do_umount(const char *name, int useMtab) { - int status; - char *blockDevice = mtab_getinfo(name, MTAB_GETDEVICE); + int status; + char *blockDevice = mtab_getinfo(name, MTAB_GETDEVICE); - if (blockDevice && strcmp(blockDevice, name) == 0) - name = mtab_getinfo(blockDevice, MTAB_GETMOUNTPT); + if (blockDevice && strcmp(blockDevice, name) == 0) + name = mtab_getinfo(blockDevice, MTAB_GETMOUNTPT); - status = umount(name); + status = umount(name); #if defined BB_FEATURE_MOUNT_LOOP - if (blockDevice != NULL && !strncmp("/dev/loop", blockDevice, 9)) - /* this was a loop device, delete it */ - del_loop(blockDevice); + if (blockDevice != NULL && !strncmp("/dev/loop", blockDevice, 9)) + /* this was a loop device, delete it */ + del_loop(blockDevice); #endif #if defined BB_FEATURE_REMOUNT - if ( status != 0 && doRemount == TRUE && errno == EBUSY ) { - status = mount(blockDevice, name, NULL, - MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL); - if (status == 0) { - fprintf(stderr, "umount: %s busy - remounted read-only\n", - blockDevice); - /* TODO: update mtab if BB_MTAB is defined */ - } else { - fprintf(stderr, "umount: Cannot remount %s read-only\n", - blockDevice); + if (status != 0 && doRemount == TRUE && errno == EBUSY) { + status = mount(blockDevice, name, NULL, + MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL); + if (status == 0) { + fprintf(stderr, "umount: %s busy - remounted read-only\n", + blockDevice); + /* TODO: update mtab if BB_MTAB is defined */ + } else { + fprintf(stderr, "umount: Cannot remount %s read-only\n", + blockDevice); + } } - } #endif - if ( status == 0 ) { + if (status == 0) { #if defined BB_MTAB - if ( useMtab==TRUE ) - erase_mtab(name); + if (useMtab == TRUE) + erase_mtab(name); #endif - return( TRUE); - } - return(FALSE); + return (TRUE); + } + return (FALSE); } -static int -umount_all(int useMtab) +static int umount_all(int useMtab) { int status = TRUE; char *mountpt; void *iter; for (mountpt = mtab_first(&iter); mountpt; mountpt = mtab_next(&iter)) { - status=do_umount (mountpt, useMtab); - if (status != 0) { - /* Don't bother retrying the umount on busy devices */ - if (errno == EBUSY) { - perror(mountpt); - continue; - } - status = do_umount (mountpt, useMtab); + status = do_umount(mountpt, useMtab); if (status != 0) { - printf ("Couldn't umount %s on %s: %s\n", - mountpt, mtab_getinfo(mountpt, MTAB_GETDEVICE), strerror(errno)); + /* Don't bother retrying the umount on busy devices */ + if (errno == EBUSY) { + perror(mountpt); + continue; + } + status = do_umount(mountpt, useMtab); + if (status != 0) { + printf("Couldn't umount %s on %s: %s\n", + mountpt, mtab_getinfo(mountpt, MTAB_GETDEVICE), + strerror(errno)); + } } - } - } - return (status); + } + return (status); } -extern int -umount_main(int argc, char** argv) +extern int umount_main(int argc, char **argv) { - if (argc < 2) { - usage( umount_usage); - } - - /* Parse any options */ - while (--argc > 0 && **(++argv) == '-') { - while (*++(*argv)) switch (**argv) { - case 'a': - umountAll = TRUE; - break; + if (argc < 2) { + usage(umount_usage); + } + + /* Parse any options */ + while (--argc > 0 && **(++argv) == '-') { + while (*++(*argv)) + switch (**argv) { + case 'a': + umountAll = TRUE; + break; #ifdef BB_MTAB - case 'n': - useMtab = FALSE; - break; + case 'n': + useMtab = FALSE; + break; #endif #ifdef BB_FEATURE_REMOUNT - case 'r': - doRemount = TRUE; - break; + case 'r': + doRemount = TRUE; + break; #endif - default: - usage( umount_usage); + default: + usage(umount_usage); + } + } + + mtab_read(); + if (umountAll == TRUE) { + exit(umount_all(useMtab)); + } + if (do_umount(*argv, useMtab) == 0) + exit(TRUE); + else { + perror("umount"); + exit(FALSE); } - } - - mtab_read(); - if (umountAll==TRUE) { - exit(umount_all(useMtab)); - } - if ( do_umount(*argv,useMtab) == 0 ) - exit (TRUE); - else { - perror("umount"); - exit(FALSE); - } } @@ -172,79 +171,89 @@ umount_main(int argc, char** argv) */ void mtab_read(void) { - struct _mtab_entry_t *entry = NULL; - struct mntent *e; - FILE *fp; - - if (mtab_cache != NULL) return; - - if ((fp = setmntent(mtab_file, "r")) == NULL) { - fprintf(stderr, "Cannot open %s\n", mtab_file); - return; - } - while ((e = getmntent(fp))) { - entry = malloc(sizeof(struct _mtab_entry_t)); - entry->device = strdup(e->mnt_fsname); - entry->mountpt = strdup(e->mnt_dir); - entry->next = mtab_cache; - mtab_cache = entry; - } - endmntent(fp); + struct _mtab_entry_t *entry = NULL; + struct mntent *e; + FILE *fp; + + if (mtab_cache != NULL) + return; + + if ((fp = setmntent(mtab_file, "r")) == NULL) { + fprintf(stderr, "Cannot open %s\n", mtab_file); + return; + } + while ((e = getmntent(fp))) { + entry = malloc(sizeof(struct _mtab_entry_t)); + + entry->device = strdup(e->mnt_fsname); + entry->mountpt = strdup(e->mnt_dir); + entry->next = mtab_cache; + mtab_cache = entry; + } + endmntent(fp); } char *mtab_getinfo(const char *match, const char which) { - struct _mtab_entry_t *cur = mtab_cache; - while (cur) { - if (strcmp(cur->mountpt, match) == 0 || - strcmp(cur->device, match) == 0) { - if (which == MTAB_GETMOUNTPT) { - return cur->mountpt; - } else { + struct _mtab_entry_t *cur = mtab_cache; + + while (cur) { + if (strcmp(cur->mountpt, match) == 0 || + strcmp(cur->device, match) == 0) { + if (which == MTAB_GETMOUNTPT) { + return cur->mountpt; + } else { #if !defined BB_MTAB - if (strcmp(cur->device, "/dev/root") == 0) { - struct fstab* fstabItem; - fstabItem = getfsfile ("/"); - if (fstabItem != NULL) return fstabItem->fs_spec; - } + if (strcmp(cur->device, "/dev/root") == 0) { + struct fstab *fstabItem; + + fstabItem = getfsfile("/"); + if (fstabItem != NULL) + return fstabItem->fs_spec; + } #endif - return cur->device; - } + return cur->device; + } + } + cur = cur->next; } - cur = cur->next; - } - return NULL; + return NULL; } char *mtab_first(void **iter) { - struct _mtab_entry_t *mtab_iter; - if (!iter) return NULL; - mtab_iter = mtab_cache; - *iter = (void *)mtab_iter; - return mtab_next(iter); + struct _mtab_entry_t *mtab_iter; + + if (!iter) + return NULL; + mtab_iter = mtab_cache; + *iter = (void *) mtab_iter; + return mtab_next(iter); } char *mtab_next(void **iter) { - char *mp; - if (iter == NULL || *iter == NULL) return NULL; - mp = ((struct _mtab_entry_t *)(*iter))->mountpt; - *iter = (void *)((struct _mtab_entry_t *)(*iter))->next; - return mp; + char *mp; + + if (iter == NULL || *iter == NULL) + return NULL; + mp = ((struct _mtab_entry_t *) (*iter))->mountpt; + *iter = (void *) ((struct _mtab_entry_t *) (*iter))->next; + return mp; } void mtab_free(void) { - struct _mtab_entry_t *this, *next; - - this = mtab_cache; - while (this) { - next = this->next; - if (this->device) free(this->device); - if (this->mountpt) free(this->mountpt); - free(this); - this = next; - } -} + struct _mtab_entry_t *this, *next; + this = mtab_cache; + while (this) { + next = this->next; + if (this->device) + free(this->device); + if (this->mountpt) + free(this->mountpt); + free(this); + this = next; + } +} -- cgit v1.2.3