utest/zxcrypt/zxcrypt.cpp

16 #include <zircon/device/block.h>
17 #include <zircon/device/ramdisk.h>
22 #include "test-device.h"
28 // See test-device.h; the following macros allow reusing tests for each of the supported versions.
34     TestDevice device;
35     EXPECT_TRUE(device.Bind(version, fvm));
47     TestDevice device;
48     ASSERT_TRUE(device.Bind(version, fvm));
49     fbl::unique_fd parent = device.parent();
50     fbl::unique_fd zxcrypt = device.zxcrypt();
57     EXPECT_EQ((parent_buf.st_size - zxcrypt_buf.st_size) / device.block_size(),
58               device.reserved_blocks());
68     TestDevice device;
69     ASSERT_TRUE(device.Bind(version, fvm));
70     fbl::unique_fd parent = device.parent();
71     fbl::unique_fd zxcrypt = device.zxcrypt();
80     EXPECT_GE(parent_blk.block_count, zxcrypt_blk.block_count + device.reserved_blocks());
89     TestDevice device;
90     ASSERT_TRUE(device.Bind(version, fvm));
91     fbl::unique_fd parent = device.parent();
92     fbl::unique_fd zxcrypt = device.zxcrypt();
96         // Send FVM query to non-FVM device
105         EXPECT_EQ(parent_fvm.vslice_count, zxcrypt_fvm.vslice_count + device.reserved_slices());
112 bool QueryLeadingFvmSlice(const TestDevice& device) {
115     fbl::unique_fd parent = device.parent();
116     fbl::unique_fd zxcrypt = device.zxcrypt();
134                   zxcrypt_resp.vslice_range[0].count + device.reserved_slices());
142     TestDevice device;
143     ASSERT_TRUE(device.Bind(version, fvm));
144     EXPECT_TRUE(QueryLeadingFvmSlice(device));
152     TestDevice device;
153     ASSERT_TRUE(device.Bind(version, fvm));
154     fbl::unique_fd zxcrypt = device.zxcrypt();
161         // Send FVM ioctl to non-FVM device
167         EXPECT_TRUE(QueryLeadingFvmSlice(device));
171         EXPECT_TRUE(QueryLeadingFvmSlice(device));
181     TestDevice device;
182     ASSERT_TRUE(device.Bind(version, fvm));
184     EXPECT_TRUE(device.WriteFd(0, 0));
185     EXPECT_TRUE(device.ReadFd(0, 0));
194     TestDevice device;
195     ASSERT_TRUE(device.Bind(version, fvm));
196     size_t one = device.block_size();
198     EXPECT_TRUE(device.WriteFd(0, one));
199     EXPECT_TRUE(device.ReadFd(0, one));
208     TestDevice device;
209     ASSERT_TRUE(device.Bind(version, fvm));
210     size_t n = device.size();
211     size_t one = device.block_size();
213     EXPECT_TRUE(device.WriteFd(n - one, one));
214     EXPECT_TRUE(device.ReadFd(n - one, one));
223     TestDevice device;
224     ASSERT_TRUE(device.Bind(version, fvm));
225     size_t n = device.size();
227     EXPECT_TRUE(device.WriteFd(0, n));
228     EXPECT_TRUE(device.ReadFd(0, n));
237     TestDevice device;
238     ASSERT_TRUE(device.Bind(version, fvm));
239     size_t one = device.block_size();
242     ASSERT_TRUE(device.WriteFd(one, one));
243     ASSERT_TRUE(device.ReadFd(one, one));
245     EXPECT_EQ(device.lseek(one - 1), one_s - 1);
246     EXPECT_LT(device.write(one, one), 0);
247     EXPECT_LT(device.read(one, one), 0);
249     EXPECT_EQ(device.lseek(one + 1), one_s + 1);
250     EXPECT_LT(device.write(one, one), 0);
251     EXPECT_LT(device.read(one, one), 0);
253     EXPECT_EQ(device.lseek(one), one_s);
254     EXPECT_LT(device.write(one, one - 1), 0);
255     EXPECT_LT(device.read(one, one - 1), 0);
257     EXPECT_EQ(device.lseek(one), one_s);
258     EXPECT_LT(device.write(one, one + 1), 0);
259     EXPECT_LT(device.read(one, one + 1), 0);
268     TestDevice device;
269     ASSERT_TRUE(device.Bind(version, fvm));
270     size_t n = device.size();
273     size_t one = device.block_size();
279     ASSERT_TRUE(device.WriteFd(0, one));
281     EXPECT_EQ(device.lseek(n), n_s);
282     EXPECT_NE(device.write(n, one), one_s);
284     EXPECT_EQ(device.lseek(n - one), n_s - one_s);
285     EXPECT_NE(device.write(n - one, two), two_s);
287     EXPECT_EQ(device.lseek(two), two_s);
288     EXPECT_NE(device.write(two, n - one), n_s - one_s);
290     EXPECT_EQ(device.lseek(one), one_s);
291     EXPECT_NE(device.write(one, n), n_s);
293     ASSERT_TRUE(device.ReadFd(0, one));
295     EXPECT_EQ(device.lseek(n), n_s);
296     EXPECT_NE(device.read(n, one), one_s);
298     EXPECT_EQ(device.lseek(n - one), n_s - one_s);
299     EXPECT_NE(device.read(n - one, two), two_s);
301     EXPECT_EQ(device.lseek(two), two_s);
302     EXPECT_NE(device.read(two, n - one), n_s - one_s);
304     EXPECT_EQ(device.lseek(one), one_s);
305     EXPECT_NE(device.read(one, n), n_s);
314     TestDevice device;
315     ASSERT_TRUE(device.Bind(version, fvm));
316     size_t n = device.size();
317     size_t one = device.block_size();
319     ASSERT_TRUE(device.WriteFd(0, n));
320     ASSERT_TRUE(device.Rebind());
323         EXPECT_TRUE(device.ReadFd(off, one));
333     TestDevice device;
334     ASSERT_TRUE(device.Bind(version, fvm));
335     size_t n = device.size();
336     size_t one = device.block_size();
339         EXPECT_TRUE(device.WriteFd(off, one));
342     ASSERT_TRUE(device.Rebind());
343     EXPECT_TRUE(device.ReadFd(0, n));
353     TestDevice device;
354     ASSERT_TRUE(device.Bind(version, fvm));
357     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_WRITE, 0, 0), ZX_ERR_INVALID_ARGS);
358     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_READ, 0, 0), ZX_ERR_INVALID_ARGS);
367     TestDevice device;
368     ASSERT_TRUE(device.Bind(version, fvm));
370     EXPECT_TRUE(device.WriteVmo(0, 1));
371     EXPECT_TRUE(device.ReadVmo(0, 1));
380     TestDevice device;
381     ASSERT_TRUE(device.Bind(version, fvm));
382     size_t n = device.block_count();
384     EXPECT_TRUE(device.WriteVmo(n - 1, 1));
385     EXPECT_TRUE(device.ReadVmo(n - 1, 1));
394     TestDevice device;
395     ASSERT_TRUE(device.Bind(version, fvm));
396     size_t n = device.block_count();
398     EXPECT_TRUE(device.WriteVmo(0, n));
399     EXPECT_TRUE(device.ReadVmo(0, n));
408     TestDevice device;
409     ASSERT_TRUE(device.Bind(version, fvm));
410     size_t n = device.block_count();
412     ASSERT_TRUE(device.WriteVmo(0, 1));
414     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_WRITE, n, 1), ZX_ERR_OUT_OF_RANGE);
415     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_WRITE, n - 1, 2), ZX_ERR_OUT_OF_RANGE);
416     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_WRITE, 2, n - 1), ZX_ERR_OUT_OF_RANGE);
417     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_WRITE, 1, n), ZX_ERR_OUT_OF_RANGE);
419     ASSERT_TRUE(device.ReadVmo(0, 1));
421     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_READ, n, 1), ZX_ERR_OUT_OF_RANGE);
422     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_READ, n - 1, 2), ZX_ERR_OUT_OF_RANGE);
423     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_READ, 2, n - 1), ZX_ERR_OUT_OF_RANGE);
424     EXPECT_ZX(device.block_fifo_txn(BLOCKIO_READ, 1, n), ZX_ERR_OUT_OF_RANGE);
433     TestDevice device;
434     ASSERT_TRUE(device.Bind(version, fvm));
435     size_t n = device.block_count();
437     EXPECT_TRUE(device.WriteVmo(0, n));
438     ASSERT_TRUE(device.Rebind());
440         EXPECT_TRUE(device.ReadVmo(off, 1));
450     TestDevice device;
451     ASSERT_TRUE(device.Bind(version, fvm));
452     size_t n = device.block_count();
455         EXPECT_TRUE(device.WriteVmo(off, 1));
458     ASSERT_TRUE(device.Rebind());
459     EXPECT_TRUE(device.ReadVmo(0, n));
467     TestDevice device;
468     ASSERT_TRUE(device.Bind(version, fvm));
469     fbl::unique_fd zxcrypt = device.zxcrypt();
471     // The device can have up to 4 * max_transfer_size bytes in flight before it begins queuing them
476     size_t max = Volume::kBufferSize / (device.block_size() * blks_per_req);
488     EXPECT_TRUE(device.SleepUntil(max, true /* defer transactions */));
489     EXPECT_EQ(device.block_fifo_txn(requests.get(), num), ZX_OK);
490     EXPECT_TRUE(device.WakeUp());
499     TestDevice device;
500     ASSERT_TRUE(device.Bind(version, true));
501     fbl::unique_fd zxcrypt = device.zxcrypt();
503     size_t n = device.size();
506     size_t one = device.block_size();
509     EXPECT_EQ(device.lseek(n), n_s);
510     EXPECT_NE(device.write(n, one), one_s);
516     mod.offset = device.size() / info.slice_size;
520     EXPECT_EQ(device.lseek(n), n_s);
521     EXPECT_EQ(device.write(n, one), one_s);