[blktest] Avoid assuming PAGE_SIZE > block_size

Test: blktest on device with 8KB block size.

ZX-2141 #comment In Progress

Change-Id: I3d9f62291919d6d73e7735901ada0eea44d0db65

[storage] Fix blktest when working with a 4KB block size device.

Some tests assumed that the block size would be smaller than PAGESIZE.

Test: blktest passes with a device of 4KB blocks.
Change-Id: I71e7aac30b23741f92c5c2d5ca691caed072628d

[utest] Remove unused #defines of RAMCTL_PATH

Test: compile
Change-Id: Ic1b11aa8a159b569f2b2a9a67a6c034219d7376c

[block] Implement v2 of Block Protocol

- "Transactions" renamed to "Groups". The term
transaction remains, and is used to corresponds to a
single FIFO request.
- "Groups" pre-allocated by block server.
Clients can use groups between [0, MAX_TXN_GROUP_COUNT)
without needing to allocate. Groups signify structures
that can wait to transmit responses for a collection of
transactions. These transactions may be requested via
"BLOCKIO_TXN_GROUP"; the block-client library does this
automatically.
- "One-shot" transactions, which are not associated with
a group, are also implemented. All "one-shot" transactions
receive a FIFO response.

ZX-1584 #done
ZX-1580 #comment In Progress

TEST=ramdisk, fvm, zxcrypt, block, fs tests, running iochk manually

Change-Id: I7caf342804baf32543adfef3fec76f7d77d89b3f

[fs] Remove artificial MAX_TXN_MESSAGES constraint

Previously, the block midlayer limited the number of
permitted messages to an arbitrary constant size, since
it pre-allocated space for a fixed size number of incoming
messages.

However, with the revamped block protocol, no such limit exists:
clients are free to write requests until the block FIFO
is full.

Remove this constant, and allow filesystem transactions to
grow to an arbitrary number of fragmented requests.

ZX-1918 #done

Change-Id: I4922e93a2e25533d1a2a31dec17d25c02398f162

[block] Add queueing to block midlayer.

Additionally, implement sync barriers within the block midlayer.

ZX-1582 #done
ZX-1584 #comment In Progress

Change-Id: Id6c084d13ffa91ededab7d5f731614f81ccf1b2b

[ulib][blktest] fix blkdev_test_fifo_bad_client_bad_vmo

The test previously attempts to create a VMO with a non
multiple of PAGE_SIZE. The test was invalid because all VMOs
are rounded up to a multiple of PAGE_SIZE.

ZX-1917 #done

Change-Id: I8b7faaf16b4e2c3c332477ed4b267ab9f1781c95

[syscall][vmo] removal of zx_vmo_{read,write}() actual parameter 4/n

This reverts commit d7c91f0a8a876bd4de8808595cafcd4f2c3fd7a1.

Change-Id: I5c61410f62850583a970d3ff2f44b6d58901509a

[revert] Revert "[syscall][vmo] removal of zx_vmo_{read,write}() actual parameter 4/n"

This reverts commit 2d25909b7ab244d73172c9f5bc11d85b49ccefbb.

Change-Id: I09efe4e1d69d7aeadb051936d3ddc8237e7d39cf

[syscall][vmo] removal of zx_vmo_{read,write}() actual parameter 4/n

Remove actual from zx_vmo_{read,write}
Mark zx_vmo_{read,write}_old as deprecated
Retarget most uses of zx_vmo_{read,write}_old to zx_vmo_{read,write}.

Still need to migrate a handful of uses of _old that had meaningful
usage of actual.
This is good enough to go ahead and migrate uses in Garnet and Topaz.

ZX-1802

Change-Id: If57329f9c5183a0dacd29083decbaf771925145f

[syscall][vmo] removal of zx_vmo_{read,write}() actual parameter 1/n

In preparation for changing the zx_vmo_read() and write() syscalls,
introduce aliases (zx_vmo_read_old() and write_old()) for the existing
behaviour, migrate zircon callers to the aliases, and mark the original
syscalls as deprecated.

Once the garnet and above layers have been migrated, the original
syscalls will be adjusted to remove the "actual" argument, and the
temporary _old() versions will be deprecated, and then removed.

ZX-1802

Change-Id: I2fab9a59caf4093fb585ada6015197017767aba2

[blktest] Reduce test flake

This is the equivalent of the ramdisk flake, but for real hardware

ZX-1600 #done (again)

Change-Id: Ib5ccb7950e366117deb27776465c9933cafcac85

[block] Convert FIFO-based block protocol to use block units, not bytes

ZX-1541 #done

Change-Id: I115b59c0991f15dd312d9199583ebe583735b004

[blktest] Block txns must use VMO offsets which are multiples of the block size

This patch will be obsolete when ZX-1541 is complete, but in the
meantime, it prevents blktest from failing.

ZX-1588 #done

Change-Id: Ic9e23c6f6d6ccd66ac54720a7c53680dc5a19da2

[block] Larger-than-device requests should fail, not truncate

ZX-1545 #comment In Progress

Change-Id: I456c71c1b093791d1e21855849d566726a4c0544

[blktest] Fix blktest error when sending poorly-sized requests

ZX-1535 #done

Change-Id: I93afec9ef8765244ec8842732ba2a940ba0f8e30

Clean up sloppy zx_handle_t/integer conflation

Change-Id: I5659232efa8531ef97261639cc65f211ee9f0cc8

[zx] Magenta -> Zircon

The Great Renaming is here!

Change-Id: I3229bdeb2a3d0e40fb4db6fec8ca7d971fbffb94

[zircon][mxtl->fbl] Rename mxtl to fbl

Change-Id: Ie21b6498e1bfb0a7fa0315e40b9e5c3ee78646be

[unittest] Use ASSERT_NE()/EXPECT_NE() instead of ASSERT_NEQ()/EXPECT_NEQ()

This is to make the interface more consistent with gtest, which uses
the _NE suffix rather than _NEQ for "not equal".

Change-Id: Ic03fda7322ab79cbd806c8f849b6956d201c6d45

[mxtl][mxalloc] Redirect all clients of mxalloc to mxtl.

Change-Id: Ib6d88937212ab23612f59add8bd028862308ead5

[cpp][countof] Prefer the typesafe mxtl::count_of in C++ code

Change-Id: I3e475731f6872e6daf764f31964bed9f09186c7c

[ulib][blktest] Use the MX_ERR_* and MX_OK mx_status_t names

Change-Id: Iaf7ba934ceb47298b056ef64967637fc8e838a27

[virtio][block] Add BLOCK_CORE support to virtio driver

Extend the virtio block driver to support scatter gather.

NOTE: will hit limits in blktest for having too many outstanding
transactions (32) or exhausting the virtio ring, which is currently hard
coded to 128 entries.

Change-Id: I3ca85964fbea40c22059b962b4846c5d3eb77ba8

[mxcpp][mxalloc] Split mxcpp into mxcpp and mxalloc

mxcpp used to provide three things.

(1) is a very minimal C++ runtime environment. This means essentially
the definition of __cxa_pure_virtual, which is a function the compiler
expects to have ambient. This functionality is necessary for code
written in environments which cannot link the standard library (the
kernel and a handful of initial userspace processes).

(2) is the definitions of the standard new and delete
overloads. Again, these are needed for code that wants to call them
but to not link the standard library, but this time only in userspace
(the kernel does not want certain behavior stemming from the standard
overloads). The behavior is slightly different than the standard ones
in failure cases, but not in a way particularly interesting to the
rest of this email.

(3) is the userspace version of our special AllocChecker new
overloads. This mechanism exists for kernelspace, where allocation
failure is real and needs to be handled. This mechanism works
perfectly well in userspace, in that it compiles, even though the
underlying allocator is unlikely to ever return nullptr. It's
therefore essentially harmless in userspace. A handful of small
libraries are used in both userspace and in the kernel, and also use
this mechanism. Note that this feature is essentially copy-pasted
between the kernel and userspace.

This all works perfectly well for the kernel.

Some userspace code also uses these mechanisms, as mentioned. As long
as the standard library isn't linked, there are again no issues.

But as soon as you want both (3) and std::vector, which is a
reasonable thing to want!, there are issues because (1) and (3) come
in the same static library. This causes link failures due to duplicate
__cxa_pure_virtual symbols. This issue is exacerbated by different
behavior in Linux, OS X, and target linkage, in terms of confusion and
it-works-on-my-machine sort of issues.

This patch splits mxcpp into: mxcpp, containing (1) __cxa_pure_virtual
and (2) only if in userspace, the standard new and delete overloads;
and mxalloc, containing (3) AllocChecker. mxcpp is mutually exclusive
of the standard library. mxalloc can be linked against both code using
the standard library, and against code using mxcpp.

This patch also deduplicates the AllocChecker between userspace and
kernel, and moves the InlineArray class into the kernel (its only
callsites are in the kernel).

Change-Id: Id42d5d019ee977d44d6cb89ce7ab6884f7a56cd1

[ulib] Merge ulib/hexdump into ulib/pretty

Change-Id: I194595de04e83178121c455f31732d1046448850

[udev][block] normalize error handling

read() and write() on block devices perform truncated transactions
if the requested length is unaligned or if it attempts to access
beyond the capacity of the device. BLOCK_CORE operations do not
truncate and return ERR_OUT_OF_RANGE for out of range accesses,
and ERR_INVALID_ARGS for unaligned accesses. Unaligned device
offsets always return ERR_INVALID_ARGS.

Change-Id: Ia0b99e0d37f1caed77c267f4efda532ba0a5a6ca

[blktest] comment out whole_disk test

Most people probably don't want to run the test on the whole disk.

Change-Id: If0a73c45335c0c41e13afd13c21b0af5051f0be9

[udev][sata] support scatter/gather

Support discontiguous iotxns and increase the PRD table size to 8k,
so the maximum worst-case transfer size is 32M for a fully
distiguous iotxn. Add a field in block_info_t to return this info.

Change-Id: I68f3cf6c25ca2d2cbe709768bfa43e1fc20e300e

[block] Convert BLOCK SIZE ioctls to GET_INFO

MG-709 #done

Change-Id: I96a7ca110a1e33eded5e6a2ee2535131c7b7ade6

[ramdisk][blktest] Fix flake from small VMOs

The "unaligned request" test, existent in both the
ramdisk and blktest tests, tests the FIFO-based block
protocol when invalid alignment requests are sent.

It tests:
- Unaligned length requests (+/-1) (error expected)
- Unaligned device offset requests (error expected)
- and unaligned vmo offset requests (+1) (error NOT expected)

HOWEVER, when we create VMOs, we create them with
randomly generated sizes: 512 + (rand() % 5) * 512.

As a consequence, if we attempt to access a randomly small vmo in the
final test case (listed above), with:

- Device Offset: 0
- Vmo Offset: 1
- Length: 512
- Total VMO Size: 512

We end up trying to read beyond the end of the VMO. This triggers the
"ERR_INVALID_ARGS" (-10) result on the block device server, which checks
that the VMO operation can act on the VMO of the requested size.
(See: udev/block/server.cpp, line 129)

As a fix, when creating a VMO for this test, specify a minimum size of
"kBlockSize * 2", so that if we read "kBlockSize" bytes from offset 1,
we always read within the bounds of the VMO.

Change-Id: Id6227c715c4e1b295a7fd111631f9b6e4f8301fa

[ulib][blktest] close the fd after a test

Change-Id: I423dbff95afcf15c1edf09b919756aacf2dfc16e

[udev][sata] use block fifo

Currently, if the VMO passed in is non contiguous the operation will fail. Scatter
gather coming in the next CL.

Change-Id: I9e1ccfd4914fa3795fa48418b1fb86b86a50f94e