process: when debugging it's nice to know why something exited

z80pack: turn on MMU feature

z80pack: add an extreme example of the mmu hooks

lowlevel-z80: add hooking points for Z80 systems with memory protect bits

z80pack: we added a tty

z80pack: drop stuff we don't need

ibmpc: note older 80x86 errata

z80pack: add the outgoing port as another tty

z80: fix the banked code FIXME about syscalls.

Note the call is also safe as the entry point is not banked

z80pack: Fix the printer driver

du: switch version

Use the tidied up MWC one. It's nicer, smaller and calculates stuff like
indirect block cost.

as: bracket or square...

Z80 and 6502 use () to indicate a layer of indirection, so the assembler uses
[] for expressions

6809 uses [] for indirect, so we need to use () for expressions

as: incomplete 6809 code

Doesn't build yet but I figure we might as well make all of our platforms
able to use the same object file format, linker, library tools for self hosting
work.

as: Fix more bugs, add < and > for lo/hi relocations

Still plenty of bugs I am sure.

as further work

- Initial core support for word addressed machines
- Sketch out a compilable DG Nova PoC for this
- PC relative addressing

ld: first cut at big endian logic, pcrel, overflow suppression and high8

obj: add proper PCREL definitions for relocation entries

We can generate them but not yet link them

as4: add relative byte output

asz80: improve handling of segment type clashes

ld: teach new tags, and make it reject them also tidy segment constraints

obj: update with endian and word tags and some oddments

as: lots of stuff here

- Rework types for cpu / flags
- Add 6502 types
- Teach ld that there can be a ZP segment
- Restructure the assembler to put arch specific code in less files
- Fix various minor bugs (segment checking etc)
- Fix a bug where a_sym was not reliably set to NULL for constants
- Add initial test 6502 support to prove can re-target easily

asz80: Z180 initial support, fix range checking, correct IX disp non abs

In particular

out (300),a  errors
ld (ix+300),a errors

ld (ix+FOO),a generates a relocation entry for FOO

That means you can

FOO .equ 21

ld (ix+FOO),a

or even define FOO as an external

ld: don't break if the symbol unused bytes are nn zero

ld: add the hash function

obj: make Z80 an 8080 variant as this makes more sense

SmallC: Fix initialization of static/global pointers

It's trivial to add the code generation for this and it's an annoying lack in
the compiler.

smallc: tidy up a bit, align Z80 with assembler and fix bogus pop bc bug

ld: tidy up pass

ld: furthr polishing

At this point it appears to be functioal

Merge branch 'master' of https://github.com/EtchedPixels/FUZIX

ld: Save current status

Libraries work
Still doing some final debug on symbol resolutions
Unbreak handling of internal symbols

obj.h: add 'ANY' segment definition

nm: understand the fact a U symbol may be segment constrained

as: fix handling of unknown symbols in subtraction

Propogate segment requirements to object module for linker to fault

as: fix blkb/defs

We make it twice the size and get very confused as a result

Merge pull request #540 from beretta42/mem

bank16k: report correct memory used

bank16k: report correct memory used

pfptr goes down as memory is allocated. return it's compliement instead.

ld: closer but not yet entirely correct

ld: further updates

At this point we can do some minimal linking and write out correctly looking
objects.

asz80: fixes to output format logic

obj: format tweaking

README: updates

- We now have a useful gcc 8086, in fact at many things it rocks.
- SDCC is ever improving

ld: Fix some stuff by inspection and fold in basic logic for library modules

ld: first parts of a linker

Far from complete!

z80as: change object file format to fixed sized symbol records

This makes life a lot easier for the other tools

asz80: always write the debug symbol base

It avoids special cases and means the linker can size the table itself.

asz80: finish conversion

This now behaves rather more like we need. It lacks includes and some other
nice to have bits but is also small enough to run on a Z80 box sanely. Trimming
out stdio and soem other slack could be done if needed but is a fair bit of
work.

Also add an nm mostly at this point to check the output is valid.

Now all we need is to tweak the smallc output syntax to match, and a linker...

asz80: write symbols out

Also fix the .export handling and some oddments related to it.

We now should be writing out correct relocations and symbol tables. The one
thing we have yet to do is to properly number the external symbols so that
we can output them in that order and tie it nicely to the relocations so that
ld doesn't have to work overtime.

asz80: some quick changes over tea

We now write out parts of something resembling a relocatable object file. We
don't yet write out the symbols nor do we write out the longer relocations
for symbol references rather than segment offsets.

Merge branch 'master' of https://github.com/EtchedPixels/FUZIX

Merge pull request #536 from beretta42/make2

fsck: fix some more bugs

Merge pull request #537 from beretta42/up

Tidy 'make'

Merge pull request #538 from beretta42/halt

util: link 'halt' to 'reboot' on fs

util: link 'halt' to 'reboot' on fs

fsck: fix another wrap bug, and continuing is not an error.

standalone fsck: fix always returns 1; parenths to fix wrapping issue

MWC: add 'make' to filesystem maker script

make: fix compiler complaint

fsck: minor fixes

Makefile: hook in z80 assembler

make: make

Add the older MwC make as it fits a small machine nicely

as: Z80 assembler from Coherent

This one doesn't do relocations or external symbol resolution so will need a
bit of tweaking to generate object files not binaries. It is however very
tidy and extremely small.

cron: add cron

start: tiny optimization

fsck: Fix the wrap bug on standalone fsck

tty: Fix ^D echo bug

fsck: fix wrap on full sized fs

Noticed by Brett

games add hangman and quiz

v7yacc: Add the V7 yacc as a cross building tool

bogomips: because ...

Z80 4MHz 0.2 bogomips
FPGA Z80 128MHz 10.55 bogomips - beats an Intel 386 ;)

clock: fix scaling error

free: add a Linux like "free" command to see swap and memory usage

init: bug fixes and fussier about leaving files open

Merge pull request #533 from beretta42/fix

kernel: syscall_16: put header in userspace too.

kernel: syscall_16: put header in userspace too.

mount/umount: Fixups for the other cases I missed

With this I seem to get the right behaviour

mount: add support for fsck

- Dirty/clean status handling
- Write back superblocks when we go clean but not if we are clean (or bad)
- Add full checks so remount ro works for all cases

This allows you to fsck -a `prtroot` in /etc/rc to recover the system if
needed. Before rebooting you need to remount filesystems r/o or unmount them.

This last bit wants wiring into reboot so it does a runlevel change to init
unless -f is used. We can then umount everything nicely (by adding umount -a)
and remount the rootfs r/o as well as doing a killall etc when we shutdown.

syscall_exec16: fix crash with small binaries, reduce code footprint

Standalone: move to the new fsck behaviour

fsck: get the fsck tool working

This (with the needed kernel changes) seems to give us the correct behaviour
including handling recovering the live root file system.

If you boot with 'r' as an option or a dirty rootfs you'll now get a r/o
mount and you can fsck /dev/whatever to check it. If it's bad you'll then
get to fix it and it'll reboot.

reboot: add user side support for reboot -f

kernel: we don't use the void *'s back from the blkbuf ops so lose them

ExternalBuffers: document how the model works

test: fix silly error when copying fixes over

fuzix-util: add remount to package list

umount/remount: tidy up umount and add a remount

umount: fix includes

This worked by luck before. Now add the correct include file

fsck: Rework standalone fsck to use as native fsck

- Use bitmaps not bytemaps
- Support yes() properly

Not heavily tested yet!

mm: tidy up some odds and ends with the buffer changes

We actually need something different to what was guessed at, so change the
prototypes and define the functions differently

devsys: error rather than 0 on failed uput in devsys

Merge pull request #530 from beretta42/fix2

devsys: read should return no. of bytes

/dev/proc: return number of bytes read.

uput only returns -1 on validation fail, or 0 ok.  this made 'ps' sad.
/dev/kmem reading might be broken too...

Kernel: quick pointer fix.

umount: add new syscall wrapper for umount

remount: add new syscall interface

kernel: rework buffer handling and superblocks

Be scared.. be very scared

Back up your disks before testing this changeset

The basic idea of this set of patches is to put in most of the framework for
keeping the buffer cache outside of the main kernel mapping. Instead we
introduce some functions to copy between kernel/buffer and user/buffer. As
most traffic goes directly between user/buffer this doesn't hurt us. These
patches don't implement the bits needed for an external buffer cache but they
do implement the framework required to add it.

To minimize impact on some bits like directory scanning we also introduce a
routine that with separate buffer cache address space wil make a temporary copy
of a small area, but on machines with the buffer cache in the normal place
resolves as essentially the same assembler as before (6502 suffers a tiny bit
I suspect).

In order to do this we also have to rework the mount handling. Superblocks are
now copied to/from buffers on mount and sync rather than pinning a buffer. The
superblock buffers mean that for a small system you probably want to drop the
buffer cache size by one block (the one previously pinned for the superblock)
in favour of the superblock table entries you'll now get (which are about 256
bytes each).

Execve is also tided up. We had a set of custom fastpath code for loading a
binary. Only it turns out that if we use readi the existing O_DIRECT fastpath
will do the work for us, which means execve itself can become oblivious to
where the buffer cache hides. This will need work for 8086 when split I/D hits
but it's quite manageable.

While I was at it I also realised that the problem with trying to add remount
support to mount is that remounting despite what the name implies is actually
a variant of umount. You do the same lookups to find the same existing
superblock, iterate the inode list but then swizzle some flags instead of
checking it is non-busy and firing it into hyperspace.

This patch changes umount(x) into _umount(x, flags) where flags include
MS_REMOUNT, MS_RDONLY and MS_NOSUID (not yet properly supported). This provides
enough functionality that you can now probably safely boot read only, fsck the
root fs (except I need to port the native fsck over and squash memory usage)
and the mount it r/w. You *cannot* fix the root fs and remount it without a
reboot. That involves jumping through far too many hoops. I think this is
sufficient as it'll allow the default initscripts to fsck, check and either
reboot or go read/write so we have proper fs recovery (whoopeee)

Programs using umount (all one if it) will need recompiling.

Why do all this

1. It lets you push several KB out of kernel space, which is valuable space
you can then turn into code, inodes (much needed) or processes.
2. Some platforms need the buffers themselves aligned and on boundaries. The
existing model doesn't handle this. For example the PC needs them so one does
not cross a DMA boundary.

At the moment we have systems with 512K+ of RAM that simply can't run with an
appropriate amount of buffering and inodes. Once 8086 is included we get into
situations where we might have 4MB of expanded memory and at that point we
can't hope to get the buffers needed into the 64K of data space, while we
can shove it elsewhere, and with expanded memory into a 64K expanded memory
bank along with some other oddments.

Once this support is finished we can shove both the tty buffers and the disk
buffers out of the way. On a 'big' configuration like a 286 PC we need something
like 30K for process/inode/file/buffer head/superblock data structures to match
the values 2BSD tuned to. That's without buffers ! The big hogs in the kernel
are then the inode structures and the process table entries. We might be able
to move a few bits of the process into its udata but neither it nor pushing
inodes out are easy problems to attack.

Library: Fix Z80 breakage from 6809 fixes

ifeq in Makefiles is subtle and quick to anger....

Also check z80 not sdcc.

emm: Add some notes

z80fixedbank: note a possible optimization