tests/fstest/recovery_test.cpp

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless requied by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 /*
  19  * These file system recovery tests ensure the ability to recover from
  20  * filesystem crashes in key blocks (e.g. superblock).
  21  */
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <fs_mgr.h>
  26 #include <gtest/gtest.h>
  27 #include <logwrap/logwrap.h>
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30
  31 #include "cutils/properties.h"
  32 #include "ext4.h"
  33 #include "ext4_utils.h"
  34
  35 #define LOG_TAG "fsRecoveryTest"
  36 #include <utils/Log.h>
  37 #include <testUtil.h>
  38
  39 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  40 #define FSTAB_PREFIX "/fstab."
  41 #define SB_OFFSET 1024
  42 static char UMOUNT_BIN[] = "/system/bin/umount";
  43 static char VDC_BIN[] = "/system/bin/vdc";
  44
  45 enum Fs_Type { FS_UNKNOWN, FS_EXT4, FS_F2FS };
  46
  47 namespace android {
  48
  49 class DataFileVerifier {
  50  public:
  51   DataFileVerifier(const char* file_name) {
  52     strncpy(test_file_, file_name, FILENAME_MAX);
  53   }
  54
  55   void verify_write() {
  56     int write_fd = open(test_file_, O_CREAT | O_WRONLY, 0666);
  57     ASSERT_TRUE(write_fd);
  58     ASSERT_EQ(write(write_fd, "TEST", 4), 4);
  59     close(write_fd);
  60   }
  61
  62   void verify_read() {
  63     char read_buff[4];
  64     int read_fd = open(test_file_, O_RDONLY);
  65     ASSERT_TRUE(read_fd);
  66     ASSERT_EQ(read(read_fd, read_buff, sizeof(read_buff)), 4);
  67     ASSERT_FALSE(strncmp(read_buff, "TEST", 4));
  68     close(read_fd);
  69   }
  70
  71   ~DataFileVerifier() {
  72     unlink(test_file_);
  73   }
  74
  75  private:
  76   char test_file_[FILENAME_MAX];
  77 };
  78
  79 namespace ext4 {
  80 bool getSuperBlock(const int blk_fd, struct ext4_super_block* sb) {
  81   if (lseek(blk_fd, SB_OFFSET, SEEK_SET) == -1) {
  82     testPrintE("Cannot lseek to ext4 superblock to read");
  83     return false;
  84   }
  85
  86   if (read(blk_fd, sb, sizeof(*sb)) != sizeof(*sb)) {
  87     testPrintE("Cannot read ext4 superblock");
  88     return false;
  89   }
  90
  91   if (sb->s_magic != 0xEF53) {
  92     testPrintE("Invalid ext4 superblock magic");
  93     return false;
  94   }
  95
  96   return true;
  97 }
  98
  99 bool setSbErrorBit(const int blk_fd) {
 100   // Read super block.
 101   struct ext4_super_block sb;
 102   if (!getSuperBlock(blk_fd, &sb)) {
 103     return false;
 104   }
 105
 106   // Check that the detected errors bit is not set.
 107   if (sb.s_state & 0x2) {
 108     testPrintE("Ext4 superblock already corrupted");
 109     return false;
 110   }
 111
 112   // Set the detected errors bit.
 113   sb.s_state |= 0x2;
 114
 115   // Write superblock.
 116   if (lseek(blk_fd, SB_OFFSET, SEEK_SET) == -1) {
 117       testPrintE("Cannot lseek to superblock to write\n");
 118       return false;
 119   }
 120
 121   if (write(blk_fd, &sb, sizeof(sb)) != sizeof(sb)) {
 122       testPrintE("Cannot write superblock\n");
 123       return false;
 124   }
 125
 126   return true;
 127 }
 128
 129 bool corruptGdtFreeBlock(const int blk_fd) {
 130   // Read super block.
 131   struct ext4_super_block sb;
 132   if (!getSuperBlock(blk_fd, &sb)) {
 133     return false;
 134   }
 135   // Make sure the block size is 2K or 4K.
 136   if ((sb.s_log_block_size != 1) && (sb.s_log_block_size != 2)) {
 137       testPrintE("Ext4 block size not 2K or 4K\n");
 138       return false;
 139   }
 140   int block_size = 1 << (10 + sb.s_log_block_size);
 141   int num_bgs = DIV_ROUND_UP(sb.s_blocks_count_lo, sb.s_blocks_per_group);
 142
 143   if (sb.s_desc_size != sizeof(struct ext2_group_desc)) {
 144     testPrintE("Can't handle ext4 block group descriptor size of %d",
 145                sb.s_desc_size);
 146     return false;
 147   }
 148
 149   // Read first block group descriptor, decrement free block count, and
 150   // write it back out.
 151   if (lseek(blk_fd, block_size, SEEK_SET) == -1) {
 152     testPrintE("Cannot lseek to ext4 block group descriptor table to read");
 153     return false;
 154   }
 155
 156   // Read in block group descriptors till we read one that has at least one free
 157   // block.
 158   struct ext2_group_desc gd;
 159   for (int i = 0; i < num_bgs; i++) {
 160     if (read(blk_fd, &gd, sizeof(gd)) != sizeof(gd)) {
 161       testPrintE("Cannot read ext4 group descriptor %d", i);
 162       return false;
 163     }
 164     if (gd.bg_free_blocks_count) {
 165       break;
 166     }
 167   }
 168
 169   gd.bg_free_blocks_count--;
 170
 171   if (lseek(blk_fd, -sizeof(gd), SEEK_CUR) == -1) {
 172     testPrintE("Cannot lseek to ext4 block group descriptor table to write");
 173     return false;
 174   }
 175
 176   if (write(blk_fd, &gd, sizeof(gd)) != sizeof(gd)) {
 177     testPrintE("Cannot write modified ext4 group descriptor");
 178     return false;
 179   }
 180   return true;
 181 }
 182
 183 }  // namespace ext4
 184
 185 class FsRecoveryTest : public ::testing::Test {
 186  protected:
 187   FsRecoveryTest() : fs_type(FS_UNKNOWN), blk_fd_(-1) {}
 188
 189   bool setCacheInfoFromFstab() {
 190     fs_type = FS_UNKNOWN;
 191     char propbuf[PROPERTY_VALUE_MAX];
 192     property_get("ro.hardware", propbuf, "");
 193     char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)];
 194     snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX"%s", propbuf);
 195
 196     struct fstab *fstab = fs_mgr_read_fstab(fstab_filename);
 197     if (!fstab) {
 198       testPrintE("failed to open %s\n", fstab_filename);
 199     } else {
 200       // Loop through entries looking for cache.
 201       for (int i = 0; i < fstab->num_entries; ++i) {
 202         if (!strcmp(fstab->recs[i].mount_point, "/cache")) {
 203           strcpy(blk_path_, fstab->recs[i].blk_device);
 204           if (!strcmp(fstab->recs[i].fs_type, "ext4")) {
 205             fs_type = FS_EXT4;
 206             break;
 207           } else if (!strcmp(fstab->recs[i].fs_type, "f2fs")) {
 208             fs_type = FS_F2FS;
 209             break;
 210           }
 211         }
 212       }
 213       fs_mgr_free_fstab(fstab);
 214     }
 215     return fs_type != FS_UNKNOWN;
 216   }
 217
 218   bool unmountCache() {
 219     char cache_str[] = "/cache";
 220     char *umount_argv[] = {
 221       UMOUNT_BIN,
 222       cache_str,
 223     };
 224     int status;
 225     return android_fork_execvp_ext(ARRAY_SIZE(umount_argv), umount_argv,
 226                                    NULL, true, LOG_KLOG, false, NULL,
 227                                    NULL, 0) >= 0;
 228   }
 229
 230   bool mountAll() {
 231     char storage_str[] = "storage";
 232     char mountall_str[] = "mountall";
 233     char *mountall_argv[] = {
 234       VDC_BIN,
 235       storage_str,
 236       mountall_str,
 237     };
 238     int status;
 239     return android_fork_execvp_ext(ARRAY_SIZE(mountall_argv), mountall_argv,
 240                                    NULL, true, LOG_KLOG, false, NULL,
 241                                    NULL, 0) >= 0;
 242   }
 243
 244   int getCacheBlkFd() {
 245     if (blk_fd_ == -1) {
 246       blk_fd_ = open(blk_path_, O_RDWR);
 247     }
 248     return blk_fd_;
 249   }
 250
 251   void closeCacheBlkFd() {
 252     if (blk_fd_ > -1) {
 253       close(blk_fd_);
 254     }
 255     blk_fd_ = -1;
 256   }
 257
 258   void assertCacheHealthy() {
 259     const char* test_file = "/cache/FsRecoveryTestGarbage.txt";
 260     DataFileVerifier file_verify(test_file);
 261     file_verify.verify_write();
 262     file_verify.verify_read();
 263   }
 264
 265   virtual void SetUp() {
 266     assertCacheHealthy();
 267     ASSERT_TRUE(setCacheInfoFromFstab());
 268   }
 269
 270   virtual void TearDown() {
 271     // Ensure /cache partition is accessible, mounted and healthy for other
 272     // tests.
 273     closeCacheBlkFd();
 274     ASSERT_TRUE(mountAll());
 275     assertCacheHealthy();
 276   }
 277
 278   Fs_Type fs_type;
 279
 280  private:
 281   char blk_path_[FILENAME_MAX];
 282   int blk_fd_;
 283 };
 284
 285 TEST_F(FsRecoveryTest, EXT4_CorruptGdt) {
 286   if (fs_type != FS_EXT4) {
 287     return;
 288   }
 289   // Setup test file in /cache.
 290   const char* test_file = "/cache/CorruptGdtGarbage.txt";
 291   DataFileVerifier file_verify(test_file);
 292   file_verify.verify_write();
 293   // Unmount and corrupt /cache gdt.
 294   ASSERT_TRUE(unmountCache());
 295   ASSERT_TRUE(ext4::corruptGdtFreeBlock(getCacheBlkFd()));
 296   closeCacheBlkFd();
 297   ASSERT_TRUE(mountAll());
 298
 299   // Verify results.
 300   file_verify.verify_read();
 301 }
 302
 303 TEST_F(FsRecoveryTest, EXT4_SetErrorBit) {
 304   if (fs_type != FS_EXT4) {
 305     return;
 306   }
 307   // Setup test file in /cache.
 308   const char* test_file = "/cache/ErrorBitGarbagetxt";
 309   DataFileVerifier file_verify(test_file);
 310   file_verify.verify_write();
 311
 312   // Unmount and set /cache super block error bit.
 313   ASSERT_TRUE(unmountCache());
 314   ASSERT_TRUE(ext4::setSbErrorBit(getCacheBlkFd()));
 315   closeCacheBlkFd();
 316   ASSERT_TRUE(mountAll());
 317
 318   // Verify results.
 319   file_verify.verify_read();
 320   struct ext4_super_block sb;
 321   ASSERT_TRUE(ext4::getSuperBlock(getCacheBlkFd(), &sb));
 322   // Verify e2fsck has recovered the error bit of sb.
 323   ASSERT_FALSE(sb.s_state & 0x2);
 324 }
 325 }  // namespace android