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#include <linux/aio.h>
24
25#include "gfs2.h"
26#include "incore.h"
27#include "bmap.h"
28#include "glock.h"
29#include "inode.h"
30#include "log.h"
31#include "meta_io.h"
32#include "quota.h"
33#include "trans.h"
34#include "rgrp.h"
35#include "super.h"
36#include "util.h"
37#include "glops.h"
38
39
40static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
41 unsigned int from, unsigned int to)
42{
43 struct buffer_head *head = page_buffers(page);
44 unsigned int bsize = head->b_size;
45 struct buffer_head *bh;
46 unsigned int start, end;
47
48 for (bh = head, start = 0; bh != head || !start;
49 bh = bh->b_this_page, start = end) {
50 end = start + bsize;
51 if (end <= from || start >= to)
52 continue;
53 if (gfs2_is_jdata(ip))
54 set_buffer_uptodate(bh);
55 gfs2_trans_add_data(ip->i_gl, bh);
56 }
57}
58
59
60
61
62
63
64
65
66
67
68
69static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
70 struct buffer_head *bh_result, int create)
71{
72 int error;
73
74 error = gfs2_block_map(inode, lblock, bh_result, 0);
75 if (error)
76 return error;
77 if (!buffer_mapped(bh_result))
78 return -EIO;
79 return 0;
80}
81
82static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
83 struct buffer_head *bh_result, int create)
84{
85 return gfs2_block_map(inode, lblock, bh_result, 0);
86}
87
88
89
90
91
92
93
94
95
96static int gfs2_writepage_common(struct page *page,
97 struct writeback_control *wbc)
98{
99 struct inode *inode = page->mapping->host;
100 struct gfs2_inode *ip = GFS2_I(inode);
101 struct gfs2_sbd *sdp = GFS2_SB(inode);
102 loff_t i_size = i_size_read(inode);
103 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
104 unsigned offset;
105
106 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl)))
107 goto out;
108 if (current->journal_info)
109 goto redirty;
110
111 offset = i_size & (PAGE_CACHE_SIZE-1);
112 if (page->index > end_index || (page->index == end_index && !offset)) {
113 page->mapping->a_ops->invalidatepage(page, 0, PAGE_CACHE_SIZE);
114 goto out;
115 }
116 return 1;
117redirty:
118 redirty_page_for_writepage(wbc, page);
119out:
120 unlock_page(page);
121 return 0;
122}
123
124
125
126
127
128
129
130
131static int gfs2_writeback_writepage(struct page *page,
132 struct writeback_control *wbc)
133{
134 int ret;
135
136 ret = gfs2_writepage_common(page, wbc);
137 if (ret <= 0)
138 return ret;
139
140 return nobh_writepage(page, gfs2_get_block_noalloc, wbc);
141}
142
143
144
145
146
147
148
149
150static int gfs2_ordered_writepage(struct page *page,
151 struct writeback_control *wbc)
152{
153 struct inode *inode = page->mapping->host;
154 struct gfs2_inode *ip = GFS2_I(inode);
155 int ret;
156
157 ret = gfs2_writepage_common(page, wbc);
158 if (ret <= 0)
159 return ret;
160
161 if (!page_has_buffers(page)) {
162 create_empty_buffers(page, inode->i_sb->s_blocksize,
163 (1 << BH_Dirty)|(1 << BH_Uptodate));
164 }
165 gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1);
166 return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
167}
168
169
170
171
172
173
174
175
176
177
178
179
180static int __gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
181{
182 struct inode *inode = page->mapping->host;
183 struct gfs2_inode *ip = GFS2_I(inode);
184 struct gfs2_sbd *sdp = GFS2_SB(inode);
185
186 if (PageChecked(page)) {
187 ClearPageChecked(page);
188 if (!page_has_buffers(page)) {
189 create_empty_buffers(page, inode->i_sb->s_blocksize,
190 (1 << BH_Dirty)|(1 << BH_Uptodate));
191 }
192 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
193 }
194 return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
195}
196
197
198
199
200
201
202
203
204
205static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
206{
207 struct inode *inode = page->mapping->host;
208 struct gfs2_sbd *sdp = GFS2_SB(inode);
209 int ret;
210 int done_trans = 0;
211
212 if (PageChecked(page)) {
213 if (wbc->sync_mode != WB_SYNC_ALL)
214 goto out_ignore;
215 ret = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
216 if (ret)
217 goto out_ignore;
218 done_trans = 1;
219 }
220 ret = gfs2_writepage_common(page, wbc);
221 if (ret > 0)
222 ret = __gfs2_jdata_writepage(page, wbc);
223 if (done_trans)
224 gfs2_trans_end(sdp);
225 return ret;
226
227out_ignore:
228 redirty_page_for_writepage(wbc, page);
229 unlock_page(page);
230 return 0;
231}
232
233
234
235
236
237
238
239
240static int gfs2_writepages(struct address_space *mapping,
241 struct writeback_control *wbc)
242{
243 return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
244}
245
246
247
248
249
250
251
252
253
254
255
256
257static int gfs2_write_jdata_pagevec(struct address_space *mapping,
258 struct writeback_control *wbc,
259 struct pagevec *pvec,
260 int nr_pages, pgoff_t end)
261{
262 struct inode *inode = mapping->host;
263 struct gfs2_sbd *sdp = GFS2_SB(inode);
264 loff_t i_size = i_size_read(inode);
265 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
266 unsigned offset = i_size & (PAGE_CACHE_SIZE-1);
267 unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);
268 int i;
269 int ret;
270
271 ret = gfs2_trans_begin(sdp, nrblocks, nrblocks);
272 if (ret < 0)
273 return ret;
274
275 for(i = 0; i < nr_pages; i++) {
276 struct page *page = pvec->pages[i];
277
278 lock_page(page);
279
280 if (unlikely(page->mapping != mapping)) {
281 unlock_page(page);
282 continue;
283 }
284
285 if (!wbc->range_cyclic && page->index > end) {
286 ret = 1;
287 unlock_page(page);
288 continue;
289 }
290
291 if (wbc->sync_mode != WB_SYNC_NONE)
292 wait_on_page_writeback(page);
293
294 if (PageWriteback(page) ||
295 !clear_page_dirty_for_io(page)) {
296 unlock_page(page);
297 continue;
298 }
299
300
301 if (page->index > end_index || (page->index == end_index && !offset)) {
302 page->mapping->a_ops->invalidatepage(page, 0,
303 PAGE_CACHE_SIZE);
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);
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);
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
526int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos,
527 unsigned size)
528{
529 struct address_space *mapping = ip->i_inode.i_mapping;
530 unsigned long index = *pos / PAGE_CACHE_SIZE;
531 unsigned offset = *pos & (PAGE_CACHE_SIZE - 1);
532 unsigned copied = 0;
533 unsigned amt;
534 struct page *page;
535 void *p;
536
537 do {
538 amt = size - copied;
539 if (offset + size > PAGE_CACHE_SIZE)
540 amt = PAGE_CACHE_SIZE - offset;
541 page = read_cache_page(mapping, index, __gfs2_readpage, NULL);
542 if (IS_ERR(page))
543 return PTR_ERR(page);
544 p = kmap_atomic(page);
545 memcpy(buf + copied, p + offset, amt);
546 kunmap_atomic(p);
547 mark_page_accessed(page);
548 page_cache_release(page);
549 copied += amt;
550 index++;
551 offset = 0;
552 } while(copied < size);
553 (*pos) += size;
554 return size;
555}
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571static int gfs2_readpages(struct file *file, struct address_space *mapping,
572 struct list_head *pages, unsigned nr_pages)
573{
574 struct inode *inode = mapping->host;
575 struct gfs2_inode *ip = GFS2_I(inode);
576 struct gfs2_sbd *sdp = GFS2_SB(inode);
577 struct gfs2_holder gh;
578 int ret;
579
580 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
581 ret = gfs2_glock_nq(&gh);
582 if (unlikely(ret))
583 goto out_uninit;
584 if (!gfs2_is_stuffed(ip))
585 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);
586 gfs2_glock_dq(&gh);
587out_uninit:
588 gfs2_holder_uninit(&gh);
589 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
590 ret = -EIO;
591 return ret;
592}
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607static int gfs2_write_begin(struct file *file, struct address_space *mapping,
608 loff_t pos, unsigned len, unsigned flags,
609 struct page **pagep, void **fsdata)
610{
611 struct gfs2_inode *ip = GFS2_I(mapping->host);
612 struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
613 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
614 unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
615 unsigned requested = 0;
616 int alloc_required;
617 int error = 0;
618 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
619 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
620 struct page *page;
621
622 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
623 error = gfs2_glock_nq(&ip->i_gh);
624 if (unlikely(error))
625 goto out_uninit;
626 if (&ip->i_inode == sdp->sd_rindex) {
627 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
628 GL_NOCACHE, &m_ip->i_gh);
629 if (unlikely(error)) {
630 gfs2_glock_dq(&ip->i_gh);
631 goto out_uninit;
632 }
633 }
634
635 alloc_required = gfs2_write_alloc_required(ip, pos, len);
636
637 if (alloc_required || gfs2_is_jdata(ip))
638 gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
639
640 if (alloc_required) {
641 error = gfs2_quota_lock_check(ip);
642 if (error)
643 goto out_unlock;
644
645 requested = data_blocks + ind_blocks;
646 error = gfs2_inplace_reserve(ip, requested, 0);
647 if (error)
648 goto out_qunlock;
649 }
650
651 rblocks = RES_DINODE + ind_blocks;
652 if (gfs2_is_jdata(ip))
653 rblocks += data_blocks ? data_blocks : 1;
654 if (ind_blocks || data_blocks)
655 rblocks += RES_STATFS + RES_QUOTA;
656 if (&ip->i_inode == sdp->sd_rindex)
657 rblocks += 2 * RES_STATFS;
658 if (alloc_required)
659 rblocks += gfs2_rg_blocks(ip, requested);
660
661 error = gfs2_trans_begin(sdp, rblocks,
662 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
663 if (error)
664 goto out_trans_fail;
665
666 error = -ENOMEM;
667 flags |= AOP_FLAG_NOFS;
668 page = grab_cache_page_write_begin(mapping, index, flags);
669 *pagep = page;
670 if (unlikely(!page))
671 goto out_endtrans;
672
673 if (gfs2_is_stuffed(ip)) {
674 error = 0;
675 if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
676 error = gfs2_unstuff_dinode(ip, page);
677 if (error == 0)
678 goto prepare_write;
679 } else if (!PageUptodate(page)) {
680 error = stuffed_readpage(ip, page);
681 }
682 goto out;
683 }
684
685prepare_write:
686 error = __block_write_begin(page, from, len, gfs2_block_map);
687out:
688 if (error == 0)
689 return 0;
690
691 unlock_page(page);
692 page_cache_release(page);
693
694 gfs2_trans_end(sdp);
695 if (pos + len > ip->i_inode.i_size)
696 gfs2_trim_blocks(&ip->i_inode);
697 goto out_trans_fail;
698
699out_endtrans:
700 gfs2_trans_end(sdp);
701out_trans_fail:
702 if (alloc_required) {
703 gfs2_inplace_release(ip);
704out_qunlock:
705 gfs2_quota_unlock(ip);
706 }
707out_unlock:
708 if (&ip->i_inode == sdp->sd_rindex) {
709 gfs2_glock_dq(&m_ip->i_gh);
710 gfs2_holder_uninit(&m_ip->i_gh);
711 }
712 gfs2_glock_dq(&ip->i_gh);
713out_uninit:
714 gfs2_holder_uninit(&ip->i_gh);
715 return error;
716}
717
718
719
720
721
722static void adjust_fs_space(struct inode *inode)
723{
724 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
725 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
726 struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
727 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
728 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
729 struct buffer_head *m_bh, *l_bh;
730 u64 fs_total, new_free;
731
732
733 fs_total = gfs2_ri_total(sdp);
734 if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0)
735 return;
736
737 spin_lock(&sdp->sd_statfs_spin);
738 gfs2_statfs_change_in(m_sc, m_bh->b_data +
739 sizeof(struct gfs2_dinode));
740 if (fs_total > (m_sc->sc_total + l_sc->sc_total))
741 new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
742 else
743 new_free = 0;
744 spin_unlock(&sdp->sd_statfs_spin);
745 fs_warn(sdp, "File system extended by %llu blocks.\n",
746 (unsigned long long)new_free);
747 gfs2_statfs_change(sdp, new_free, new_free, 0);
748
749 if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0)
750 goto out;
751 update_statfs(sdp, m_bh, l_bh);
752 brelse(l_bh);
753out:
754 brelse(m_bh);
755}
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,
772 loff_t pos, unsigned len, unsigned copied,
773 struct page *page)
774{
775 struct gfs2_inode *ip = GFS2_I(inode);
776 struct gfs2_sbd *sdp = GFS2_SB(inode);
777 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
778 u64 to = pos + copied;
779 void *kaddr;
780 unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode);
781
782 BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode)));
783 kaddr = kmap_atomic(page);
784 memcpy(buf + pos, kaddr + pos, copied);
785 memset(kaddr + pos + copied, 0, len - copied);
786 flush_dcache_page(page);
787 kunmap_atomic(kaddr);
788
789 if (!PageUptodate(page))
790 SetPageUptodate(page);
791 unlock_page(page);
792 page_cache_release(page);
793
794 if (copied) {
795 if (inode->i_size < to)
796 i_size_write(inode, to);
797 mark_inode_dirty(inode);
798 }
799
800 if (inode == sdp->sd_rindex) {
801 adjust_fs_space(inode);
802 sdp->sd_rindex_uptodate = 0;
803 }
804
805 brelse(dibh);
806 gfs2_trans_end(sdp);
807 if (inode == sdp->sd_rindex) {
808 gfs2_glock_dq(&m_ip->i_gh);
809 gfs2_holder_uninit(&m_ip->i_gh);
810 }
811 gfs2_glock_dq(&ip->i_gh);
812 gfs2_holder_uninit(&ip->i_gh);
813 return copied;
814}
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833static int gfs2_write_end(struct file *file, struct address_space *mapping,
834 loff_t pos, unsigned len, unsigned copied,
835 struct page *page, void *fsdata)
836{
837 struct inode *inode = page->mapping->host;
838 struct gfs2_inode *ip = GFS2_I(inode);
839 struct gfs2_sbd *sdp = GFS2_SB(inode);
840 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
841 struct buffer_head *dibh;
842 unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
843 unsigned int to = from + len;
844 int ret;
845
846 BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL);
847
848 ret = gfs2_meta_inode_buffer(ip, &dibh);
849 if (unlikely(ret)) {
850 unlock_page(page);
851 page_cache_release(page);
852 goto failed;
853 }
854
855 gfs2_trans_add_meta(ip->i_gl, dibh);
856
857 if (gfs2_is_stuffed(ip))
858 return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
859
860 if (!gfs2_is_writeback(ip))
861 gfs2_page_add_databufs(ip, page, from, to);
862
863 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
864
865 if (inode == sdp->sd_rindex) {
866 adjust_fs_space(inode);
867 sdp->sd_rindex_uptodate = 0;
868 }
869
870 brelse(dibh);
871failed:
872 gfs2_trans_end(sdp);
873 gfs2_inplace_release(ip);
874 if (ip->i_res->rs_qa_qd_num)
875 gfs2_quota_unlock(ip);
876 if (inode == sdp->sd_rindex) {
877 gfs2_glock_dq(&m_ip->i_gh);
878 gfs2_holder_uninit(&m_ip->i_gh);
879 }
880 gfs2_glock_dq(&ip->i_gh);
881 gfs2_holder_uninit(&ip->i_gh);
882 return ret;
883}
884
885
886
887
888
889
890
891
892static int gfs2_set_page_dirty(struct page *page)
893{
894 SetPageChecked(page);
895 return __set_page_dirty_buffers(page);
896}
897
898
899
900
901
902
903
904
905
906static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
907{
908 struct gfs2_inode *ip = GFS2_I(mapping->host);
909 struct gfs2_holder i_gh;
910 sector_t dblock = 0;
911 int error;
912
913 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
914 if (error)
915 return 0;
916
917 if (!gfs2_is_stuffed(ip))
918 dblock = generic_block_bmap(mapping, lblock, gfs2_block_map);
919
920 gfs2_glock_dq_uninit(&i_gh);
921
922 return dblock;
923}
924
925static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh)
926{
927 struct gfs2_bufdata *bd;
928
929 lock_buffer(bh);
930 gfs2_log_lock(sdp);
931 clear_buffer_dirty(bh);
932 bd = bh->b_private;
933 if (bd) {
934 if (!list_empty(&bd->bd_list) && !buffer_pinned(bh))
935 list_del_init(&bd->bd_list);
936 else
937 gfs2_remove_from_journal(bh, current->journal_info, 0);
938 }
939 bh->b_bdev = NULL;
940 clear_buffer_mapped(bh);
941 clear_buffer_req(bh);
942 clear_buffer_new(bh);
943 gfs2_log_unlock(sdp);
944 unlock_buffer(bh);
945}
946
947static void gfs2_invalidatepage(struct page *page, unsigned int offset,
948 unsigned int length)
949{
950 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
951 unsigned int stop = offset + length;
952 int partial_page = (offset || length < PAGE_CACHE_SIZE);
953 struct buffer_head *bh, *head;
954 unsigned long pos = 0;
955
956 BUG_ON(!PageLocked(page));
957 if (!partial_page)
958 ClearPageChecked(page);
959 if (!page_has_buffers(page))
960 goto out;
961
962 bh = head = page_buffers(page);
963 do {
964 if (pos + bh->b_size > stop)
965 return;
966
967 if (offset <= pos)
968 gfs2_discard(sdp, bh);
969 pos += bh->b_size;
970 bh = bh->b_this_page;
971 } while (bh != head);
972out:
973 if (!partial_page)
974 try_to_release_page(page, 0);
975}
976
977
978
979
980
981
982
983
984
985
986static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
987{
988
989
990
991
992
993 if (gfs2_is_stuffed(ip))
994 return 0;
995
996 if (offset >= i_size_read(&ip->i_inode))
997 return 0;
998 return 1;
999}
1000
1001
1002
1003static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
1004 const struct iovec *iov, loff_t offset,
1005 unsigned long nr_segs)
1006{
1007 struct file *file = iocb->ki_filp;
1008 struct inode *inode = file->f_mapping->host;
1009 struct gfs2_inode *ip = GFS2_I(inode);
1010 struct gfs2_holder gh;
1011 int rv;
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021 gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh);
1022 rv = gfs2_glock_nq(&gh);
1023 if (rv)
1024 return rv;
1025 rv = gfs2_ok_for_dio(ip, rw, offset);
1026 if (rv != 1)
1027 goto out;
1028
1029 rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1030 offset, nr_segs, gfs2_get_block_direct,
1031 NULL, NULL, 0);
1032out:
1033 gfs2_glock_dq(&gh);
1034 gfs2_holder_uninit(&gh);
1035 return rv;
1036}
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
1050{
1051 struct address_space *mapping = page->mapping;
1052 struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
1053 struct buffer_head *bh, *head;
1054 struct gfs2_bufdata *bd;
1055
1056 if (!page_has_buffers(page))
1057 return 0;
1058
1059 gfs2_log_lock(sdp);
1060 spin_lock(&sdp->sd_ail_lock);
1061 head = bh = page_buffers(page);
1062 do {
1063 if (atomic_read(&bh->b_count))
1064 goto cannot_release;
1065 bd = bh->b_private;
1066 if (bd && bd->bd_tr)
1067 goto cannot_release;
1068 if (buffer_pinned(bh) || buffer_dirty(bh))
1069 goto not_possible;
1070 bh = bh->b_this_page;
1071 } while(bh != head);
1072 spin_unlock(&sdp->sd_ail_lock);
1073 gfs2_log_unlock(sdp);
1074
1075 head = bh = page_buffers(page);
1076 do {
1077 gfs2_log_lock(sdp);
1078 bd = bh->b_private;
1079 if (bd) {
1080 gfs2_assert_warn(sdp, bd->bd_bh == bh);
1081 if (!list_empty(&bd->bd_list)) {
1082 if (!buffer_pinned(bh))
1083 list_del_init(&bd->bd_list);
1084 else
1085 bd = NULL;
1086 }
1087 if (bd)
1088 bd->bd_bh = NULL;
1089 bh->b_private = NULL;
1090 }
1091 gfs2_log_unlock(sdp);
1092 if (bd)
1093 kmem_cache_free(gfs2_bufdata_cachep, bd);
1094
1095 bh = bh->b_this_page;
1096 } while (bh != head);
1097
1098 return try_to_free_buffers(page);
1099
1100not_possible:
1101 WARN_ON(buffer_dirty(bh));
1102 WARN_ON(buffer_pinned(bh));
1103cannot_release:
1104 spin_unlock(&sdp->sd_ail_lock);
1105 gfs2_log_unlock(sdp);
1106 return 0;
1107}
1108
1109static const struct address_space_operations gfs2_writeback_aops = {
1110 .writepage = gfs2_writeback_writepage,
1111 .writepages = gfs2_writepages,
1112 .readpage = gfs2_readpage,
1113 .readpages = gfs2_readpages,
1114 .write_begin = gfs2_write_begin,
1115 .write_end = gfs2_write_end,
1116 .bmap = gfs2_bmap,
1117 .invalidatepage = gfs2_invalidatepage,
1118 .releasepage = gfs2_releasepage,
1119 .direct_IO = gfs2_direct_IO,
1120 .migratepage = buffer_migrate_page,
1121 .is_partially_uptodate = block_is_partially_uptodate,
1122 .error_remove_page = generic_error_remove_page,
1123};
1124
1125static const struct address_space_operations gfs2_ordered_aops = {
1126 .writepage = gfs2_ordered_writepage,
1127 .writepages = gfs2_writepages,
1128 .readpage = gfs2_readpage,
1129 .readpages = gfs2_readpages,
1130 .write_begin = gfs2_write_begin,
1131 .write_end = gfs2_write_end,
1132 .set_page_dirty = gfs2_set_page_dirty,
1133 .bmap = gfs2_bmap,
1134 .invalidatepage = gfs2_invalidatepage,
1135 .releasepage = gfs2_releasepage,
1136 .direct_IO = gfs2_direct_IO,
1137 .migratepage = buffer_migrate_page,
1138 .is_partially_uptodate = block_is_partially_uptodate,
1139 .error_remove_page = generic_error_remove_page,
1140};
1141
1142static const struct address_space_operations gfs2_jdata_aops = {
1143 .writepage = gfs2_jdata_writepage,
1144 .writepages = gfs2_jdata_writepages,
1145 .readpage = gfs2_readpage,
1146 .readpages = gfs2_readpages,
1147 .write_begin = gfs2_write_begin,
1148 .write_end = gfs2_write_end,
1149 .set_page_dirty = gfs2_set_page_dirty,
1150 .bmap = gfs2_bmap,
1151 .invalidatepage = gfs2_invalidatepage,
1152 .releasepage = gfs2_releasepage,
1153 .is_partially_uptodate = block_is_partially_uptodate,
1154 .error_remove_page = generic_error_remove_page,
1155};
1156
1157void gfs2_set_aops(struct inode *inode)
1158{
1159 struct gfs2_inode *ip = GFS2_I(inode);
1160
1161 if (gfs2_is_writeback(ip))
1162 inode->i_mapping->a_ops = &gfs2_writeback_aops;
1163 else if (gfs2_is_ordered(ip))
1164 inode->i_mapping->a_ops = &gfs2_ordered_aops;
1165 else if (gfs2_is_jdata(ip))
1166 inode->i_mapping->a_ops = &gfs2_jdata_aops;
1167 else
1168 BUG();
1169}
1170
1171