I'm not sure why this dumps core so in clrbuf, so I need to look at that closely.

I do not understand this memset here. It makes no sense to me. All users of getblk replace the contents by calling clrbuf, memset or memcpy.

We might want to introduce flags to bp's here to know when this is still 'valid' and when it's just been allocated. That would save the read. But since we brelse things aggressively and toss away the buffer cache in the non mmap case, I'm not sure how big a win that would be.

I guess it's just a safety belt? To make sure that a programming bug doesn't cause us to write uninitialized bytes into the image.

This should be sorted with the sys/param.h include above.

Shouldn't this be MAP_SHARED?

I have found that if I always malloc the buffer and copy into and out of the mmap'd image, then things work. But this
eliminates a lot of the benefit from the change for msdos. There's something in the ufs code that's silently depending on this slight difference that I've not been able to find.

Even when I account for the 'negative' blocks being used to store metadata and getblk being used to remember the mapping of -lbn to actual block on the disk. This is a second reason why things don't work. We get further if we have a hybrid approach of allocating the buffer until we know the block and then moving the pointer to it (after copying the contents of the buffer), but it still doesn't quite work right :(

Except we do it also when we change the size of the buffer, which doesn't make a lot of sense to me. It seems to be critical to making things work, though, based on my experiments over the weekend for reasons I've not found the root cause for.

ok

I'm unsure. I thought MAP_SHARED was for multiple programs accessing the file, of which this is not.
I did see elsewhere a MAP_FILE | MAP_PRIVATE as well, but 'MAP_FILE' is 0 so only can convey intent.

MAP_PRIVATE means that the changes will not be visible to other processes, so accesses to the file mapping are copy-on-write and get discarded when the mapping is destroyed. So I'm confused about how this works.

It worked due to a testing error on my part. MAP_SHARED is needed for these changes to survive the process dying. So I've updated this and made a couple of other changes.

= NULL?

yup

NULL here too

I think the proper test here is B_ALLOC bit in flags, no?