disk-utils/mkfs.bfs.c

   1 /*
   2  *  mkfs.bfs - Create SCO BFS filesystem - aeb, 1999-09-07
   3  *
   4  *      Usage: mkfs.bfs [-N nr-of-inodes] [-V volume-name] [-F fsname] device
   5  */
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <getopt.h>
  10 #include <limits.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <sys/stat.h>
  15 #include <time.h>
  16 #include <unistd.h>
  17
  18 #include "blkdev.h"
  19 #include "c.h"
  20 #include "closestream.h"
  21 #include "nls.h"
  22 #include "strutils.h"
  23 #include "xalloc.h"
  24 #include "bitops.h"
  25
  26 #define BFS_ROOT_INO            2
  27 #define BFS_NAMELEN             14
  28 #define BFS_BLOCKSIZE           512
  29 #define BFS_SUPER_MAGIC         0x1badface
  30
  31 /* superblock - 512 bytes */
  32 struct bfssb {
  33         uint32_t s_magic;
  34         uint32_t s_start;       /* byte offset of start of data */
  35         uint32_t s_end; /* sizeof(slice)-1 */
  36
  37         /* for recovery during compaction */
  38         uint32_t s_from, s_to;  /* src and dest block of current transfer */
  39         int32_t s_backup_from, s_backup_to;
  40
  41         /* labels - may well contain garbage */
  42         char s_fsname[6];
  43         char s_volume[6];
  44         char s_pad[472];
  45 };
  46
  47 /* inode - 64 bytes */
  48 struct bfsi {
  49         uint16_t i_ino;
  50         unsigned char i_pad1[2];
  51         uint32_t i_first_block;
  52         uint32_t i_last_block;
  53         uint32_t i_bytes_to_end;
  54         uint32_t i_type;        /* 1: file, 2: the unique dir */
  55         uint32_t i_mode;
  56         uint32_t i_uid, i_gid;
  57         uint32_t i_nlinks;
  58         uint32_t i_atime, i_mtime, i_ctime;
  59         unsigned char i_pad2[16];
  60 };
  61
  62 #define BFS_DIR_TYPE    2
  63
  64 /* directory entry - 16 bytes */
  65 struct bfsde {
  66         uint16_t d_ino;
  67         char d_name[BFS_NAMELEN];
  68 };
  69
  70 static void __attribute__((__noreturn__)) usage(void)
  71 {
  72         FILE *out = stdout;
  73         fprintf(out,
  74                 _("Usage: %s [options] device [block-count]\n"),
  75                 program_invocation_short_name);
  76
  77         fputs(USAGE_SEPARATOR, out);
  78         fputs(_("Make an SCO bfs filesystem.\n"), out);
  79
  80         fprintf(out, _("\nOptions:\n"
  81                        " -N, --inodes=NUM    specify desired number of inodes\n"
  82                        " -V, --vname=NAME    specify volume name\n"
  83                        " -F, --fname=NAME    specify file system name\n"
  84                        " -v, --verbose       explain what is being done\n"
  85                        " -c                  this option is silently ignored\n"
  86                        " -l                  this option is silently ignored\n"
  87                        " -V, --version       output version information and exit\n"
  88                        "                     -V as version must be only option\n"
  89                        " -h, --help          display this help and exit\n\n"));
  90
  91         fprintf(out, USAGE_MAN_TAIL("mkfs.bfs(8)"));
  92         exit(EXIT_SUCCESS);
  93 }
  94
  95 static void __attribute__ ((__noreturn__)) print_version(void)
  96 {
  97         printf(UTIL_LINUX_VERSION);
  98         exit(EXIT_SUCCESS);
  99 }
 100
 101 int main(int argc, char **argv)
 102 {
 103         char *device, *volume, *fsname;
 104         long inodes;
 105         unsigned long long total_blocks, ino_bytes, ino_blocks, data_blocks;
 106         unsigned long long user_specified_total_blocks = 0;
 107         int verbose = 0;
 108         int fd;
 109         uint32_t first_block;
 110         struct bfssb sb;
 111         struct bfsi ri;
 112         struct bfsde de;
 113         struct stat statbuf;
 114         time_t now;
 115         int c, i, len;
 116
 117         enum { VERSION_OPTION = CHAR_MAX + 1 };
 118         static const struct option longopts[] = {
 119                 {"inodes", required_argument, NULL, 'N'},
 120                 {"vname", required_argument, NULL, 'V'},
 121                 {"fname", required_argument, NULL, 'F'},
 122                 {"verbose", no_argument, NULL, 'v'},
 123                 {"version", no_argument, NULL, VERSION_OPTION},
 124                 {"help", no_argument, NULL, 'h'},
 125                 {NULL, 0, NULL, 0}
 126         };
 127
 128         setlocale(LC_ALL, "");
 129         bindtextdomain(PACKAGE, LOCALEDIR);
 130         textdomain(PACKAGE);
 131         atexit(close_stdout);
 132
 133         if (argc < 2) {
 134                 warnx(_("not enough arguments"));
 135                 errtryhelp(EXIT_FAILURE);
 136         }
 137         if (argc == 2 && !strcmp(argv[1], "-V"))
 138                 print_version();
 139
 140         volume = fsname = "      ";     /* is there a default? */
 141         inodes = 0;
 142
 143         while ((c = getopt_long(argc, argv, "N:V:F:vhcl", longopts, NULL)) != -1) {
 144                 switch (c) {
 145                 case 'N':
 146                         inodes = strtol_or_err(optarg, _("invalid number of inodes"));
 147                         break;
 148
 149                 case 'V':
 150                         len = strlen(optarg);
 151                         if (len <= 0 || len > 6)
 152                                 errx(EXIT_FAILURE, _("volume name too long"));
 153                         volume = xstrdup(optarg);
 154                         break;
 155
 156                 case 'F':
 157                         len = strlen(optarg);
 158                         if (len <= 0 || len > 6)
 159                                 errx(EXIT_FAILURE, _("fsname name too long"));
 160                         fsname = xstrdup(optarg);
 161                         break;
 162
 163                 case 'v':
 164                         verbose = 1;
 165                         break;
 166
 167                 case 'c':
 168                 case 'l':
 169                         /* when called via mkfs we may get options c,l,v */
 170                         break;
 171
 172                 case VERSION_OPTION:
 173                         print_version();
 174                 case 'h':
 175                         usage();
 176                 default:
 177                         errtryhelp(EXIT_FAILURE);
 178                 }
 179         }
 180
 181         if (optind == argc) {
 182                 warnx(_("no device specified"));
 183                 errtryhelp(EXIT_FAILURE);
 184         }
 185
 186         device = argv[optind++];
 187
 188         if (stat(device, &statbuf) < 0)
 189                 err(EXIT_FAILURE, _("stat of %s failed"), device);
 190
 191         fd = open_blkdev_or_file(&statbuf, device, O_RDWR);
 192         if (fd < 0)
 193                 err(EXIT_FAILURE, _("cannot open %s"), device);
 194
 195         if (optind == argc - 1)
 196                 user_specified_total_blocks =
 197                         strtou64_or_err(argv[optind], _("invalid block-count"));
 198         else if (optind != argc) {
 199                 warnx(_("bad usage"));
 200                 errtryhelp(EXIT_FAILURE);
 201         }
 202
 203         if (blkdev_get_sectors(fd, &total_blocks) == -1) {
 204                 if (!user_specified_total_blocks)
 205                         err(EXIT_FAILURE, _("cannot get size of %s"), device);
 206                 total_blocks = user_specified_total_blocks;
 207         } else if (user_specified_total_blocks) {
 208                 if (user_specified_total_blocks > total_blocks)
 209                         errx(EXIT_FAILURE,
 210                              _("blocks argument too large, max is %llu"),
 211                              total_blocks);
 212                 total_blocks = user_specified_total_blocks;
 213         }
 214
 215         if (!inodes) {
 216                 /* pick some reasonable default */
 217                 inodes = 8 * (total_blocks / 800);
 218                 if (inodes < 48)
 219                         inodes = 48;
 220                 if (512 < inodes)
 221                         inodes = 512;
 222         } else {
 223                 /* believe the user */
 224                 if (512 < inodes)
 225                         errx(EXIT_FAILURE, _("too many inodes - max is 512"));
 226         }
 227
 228         ino_bytes = inodes * sizeof(struct bfsi);
 229         ino_blocks = (ino_bytes + BFS_BLOCKSIZE - 1) / BFS_BLOCKSIZE;
 230         data_blocks = total_blocks - ino_blocks - 1;
 231
 232         /* mimic the behavior of SCO's mkfs - maybe this limit is needed */
 233         if (data_blocks < 32)
 234                 errx(EXIT_FAILURE,
 235                      _("not enough space, need at least %llu blocks"),
 236                      ino_blocks + 33);
 237
 238         memset(&sb, 0, sizeof(sb));
 239         sb.s_magic = cpu_to_le32(BFS_SUPER_MAGIC);
 240         sb.s_start = cpu_to_le32(ino_bytes + sizeof(struct bfssb));
 241         sb.s_end = cpu_to_le32(total_blocks * BFS_BLOCKSIZE - 1);
 242         sb.s_from = sb.s_to = sb.s_backup_from = sb.s_backup_to = -1;
 243         memcpy(sb.s_fsname, fsname, 6);
 244         memcpy(sb.s_volume, volume, 6);
 245
 246         if (verbose) {
 247                 fprintf(stderr, _("Device: %s\n"), device);
 248                 fprintf(stderr, _("Volume: <%-6s>\n"), volume);
 249                 fprintf(stderr, _("FSname: <%-6s>\n"), fsname);
 250                 fprintf(stderr, _("BlockSize: %d\n"), BFS_BLOCKSIZE);
 251                 if (ino_blocks == 1)
 252                         fprintf(stderr, _("Inodes: %ld (in 1 block)\n"),
 253                                 inodes);
 254                 else
 255                         fprintf(stderr, _("Inodes: %ld (in %llu blocks)\n"),
 256                                 inodes, ino_blocks);
 257                 fprintf(stderr, _("Blocks: %llu\n"), total_blocks);
 258                 fprintf(stderr, _("Inode end: %d, Data end: %d\n"),
 259                         le32_to_cpu(sb.s_start) - 1, le32_to_cpu(sb.s_end));
 260         }
 261
 262         if (write(fd, &sb, sizeof(sb)) != sizeof(sb))
 263                 err(EXIT_FAILURE, _("error writing superblock"));
 264
 265         memset(&ri, 0, sizeof(ri));
 266         ri.i_ino = cpu_to_le16(BFS_ROOT_INO);
 267         first_block = 1 + ino_blocks;
 268         ri.i_first_block = cpu_to_le32(first_block);
 269         ri.i_last_block = cpu_to_le32(first_block +
 270             (inodes * sizeof(de) - 1) / BFS_BLOCKSIZE);
 271         ri.i_bytes_to_end = cpu_to_le32(first_block * BFS_BLOCKSIZE
 272             + 2 * sizeof(struct bfsde) - 1);
 273         ri.i_type = cpu_to_le32(BFS_DIR_TYPE);
 274         ri.i_mode = cpu_to_le32(S_IFDIR | 0755);        /* or just 0755 */
 275         ri.i_uid = cpu_to_le32(0);
 276         ri.i_gid = cpu_to_le32(1);                      /* random */
 277         ri.i_nlinks = 2;
 278         time(&now);
 279         ri.i_atime = cpu_to_le32(now);
 280         ri.i_mtime = cpu_to_le32(now);
 281         ri.i_ctime = cpu_to_le32(now);
 282
 283         if (write(fd, &ri, sizeof(ri)) != sizeof(ri))
 284                 err(EXIT_FAILURE, _("error writing root inode"));
 285
 286         memset(&ri, 0, sizeof(ri));
 287         for (i = 1; i < inodes; i++)
 288                 if (write(fd, &ri, sizeof(ri)) != sizeof(ri))
 289                         err(EXIT_FAILURE, _("error writing inode"));
 290
 291         if (lseek(fd, (1 + ino_blocks) * BFS_BLOCKSIZE, SEEK_SET) == -1)
 292                 err(EXIT_FAILURE, _("seek error"));
 293
 294         memset(&de, 0, sizeof(de));
 295         de.d_ino = cpu_to_le16(BFS_ROOT_INO);
 296         memcpy(de.d_name, ".", 1);
 297         if (write(fd, &de, sizeof(de)) != sizeof(de))
 298                 err(EXIT_FAILURE, _("error writing . entry"));
 299
 300         memcpy(de.d_name, "..", 2);
 301         if (write(fd, &de, sizeof(de)) != sizeof(de))
 302                 err(EXIT_FAILURE, _("error writing .. entry"));
 303
 304         if (close_fd(fd) != 0)
 305                 err(EXIT_FAILURE, _("error closing %s"), device);
 306
 307         return EXIT_SUCCESS;
 308 }