Snapshot of work in progress on a modernised disk quota system:
- new quotactl syscall (versionned for backward compat), which takes
  as parameter a path to a mount point, and a prop_dictionary
  (in plistref format) describing commands and arguments.
  For each command, status and data are returned as a prop_dictionary.
  quota commands features will be added to take advantage of this,
  exporting quota data or getting quota commands as plists.

- new on disk-format storage (all 64bit wide), integrated to metadata for
  ffs (and playing nicely with wapbl).
  Quotas are enabled on a ffs filesystem via superblock flags.
  tunefs(8) can enable or disable quotas.
  On a quota-enabled filesystem, fsck_ffs(8) will track per-uid/gid
  block and inode usages, and will check and update quotas in Pass 6.
  quota usage and limits are stored in unliked files (one for users,
  one for groups)l fsck_ffs(8) will create the files if needed, or
  free them if needed. This means that after enabling or disabling
  quotas on a filesystem; a fsck_ffs(8) run is required.
  quotacheck(8) is not needed any more, on a unclean shutdown
  fsck or journal replay will take care of fixing quotas.
  newfs(8) can create a ready-to-mount quota-enabled filesystem
  (superblock flags are set and quota inodes are created).
  Other new features or semantic changes:
  - default quota datas, applied to users or groups which don't already
    have a quota entry
  - per-user/group grace time (instead of a filesystem global one)
  - 0 really means "nothing allowed at all", not "no limit".
    If you want "no limit", set the limit to UQUAD_MAX (tools will
    understand "unlimited" and "-")

  A quota file is structured as follow:
  it starts with a header, containing a few per-filesystem values,
  and the default quota limits.
  Quota entries are linked together as a simple list, each entry has a
  pointer (as an offset withing the file) to the next.
  The header has a pointer to a list of free quota entries, and
  a hash table of in-use entries. The size of the hash table depends
  on the filesystem block size (header+hash table should fit in the
  first block). The file is not sparse and is a multiple of
  filesystem block size (when the free quota entry list is empty a new
  filesystem block is allocated). quota entries to not cross
  filesystem block boundaries.

  In memory, the kernel keeps a cache of recently used quota entries
  as a reference to the block number, and offset withing the block.
  The quota entry itself is keept in the buf cache.

fsck_ffs(8), tunefs(8) and newfs(8) supports are completed (with
related atf tests :)
The kernel can update disk usage and report it via quotactl(2).

Todo: enforce quotas limits (limits are not checked by kernel yet)
      update repquota, edquota and rpc.rquotad to the new world
      implement compat_50_quotactl ioctl.
      update quotactl(2) man page

fsck_ffs required fixes so that allocating new blocks or inodes will
properly update the superblock and cg sumaries. This was not an issue up
to now because superblock and cg sumaries check happened last, but now
allocations or frees can happen in pass 6.
Remove FILES section, it's obsolete
Add support for quotactl("getall") command, and convert repquota to new
world.
Introduce quota2_ufs_rwq2v() and quota2_ufs_rwq2e() functions, which
byteswap a quota2_val or quota2_entry if needed.
Use this to get quota2_entry in host order before calling q2etoprop().

quota2_walk_list() will byteswap the offset if needed to leave
it in FS byte order in callers.
Add rump versions of quota utilities, to be used by tests.
Add a test which figures if we can retrieve quota values from
the kernel.
Rename getufsquota to getvfsquota, and abstract in its own file.
Add RCSID
Add conversion functions between old and new format.
Use quota1_subr.c
Allow to pass HN_PRIV_UNLIMITED flag (private to printquota consumers),
which cause it to return "unlimited" instead of "-" of UQUAD_MAX.
Introduce intrd(), which parses a string and return a value appropriate
for quota limits. The string can be a decimal number, a value in
understandable by dehumanize_number(), "-" or "unlimited".
Describe how the on-disk structures are protected from concurent access,
and try to implement it.
intprt() can be called up to 3 times for a single printf();
make sure to return 3 different static buffers in such a case.
Implement 'set' command for quota2.
Convert to new quotactl()
Add a edquota rump client
Remove unused function
Add tests cases for quotactl("set")
Handle humanized numbers for -h/-s
Add a command-line flag to toggle foreground/background
Ask the rump server to background itself, to avoid a race at startup where
a rump command could be run before the server is available.
Add a sleep after shutdown to workaround a race where the fsck would run
before the server is fully showdown (testing for the existence of the
socket seems to not be enough).