Remove Btrfs compat code for older kernels

Btrfs had compatibility code for kernels back to 2.6.18.  These have
been removed, and will be maintained in a separate backport
git tree from now on.

Signed-off-by: Chris Mason <chris.mason@oracle.com>

diff --git a/fs/btrfs/async-thread.c b/fs/btrfs/async-thread.c
index 2ee3017..4e780b2 100644 (file)
--- a/fs/btrfs/async-thread.c
+++ b/fs/btrfs/async-thread.c
@@ -20,13 +20,7 @@
 #include <linux/kthread.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
 # include <linux/freezer.h>
-#else
-# include <linux/sched.h>
-#endif
-
 #include "async-thread.h"
 
 /*

diff --git a/fs/btrfs/compat.h b/fs/btrfs/compat.h
index b0ed188..cd6598b 100644 (file)
--- a/fs/btrfs/compat.h
+++ b/fs/btrfs/compat.h
@@ -1,9 +1,8 @@
 #ifndef _COMPAT_H_
 #define _COMPAT_H_
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,26)
-#define trylock_page(page) (!TestSetPageLocked(page))
-#endif
+#define btrfs_drop_nlink(inode) drop_nlink(inode)
+#define btrfs_inc_nlink(inode) inc_nlink(inode)
 
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,27)
 static inline struct dentry *d_obtain_alias(struct inode *inode)
@@ -22,39 +21,4 @@ static inline struct dentry *d_obtain_alias(struct inode *inode)
 }
 #endif
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
-static inline void btrfs_drop_nlink(struct inode *inode)
-{
-       inode->i_nlink--;
-}
-
-static inline void btrfs_inc_nlink(struct inode *inode)
-{
-       inode->i_nlink++;
-}
-#else
-# define btrfs_drop_nlink(inode) drop_nlink(inode)
-# define btrfs_inc_nlink(inode)        inc_nlink(inode)
-#endif
-
-/*
- * Even if AppArmor isn't enabled, it still has different prototypes.
- * Add more distro/version pairs here to declare which has AppArmor applied.
- */
-#if defined(CONFIG_SUSE_KERNEL)
-# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-# define REMOVE_SUID_PATH 1
-# endif
-#endif
-
-/*
- * catch any other distros that have patched in apparmor.  This isn't
- * 100% reliable because it won't catch people that hand compile their
- * own distro kernels without apparmor compiled in.  But, it is better
- * than nothing.
- */
-#ifdef CONFIG_SECURITY_APPARMOR
-# define REMOVE_SUID_PATH 1
-#endif
-
 #endif /* _COMPAT_H_ */

diff --git a/fs/btrfs/crc32c.h b/fs/btrfs/crc32c.h
index bf6c12e..4f0fefe 100644 (file)
--- a/fs/btrfs/crc32c.h
+++ b/fs/btrfs/crc32c.h
@@ -96,13 +96,7 @@ static inline u32 __btrfs_crc32c(u32 crc, unsigned char const *address,
  * We must workaround older implementations of crc32c_le()
  * found on older kernel versions.
  */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
-#define btrfs_crc32c(seed, data, length) \
-       __cpu_to_le32( __btrfs_crc32c( __le32_to_cpu(seed), \
-                                     (unsigned char const *)data, length) )
-#else
 #define btrfs_crc32c(seed, data, length) \
        __btrfs_crc32c(seed, (unsigned char const *)data, length)
 #endif
-#endif
 

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 138c157..3b3c1ca 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1472,12 +1472,9 @@ static inline u32 btrfs_level_size(struct btrfs_root *root, int level) {
        ((unsigned long)(btrfs_leaf_data(leaf) + \
        btrfs_item_offset_nr(leaf, slot)))
 
-static inline struct dentry *fdentry(struct file *file) {
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
-       return file->f_dentry;
-#else
+static inline struct dentry *fdentry(struct file *file)
+{
        return file->f_path.dentry;
-#endif
 }
 
 /* extent-tree.c */

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index d35ca6a..dffb8da 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -26,11 +26,7 @@
 #include <linux/buffer_head.h> // for block_sync_page
 #include <linux/workqueue.h>
 #include <linux/kthread.h>
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
 # include <linux/freezer.h>
-#else
-# include <linux/sched.h>
-#endif
 #include "crc32c.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -373,21 +369,11 @@ out:
        return ret;
 }
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 static void end_workqueue_bio(struct bio *bio, int err)
-#else
-static int end_workqueue_bio(struct bio *bio,
-                                  unsigned int bytes_done, int err)
-#endif
 {
        struct end_io_wq *end_io_wq = bio->bi_private;
        struct btrfs_fs_info *fs_info;
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       if (bio->bi_size)
-               return 1;
-#endif
-
        fs_info = end_io_wq->info;
        end_io_wq->error = err;
        end_io_wq->work.func = end_workqueue_fn;
@@ -397,10 +383,6 @@ static int end_workqueue_bio(struct bio *bio,
                                   &end_io_wq->work);
        else
                btrfs_queue_worker(&fs_info->endio_workers, &end_io_wq->work);
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       return 0;
-#endif
 }
 
 int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
@@ -1161,9 +1143,7 @@ void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
 
 static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
 {
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
        bdi_init(bdi);
-#endif
        bdi->ra_pages   = default_backing_dev_info.ra_pages;
        bdi->state              = 0;
        bdi->capabilities       = default_backing_dev_info.capabilities;
@@ -1242,11 +1222,7 @@ static void end_workqueue_fn(struct btrfs_work *work)
        bio->bi_private = end_io_wq->private;
        bio->bi_end_io = end_io_wq->end_io;
        kfree(end_io_wq);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       bio_endio(bio, bio->bi_size, error);
-#else
        bio_endio(bio, error);
-#endif
 }
 
 static int cleaner_kthread(void *arg)
@@ -1673,9 +1649,7 @@ fail:
 
        kfree(extent_root);
        kfree(tree_root);
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
        bdi_destroy(&fs_info->bdi);
-#endif
        kfree(fs_info);
        return ERR_PTR(err);
 }
@@ -1936,9 +1910,7 @@ int close_ctree(struct btrfs_root *root)
        btrfs_close_devices(fs_info->fs_devices);
        btrfs_mapping_tree_free(&fs_info->mapping_tree);
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
        bdi_destroy(&fs_info->bdi);
-#endif
 
        kfree(fs_info->extent_root);
        kfree(fs_info->tree_root);

diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index 2b357a6..48b82cd 100644 (file)
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -7,12 +7,6 @@
 #include "export.h"
 #include "compat.h"
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
-#define FILEID_BTRFS_WITHOUT_PARENT            0x4d
-#define FILEID_BTRFS_WITH_PARENT               0x4e
-#define FILEID_BTRFS_WITH_PARENT_ROOT          0x4f
-#endif
-
 #define BTRFS_FID_SIZE_NON_CONNECTABLE         (offsetof(struct btrfs_fid, parent_objectid)/4)
 #define BTRFS_FID_SIZE_CONNECTABLE             (offsetof(struct btrfs_fid, parent_root_objectid)/4)
 #define BTRFS_FID_SIZE_CONNECTABLE_ROOT                (sizeof(struct btrfs_fid)/4)

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 58ad258..e3a25be 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1397,12 +1397,7 @@ static int check_page_writeback(struct extent_io_tree *tree,
  * Scheduling is not allowed, so the extent state tree is expected
  * to have one and only one object corresponding to this IO.
  */
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 static void end_bio_extent_writepage(struct bio *bio, int err)
-#else
-static int end_bio_extent_writepage(struct bio *bio,
-                                  unsigned int bytes_done, int err)
-#endif
 {
        int uptodate = err == 0;
        struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
@@ -1412,10 +1407,6 @@ static int end_bio_extent_writepage(struct bio *bio,
        int whole_page;
        int ret;
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       if (bio->bi_size)
-               return 1;
-#endif
        do {
                struct page *page = bvec->bv_page;
                tree = &BTRFS_I(page->mapping->host)->io_tree;
@@ -1461,10 +1452,8 @@ static int end_bio_extent_writepage(struct bio *bio,
                else
                        check_page_writeback(tree, page);
        } while (bvec >= bio->bi_io_vec);
+
        bio_put(bio);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       return 0;
-#endif
 }
 
 /*
@@ -1478,12 +1467,7 @@ static int end_bio_extent_writepage(struct bio *bio,
  * Scheduling is not allowed, so the extent state tree is expected
  * to have one and only one object corresponding to this IO.
  */
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 static void end_bio_extent_readpage(struct bio *bio, int err)
-#else
-static int end_bio_extent_readpage(struct bio *bio,
-                                  unsigned int bytes_done, int err)
-#endif
 {
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
@@ -1493,11 +1477,6 @@ static int end_bio_extent_readpage(struct bio *bio,
        int whole_page;
        int ret;
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       if (bio->bi_size)
-               return 1;
-#endif
-
        do {
                struct page *page = bvec->bv_page;
                tree = &BTRFS_I(page->mapping->host)->io_tree;
@@ -1556,9 +1535,6 @@ static int end_bio_extent_readpage(struct bio *bio,
        } while (bvec >= bio->bi_io_vec);
 
        bio_put(bio);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       return 0;
-#endif
 }
 
 /*
@@ -1566,12 +1542,7 @@ static int end_bio_extent_readpage(struct bio *bio,
  * the structs in the extent tree when done, and set the uptodate bits
  * as appropriate.
  */
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 static void end_bio_extent_preparewrite(struct bio *bio, int err)
-#else
-static int end_bio_extent_preparewrite(struct bio *bio,
-                                      unsigned int bytes_done, int err)
-#endif
 {
        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
@@ -1579,11 +1550,6 @@ static int end_bio_extent_preparewrite(struct bio *bio,
        u64 start;
        u64 end;
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       if (bio->bi_size)
-               return 1;
-#endif
-
        do {
                struct page *page = bvec->bv_page;
                tree = &BTRFS_I(page->mapping->host)->io_tree;
@@ -1607,9 +1573,6 @@ static int end_bio_extent_preparewrite(struct bio *bio,
        } while (bvec >= bio->bi_io_vec);
 
        bio_put(bio);
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       return 0;
-#endif
 }
 
 static struct bio *
@@ -2079,12 +2042,6 @@ done:
        return 0;
 }
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
-/* Taken directly from 2.6.23 with a mod for a lockpage hook */
-typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
-                                void *data);
-#endif
-
 /**
  * write_cache_pages - walk the list of dirty pages of the given address space and write all of them.
  * @mapping: address space structure to write
@@ -2201,10 +2158,9 @@ retry:
        }
        if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
                mapping->writeback_index = index;
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
+
        if (wbc->range_cont)
                wbc->range_start = index << PAGE_CACHE_SHIFT;
-#endif
        return ret;
 }
 EXPORT_SYMBOL(extent_write_cache_pages);
@@ -2560,18 +2516,10 @@ static inline struct page *extent_buffer_page(struct extent_buffer *eb,
         * by increasing the reference count.  So we know the page must
         * be in the radix tree.
         */
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
        rcu_read_lock();
-#else
-       read_lock_irq(&mapping->tree_lock);
-#endif
        p = radix_tree_lookup(&mapping->page_tree, i);
-
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
        rcu_read_unlock();
-#else
-       read_unlock_irq(&mapping->tree_lock);
-#endif
+
        return p;
 }
 
@@ -2773,21 +2721,13 @@ int clear_extent_buffer_dirty(struct extent_io_tree *tree,
                        }
                }
                clear_page_dirty_for_io(page);
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
                spin_lock_irq(&page->mapping->tree_lock);
-#else
-               read_lock_irq(&page->mapping->tree_lock);
-#endif
                if (!PageDirty(page)) {
                        radix_tree_tag_clear(&page->mapping->page_tree,
                                                page_index(page),
                                                PAGECACHE_TAG_DIRTY);
                }
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
                spin_unlock_irq(&page->mapping->tree_lock);
-#else
-               read_unlock_irq(&page->mapping->tree_lock);
-#endif
                unlock_page(page);
        }
        return 0;

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 48a702d..8856570 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -871,15 +871,8 @@ static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
                goto out_nolock;
        if (count == 0)
                goto out_nolock;
-#ifdef REMOVE_SUID_PATH
-       err = remove_suid(&file->f_path);
-#else
-# if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
+
        err = file_remove_suid(file);
-# else
-       err = remove_suid(fdentry(file));
-# endif
-#endif
        if (err)
                goto out_nolock;
        file_update_time(file);
@@ -1003,17 +996,10 @@ out_nolock:
                        btrfs_commit_transaction(trans, root);
                }
        } else if (num_written > 0 && (file->f_flags & O_DIRECT)) {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
-               do_sync_file_range(file, start_pos,
-                                     start_pos + num_written - 1,
-                                     SYNC_FILE_RANGE_WRITE |
-                                     SYNC_FILE_RANGE_WAIT_AFTER);
-#else
                do_sync_mapping_range(inode->i_mapping, start_pos,
                                      start_pos + num_written - 1,
                                      SYNC_FILE_RANGE_WRITE |
                                      SYNC_FILE_RANGE_WAIT_AFTER);
-#endif
                invalidate_mapping_pages(inode->i_mapping,
                      start_pos >> PAGE_CACHE_SHIFT,
                     (start_pos + num_written - 1) >> PAGE_CACHE_SHIFT);
@@ -1097,12 +1083,7 @@ out:
 }
 
 static struct vm_operations_struct btrfs_file_vm_ops = {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
-       .nopage         = filemap_nopage,
-       .populate       = filemap_populate,
-#else
        .fault          = filemap_fault,
-#endif
        .page_mkwrite   = btrfs_page_mkwrite,
 };
 
@@ -1118,9 +1099,6 @@ struct file_operations btrfs_file_operations = {
        .read           = do_sync_read,
        .aio_read       = generic_file_aio_read,
        .splice_read    = generic_file_splice_read,
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
-       .sendfile       = generic_file_sendfile,
-#endif
        .write          = btrfs_file_write,
        .mmap           = btrfs_file_mmap,
        .open           = generic_file_open,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index adb169d..48a3dc0 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2073,104 +2073,6 @@ err:
        return ret;
 }
 
-/* Kernels earlier than 2.6.28 still have the NFS deadlock where nfsd
-   will call the file system's ->lookup() method from within its
-   filldir callback, which in turn was called from the file system's
-   ->readdir() method. And will deadlock for many file systems. */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
-
-struct nfshack_dirent {
-       u64             ino;
-       loff_t          offset;
-       int             namlen;
-       unsigned int    d_type;
-       char            name[];
-};
-
-struct nfshack_readdir {
-       char            *dirent;
-       size_t          used;
-       int             full;
-};
-
-
-
-static int btrfs_nfshack_filldir(void *__buf, const char *name, int namlen,
-                             loff_t offset, u64 ino, unsigned int d_type)
-{
-       struct nfshack_readdir *buf = __buf;
-       struct nfshack_dirent *de = (void *)(buf->dirent + buf->used);
-       unsigned int reclen;
-
-       reclen = ALIGN(sizeof(struct nfshack_dirent) + namlen, sizeof(u64));
-       if (buf->used + reclen > PAGE_SIZE) {
-               buf->full = 1;
-               return -EINVAL;
-       }
-
-       de->namlen = namlen;
-       de->offset = offset;
-       de->ino = ino;
-       de->d_type = d_type;
-       memcpy(de->name, name, namlen);
-       buf->used += reclen;
-
-       return 0;
-}
-
-static int btrfs_nfshack_readdir(struct file *file, void *dirent,
-                                filldir_t filldir)
-{
-       struct nfshack_readdir buf;
-       struct nfshack_dirent *de;
-       int err;
-       int size;
-       loff_t offset;
-
-       buf.dirent = (void *)__get_free_page(GFP_KERNEL);
-       if (!buf.dirent)
-               return -ENOMEM;
-
-       offset = file->f_pos;
-
-       do {
-               unsigned int reclen;
-
-               buf.used = 0;
-               buf.full = 0;
-               err = btrfs_real_readdir(file, &buf, btrfs_nfshack_filldir);
-               if (err)
-                       break;
-
-               size = buf.used;
-
-               if (!size)
-                       break;
-
-               de = (struct nfshack_dirent *)buf.dirent;
-               while (size > 0) {
-                       offset = de->offset;
-
-                       if (filldir(dirent, de->name, de->namlen, de->offset,
-                                   de->ino, de->d_type))
-                               goto done;
-                       offset = file->f_pos;
-
-                       reclen = ALIGN(sizeof(*de) + de->namlen,
-                                      sizeof(u64));
-                       size -= reclen;
-                       de = (struct nfshack_dirent *)((char *)de + reclen);
-               }
-       } while (buf.full);
-
- done:
-       free_page((unsigned long)buf.dirent);
-       file->f_pos = offset;
-
-       return err;
-}
-#endif
-
 int btrfs_write_inode(struct inode *inode, int wait)
 {
        struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -3311,13 +3213,8 @@ unsigned long btrfs_force_ra(struct address_space *mapping,
 {
        pgoff_t req_size = last_index - offset + 1;
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
-       offset = page_cache_readahead(mapping, ra, file, offset, req_size);
-       return offset;
-#else
        page_cache_sync_readahead(mapping, ra, file, offset, req_size);
        return offset + req_size;
-#endif
 }
 
 struct inode *btrfs_alloc_inode(struct super_block *sb)
@@ -3373,14 +3270,7 @@ void btrfs_destroy_inode(struct inode *inode)
        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
 }
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
 static void init_once(void *foo)
-#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
-static void init_once(struct kmem_cache * cachep, void *foo)
-#else
-static void init_once(void * foo, struct kmem_cache * cachep,
-                     unsigned long flags)
-#endif
 {
        struct btrfs_inode *ei = (struct btrfs_inode *) foo;
 
@@ -3403,22 +3293,10 @@ void btrfs_destroy_cachep(void)
 
 struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
                                       unsigned long extra_flags,
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
-                                      void (*ctor)(void *)
-#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
-                                      void (*ctor)(struct kmem_cache *, void *)
-#else
-                                      void (*ctor)(void *, struct kmem_cache *,
-                                                   unsigned long)
-#endif
-                                    )
+                                      void (*ctor)(void *))
 {
        return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
-                                SLAB_MEM_SPREAD | extra_flags), ctor
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
-                                ,NULL
-#endif
-                               );
+                                SLAB_MEM_SPREAD | extra_flags), ctor);
 }
 
 int btrfs_init_cachep(void)
@@ -3666,12 +3544,7 @@ static int btrfs_set_page_dirty(struct page *page)
        return __set_page_dirty_nobuffers(page);
 }
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
 static int btrfs_permission(struct inode *inode, int mask)
-#else
-static int btrfs_permission(struct inode *inode, int mask,
-                           struct nameidata *nd)
-#endif
 {
        if (btrfs_test_flag(inode, READONLY) && (mask & MAY_WRITE))
                return -EACCES;
@@ -3702,11 +3575,7 @@ static struct inode_operations btrfs_dir_ro_inode_operations = {
 static struct file_operations btrfs_dir_file_operations = {
        .llseek         = generic_file_llseek,
        .read           = generic_read_dir,
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
-       .readdir        = btrfs_nfshack_readdir,
-#else /* NFSd readdir/lookup deadlock is fixed */
        .readdir        = btrfs_real_readdir,
-#endif
        .unlocked_ioctl = btrfs_ioctl,
 #ifdef CONFIG_COMPAT
        .compat_ioctl   = btrfs_ioctl,

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index f7b3eac..8399d6d 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -349,10 +349,7 @@ static int btrfs_fill_super(struct super_block * sb,
 
        sb->s_root = root_dentry;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
        save_mount_options(sb, data);
-#endif
-
        return 0;
 
 fail_close:
@@ -566,11 +563,7 @@ static struct super_operations btrfs_super_ops = {
        .put_super      = btrfs_put_super,
        .write_super    = btrfs_write_super,
        .sync_fs        = btrfs_sync_fs,
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
-       .read_inode     = btrfs_read_locked_inode,
-#else
        .show_options   = generic_show_options,
-#endif
        .write_inode    = btrfs_write_inode,
        .dirty_inode    = btrfs_dirty_inode,
        .alloc_inode    = btrfs_alloc_inode,

diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c
index 61af5d8..300076e 100644 (file)
--- a/fs/btrfs/sysfs.c
+++ b/fs/btrfs/sysfs.c
@@ -28,7 +28,6 @@
 #include "disk-io.h"
 #include "transaction.h"
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 static ssize_t root_blocks_used_show(struct btrfs_root *root, char *buf)
 {
        return snprintf(buf, PAGE_SIZE, "%llu\n",
@@ -267,35 +266,3 @@ void btrfs_exit_sysfs(void)
        kset_unregister(btrfs_kset);
 }
 
-#else
-
-int btrfs_sysfs_add_super(struct btrfs_fs_info *fs)
-{
-       return 0;
-}
-
-int btrfs_sysfs_add_root(struct btrfs_root *root)
-{
-       return 0;
-}
-
-void btrfs_sysfs_del_root(struct btrfs_root *root)
-{
-       return;
-}
-
-void btrfs_sysfs_del_super(struct btrfs_fs_info *fs)
-{
-       return;
-}
-
-int btrfs_init_sysfs(void)
-{
-       return 0;
-}
-
-void btrfs_exit_sysfs(void)
-{
-       return;
-}
-#endif

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index b9e5c2d..ddf8962 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2080,20 +2080,11 @@ int btrfs_unplug_page(struct btrfs_mapping_tree *map_tree,
 }
 
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
 static void end_bio_multi_stripe(struct bio *bio, int err)
-#else
-static int end_bio_multi_stripe(struct bio *bio,
-                                  unsigned int bytes_done, int err)
-#endif
 {
        struct btrfs_multi_bio *multi = bio->bi_private;
        int is_orig_bio = 0;
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       if (bio->bi_size)
-               return 1;
-#endif
        if (err)
                atomic_inc(&multi->error);
 
@@ -2122,17 +2113,10 @@ static int end_bio_multi_stripe(struct bio *bio,
                }
                kfree(multi);
 
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-               bio_endio(bio, bio->bi_size, err);
-#else
                bio_endio(bio, err);
-#endif
        } else if (!is_orig_bio) {
                bio_put(bio);
        }
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-       return 0;
-#endif
 }
 
 struct async_sched {
@@ -2248,11 +2232,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
                } else {
                        bio->bi_bdev = root->fs_info->fs_devices->latest_bdev;
                        bio->bi_sector = logical >> 9;
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
-                       bio_endio(bio, bio->bi_size, -EIO);
-#else
                        bio_endio(bio, -EIO);
-#endif
                }
                dev_nr++;
        }