1
2
3
4
5
6
7
8
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
15#include <linux/pagemap.h>
16#include <linux/pagevec.h>
17#include <linux/mpage.h>
18#include <linux/fs.h>
19#include <linux/writeback.h>
20#include <linux/swap.h>
21#include <linux/gfs2_ondisk.h>
22#include <linux/backing-dev.h>
23
24#include "gfs2.h"
25#include "incore.h"
26#include "bmap.h"
27#include "glock.h"
28#include "inode.h"
29#include "log.h"
30#include "meta_io.h"
31#include "quota.h"
32#include "trans.h"
33#include "rgrp.h"
34#include "super.h"
35#include "util.h"
36#include "glops.h"
37
38
39void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
40 unsigned int from, unsigned int to)
41{
42 struct buffer_head *head = page_buffers(page);
43 unsigned int bsize = head->b_size;
44 struct buffer_head *bh;
45 unsigned int start, end;
46
47 for (bh = head, start = 0; bh != head || !start;
48 bh = bh->b_this_page, start = end) {
49 end = start + bsize;
50 if (end <= from || start >= to)
51 continue;
52 if (gfs2_is_jdata(ip))
53 set_buffer_uptodate(bh);
54 gfs2_trans_add_bh(ip->i_gl, bh, 0);
55 }
56}
57
58
59
60
61
62
63
64
65
66
67
68static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
69 struct buffer_head *bh_result, int create)
70{
71 int error;
72
73 error = gfs2_block_map(inode, lblock, bh_result, 0);
74 if (error)
75 return error;
76 if (!buffer_mapped(bh_result))
77 return -EIO;
78 return 0;
79}
80
81static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
82 struct buffer_head *bh_result, int create)
83{
84 return gfs2_block_map(inode, lblock, bh_result, 0);
85}
86
87
88
89
90
91
92
93
94
95static int gfs2_writepage_common(struct page *page,
96 struct writeback_control *wbc)
97{
98 struct inode *inode = page->mapping->host;
99 struct gfs2_inode *ip = GFS2_I(inode);
100 struct gfs2_sbd *sdp = GFS2_SB(inode);
101 loff_t i_size = i_size_read(inode);
102 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
103 unsigned offset;
104
105 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl)))
106 goto out;
107 if (current->journal_info)
108 goto redirty;
109
110 offset = i_size & (PAGE_CACHE_SIZE-1);
111 if (page->index > end_index || (page->index == end_index && !offset)) {
112 page->mapping->a_ops->invalidatepage(page, 0);
113 goto out;
114 }
115 return 1;
116redirty:
117 redirty_page_for_writepage(wbc, page);
118out:
119 unlock_page(page);
120 return 0;
121}
122
123
124
125
126
127
128
129
130static int gfs2_writeback_writepage(struct page *page,
131 struct writeback_control *wbc)
132{
133 int ret;
134
135 ret = gfs2_writepage_common(page, wbc);
136 if (ret <= 0)
137 return ret;
138
139 return nobh_writepage(page, gfs2_get_block_noalloc, wbc);
140}
141
142
143
144
145
146
147
148
149static int gfs2_ordered_writepage(struct page *page,
150 struct writeback_control *wbc)
151{
152 struct inode *inode = page->mapping->host;
153 struct gfs2_inode *ip = GFS2_I(inode);
154 int ret;
155
156 ret = gfs2_writepage_common(page, wbc);
157 if (ret <= 0)
158 return ret;
159
160 if (!page_has_buffers(page)) {
161 create_empty_buffers(page, inode->i_sb->s_blocksize,
162 (1 << BH_Dirty)|(1 << BH_Uptodate));
163 }
164 gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1);
165 return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
166}
167
168
169
170
171
172
173
174
175
176
177
178
179static int __gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
180{
181 struct inode *inode = page->mapping->host;
182 struct gfs2_inode *ip = GFS2_I(inode);
183 struct gfs2_sbd *sdp = GFS2_SB(inode);
184
185 if (PageChecked(page)) {
186 ClearPageChecked(page);
187 if (!page_has_buffers(page)) {
188 create_empty_buffers(page, inode->i_sb->s_blocksize,
189 (1 << BH_Dirty)|(1 << BH_Uptodate));
190 }
191 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
192 }
193 return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
194}
195
196
197
198
199
200
201
202
203
204static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
205{
206 struct inode *inode = page->mapping->host;
207 struct gfs2_sbd *sdp = GFS2_SB(inode);
208 int ret;
209 int done_trans = 0;
210
211 if (PageChecked(page)) {
212 if (wbc->sync_mode != WB_SYNC_ALL)
213 goto out_ignore;
214 ret = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
215 if (ret)
216 goto out_ignore;
217 done_trans = 1;
218 }
219 ret = gfs2_writepage_common(page, wbc);
220 if (ret > 0)
221 ret = __gfs2_jdata_writepage(page, wbc);
222 if (done_trans)
223 gfs2_trans_end(sdp);
224 return ret;
225
226out_ignore:
227 redirty_page_for_writepage(wbc, page);
228 unlock_page(page);
229 return 0;
230}
231
232
233
234
235
236
237
238
239
240
241static int gfs2_writeback_writepages(struct address_space *mapping,
242 struct writeback_control *wbc)
243{
244 return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
245}
246
247
248
249
250
251
252
253
254
255
256
257
258static int gfs2_write_jdata_pagevec(struct address_space *mapping,
259 struct writeback_control *wbc,
260 struct pagevec *pvec,
261 int nr_pages, pgoff_t end)
262{
263 struct inode *inode = mapping->host;
264 struct gfs2_sbd *sdp = GFS2_SB(inode);
265 loff_t i_size = i_size_read(inode);
266 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
267 unsigned offset = i_size & (PAGE_CACHE_SIZE-1);
268 unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);
269 int i;
270 int ret;
271
272 ret = gfs2_trans_begin(sdp, nrblocks, nrblocks);
273 if (ret < 0)
274 return ret;
275
276 for(i = 0; i < nr_pages; i++) {
277 struct page *page = pvec->pages[i];
278
279 lock_page(page);
280
281 if (unlikely(page->mapping != mapping)) {
282 unlock_page(page);
283 continue;
284 }
285
286 if (!wbc->range_cyclic && page->index > end) {
287 ret = 1;
288 unlock_page(page);
289 continue;
290 }
291
292 if (wbc->sync_mode != WB_SYNC_NONE)
293 wait_on_page_writeback(page);
294
295 if (PageWriteback(page) ||
296 !clear_page_dirty_for_io(page)) {
297 unlock_page(page);
298 continue;
299 }
300
301
302 if (page->index > end_index || (page->index == end_index && !offset)) {
303 page->mapping->a_ops->invalidatepage(page, 0);
304 unlock_page(page);
305 continue;
306 }
307
308 ret = __gfs2_jdata_writepage(page, wbc);
309
310 if (ret || (--(wbc->nr_to_write) <= 0))
311 ret = 1;
312 }
313 gfs2_trans_end(sdp);
314 return ret;
315}
316
317
318
319
320
321
322
323
324
325
326
327
328
329static int gfs2_write_cache_jdata(struct address_space *mapping,
330 struct writeback_control *wbc)
331{
332 int ret = 0;
333 int done = 0;
334 struct pagevec pvec;
335 int nr_pages;
336 pgoff_t index;
337 pgoff_t end;
338 int scanned = 0;
339 int range_whole = 0;
340
341 pagevec_init(&pvec, 0);
342 if (wbc->range_cyclic) {
343 index = mapping->writeback_index;
344 end = -1;
345 } else {
346 index = wbc->range_start >> PAGE_CACHE_SHIFT;
347 end = wbc->range_end >> PAGE_CACHE_SHIFT;
348 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
349 range_whole = 1;
350 scanned = 1;
351 }
352
353retry:
354 while (!done && (index <= end) &&
355 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
356 PAGECACHE_TAG_DIRTY,
357 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
358 scanned = 1;
359 ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end);
360 if (ret)
361 done = 1;
362 if (ret > 0)
363 ret = 0;
364
365 pagevec_release(&pvec);
366 cond_resched();
367 }
368
369 if (!scanned && !done) {
370
371
372
373
374 scanned = 1;
375 index = 0;
376 goto retry;
377 }
378
379 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
380 mapping->writeback_index = index;
381 return ret;
382}
383
384
385
386
387
388
389
390
391
392static int gfs2_jdata_writepages(struct address_space *mapping,
393 struct writeback_control *wbc)
394{
395 struct gfs2_inode *ip = GFS2_I(mapping->host);
396 struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
397 int ret;
398
399 ret = gfs2_write_cache_jdata(mapping, wbc);
400 if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {
401 gfs2_log_flush(sdp, ip->i_gl);
402 ret = gfs2_write_cache_jdata(mapping, wbc);
403 }
404 return ret;
405}
406
407
408
409
410
411
412
413
414
415static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
416{
417 struct buffer_head *dibh;
418 u64 dsize = i_size_read(&ip->i_inode);
419 void *kaddr;
420 int error;
421
422
423
424
425
426
427 if (unlikely(page->index)) {
428 zero_user(page, 0, PAGE_CACHE_SIZE);
429 SetPageUptodate(page);
430 return 0;
431 }
432
433 error = gfs2_meta_inode_buffer(ip, &dibh);
434 if (error)
435 return error;
436
437 kaddr = kmap_atomic(page, KM_USER0);
438 if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
439 dsize = (dibh->b_size - sizeof(struct gfs2_dinode));
440 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
441 memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
442 kunmap_atomic(kaddr, KM_USER0);
443 flush_dcache_page(page);
444 brelse(dibh);
445 SetPageUptodate(page);
446
447 return 0;
448}
449
450
451
452
453
454
455
456
457
458
459
460
461
462static int __gfs2_readpage(void *file, struct page *page)
463{
464 struct gfs2_inode *ip = GFS2_I(page->mapping->host);
465 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
466 int error;
467
468 if (gfs2_is_stuffed(ip)) {
469 error = stuffed_readpage(ip, page);
470 unlock_page(page);
471 } else {
472 error = mpage_readpage(page, gfs2_block_map);
473 }
474
475 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
476 return -EIO;
477
478 return error;
479}
480
481
482
483
484
485
486
487
488
489
490
491static int gfs2_readpage(struct file *file, struct page *page)
492{
493 struct address_space *mapping = page->mapping;
494 struct gfs2_inode *ip = GFS2_I(mapping->host);
495 struct gfs2_holder gh;
496 int error;
497
498 unlock_page(page);
499 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
500 error = gfs2_glock_nq(&gh);
501 if (unlikely(error))
502 goto out;
503 error = AOP_TRUNCATED_PAGE;
504 lock_page(page);
505 if (page->mapping == mapping && !PageUptodate(page))
506 error = __gfs2_readpage(file, page);
507 else
508 unlock_page(page);
509 gfs2_glock_dq(&gh);
510out:
511 gfs2_holder_uninit(&gh);
512 if (error && error != AOP_TRUNCATED_PAGE)
513 lock_page(page);
514 return error;
515}
516
517
518
519
520
521
522
523
524
525
526
527int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
528 char *buf, loff_t *pos, unsigned size)
529{
530 struct address_space *mapping = ip->i_inode.i_mapping;
531 unsigned long index = *pos / PAGE_CACHE_SIZE;
532 unsigned offset = *pos & (PAGE_CACHE_SIZE - 1);
533 unsigned copied = 0;
534 unsigned amt;
535 struct page *page;
536 void *p;
537
538 do {
539 amt = size - copied;
540 if (offset + size > PAGE_CACHE_SIZE)
541 amt = PAGE_CACHE_SIZE - offset;
542 page = read_cache_page(mapping, index, __gfs2_readpage, NULL);
543 if (IS_ERR(page))
544 return PTR_ERR(page);
545 p = kmap_atomic(page, KM_USER0);
546 memcpy(buf + copied, p + offset, amt);
547 kunmap_atomic(p, KM_USER0);
548 mark_page_accessed(page);
549 page_cache_release(page);
550 copied += amt;
551 index++;
552 offset = 0;
553 } while(copied < size);
554 (*pos) += size;
555 return size;
556}
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572static int gfs2_readpages(struct file *file, struct address_space *mapping,
573 struct list_head *pages, unsigned nr_pages)
574{
575 struct inode *inode = mapping->host;
576 struct gfs2_inode *ip = GFS2_I(inode);
577 struct gfs2_sbd *sdp = GFS2_SB(inode);
578 struct gfs2_holder gh;
579 int ret;
580
581 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
582 ret = gfs2_glock_nq(&gh);
583 if (unlikely(ret))
584 goto out_uninit;
585 if (!gfs2_is_stuffed(ip))
586 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);
587 gfs2_glock_dq(&gh);
588out_uninit:
589 gfs2_holder_uninit(&gh);
590 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
591 ret = -EIO;
592 return ret;
593}
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608static int gfs2_write_begin(struct file *file, struct address_space *mapping,
609 loff_t pos, unsigned len, unsigned flags,
610 struct page **pagep, void **fsdata)
611{
612 struct gfs2_inode *ip = GFS2_I(mapping->host);
613 struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
614 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
615 unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
616 int alloc_required;
617 int error = 0;
618 struct gfs2_alloc *al = NULL;
619 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
620 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
621 struct page *page;
622
623 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
624 error = gfs2_glock_nq(&ip->i_gh);
625 if (unlikely(error))
626 goto out_uninit;
627 if (&ip->i_inode == sdp->sd_rindex) {
628 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
629 GL_NOCACHE, &m_ip->i_gh);
630 if (unlikely(error)) {
631 gfs2_glock_dq(&ip->i_gh);
632 goto out_uninit;
633 }
634 }
635
636 alloc_required = gfs2_write_alloc_required(ip, pos, len);
637
638 if (alloc_required || gfs2_is_jdata(ip))
639 gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
640
641 if (alloc_required) {
642 al = gfs2_alloc_get(ip);
643 if (!al) {
644 error = -ENOMEM;
645 goto out_unlock;
646 }
647
648 error = gfs2_quota_lock_check(ip);
649 if (error)
650 goto out_alloc_put;
651
652 al->al_requested = data_blocks + ind_blocks;
653 error = gfs2_inplace_reserve(ip);
654 if (error)
655 goto out_qunlock;
656 }
657
658 rblocks = RES_DINODE + ind_blocks;
659 if (gfs2_is_jdata(ip))
660 rblocks += data_blocks ? data_blocks : 1;
661 if (ind_blocks || data_blocks)
662 rblocks += RES_STATFS + RES_QUOTA;
663 if (&ip->i_inode == sdp->sd_rindex)
664 rblocks += 2 * RES_STATFS;
665 if (alloc_required)
666 rblocks += gfs2_rg_blocks(al);
667
668 error = gfs2_trans_begin(sdp, rblocks,
669 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
670 if (error)
671 goto out_trans_fail;
672
673 error = -ENOMEM;
674 flags |= AOP_FLAG_NOFS;
675 page = grab_cache_page_write_begin(mapping, index, flags);
676 *pagep = page;
677 if (unlikely(!page))
678 goto out_endtrans;
679
680 if (gfs2_is_stuffed(ip)) {
681 error = 0;
682 if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
683 error = gfs2_unstuff_dinode(ip, page);
684 if (error == 0)
685 goto prepare_write;
686 } else if (!PageUptodate(page)) {
687 error = stuffed_readpage(ip, page);
688 }
689 goto out;
690 }
691
692prepare_write:
693 error = __block_write_begin(page, from, len, gfs2_block_map);
694out:
695 if (error == 0)
696 return 0;
697
698 page_cache_release(page);
699
700 gfs2_trans_end(sdp);
701 if (pos + len > ip->i_inode.i_size)
702 gfs2_trim_blocks(&ip->i_inode);
703 goto out_trans_fail;
704
705out_endtrans:
706 gfs2_trans_end(sdp);
707out_trans_fail:
708 if (alloc_required) {
709 gfs2_inplace_release(ip);
710out_qunlock:
711 gfs2_quota_unlock(ip);
712out_alloc_put:
713 gfs2_alloc_put(ip);
714 }
715out_unlock:
716 if (&ip->i_inode == sdp->sd_rindex) {
717 gfs2_glock_dq(&m_ip->i_gh);
718 gfs2_holder_uninit(&m_ip->i_gh);
719 }
720 gfs2_glock_dq(&ip->i_gh);
721out_uninit:
722 gfs2_holder_uninit(&ip->i_gh);
723 return error;
724}
725
726
727
728
729
730static void adjust_fs_space(struct inode *inode)
731{
732 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
733 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
734 struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
735 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
736 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
737 struct buffer_head *m_bh, *l_bh;
738 u64 fs_total, new_free;
739
740
741 fs_total = gfs2_ri_total(sdp);
742 if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0)
743 return;
744
745 spin_lock(&sdp->sd_statfs_spin);
746 gfs2_statfs_change_in(m_sc, m_bh->b_data +
747 sizeof(struct gfs2_dinode));
748 if (fs_total > (m_sc->sc_total + l_sc->sc_total))
749 new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
750 else
751 new_free = 0;
752 spin_unlock(&sdp->sd_statfs_spin);
753 fs_warn(sdp, "File system extended by %llu blocks.\n",
754 (unsigned long long)new_free);
755 gfs2_statfs_change(sdp, new_free, new_free, 0);
756
757 if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0)
758 goto out;
759 update_statfs(sdp, m_bh, l_bh);
760 brelse(l_bh);
761out:
762 brelse(m_bh);
763}
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,
780 loff_t pos, unsigned len, unsigned copied,
781 struct page *page)
782{
783 struct gfs2_inode *ip = GFS2_I(inode);
784 struct gfs2_sbd *sdp = GFS2_SB(inode);
785 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
786 u64 to = pos + copied;
787 void *kaddr;
788 unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode);
789 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
790
791 BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode)));
792 kaddr = kmap_atomic(page, KM_USER0);
793 memcpy(buf + pos, kaddr + pos, copied);
794 memset(kaddr + pos + copied, 0, len - copied);
795 flush_dcache_page(page);
796 kunmap_atomic(kaddr, KM_USER0);
797
798 if (!PageUptodate(page))
799 SetPageUptodate(page);
800 unlock_page(page);
801 page_cache_release(page);
802
803 if (copied) {
804 if (inode->i_size < to)
805 i_size_write(inode, to);
806 gfs2_dinode_out(ip, di);
807 mark_inode_dirty(inode);
808 }
809
810 if (inode == sdp->sd_rindex) {
811 adjust_fs_space(inode);
812 ip->i_gh.gh_flags |= GL_NOCACHE;
813 }
814
815 brelse(dibh);
816 gfs2_trans_end(sdp);
817 if (inode == sdp->sd_rindex) {
818 gfs2_glock_dq(&m_ip->i_gh);
819 gfs2_holder_uninit(&m_ip->i_gh);
820 }
821 gfs2_glock_dq(&ip->i_gh);
822 gfs2_holder_uninit(&ip->i_gh);
823 return copied;
824}
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843static int gfs2_write_end(struct file *file, struct address_space *mapping,
844 loff_t pos, unsigned len, unsigned copied,
845 struct page *page, void *fsdata)
846{
847 struct inode *inode = page->mapping->host;
848 struct gfs2_inode *ip = GFS2_I(inode);
849 struct gfs2_sbd *sdp = GFS2_SB(inode);
850 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
851 struct buffer_head *dibh;
852 struct gfs2_alloc *al = ip->i_alloc;
853 unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
854 unsigned int to = from + len;
855 int ret;
856
857 BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL);
858
859 ret = gfs2_meta_inode_buffer(ip, &dibh);
860 if (unlikely(ret)) {
861 unlock_page(page);
862 page_cache_release(page);
863 goto failed;
864 }
865
866 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
867
868 if (gfs2_is_stuffed(ip))
869 return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
870
871 if (!gfs2_is_writeback(ip))
872 gfs2_page_add_databufs(ip, page, from, to);
873
874 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
875 if (ret > 0) {
876 gfs2_dinode_out(ip, dibh->b_data);
877 mark_inode_dirty(inode);
878 }
879
880 if (inode == sdp->sd_rindex) {
881 adjust_fs_space(inode);
882 ip->i_gh.gh_flags |= GL_NOCACHE;
883 }
884
885 brelse(dibh);
886 gfs2_trans_end(sdp);
887failed:
888 if (al) {
889 gfs2_inplace_release(ip);
890 gfs2_quota_unlock(ip);
891 gfs2_alloc_put(ip);
892 }
893 if (inode == sdp->sd_rindex) {
894 gfs2_glock_dq(&m_ip->i_gh);
895 gfs2_holder_uninit(&m_ip->i_gh);
896 }
897 gfs2_glock_dq(&ip->i_gh);
898 gfs2_holder_uninit(&ip->i_gh);
899 return ret;
900}
901
902
903
904
905
906
907
908
909static int gfs2_set_page_dirty(struct page *page)
910{
911 SetPageChecked(page);
912 return __set_page_dirty_buffers(page);
913}
914
915
916
917
918
919
920
921
922
923static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
924{
925 struct gfs2_inode *ip = GFS2_I(mapping->host);
926 struct gfs2_holder i_gh;
927 sector_t dblock = 0;
928 int error;
929
930 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
931 if (error)
932 return 0;
933
934 if (!gfs2_is_stuffed(ip))
935 dblock = generic_block_bmap(mapping, lblock, gfs2_block_map);
936
937 gfs2_glock_dq_uninit(&i_gh);
938
939 return dblock;
940}
941
942static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh)
943{
944 struct gfs2_bufdata *bd;
945
946 lock_buffer(bh);
947 gfs2_log_lock(sdp);
948 clear_buffer_dirty(bh);
949 bd = bh->b_private;
950 if (bd) {
951 if (!list_empty(&bd->bd_le.le_list) && !buffer_pinned(bh))
952 list_del_init(&bd->bd_le.le_list);
953 else
954 gfs2_remove_from_journal(bh, current->journal_info, 0);
955 }
956 bh->b_bdev = NULL;
957 clear_buffer_mapped(bh);
958 clear_buffer_req(bh);
959 clear_buffer_new(bh);
960 gfs2_log_unlock(sdp);
961 unlock_buffer(bh);
962}
963
964static void gfs2_invalidatepage(struct page *page, unsigned long offset)
965{
966 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
967 struct buffer_head *bh, *head;
968 unsigned long pos = 0;
969
970 BUG_ON(!PageLocked(page));
971 if (offset == 0)
972 ClearPageChecked(page);
973 if (!page_has_buffers(page))
974 goto out;
975
976 bh = head = page_buffers(page);
977 do {
978 if (offset <= pos)
979 gfs2_discard(sdp, bh);
980 pos += bh->b_size;
981 bh = bh->b_this_page;
982 } while (bh != head);
983out:
984 if (offset == 0)
985 try_to_release_page(page, 0);
986}
987
988
989
990
991
992
993
994
995
996
997static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
998{
999
1000
1001
1002
1003
1004 if (gfs2_is_stuffed(ip))
1005 return 0;
1006
1007 if (offset >= i_size_read(&ip->i_inode))
1008 return 0;
1009 return 1;
1010}
1011
1012
1013
1014static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
1015 const struct iovec *iov, loff_t offset,
1016 unsigned long nr_segs)
1017{
1018 struct file *file = iocb->ki_filp;
1019 struct inode *inode = file->f_mapping->host;
1020 struct gfs2_inode *ip = GFS2_I(inode);
1021 struct gfs2_holder gh;
1022 int rv;
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh);
1033 rv = gfs2_glock_nq(&gh);
1034 if (rv)
1035 return rv;
1036 rv = gfs2_ok_for_dio(ip, rw, offset);
1037 if (rv != 1)
1038 goto out;
1039
1040 rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1041 offset, nr_segs, gfs2_get_block_direct,
1042 NULL, NULL, 0);
1043out:
1044 gfs2_glock_dq_m(1, &gh);
1045 gfs2_holder_uninit(&gh);
1046 return rv;
1047}
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
1061{
1062 struct address_space *mapping = page->mapping;
1063 struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
1064 struct buffer_head *bh, *head;
1065 struct gfs2_bufdata *bd;
1066
1067 if (!page_has_buffers(page))
1068 return 0;
1069
1070 gfs2_log_lock(sdp);
1071 head = bh = page_buffers(page);
1072 do {
1073 if (atomic_read(&bh->b_count))
1074 goto cannot_release;
1075 bd = bh->b_private;
1076 if (bd && bd->bd_ail)
1077 goto cannot_release;
1078 gfs2_assert_warn(sdp, !buffer_pinned(bh));
1079 gfs2_assert_warn(sdp, !buffer_dirty(bh));
1080 bh = bh->b_this_page;
1081 } while(bh != head);
1082 gfs2_log_unlock(sdp);
1083
1084 head = bh = page_buffers(page);
1085 do {
1086 gfs2_log_lock(sdp);
1087 bd = bh->b_private;
1088 if (bd) {
1089 gfs2_assert_warn(sdp, bd->bd_bh == bh);
1090 gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
1091 if (!list_empty(&bd->bd_le.le_list)) {
1092 if (!buffer_pinned(bh))
1093 list_del_init(&bd->bd_le.le_list);
1094 else
1095 bd = NULL;
1096 }
1097 if (bd)
1098 bd->bd_bh = NULL;
1099 bh->b_private = NULL;
1100 }
1101 gfs2_log_unlock(sdp);
1102 if (bd)
1103 kmem_cache_free(gfs2_bufdata_cachep, bd);
1104
1105 bh = bh->b_this_page;
1106 } while (bh != head);
1107
1108 return try_to_free_buffers(page);
1109cannot_release:
1110 gfs2_log_unlock(sdp);
1111 return 0;
1112}
1113
1114static const struct address_space_operations gfs2_writeback_aops = {
1115 .writepage = gfs2_writeback_writepage,
1116 .writepages = gfs2_writeback_writepages,
1117 .readpage = gfs2_readpage,
1118 .readpages = gfs2_readpages,
1119 .sync_page = block_sync_page,
1120 .write_begin = gfs2_write_begin,
1121 .write_end = gfs2_write_end,
1122 .bmap = gfs2_bmap,
1123 .invalidatepage = gfs2_invalidatepage,
1124 .releasepage = gfs2_releasepage,
1125 .direct_IO = gfs2_direct_IO,
1126 .migratepage = buffer_migrate_page,
1127 .is_partially_uptodate = block_is_partially_uptodate,
1128 .error_remove_page = generic_error_remove_page,
1129};
1130
1131static const struct address_space_operations gfs2_ordered_aops = {
1132 .writepage = gfs2_ordered_writepage,
1133 .readpage = gfs2_readpage,
1134 .readpages = gfs2_readpages,
1135 .sync_page = block_sync_page,
1136 .write_begin = gfs2_write_begin,
1137 .write_end = gfs2_write_end,
1138 .set_page_dirty = gfs2_set_page_dirty,
1139 .bmap = gfs2_bmap,
1140 .invalidatepage = gfs2_invalidatepage,
1141 .releasepage = gfs2_releasepage,
1142 .direct_IO = gfs2_direct_IO,
1143 .migratepage = buffer_migrate_page,
1144 .is_partially_uptodate = block_is_partially_uptodate,
1145 .error_remove_page = generic_error_remove_page,
1146};
1147
1148static const struct address_space_operations gfs2_jdata_aops = {
1149 .writepage = gfs2_jdata_writepage,
1150 .writepages = gfs2_jdata_writepages,
1151 .readpage = gfs2_readpage,
1152 .readpages = gfs2_readpages,
1153 .sync_page = block_sync_page,
1154 .write_begin = gfs2_write_begin,
1155 .write_end = gfs2_write_end,
1156 .set_page_dirty = gfs2_set_page_dirty,
1157 .bmap = gfs2_bmap,
1158 .invalidatepage = gfs2_invalidatepage,
1159 .releasepage = gfs2_releasepage,
1160 .is_partially_uptodate = block_is_partially_uptodate,
1161 .error_remove_page = generic_error_remove_page,
1162};
1163
1164void gfs2_set_aops(struct inode *inode)
1165{
1166 struct gfs2_inode *ip = GFS2_I(inode);
1167
1168 if (gfs2_is_writeback(ip))
1169 inode->i_mapping->a_ops = &gfs2_writeback_aops;
1170 else if (gfs2_is_ordered(ip))
1171 inode->i_mapping->a_ops = &gfs2_ordered_aops;
1172 else if (gfs2_is_jdata(ip))
1173 inode->i_mapping->a_ops = &gfs2_jdata_aops;
1174 else
1175 BUG();
1176}
1177
1178