obsolete-buildroot/sources/genext2fs.patch

   1 diff -urN genext2fs-1.3.orig/Makefile genext2fs-1.3/Makefile
   2 --- genext2fs-1.3.orig/Makefile 1969-12-31 17:00:00.000000000 -0700
   3 +++ genext2fs-1.3/Makefile      2003-04-21 01:41:42.000000000 -0600
   4 @@ -0,0 +1,46 @@
   5 +CC=gcc
   6 +CFLAGS=-Wall -O0 -g
   7 +
   8 +SRC=genext2fs.c
   9 +OBJS=$(patsubst %.c,%.o, $(SRC))
  10 +
  11 +all: genext2fs
  12 +INSTALL=install
  13 +
  14 +genext2fs: $(OBJS)
  15 +       $(CC) $(CFLAGS) -o $@ $(OBJS) -o $@
  16 +
  17 +$(OBJS): %.o : %.c
  18 +       $(CC) $(CFLAGS) -c $< -o $@
  19 +
  20 +$(OBJS): Makefile
  21 +
  22 +install:
  23 +       $(INSTALL) -d $(DESTDIR)/usr/bin/
  24 +       $(INSTALL) -m 755 genext2fs $(DESTDIR)/usr/bin/
  25 +       $(INSTALL) -d $(DESTDIR)/usr/share/man/man8/
  26 +       $(INSTALL) -m 644 genext2fs.8 $(DESTDIR)/usr/share/man/man8/
  27 +
  28 +clean:
  29 +       rm -rf *.o *.a core genext2fs
  30 +       rm -rf test ext2.img
  31 +
  32 +check: all
  33 +       mkdir -p test
  34 +       dd if=/dev/zero of=test/zero count=1
  35 +       ./genext2fs -b 4096 -d test ext2.img
  36 +
  37 +       md5=`md5sum ext2.img | cut -f 1 -d " "`; \
  38 +       if [ "$$md5" != "89471302d95f96a76fbb2cff98182cde" ] ; then \
  39 +               echo "test failed."; \
  40 +       else \
  41 +               echo "test succeeded."; \
  42 +       fi
  43 +
  44 +# test genext2fs by creating the image and comparing checksums
  45 +test: all
  46 +       sh ./test.sh
  47 +
  48 +# test genext2fs by actually mounting the created image.
  49 +test-mount: all
  50 +       sudo sh ./test-mount.sh
  51 diff -urN genext2fs-1.3.orig/debian/changelog genext2fs-1.3/debian/changelog
  52 --- genext2fs-1.3.orig/debian/changelog 1969-12-31 17:00:00.000000000 -0700
  53 +++ genext2fs-1.3/debian/changelog      2003-04-21 01:41:42.000000000 -0600
  54 @@ -0,0 +1,17 @@
  55 +genext2fs (1.3-2) unstable; urgency=low
  56 +
  57 +  * apply fix from upstream cvs that appears to fix endian bug
  58 +    (closes: #122411)
  59 +  * mention filesystem size limit in manpage (closes: #122729)
  60 +  * mention that hard links are not supported in manpage
  61 +    (closes: #155464)
  62 +  * add sanity check at the end of the build
  63 +
  64 + -- David Kimdon <dwhedon@debian.org>  Fri,  8 Mar 2002 23:17:36 -0800
  65 +
  66 +genext2fs (1.3-1) unstable; urgency=low
  67 +
  68 +  * Initial Release. (closes: #105263)
  69 +
  70 + -- David Kimdon <dwhedon@debian.org>  Sat, 14 Jul 2001 13:24:49 -0700
  71 +
  72 diff -urN genext2fs-1.3.orig/debian/control genext2fs-1.3/debian/control
  73 --- genext2fs-1.3.orig/debian/control   1969-12-31 17:00:00.000000000 -0700
  74 +++ genext2fs-1.3/debian/control        2003-04-21 01:41:42.000000000 -0600
  75 @@ -0,0 +1,19 @@
  76 +Source: genext2fs
  77 +Section: admin
  78 +Priority: optional
  79 +Maintainer: David Kimdon <dwhedon@debian.org>
  80 +Build-Depends: debhelper (>> 3.0.0)
  81 +Standards-Version: 3.5.2
  82 +
  83 +Package: genext2fs
  84 +Architecture: any
  85 +Depends: ${shlibs:Depends}
  86 +Description: ext2 filesystem generator for embedded systems
  87 + `genext2fs' is meant to generate an ext2 filesystem
  88 + as a normal (non-root) user. It doesn't require you to mount
  89 + the image file to copy files on it. It doesn't even require
  90 + you to be the superuser to make device nodes.
  91 + .
  92 + Warning ! `genext2fs' has been designed for embedded
  93 + systems. As such, it will generate a filesystem for single-user
  94 + usage: all files/directories/etc... will belong to UID/GID 0
  95 diff -urN genext2fs-1.3.orig/debian/copyright genext2fs-1.3/debian/copyright
  96 --- genext2fs-1.3.orig/debian/copyright 1969-12-31 17:00:00.000000000 -0700
  97 +++ genext2fs-1.3/debian/copyright      2003-04-21 01:41:42.000000000 -0600
  98 @@ -0,0 +1,15 @@
  99 +This package was debianized by David Kimdon <dwhedon@debian.org> on
 100 +Sat, 14 Jul 2001 13:24:49 -0700.
 101 +
 102 +It was downloaded from http://freshmeat.net/projects/genext2fs/
 103 +Upstream Author(s):   Xavier Bestel <xbestel@aplio.fr>
 104 +
 105 +Copyright (C) 2000 Xavier Bestel <xavier.bestel@free.fr>
 106 +
 107 +This program is free software; you can redistribute it and/or
 108 +modify it under the terms of the GNU General Public License
 109 +as published by the Free Software Foundation; version
 110 +2 of the License.
 111 +
 112 +On Debian systems, the complete text of the GNU General Public
 113 +License can be found in /usr/share/common-licenses/GPL file.
 114 diff -urN genext2fs-1.3.orig/debian/rules genext2fs-1.3/debian/rules
 115 --- genext2fs-1.3.orig/debian/rules     1969-12-31 17:00:00.000000000 -0700
 116 +++ genext2fs-1.3/debian/rules  2003-04-21 01:41:42.000000000 -0600
 117 @@ -0,0 +1,70 @@
 118 +#!/usr/bin/make -f
 119 +# Sample debian/rules that uses debhelper.
 120 +# GNU copyright 1997 to 1999 by Joey Hess.
 121 +
 122 +# Uncomment this to turn on verbose mode.
 123 +#export DH_VERBOSE=1
 124 +
 125 +# This is the debhelper compatability version to use.
 126 +export DH_COMPAT=2
 127 +
 128 +configure: configure-stamp
 129 +configure-stamp:
 130 +       dh_testdir
 131 +       # Add here commands to configure the package.
 132 +       # ./configure --prefix=/usr --mandir=/usr/share/man/
 133 +
 134 +       touch configure-stamp
 135 +
 136 +build: configure-stamp build-stamp
 137 +build-stamp:
 138 +       dh_testdir
 139 +
 140 +       # Add here commands to compile the package.
 141 +       $(MAKE)
 142 +       $(MAKE) check
 143 +
 144 +       touch build-stamp
 145 +
 146 +clean:
 147 +       dh_testdir
 148 +       dh_testroot
 149 +       rm -f build-stamp configure-stamp
 150 +
 151 +       # Add here commands to clean up after the build process.
 152 +       -$(MAKE) clean
 153 +
 154 +       dh_clean
 155 +
 156 +install: build
 157 +       dh_testdir
 158 +       dh_testroot
 159 +       dh_clean -k
 160 +       dh_installdirs
 161 +
 162 +       # Add here commands to install the package into debian/genext2fs.
 163 +       $(MAKE) install DESTDIR=`pwd`/debian/genext2fs
 164 +
 165 +
 166 +# Build architecture-independent files here.
 167 +binary-indep: build install
 168 +# We have nothing to do by default.
 169 +
 170 +# Build architecture-dependent files here.
 171 +binary-arch: build install
 172 +       dh_testdir
 173 +       dh_testroot
 174 +       dh_installdocs
 175 +       dh_installchangelogs
 176 +       dh_link
 177 +       dh_strip
 178 +       dh_compress
 179 +       dh_fixperms
 180 +       dh_installdeb
 181 +       dh_shlibdeps
 182 +       dh_gencontrol
 183 +       dh_md5sums
 184 +       dh_builddeb
 185 +
 186 +binary: binary-indep binary-arch
 187 +.PHONY: build clean binary-indep binary-arch binary install configure
 188 diff -urN genext2fs-1.3.orig/dev.txt genext2fs-1.3/dev.txt
 189 --- genext2fs-1.3.orig/dev.txt  2000-09-28 09:03:19.000000000 -0600
 190 +++ genext2fs-1.3/dev.txt       1969-12-31 17:00:00.000000000 -0700
 191 @@ -1,94 +0,0 @@
 192 -drwx           /dev
 193 -crw-   10,190  /dev/lcd
 194 -crw-   10,191  /dev/splc781
 195 -crw-   4,0     /dev/console
 196 -crw-   5,64    /dev/cua0
 197 -crw-   5,65    /dev/cua1
 198 -crw-   5,66    /dev/cua2
 199 -crw-   5,70    /dev/cua6
 200 -crw-   5,71    /dev/cua7
 201 -crw-   5,72    /dev/cua8
 202 -crw-   5,73    /dev/cua9
 203 -crw-   29,0    /dev/fb0
 204 -crw-   29,32   /dev/fb1
 205 -crw-   1,2     /dev/kmem
 206 -crw-   1,1     /dev/mem
 207 -crw-   1,3     /dev/null
 208 -crw-   2,2     /dev/ptyp2
 209 -crw-   2,3     /dev/ptyp3
 210 -crw-   2,5     /dev/ptyp5
 211 -crw-   2,4     /dev/ptyp4
 212 -crw-   10,178  /dev/triokb
 213 -crw-   2,0     /dev/ptyp0
 214 -crw-   2,6     /dev/ptyp6
 215 -crw-   2,7     /dev/ptyp7
 216 -crw-   2,8     /dev/ptyp8
 217 -crw-   2,9     /dev/ptyp9
 218 -crw-   2,10    /dev/ptypa
 219 -crw-   2,11    /dev/ptypb
 220 -crw-   2,12    /dev/ptypc
 221 -crw-   2,13    /dev/ptypd
 222 -crw-   2,14    /dev/ptype
 223 -crw-   2,15    /dev/ptypf
 224 -brw-   1,0     /dev/ram0
 225 -brw-   1,1     /dev/ram1
 226 -brw-   1,2     /dev/ram2
 227 -brw-   1,3     /dev/ram3
 228 -br--   31,0    /dev/rom0
 229 -brw-   31,1    /dev/rom1
 230 -brw-   31,2    /dev/rom2
 231 -brw-   31,3    /dev/rom3
 232 -crw-   5,0     /dev/tty
 233 -crw-   4,0     /dev/tty0
 234 -crwx   4,1     /dev/tty1
 235 -crwx   4,2     /dev/tty2
 236 -crwx   4,3     /dev/tty3
 237 -crwx   4,4     /dev/tty4
 238 -crw-   4,5     /dev/tty5
 239 -crwx   4,6     /dev/tty6
 240 -crw-   4,7     /dev/tty7
 241 -crw-   4,8     /dev/tty8
 242 -crw-   4,9     /dev/tty9
 243 -crw-   4,64    /dev/ttyS0
 244 -crw-   4,65    /dev/ttyS1
 245 -crw-   4,66    /dev/ttyS2
 246 -crw-   4,67    /dev/ttyS3
 247 -crw-   4,68    /dev/ttyS4
 248 -crw-   4,69    /dev/ttyS5
 249 -crw-   4,70    /dev/ttyS6
 250 -crw-   4,71    /dev/ttyS7
 251 -crw-   4,72    /dev/ttyS8
 252 -crw-   4,73    /dev/ttyS9
 253 -crw-   3,0     /dev/ttyp0
 254 -crw-   3,1     /dev/ttyp1
 255 -crw-   3,2     /dev/ttyp2
 256 -crw-   3,3     /dev/ttyp3
 257 -crw-   3,4     /dev/ttyp4
 258 -crw-   3,5     /dev/ttyp5
 259 -crw-   3,6     /dev/ttyp6
 260 -crw-   3,7     /dev/ttyp7
 261 -crw-   3,8     /dev/ttyp8
 262 -crw-   3,9     /dev/ttyp9
 263 -crw-   3,10    /dev/ttypa
 264 -crw-   3,11    /dev/ttypb
 265 -crw-   3,12    /dev/ttypc
 266 -crw-   3,13    /dev/ttypd
 267 -crw-   3,14    /dev/ttype
 268 -crw-   3,15    /dev/ttypf
 269 -crw-   1,5     /dev/zero
 270 -crwx   10,111  /dev/dtedrv
 271 -crwx   4,110   /dev/ttyM
 272 -crw-   77,1    /dev/tssnd
 273 -crw-   77,2    /dev/tstone
 274 -crw-   2,1     /dev/ptyp1
 275 -crwx   10,180  /dev/triohook
 276 -crw-   90,0    /dev/mtd0
 277 -brw-   44,0    /dev/ftl0
 278 -crw-   10,175  /dev/tporta
 279 -crw-   10,176  /dev/tportb
 280 -crwx   10,100  /dev/softmodem
 281 -crwx   10,101  /dev/softmodem_signals
 282 -crwx   10,181  /dev/triovoice
 283 -crw-   5,67    /dev/cua3
 284 -crw-   5,68    /dev/cua4
 285 -crw-   5,69    /dev/cua5
 286 diff -urN genext2fs-1.3.orig/device_table.txt genext2fs-1.3/device_table.txt
 287 --- genext2fs-1.3.orig/device_table.txt 1969-12-31 17:00:00.000000000 -0700
 288 +++ genext2fs-1.3/device_table.txt      2003-04-21 01:41:42.000000000 -0600
 289 @@ -0,0 +1,129 @@
 290 +# When building a target filesystem, it is desirable to not have to
 291 +# become root and then run 'mknod' a thousand times.  Using a device
 292 +# table you can create device nodes and directories "on the fly".
 293 +#
 294 +# This is a sample device table file for use with genext2fs.  You can
 295 +# do all sorts of interesting things with a device table file.  For
 296 +# example, if you want to adjust the permissions on a particular file
 297 +# you can just add an entry like:
 298 +#   /sbin/foobar        f       2755    0       0       -       -       -       -       -
 299 +# and (assuming the file /sbin/foobar exists) it will be made setuid
 300 +# root (regardless of what its permissions are on the host filesystem.
 301 +# Furthermore, you can use a single table entry to create a many device
 302 +# minors.  For example, if I wanted to create /dev/hda and /dev/hda[0-15]
 303 +# I could just use the following two table entries:
 304 +#   /dev/hda    b       640     0       0       3       0       0       0       -
 305 +#   /dev/hda    b       640     0       0       3       1       1       1       15
 306 +#
 307 +# Device table entries take the form of:
 308 +# <name>    <type>      <mode>  <uid>   <gid>   <major> <minor> <start> <inc>   <count>
 309 +# where name is the file name,  type can be one of:
 310 +#       f       A regular file
 311 +#       d       Directory
 312 +#       c       Character special device file
 313 +#       b       Block special device file
 314 +#       p       Fifo (named pipe)
 315 +# uid is the user id for the target file, gid is the group id for the
 316 +# target file.  The rest of the entries (major, minor, etc) apply only
 317 +# to device special files.
 318 +
 319 +# Have fun
 320 +# -Erik Andersen <andersen@codepoet.org>
 321 +#
 322 +
 323 +#<name>                <type>  <mode>  <uid>   <gid>   <major> <minor> <start> <inc>   <count>
 324 +/dev           d       755     0       0       -       -       -       -       -
 325 +/dev/mem       c       640     0       0       1       1       0       0       -
 326 +/dev/kmem      c       640     0       0       1       2       0       0       -
 327 +/dev/null      c       640     0       0       1       3       0       0       -
 328 +/dev/zero      c       640     0       0       1       5       0       0       -
 329 +/dev/random    c       640     0       0       1       8       0       0       -
 330 +/dev/urandom   c       640     0       0       1       9       0       0       -
 331 +/dev/tty       c       666     0       0       5       0       0       0       -
 332 +/dev/tty       c       666     0       0       4       0       0       1       6
 333 +/dev/console   c       640     0       0       5       1       0       0       -
 334 +/dev/ram       b       640     0       0       1       1       0       0       -
 335 +/dev/ram       b       640     0       0       1       0       0       1       4
 336 +/dev/loop      b       640     0       0       7       0       0       1       2
 337 +/dev/ptmx      c       666     0       0       5       2       0       0       -
 338 +#/dev/ttyS     c       640     0       0       4       64      0       1       4
 339 +#/dev/psaux    c       640     0       0       10      1       0       0       -
 340 +#/dev/rtc      c       640     0       0       10      135     0       0       -
 341 +
 342 +# Adjust permissions on some normal files
 343 +#/etc/shadow   f       600     0       0       -       -       -       -       -
 344 +#/bin/tinylogin        f       4755    0       0       -       -       -       -       -
 345 +
 346 +# User-mode Linux stuff
 347 +/dev/ubda      b       640     0       0       98      0       0       0       -
 348 +/dev/ubda      b       640     0       0       98      1       1       1       15
 349 +
 350 +# IDE Devices
 351 +/dev/hda       b       640     0       0       3       0       0       0       -
 352 +/dev/hda       b       640     0       0       3       1       1       1       15
 353 +/dev/hdb       b       640     0       0       3       64      0       0       -
 354 +/dev/hdb       b       640     0       0       3       65      1       1       15
 355 +#/dev/hdc      b       640     0       0       22      0       0       0       -
 356 +#/dev/hdc      b       640     0       0       22      1       1       1       15
 357 +#/dev/hdd      b       640     0       0       22      64      0       0       -
 358 +#/dev/hdd      b       640     0       0       22      65      1       1       15
 359 +#/dev/hde      b       640     0       0       33      0       0       0       -
 360 +#/dev/hde      b       640     0       0       33      1       1       1       15
 361 +#/dev/hdf      b       640     0       0       33      64      0       0       -
 362 +#/dev/hdf      b       640     0       0       33      65      1       1       15
 363 +#/dev/hdg      b       640     0       0       34      0       0       0       -
 364 +#/dev/hdg      b       640     0       0       34      1       1       1       15
 365 +#/dev/hdh      b       640     0       0       34      64      0       0       -
 366 +#/dev/hdh      b       640     0       0       34      65      1       1       15
 367 +
 368 +# SCSI Devices
 369 +#/dev/sda      b       640     0       0       8       0       0       0       -
 370 +#/dev/sda      b       640     0       0       8       1       1       1       15
 371 +#/dev/sdb      b       640     0       0       8       16      0       0       -
 372 +#/dev/sdb      b       640     0       0       8       17      1       1       15
 373 +#/dev/sdc      b       640     0       0       8       32      0       0       -
 374 +#/dev/sdc      b       640     0       0       8       33      1       1       15
 375 +#/dev/sdd      b       640     0       0       8       48      0       0       -
 376 +#/dev/sdd      b       640     0       0       8       49      1       1       15
 377 +#/dev/sde      b       640     0       0       8       64      0       0       -
 378 +#/dev/sde      b       640     0       0       8       65      1       1       15
 379 +#/dev/sdf      b       640     0       0       8       80      0       0       -
 380 +#/dev/sdf      b       640     0       0       8       81      1       1       15
 381 +#/dev/sdg      b       640     0       0       8       96      0       0       -
 382 +#/dev/sdg      b       640     0       0       8       97      1       1       15
 383 +#/dev/sdh      b       640     0       0       8       112     0       0       -
 384 +#/dev/sdh      b       640     0       0       8       113     1       1       15
 385 +#/dev/sg               c       640     0       0       21      0       0       1       15
 386 +#/dev/scd      b       640     0       0       11      0       0       1       15
 387 +#/dev/st               c       640     0       0       9       0       0       1       8
 388 +#/dev/nst      c       640     0       0       9       128     0       1       8
 389 +#/dev/st       c       640     0       0       9       32      1       1       4
 390 +#/dev/st       c       640     0       0       9       64      1       1       4
 391 +#/dev/st       c       640     0       0       9       96      1       1       4
 392 +
 393 +# Floppy disk devices
 394 +#/dev/fd               b       640     0       0       2       0       0       1       2
 395 +#/dev/fd0d360  b       640     0       0       2       4       0       0       -
 396 +#/dev/fd1d360  b       640     0       0       2       5       0       0       -
 397 +#/dev/fd0h1200 b       640     0       0       2       8       0       0       -
 398 +#/dev/fd1h1200 b       640     0       0       2       9       0       0       -
 399 +#/dev/fd0u1440 b       640     0       0       2       28      0       0       -
 400 +#/dev/fd1u1440 b       640     0       0       2       29      0       0       -
 401 +#/dev/fd0u2880 b       640     0       0       2       32      0       0       -
 402 +#/dev/fd1u2880 b       640     0       0       2       33      0       0       -
 403 +
 404 +# All the proprietary cdrom devices in the world
 405 +#/dev/aztcd    b       640     0       0       29      0       0       0       -
 406 +#/dev/bpcd     b       640     0       0       41      0       0       0       -
 407 +#/dev/capi20   c       640     0       0       68      0       0       1       2
 408 +#/dev/cdu31a   b       640     0       0       15      0       0       0       -
 409 +#/dev/cdu535   b       640     0       0       24      0       0       0       -
 410 +#/dev/cm206cd  b       640     0       0       32      0       0       0       -
 411 +#/dev/sjcd     b       640     0       0       18      0       0       0       -
 412 +#/dev/sonycd   b       640     0       0       15      0       0       0       -
 413 +#/dev/gscd     b       640     0       0       16      0       0       0       -
 414 +#/dev/sbpcd    b       640     0       0       25      0       0       0       -
 415 +#/dev/sbpcd    b       640     0       0       25      0       0       1       4
 416 +#/dev/mcd      b       640     0       0       23      0       0       0       -
 417 +#/dev/optcd    b       640     0       0       17      0       0       0       -
 418 +
 419 diff -urN genext2fs-1.3.orig/genext2fs.8 genext2fs-1.3/genext2fs.8
 420 --- genext2fs-1.3.orig/genext2fs.8      1969-12-31 17:00:00.000000000 -0700
 421 +++ genext2fs-1.3/genext2fs.8   2003-04-21 01:41:42.000000000 -0600
 422 @@ -0,0 +1,125 @@
 423 +.\"                                      Hey, EMACS: -*- nroff -*-
 424 +.\" First parameter, NAME, should be all caps
 425 +.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 426 +.\" other parameters are allowed: see man(7), man(1)
 427 +.TH GENEXT2FS 8 "July 14, 2001"
 428 +.\" Please adjust this date whenever revising the manpage.
 429 +.\"
 430 +.\" Some roff macros, for reference:
 431 +.\" .nh        disable hyphenation
 432 +.\" .hy        enable hyphenation
 433 +.\" .ad l      left justify
 434 +.\" .ad b      justify to both left and right margins
 435 +.\" .nf        disable filling
 436 +.\" .fi        enable filling
 437 +.\" .br        insert line break
 438 +.\" .sp <n>    insert n+1 empty lines
 439 +.\" for manpage-specific macros, see man(7)
 440 +.SH NAME
 441 +genext2fs \- ext2 filesystem generator for embedded systems
 442 +.SH SYNOPSIS
 443 +.B genext2fs
 444 +.RI [ options ]  " image"
 445 +.SH DESCRIPTION
 446 +\fBgenext2fs\fP generates an ext2 filesystem
 447 +as a normal (non-root) user. It doesn't require you to mount
 448 +the image file to copy files on it. It doesn't even require
 449 +you to be the superuser to make device nodes.
 450 +.SH OPTIONS
 451 +.TP
 452 +.BI -x \ image
 453 +Use this image as a starting point
 454 +.TP
 455 +.BI -d \ directory
 456 +Add this directory as source
 457 +.TP
 458 +.BI -f \ FILE
 459 +.TP
 460 +.BI -D \ FILE
 461 +Uses the named FILE as a device table file, to create device
 462 +nodes and directories "on the fly".
 463 +.TP
 464 +.BI -b \ blocks
 465 +Size in blocks
 466 +.TP
 467 +.BI -i \ inodes
 468 +Number of inodes
 469 +.TP
 470 +.BI -r \ reserved
 471 +Number of reserved blocks
 472 +.TP
 473 +.BI -g \ path
 474 +Generate a block map file for this path
 475 +.TP
 476 +.BI -e \ value
 477 +Fill unallocated blocks with value
 478 +.TP
 479 +.BI -z
 480 +Make files with holes
 481 +.TP
 482 +.BI -U
 483 +Squash owners making all files be owned by root
 484 +.TP
 485 +.BI -P
 486 +Squash permissions on all files
 487 +.TP
 488 +.BI -q
 489 +Squash permissions and owners (same as -P -U)
 490 +.TP
 491 +.BI -v
 492 +Print resulting filesystem structure
 493 +.TP
 494 +.BI -h
 495 +Display help
 496 +.TP
 497 +.SH EXAMPLES
 498 +
 499 +.EX
 500 +.B
 501 + genext2fs -b 1440 -d src /dev/fd0
 502 +.EE
 503 +
 504 +All files in the
 505 +.I src
 506 +directory will be written to
 507 +.B /dev/fd0
 508 +as a new ext2 filesystem image. You can then mount the floppy as
 509 +usual.
 510 +
 511 +.EX
 512 +.B
 513 + genext2fs -b 1024 -d src -D device_table.txt flashdisk.img
 514 +.EE
 515 +
 516 +This example builds a filesystem from all the files in
 517 +.I src
 518 +, then device nodes are created based on the content the device_table file
 519 +.I dev.txt.
 520 +An example device file follows:
 521 +
 522 +.EX
 523 + #<name>               <type>  <mode>  <uid>   <gid>   <major> <minor> <start> <inc>   <count>
 524 + /dev          d       755     0       0       -       -       -       -       -
 525 + /dev/mem      c       640     0       0       1       1       0       0       -
 526 + /dev/tty      c       666     0       0       5       0       0       0       -
 527 + /dev/tty      c       666     0       0       4       0       0       1       6
 528 + /dev/loop     b       640     0       0       7       0       0       1       2
 529 + /dev/hda      b       640     0       0       3       0       0       0       -
 530 + /dev/hda      b       640     0       0       3       1       1       1       16
 531 +.EE
 532 +
 533 +This device table creates the /dev directory, a character device
 534 +node /dev/mem (major 1, minor 1), it also creates /dev/tty,
 535 +/dev/tty[0-5], /dev/loop[0-1], /dev/hda, and /dev/hda0 to /dev/hda15
 536 +.SH BUGS
 537 +\fBgenext2fs\fP does not support hard links.  Hard links present in the input
 538 +tree will be represented as separate files in the ext2 image.
 539 +
 540 +.SH SEE ALSO
 541 +.BR mkfs (8),
 542 +.BR genromfs (8),
 543 +.BR mkisofs (8).
 544 +.br
 545 +.SH AUTHOR
 546 +This manual page was written by David Kimdon <dwhedon@debian.org>,
 547 +for the Debian GNU/Linux system (but may be used by others).
 548 diff -urN genext2fs-1.3.orig/genext2fs.c genext2fs-1.3/genext2fs.c
 549 --- genext2fs-1.3.orig/genext2fs.c      2001-06-18 02:11:32.000000000 -0600
 550 +++ genext2fs-1.3/genext2fs.c   2003-04-21 01:48:35.000000000 -0600
 551 @@ -1,3 +1,4 @@
 552 +/* vi: set sw=8 ts=8: */
 553  // genext2fs.c
 554  //
 555  // ext2 filesystem generator for embedded systems
 556 @@ -26,6 +27,22 @@
 557  //                     Bugfix: getcwd values for Solaris       xavier.gueguen@col.bsf.alcatel.fr
 558  //                     Bugfix: ANSI scanf for non-GNU C        xavier.gueguen@col.bsf.alcatel.fr
 559  //     28 Jun 2001     Bugfix: getcwd differs for Solaris/GNU  mike@sowbug.com
 560 +//     23 Mar 2002     Bugfix: test for IFCHR or IFBLK was flawed
 561 +//     10 Oct 2002     Added comments,makefile targets,        vsundar@ixiacom.com
 562 +//                     endianess swap assert check.
 563 +//                     Copyright (C) 2002 Ixia communications
 564 +//     12 Oct 2002     Added support for triple indirection    vsundar@ixiacom.com
 565 +//                     Copyright (C) 2002 Ixia communications
 566 +//     14 Oct 2002     Added support for groups                vsundar@ixiacom.com
 567 +//                     Copyright (C) 2002 Ixia communications
 568 +//     5 Jan 2003      Bugfixes: reserved inodes should be set vsundar@usc.edu
 569 +//                     only in the first group; directory names
 570 +//                     need to be null padded at the end; and
 571 +//                     number of blocks per group should be a
 572 +//                     multiple of 8. Updated md5 values.
 573 +//     6 Jan 2003      Erik Andersen <andersee@debian.org> added
 574 +//                         mkfs.jffs2 compatible device table support,
 575 +//                         along with -q, -P, -U
 576
 577
 578  // `genext2fs' is a mean to generate an ext2 filesystem
 579 @@ -33,10 +50,6 @@
 580  // the image file to copy files on it. It doesn't even require
 581  // you to be the superuser to make device nodes.
 582  //
 583 -// Warning ! `genext2fs' has been designed for embedded
 584 -// systems. As such, it will generate a filesystem for single-user
 585 -// usage: all files/directories/etc... will belong to UID/GID 0
 586 -//
 587  // Example usage:
 588  //
 589  // # genext2fs -b 1440 -d srcdir /dev/fd0
 590 @@ -45,21 +58,15 @@
 591  // a new ext2 filesystem image. You can then mount the floppy as
 592  // usual.
 593  //
 594 -// # genext2fs -b 1024 -d builddir -f devices.txt flashdisk.img
 595 +// # genext2fs -b 1024 -d builddir -D device_table.txt flashdisk.img
 596  //
 597  // This one would build a filesystem from all the files in builddir,
 598 -// then would read a devices list and make apropriate nodes. The
 599 -// format for the device list is:
 600 -//
 601 -// drwx            /dev
 602 -// crw-    10,190  /dev/lcd
 603 -// brw-    1,0     /dev/ram0
 604 -//
 605 -// This device list builds the /dev directory, a character device
 606 -// node /dev/lcd (major 10, minor 190) and a block device node
 607 -// /dev/ram0 (major 1, minor 0)
 608 +// then would read the device_table.txt file and make apropriate nodes.
 609 +// The format for the device table file is covered in detail in the sample
 610 +// device_table.txt file provided with the genext2fs source.
 611
 612
 613 +#define _GNU_SOURCE
 614  #include <stdio.h>
 615  #include <stdlib.h>
 616  #include <string.h>
 617 @@ -67,6 +74,11 @@
 618  #include <stdarg.h>
 619  #include <unistd.h>
 620  #include <sys/stat.h>
 621 +#include <assert.h>
 622 +#include <time.h>
 623 +#include <ctype.h>
 624 +#include <errno.h>
 625 +#include <fcntl.h>
 626
 627
 628
 629 @@ -76,10 +88,14 @@
 630  #define BLOCKSIZE         1024
 631  #define BLOCKS_PER_GROUP  8192
 632  #define BYTES_PER_INODE   (8*BLOCKSIZE)
 633 +/* Percentage of blocks that are reserved.*/
 634  #define RESERVED_INODES   5/100
 635
 636
 637  // inode block size (why is it != BLOCKSIZE ?!?)
 638 +/* The field i_blocks in the ext2 inode stores the number of data blocks
 639 +   but in terms of 512 bytes. That is what INODE_BLOCKSIZE represents.
 640 +   INOBLK is the number of such blocks in an actual disk block            */
 641
 642  #define INODE_BLOCKSIZE   512
 643  #define INOBLK            (BLOCKSIZE / INODE_BLOCKSIZE)
 644 @@ -147,6 +163,39 @@
 645
 646  #define OP_HOLES     0x01       // make files with holes
 647
 648 +/* Defines for accessing group details */
 649 +
 650 +// Number of groups in the filesystem
 651 +#define GRP_NBGROUPS(fs) ( ((fs)->sb.s_blocks_count-1)/(fs)->sb.s_blocks_per_group )
 652 +
 653 +// Get group block bitmap (bbm) given the group number
 654 +#define GRP_GET_GROUP_BBM(fs,grp) ( get_blk((fs),(fs)->gd[(grp)].bg_block_bitmap) )
 655 +
 656 +// Get group inode bitmap (ibm) given the group number
 657 +#define GRP_GET_GROUP_IBM(fs,grp) ( get_blk((fs),(fs)->gd[(grp)].bg_inode_bitmap) )
 658 +
 659 +// Given an inode number find the group it belongs to
 660 +#define GRP_GROUP_OF_INODE(fs,nod) ( ((nod)-1) / (fs)->sb.s_inodes_per_group)
 661 +
 662 +//Given an inode number get the inode bitmap that covers it
 663 +#define GRP_GET_INODE_BITMAP(fs,nod) \
 664 +       ( GRP_GET_GROUP_IBM((fs),GRP_GROUP_OF_INODE((fs),(nod))) )
 665 +
 666 +//Given an inode number find its offset within the inode bitmap that covers it
 667 +#define GRP_IBM_OFFSET(fs,nod) \
 668 +       ( (nod) - GRP_GROUP_OF_INODE((fs),(nod))*(fs)->sb.s_inodes_per_group )
 669 +
 670 +// Given a block number find the group it belongs to
 671 +#define GRP_GROUP_OF_BLOCK(fs,blk) ( ((blk)-1) / (fs)->sb.s_blocks_per_group)
 672 +
 673 +//Given a block number get the block bitmap that covers it
 674 +#define GRP_GET_BLOCK_BITMAP(fs,blk) \
 675 +       ( GRP_GET_GROUP_BBM((fs),GRP_GROUP_OF_BLOCK((fs),(blk))) )
 676 +
 677 +//Given a block number find its offset within the block bitmap that covers it
 678 +#define GRP_BBM_OFFSET(fs,blk) \
 679 +       ( (blk) - GRP_GROUP_OF_BLOCK((fs),(blk))*(fs)->sb.s_blocks_per_group )
 680 +
 681
 682  // used types
 683
 684 @@ -287,7 +336,6 @@
 685  {
 686         groupdescriptor_decl
 687         uint32 bg_reserved[3];
 688 -       uint32 bg_pad_to_bk[(BLOCKSIZE-32)/sizeof(uint32)];
 689  } groupdescriptor;
 690
 691  typedef struct
 692 @@ -304,6 +352,32 @@
 693
 694  typedef uint8 block[BLOCKSIZE];
 695
 696 +/* blockwalker fields:
 697 +   The blockwalker is used to access all the blocks of a file (including
 698 +   the indirection blocks) through repeated calls to walk_bw.
 699 +
 700 +   bpdir -> index into the inode->i_block[]. Indicates level of indirection.
 701 +   bnum -> total number of blocks so far accessed. including indirection
 702 +           blocks.
 703 +   bpind,bpdind,bptind -> index into indirection blocks.
 704 +
 705 +   bpind, bpdind, bptind do *NOT* index into single, double and triple
 706 +   indirect blocks resp. as you might expect from their names. Instead
 707 +   they are in order the 1st, 2nd & 3rd index to be used
 708 +
 709 +   As an example..
 710 +   To access data block number 70000:
 711 +        bpdir: 15 (we are doing triple indirection)
 712 +        bpind: 0 ( index into the triple indirection block)
 713 +        bpdind: 16 ( index into the double indirection block)
 714 +        bptind: 99 ( index into the single indirection block)
 715 +       70000 = 12 + 256 + 256*256 + 16*256 + 100 (indexing starts from zero)
 716 +
 717 +   So,for double indirection bpind will index into the double indirection
 718 +   block and bpdind into the single indirection block. For single indirection
 719 +   only bpind will be used.
 720 +*/
 721 +
 722  typedef struct
 723  {
 724         uint32 bnum;
 725 @@ -313,15 +387,14 @@
 726         uint32 bptind;
 727  } blockwalker;
 728
 729 +
 730 +/* Filesystem structure that support groups */
 731  #if BLOCKSIZE == 1024
 732  typedef struct
 733  {
 734         block zero;          // The famous block 0
 735         superblock sb;       // The superblock
 736 -       groupdescriptor gd;  // The group desciptor
 737 -       block bbm;           // The block bitmap
 738 -       block ibm;           // The inode bitmap
 739 -       inode itab[0];       // The inode table
 740 +       groupdescriptor gd[0]; // The group descriptors
 741  } filesystem;
 742  #else
 743  #error UNHANDLED BLOCKSIZE
 744 @@ -389,25 +462,113 @@
 745  #undef udecl32
 746  #undef utdecl32
 747
 748 -char * argv0;
 749 +static char * app_name;
 750 +static int squash_uids = 0;
 751 +static int squash_perms = 0;
 752 +static const char *const memory_exhausted = "memory exhausted";
 753
 754  // error (un)handling
 755 -inline void errexit(const char *fmt, ...)
 756 +static void verror_msg(const char *s, va_list p)
 757  {
 758 -       va_list ap;
 759 -       fprintf(stderr, "%s: ", argv0);
 760 -       va_start(ap, fmt);
 761 -       vfprintf(stderr, fmt, ap);
 762 -       va_end(ap);
 763 -       fprintf(stderr, "\n");
 764 -       exit(1);
 765 +       fflush(stdout);
 766 +       fprintf(stderr, "%s: ", app_name);
 767 +       vfprintf(stderr, s, p);
 768 +}
 769 +static void error_msg(const char *s, ...)
 770 +{
 771 +       va_list p;
 772 +       va_start(p, s);
 773 +       verror_msg(s, p);
 774 +       va_end(p);
 775 +       putc('\n', stderr);
 776 +}
 777 +
 778 +static void error_msg_and_die(const char *s, ...)
 779 +{
 780 +       va_list p;
 781 +       va_start(p, s);
 782 +       verror_msg(s, p);
 783 +       va_end(p);
 784 +       putc('\n', stderr);
 785 +       exit(EXIT_FAILURE);
 786 +}
 787 +
 788 +static void vperror_msg(const char *s, va_list p)
 789 +{
 790 +       int err = errno;
 791 +       if (s == 0)
 792 +               s = "";
 793 +       verror_msg(s, p);
 794 +       if (*s)
 795 +               s = ": ";
 796 +       fprintf(stderr, "%s%s\n", s, strerror(err));
 797 +}
 798 +
 799 +#if 0
 800 +static void perror_msg(const char *s, ...)
 801 +{
 802 +       va_list p;
 803 +       va_start(p, s);
 804 +       vperror_msg(s, p);
 805 +       va_end(p);
 806 +}
 807 +#endif
 808 +static void perror_msg_and_die(const char *s, ...)
 809 +{
 810 +       va_list p;
 811 +       va_start(p, s);
 812 +       vperror_msg(s, p);
 813 +       va_end(p);
 814 +       exit(EXIT_FAILURE);
 815  }
 816
 817 -inline void pexit(const char * fname)
 818 +static FILE *xfopen(const char *path, const char *mode)
 819  {
 820 -       fprintf(stderr, "%s: ", argv0);
 821 -       perror(fname);
 822 -       exit(1);
 823 +       FILE *fp;
 824 +       if ((fp = fopen(path, mode)) == NULL)
 825 +               perror_msg_and_die("%s", path);
 826 +       return fp;
 827 +}
 828 +
 829 +static char *xstrdup(const char *s)
 830 +{
 831 +       char *t;
 832 +
 833 +       if (s == NULL)
 834 +               return NULL;
 835 +       t = strdup(s);
 836 +       if (t == NULL)
 837 +               error_msg_and_die(memory_exhausted);
 838 +       return t;
 839 +}
 840 +
 841 +extern void *xrealloc(void *ptr, size_t size)
 842 +{
 843 +       ptr = realloc(ptr, size);
 844 +       if (ptr == NULL && size != 0)
 845 +               error_msg_and_die(memory_exhausted);
 846 +       return ptr;
 847 +}
 848 +
 849 +static char *xreadlink(const char *path)
 850 +{
 851 +       static const int GROWBY = 80; /* how large we will grow strings by */
 852 +
 853 +       char *buf = NULL;
 854 +       int bufsize = 0, readsize = 0;
 855 +
 856 +       do {
 857 +               buf = xrealloc(buf, bufsize += GROWBY);
 858 +               readsize = readlink(path, buf, bufsize); /* 1st try */
 859 +               if (readsize == -1) {
 860 +                       perror_msg_and_die("%s:%s", app_name, path);
 861 +               }
 862 +       }
 863 +       while (bufsize < readsize + 1);
 864 +
 865 +       buf[readsize] = '\0';
 866 +
 867 +       return buf;
 868  }
 869
 870  // printf helper macro
 871 @@ -423,7 +584,7 @@
 872  {
 873  }
 874
 875 -// rounds a quantity up to a blocksize
 876 +/* Rounds qty upto a multiple of siz. siz should be a power of 2 */
 877  uint32 rndup(uint32 qty, uint32 siz)
 878  {
 879         return (qty + (siz - 1)) & ~(siz - 1);
 880 @@ -444,7 +605,13 @@
 881  // return a given inode from a filesystem
 882  inline inode * get_nod(filesystem *fs, uint32 nod)
 883  {
 884 -       return &fs->itab[nod-1];
 885 +       int grp,offset;
 886 +       inode *itab;
 887 +
 888 +       offset = GRP_IBM_OFFSET(fs,nod);
 889 +       grp = GRP_GROUP_OF_INODE(fs,nod);
 890 +       itab = (inode *)get_blk(fs, fs->gd[grp].bg_inode_table);
 891 +       return itab+offset-1;
 892  }
 893
 894  // allocate a given block/inode in the bitmap
 895 @@ -479,29 +646,57 @@
 896  }
 897
 898  // allocate a block
 899 -uint32 alloc_blk(filesystem *fs)
 900 +uint32 alloc_blk(filesystem *fs, uint32  nod)
 901  {
 902 -       uint32 bk;
 903 -       if(!(bk = allocate(fs->bbm, 0)))
 904 -               errexit("couldn't allocate a block (no free space)");
 905 -       if(!(fs->gd.bg_free_blocks_count--))
 906 -               errexit("group descr. free blocks count == 0 (corrupted fs?)");
 907 +       uint32 bk=0;
 908 +       uint32 grp,nbgroups;
 909 +
 910 +       grp = nod/fs->sb.s_inodes_per_group;
 911 +       nbgroups = ( fs->sb.s_blocks_count - fs->sb.s_first_data_block + fs->sb.s_blocks_per_group -1 ) /
 912 +                                       fs->sb.s_blocks_per_group;
 913 +       if(!(bk = allocate(get_blk(fs,fs->gd[grp].bg_block_bitmap), 0))) {
 914 +               for(grp=0;grp<nbgroups && !bk;grp++)
 915 +                       bk=allocate(get_blk(fs,fs->gd[grp].bg_block_bitmap),0);
 916 +               grp--;
 917 +       }
 918 +       if (!bk)
 919 +               error_msg_and_die("couldn't allocate a block (no free space)");
 920 +       if(!(fs->gd[grp].bg_free_blocks_count--))
 921 +               error_msg_and_die("group descr %d. free blocks count == 0 (corrupted fs?)",grp);
 922         if(!(fs->sb.s_free_blocks_count--))
 923 -               errexit("superblock free blocks count == 0 (corrupted fs?)");
 924 -       return bk;
 925 +               error_msg_and_die("superblock free blocks count == 0 (corrupted fs?)");
 926 +       return fs->sb.s_blocks_per_group*grp + bk;
 927  }
 928
 929  // allocate an inode
 930  uint32 alloc_nod(filesystem *fs)
 931  {
 932 -       uint32 nod;
 933 -       if(!(nod = allocate(fs->ibm, 0)))
 934 -               errexit("couldn't allocate an inode (no free inode)");
 935 -       if(!(fs->gd.bg_free_inodes_count--))
 936 -               errexit("group descr. free blocks count == 0 (corrupted fs?)");
 937 +       uint32 nod=0,best_group=0;
 938 +       uint32 grp,nbgroups,avefreei;
 939 +
 940 +       nbgroups = ( fs->sb.s_blocks_count - fs->sb.s_first_data_block + fs->sb.s_blocks_per_group -1 ) /
 941 +                                       fs->sb.s_blocks_per_group;
 942 +
 943 +       /* Distribute inodes amongst all the blocks                           */
 944 +       /* For every block group with more than average number of free inodes */
 945 +       /* find the one with the most free blocks and allocate node there     */
 946 +       /* Idea from find_group_dir in fs/ext2/ialloc.c in 2.4.19 kernel      */
 947 +       /* We do it for all inodes.                                           */
 948 +       avefreei  =  fs->sb.s_free_inodes_count / nbgroups;
 949 +       for(grp=0;grp<nbgroups && !nod;grp++) {
 950 +               if (fs->gd[grp].bg_free_inodes_count < avefreei)
 951 +                       continue;
 952 +               if (!best_group ||
 953 +                       fs->gd[grp].bg_free_blocks_count > fs->gd[best_group].bg_free_blocks_count)
 954 +                       best_group = grp;
 955 +       }
 956 +       if (!(nod = allocate(get_blk(fs,fs->gd[best_group].bg_inode_bitmap),0)))
 957 +               error_msg_and_die("couldn't allocate an inode (no free inode)");
 958 +       if(!(fs->gd[best_group].bg_free_inodes_count--))
 959 +               error_msg_and_die("group descr. free blocks count == 0 (corrupted fs?)");
 960         if(!(fs->sb.s_free_inodes_count--))
 961 -               errexit("superblock free blocks count == 0 (corrupted fs?)");
 962 -       return nod;
 963 +               error_msg_and_die("superblock free blocks count == 0 (corrupted fs?)");
 964 +       return fs->sb.s_inodes_per_group*best_group+nod;
 965  }
 966
 967  // print a bitmap allocation
 968 @@ -546,14 +741,14 @@
 969         {
 970                 bkref = &get_nod(fs, nod)->i_block[bw->bpdir = 0];
 971                 if(extend) // allocate first block
 972 -                       *bkref = hole ? 0 : alloc_blk(fs);
 973 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
 974         }
 975         // direct block
 976         else if(bw->bpdir < EXT2_NDIR_BLOCKS)
 977         {
 978                 bkref = &get_nod(fs, nod)->i_block[++bw->bpdir];
 979                 if(extend) // allocate block
 980 -                       *bkref = hole ? 0 : alloc_blk(fs);
 981 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
 982         }
 983         // first block in indirect block
 984         else if(bw->bpdir == EXT2_NDIR_BLOCKS)
 985 @@ -562,11 +757,11 @@
 986                 bw->bpdir = EXT2_IND_BLOCK;
 987                 bw->bpind = 0;
 988                 if(extend) // allocate indirect block
 989 -                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs);
 990 +                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
 991                 b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
 992                 bkref = &b[bw->bpind];
 993                 if(extend) // allocate first block
 994 -                       *bkref = hole ? 0 : alloc_blk(fs);
 995 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
 996         }
 997         // block in indirect block
 998         else if((bw->bpdir == EXT2_IND_BLOCK) && (bw->bpind < BLOCKSIZE/4 - 1))
 999 @@ -575,7 +770,7 @@
1000                 b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1001                 bkref = &b[bw->bpind];
1002                 if(extend) // allocate block
1003 -                       *bkref = hole ? 0 : alloc_blk(fs);
1004 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1005         }
1006         // first block in first indirect block in first double indirect block
1007         else if(bw->bpdir == EXT2_IND_BLOCK)
1008 @@ -585,14 +780,14 @@
1009                 bw->bpind = 0;
1010                 bw->bpdind = 0;
1011                 if(extend) // allocate double indirect block
1012 -                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs);
1013 +                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
1014                 b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1015                 if(extend) // allocate first indirect block
1016 -                       b[bw->bpind] = alloc_blk(fs);
1017 +                       b[bw->bpind] = alloc_blk(fs,nod);
1018                 b = (uint32*)get_blk(fs, b[bw->bpind]);
1019                 bkref = &b[bw->bpdind];
1020                 if(extend) // allocate first block
1021 -                       *bkref = hole ? 0 : alloc_blk(fs);
1022 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1023         }
1024         // block in indirect block in double indirect block
1025         else if((bw->bpdir == EXT2_DIND_BLOCK) && (bw->bpdind < BLOCKSIZE/4 - 1))
1026 @@ -602,7 +797,7 @@
1027                 b = (uint32*)get_blk(fs, b[bw->bpind]);
1028                 bkref = &b[bw->bpdind];
1029                 if(extend) // allocate block
1030 -                       *bkref = hole ? 0 : alloc_blk(fs);
1031 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1032         }
1033         // first block in indirect block in double indirect block
1034         else if((bw->bpdir == EXT2_DIND_BLOCK) && (bw->bpind < BLOCKSIZE/4 - 1))
1035 @@ -612,20 +807,100 @@
1036                 bw->bpind++;
1037                 b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1038                 if(extend) // allocate indirect block
1039 -                       b[bw->bpind] = alloc_blk(fs);
1040 +                       b[bw->bpind] = alloc_blk(fs,nod);
1041                 b = (uint32*)get_blk(fs, b[bw->bpind]);
1042                 bkref = &b[bw->bpdind];
1043                 if(extend) // allocate first block
1044 -                       *bkref = hole ? 0 : alloc_blk(fs);
1045 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1046 +       }
1047 +
1048 +       /* Adding support for triple indirection */
1049 +       /* Just starting triple indirection. Allocate the indirection
1050 +          blocks and the first data block
1051 +        */
1052 +       else if (bw->bpdir == EXT2_DIND_BLOCK)
1053 +       {
1054 +               bw->bnum += 3;
1055 +               bw->bpdir = EXT2_TIND_BLOCK;
1056 +               bw->bpind = 0;
1057 +               bw->bpdind = 0;
1058 +               bw->bptind = 0;
1059 +               if(extend) // allocate triple indirect block
1060 +                       get_nod(fs, nod)->i_block[bw->bpdir] = alloc_blk(fs,nod);
1061 +               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1062 +               if(extend) // allocate first double indirect block
1063 +                       b[bw->bpind] = alloc_blk(fs,nod);
1064 +               b = (uint32*)get_blk(fs, b[bw->bpind]);
1065 +               if(extend) // allocate first indirect block
1066 +                       b[bw->bpdind] = alloc_blk(fs,nod);
1067 +               b = (uint32*)get_blk(fs, b[bw->bpdind]);
1068 +               bkref = &b[bw->bptind];
1069 +               if(extend) // allocate first data block
1070 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1071 +       }
1072 +       /* Still processing a single indirect block down the indirection
1073 +          chain.Allocate a data block for it
1074 +        */
1075 +       else if ( (bw->bpdir == EXT2_TIND_BLOCK) &&
1076 +                 (bw->bptind < BLOCKSIZE/4 -1) )
1077 +       {
1078 +               bw->bptind++;
1079 +               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1080 +               b = (uint32*)get_blk(fs, b[bw->bpind]);
1081 +               b = (uint32*)get_blk(fs, b[bw->bpdind]);
1082 +               bkref = &b[bw->bptind];
1083 +               if(extend) // allocate data block
1084 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1085 +       }
1086 +       /* Finished processing a single indirect block. But still in the
1087 +          same double indirect block. Allocate new single indirect block
1088 +          for it and a data block
1089 +        */
1090 +       else if ( (bw->bpdir == EXT2_TIND_BLOCK) &&
1091 +                 (bw->bpdind < BLOCKSIZE/4 -1) )
1092 +       {
1093 +               bw->bnum++;
1094 +               bw->bptind = 0;
1095 +               bw->bpdind++;
1096 +               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1097 +               b = (uint32*)get_blk(fs, b[bw->bpind]);
1098 +               if (extend) // allocate single indirect block
1099 +                       b[bw->bpdind] = alloc_blk(fs,nod);
1100 +               b = (uint32*)get_blk(fs, b[bw->bpdind]);
1101 +               bkref = &b[bw->bptind];
1102 +               if(extend) // allocate first data block
1103 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1104 +       }
1105 +       /* Finished processing a double indirect block. Allocate the next
1106 +          double indirect block and the single,data blocks for it
1107 +        */
1108 +       else if ( (bw->bpdir == EXT2_TIND_BLOCK) &&
1109 +                 (bw->bpind < BLOCKSIZE/4 - 1) )
1110 +       {
1111 +               bw->bnum += 2;
1112 +               bw->bpdind = 0;
1113 +               bw->bptind = 0;
1114 +               bw->bpind++;
1115 +               b = (uint32*)get_blk(fs, get_nod(fs, nod)->i_block[bw->bpdir]);
1116 +               if(extend) // allocate double indirect block
1117 +                       b[bw->bpind] = alloc_blk(fs,nod);
1118 +               b = (uint32*)get_blk(fs, b[bw->bpind]);
1119 +               if(extend) // allocate single indirect block
1120 +                       b[bw->bpdind] = alloc_blk(fs,nod);
1121 +               b = (uint32*)get_blk(fs, b[bw->bpdind]);
1122 +               bkref = &b[bw->bptind];
1123 +               if(extend) // allocate first block
1124 +                       *bkref = hole ? 0 : alloc_blk(fs,nod);
1125         }
1126 -       // I don't do triple indirect - it's such a small filesystem ...
1127         else
1128 -               errexit("file too big ! blocks list for inode %d extends past double indirect blocks!", nod);
1129 +               error_msg_and_die("file too big !");
1130 +       /* End change for walking triple indirection */
1131 +
1132         if(*bkref)
1133         {
1134                 bw->bnum++;
1135 -               if(!allocated(fs->bbm, *bkref))
1136 -                       errexit("[block %d of inode %d is unallocated !]", *bkref, nod);
1137 +               if(!allocated(GRP_GET_BLOCK_BITMAP(fs,*bkref), GRP_BBM_OFFSET(fs,*bkref)))
1138 +                       error_msg_and_die("[block %d of inode %d is unallocated !]", *bkref, nod);
1139         }
1140         if(extend)
1141                 get_nod(fs, nod)->i_blocks = bw->bnum * INOBLK;
1142 @@ -663,23 +938,40 @@
1143  }
1144
1145  // link an entry (inode #) to a directory
1146 -void add2dir(filesystem *fs, uint32 dnod, uint32 nod, const char* name)
1147 +void add2dir(filesystem *fs, uint32 dnod, uint32 nod, const char* name, uint32 mode, uid_t uid, gid_t gid, time_t ctime)
1148  {
1149         blockwalker bw;
1150         uint32 bk;
1151         uint8 *b;
1152         directory *d;
1153         int reclen, nlen;
1154 -       if((get_nod(fs, dnod)->i_mode & FM_IFMT) != FM_IFDIR)
1155 -               errexit("can't add '%s' to a non-directory", name);
1156 +       inode *node;
1157 +       inode *pnode;
1158 +
1159 +       /* Squash all permissions so files are owned by root
1160 +        * and file permissions have group/other perms removed */
1161 +       if (squash_uids) {
1162 +               uid = gid = 0;
1163 +       }
1164 +       if (squash_perms) {
1165 +               if (!S_ISLNK(mode)) {
1166 +                       mode &= ~(S_IWGRP | S_IWOTH);
1167 +                       mode &= ~(S_ISUID | S_ISGID);
1168 +               }
1169 +       }
1170 +
1171 +       pnode = get_nod(fs, dnod);
1172 +
1173 +       if(!S_ISDIR(pnode->i_mode))
1174 +               error_msg_and_die("can't add '%s' to a non-directory", name);
1175         if(!*name)
1176 -               errexit("bad name '%s' (not meaningful)", name);
1177 +               error_msg_and_die("bad name '%s' (not meaningful)", name);
1178         if(strchr(name, '/'))
1179 -               errexit("bad name '%s' (contains a slash)", name);
1180 +               error_msg_and_die("bad name '%s' (contains a slash)", name);
1181         nlen = strlen(name);
1182         reclen = sizeof(directory) + rndup(nlen, 4);
1183         if(reclen > BLOCKSIZE)
1184 -               errexit("bad name '%s' (too long)", name);
1185 +               error_msg_and_die("bad name '%s' (too long)", name);
1186         init_bw(fs, dnod, &bw);
1187         while((bk = walk_bw(fs, dnod, &bw, 0, 0)) != WALK_END) // for all blocks in dir
1188         {
1189 @@ -691,9 +983,16 @@
1190                         if((!d->d_inode) && (d->d_rec_len >= reclen))
1191                         {
1192                                 d->d_inode = nod;
1193 -                               get_nod(fs, nod)->i_links_count++;
1194 +                               node = get_nod(fs, nod);
1195 +                               node->i_links_count++;
1196                                 d->d_name_len = nlen;
1197 -                               strncpy(d->d_name, name, nlen);
1198 +                               strncpy(d->d_name, name, rndup(nlen,4));
1199 +                               node->i_mode = mode;
1200 +                               node->i_uid = uid;
1201 +                               node->i_gid = gid;
1202 +                               node->i_atime = ctime;
1203 +                               node->i_ctime = ctime;
1204 +                               node->i_mtime = ctime;
1205                                 return;
1206                         }
1207                         // if entry with enough room (last one?), shrink it & use it
1208 @@ -705,9 +1004,16 @@
1209                                 d = (directory*) (((int8*)d) + d->d_rec_len);
1210                                 d->d_rec_len = reclen;
1211                                 d->d_inode = nod;
1212 -                               get_nod(fs, nod)->i_links_count++;
1213 +                               node = get_nod(fs, nod);
1214 +                               node->i_links_count++;
1215                                 d->d_name_len = nlen;
1216 -                               strncpy(d->d_name, name, nlen);
1217 +                               strncpy(d->d_name, name, rndup(nlen,4));
1218 +                               node->i_mode = mode;
1219 +                               node->i_uid = uid;
1220 +                               node->i_gid = gid;
1221 +                               node->i_atime = ctime;
1222 +                               node->i_ctime = ctime;
1223 +                               node->i_mtime = ctime;
1224                                 return;
1225                         }
1226                 }
1227 @@ -716,10 +1022,17 @@
1228         b = get_workblk();
1229         d = (directory*)b;
1230         d->d_inode = nod;
1231 -       get_nod(fs, nod)->i_links_count++;
1232 +       node = get_nod(fs, nod);
1233 +       node->i_links_count++;
1234         d->d_rec_len = BLOCKSIZE;
1235         d->d_name_len = nlen;
1236 -       strncpy(d->d_name, name, nlen);
1237 +       strncpy(d->d_name, name, rndup(nlen,4));
1238 +       node->i_mode = mode;
1239 +       node->i_uid = uid;
1240 +       node->i_gid = gid;
1241 +       node->i_atime = ctime;
1242 +       node->i_ctime = ctime;
1243 +       node->i_mtime = ctime;
1244         extend_blk(fs, dnod, b, 1);
1245         get_nod(fs, dnod)->i_size += BLOCKSIZE;
1246         free_workblk(b);
1247 @@ -747,7 +1060,7 @@
1248  // find the inode of a full path
1249  uint32 find_path(filesystem *fs, uint32 nod, const char * name)
1250  {
1251 -       char *p, *n, *n2 = strdup(name);
1252 +       char *p, *n, *n2 = xstrdup(name);
1253         n = n2;
1254         while(*n == '/')
1255         {
1256 @@ -770,27 +1083,32 @@
1257  }
1258
1259  // make a full-fledged directory (i.e. with "." & "..")
1260 -uint32 mkdir_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode)
1261 +uint32 mkdir_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode,
1262 +       uid_t uid, gid_t gid, time_t ctime)
1263  {
1264         uint32 nod;
1265         if((nod = find_dir(fs, parent_nod, name)))
1266                 return nod;
1267                 nod = alloc_nod(fs);
1268 -       get_nod(fs, nod)->i_mode = FM_IFDIR | mode;
1269 -       add2dir(fs, parent_nod, nod, name);
1270 -       add2dir(fs, nod, nod, ".");
1271 -       add2dir(fs, nod, parent_nod, "..");
1272 -       fs->gd.bg_used_dirs_count++;
1273 +       if (!(mode & FM_IFDIR))
1274 +           mode |= FM_IFDIR;
1275 +       add2dir(fs, parent_nod, nod, name, mode, uid, gid, ctime);
1276 +       add2dir(fs, nod, nod, ".", mode, uid, gid, ctime);
1277 +       add2dir(fs, nod, parent_nod, "..", mode, uid, gid, ctime);
1278 +       fs->gd[GRP_GROUP_OF_INODE(fs,nod)].bg_used_dirs_count++;
1279         return nod;
1280  }
1281
1282  // make a symlink
1283 -uint32 mklink_fs(filesystem *fs, uint32 parent_nod, const char *name, size_t size, uint8 * b)
1284 +uint32 mklink_fs(filesystem *fs, uint32 parent_nod, const char *name, size_t size,
1285 +       uint8 * b, uid_t uid, gid_t gid, time_t ctime)
1286  {
1287 +       uint32 mode;
1288         uint32 nod = alloc_nod(fs);
1289 +       mode = FM_IFLNK | FM_IRWXU | FM_IRWXG | FM_IRWXO;
1290         get_nod(fs, nod)->i_mode = FM_IFLNK | FM_IRWXU | FM_IRWXG | FM_IRWXO;
1291         get_nod(fs, nod)->i_size = size;
1292 -       add2dir(fs, parent_nod, nod, name);
1293 +       add2dir(fs, parent_nod, nod, name, mode, uid, gid, ctime);
1294         if(size <= 4 * (EXT2_TIND_BLOCK+1))
1295         {
1296                 strncpy((char*)get_nod(fs, nod)->i_block, (char*)b, size);
1297 @@ -801,15 +1119,15 @@
1298  }
1299
1300  // make a file from a FILE*
1301 -uint32 mkfile_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode, size_t size, FILE *f)
1302 +uint32 mkfile_fs(filesystem *fs, uint32 parent_nod, const char *name, uint32 mode, size_t size, FILE *f, uid_t uid, gid_t gid, time_t ctime)
1303  {
1304         uint8 * b;
1305         uint32 nod = alloc_nod(fs);
1306 -       get_nod(fs, nod)->i_mode = FM_IFREG | mode;
1307 +       mode |= FM_IFREG;
1308         get_nod(fs, nod)->i_size = size;
1309 -       add2dir(fs, parent_nod, nod, name);
1310 +       add2dir(fs, parent_nod, nod, name, mode, uid, gid, ctime);
1311         if(!(b = (uint8*)malloc(rndup(size, BLOCKSIZE))))
1312 -               errexit("not enough mem to read file '%s'", name);
1313 +               error_msg_and_die("not enough mem to read file '%s'", name);
1314         memset(b, 0,rndup(size, BLOCKSIZE));
1315         if(f)
1316                 fread(b, size, 1, f);
1317 @@ -824,6 +1142,15 @@
1318  uint32 get_mode(struct stat *st)
1319  {
1320         uint32 mode = 0;
1321 +
1322 +       /* Squash file permissions as needed */
1323 +       if (squash_perms) {
1324 +               if (!S_ISLNK(mode)) {
1325 +                       st->st_mode &= ~(S_IWGRP | S_IWOTH);
1326 +                       st->st_mode &= ~(S_ISUID | S_ISGID);
1327 +               }
1328 +       }
1329 +
1330         if(st->st_mode & S_IRUSR)
1331                 mode |= FM_IRUSR | FM_IRGRP | FM_IROTH;
1332         if(st->st_mode & S_IWUSR)
1333 @@ -833,30 +1160,17 @@
1334         return mode;
1335  }
1336
1337 -// retrieves a mode info from a string
1338 -uint32 get_modestr(const char *p)
1339 -{
1340 -       uint32 mode = 0;
1341 -       if(p[0] == 'r')
1342 -               mode |= FM_IRUSR | FM_IRGRP | FM_IROTH;
1343 -       if(p[1] == 'w')
1344 -               mode |= FM_IWUSR | FM_IWGRP | FM_IWOTH;
1345 -       if(p[2] == 'x' || p[2] == 's')
1346 -               mode |= FM_IXUSR | FM_IXGRP | FM_IXOTH;
1347 -       return mode;
1348 -}
1349 -
1350  // basename of a path - free me
1351  char * basename(const char * fullpath)
1352  {
1353         char * p = strrchr(fullpath, '/');
1354 -       return strdup(p ? p + 1 : fullpath);
1355 +       return xstrdup(p ? p + 1 : fullpath);
1356  }
1357
1358  // dirname of a path - free me
1359  char * dirname(const char * fullpath)
1360  {
1361 -       char * p, * n = strdup(fullpath);
1362 +       char * p, * n = xstrdup(fullpath);
1363         if((p = strrchr(n, '/')))
1364                 *(p+1) = 0;
1365         else
1366 @@ -864,66 +1178,6 @@
1367         return n;
1368  }
1369
1370 -// adds entries to the filesystem from a text file
1371 -void add2fs_from_file(filesystem *fs, uint32 this_nod, FILE * fh)
1372 -{
1373 -       uint32 mode;
1374 -       uint32 nod, nod2;
1375 -       char cmod[11], *path, *name, *dir;
1376 -       int major, minor;
1377 -       while(fscanf(fh, "%10s", cmod))
1378 -       {
1379 -               if(feof(fh))
1380 -                       break;
1381 -               mode = get_modestr(cmod + 1);
1382 -               switch(*cmod)
1383 -               {
1384 -                       case 'd':
1385 -                               fscanf(fh, "%" SCANF_PREFIX "s\n", SCANF_STRING(path));
1386 -                               break;
1387 -                       case 'c':
1388 -                               mode |= FM_IFCHR;
1389 -                               fscanf(fh, "%i, %i %" SCANF_PREFIX "s\n", &major, &minor, SCANF_STRING(path));
1390 -                               break;
1391 -                       case 'b':
1392 -                               mode |= FM_IFBLK;
1393 -                               fscanf(fh, "%i, %i %" SCANF_PREFIX "s\n", &major, &minor, SCANF_STRING(path));
1394 -                               break;
1395 -                       case '#':
1396 -                               while(fgetc(fh) != '\n');
1397 -                               continue;
1398 -                       default:
1399 -                               errexit("malformed text input file");
1400 -               }
1401 -               name = basename(path);
1402 -               dir = dirname(path);
1403 -               free(path);
1404 -               if(!(nod = find_path(fs, this_nod, dir)))
1405 -                       errexit("can't find directory '%s' to create '%s''", dir, name);
1406 -               free(dir);
1407 -               if((!strcmp(name, ".")) || (!strcmp(name, "..")))
1408 -               {
1409 -                       free(name);
1410 -                       continue;
1411 -               }
1412 -               switch(*cmod)
1413 -               {
1414 -                       case 'd':
1415 -                               mkdir_fs(fs, nod, name, mode);
1416 -                               break;
1417 -                       case 'c':
1418 -                       case 'b':
1419 -                               nod2 = alloc_nod(fs);
1420 -                               get_nod(fs, nod2)->i_mode = mode;
1421 -                               ((uint8*)get_nod(fs, nod2)->i_block)[0] = minor;
1422 -                               ((uint8*)get_nod(fs, nod2)->i_block)[1] = major;
1423 -                               add2dir(fs, nod, nod2, name);
1424 -                               break;
1425 -               }
1426 -               free(name);
1427 -       }
1428 -}
1429 -
1430  // adds a tree of entries to the filesystem from current dir
1431  void add2fs_from_dir(filesystem *fs, uint32 this_nod)
1432  {
1433 @@ -934,7 +1188,7 @@
1434         struct stat st;
1435         uint8 *b;
1436         if(!(dh = opendir(".")))
1437 -               pexit(".");
1438 +               perror_msg_and_die(".");
1439         while((dent = readdir(dh)))
1440         {
1441                 if((!strcmp(dent->d_name, ".")) || (!strcmp(dent->d_name, "..")))
1442 @@ -948,31 +1202,27 @@
1443                                 get_nod(fs, nod)->i_mode = (((st.st_mode & S_IFMT) == S_IFCHR) ? FM_IFCHR : FM_IFBLK) | get_mode(&st);
1444                                 ((uint8*)get_nod(fs, nod)->i_block)[0] = (st.st_rdev & 0xff);
1445                                 ((uint8*)get_nod(fs, nod)->i_block)[1] = (st.st_rdev >> 8);
1446 -                               add2dir(fs, this_nod, nod, dent->d_name);
1447 +                               add2dir(fs, this_nod, nod, dent->d_name, st.st_mode, st.st_uid, st.st_gid, st.st_ctime);
1448                                 break;
1449                         case S_IFLNK:
1450 -                               if(!(b = (uint8*)malloc(rndup(st.st_size, BLOCKSIZE))))
1451 -                                       errexit("out of memory");
1452 -                               if(readlink(dent->d_name, (char*)b, st.st_size) < 0)
1453 -                                       pexit(dent->d_name);
1454 -                               mklink_fs(fs, this_nod, dent->d_name, st.st_size, b);
1455 +                               b = xreadlink(dent->d_name);
1456 +                               mklink_fs(fs, this_nod, dent->d_name, st.st_size, b, st.st_uid, st.st_gid, st.st_ctime);
1457                                 free(b);
1458                                 break;
1459                         case S_IFREG:
1460 -                               if(!(fh = fopen(dent->d_name, "r")))
1461 -                                       pexit(dent->d_name);
1462 -                               mkfile_fs(fs, this_nod, dent->d_name, get_mode(&st), st.st_size, fh);
1463 +                               fh = xfopen(dent->d_name, "r");
1464 +                               mkfile_fs(fs, this_nod, dent->d_name, st.st_mode, st.st_size, fh, st.st_uid, st.st_gid, st.st_ctime);
1465                                 fclose(fh);
1466                                 break;
1467                         case S_IFDIR:
1468 -                               nod = mkdir_fs(fs, this_nod, dent->d_name, get_mode(&st));
1469 +                               nod = mkdir_fs(fs, this_nod, dent->d_name, st.st_mode, st.st_uid, st.st_gid, st.st_ctime);
1470                                 if(chdir(dent->d_name) < 0)
1471 -                                       pexit(dent->d_name);
1472 +                                       perror_msg_and_die(dent->d_name);
1473                                 add2fs_from_dir(fs, nod);
1474                                 chdir("..");
1475                                 break;
1476                         default:
1477 -                               fprintf(stderr, "ignoring entry %s", dent->d_name);
1478 +                               error_msg("ignoring entry %s", dent->d_name);
1479                 }
1480         }
1481         closedir(dh);
1482 @@ -981,9 +1231,11 @@
1483  // endianness swap of x-indirect blocks
1484  void swap_goodblocks(filesystem *fs, inode *nod)
1485  {
1486 -       int i;
1487 +       int i,j,done=0;
1488 +       uint32 *b,*b2;
1489 +
1490         int nblk = nod->i_blocks / INOBLK;
1491 -       if((nod->i_size && !nblk) || (nod->i_mode & (FM_IFBLK | FM_IFCHR)))
1492 +       if((nod->i_size && !nblk) || ((nod->i_mode & FM_IFBLK) == FM_IFBLK) || ((nod->i_mode & FM_IFCHR) == FM_IFCHR))
1493                 for(i = 0; i <= EXT2_TIND_BLOCK; i++)
1494                         nod->i_block[i] = swab32(nod->i_block[i]);
1495         if(nblk <= EXT2_IND_BLOCK)
1496 @@ -991,20 +1243,55 @@
1497         swap_block(get_blk(fs, nod->i_block[EXT2_IND_BLOCK]));
1498         if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4)
1499                 return;
1500 +       /* Currently this will fail b'cos the number of blocks as stored
1501 +          in i_blocks also includes the indirection blocks (see
1502 +          walk_bw). But this function assumes that i_blocks only
1503 +          stores the count of data blocks ( Actually according to
1504 +          "Understanding the Linux Kernel" (Table 17-3 p502 1st Ed)
1505 +          i_blocks IS supposed to store the count of data blocks). so
1506 +          with a file of size 268K nblk would be 269.The above check
1507 +          will be false even though double indirection hasn't been
1508 +          started.This is benign as 0 means block 0 which has been
1509 +          zeroed out and therefore points back to itself from any offset
1510 +        */
1511 +       assert(nod->i_block[EXT2_DIND_BLOCK] != 0);
1512         for(i = 0; i < BLOCKSIZE/4; i++)
1513 +               /* Should this be...
1514 +               if(nblk > EXT2_IND_BLOCK + BLOCKSIZE/4 + (BLOCKSIZE/4)*i )
1515 +               */
1516                 if(nblk > EXT2_IND_BLOCK + BLOCKSIZE/4 + i)
1517                         swap_block(get_blk(fs, ((uint32*)get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]))[i]));
1518         swap_block(get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]));
1519         if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4 + BLOCKSIZE/4 * BLOCKSIZE/4)
1520                 return;
1521 -       errexit("too big file on the filesystem");
1522 +       /* Adding support for triple indirection */
1523 +       b = (uint32*)get_blk(fs,nod->i_block[EXT2_TIND_BLOCK]);
1524 +       for(i=0;i < BLOCKSIZE/4 && !done ; i++) {
1525 +               b2 = (uint32*)get_blk(fs,b[i]);
1526 +               for(j=0; j<BLOCKSIZE/4;j++) {
1527 +                       if (nblk > ( EXT2_IND_BLOCK + BLOCKSIZE/4 +
1528 +                                    (BLOCKSIZE/4)*(BLOCKSIZE/4) +
1529 +                                    i*(BLOCKSIZE/4)*(BLOCKSIZE/4) +
1530 +                                    j*(BLOCKSIZE/4)) )
1531 +                         swap_block(get_blk(fs,b2[j]));
1532 +                       else {
1533 +                         done = 1;
1534 +                         break;
1535 +                       }
1536 +               }
1537 +               swap_block((uint8 *)b2);
1538 +       }
1539 +       swap_block((uint8 *)b);
1540 +       return;
1541  }
1542
1543  void swap_badblocks(filesystem *fs, inode *nod)
1544  {
1545 -       int i;
1546 +       int i,j,done=0;
1547 +       uint32 *b,*b2;
1548 +
1549         int nblk = nod->i_blocks / INOBLK;
1550 -       if((nod->i_size && !nblk) || (nod->i_mode & (FM_IFBLK | FM_IFCHR)))
1551 +       if((nod->i_size && !nblk) || ((nod->i_mode & FM_IFBLK) == FM_IFBLK) || ((nod->i_mode & FM_IFCHR) == FM_IFCHR))
1552                 for(i = 0; i <= EXT2_TIND_BLOCK; i++)
1553                         nod->i_block[i] = swab32(nod->i_block[i]);
1554         if(nblk <= EXT2_IND_BLOCK)
1555 @@ -1012,13 +1299,34 @@
1556         swap_block(get_blk(fs, nod->i_block[EXT2_IND_BLOCK]));
1557         if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4)
1558                 return;
1559 +       /* See comment in swap_goodblocks */
1560 +       assert(nod->i_block[EXT2_DIND_BLOCK] != 0);
1561         swap_block(get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]));
1562         for(i = 0; i < BLOCKSIZE/4; i++)
1563 +               /* See comment in swap_goodblocks */
1564                 if(nblk > EXT2_IND_BLOCK + BLOCKSIZE/4 + i)
1565                         swap_block(get_blk(fs, ((uint32*)get_blk(fs, nod->i_block[EXT2_DIND_BLOCK]))[i]));
1566         if(nblk <= EXT2_IND_BLOCK + BLOCKSIZE/4 + BLOCKSIZE/4 * BLOCKSIZE/4)
1567                 return;
1568 -       errexit("too big file on the filesystem");
1569 +       /* Adding support for triple indirection */
1570 +       b = (uint32*)get_blk(fs,nod->i_block[EXT2_TIND_BLOCK]);
1571 +       swap_block((uint8 *)b);
1572 +       for(i=0;i < BLOCKSIZE/4 && !done ; i++) {
1573 +               b2 = (uint32*)get_blk(fs,b[i]);
1574 +               swap_block((uint8 *)b2);
1575 +               for(j=0; j<BLOCKSIZE/4;j++) {
1576 +                       if (nblk > ( EXT2_IND_BLOCK + BLOCKSIZE/4 +
1577 +                                    (BLOCKSIZE/4)*(BLOCKSIZE/4) +
1578 +                                    i*(BLOCKSIZE/4)*(BLOCKSIZE/4) +
1579 +                                    j*(BLOCKSIZE/4)) )
1580 +                         swap_block(get_blk(fs,b2[j]));
1581 +                       else {
1582 +                         done = 1;
1583 +                         break;
1584 +                       }
1585 +               }
1586 +       }
1587 +       return;
1588  }
1589
1590  // endianness swap of the whole filesystem
1591 @@ -1045,7 +1353,8 @@
1592                 swap_goodblocks(fs, nod);
1593                 swap_nod(nod);
1594         }
1595 -       swap_gd(&fs->gd);
1596 +       for(i=0;i<GRP_NBGROUPS(fs);i++)
1597 +               swap_gd(&(fs->gd[i]));
1598         swap_sb(&fs->sb);
1599  }
1600
1601 @@ -1053,7 +1362,8 @@
1602  {
1603         int i;
1604         swap_sb(&fs->sb);
1605 -       swap_gd(&fs->gd);
1606 +       for(i=0;i<GRP_NBGROUPS(fs);i++)
1607 +               swap_gd(&(fs->gd[i]));
1608         for(i = 1; i < fs->sb.s_inodes_count; i++)
1609         {
1610                 inode *nod = get_nod(fs, i);
1611 @@ -1084,53 +1394,118 @@
1612         directory *d;
1613         uint8 * b;
1614         uint32 nod;
1615 +       uint32 nbgroups,nbinodes_per_group,overhead_per_group,free_blocks,
1616 +               free_blocks_per_group,nbblocks_per_group;
1617 +       uint32 gd,itbl,ibmpos,bbmpos,itblpos;
1618 +       int j;
1619 +       uint8 *bbm,*ibm;
1620 +       inode *itab0;
1621
1622         if(nbblocks < 16) // totally arbitrary
1623 -               errexit("too small filesystem");
1624 -       if(nbblocks >BLOCKS_PER_GROUP) // I build only one group
1625 -               errexit("too big filesystem");
1626 +               error_msg_and_die("too small filesystem");
1627 +
1628 +       /* nbblocks is the total number of blocks in the system. First
1629 +        * calculate how much overhead blocks - inode table blocks,bitmap
1630 +        * blocks,group descriptor blocks etc. - are needed assuming each
1631 +        * group has BLOCKS_PER_GROUP blocks.Then recalculate nbblocks with
1632 +        * this figure. Each group has the same number of blocks. So the fs
1633 +        * has a size atleast the given value but usually rounded off to a i
1634 +        * higher number.
1635 +        */
1636 +       nbgroups = rndup(nbblocks,BLOCKS_PER_GROUP)/ BLOCKS_PER_GROUP;
1637 +       nbinodes_per_group = nbinodes/nbgroups +1;
1638 +       nbinodes_per_group = rndup(nbinodes_per_group, BLOCKSIZE/sizeof(inode));
1639 +       if (nbinodes_per_group < 16)
1640 +               nbinodes_per_group = 16; //minimum number b'cos the first 10 are reserved
1641 +       overhead_per_group = 3 /*super block,ibm,bbm*/
1642 +                            + /* No. of blocks that the inodes occupy */
1643 +                              nbinodes_per_group *sizeof(inode)/BLOCKSIZE
1644 +                            + /* No. of blocks that group descriptors occupy */
1645 +                              rndup(nbgroups*sizeof(groupdescriptor),BLOCKSIZE)/BLOCKSIZE;
1646 +       free_blocks = nbblocks - overhead_per_group * nbgroups - 1 /*boot block */;
1647 +       free_blocks_per_group = free_blocks/nbgroups;
1648 +       if (free_blocks > free_blocks_per_group * nbgroups)
1649 +               free_blocks_per_group++;
1650 +       nbblocks_per_group = free_blocks_per_group + overhead_per_group;
1651 +       /* e2fsck complains if nbblocks_per_group is not a multiple of 8 */
1652 +       nbblocks_per_group = rndup(nbblocks_per_group,8);
1653 +       free_blocks_per_group = nbblocks_per_group - overhead_per_group;
1654 +       if (nbblocks_per_group > BLOCKS_PER_GROUP) {
1655 +               /* Can this happen ? */
1656 +               nbblocks_per_group = BLOCKS_PER_GROUP;
1657 +               free_blocks_per_group = nbblocks_per_group - overhead_per_group;
1658 +       }
1659 +       nbblocks = nbblocks_per_group * nbgroups + 1;
1660 +
1661 +
1662         if(!(fs = (filesystem*)calloc(nbblocks, BLOCKSIZE)))
1663 -               errexit("not enough memory for filesystem");
1664 +               error_msg_and_die("not enough memory for filesystem");
1665
1666         // create the superblock for an empty filesystem
1667 -       fs->sb.s_inodes_count = rndup(nbinodes, BLOCKSIZE/sizeof(inode));
1668 +       fs->sb.s_inodes_count = nbinodes_per_group * nbgroups;
1669         fs->sb.s_blocks_count = nbblocks;
1670         fs->sb.s_r_blocks_count = nbresrvd;
1671 -       fs->sb.s_free_blocks_count = nbblocks;
1672 +       fs->sb.s_free_blocks_count = free_blocks_per_group*nbgroups;
1673         fs->sb.s_free_inodes_count = fs->sb.s_inodes_count - EXT2_FIRST_INO + 1;
1674         fs->sb.s_first_data_block = (BLOCKSIZE == 1024);
1675         fs->sb.s_log_block_size = BLOCKSIZE >> 11;
1676         fs->sb.s_log_frag_size = BLOCKSIZE >> 11;
1677 -       fs->sb.s_blocks_per_group = BLOCKS_PER_GROUP;
1678 -       fs->sb.s_frags_per_group = BLOCKS_PER_GROUP;
1679 -       fs->sb.s_inodes_per_group = fs->sb.s_inodes_count;
1680 +       fs->sb.s_blocks_per_group = nbblocks_per_group;
1681 +       fs->sb.s_frags_per_group = nbblocks_per_group;
1682 +       fs->sb.s_inodes_per_group = nbinodes_per_group;
1683         fs->sb.s_magic = EXT2_MAGIC_NUMBER;
1684
1685         // set up groupdescriptors
1686 -       fs->sb.s_free_blocks_count -= 5 + fs->sb.s_inodes_count * sizeof(inode) / BLOCKSIZE;
1687 -       fs->gd.bg_free_blocks_count = fs->sb.s_free_blocks_count;
1688 -       fs->gd.bg_free_inodes_count = fs->sb.s_free_inodes_count;
1689 -       fs->gd.bg_used_dirs_count = 1;
1690 -       fs->gd.bg_block_bitmap = 3;
1691 -       fs->gd.bg_inode_bitmap = 4;
1692 -       fs->gd.bg_inode_table = 5;
1693 -
1694 -       // mark non-filesystem blocks and inodes as allocated
1695 -       for(i = fs->sb.s_blocks_count; i <= BLOCKSIZE * 8; i++)
1696 -               allocate(fs->bbm, i);
1697 -       for(i = fs->sb.s_inodes_count + 1; i <= BLOCKSIZE * 8; i++)
1698 -               allocate(fs->ibm, i);
1699 -
1700 -       // mark system blocsk and inodes as allocated
1701 -       for(i = 1; i <= 4 + fs->sb.s_inodes_count * sizeof(inode) / BLOCKSIZE; i++)
1702 -               allocate(fs->bbm, i);
1703 -       for(i = 1; i < EXT2_FIRST_INO; i++)
1704 -               allocate(fs->ibm, i);
1705 -
1706 -       // make root inode and directory
1707 -       fs->itab[EXT2_ROOT_INO-1].i_mode = FM_IFDIR | FM_IRWXU | FM_IRWXG | FM_IRWXO;
1708 -       fs->itab[EXT2_ROOT_INO-1].i_size = BLOCKSIZE;
1709 -       fs->itab[EXT2_ROOT_INO-1].i_links_count = 2;
1710 +       gd = rndup(nbgroups*sizeof(groupdescriptor),BLOCKSIZE)/BLOCKSIZE;
1711 +       itbl = nbinodes_per_group*sizeof(inode)/BLOCKSIZE;
1712 +       for(i = 0,bbmpos=2+gd,ibmpos=3+gd,itblpos =4+gd;
1713 +               i<nbgroups;
1714 +               i++, bbmpos += nbblocks_per_group,ibmpos += nbblocks_per_group,
1715 +               itblpos += nbblocks_per_group)  {
1716 +
1717 +               fs->gd[i].bg_free_blocks_count = free_blocks_per_group;
1718 +               fs->gd[i].bg_free_inodes_count = nbinodes_per_group;
1719 +               fs->gd[i].bg_used_dirs_count = 0;
1720 +               fs->gd[i].bg_block_bitmap = bbmpos;
1721 +               fs->gd[i].bg_inode_bitmap = ibmpos;
1722 +               fs->gd[i].bg_inode_table = itblpos;
1723 +       }
1724 +
1725 +       /* Mark non-filesystem blocks and inodes as allocated */
1726 +       /* Mark system blocks and inodes as allocated         */
1727 +       for(i = 0; i<nbgroups;i++) {
1728 +
1729 +               /* Block bitmap */
1730 +               bbm = get_blk(fs,fs->gd[i].bg_block_bitmap);
1731 +               //non-filesystem blocks.
1732 +               for(j=fs->sb.s_blocks_per_group + 1; j <= BLOCKSIZE * 8; j++)
1733 +                       allocate(bbm, j);
1734 +               //system blocks
1735 +               for(j = 1; j <= 3+gd+itbl; j++)
1736 +                       allocate(bbm, j);
1737 +
1738 +               /* Inode bitmap */
1739 +               ibm = get_blk(fs,fs->gd[i].bg_inode_bitmap);
1740 +               //non-filesystem inodes
1741 +               for(j = fs->sb.s_inodes_per_group+1; j <= BLOCKSIZE * 8; j++)
1742 +                       allocate(ibm, j);
1743 +       }
1744 +
1745 +       /* We have groups now. Add the root filesystem in group 0  */
1746 +       /* Also allocate the system inodes in group 0 and update   */
1747 +       /* directory count and inode count for group 0             */
1748 +
1749 +       ibm = get_blk(fs,fs->gd[0].bg_inode_bitmap);
1750 +       for(j = 1; j < EXT2_FIRST_INO; j++) {
1751 +               allocate(ibm, j);
1752 +               fs->gd[0].bg_free_inodes_count--;
1753 +       }
1754 +       fs->gd[0].bg_used_dirs_count = 1;
1755 +       itab0 = (inode *)get_blk(fs,fs->gd[0].bg_inode_table);
1756 +       itab0[EXT2_ROOT_INO-1].i_mode = FM_IFDIR | FM_IRWXU | FM_IRWXG | FM_IRWXO;
1757 +       itab0[EXT2_ROOT_INO-1].i_size = BLOCKSIZE;
1758 +       itab0[EXT2_ROOT_INO-1].i_links_count = 2;
1759 +
1760         b = get_workblk();
1761         d = (directory*)b;
1762         d->d_inode = EXT2_ROOT_INO;
1763 @@ -1147,9 +1522,14 @@
1764         // make lost+found directory and reserve blocks
1765         if(fs->sb.s_r_blocks_count)
1766         {
1767 -               nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", FM_IRWXU | FM_IRWXG | FM_IRWXO);
1768 +               nod = mkdir_fs(fs, EXT2_ROOT_INO, "lost+found", S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, 0, 0, time(NULL));
1769                 memset(b, 0, BLOCKSIZE);
1770                 ((directory*)b)->d_rec_len = BLOCKSIZE;
1771 +               /* We run into problems with e2fsck if directory lost+found grows
1772 +                * bigger than this. Need to find out why this happens - sundar
1773 +                */
1774 +               if (fs->sb.s_r_blocks_count > 2049 )
1775 +                       fs->sb.s_r_blocks_count=2049;
1776                 for(i = 1; i < fs->sb.s_r_blocks_count; i++)
1777                         extend_blk(fs, nod, b, 1);
1778                 get_nod(fs, nod)->i_size = fs->sb.s_r_blocks_count * BLOCKSIZE;
1779 @@ -1170,24 +1550,24 @@
1780  // loads a filesystem from disk
1781  filesystem * load_fs(FILE * fh, int swapit)
1782  {
1783 -       size_t fssize;
1784 +       size_t fssize = 0;
1785         filesystem *fs;
1786         if((fseek(fh, 0, SEEK_END) < 0) || ((fssize = ftell(fh)) < 0))
1787 -               pexit("input filesystem image");
1788 +               perror_msg_and_die("input filesystem image");
1789         rewind(fh);
1790         fssize = (fssize + BLOCKSIZE - 1) / BLOCKSIZE;
1791         if(fssize < 16) // totally arbitrary
1792 -               errexit("too small filesystem");
1793 -       if(fssize > BLOCKS_PER_GROUP) // I build only one group
1794 -               errexit("too big filesystem");
1795 +               error_msg_and_die("too small filesystem");
1796 +/*     if(fssize > BLOCKS_PER_GROUP) // I build only one group
1797 +               error_msg_and_die("too big filesystem"); */
1798         if(!(fs = (filesystem*)calloc(fssize, BLOCKSIZE)))
1799 -               errexit("not enough memory for filesystem");
1800 +               error_msg_and_die("not enough memory for filesystem");
1801         if(fread(fs, BLOCKSIZE, fssize, fh) != fssize)
1802 -               pexit("input filesystem image");
1803 +               perror_msg_and_die("input filesystem image");
1804         if(swapit)
1805                 swap_badfs(fs);
1806         if(fs->sb.s_rev_level || (fs->sb.s_magic != EXT2_MAGIC_NUMBER))
1807 -               errexit("not a suitable ext2 filesystem");
1808 +               error_msg_and_die("not a suitable ext2 filesystem");
1809         return fs;
1810  }
1811
1812 @@ -1230,9 +1610,9 @@
1813         while((bk = walk_bw(fs, nod, &bw, 0, 0)) != WALK_END)
1814         {
1815                 if(fsize <= 0)
1816 -                       errexit("wrong size while saving inode %d", nod);
1817 +                       error_msg_and_die("wrong size while saving inode %d", nod);
1818                 if(fwrite(get_blk(fs, bk), (fsize > BLOCKSIZE) ? BLOCKSIZE : fsize, 1, f) != 1)
1819 -                       errexit("error while saving inode %d", nod);
1820 +                       error_msg_and_die("error while saving inode %d", nod);
1821                 fsize -= BLOCKSIZE;
1822         }
1823  }
1824 @@ -1250,7 +1630,7 @@
1825         {
1826                 int i, j;
1827                 if(fsize <= 0)
1828 -                       errexit("wrong size while saving inode %d", nod);
1829 +                       error_msg_and_die("wrong size while saving inode %d", nod);
1830                 b = get_blk(fs, bk);
1831                 for(i = 0; i < 64; i++)
1832                 {
1833 @@ -1406,7 +1786,7 @@
1834                         s = (nod >= EXT2_FIRST_INO) ? "normal" : "unknown reserved";
1835         }
1836         printf("inode %d (%s, %d links): ", nod, s, get_nod(fs, nod)->i_links_count);
1837 -       if(!allocated(fs->ibm, nod))
1838 +       if(!allocated(GRP_GET_INODE_BITMAP(fs,nod), GRP_IBM_OFFSET(fs,nod)))
1839         {
1840                 printf("unallocated\n");
1841                 return;
1842 @@ -1440,24 +1820,46 @@
1843                 default:
1844                         list_blocks(fs, nod);
1845         }
1846 +       printf("Done with inode %d\n",nod);
1847  }
1848
1849  // describes various fields in a filesystem
1850  void print_fs(filesystem *fs)
1851  {
1852 -       int i;
1853 -       printf("%d blocks (%d free, %d reserved), first data block: %d\n", fs->sb.s_blocks_count, fs->sb.s_free_blocks_count, fs->sb.s_r_blocks_count, fs->sb.s_first_data_block);
1854 -       printf("%d inodes (%d free)\n", fs->sb.s_inodes_count, fs->sb.s_free_inodes_count);
1855 -       printf("block size = %d, frag size = %d\n", fs->sb.s_log_block_size ? (fs->sb.s_log_block_size << 11) : 1024, fs->sb.s_log_frag_size ? (fs->sb.s_log_frag_size << 11) : 1024);
1856 -       printf("%d blocks per group, %d frags per group, %d inodes per group\n", fs->sb.s_blocks_per_group, fs->sb.s_frags_per_group, fs->sb.s_inodes_per_group);
1857 -       printf("block bitmap: block %d, inode bitmap: block %d, inode table: block %d\n", fs->gd.bg_block_bitmap, fs->gd.bg_inode_bitmap, fs->gd.bg_inode_table);
1858 -       printf("block bitmap allocation:\n");
1859 -       print_bm(fs->bbm, fs->sb.s_blocks_count);
1860 -       printf("inode bitmap allocation:\n");
1861 -       print_bm(fs->ibm, fs->sb.s_inodes_count);
1862 -       for(i=1; i<=fs->sb.s_inodes_count; i++)
1863 -               if(allocated(fs->ibm, i))
1864 -                       print_inode(fs, i);
1865 +       int i,j;
1866 +       uint8 *ibm;
1867 +
1868 +       printf("%d blocks (%d free, %d reserved), first data block: %d\n",
1869 +              fs->sb.s_blocks_count, fs->sb.s_free_blocks_count,
1870 +              fs->sb.s_r_blocks_count, fs->sb.s_first_data_block);
1871 +       printf("%d inodes (%d free)\n", fs->sb.s_inodes_count,
1872 +              fs->sb.s_free_inodes_count);
1873 +       printf("block size = %d, frag size = %d\n",
1874 +              fs->sb.s_log_block_size ? (fs->sb.s_log_block_size << 11) : 1024,
1875 +              fs->sb.s_log_frag_size ? (fs->sb.s_log_frag_size << 11) : 1024);
1876 +       printf("Number of groups: %d\n",GRP_NBGROUPS(fs));
1877 +       printf("%d blocks per group,%d frags per group,%d inodes per group\n",
1878 +            fs->sb.s_blocks_per_group, fs->sb.s_frags_per_group,
1879 +            fs->sb.s_inodes_per_group);
1880 +       printf("Size of inode table: %d blocks\n",
1881 +                       fs->sb.s_inodes_per_group * sizeof(inode)/BLOCKSIZE);
1882 +       for (i = 0; i < GRP_NBGROUPS(fs); i++) {
1883 +               printf("Group No: %d\n", i);
1884 +               printf("block bitmap: block %d,inode bitmap: block %d, inode table: block %d\n",
1885 +                    fs->gd[i].bg_block_bitmap, fs->gd[i].bg_inode_bitmap,
1886 +                    fs->gd[i].bg_inode_table);
1887 +               printf("Free blocks count: %d\n",fs->gd[i].bg_free_blocks_count);
1888 +               printf("Free inodes count: %d\n",fs->gd[i].bg_free_inodes_count);
1889 +               printf("Used dir count: %d\n",fs->gd[i].bg_used_dirs_count);
1890 +               printf("block bitmap allocation:\n");
1891 +               print_bm(GRP_GET_GROUP_BBM(fs, i),fs->sb.s_blocks_per_group);
1892 +               printf("inode bitmap allocation:\n");
1893 +               ibm = GRP_GET_GROUP_IBM(fs, i);
1894 +               print_bm(ibm, fs->sb.s_inodes_per_group);
1895 +               for (j = 1; j <= fs->sb.s_inodes_per_group; j++)
1896 +                       if (allocated(ibm, j))
1897 +                               print_inode(fs, i*fs->sb.s_inodes_per_group + j);
1898 +       }
1899  }
1900
1901  void dump_fs(filesystem *fs, FILE * fh, int swapit)
1902 @@ -1467,31 +1869,234 @@
1903         if(swapit)
1904                 swap_goodfs(fs);
1905         if(fwrite(fs, BLOCKSIZE, nbblocks, fh) < nbblocks)
1906 -               pexit("output filesystem image");
1907 +               perror_msg_and_die("output filesystem image");
1908         if(swapit)
1909                 swap_badfs(fs);
1910  }
1911
1912 +/*  device table entries take the form of:
1913 +    <path>     <type> <mode>   <uid>   <gid>   <major> <minor> <start> <inc>   <count>
1914 +    /dev/mem     c    640       0       0         1       1       0     0         -
1915 +
1916 +    type can be one of:
1917 +       f       A regular file
1918 +       d       Directory
1919 +       c       Character special device file
1920 +       b       Block special device file
1921 +       p       Fifo (named pipe)
1922 +
1923 +    I don't bother with symlinks (permissions are irrelevant), hard
1924 +    links (special cases of regular files), or sockets (why bother).
1925 +
1926 +    Regular files must exist in the target root directory.  If a char,
1927 +    block, fifo, or directory does not exist, it will be created.
1928 +*/
1929 +static int interpret_table_entry(filesystem *fs, char *line)
1930 +{
1931 +       char type, *name = NULL, *tmp, *dir, *bname;
1932 +       unsigned long mode = 0755, uid = 0, gid = 0, major = 0, minor = 0;
1933 +       unsigned long start = 0, increment = 1, count = 0;
1934 +       inode *entry;
1935 +       uint32 nod, parent;
1936 +
1937 +       if (sscanf (line, "%" SCANF_PREFIX "s %c %lo %lu %lu %lu %lu %lu %lu %lu",
1938 +                               SCANF_STRING(name), &type, &mode, &uid, &gid, &major, &minor,
1939 +                               &start, &increment, &count) < 0)
1940 +       {
1941 +               return 1;
1942 +       }
1943 +
1944 +       if (!strcmp(name, "/")) {
1945 +               error_msg_and_die("Device table entries require absolute paths");
1946 +       }
1947 +
1948 +       /* Check if this file already exists... */
1949 +       switch (type) {
1950 +               case 'd':
1951 +                       mode |= S_IFDIR;
1952 +                       break;
1953 +               case 'f':
1954 +                       mode |= S_IFREG;
1955 +                       break;
1956 +               case 'p':
1957 +                       mode |= S_IFIFO;
1958 +                       break;
1959 +               case 'c':
1960 +                       mode |= S_IFCHR;
1961 +                       break;
1962 +               case 'b':
1963 +                       mode |= S_IFBLK;
1964 +                       break;
1965 +               default:
1966 +                       error_msg_and_die("Unsupported file type");
1967 +       }
1968 +       nod = 0;
1969 +       if (count==0)
1970 +               nod = find_path(fs, EXT2_ROOT_INO, name);
1971 +       if (nod) {
1972 +               /* Ok, we just need to fixup an existing entry
1973 +                * and we will be all done... */
1974 +               entry = get_nod(fs, nod);
1975 +               entry->i_uid = uid;
1976 +               entry->i_gid = gid;
1977 +               entry->i_mode = mode;
1978 +               if (major) {
1979 +                       dev_t rdev = makedev(major, minor);
1980 +                       ((uint8*)entry->i_block)[0] = (rdev & 0xff);
1981 +                       ((uint8*)entry->i_block)[1] = (rdev >> 8);
1982 +               }
1983 +       } else {
1984 +               /* Try and find our parent now */
1985 +               tmp = xstrdup(name);
1986 +               dir = dirname(tmp);
1987 +               parent = find_path(fs, EXT2_ROOT_INO, dir);
1988 +               free(tmp);
1989 +               if (!parent) {
1990 +                       error_msg ("skipping device_table entry '%s': no parent directory!", name);
1991 +                       free(name);
1992 +                       return 1;
1993 +               }
1994 +
1995 +               tmp = xstrdup(name);
1996 +               bname = xstrdup(basename(tmp));
1997 +               free(tmp);
1998 +               switch (type) {
1999 +                       case 'd':
2000 +                               mkdir_fs(fs, parent, bname, mode|FM_IFDIR, uid, gid, time(NULL));
2001 +                               break;
2002 +                       case 'f':
2003 +#if 0
2004 +                               {
2005 +                                       // This is a bit odd.. This will try to include
2006 +                                       // the file of the same name from your _build_
2007 +                                       // system...  Probably a very bad idea....
2008 +                                       struct stat st;
2009 +                                       FILE *fh = xfopen(name, "r");
2010 +                                       lstat(name, &st);
2011 +                                       mkfile_fs(fs, parent, bname, mode|FM_IFREG, st.st_size, fh, uid, gid, st.st_ctime);
2012 +                                       fclose(fh);
2013 +                               }
2014 +#else
2015 +                               error_msg("ignoring entry %s", name);
2016 +#endif
2017 +                               break;
2018 +                       case 'p':
2019 +                               error_msg("ignoring entry %s", name);
2020 +                               break;
2021 +                       case 'c':
2022 +                       case 'b':
2023 +                               if (count > 0) {
2024 +                                       dev_t rdev;
2025 +                                       char *dname;
2026 +                                       unsigned long i;
2027 +                                       for (i = start; i < count; i++) {
2028 +                                               asprintf(&dname, "%s%lu", bname, i);
2029 +                                               nod = find_path(fs, EXT2_ROOT_INO, dname);
2030 +                                               if (nod) {
2031 +                                                       /* We just need to fixup an existing entry */
2032 +                                                       entry = get_nod(fs, nod);
2033 +                                               } else {
2034 +                                                       nod = alloc_nod(fs);
2035 +                                                       add2dir(fs, parent, nod, dname, mode, uid, gid, time(NULL));
2036 +                                                       entry = get_nod(fs, nod);
2037 +                                               }
2038 +                                               entry->i_uid = uid;
2039 +                                               entry->i_gid = gid;
2040 +                                               entry->i_mode = mode;
2041 +                                               rdev = makedev(major, minor + (i * increment - start));
2042 +                                               ((uint8*)entry->i_block)[0] = (rdev & 0xff);
2043 +                                               ((uint8*)entry->i_block)[1] = (rdev >> 8);
2044 +                                               free(dname);
2045 +                                       }
2046 +                               } else {
2047 +                                       dev_t rdev = makedev(major, minor);
2048 +                                       nod = alloc_nod(fs);
2049 +                                       add2dir(fs, parent, nod, bname, mode, uid, gid, time(NULL));
2050 +                                       entry = get_nod(fs, nod);
2051 +                                       ((uint8*)entry->i_block)[0] = (rdev & 0xff);
2052 +                                       ((uint8*)entry->i_block)[1] = (rdev >> 8);
2053 +                               }
2054 +                               break;
2055 +                       default:
2056 +                               error_msg_and_die("Unsupported file type");
2057 +               }
2058 +               free(bname);
2059 +       }
2060 +       free(name);
2061 +       return 0;
2062 +}
2063 +
2064 +static int parse_device_table(filesystem *root, FILE * file)
2065 +{
2066 +       char *line;
2067 +       int status = 0;
2068 +       size_t length = 0;
2069 +
2070 +       /* Turn off squash, since we must ensure that values
2071 +        * entered via the device table are not squashed */
2072 +       squash_uids = 0;
2073 +       squash_perms = 0;
2074 +
2075 +       /* Looks ok so far.  The general plan now is to read in one
2076 +        * line at a time, check for leading comment delimiters ('#'),
2077 +        * then try and parse the line as a device table.  If we fail
2078 +        * to parse things, try and help the poor fool to fix their
2079 +        * device table with a useful error msg... */
2080 +       line = NULL;
2081 +       while (getline(&line, &length, file) != -1) {
2082 +               /* First trim off any whitespace */
2083 +               int len = strlen(line);
2084 +
2085 +               /* trim trailing whitespace */
2086 +               while (len > 0 && isspace(line[len - 1]))
2087 +                       line[--len] = '\0';
2088 +               /* trim leading whitespace */
2089 +               memmove(line, &line[strspn(line, " \n\r\t\v")], len);
2090 +
2091 +               /* How long are we after trimming? */
2092 +               len = strlen(line);
2093 +
2094 +               /* If this is NOT a comment line, try to interpret it */
2095 +               if (len && *line != '#') {
2096 +                       if (interpret_table_entry(root, line))
2097 +                               status = 1;
2098 +               }
2099 +
2100 +               free(line);
2101 +               line = NULL;
2102 +       }
2103 +       fclose(file);
2104 +
2105 +       return status;
2106 +}
2107 +
2108 +/*
2109 +Local Variables:
2110 +c-file-style: "linux"
2111 +c-basic-offset: 4
2112 +tab-width: 4
2113 +End:
2114 +*/
2115 +
2116  void showhelp(void)
2117  {
2118         fprintf(stderr, "Usage: %s [options] image\n"
2119         "Create an ext2 filesystem image from directories/files\n\n"
2120 -       "  -x image                Use this image as a starting point\n"
2121 -       "  -d directory            Add this directory as source\n"
2122 -       "  -f file                 Add nodes (e.g. devices) from this spec file\n"
2123 -       "  -b blocks               Size in blocks\n"
2124 -       "  -i inodes               Number of inodes\n"
2125 -       "  -r reserved             Number of reserved blocks\n"
2126 -       "  -g path                 Generate a block map file for this path\n"
2127 -       "  -e value                Fill unallocated blocks with value\n"
2128 -       "  -z                      Make files with holes\n"
2129 -       "  -v                      Print resulting filesystem structure\n"
2130 -       "  -h                      Show this help\n\n"
2131 -       "Example of spec file:\n"
2132 -       "drwx            /dev\n"
2133 -       "crw-    10,190  /dev/lcd\n"
2134 -       "brw-    1,0     /dev/ram0\n\n"
2135 -       "Report bugs to xavier.bestel@free.fr\n", argv0);
2136 +       "  -x image         Use this image as a starting point\n"
2137 +       "  -d directory     Add this directory as source\n"
2138 +       "  -b blocks        Size in blocks\n"
2139 +       "  -i inodes        Number of inodes\n"
2140 +       "  -r reserved      Number of reserved blocks\n"
2141 +       "  -g path          Generate a block map file for this path\n"
2142 +       "  -e value         Fill unallocated blocks with value\n"
2143 +       "  -z               Make files with holes\n"
2144 +       "  -D,-f            Use the named FILE as a device table file\n"
2145 +       "  -q               Squash permissions and owners making all files be owned by root\n"
2146 +       "  -U               Squash owners making all files be owned by root\n"
2147 +       "  -P               Squash permissions on all files\n"
2148 +       "  -v               Print resulting filesystem structure\n"
2149 +       "  -h               Show this help\n\n"
2150 +       "Report bugs to xavier.bestel@free.fr\n", app_name);
2151  }
2152
2153  #define MAX_DOPT 128
2154 @@ -1521,21 +2126,17 @@
2155         filesystem *fs;
2156         int i;
2157         int c;
2158 +       struct stat sb;
2159 +       FILE *devtable = NULL;
2160
2161 -       argv0 = argv[0];
2162 -       if(argc <= 1)
2163 -       {
2164 -               showhelp();
2165 -               exit(1);
2166 -       }
2167 -       while((c = getopt(argc, argv, "x:f:d:b:i:r:g:e:zvh")) != EOF)
2168 +       app_name = argv[0];
2169 +       while((c = getopt(argc, argv, "x:d:b:i:r:g:e:zvhD:f:qUP")) != EOF)
2170                 switch(c)
2171                 {
2172                         case 'x':
2173                                 fsin = optarg;
2174                                 break;
2175                         case 'd':
2176 -                       case 'f':
2177                                 dopt[didx++] = optarg;
2178                                 break;
2179                         case 'b':
2180 @@ -1556,6 +2157,24 @@
2181                         case 'z':
2182                                 holes = 1;
2183                                 break;
2184 +                       case 'f':
2185 +                       case 'D':
2186 +                               devtable = xfopen(optarg, "r");
2187 +                               if (fstat(fileno(devtable), &sb) < 0)
2188 +                                       perror_msg_and_die(optarg);
2189 +                               if (sb.st_size < 10)
2190 +                                       error_msg_and_die("%s: not a proper device table file", optarg);
2191 +                               break;
2192 +                       case 'q':
2193 +                               squash_uids = 1;
2194 +                               squash_perms = 1;
2195 +                               break;
2196 +                       case 'U':
2197 +                               squash_uids = 1;
2198 +                               break;
2199 +                       case 'P':
2200 +                               squash_perms = 1;
2201 +                               break;
2202                         case 'v':
2203                                 verbose = 1;
2204                                 break;
2205 @@ -1566,16 +2185,14 @@
2206                                 exit(1);
2207                 }
2208         if(optind < (argc - 1))
2209 -               errexit("too many arguments");
2210 +               error_msg_and_die("too many arguments");
2211         if(optind == (argc - 1))
2212                 fsout = argv[optind];
2213         if(fsin)
2214         {
2215                 if(strcmp(fsin, "-"))
2216                 {
2217 -                       FILE * fh = fopen(fsin, "r");
2218 -                       if(!fh)
2219 -                               pexit(fsin);
2220 +                       FILE * fh = xfopen(fsin, "r");
2221                         fs = load_fs(fh, bigendian);
2222                         fclose(fh);
2223                 }
2224 @@ -1585,7 +2202,7 @@
2225         else
2226         {
2227                 if(nbblocks == -1)
2228 -                       errexit("filesystem size unspecified");
2229 +                       error_msg_and_die("filesystem size unspecified");
2230                 if(nbinodes == -1)
2231                         nbinodes = nbblocks * BLOCKSIZE / rndup(BYTES_PER_INODE, BLOCKSIZE);
2232                 if(nbresrvd == -1)
2233 @@ -1595,35 +2212,30 @@
2234         for(i = 0; i < didx; i++)
2235         {
2236                 struct stat st;
2237 -               FILE *fh;
2238                 char *pdir;
2239                 stat(dopt[i], &st);
2240                 switch(st.st_mode & S_IFMT)
2241                 {
2242 -                       case S_IFREG:
2243 -                               if(!(fh = fopen(dopt[i], "r")))
2244 -                                       pexit(dopt[i]);
2245 -                               add2fs_from_file(fs, EXT2_ROOT_INO, fh);
2246 -                               fclose(fh);
2247 -                               break;
2248                         case S_IFDIR:
2249                                 if(!(pdir = getcwd(0, GETCWD_SIZE)))
2250 -                                       pexit(dopt[i]);
2251 +                                       perror_msg_and_die(dopt[i]);
2252                                 if(chdir(dopt[i]) < 0)
2253 -                                       pexit(dopt[i]);
2254 +                                       perror_msg_and_die(dopt[i]);
2255                                 add2fs_from_dir(fs, EXT2_ROOT_INO);
2256                                 if(chdir(pdir) < 0)
2257 -                                       pexit(pdir);
2258 +                                       perror_msg_and_die(pdir);
2259                                 free(pdir);
2260                                 break;
2261                         default:
2262 -                               errexit("%s in neither a file nor a directory", dopt[i]);
2263 +                               error_msg_and_die("%s is neither a file nor a directory", dopt[i]);
2264                 }
2265         }
2266         if(emptyval)
2267                 for(i = 1; i < fs->sb.s_blocks_count; i++)
2268 -                       if(!allocated(fs->bbm, i))
2269 +                       if(!allocated(GRP_GET_BLOCK_BITMAP(fs,i),GRP_BBM_OFFSET(fs,i)))
2270                                 memset(get_blk(fs, i), emptyval, BLOCKSIZE);
2271 +       if(devtable)
2272 +               parse_device_table(fs, devtable);
2273         if(verbose)
2274                 print_fs(fs);
2275         for(i = 0; i < gidx; i++)
2276 @@ -1633,21 +2245,18 @@
2277                 char *p;
2278                 FILE *fh;
2279                 if(!(nod = find_path(fs, EXT2_ROOT_INO, gopt[i])))
2280 -                       errexit("path %s not found in filesystem", gopt[i]);
2281 +                       error_msg_and_die("path %s not found in filesystem", gopt[i]);
2282                 while((p = strchr(gopt[i], '/')))
2283                         *p = '_';
2284                 snprintf(fname, MAX_FILENAME-1, "%s.blk", gopt[i]);
2285 -               if(!(fh = fopen(fname, "w")))
2286 -                       pexit(fname);
2287 +               fh = xfopen(fname, "w");
2288                 fprintf(fh, "%d:", get_nod(fs, nod)->i_size);
2289                 flist_blocks(fs, nod, fh);
2290                 fclose(fh);
2291         }
2292         if(strcmp(fsout, "-"))
2293         {
2294 -               FILE * fh = fopen(fsout, "w");
2295 -               if(!fh)
2296 -                       pexit(fsout);
2297 +               FILE * fh = xfopen(fsout, "w");
2298                 dump_fs(fs, fh, bigendian);
2299                 fclose(fh);
2300         }
2301 diff -urN genext2fs-1.3.orig/test-mount.sh genext2fs-1.3/test-mount.sh
2302 --- genext2fs-1.3.orig/test-mount.sh    1969-12-31 17:00:00.000000000 -0700
2303 +++ genext2fs-1.3/test-mount.sh 2003-04-21 01:41:42.000000000 -0600
2304 @@ -0,0 +1,96 @@
2305 +#!/bin/sh
2306 +set -e
2307 +
2308 +cleanup () {
2309 +       set +e
2310 +       umount mnt 2>/dev/null
2311 +       rm -rf mnt ext2.img lsout fout test 2>/dev/null
2312 +}
2313 +
2314 +# dtest - Uses the -d directory option of genext2fs
2315 +# Creates an image with a file of given size and verifies it
2316 +# Usage: dtest file-size number-of-blocks
2317 +dtest () {
2318 +       size=$1; blocks=$2;fname=$size
2319 +       echo "Testing with file of size $size "
2320 +       mkdir -p test
2321 +       cd test
2322 +       dd if=/dev/zero of=file.$1 bs=1 count=$size
2323 +       cd ..
2324 +       ./genext2fs -b $blocks -d test ext2.img
2325 +       md5=`md5sum ext2.img | cut -f1 -d " "`
2326 +       if ! /sbin/e2fsck -fn ext2.img ; then
2327 +               echo "fsck failed"
2328 +               echo FAILED
2329 +               cleanup
2330 +               exit 1
2331 +       fi
2332 +       mkdir -p mnt
2333 +       if ! mount -t ext2 -o loop ext2.img mnt; then
2334 +               echo FAILED
2335 +               cleanup
2336 +               exit 1
2337 +       fi
2338 +       if (! [ -f mnt/file.$fname ]) || \
2339 +                       [ $fname != "`ls -al mnt | grep file.$fname |awk '{print $5}'`" ] ; then
2340 +               echo FAILED
2341 +               cleanup
2342 +               exit 1
2343 +       fi
2344 +       echo PASSED "(md5 checksum for the image: $md5)"
2345 +       cleanup
2346 +}
2347 +
2348 +# ftest - Uses the -f spec-file option of genext2fs
2349 +# Creates an image with the devices mentioned in the given spec
2350 +# file and verifies it
2351 +# Usage: ftest spec-file number-of-blocks
2352 +ftest () {
2353 +       fname=$1; blocks=$2;
2354 +       echo "Testing with devices file $fname"
2355 +       ./genext2fs -b $blocks -f $fname ext2.img
2356 +       md5=`md5sum ext2.img | cut -f 1 -d " "`
2357 +       if ! /sbin/e2fsck -fn ext2.img ; then
2358 +               echo "fsck failed"
2359 +               echo FAILED
2360 +               cleanup
2361 +               exit 1
2362 +       fi
2363 +       mkdir -p mnt
2364 +       if ! mount -t ext2 -o loop ext2.img mnt; then
2365 +               echo FAILED
2366 +               cleanup
2367 +               exit 1
2368 +       fi
2369 +       if ! [ -d mnt/dev ] ; then
2370 +               echo FAILED
2371 +               cleanup
2372 +               exit 1
2373 +       fi
2374 +       cat dev.txt | grep ^[bc] | \
2375 +               awk '{print $1substr($1,2)substr($1,2),$2,$3}'| \
2376 +                       sort -d -k3.6 > fout
2377 +       ls -al mnt/dev | grep ^[bc] | \
2378 +               awk '{ print $1,$5$6,"/dev/"$10}' | \
2379 +                       sort -d -k3.6 > lsout
2380 +       if ! diff fout lsout ; then
2381 +               echo FAILED
2382 +               cleanup
2383 +               exit 1
2384 +       fi
2385 +       echo PASSED "(md5 checksum for the image: $md5)"
2386 +       cleanup
2387 +}
2388 +
2389 +dtest 0 4096
2390 +dtest 0 8193
2391 +dtest 0 8194
2392 +dtest 1 4096
2393 +dtest 12288 4096
2394 +dtest 274432 4096
2395 +dtest 8388608 9000
2396 +dtest 16777216 20000
2397 +
2398 +ftest dev.txt 4096
2399 +
2400 +exit 0
2401 diff -urN genext2fs-1.3.orig/test.sh genext2fs-1.3/test.sh
2402 --- genext2fs-1.3.orig/test.sh  1969-12-31 17:00:00.000000000 -0700
2403 +++ genext2fs-1.3/test.sh       2003-04-21 01:41:42.000000000 -0600
2404 @@ -0,0 +1,53 @@
2405 +#!/bin/sh
2406 +set -e
2407 +
2408 +# dtest - Uses the -d directory option of genext2fs
2409 +# Creates an image with a file of given size and verifies it
2410 +# Usage: dtest file-size number-of-blocks correct-checksum
2411 +dtest () {
2412 +       size=$1; blocks=$2; checksum=$3
2413 +       echo "Testing with file of size $size "
2414 +       mkdir -p test
2415 +       cd test
2416 +       dd if=/dev/zero of=file.$1 bs=1 count=$size
2417 +       cd ..
2418 +       ./genext2fs -b $blocks -d test ext2.img
2419 +       md5=`md5sum ext2.img | cut -d" " -f1`
2420 +       rm -rf ext2.img test
2421 +       if [ $md5 == $checksum ] ; then
2422 +               echo PASSED
2423 +       else
2424 +               echo FAILED
2425 +               exit 1
2426 +       fi
2427 +}
2428 +
2429 +# ftest - Uses the -f spec-file option of genext2fs
2430 +# Creates an image with the devices mentioned in the given spec
2431 +# file and verifies it
2432 +# Usage: ftest spec-file number-of-blocks correct-checksum
2433 +ftest () {
2434 +       fname=$1; blocks=$2; checksum=$3
2435 +       echo "Testing with devices file $fname"
2436 +       ./genext2fs -b $blocks -f $fname ext2.img
2437 +       md5=`md5sum ext2.img | cut -d" " -f1`
2438 +       rm -rf ext2.img
2439 +       if [ $md5 == $checksum ] ; then
2440 +               echo PASSED
2441 +       else
2442 +               echo FAILED
2443 +               exit 1
2444 +       fi
2445 +}
2446 +
2447 +dtest 0 4096 491a43ab93c2e5c186c9f1f72d88e5c5
2448 +dtest 0 8193 6289224f0b7f151994479ba156c43505
2449 +dtest 0 8194 3272c43c25e8d0c3768935861a643a65
2450 +dtest 1 4096 5ee24486d33af88c63080b09d8cadfb5
2451 +dtest 12288 4096 494498364defdc27b2770d1f9c1e3387
2452 +dtest 274432 4096 65c4bd8d30bf563fa5434119a12abff1
2453 +dtest 8388608 9000 9a49b0461ee236b7fd7c452fb6a1f2dc
2454 +dtest 16777216 20000 91e16429c901b68d30f783263f0611b7
2455 +
2456 +ftest dev.txt 4096 921ee9343b0759e16ad8d979d7dd16ec
2457 +exit 0