← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to fs/gfs2/aops.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/gfs2/aops.c
36
36
#include "glops.h"
37
37
 
38
38
 
39
 
static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
40
 
                                   unsigned int from, unsigned int to)
 
39
void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
 
40
                            unsigned int from, unsigned int to)
41
41
{
42
42
        struct buffer_head *head = page_buffers(page);
43
43
        unsigned int bsize = head->b_size;
136
136
        if (ret <= 0)
137
137
                return ret;
138
138
 
139
 
        ret = mpage_writepage(page, gfs2_get_block_noalloc, wbc);
140
 
        if (ret == -EAGAIN)
141
 
                ret = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
142
 
        return ret;
 
139
        return nobh_writepage(page, gfs2_get_block_noalloc, wbc);
143
140
}
144
141
 
145
142
/**
269
266
        pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
270
267
        unsigned offset = i_size & (PAGE_CACHE_SIZE-1);
271
268
        unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);
272
 
        struct backing_dev_info *bdi = mapping->backing_dev_info;
273
269
        int i;
274
270
        int ret;
275
271
 
313
309
 
314
310
                if (ret || (--(wbc->nr_to_write) <= 0))
315
311
                        ret = 1;
316
 
                if (wbc->nonblocking && bdi_write_congested(bdi)) {
317
 
                        wbc->encountered_congestion = 1;
318
 
                        ret = 1;
319
 
                }
320
 
 
321
312
        }
322
313
        gfs2_trans_end(sdp);
323
314
        return ret;
338
329
static int gfs2_write_cache_jdata(struct address_space *mapping,
339
330
                                  struct writeback_control *wbc)
340
331
{
341
 
        struct backing_dev_info *bdi = mapping->backing_dev_info;
342
332
        int ret = 0;
343
333
        int done = 0;
344
334
        struct pagevec pvec;
348
338
        int scanned = 0;
349
339
        int range_whole = 0;
350
340
 
351
 
        if (wbc->nonblocking && bdi_write_congested(bdi)) {
352
 
                wbc->encountered_congestion = 1;
353
 
                return 0;
354
 
        }
355
 
 
356
341
        pagevec_init(&pvec, 0);
357
342
        if (wbc->range_cyclic) {
358
343
                index = mapping->writeback_index; /* Start from prev offset */
430
415
static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
431
416
{
432
417
        struct buffer_head *dibh;
 
418
        u64 dsize = i_size_read(&ip->i_inode);
433
419
        void *kaddr;
434
420
        int error;
435
421
 
449
435
                return error;
450
436
 
451
437
        kaddr = kmap_atomic(page, KM_USER0);
452
 
        memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
453
 
               ip->i_disksize);
454
 
        memset(kaddr + ip->i_disksize, 0, PAGE_CACHE_SIZE - ip->i_disksize);
 
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);
455
442
        kunmap_atomic(kaddr, KM_USER0);
456
443
        flush_dcache_page(page);
457
444
        brelse(dibh);
628
615
        unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
629
616
        int alloc_required;
630
617
        int error = 0;
631
 
        struct gfs2_alloc *al;
 
618
        struct gfs2_alloc *al = NULL;
632
619
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
633
620
        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
634
 
        unsigned to = from + len;
635
621
        struct page *page;
636
622
 
637
623
        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
647
633
                }
648
634
        }
649
635
 
650
 
        error = gfs2_write_alloc_required(ip, pos, len, &alloc_required);
651
 
        if (error)
652
 
                goto out_unlock;
 
636
        alloc_required = gfs2_write_alloc_required(ip, pos, len);
653
637
 
654
638
        if (alloc_required || gfs2_is_jdata(ip))
655
639
                gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
678
662
                rblocks += RES_STATFS + RES_QUOTA;
679
663
        if (&ip->i_inode == sdp->sd_rindex)
680
664
                rblocks += 2 * RES_STATFS;
 
665
        if (alloc_required)
 
666
                rblocks += gfs2_rg_blocks(al);
681
667
 
682
668
        error = gfs2_trans_begin(sdp, rblocks,
683
669
                                 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
704
690
        }
705
691
 
706
692
prepare_write:
707
 
        error = block_prepare_write(page, from, to, gfs2_block_map);
 
693
        error = __block_write_begin(page, from, len, gfs2_block_map);
708
694
out:
709
695
        if (error == 0)
710
696
                return 0;
711
697
 
712
698
        page_cache_release(page);
 
699
 
 
700
        gfs2_trans_end(sdp);
713
701
        if (pos + len > ip->i_inode.i_size)
714
 
                vmtruncate(&ip->i_inode, ip->i_inode.i_size);
 
702
                gfs2_trim_blocks(&ip->i_inode);
 
703
        goto out_trans_fail;
 
704
 
715
705
out_endtrans:
716
706
        gfs2_trans_end(sdp);
717
707
out_trans_fail:
811
801
        page_cache_release(page);
812
802
 
813
803
        if (copied) {
814
 
                if (inode->i_size < to) {
 
804
                if (inode->i_size < to)
815
805
                        i_size_write(inode, to);
816
 
                        ip->i_disksize = inode->i_size;
817
 
                }
818
806
                gfs2_dinode_out(ip, di);
819
807
                mark_inode_dirty(inode);
820
808
        }
821
809
 
822
 
        if (inode == sdp->sd_rindex)
 
810
        if (inode == sdp->sd_rindex) {
823
811
                adjust_fs_space(inode);
 
812
                ip->i_gh.gh_flags |= GL_NOCACHE;
 
813
        }
824
814
 
825
815
        brelse(dibh);
826
816
        gfs2_trans_end(sdp);
883
873
 
884
874
        ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
885
875
        if (ret > 0) {
886
 
                if (inode->i_size > ip->i_disksize)
887
 
                        ip->i_disksize = inode->i_size;
888
876
                gfs2_dinode_out(ip, dibh->b_data);
889
877
                mark_inode_dirty(inode);
890
878
        }
891
879
 
892
 
        if (inode == sdp->sd_rindex)
 
880
        if (inode == sdp->sd_rindex) {
893
881
                adjust_fs_space(inode);
 
882
                ip->i_gh.gh_flags |= GL_NOCACHE;
 
883
        }
894
884
 
895
885
        brelse(dibh);
896
886
        gfs2_trans_end(sdp);
1047
1037
        if (rv != 1)
1048
1038
                goto out; /* dio not valid, fall back to buffered i/o */
1049
1039
 
1050
 
        rv = blockdev_direct_IO_no_locking(rw, iocb, inode, inode->i_sb->s_bdev,
1051
 
                                           iov, offset, nr_segs,
1052
 
                                           gfs2_get_block_direct, NULL);
 
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);
1053
1043
out:
1054
1044
        gfs2_glock_dq_m(1, &gh);
1055
1045
        gfs2_holder_uninit(&gh);
1069
1059
 
1070
1060
int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
1071
1061
{
1072
 
        struct inode *aspace = page->mapping->host;
1073
 
        struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
 
1062
        struct address_space *mapping = page->mapping;
 
1063
        struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
1074
1064
        struct buffer_head *bh, *head;
1075
1065
        struct gfs2_bufdata *bd;
1076
1066