1 /* 2 * Helper functions for multiple mount protection (MMP). 3 * 4 * Copyright (C) 2011 Whamcloud, Inc. 5 * 6 * %Begin-Header% 7 * This file may be redistributed under the terms of the GNU Library 8 * General Public License, version 2. 9 * %End-Header% 10 */ 11 12 #ifndef _GNU_SOURCE 13 #define _GNU_SOURCE 14 #endif 15 #ifndef _DEFAULT_SOURCE 16 #define _DEFAULT_SOURCE /* since glibc 2.20 _SVID_SOURCE is deprecated */ 17 #endif 18 19 #include "config.h" 20 21 #if HAVE_UNISTD_H 22 #include <unistd.h> 23 #endif 24 #include <sys/time.h> 25 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <fcntl.h> 29 30 #include "ext2fs/ext2_fs.h" 31 #include "ext2fs/ext2fs.h" 32 33 #ifndef O_DIRECT 34 #define O_DIRECT 0 35 #endif 36 37 #pragma GCC diagnostic push 38 #ifndef CONFIG_MMP 39 #pragma GCC diagnostic ignored "-Wunused-parameter" 40 #endif 41 42 errcode_t ext2fs_mmp_read(ext2_filsys fs, blk64_t mmp_blk, void *buf) 43 { 44 #ifdef CONFIG_MMP 45 struct mmp_struct *mmp_cmp; 46 errcode_t retval = 0; 47 48 if ((mmp_blk <= fs->super->s_first_data_block) || 49 (mmp_blk >= ext2fs_blocks_count(fs->super))) 50 return EXT2_ET_MMP_BAD_BLOCK; 51 52 /* ext2fs_open() reserves fd0,1,2 to avoid stdio collision, so checking 53 * mmp_fd <= 0 is OK to validate that the fd is valid. This opens its 54 * own fd to read the MMP block to ensure that it is using O_DIRECT, 55 * regardless of how the io_manager is doing reads, to avoid caching of 56 * the MMP block by the io_manager or the VM. It needs to be fresh. */ 57 if (fs->mmp_fd <= 0) { 58 fs->mmp_fd = open(fs->device_name, O_RDWR | O_DIRECT); 59 if (fs->mmp_fd < 0) { 60 retval = EXT2_ET_MMP_OPEN_DIRECT; 61 goto out; 62 } 63 } 64 65 if (fs->mmp_cmp == NULL) { 66 int align = ext2fs_get_dio_alignment(fs->mmp_fd); 67 68 retval = ext2fs_get_memalign(fs->blocksize, align, 69 &fs->mmp_cmp); 70 if (retval) 71 return retval; 72 } 73 74 if ((blk64_t) ext2fs_llseek(fs->mmp_fd, mmp_blk * fs->blocksize, 75 SEEK_SET) != 76 mmp_blk * fs->blocksize) { 77 retval = EXT2_ET_LLSEEK_FAILED; 78 goto out; 79 } 80 81 if (read(fs->mmp_fd, fs->mmp_cmp, fs->blocksize) != fs->blocksize) { 82 retval = EXT2_ET_SHORT_READ; 83 goto out; 84 } 85 86 mmp_cmp = fs->mmp_cmp; 87 88 if (!(fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) && 89 !ext2fs_mmp_csum_verify(fs, mmp_cmp)) 90 retval = EXT2_ET_MMP_CSUM_INVALID; 91 92 #ifdef WORDS_BIGENDIAN 93 ext2fs_swap_mmp(mmp_cmp); 94 #endif 95 96 if (buf != NULL && buf != fs->mmp_cmp) 97 memcpy(buf, fs->mmp_cmp, fs->blocksize); 98 99 if (mmp_cmp->mmp_magic != EXT4_MMP_MAGIC) { 100 retval = EXT2_ET_MMP_MAGIC_INVALID; 101 goto out; 102 } 103 104 out: 105 return retval; 106 #else 107 return EXT2_ET_OP_NOT_SUPPORTED; 108 #endif 109 } 110 111 errcode_t ext2fs_mmp_write(ext2_filsys fs, blk64_t mmp_blk, void *buf) 112 { 113 #ifdef CONFIG_MMP 114 struct mmp_struct *mmp_s = buf; 115 struct timeval tv; 116 errcode_t retval = 0; 117 118 gettimeofday(&tv, 0); 119 mmp_s->mmp_time = tv.tv_sec; 120 fs->mmp_last_written = tv.tv_sec; 121 122 if (fs->super->s_mmp_block < fs->super->s_first_data_block || 123 fs->super->s_mmp_block > ext2fs_blocks_count(fs->super)) 124 return EXT2_ET_MMP_BAD_BLOCK; 125 126 #ifdef WORDS_BIGENDIAN 127 ext2fs_swap_mmp(mmp_s); 128 #endif 129 130 retval = ext2fs_mmp_csum_set(fs, mmp_s); 131 if (retval) 132 return retval; 133 134 /* I was tempted to make this use O_DIRECT and the mmp_fd, but 135 * this caused no end of grief, while leaving it as-is works. */ 136 retval = io_channel_write_blk64(fs->io, mmp_blk, -(int)sizeof(struct mmp_struct), buf); 137 138 #ifdef WORDS_BIGENDIAN 139 ext2fs_swap_mmp(mmp_s); 140 #endif 141 142 /* Make sure the block gets to disk quickly */ 143 io_channel_flush(fs->io); 144 return retval; 145 #else 146 return EXT2_ET_OP_NOT_SUPPORTED; 147 #endif 148 } 149 150 #ifdef HAVE_SRANDOM 151 #define srand(x) srandom(x) 152 #define rand() random() 153 #endif 154 155 unsigned ext2fs_mmp_new_seq(void) 156 { 157 #ifdef CONFIG_MMP 158 unsigned new_seq; 159 struct timeval tv; 160 161 gettimeofday(&tv, 0); 162 srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec); 163 164 gettimeofday(&tv, 0); 165 /* Crank the random number generator a few times */ 166 for (new_seq = (tv.tv_sec ^ tv.tv_usec) & 0x1F; new_seq > 0; new_seq--) 167 rand(); 168 169 do { 170 new_seq = rand(); 171 } while (new_seq > EXT4_MMP_SEQ_MAX); 172 173 return new_seq; 174 #else 175 return EXT2_ET_OP_NOT_SUPPORTED; 176 #endif 177 } 178 179 #ifdef CONFIG_MMP 180 static errcode_t ext2fs_mmp_reset(ext2_filsys fs) 181 { 182 struct mmp_struct *mmp_s = NULL; 183 errcode_t retval = 0; 184 185 if (fs->mmp_buf == NULL) { 186 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf); 187 if (retval) 188 goto out; 189 } 190 191 memset(fs->mmp_buf, 0, fs->blocksize); 192 mmp_s = fs->mmp_buf; 193 194 mmp_s->mmp_magic = EXT4_MMP_MAGIC; 195 mmp_s->mmp_seq = EXT4_MMP_SEQ_CLEAN; 196 mmp_s->mmp_time = 0; 197 #if _BSD_SOURCE || _XOPEN_SOURCE >= 500 198 gethostname(mmp_s->mmp_nodename, sizeof(mmp_s->mmp_nodename)); 199 #else 200 mmp_s->mmp_nodename[0] = '\0'; 201 #endif 202 strncpy(mmp_s->mmp_bdevname, fs->device_name, 203 sizeof(mmp_s->mmp_bdevname)); 204 205 mmp_s->mmp_check_interval = fs->super->s_mmp_update_interval; 206 if (mmp_s->mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL) 207 mmp_s->mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL; 208 209 retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf); 210 out: 211 return retval; 212 } 213 #endif 214 215 errcode_t ext2fs_mmp_update(ext2_filsys fs) 216 { 217 return ext2fs_mmp_update2(fs, 0); 218 } 219 220 errcode_t ext2fs_mmp_clear(ext2_filsys fs) 221 { 222 #ifdef CONFIG_MMP 223 errcode_t retval = 0; 224 225 if (!(fs->flags & EXT2_FLAG_RW)) 226 return EXT2_ET_RO_FILSYS; 227 228 retval = ext2fs_mmp_reset(fs); 229 230 return retval; 231 #else 232 return EXT2_ET_OP_NOT_SUPPORTED; 233 #endif 234 } 235 236 errcode_t ext2fs_mmp_init(ext2_filsys fs) 237 { 238 #ifdef CONFIG_MMP 239 struct ext2_super_block *sb = fs->super; 240 blk64_t mmp_block; 241 errcode_t retval; 242 243 if (sb->s_mmp_update_interval == 0) 244 sb->s_mmp_update_interval = EXT4_MMP_UPDATE_INTERVAL; 245 /* This is probably excessively large, but who knows? */ 246 else if (sb->s_mmp_update_interval > EXT4_MMP_MAX_UPDATE_INTERVAL) 247 return EXT2_ET_INVALID_ARGUMENT; 248 249 if (fs->mmp_buf == NULL) { 250 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf); 251 if (retval) 252 goto out; 253 } 254 255 retval = ext2fs_alloc_block2(fs, 0, fs->mmp_buf, &mmp_block); 256 if (retval) 257 goto out; 258 259 sb->s_mmp_block = mmp_block; 260 261 retval = ext2fs_mmp_reset(fs); 262 if (retval) 263 goto out; 264 265 out: 266 return retval; 267 #else 268 return EXT2_ET_OP_NOT_SUPPORTED; 269 #endif 270 } 271 272 /* 273 * Make sure that the fs is not mounted or being fsck'ed while opening the fs. 274 */ 275 errcode_t ext2fs_mmp_start(ext2_filsys fs) 276 { 277 #ifdef CONFIG_MMP 278 struct mmp_struct *mmp_s; 279 unsigned seq; 280 unsigned int mmp_check_interval; 281 errcode_t retval = 0; 282 283 if (fs->mmp_buf == NULL) { 284 retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf); 285 if (retval) 286 goto mmp_error; 287 } 288 289 retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); 290 if (retval) 291 goto mmp_error; 292 293 mmp_s = fs->mmp_buf; 294 295 mmp_check_interval = fs->super->s_mmp_update_interval; 296 if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL) 297 mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL; 298 299 seq = mmp_s->mmp_seq; 300 if (seq == EXT4_MMP_SEQ_CLEAN) 301 goto clean_seq; 302 if (seq == EXT4_MMP_SEQ_FSCK) { 303 retval = EXT2_ET_MMP_FSCK_ON; 304 goto mmp_error; 305 } 306 307 if (seq > EXT4_MMP_SEQ_FSCK) { 308 retval = EXT2_ET_MMP_UNKNOWN_SEQ; 309 goto mmp_error; 310 } 311 312 /* 313 * If check_interval in MMP block is larger, use that instead of 314 * check_interval from the superblock. 315 */ 316 if (mmp_s->mmp_check_interval > mmp_check_interval) 317 mmp_check_interval = mmp_s->mmp_check_interval; 318 319 sleep(2 * mmp_check_interval + 1); 320 321 retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); 322 if (retval) 323 goto mmp_error; 324 325 if (seq != mmp_s->mmp_seq) { 326 retval = EXT2_ET_MMP_FAILED; 327 goto mmp_error; 328 } 329 330 clean_seq: 331 if (!(fs->flags & EXT2_FLAG_RW)) 332 goto mmp_error; 333 334 mmp_s->mmp_seq = seq = ext2fs_mmp_new_seq(); 335 #if _BSD_SOURCE || _XOPEN_SOURCE >= 500 336 gethostname(mmp_s->mmp_nodename, sizeof(mmp_s->mmp_nodename)); 337 #else 338 strcpy(mmp_s->mmp_nodename, "unknown host"); 339 #endif 340 strncpy(mmp_s->mmp_bdevname, fs->device_name, 341 sizeof(mmp_s->mmp_bdevname)); 342 343 retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf); 344 if (retval) 345 goto mmp_error; 346 347 sleep(2 * mmp_check_interval + 1); 348 349 retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); 350 if (retval) 351 goto mmp_error; 352 353 if (seq != mmp_s->mmp_seq) { 354 retval = EXT2_ET_MMP_FAILED; 355 goto mmp_error; 356 } 357 358 mmp_s->mmp_seq = EXT4_MMP_SEQ_FSCK; 359 retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf); 360 if (retval) 361 goto mmp_error; 362 363 return 0; 364 365 mmp_error: 366 return retval; 367 #else 368 return EXT2_ET_OP_NOT_SUPPORTED; 369 #endif 370 } 371 372 /* 373 * Clear the MMP usage in the filesystem. If this function returns an 374 * error EXT2_ET_MMP_CHANGE_ABORT it means the filesystem was modified 375 * by some other process while in use, and changes should be dropped, or 376 * risk filesystem corruption. 377 */ 378 errcode_t ext2fs_mmp_stop(ext2_filsys fs) 379 { 380 #ifdef CONFIG_MMP 381 struct mmp_struct *mmp, *mmp_cmp; 382 errcode_t retval = 0; 383 384 if (!ext2fs_has_feature_mmp(fs->super) || 385 !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP)) 386 goto mmp_error; 387 388 retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); 389 if (retval) 390 goto mmp_error; 391 392 /* Check if the MMP block is not changed. */ 393 mmp = fs->mmp_buf; 394 mmp_cmp = fs->mmp_cmp; 395 if (memcmp(mmp, mmp_cmp, sizeof(*mmp_cmp))) { 396 retval = EXT2_ET_MMP_CHANGE_ABORT; 397 goto mmp_error; 398 } 399 400 mmp_cmp->mmp_seq = EXT4_MMP_SEQ_CLEAN; 401 retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_cmp); 402 403 mmp_error: 404 if (fs->mmp_fd > 0) { 405 close(fs->mmp_fd); 406 fs->mmp_fd = -1; 407 } 408 409 return retval; 410 #else 411 if (!ext2fs_has_feature_mmp(fs->super) || 412 !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP)) 413 return 0; 414 415 return EXT2_ET_OP_NOT_SUPPORTED; 416 #endif 417 } 418 419 #define EXT2_MIN_MMP_UPDATE_INTERVAL 60 420 421 /* 422 * Update the on-disk mmp buffer, after checking that it hasn't been changed. 423 */ 424 errcode_t ext2fs_mmp_update2(ext2_filsys fs, int immediately) 425 { 426 #ifdef CONFIG_MMP 427 struct mmp_struct *mmp, *mmp_cmp; 428 struct timeval tv; 429 errcode_t retval = 0; 430 431 if (!ext2fs_has_feature_mmp(fs->super) || 432 !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP)) 433 return 0; 434 435 gettimeofday(&tv, 0); 436 if (!immediately && 437 tv.tv_sec - fs->mmp_last_written < EXT2_MIN_MMP_UPDATE_INTERVAL) 438 return 0; 439 440 retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, NULL); 441 if (retval) 442 goto mmp_error; 443 444 mmp = fs->mmp_buf; 445 mmp_cmp = fs->mmp_cmp; 446 447 if (memcmp(mmp, mmp_cmp, sizeof(*mmp_cmp))) 448 return EXT2_ET_MMP_CHANGE_ABORT; 449 450 mmp->mmp_time = tv.tv_sec; 451 mmp->mmp_seq = EXT4_MMP_SEQ_FSCK; 452 retval = ext2fs_mmp_write(fs, fs->super->s_mmp_block, fs->mmp_buf); 453 454 mmp_error: 455 return retval; 456 #else 457 if (!ext2fs_has_feature_mmp(fs->super) || 458 !(fs->flags & EXT2_FLAG_RW) || (fs->flags & EXT2_FLAG_SKIP_MMP)) 459 return 0; 460 461 return EXT2_ET_OP_NOT_SUPPORTED; 462 #endif 463 } 464 #pragma GCC diagnostic pop 465
