← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/btrfs/compression.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/btrfs/compression.c
125
125
                kunmap_atomic(kaddr, KM_USER0);
126
126
 
127
127
                if (csum != *cb_sum) {
128
 
                        printk(KERN_INFO "btrfs csum failed ino %lu "
 
128
                        printk(KERN_INFO "btrfs csum failed ino %llu "
129
129
                               "extent %llu csum %u "
130
 
                               "wanted %u mirror %d\n", inode->i_ino,
 
130
                               "wanted %u mirror %d\n",
 
131
                               (unsigned long long)btrfs_ino(inode),
131
132
                               (unsigned long long)disk_start,
132
133
                               csum, *cb_sum, cb->mirror_num);
133
134
                        ret = -EIO;
332
333
        struct compressed_bio *cb;
333
334
        unsigned long bytes_left;
334
335
        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
335
 
        int page_index = 0;
 
336
        int pg_index = 0;
336
337
        struct page *page;
337
338
        u64 first_byte = disk_start;
338
339
        struct block_device *bdev;
340
341
 
341
342
        WARN_ON(start & ((u64)PAGE_CACHE_SIZE - 1));
342
343
        cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);
 
344
        if (!cb)
 
345
                return -ENOMEM;
343
346
        atomic_set(&cb->pending_bios, 0);
344
347
        cb->errors = 0;
345
348
        cb->inode = inode;
354
357
        bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
355
358
 
356
359
        bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
 
360
        if(!bio) {
 
361
                kfree(cb);
 
362
                return -ENOMEM;
 
363
        }
357
364
        bio->bi_private = cb;
358
365
        bio->bi_end_io = end_compressed_bio_write;
359
366
        atomic_inc(&cb->pending_bios);
360
367
 
361
368
        /* create and submit bios for the compressed pages */
362
369
        bytes_left = compressed_len;
363
 
        for (page_index = 0; page_index < cb->nr_pages; page_index++) {
364
 
                page = compressed_pages[page_index];
 
370
        for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {
 
371
                page = compressed_pages[pg_index];
365
372
                page->mapping = inode->i_mapping;
366
373
                if (bio->bi_size)
367
374
                        ret = io_tree->ops->merge_bio_hook(page, 0,
426
433
                                     struct compressed_bio *cb)
427
434
{
428
435
        unsigned long end_index;
429
 
        unsigned long page_index;
 
436
        unsigned long pg_index;
430
437
        u64 last_offset;
431
438
        u64 isize = i_size_read(inode);
432
439
        int ret;
450
457
        end_index = (i_size_read(inode) - 1) >> PAGE_CACHE_SHIFT;
451
458
 
452
459
        while (last_offset < compressed_end) {
453
 
                page_index = last_offset >> PAGE_CACHE_SHIFT;
 
460
                pg_index = last_offset >> PAGE_CACHE_SHIFT;
454
461
 
455
 
                if (page_index > end_index)
 
462
                if (pg_index > end_index)
456
463
                        break;
457
464
 
458
465
                rcu_read_lock();
459
 
                page = radix_tree_lookup(&mapping->page_tree, page_index);
 
466
                page = radix_tree_lookup(&mapping->page_tree, pg_index);
460
467
                rcu_read_unlock();
461
468
                if (page) {
462
469
                        misses++;
470
477
                if (!page)
471
478
                        break;
472
479
 
473
 
                if (add_to_page_cache_lru(page, mapping, page_index,
 
480
                if (add_to_page_cache_lru(page, mapping, pg_index,
474
481
                                                                GFP_NOFS)) {
475
482
                        page_cache_release(page);
476
483
                        goto next;
554
561
        unsigned long uncompressed_len = bio->bi_vcnt * PAGE_CACHE_SIZE;
555
562
        unsigned long compressed_len;
556
563
        unsigned long nr_pages;
557
 
        unsigned long page_index;
 
564
        unsigned long pg_index;
558
565
        struct page *page;
559
566
        struct block_device *bdev;
560
567
        struct bio *comp_bio;
607
614
 
608
615
        bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
609
616
 
610
 
        for (page_index = 0; page_index < nr_pages; page_index++) {
611
 
                cb->compressed_pages[page_index] = alloc_page(GFP_NOFS |
 
617
        for (pg_index = 0; pg_index < nr_pages; pg_index++) {
 
618
                cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS |
612
619
                                                              __GFP_HIGHMEM);
613
 
                if (!cb->compressed_pages[page_index])
 
620
                if (!cb->compressed_pages[pg_index])
614
621
                        goto fail2;
615
622
        }
616
623
        cb->nr_pages = nr_pages;
628
635
        comp_bio->bi_end_io = end_compressed_bio_read;
629
636
        atomic_inc(&cb->pending_bios);
630
637
 
631
 
        for (page_index = 0; page_index < nr_pages; page_index++) {
632
 
                page = cb->compressed_pages[page_index];
 
638
        for (pg_index = 0; pg_index < nr_pages; pg_index++) {
 
639
                page = cb->compressed_pages[pg_index];
633
640
                page->mapping = inode->i_mapping;
634
641
                page->index = em_start >> PAGE_CACHE_SHIFT;
635
642
 
657
664
                        atomic_inc(&cb->pending_bios);
658
665
 
659
666
                        if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
660
 
                                btrfs_lookup_bio_sums(root, inode, comp_bio,
661
 
                                                      sums);
 
667
                                ret = btrfs_lookup_bio_sums(root, inode,
 
668
                                                        comp_bio, sums);
 
669
                                BUG_ON(ret);
662
670
                        }
663
671
                        sums += (comp_bio->bi_size + root->sectorsize - 1) /
664
672
                                root->sectorsize;
683
691
        ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);
684
692
        BUG_ON(ret);
685
693
 
686
 
        if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
687
 
                btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
 
694
        if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
 
695
                ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
 
696
                BUG_ON(ret);
 
697
        }
688
698
 
689
699
        ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
690
700
        BUG_ON(ret);
693
703
        return 0;
694
704
 
695
705
fail2:
696
 
        for (page_index = 0; page_index < nr_pages; page_index++)
697
 
                free_page((unsigned long)cb->compressed_pages[page_index]);
 
706
        for (pg_index = 0; pg_index < nr_pages; pg_index++)
 
707
                free_page((unsigned long)cb->compressed_pages[pg_index]);
698
708
 
699
709
        kfree(cb->compressed_pages);
700
710
fail1:
936
946
int btrfs_decompress_buf2page(char *buf, unsigned long buf_start,
937
947
                              unsigned long total_out, u64 disk_start,
938
948
                              struct bio_vec *bvec, int vcnt,
939
 
                              unsigned long *page_index,
 
949
                              unsigned long *pg_index,
940
950
                              unsigned long *pg_offset)
941
951
{
942
952
        unsigned long buf_offset;
945
955
        unsigned long working_bytes = total_out - buf_start;
946
956
        unsigned long bytes;
947
957
        char *kaddr;
948
 
        struct page *page_out = bvec[*page_index].bv_page;
 
958
        struct page *page_out = bvec[*pg_index].bv_page;
949
959
 
950
960
        /*
951
961
         * start byte is the first byte of the page we're currently
986
996
 
987
997
                /* check if we need to pick another page */
988
998
                if (*pg_offset == PAGE_CACHE_SIZE) {
989
 
                        (*page_index)++;
990
 
                        if (*page_index >= vcnt)
 
999
                        (*pg_index)++;
 
1000
                        if (*pg_index >= vcnt)
991
1001
                                return 0;
992
1002
 
993
 
                        page_out = bvec[*page_index].bv_page;
 
1003
                        page_out = bvec[*pg_index].bv_page;
994
1004
                        *pg_offset = 0;
995
1005
                        start_byte = page_offset(page_out) - disk_start;
996
1006