1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * io.c 4 * 5 * Buffer cache handling 6 * 7 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 8 */ 9 10 #include <linux/fs.h> 11 #include <linux/types.h> 12 #include <linux/highmem.h> 13 #include <linux/bio.h> 14 15 #include <cluster/masklog.h> 16 17 #include "ocfs2.h" 18 19 #include "alloc.h" 20 #include "inode.h" 21 #include "journal.h" 22 #include "uptodate.h" 23 #include "buffer_head_io.h" 24 #include "ocfs2_trace.h" 25 26 /* 27 * Bits on bh->b_state used by ocfs2. 28 * 29 * These MUST be after the JBD2 bits. Hence, we use BH_JBDPrivateStart. 30 */ 31 enum ocfs2_state_bits { 32 BH_NeedsValidate = BH_JBDPrivateStart, 33 }; 34 35 /* Expand the magic b_state functions */ 36 BUFFER_FNS(NeedsValidate, needs_validate); 37 38 int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh, 39 struct ocfs2_caching_info *ci) 40 { 41 int ret = 0; 42 43 trace_ocfs2_write_block((unsigned long long)bh->b_blocknr, ci); 44 45 BUG_ON(bh->b_blocknr < OCFS2_SUPER_BLOCK_BLKNO); 46 BUG_ON(buffer_jbd(bh)); 47 48 /* No need to check for a soft readonly file system here. non 49 * journalled writes are only ever done on system files which 50 * can get modified during recovery even if read-only. */ 51 if (ocfs2_is_hard_readonly(osb)) { 52 ret = -EROFS; 53 mlog_errno(ret); 54 goto out; 55 } 56 57 ocfs2_metadata_cache_io_lock(ci); 58 59 lock_buffer(bh); 60 set_buffer_uptodate(bh); 61 62 /* remove from dirty list before I/O. */ 63 clear_buffer_dirty(bh); 64 65 get_bh(bh); /* for end_buffer_write_sync() */ 66 bh->b_end_io = end_buffer_write_sync; 67 submit_bh(REQ_OP_WRITE, 0, bh); 68 69 wait_on_buffer(bh); 70 71 if (buffer_uptodate(bh)) { 72 ocfs2_set_buffer_uptodate(ci, bh); 73 } else { 74 /* We don't need to remove the clustered uptodate 75 * information for this bh as it's not marked locally 76 * uptodate. */ 77 ret = -EIO; 78 mlog_errno(ret); 79 } 80 81 ocfs2_metadata_cache_io_unlock(ci); 82 out: 83 return ret; 84 } 85 86 /* Caller must provide a bhs[] with all NULL or non-NULL entries, so it 87 * will be easier to handle read failure. 88 */ 89 int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block, 90 unsigned int nr, struct buffer_head *bhs[]) 91 { 92 int status = 0; 93 unsigned int i; 94 struct buffer_head *bh; 95 int new_bh = 0; 96 97 trace_ocfs2_read_blocks_sync((unsigned long long)block, nr); 98 99 if (!nr) 100 goto bail; 101 102 /* Don't put buffer head and re-assign it to NULL if it is allocated 103 * outside since the caller can't be aware of this alternation! 104 */ 105 new_bh = (bhs[0] == NULL); 106 107 for (i = 0 ; i < nr ; i++) { 108 if (bhs[i] == NULL) { 109 bhs[i] = sb_getblk(osb->sb, block++); 110 if (bhs[i] == NULL) { 111 status = -ENOMEM; 112 mlog_errno(status); 113 break; 114 } 115 } 116 bh = bhs[i]; 117 118 if (buffer_jbd(bh)) { 119 trace_ocfs2_read_blocks_sync_jbd( 120 (unsigned long long)bh->b_blocknr); 121 continue; 122 } 123 124 if (buffer_dirty(bh)) { 125 /* This should probably be a BUG, or 126 * at least return an error. */ 127 mlog(ML_ERROR, 128 "trying to sync read a dirty " 129 "buffer! (blocknr = %llu), skipping\n", 130 (unsigned long long)bh->b_blocknr); 131 continue; 132 } 133 134 lock_buffer(bh); 135 if (buffer_jbd(bh)) { 136 #ifdef CATCH_BH_JBD_RACES 137 mlog(ML_ERROR, 138 "block %llu had the JBD bit set " 139 "while I was in lock_buffer!", 140 (unsigned long long)bh->b_blocknr); 141 BUG(); 142 #else 143 unlock_buffer(bh); 144 continue; 145 #endif 146 } 147 148 get_bh(bh); /* for end_buffer_read_sync() */ 149 bh->b_end_io = end_buffer_read_sync; 150 submit_bh(REQ_OP_READ, 0, bh); 151 } 152 153 read_failure: 154 for (i = nr; i > 0; i--) { 155 bh = bhs[i - 1]; 156 157 if (unlikely(status)) { 158 if (new_bh && bh) { 159 /* If middle bh fails, let previous bh 160 * finish its read and then put it to 161 * aovoid bh leak 162 */ 163 if (!buffer_jbd(bh)) 164 wait_on_buffer(bh); 165 put_bh(bh); 166 bhs[i - 1] = NULL; 167 } else if (bh && buffer_uptodate(bh)) { 168 clear_buffer_uptodate(bh); 169 } 170 continue; 171 } 172 173 /* No need to wait on the buffer if it's managed by JBD. */ 174 if (!buffer_jbd(bh)) 175 wait_on_buffer(bh); 176 177 if (!buffer_uptodate(bh)) { 178 /* Status won't be cleared from here on out, 179 * so we can safely record this and loop back 180 * to cleanup the other buffers. */ 181 status = -EIO; 182 goto read_failure; 183 } 184 } 185 186 bail: 187 return status; 188 } 189 190 /* Caller must provide a bhs[] with all NULL or non-NULL entries, so it 191 * will be easier to handle read failure. 192 */ 193 int ocfs2_read_blocks(struct ocfs2_caching_info *ci, u64 block, int nr, 194 struct buffer_head *bhs[], int flags, 195 int (*validate)(struct super_block *sb, 196 struct buffer_head *bh)) 197 { 198 int status = 0; 199 int i, ignore_cache = 0; 200 struct buffer_head *bh; 201 struct super_block *sb = ocfs2_metadata_cache_get_super(ci); 202 int new_bh = 0; 203 204 trace_ocfs2_read_blocks_begin(ci, (unsigned long long)block, nr, flags); 205 206 BUG_ON(!ci); 207 BUG_ON((flags & OCFS2_BH_READAHEAD) && 208 (flags & OCFS2_BH_IGNORE_CACHE)); 209 210 if (bhs == NULL) { 211 status = -EINVAL; 212 mlog_errno(status); 213 goto bail; 214 } 215 216 if (nr < 0) { 217 mlog(ML_ERROR, "asked to read %d blocks!\n", nr); 218 status = -EINVAL; 219 mlog_errno(status); 220 goto bail; 221 } 222 223 if (nr == 0) { 224 status = 0; 225 goto bail; 226 } 227 228 /* Don't put buffer head and re-assign it to NULL if it is allocated 229 * outside since the caller can't be aware of this alternation! 230 */ 231 new_bh = (bhs[0] == NULL); 232 233 ocfs2_metadata_cache_io_lock(ci); 234 for (i = 0 ; i < nr ; i++) { 235 if (bhs[i] == NULL) { 236 bhs[i] = sb_getblk(sb, block++); 237 if (bhs[i] == NULL) { 238 ocfs2_metadata_cache_io_unlock(ci); 239 status = -ENOMEM; 240 mlog_errno(status); 241 /* Don't forget to put previous bh! */ 242 break; 243 } 244 } 245 bh = bhs[i]; 246 ignore_cache = (flags & OCFS2_BH_IGNORE_CACHE); 247 248 /* There are three read-ahead cases here which we need to 249 * be concerned with. All three assume a buffer has 250 * previously been submitted with OCFS2_BH_READAHEAD 251 * and it hasn't yet completed I/O. 252 * 253 * 1) The current request is sync to disk. This rarely 254 * happens these days, and never when performance 255 * matters - the code can just wait on the buffer 256 * lock and re-submit. 257 * 258 * 2) The current request is cached, but not 259 * readahead. ocfs2_buffer_uptodate() will return 260 * false anyway, so we'll wind up waiting on the 261 * buffer lock to do I/O. We re-check the request 262 * with after getting the lock to avoid a re-submit. 263 * 264 * 3) The current request is readahead (and so must 265 * also be a caching one). We short circuit if the 266 * buffer is locked (under I/O) and if it's in the 267 * uptodate cache. The re-check from #2 catches the 268 * case that the previous read-ahead completes just 269 * before our is-it-in-flight check. 270 */ 271 272 if (!ignore_cache && !ocfs2_buffer_uptodate(ci, bh)) { 273 trace_ocfs2_read_blocks_from_disk( 274 (unsigned long long)bh->b_blocknr, 275 (unsigned long long)ocfs2_metadata_cache_owner(ci)); 276 /* We're using ignore_cache here to say 277 * "go to disk" */ 278 ignore_cache = 1; 279 } 280 281 trace_ocfs2_read_blocks_bh((unsigned long long)bh->b_blocknr, 282 ignore_cache, buffer_jbd(bh), buffer_dirty(bh)); 283 284 if (buffer_jbd(bh)) { 285 continue; 286 } 287 288 if (ignore_cache) { 289 if (buffer_dirty(bh)) { 290 /* This should probably be a BUG, or 291 * at least return an error. */ 292 continue; 293 } 294 295 /* A read-ahead request was made - if the 296 * buffer is already under read-ahead from a 297 * previously submitted request than we are 298 * done here. */ 299 if ((flags & OCFS2_BH_READAHEAD) 300 && ocfs2_buffer_read_ahead(ci, bh)) 301 continue; 302 303 lock_buffer(bh); 304 if (buffer_jbd(bh)) { 305 #ifdef CATCH_BH_JBD_RACES 306 mlog(ML_ERROR, "block %llu had the JBD bit set " 307 "while I was in lock_buffer!", 308 (unsigned long long)bh->b_blocknr); 309 BUG(); 310 #else 311 unlock_buffer(bh); 312 continue; 313 #endif 314 } 315 316 /* Re-check ocfs2_buffer_uptodate() as a 317 * previously read-ahead buffer may have 318 * completed I/O while we were waiting for the 319 * buffer lock. */ 320 if (!(flags & OCFS2_BH_IGNORE_CACHE) 321 && !(flags & OCFS2_BH_READAHEAD) 322 && ocfs2_buffer_uptodate(ci, bh)) { 323 unlock_buffer(bh); 324 continue; 325 } 326 327 get_bh(bh); /* for end_buffer_read_sync() */ 328 if (validate) 329 set_buffer_needs_validate(bh); 330 bh->b_end_io = end_buffer_read_sync; 331 submit_bh(REQ_OP_READ, 0, bh); 332 continue; 333 } 334 } 335 336 read_failure: 337 for (i = (nr - 1); i >= 0; i--) { 338 bh = bhs[i]; 339 340 if (!(flags & OCFS2_BH_READAHEAD)) { 341 if (unlikely(status)) { 342 /* Clear the buffers on error including those 343 * ever succeeded in reading 344 */ 345 if (new_bh && bh) { 346 /* If middle bh fails, let previous bh 347 * finish its read and then put it to 348 * aovoid bh leak 349 */ 350 if (!buffer_jbd(bh)) 351 wait_on_buffer(bh); 352 put_bh(bh); 353 bhs[i] = NULL; 354 } else if (bh && buffer_uptodate(bh)) { 355 clear_buffer_uptodate(bh); 356 } 357 continue; 358 } 359 /* We know this can't have changed as we hold the 360 * owner sem. Avoid doing any work on the bh if the 361 * journal has it. */ 362 if (!buffer_jbd(bh)) 363 wait_on_buffer(bh); 364 365 if (!buffer_uptodate(bh)) { 366 /* Status won't be cleared from here on out, 367 * so we can safely record this and loop back 368 * to cleanup the other buffers. Don't need to 369 * remove the clustered uptodate information 370 * for this bh as it's not marked locally 371 * uptodate. */ 372 status = -EIO; 373 clear_buffer_needs_validate(bh); 374 goto read_failure; 375 } 376 377 if (buffer_needs_validate(bh)) { 378 /* We never set NeedsValidate if the 379 * buffer was held by the journal, so 380 * that better not have changed */ 381 BUG_ON(buffer_jbd(bh)); 382 clear_buffer_needs_validate(bh); 383 status = validate(sb, bh); 384 if (status) 385 goto read_failure; 386 } 387 } 388 389 /* Always set the buffer in the cache, even if it was 390 * a forced read, or read-ahead which hasn't yet 391 * completed. */ 392 ocfs2_set_buffer_uptodate(ci, bh); 393 } 394 ocfs2_metadata_cache_io_unlock(ci); 395 396 trace_ocfs2_read_blocks_end((unsigned long long)block, nr, 397 flags, ignore_cache); 398 399 bail: 400 401 return status; 402 } 403 404 /* Check whether the blkno is the super block or one of the backups. */ 405 static void ocfs2_check_super_or_backup(struct super_block *sb, 406 sector_t blkno) 407 { 408 int i; 409 u64 backup_blkno; 410 411 if (blkno == OCFS2_SUPER_BLOCK_BLKNO) 412 return; 413 414 for (i = 0; i < OCFS2_MAX_BACKUP_SUPERBLOCKS; i++) { 415 backup_blkno = ocfs2_backup_super_blkno(sb, i); 416 if (backup_blkno == blkno) 417 return; 418 } 419 420 BUG(); 421 } 422 423 /* 424 * Write super block and backups doesn't need to collaborate with journal, 425 * so we don't need to lock ip_io_mutex and ci doesn't need to bea passed 426 * into this function. 427 */ 428 int ocfs2_write_super_or_backup(struct ocfs2_super *osb, 429 struct buffer_head *bh) 430 { 431 int ret = 0; 432 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 433 434 BUG_ON(buffer_jbd(bh)); 435 ocfs2_check_super_or_backup(osb->sb, bh->b_blocknr); 436 437 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) { 438 ret = -EROFS; 439 mlog_errno(ret); 440 goto out; 441 } 442 443 lock_buffer(bh); 444 set_buffer_uptodate(bh); 445 446 /* remove from dirty list before I/O. */ 447 clear_buffer_dirty(bh); 448 449 get_bh(bh); /* for end_buffer_write_sync() */ 450 bh->b_end_io = end_buffer_write_sync; 451 ocfs2_compute_meta_ecc(osb->sb, bh->b_data, &di->i_check); 452 submit_bh(REQ_OP_WRITE, 0, bh); 453 454 wait_on_buffer(bh); 455 456 if (!buffer_uptodate(bh)) { 457 ret = -EIO; 458 mlog_errno(ret); 459 } 460 461 out: 462 return ret; 463 } 464