Lines Matching refs:info
418 fuchsia_io_FilesystemInfo info;
420 ASSERT_EQ(fuchsia_io_DirectoryAdminQueryFilesystem(caller.borrow_channel(), &status, &info),
424 const char* name = reinterpret_cast<const char*>(info.name);
426 ASSERT_LE(info.used_nodes, info.total_nodes, "Used nodes greater than free nodes");
427 ASSERT_LE(info.used_bytes, info.total_bytes, "Used bytes greater than free bytes");
495 static bool MakeBlob(blob_info_t* info, fbl::unique_fd* out_fd) {
496 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
498 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
499 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
501 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
506 static bool MakeBlobUnverified(blob_info_t* info, fbl::unique_fd* out_fd) {
507 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
509 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
510 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
529 static bool MakeBlobCompromised(blob_info_t* info) {
530 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
532 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
535 StreamAll(write, fd.get(), info->data.get(), info->size_data);
537 ASSERT_TRUE(VerifyCompromised(fd.get(), info->data.get(), info->size_data));
568 fbl::unique_ptr<blob_info_t> info(new (&ac) blob_info_t);
570 info->data.reset(new (&ac) char[size_data]);
572 sourceCb(info->data.get(), size_data);
573 info->size_data = size_data;
576 info->size_merkle = MerkleTree::GetTreeLength(size_data);
577 if (info->size_merkle == 0) {
578 info->merkle = nullptr;
580 info->merkle.reset(new (&ac) char[info->size_merkle]);
584 ASSERT_EQ(MerkleTree::Create(&info->data[0], info->size_data, &info->merkle[0],
585 info->size_merkle, &digest),
587 strcpy(info->path, MOUNT_PATH "/");
588 size_t prefix_len = strlen(info->path);
589 digest.ToString(info->path + prefix_len, sizeof(info->path) - prefix_len);
592 ASSERT_EQ(MerkleTree::Verify(&info->data[0], info->size_data, &info->merkle[0],
593 info->size_merkle, 0, info->size_data, digest),
596 *out = fbl::move(info);
611 fuchsia_io_FilesystemInfo info;
613 ASSERT_EQ(fuchsia_io_DirectoryAdminQueryFilesystem(caller.borrow_channel(), &status, &info),
617 const char* name = reinterpret_cast<const char*>(info.name);
620 ASSERT_EQ(info.block_size, blobfs::kBlobfsBlockSize);
621 ASSERT_EQ(info.max_filename_size, Digest::kLength * 2);
622 ASSERT_EQ(info.fs_type, VFS_TYPE_BLOBFS);
623 ASSERT_NE(info.fs_id, 0);
626 ASSERT_GE(info.used_bytes, expected_bytes);
627 ASSERT_LE(info.used_bytes, info.total_bytes);
630 ASSERT_GE(info.total_bytes, kTestFvmSliceSize);
631 ASSERT_EQ(info.total_bytes % kTestFvmSliceSize, 0);
632 ASSERT_EQ(info.total_nodes, kTestFvmSliceSize / blobfs::kBlobfsInodeSize);
633 ASSERT_EQ(info.used_nodes, expected_nodes);
643 fbl::unique_ptr<blob_info_t> info;
644 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
647 ASSERT_TRUE(MakeBlob(info.get(), &fd));
651 fd.reset(open(info->path, O_RDONLY));
653 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
657 fd.reset(open(info->path, O_RDWR | O_CREAT));
659 fd.reset(open(info->path, O_RDWR));
661 fd.reset(open(info->path, O_WRONLY));
664 ASSERT_EQ(unlink(info->path), 0);
671 fbl::unique_ptr<blob_info_t> info;
672 ASSERT_TRUE(GenerateRandomBlob(0, &info));
674 fbl::unique_fd fd(open(info->path, O_CREAT | O_EXCL | O_RDWR));
681 fd.reset(open(info->path, O_CREAT | O_EXCL | O_RDWR));
683 fd.reset(open(info->path, O_CREAT | O_RDWR));
686 fd.reset(open(info->path, O_RDONLY));
689 ASSERT_EQ(unlink(info->path), 0, "Null Blob should be unlinkable");
697 fbl::unique_ptr<blob_info_t> info;
708 }, 1 << i, &info));
711 ASSERT_TRUE(MakeBlob(info.get(), &fd));
715 fd.reset(open(info->path, O_RDONLY));
717 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
721 fd.reset(open(info->path, O_RDWR | O_CREAT));
723 fd.reset(open(info->path, O_RDWR));
725 fd.reset(open(info->path, O_WRONLY));
730 fd.reset(open(info->path, O_RDONLY));
732 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
735 ASSERT_EQ(unlink(info->path), 0);
744 fbl::unique_ptr<blob_info_t> info;
745 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
748 ASSERT_TRUE(MakeBlob(info.get(), &fd));
750 fd.reset(open(info->path, O_RDONLY));
753 void* addr = mmap(NULL, info->size_data, PROT_READ, MAP_PRIVATE,
756 ASSERT_EQ(memcmp(addr, info->data.get(), info->size_data), 0, "Mmap data invalid");
757 ASSERT_EQ(munmap(addr, info->size_data), 0, "Could not unmap blob");
759 ASSERT_EQ(unlink(info->path), 0);
767 fbl::unique_ptr<blob_info_t> info;
768 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
771 ASSERT_TRUE(MakeBlob(info.get(), &fd));
773 fd.reset(open(info->path, O_RDONLY));
776 void* addr = mmap(NULL, info->size_data, PROT_READ, MAP_PRIVATE, fd.get(), 0);
781 ASSERT_EQ(memcmp(addr, info->data.get(), info->size_data), 0, "Mmap data invalid");
789 fd.reset(open(info->path, O_RDONLY));
790 void* addr2 = mmap(NULL, info->size_data, PROT_READ, MAP_PRIVATE, fd.get(), 0);
793 ASSERT_EQ(memcmp(addr2, info->data.get(), info->size_data), 0, "Mmap data invalid");
795 ASSERT_EQ(munmap(addr, info->size_data), 0, "Could not unmap blob");
796 ASSERT_EQ(munmap(addr2, info->size_data), 0, "Could not unmap blob");
798 ASSERT_EQ(unlink(info->path), 0);
810 info(new (&ac) fbl::unique_ptr<blob_info_t>[kMaxEntries](), kMaxEntries);
821 ASSERT_TRUE(GenerateRandomBlob(kBlobSize, &info[i]));
823 ASSERT_TRUE(MakeBlob(info[i].get(), &fd));
825 fd.reset(open(info[i]->path, O_RDONLY));
827 ASSERT_TRUE(VerifyContents(fd.get(), info[i]->data.get(), info[i]->size_data));
845 if ((info[i]->size_data != 0) &&
846 strcmp(strrchr(info[i]->path, '/') + 1, de->d_name) == 0) {
847 ASSERT_EQ(unlink(info[i]->path), 0);
850 info[i]->size_data = 0;
895 blobfs::blobfs_info_t info;
896 info.inode_count = blobfs::kBlobfsDefaultInodeCount;
897 info.block_count = blobfs::kMinimumDataBlocks;
898 info.flags = 0;
900 minimum_size = (blobfs::DataBlocks(info) + blobfs::DataStartBlock(info)) *
943 fbl::unique_ptr<blob_info_t> info;
944 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
947 ASSERT_TRUE(MakeBlob(info.get(), &fd));
949 total_bytes += fbl::round_up(info->size_merkle + info->size_data,
960 fbl::unique_ptr<blob_info_t> info;
961 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
964 ASSERT_TRUE(MakeBlob(info.get(), &fd));
967 ASSERT_EQ(unlink(info->path), 0, "Failed to unlink");
970 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
974 ASSERT_LT(open(info->path, O_RDONLY), 0, "Expected blob to be deleted");
982 fbl::unique_ptr<blob_info_t> info;
983 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
986 ASSERT_TRUE(MakeBlob(info.get(), &fd));
989 ASSERT_LT(write(fd.get(), info->data.get(), 1), 0,
992 off_t seek_pos = (rand() % info->size_data);
994 ASSERT_LT(write(fd.get(), info->data.get(), 1), 0,
996 ASSERT_LT(ftruncate(fd.get(), rand() % info->size_data), 0,
1001 ASSERT_EQ(unlink(info->path), 0, "Failed to unlink");
1008 fbl::unique_ptr<blob_info_t> info;
1010 ASSERT_TRUE(GenerateRandomBlob(size, &info));
1013 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
1016 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), size / 2), 0, "Failed to write Data");
1017 ASSERT_EQ(unlink(info->path), 0);
1018 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get() + size / 2, size - (size / 2)), 0, "Failed to write Data");
1020 ASSERT_LT(open(info->path, O_RDONLY), 0);
1027 fbl::unique_ptr<blob_info_t> info;
1028 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1031 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1035 fbl::unique_ptr<char[]> buf(new (&ac) char[info->size_data]);
1039 off_t end_off = info->size_data;
1044 for (ssize_t j = 1; j < static_cast<ssize_t>(info->size_data); j *= 2) {
1045 end_off = info->size_data - j;
1048 ASSERT_EQ(memcmp(buf.get(), &info->data[info->size_data - j], j),
1054 ASSERT_EQ(unlink(info->path), 0, "Failed to unlink");
1067 fbl::unique_ptr<blob_info_t> info;
1068 ASSERT_TRUE(GenerateRandomBlob(1 << 15, &info));
1070 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
1077 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0, "Failed to allocate blob");
1082 ASSERT_LT(open(info->path, O_RDWR), 0, "Cannot access partial blob");
1083 ASSERT_LT(open(info->path, O_RDONLY), 0, "Cannot access partial blob");
1086 fd.reset(open(info->path, O_CREAT | O_RDWR));
1088 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0, "Failed to allocate blob");
1089 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data - 1), 0,
1092 ASSERT_LT(open(info->path, O_RDWR), 0, "Cannot access partial blob");
1099 fbl::unique_ptr<blob_info_t> info;
1101 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1102 info->size_data -= (rand() % info->size_data) + 1;
1103 if (info->size_data == 0) {
1104 info->size_data = 1;
1106 ASSERT_TRUE(MakeBlobCompromised(info.get()));
1110 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1112 size_t rand_index = rand() % info->size_data;
1113 char old_val = info->data.get()[rand_index];
1114 while ((info->data.get()[rand_index] = static_cast<char>(rand())) == old_val) {
1116 ASSERT_TRUE(MakeBlobCompromised(info.get()));
1125 fbl::unique_ptr<blob_info_t> info;
1127 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1130 size_t idx = strlen(info->path) - 1 - (rand() % (2 * Digest::kLength));
1132 while (info->path[idx] == newchar) {
1135 info->path[idx] = newchar;
1136 ASSERT_TRUE(MakeBlobCompromised(info.get()));
1140 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1142 size_t rand_index = rand() % info->size_data;
1143 char old_val = info->data.get()[rand_index];
1144 while ((info->data.get()[rand_index] = static_cast<char>(rand())) == old_val) {
1146 ASSERT_TRUE(MakeBlobCompromised(info.get()));
1159 fbl::unique_ptr<blob_info_t> info;
1160 ASSERT_TRUE(GenerateRandomBlob((1 << i) + j, &info));
1162 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1163 ASSERT_EQ(unlink(info->path), 0);
1172 fbl::unique_ptr<blob_info_t> info;
1173 ASSERT_TRUE(GenerateRandomBlob(1 << 16, &info));
1175 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1183 fd.reset(open(info->path, O_RDONLY));
1185 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1188 ASSERT_EQ(unlink(info->path), 0);
1194 fbl::unique_ptr<blob_info_t> info;
1195 ASSERT_TRUE(GenerateRandomBlob(1 << 16, &info));
1197 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1199 void* addr = mmap(nullptr, info->size_data, PROT_READ, MAP_SHARED, fd.get(), 0);
1206 ASSERT_EQ(munmap(addr, info->size_data), 0);
1208 fd.reset(open(info->path, O_RDONLY));
1210 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1213 ASSERT_EQ(unlink(info->path), 0);
1219 fbl::unique_ptr<blob_info_t> info;
1220 ASSERT_TRUE(GenerateRandomBlob(1 << 16, &info));
1222 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1224 void* addr = mmap(nullptr, info->size_data, PROT_READ, MAP_SHARED, fd.get(), 0);
1230 ASSERT_EQ(munmap(addr, info->size_data), 0);
1234 fd.reset(open(info->path, O_RDONLY));
1236 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1239 ASSERT_EQ(unlink(info->path), 0);
1246 fbl::unique_ptr<blob_info_t> info;
1247 ASSERT_TRUE(GenerateRandomBlob(1 << i, &info));
1250 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1256 fd.reset(open(info->path, O_RDONLY));
1259 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1261 ASSERT_EQ(unlink(info->path), 0);
1297 fbl::unique_ptr<blob_info_t> info;
1299 ASSERT_TRUE(GenerateRandomBlob(1 << 17, &info));
1300 fbl::unique_fd fd(open(info->path, O_CREAT | O_EXCL | O_RDWR));
1303 ASSERT_LT(open(info->path, O_CREAT | O_EXCL | O_RDWR), 0,
1307 fbl::unique_fd fd2(open(info->path, O_CREAT | O_RDWR));
1312 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
1315 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
1320 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1321 ASSERT_TRUE(VerifyContents(fd2.get(), info->data.get(), info->size_data));
1328 ASSERT_EQ(unlink(info->path), 0);
1345 fbl::unique_ptr<blob_info_t> info;
1347 ASSERT_TRUE(GenerateRandomBlob(1 << 17, &info));
1348 fbl::unique_fd fd(open(info->path, O_CREAT | O_EXCL | O_RDWR));
1351 ASSERT_LT(open(info->path, O_CREAT | O_EXCL | O_RDWR), 0,
1377 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
1379 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
1391 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1393 ASSERT_EQ(unlink(info->path), 0);
1400 fbl::unique_ptr<blob_info_t> info;
1401 ASSERT_TRUE(GenerateRandomBlob(1 << 17, &info));
1402 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
1404 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
1407 while (n != info->size_data) {
1408 off_t seek_pos = (rand() % info->size_data);
1410 ssize_t d = write(fd.get(), info->data.get(), info->size_data - n);
1416 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1418 ASSERT_EQ(unlink(info->path), 0);
1435 fbl::unique_ptr<blob_info_t> info;
1436 ASSERT_TRUE(GenerateRandomBlob(1 << 17, &info));
1438 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
1442 ASSERT_TRUE(full_unlink_reopen(fd, info->path));
1445 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
1446 ASSERT_TRUE(full_unlink_reopen(fd, info->path));
1449 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0);
1450 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
1452 ASSERT_TRUE(full_unlink_reopen(fd, info->path));
1453 ASSERT_EQ(unlink(info->path), 0);
1462 fbl::unique_ptr<blob_info_t> info;
1463 ASSERT_TRUE(GenerateRandomBlob(1 << 12, &info));
1465 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1466 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1469 ASSERT_LT(rename(info->path, info->path), 0);
1470 ASSERT_LT(truncate(info->path, 0), 0);
1471 ASSERT_LT(utime(info->path, nullptr), 0);
1481 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1482 ASSERT_EQ(unlink(info->path), 0);
1493 fbl::unique_ptr<blob_info_t> info;
1494 ASSERT_TRUE(GenerateRandomBlob(1 << 12, &info));
1497 ASSERT_LT(ftruncate(dirfd.get(), info->size_data), 0);
1505 ASSERT_LT(unlink(info->path), 0);
1585 : info(fbl::move(i)), state(empty), writes_remaining(1) {
1586 bytes_remaining = info->size_data;
1589 fbl::unique_ptr<blob_info_t> info;
1608 fbl::unique_ptr<blob_info_t> info;
1609 ASSERT_TRUE(GenerateRandomBlob(1 + (rand_r(seed) % (1 << 16)), &info));
1612 fbl::unique_ptr<blob_state_t> state(new (&ac) blob_state(fbl::move(info)));
1621 fbl::unique_fd fd(open(state->info->path, O_CREAT | O_RDWR));
1642 ASSERT_EQ(ftruncate(state->fd.get(), state->info->size_data), 0);
1663 size_t bytes_offset = state->info->size_data - state->bytes_remaining;
1664 ASSERT_EQ(StreamAll(write, state->fd.get(), state->info->data.get() + bytes_offset,
1690 ASSERT_TRUE(VerifyContents(state->fd.get(), state->info->data.get(),
1691 state->info->size_data));
1710 ASSERT_EQ(unlink(state->info->path), 0, "Could not unlink blob");
1729 fbl::unique_fd fd(open(state->info->path, O_RDONLY));
1782 fbl::unique_ptr<blob_info_t> info;
1786 ASSERT_TRUE(GenerateRandomBlob(2 * blobfs::WriteBufferSize(), &info));
1789 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1793 fd.reset(open(info->path, O_RDONLY));
1795 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1799 fd.reset(open(info->path, O_RDWR | O_CREAT));
1801 fd.reset(open(info->path, O_RDWR));
1803 fd.reset(open(info->path, O_WRONLY));
1808 fd.reset(open(info->path, O_RDONLY));
1810 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1813 ASSERT_EQ(unlink(info->path), 0);
1819 fbl::unique_ptr<blob_info_t> info;
1827 }, 2 * blobfs::WriteBufferSize(), &info));
1830 ASSERT_TRUE(MakeBlob(info.get(), &fd));
1834 fd.reset(open(info->path, O_RDONLY));
1836 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1840 fd.reset(open(info->path, O_RDWR | O_CREAT));
1842 fd.reset(open(info->path, O_RDWR));
1844 fd.reset(open(info->path, O_WRONLY));
1849 fd.reset(open(info->path, O_RDONLY));
1851 ASSERT_TRUE(VerifyContents(fd.get(), info->data.get(), info->size_data));
1854 ASSERT_EQ(unlink(info->path), 0);
1903 fbl::unique_fd fd(open(state.info->path, O_RDONLY));
1905 ASSERT_TRUE(VerifyContents(fd.get(), state.info->data.get(),
1906 state.info->size_data));
1907 ASSERT_EQ(unlink(state.info->path), 0);
1911 ASSERT_LT(open(state.info->path, O_RDONLY), 0);
1984 fbl::unique_fd fd(open(state.info->path, O_RDONLY));
1986 ASSERT_TRUE(VerifyContents(fd.get(), state.info->data.get(),
1987 state.info->size_data));
1988 ASSERT_EQ(unlink(state.info->path), 0);
1992 ASSERT_LT(open(state.info->path, O_RDONLY), 0);
2006 fbl::unique_ptr<blob_info_t> info;
2007 ASSERT_TRUE(GenerateRandomBlob(1 << 17, &info));
2009 fbl::unique_fd fd(open(info->path, O_CREAT | O_RDWR));
2011 int r = ftruncate(fd.get(), info->size_data);
2017 ASSERT_EQ(ftruncate(fd.get(), info->size_data), 0, "Re-init after unlink");
2023 ASSERT_EQ(StreamAll(write, fd.get(), info->data.get(), info->size_data), 0,
2026 last_info = fbl::move(info);
2075 fbl::unique_ptr<blob_info_t> info;
2076 ASSERT_TRUE(GenerateRandomBlob(1 << 10, &info));
2078 ASSERT_TRUE(MakeBlob(info.get(), &blob_fd));
2079 ASSERT_TRUE(VerifyContents(blob_fd.get(), info->data.get(), info->size_data));
2086 blob_fd.reset(open(info->path, O_RDONLY));
2088 ASSERT_TRUE(VerifyContents(blob_fd.get(), info->data.get(), info->size_data));
2092 ASSERT_TRUE(GenerateRandomBlob(1 << 10, &info));
2093 ASSERT_LT(open(info->path, O_CREAT | O_RDWR), 0);
2109 fbl::unique_ptr<blob_info_t> info;
2110 ASSERT_TRUE(GenerateRandomBlob(64, &info));
2113 ASSERT_TRUE(MakeBlob(info.get(), &fd));
2244 fbl::unique_ptr<blob_info_t> info;
2245 ASSERT_TRUE(GenerateRandomBlob(10 * (1 << 20), &info));
2247 strcpy(dat.path, info->path);
2256 ASSERT_TRUE(MakeBlobUnverified(info.get(), &fd));
2273 ASSERT_EQ(unlink(info->path), 0);
2390 fprintf(stderr, "[fs] Could not query block device info\n");