utest/ramdisk/ramdisk.cpp

543     // Split it into two requests, spread across the disk
544     block_fifo_request_t requests[2];
545     requests[0].group      = group;
546     requests[0].vmoid      = vmoid;
547     requests[0].opcode     = BLOCKIO_WRITE;
548     requests[0].length     = 1;
549     requests[0].vmo_offset = 0;
550     requests[0].dev_offset = 0;
552     requests[1].group      = group;
553     requests[1].vmoid      = vmoid;
554     requests[1].opcode     = BLOCKIO_WRITE;
555     requests[1].length     = 2;
556     requests[1].vmo_offset = 1;
557     requests[1].dev_offset = 100;
559     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
566     requests[0].opcode = BLOCKIO_READ;
567     requests[1].opcode = BLOCKIO_READ;
568     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
573     requests[0].opcode = BLOCKIO_CLOSE_VMO;
574     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);
613     // Split it into two requests, spread across the disk
614     block_fifo_request_t requests[2];
615     requests[0].reqid      = 0;
616     requests[0].vmoid      = vmoid;
617     requests[0].opcode     = BLOCKIO_WRITE;
618     requests[0].length     = 1;
619     requests[0].vmo_offset = 0;
620     requests[0].dev_offset = 0;
622     requests[1].reqid      = 1;
623     requests[1].vmoid      = vmoid;
624     requests[1].opcode     = BLOCKIO_WRITE;
625     requests[1].length     = 2;
626     requests[1].vmo_offset = 1;
627     requests[1].dev_offset = 100;
648     ASSERT_TRUE(write_request(&requests[0]));
650     ASSERT_TRUE(write_request(&requests[1]));
659     requests[0].opcode = BLOCKIO_READ;
660     requests[1].opcode = BLOCKIO_READ;
662     ASSERT_TRUE(write_request(&requests[0]));
664     ASSERT_TRUE(write_request(&requests[1]));
671     requests[0].opcode = BLOCKIO_CLOSE_VMO;
672     ASSERT_EQ(fifo.write(requests, 1, nullptr), ZX_OK);
714     fbl::Array<block_fifo_request_t> requests(new (&ac) block_fifo_request_t[blocks], blocks);
717         requests[b].group      = group;
718         requests[b].vmoid      = obj->vmoid;
719         requests[b].opcode     = BLOCKIO_WRITE;
720         requests[b].length     = 1;
721         requests[b].vmo_offset = b;
722         requests[b].dev_offset = i + b * objs;
725     ASSERT_EQ(client->Transaction(&requests[0], requests.size()), ZX_OK);
740     fbl::Array<block_fifo_request_t> requests(new (&ac) block_fifo_request_t[blocks], blocks);
743         requests[b].group      = group;
744         requests[b].vmoid      = obj->vmoid;
745         requests[b].opcode     = BLOCKIO_READ;
746         requests[b].length     = 1;
747         requests[b].vmo_offset = b;
748         requests[b].dev_offset = i + b * objs;
751     ASSERT_EQ(client->Transaction(&requests[0], requests.size()), ZX_OK);
965         fbl::Array<block_fifo_request_t> requests(new (&ac) block_fifo_request_t[num_ops](),
970             requests[b].group      = group;
971             requests[b].vmoid      = obj.vmoid;
972             requests[b].opcode     = BLOCKIO_WRITE;
973             requests[b].length     = 1;
974             requests[b].vmo_offset = 0;
975             requests[b].dev_offset = 0;
978         ASSERT_EQ(client.Transaction(&requests[0], requests.size()), ZX_OK);
1005     fbl::Array<block_fifo_request_t> requests(new (&ac) block_fifo_request_t[kNumOps](),
1010         requests[b].group      = group;
1011         requests[b].vmoid      = obj.vmoid;
1012         requests[b].opcode     = BLOCKIO_WRITE | BLOCKIO_BARRIER_BEFORE |
1014         requests[b].length     = 1;
1015         requests[b].vmo_offset = 0;
1016         requests[b].dev_offset = b;
1031     ZX_ASSERT(fifo.write(sizeof(block_fifo_request_t), &requests[0],
1032                          requests.size(), &actual) == ZX_OK);
1071     block_fifo_request_t requests[kRequestCount];
1072     for (size_t i = 0; i < fbl::count_of(requests); i++) {
1073         requests[i].group      = group;
1074         requests[i].vmoid      = obj.vmoid;
1075         requests[i].opcode     = BLOCKIO_WRITE;
1076         requests[i].length     = 1;
1077         requests[i].vmo_offset = i;
1078         requests[i].dev_offset = i;
1080     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
1086     for (size_t bad_arg = 0; bad_arg < fbl::count_of(requests); bad_arg++) {
1094         for (size_t i = 0; i < fbl::count_of(requests); i++) {
1095             requests[i].group      = group;
1096             requests[i].vmoid      = obj.vmoid;
1097             requests[i].opcode     = BLOCKIO_READ;
1098             requests[i].length     = 1;
1099             requests[i].vmo_offset = i;
1100             requests[i].dev_offset = i;
1103         requests[bad_arg].length = 0;
1104         ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)),
1123     // Try to flex the server's error handling by sending 'malicious' client requests.
1157     // Try to flex the server's error handling by sending 'malicious' client requests.
1194     // Try to flex the server's error handling by sending 'malicious' client requests.
1256     // Try to flex the server's error handling by sending 'malicious' client requests.
1347     // Split it into two requests, spread across the disk
1348     block_fifo_request_t requests[2];
1349     requests[0].group = group;
1350     requests[0].vmoid = vmoid;
1351     requests[0].opcode = BLOCKIO_WRITE;
1352     requests[0].length = 1;
1353     requests[0].vmo_offset = 0;
1354     requests[0].dev_offset = 0;
1356     requests[1].group = group;
1357     requests[1].vmoid = vmoid;
1358     requests[1].opcode = BLOCKIO_WRITE;
1359     requests[1].length = 2;
1360     requests[1].vmo_offset = 1;
1361     requests[1].dev_offset = 100;
1363     // Send enough requests for the ramdisk to fall asleep before completing.
1364     // Other callers (e.g. block_watcher) may also send requests without affecting this test.
1365     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_ERR_UNAVAILABLE);
1375     requests[0].opcode = BLOCKIO_READ;
1376     requests[1].opcode = BLOCKIO_READ;
1377     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
1383     // Split it into two requests, spread across the disk.
1384     requests[0].opcode = BLOCKIO_WRITE;
1385     requests[0].length = 2;
1387     requests[1].opcode = BLOCKIO_WRITE;
1388     requests[1].length = 1;
1389     requests[1].vmo_offset = 2;
1391     // Send enough requests for the ramdisk to fall asleep before completing.
1392     // Other callers (e.g. block_watcher) may also send requests without affecting this test.
1393     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_ERR_UNAVAILABLE);
1402     requests[0].opcode = BLOCKIO_READ;
1403     requests[1].opcode = BLOCKIO_READ;
1404     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
1407     requests[0].opcode = BLOCKIO_CLOSE_VMO;
1408     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);
1420 //   block_fifo_txn(client, requests, fbl::count_of(requests));
1501     // Create a bunch of requests, some of which are guaranteed to block.
1502     block_fifo_request_t requests[16];
1503     for (size_t i = 0; i < fbl::count_of(requests); ++i) {
1504         requests[i].group = group;
1505         requests[i].vmoid = vmoid;
1506         requests[i].opcode = BLOCKIO_WRITE;
1507         requests[i].length = 1;
1508         requests[i].vmo_offset = i;
1509         requests[i].dev_offset = i;
1517     wake.after = fbl::count_of(requests);
1523     // Send enough requests to put the ramdisk to sleep and then be awoken wake thread. The ordering
1529     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
1535     for (size_t i = 0; i < fbl::count_of(requests); ++i) {
1536         requests[i].opcode = BLOCKIO_READ;
1540     ASSERT_EQ(client.Transaction(&requests[0], fbl::count_of(requests)), ZX_OK);
1546     requests[0].opcode = BLOCKIO_WRITE;
1547     requests[0].length = 16;
1548     requests[0].vmo_offset = 0;
1549     requests[0].dev_offset = 0;
1557     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);
1562     requests[0].opcode = BLOCKIO_READ;
1563     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);
1567     requests[0].opcode = BLOCKIO_WRITE;
1568     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);
1571     requests[0].opcode = BLOCKIO_CLOSE_VMO;
1572     ASSERT_EQ(client.Transaction(&requests[0], 1), ZX_OK);