SmartisanOS_Kernel_Source/fs/buffer.c at master · SmartisanTech/SmartisanOS_Kernel_Source · GitHub

History

3335 lines (2978 loc) · 86.2 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

* linux/fs/buffer.c

* Start bdflush() with kernel_thread not syscall - Paul Gortmaker, 12/95

* Removed a lot of unnecessary code and simplified things now that

* the buffer cache isn't our primary cache - Andrew Tridgell 12/96

* Speed up hash, lru, and free list operations. Use gfp() for allocating

* hash table, use SLAB cache for buffer heads. SMP threading. -DaveM

* Added 32k buffer block sizes - these are required older ARM systems. - RMK

* async buffer flushing, 1999 Andrea Arcangeli <andrea@suse.de>

#include <linux/kernel.h>

#include <linux/syscalls.h>

#include <linux/fs.h>

#include <linux/mm.h>

#include <linux/percpu.h>

#include <linux/slab.h>

#include <linux/capability.h>

#include <linux/blkdev.h>

#include <linux/file.h>

#include <linux/quotaops.h>

#include <linux/highmem.h>

#include <linux/export.h>

#include <linux/writeback.h>

#include <linux/hash.h>

#include <linux/suspend.h>

#include <linux/buffer_head.h>

#include <linux/task_io_accounting_ops.h>

#include <linux/bio.h>

#include <linux/notifier.h>

#include <linux/cpu.h>

#include <linux/bitops.h>

#include <linux/mpage.h>

#include <linux/bit_spinlock.h>

static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);

#define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)

inline void

init_buffer(struct buffer_head *bh, bh_end_io_t *handler, void *private)

{

bh->b_end_io = handler;

bh->b_private = private;

}

EXPORT_SYMBOL(init_buffer);

static int sleep_on_buffer(void *word)

{

io_schedule();

return 0;

}

void __lock_buffer(struct buffer_head *bh)

{

wait_on_bit_lock(&bh->b_state, BH_Lock, sleep_on_buffer,

TASK_UNINTERRUPTIBLE);

}

EXPORT_SYMBOL(__lock_buffer);

void unlock_buffer(struct buffer_head *bh)

{

clear_bit_unlock(BH_Lock, &bh->b_state);

smp_mb__after_clear_bit();

wake_up_bit(&bh->b_state, BH_Lock);

}

EXPORT_SYMBOL(unlock_buffer);

* Block until a buffer comes unlocked. This doesn't stop it

* from becoming locked again - you have to lock it yourself

* if you want to preserve its state.

void __wait_on_buffer(struct buffer_head * bh)

{

wait_on_bit(&bh->b_state, BH_Lock, sleep_on_buffer, TASK_UNINTERRUPTIBLE);

}

EXPORT_SYMBOL(__wait_on_buffer);

static void

__clear_page_buffers(struct page *page)

{

ClearPagePrivate(page);

set_page_private(page, 0);

page_cache_release(page);

}

static int quiet_error(struct buffer_head *bh)

{

if (!test_bit(BH_Quiet, &bh->b_state) && printk_ratelimit())

return 0;

return 1;

}

static void buffer_io_error(struct buffer_head *bh)

{

char b[BDEVNAME_SIZE];

printk(KERN_ERR "Buffer I/O error on device %s, logical block %Lu\n",

bdevname(bh->b_bdev, b),

(unsigned long long)bh->b_blocknr);

}

* End-of-IO handler helper function which does not touch the bh after

* unlocking it.

* Note: unlock_buffer() sort-of does touch the bh after unlocking it, but

* a race there is benign: unlock_buffer() only use the bh's address for

* hashing after unlocking the buffer, so it doesn't actually touch the bh

* itself.

static void __end_buffer_read_notouch(struct buffer_head *bh, int uptodate)

{

if (uptodate) {

set_buffer_uptodate(bh);

} else {

/* This happens, due to failed READA attempts. */

clear_buffer_uptodate(bh);

}

unlock_buffer(bh);

}

* Default synchronous end-of-IO handler.. Just mark it up-to-date and

* unlock the buffer. This is what ll_rw_block uses too.

void end_buffer_read_sync(struct buffer_head *bh, int uptodate)

{

__end_buffer_read_notouch(bh, uptodate);

put_bh(bh);

}

EXPORT_SYMBOL(end_buffer_read_sync);

void end_buffer_write_sync(struct buffer_head *bh, int uptodate)

{

char b[BDEVNAME_SIZE];

if (uptodate) {

set_buffer_uptodate(bh);

} else {

if (!quiet_error(bh)) {

buffer_io_error(bh);

printk(KERN_WARNING "lost page write due to "

"I/O error on %s\n",

bdevname(bh->b_bdev, b));

}

set_buffer_write_io_error(bh);

clear_buffer_uptodate(bh);

}

unlock_buffer(bh);

put_bh(bh);

}

EXPORT_SYMBOL(end_buffer_write_sync);

* Various filesystems appear to want __find_get_block to be non-blocking.

* But it's the page lock which protects the buffers. To get around this,

* we get exclusion from try_to_free_buffers with the blockdev mapping's

* private_lock.

* Hack idea: for the blockdev mapping, i_bufferlist_lock contention

* may be quite high. This code could TryLock the page, and if that

* succeeds, there is no need to take private_lock. (But if

* private_lock is contended then so is mapping->tree_lock).

static struct buffer_head *

__find_get_block_slow(struct block_device *bdev, sector_t block)

{

struct inode *bd_inode = bdev->bd_inode;

struct address_space *bd_mapping = bd_inode->i_mapping;

struct buffer_head *ret = NULL;

pgoff_t index;

struct buffer_head *bh;

struct buffer_head *head;

struct page *page;

int all_mapped = 1;

index = block >> (PAGE_CACHE_SHIFT - bd_inode->i_blkbits);

page = find_get_page(bd_mapping, index);

if (!page)

goto out;

spin_lock(&bd_mapping->private_lock);

if (!page_has_buffers(page))

goto out_unlock;

head = page_buffers(page);

bh = head;

do {

if (!buffer_mapped(bh))

all_mapped = 0;

else if (bh->b_blocknr == block) {

ret = bh;

get_bh(bh);

goto out_unlock;

}

bh = bh->b_this_page;

} while (bh != head);

/* we might be here because some of the buffers on this page are

* not mapped. This is due to various races between

* file io on the block device and getblk. It gets dealt with

* elsewhere, don't buffer_error if we had some unmapped buffers

if (all_mapped) {

char b[BDEVNAME_SIZE];

printk("__find_get_block_slow() failed. "

"block=%llu, b_blocknr=%llu\n",

(unsigned long long)block,

(unsigned long long)bh->b_blocknr);

printk("b_state=0x%08lx, b_size=%zu\n",

bh->b_state, bh->b_size);

printk("device %s blocksize: %d\n", bdevname(bdev, b),

1 << bd_inode->i_blkbits);

}

out_unlock:

spin_unlock(&bd_mapping->private_lock);

page_cache_release(page);

out:

return ret;

}

* Kick the writeback threads then try to free up some ZONE_NORMAL memory.

static void free_more_memory(void)

{

struct zone *zone;

int nid;

wakeup_flusher_threads(1024, WB_REASON_FREE_MORE_MEM);

yield();

for_each_online_node(nid) {

(void)first_zones_zonelist(node_zonelist(nid, GFP_NOFS),

gfp_zone(GFP_NOFS), NULL,

&zone);

if (zone)

try_to_free_pages(node_zonelist(nid, GFP_NOFS), 0,

GFP_NOFS, NULL);

}

* I/O completion handler for block_read_full_page() - pages

* which come unlocked at the end of I/O.

static void end_buffer_async_read(struct buffer_head *bh, int uptodate)

{

unsigned long flags;

struct buffer_head *first;

struct buffer_head *tmp;

struct page *page;

int page_uptodate = 1;

BUG_ON(!buffer_async_read(bh));

page = bh->b_page;

if (uptodate) {

set_buffer_uptodate(bh);

} else {

clear_buffer_uptodate(bh);

if (!quiet_error(bh))

buffer_io_error(bh);

SetPageError(page);

}

* Be _very_ careful from here on. Bad things can happen if

* two buffer heads end IO at almost the same time and both

* decide that the page is now completely done.

first = page_buffers(page);

local_irq_save(flags);

bit_spin_lock(BH_Uptodate_Lock, &first->b_state);

clear_buffer_async_read(bh);

unlock_buffer(bh);

tmp = bh;

do {

if (!buffer_uptodate(tmp))

page_uptodate = 0;

if (buffer_async_read(tmp)) {

BUG_ON(!buffer_locked(tmp));

goto still_busy;

}

tmp = tmp->b_this_page;

} while (tmp != bh);

bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);

local_irq_restore(flags);

* If none of the buffers had errors and they are all

* uptodate then we can set the page uptodate.

if (page_uptodate && !PageError(page))

SetPageUptodate(page);

unlock_page(page);

return;

still_busy:

bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);

local_irq_restore(flags);

return;

}

* Completion handler for block_write_full_page() - pages which are unlocked

* during I/O, and which have PageWriteback cleared upon I/O completion.

void end_buffer_async_write(struct buffer_head *bh, int uptodate)

{

char b[BDEVNAME_SIZE];

unsigned long flags;

struct buffer_head *first;

struct buffer_head *tmp;

struct page *page;

BUG_ON(!buffer_async_write(bh));

page = bh->b_page;

if (uptodate) {

set_buffer_uptodate(bh);

} else {

if (!quiet_error(bh)) {

buffer_io_error(bh);

printk(KERN_WARNING "lost page write due to "

"I/O error on %s\n",

bdevname(bh->b_bdev, b));

}

set_bit(AS_EIO, &page->mapping->flags);

set_buffer_write_io_error(bh);

clear_buffer_uptodate(bh);

SetPageError(page);

}

first = page_buffers(page);

local_irq_save(flags);

bit_spin_lock(BH_Uptodate_Lock, &first->b_state);

clear_buffer_async_write(bh);

unlock_buffer(bh);

tmp = bh->b_this_page;

while (tmp != bh) {

if (buffer_async_write(tmp)) {

BUG_ON(!buffer_locked(tmp));

goto still_busy;

}

tmp = tmp->b_this_page;

}

bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);

local_irq_restore(flags);

end_page_writeback(page);

return;

still_busy:

bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);

local_irq_restore(flags);

return;

}

EXPORT_SYMBOL(end_buffer_async_write);

* If a page's buffers are under async readin (end_buffer_async_read

* completion) then there is a possibility that another thread of

* control could lock one of the buffers after it has completed

* but while some of the other buffers have not completed. This

* locked buffer would confuse end_buffer_async_read() into not unlocking

* the page. So the absence of BH_Async_Read tells end_buffer_async_read()

* that this buffer is not under async I/O.

* The page comes unlocked when it has no locked buffer_async buffers

* left.

* PageLocked prevents anyone starting new async I/O reads any of

* the buffers.

* PageWriteback is used to prevent simultaneous writeout of the same

* page.

* PageLocked prevents anyone from starting writeback of a page which is

* under read I/O (PageWriteback is only ever set against a locked page).

static void mark_buffer_async_read(struct buffer_head *bh)

{

bh->b_end_io = end_buffer_async_read;

set_buffer_async_read(bh);

}

static void mark_buffer_async_write_endio(struct buffer_head *bh,

bh_end_io_t *handler)

{

bh->b_end_io = handler;

set_buffer_async_write(bh);

}

void mark_buffer_async_write(struct buffer_head *bh)

{

mark_buffer_async_write_endio(bh, end_buffer_async_write);

}

EXPORT_SYMBOL(mark_buffer_async_write);

* fs/buffer.c contains helper functions for buffer-backed address space's

* fsync functions. A common requirement for buffer-based filesystems is

* that certain data from the backing blockdev needs to be written out for

* a successful fsync(). For example, ext2 indirect blocks need to be

* written back and waited upon before fsync() returns.

* The functions mark_buffer_inode_dirty(), fsync_inode_buffers(),

* inode_has_buffers() and invalidate_inode_buffers() are provided for the

* management of a list of dependent buffers at ->i_mapping->private_list.

* Locking is a little subtle: try_to_free_buffers() will remove buffers

* from their controlling inode's queue when they are being freed. But

* try_to_free_buffers() will be operating against the *blockdev* mapping

* at the time, not against the S_ISREG file which depends on those buffers.

* So the locking for private_list is via the private_lock in the address_space

* which backs the buffers. Which is different from the address_space

* against which the buffers are listed. So for a particular address_space,

* mapping->private_lock does *not* protect mapping->private_list! In fact,

* mapping->private_list will always be protected by the backing blockdev's

* ->private_lock.

* Which introduces a requirement: all buffers on an address_space's

* ->private_list must be from the same address_space: the blockdev's.

* address_spaces which do not place buffers at ->private_list via these

* utility functions are free to use private_lock and private_list for

* whatever they want. The only requirement is that list_empty(private_list)

* be true at clear_inode() time.

* FIXME: clear_inode should not call invalidate_inode_buffers(). The

* filesystems should do that. invalidate_inode_buffers() should just go

* BUG_ON(!list_empty).

* FIXME: mark_buffer_dirty_inode() is a data-plane operation. It should

* take an address_space, not an inode. And it should be called

* mark_buffer_dirty_fsync() to clearly define why those buffers are being

* queued up.

* FIXME: mark_buffer_dirty_inode() doesn't need to add the buffer to the

* list if it is already on a list. Because if the buffer is on a list,

* it *must* already be on the right one. If not, the filesystem is being

* silly. This will save a ton of locking. But first we have to ensure

* that buffers are taken *off* the old inode's list when they are freed

* (presumably in truncate). That requires careful auditing of all

* filesystems (do it inside bforget()). It could also be done by bringing

* b_inode back.

* The buffer's backing address_space's private_lock must be held

static void __remove_assoc_queue(struct buffer_head *bh)

{

list_del_init(&bh->b_assoc_buffers);

WARN_ON(!bh->b_assoc_map);

if (buffer_write_io_error(bh))

set_bit(AS_EIO, &bh->b_assoc_map->flags);

bh->b_assoc_map = NULL;

}

int inode_has_buffers(struct inode *inode)

{

return !list_empty(&inode->i_data.private_list);

}

* osync is designed to support O_SYNC io. It waits synchronously for

* all already-submitted IO to complete, but does not queue any new

* writes to the disk.

* To do O_SYNC writes, just queue the buffer writes with ll_rw_block as

* you dirty the buffers, and then use osync_inode_buffers to wait for

* completion. Any other dirty buffers which are not yet queued for

* write will not be flushed to disk by the osync.

static int osync_buffers_list(spinlock_t *lock, struct list_head *list)

{

struct buffer_head *bh;

struct list_head *p;

int err = 0;

spin_lock(lock);

repeat:

list_for_each_prev(p, list) {

bh = BH_ENTRY(p);

if (buffer_locked(bh)) {

get_bh(bh);

spin_unlock(lock);

wait_on_buffer(bh);

if (!buffer_uptodate(bh))

err = -EIO;

brelse(bh);

spin_lock(lock);

goto repeat;

}

spin_unlock(lock);

return err;

}

static void do_thaw_one(struct super_block *sb, void *unused)

{

char b[BDEVNAME_SIZE];

while (sb->s_bdev && !thaw_bdev(sb->s_bdev, sb))

printk(KERN_WARNING "Emergency Thaw on %s\n",

bdevname(sb->s_bdev, b));

}

static void do_thaw_all(struct work_struct *work)

{

iterate_supers(do_thaw_one, NULL);

kfree(work);

printk(KERN_WARNING "Emergency Thaw complete\n");

}

/**

* emergency_thaw_all -- forcibly thaw every frozen filesystem

* Used for emergency unfreeze of all filesystems via SysRq

void emergency_thaw_all(void)

{

struct work_struct *work;

work = kmalloc(sizeof(*work), GFP_ATOMIC);

if (work) {

INIT_WORK(work, do_thaw_all);

schedule_work(work);

}

/**

* sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers

* @mapping: the mapping which wants those buffers written

* Starts I/O against the buffers at mapping->private_list, and waits upon

* that I/O.

* Basically, this is a convenience function for fsync().

* @mapping is a file or directory which needs those buffers to be written for

* a successful fsync().

int sync_mapping_buffers(struct address_space *mapping)

{

struct address_space *buffer_mapping = mapping->assoc_mapping;

if (buffer_mapping == NULL || list_empty(&mapping->private_list))

return 0;

return fsync_buffers_list(&buffer_mapping->private_lock,

&mapping->private_list);

}

EXPORT_SYMBOL(sync_mapping_buffers);

* Called when we've recently written block `bblock', and it is known that

* `bblock' was for a buffer_boundary() buffer. This means that the block at

* `bblock + 1' is probably a dirty indirect block. Hunt it down and, if it's

* dirty, schedule it for IO. So that indirects merge nicely with their data.

void write_boundary_block(struct block_device *bdev,

sector_t bblock, unsigned blocksize)

{

struct buffer_head *bh = __find_get_block(bdev, bblock + 1, blocksize);

if (bh) {

if (buffer_dirty(bh))

ll_rw_block(WRITE, 1, &bh);

put_bh(bh);

}

void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)

{

struct address_space *mapping = inode->i_mapping;

struct address_space *buffer_mapping = bh->b_page->mapping;

mark_buffer_dirty(bh);

if (!mapping->assoc_mapping) {

mapping->assoc_mapping = buffer_mapping;

} else {

BUG_ON(mapping->assoc_mapping != buffer_mapping);

}

if (!bh->b_assoc_map) {

spin_lock(&buffer_mapping->private_lock);

list_move_tail(&bh->b_assoc_buffers,

&mapping->private_list);

bh->b_assoc_map = mapping;

spin_unlock(&buffer_mapping->private_lock);

}

EXPORT_SYMBOL(mark_buffer_dirty_inode);

* Mark the page dirty, and set it dirty in the radix tree, and mark the inode

* dirty.

* If warn is true, then emit a warning if the page is not uptodate and has

* not been truncated.

static void __set_page_dirty(struct page *page,

struct address_space *mapping, int warn)

{

spin_lock_irq(&mapping->tree_lock);

if (page->mapping) { /* Race with truncate? */

WARN_ON_ONCE(warn && !PageUptodate(page));

account_page_dirtied(page, mapping);

radix_tree_tag_set(&mapping->page_tree,

page_index(page), PAGECACHE_TAG_DIRTY);

}

spin_unlock_irq(&mapping->tree_lock);

__mark_inode_dirty(mapping->host, I_DIRTY_PAGES);

}

* Add a page to the dirty page list.

* It is a sad fact of life that this function is called from several places

* deeply under spinlocking. It may not sleep.

* If the page has buffers, the uptodate buffers are set dirty, to preserve

* dirty-state coherency between the page and the buffers. It the page does

* not have buffers then when they are later attached they will all be set

* dirty.

* The buffers are dirtied before the page is dirtied. There's a small race

* window in which a writepage caller may see the page cleanness but not the

* buffer dirtiness. That's fine. If this code were to set the page dirty

* before the buffers, a concurrent writepage caller could clear the page dirty

* bit, see a bunch of clean buffers and we'd end up with dirty buffers/clean

* page on the dirty page list.

* We use private_lock to lock against try_to_free_buffers while using the

* page's buffer list. Also use this to protect against clean buffers being

* added to the page after it was set dirty.

* FIXME: may need to call ->reservepage here as well. That's rather up to the

* address_space though.

int __set_page_dirty_buffers(struct page *page)

{

int newly_dirty;

struct address_space *mapping = page_mapping(page);

if (unlikely(!mapping))

return !TestSetPageDirty(page);

spin_lock(&mapping->private_lock);

if (page_has_buffers(page)) {

struct buffer_head *head = page_buffers(page);

struct buffer_head *bh = head;

do {

set_buffer_dirty(bh);

bh = bh->b_this_page;

} while (bh != head);

}

newly_dirty = !TestSetPageDirty(page);

spin_unlock(&mapping->private_lock);

if (newly_dirty)

__set_page_dirty(page, mapping, 1);

return newly_dirty;

}

EXPORT_SYMBOL(__set_page_dirty_buffers);

* Write out and wait upon a list of buffers.

* We have conflicting pressures: we want to make sure that all

* initially dirty buffers get waited on, but that any subsequently

* dirtied buffers don't. After all, we don't want fsync to last

* forever if somebody is actively writing to the file.

* Do this in two main stages: first we copy dirty buffers to a

* temporary inode list, queueing the writes as we go. Then we clean

* up, waiting for those writes to complete.

* During this second stage, any subsequent updates to the file may end

* up refiling the buffer on the original inode's dirty list again, so

* there is a chance we will end up with a buffer queued for write but

* not yet completed on that list. So, as a final cleanup we go through

* the osync code to catch these locked, dirty buffers without requeuing

* any newly dirty buffers for write.

static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)

{

struct buffer_head *bh;

struct list_head tmp;

struct address_space *mapping;

int err = 0, err2;

struct blk_plug plug;

INIT_LIST_HEAD(&tmp);

blk_start_plug(&plug);

spin_lock(lock);

while (!list_empty(list)) {

bh = BH_ENTRY(list->next);

mapping = bh->b_assoc_map;

__remove_assoc_queue(bh);

/* Avoid race with mark_buffer_dirty_inode() which does

* a lockless check and we rely on seeing the dirty bit */

smp_mb();

if (buffer_dirty(bh) || buffer_locked(bh)) {

list_add(&bh->b_assoc_buffers, &tmp);

bh->b_assoc_map = mapping;

if (buffer_dirty(bh)) {

get_bh(bh);

spin_unlock(lock);

* Ensure any pending I/O completes so that

* write_dirty_buffer() actually writes the

* current contents - it is a noop if I/O is

* still in flight on potentially older

* contents.

write_dirty_buffer(bh, WRITE_SYNC);

* Kick off IO for the previous mapping. Note

* that we will not run the very last mapping,

* wait_on_buffer() will do that for us

* through sync_buffer().

brelse(bh);

spin_lock(lock);

}

spin_unlock(lock);

blk_finish_plug(&plug);

spin_lock(lock);

while (!list_empty(&tmp)) {

bh = BH_ENTRY(tmp.prev);

get_bh(bh);

mapping = bh->b_assoc_map;

__remove_assoc_queue(bh);

/* Avoid race with mark_buffer_dirty_inode() which does

* a lockless check and we rely on seeing the dirty bit */

smp_mb();

if (buffer_dirty(bh)) {

list_add(&bh->b_assoc_buffers,

&mapping->private_list);

bh->b_assoc_map = mapping;

}

spin_unlock(lock);

wait_on_buffer(bh);

if (!buffer_uptodate(bh))

err = -EIO;

brelse(bh);

spin_lock(lock);

}

spin_unlock(lock);

err2 = osync_buffers_list(lock, list);

if (err)

return err;

else

return err2;

}

* Invalidate any and all dirty buffers on a given inode. We are

* probably unmounting the fs, but that doesn't mean we have already

* done a sync(). Just drop the buffers from the inode list.

* NOTE: we take the inode's blockdev's mapping's private_lock. Which

* assumes that all the buffers are against the blockdev. Not true

* for reiserfs.

void invalidate_inode_buffers(struct inode *inode)

{

if (inode_has_buffers(inode)) {

struct address_space *mapping = &inode->i_data;

struct list_head *list = &mapping->private_list;

struct address_space *buffer_mapping = mapping->assoc_mapping;

spin_lock(&buffer_mapping->private_lock);

while (!list_empty(list))

__remove_assoc_queue(BH_ENTRY(list->next));

spin_unlock(&buffer_mapping->private_lock);

}

EXPORT_SYMBOL(invalidate_inode_buffers);

* Remove any clean buffers from the inode's buffer list. This is called

* when we're trying to free the inode itself. Those buffers can pin it.

* Returns true if all buffers were removed.

int remove_inode_buffers(struct inode *inode)

{

int ret = 1;

if (inode_has_buffers(inode)) {

struct address_space *mapping = &inode->i_data;

struct list_head *list = &mapping->private_list;

struct address_space *buffer_mapping = mapping->assoc_mapping;

spin_lock(&buffer_mapping->private_lock);

while (!list_empty(list)) {

struct buffer_head *bh = BH_ENTRY(list->next);

if (buffer_dirty(bh)) {

ret = 0;

break;

}

__remove_assoc_queue(bh);

}

spin_unlock(&buffer_mapping->private_lock);

}

return ret;

}

* Create the appropriate buffers when given a page for data area and

* the size of each buffer.. Use the bh->b_this_page linked list to

* follow the buffers created. Return NULL if unable to create more

* buffers.

* The retry flag is used to differentiate async IO (paging, swapping)

* which may not fail from ordinary buffer allocations.

struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,

int retry)

{

struct buffer_head *bh, *head;

long offset;

try_again:

head = NULL;

offset = PAGE_SIZE;

while ((offset -= size) >= 0) {

bh = alloc_buffer_head(GFP_NOFS);

if (!bh)

goto no_grow;

bh->b_bdev = NULL;

bh->b_this_page = head;

bh->b_blocknr = -1;

head = bh;

bh->b_state = 0;

atomic_set(&bh->b_count, 0);

bh->b_size = size;

/* Link the buffer to its page */

set_bh_page(bh, page, offset);

init_buffer(bh, NULL, NULL);

}

return head;

* In case anything failed, we just free everything we got.

no_grow:

if (head) {

do {

bh = head;

head = head->b_this_page;

free_buffer_head(bh);

} while (head);

}

* Return failure for non-async IO requests. Async IO requests

* are not allowed to fail, so we have to wait until buffer heads

* become available. But we don't want tasks sleeping with

* partially complete buffers, so all were released above.

if (!retry)

return NULL;

/* We're _really_ low on memory. Now we just

* wait for old buffer heads to become free due to

* finishing IO. Since this is an async request and

* the reserve list is empty, we're sure there are

* async buffer heads in use.

free_more_memory();

goto try_again;

}

EXPORT_SYMBOL_GPL(alloc_page_buffers);

static inline void

link_dev_buffers(struct page *page, struct buffer_head *head)

{

struct buffer_head *bh, *tail;

bh = head;

do {

tail = bh;

bh = bh->b_this_page;

} while (bh);

tail->b_this_page = head;

attach_page_buffers(page, head);

}

* Initialise the state of a blockdev page's buffers.

static void

init_page_buffers(struct page *page, struct block_device *bdev,

sector_t block, int size)

{

struct buffer_head *head = page_buffers(page);

struct buffer_head *bh = head;

int uptodate = PageUptodate(page);

sector_t end_block = blkdev_max_block(I_BDEV(bdev->bd_inode));

do {

if (!buffer_mapped(bh)) {

init_buffer(bh, NULL, NULL);

bh->b_bdev = bdev;

bh->b_blocknr = block;

if (uptodate)

set_buffer_uptodate(bh);

if (block < end_block)

set_buffer_mapped(bh);

}

block++;

bh = bh->b_this_page;

} while (bh != head);

}

* Create the page-cache page that contains the requested block.

* This is user purely for blockdev mappings.

static struct page *

grow_dev_page(struct block_device *bdev, sector_t block,

pgoff_t index, int size)

{

struct inode *inode = bdev->bd_inode;

struct page *page;

struct buffer_head *bh;

page = find_or_create_page(inode->i_mapping, index,

(mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS)|__GFP_MOVABLE);

if (!page)

return NULL;

BUG_ON(!PageLocked(page));

if (page_has_buffers(page)) {

bh = page_buffers(page);

if (bh->b_size == size) {

init_page_buffers(page, bdev, block, size);

return page;

}

if (!try_to_free_buffers(page))

goto failed;

}

* Allocate some buffers for this page

bh = alloc_page_buffers(page, size, 0);

if (!bh)

goto failed;

* Link the page to the buffers and initialise them. Take the

* lock to be atomic wrt __find_get_block(), which does not

* run under the page lock.

spin_lock(&inode->i_mapping->private_lock);

link_dev_buffers(page, bh);

init_page_buffers(page, bdev, block, size);

spin_unlock(&inode->i_mapping->private_lock);

return page;

failed:

unlock_page(page);

page_cache_release(page);

return NULL;

}

* Create buffers for the specified block device block's page. If

* that page was dirty, the buffers are set dirty also.

static int

grow_buffers(struct block_device *bdev, sector_t block, int size)

View remainder of file in raw view

SmartisanOS_Kernel_Source/fs/buffer.c at master · SmartisanTech/SmartisanOS_Kernel_Source · GitHub

Expand file tree

Breadcrumbs

buffer.c

Latest commit

History

Breadcrumbs

buffer.c

File metadata and controls