Breakout BTRFS_SETGET_FUNCS into a separate C file, the inlines were too big.

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

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index a3b51085d7f0e61b4727fe651eb557d56a87e2e5..551743be5f032dcea3fdf9879c8fda81dfc30975 100644 (file)
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -5,7 +5,7 @@ obj-m  := btrfs.o
 btrfs-y := super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
           hash.o file-item.o inode-item.o inode-map.o disk-io.o \
           transaction.o bit-radix.o inode.o file.o tree-defrag.o \
-          extent_map.o sysfs.o
+          extent_map.o sysfs.o struct-funcs.o
 
 #btrfs-y := ctree.o disk-io.o radix-tree.o extent-tree.o print-tree.o \
 #        root-tree.o dir-item.o hash.o file-item.o inode-item.o \

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 54a5d006c5623a2175e5ef7f60e88de101a77b07..0c6ed17ac1bcca9d5648b8dd0a4f481f41a4ef48 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -16,7 +16,6 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#include <linux/highmem.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index a942a242722841f931390d7a1bfe3d3c6db89169..d1c6f023a3027e3a07562bd10500803fe5b9c04e 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -426,77 +426,11 @@ struct btrfs_root {
                            offsetof(type, member),                     \
                           sizeof(((type *)0)->member)))
 
+#ifndef BTRFS_SETGET_FUNCS
 #define BTRFS_SETGET_FUNCS(name, type, member, bits)                   \
-static inline u##bits btrfs_##name(struct extent_buffer *eb,           \
-                                  type *s)                             \
-{                                                                      \
-       int err;                                                        \
-       char *map_token;                                                \
-       char *kaddr;                                                    \
-       int unmap_on_exit = (eb->map_token == NULL);                    \
-       unsigned long map_start;                                        \
-       unsigned long map_len;                                          \
-       unsigned long offset = (unsigned long)s +                       \
-                               offsetof(type, member);                 \
-       if (eb->map_token && offset >= eb->map_start &&                 \
-           offset + sizeof(((type *)0)->member) <= eb->map_start +     \
-           eb->map_len) {                                              \
-           kaddr = eb->kaddr;                                          \
-           map_start = eb->map_start;                                  \
-           err = 0;                                                    \
-       } else {                                                        \
-               err = map_extent_buffer(eb, offset,                     \
-                               sizeof(((type *)0)->member),            \
-                               &map_token, &kaddr,                     \
-                               &map_start, &map_len, KM_USER1);        \
-       }                                                               \
-       if (!err) {                                                     \
-               __le##bits *tmp = (__le##bits *)(kaddr + offset -       \
-                                              map_start);              \
-               u##bits res = le##bits##_to_cpu(*tmp);                  \
-               if (unmap_on_exit)                                      \
-                       unmap_extent_buffer(eb, map_token, KM_USER1);   \
-               return res;                                             \
-       } else {                                                        \
-               __le##bits res;                                         \
-               read_eb_member(eb, s, type, member, &res);              \
-               return le##bits##_to_cpu(res);                          \
-       }                                                               \
-}                                                                      \
-static inline void btrfs_set_##name(struct extent_buffer *eb,          \
-                                   type *s, u##bits val)               \
-{                                                                      \
-       int err;                                                        \
-       char *map_token;                                                \
-       char *kaddr;                                                    \
-       unsigned long map_start;                                        \
-       unsigned long map_len;                                          \
-       int unmap_on_exit = (eb->map_token == NULL);                    \
-       unsigned long offset = (unsigned long)s +                       \
-                               offsetof(type, member);                 \
-       if (eb->map_token && offset >= eb->map_start &&                 \
-           offset + sizeof(((type *)0)->member) <= eb->map_start +     \
-           eb->map_len) {                                              \
-           kaddr = eb->kaddr;                                          \
-           map_start = eb->map_start;                                  \
-           err = 0;                                                    \
-       } else {                                                        \
-               err = map_extent_buffer(eb, offset,                     \
-                               sizeof(((type *)0)->member),            \
-                               &map_token, &kaddr,                     \
-                               &map_start, &map_len, KM_USER1);        \
-       }                                                               \
-       if (!err) {                                                     \
-               __le##bits *tmp = (__le##bits *)(kaddr + offset -       \
-                                              map_start);              \
-               *tmp = cpu_to_le##bits(val);                            \
-               if (unmap_on_exit)                                      \
-                       unmap_extent_buffer(eb, map_token, KM_USER1);   \
-       } else {                                                        \
-               val = cpu_to_le##bits(val);                             \
-               write_eb_member(eb, s, type, member, &val);             \
-       }                                                               \
-}
+u##bits btrfs_##name(struct extent_buffer *eb, type *s);               \
+void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
+#endif
 
 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)            \
 static inline u##bits btrfs_##name(struct extent_buffer *eb)           \

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 525fa845d613082bed862bf2efbb1e7f84bc5a22..e4e68ea96483448808eaed53f7f731386a8590ec 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -1443,7 +1443,7 @@ int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
        for (i = 0; i <= orig_level; i++) {
                if (path->nodes[i]) {
                        free_extent_buffer(path->nodes[i]);
-                       path->nodes[i] = 0;
+                       path->nodes[i] = NULL;
                }
        }
 out:

diff --git a/fs/btrfs/struct-funcs.c b/fs/btrfs/struct-funcs.c
new file mode 100644 (file)
index 0000000..cf68fcf
--- /dev/null
+++ b/fs/btrfs/struct-funcs.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2007 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include <linux/highmem.h>
+#define BTRFS_SETGET_FUNCS(name, type, member, bits)                   \
+u##bits btrfs_##name(struct extent_buffer *eb,                         \
+                                  type *s)                             \
+{                                                                      \
+       unsigned long offset = (unsigned long)s +                       \
+                               offsetof(type, member);                 \
+       __le##bits *tmp;                                                \
+       /* ugly, but we want the fast path here */                      \
+       if (eb->map_token && offset >= eb->map_start &&                 \
+           offset + sizeof(((type *)0)->member) <= eb->map_start +     \
+           eb->map_len) {                                              \
+               tmp = (__le##bits *)(eb->kaddr + offset -               \
+                                    eb->map_start);                    \
+               return le##bits##_to_cpu(*tmp);                         \
+       }                                                               \
+       {                                                               \
+               int err;                                                \
+               char *map_token;                                        \
+               char *kaddr;                                            \
+               int unmap_on_exit = (eb->map_token == NULL);            \
+               unsigned long map_start;                                \
+               unsigned long map_len;                                  \
+               __le##bits res;                                         \
+               err = map_extent_buffer(eb, offset,                     \
+                               sizeof(((type *)0)->member),            \
+                               &map_token, &kaddr,                     \
+                               &map_start, &map_len, KM_USER1);        \
+               if (err) {                                              \
+                       read_eb_member(eb, s, type, member, &res);      \
+                       return le##bits##_to_cpu(res);                  \
+               }                                                       \
+               tmp = (__le##bits *)(kaddr + offset - map_start);       \
+               res = le##bits##_to_cpu(*tmp);                          \
+               if (unmap_on_exit)                                      \
+                       unmap_extent_buffer(eb, map_token, KM_USER1);   \
+               return res;                                             \
+       }                                                               \
+}                                                                      \
+void btrfs_set_##name(struct extent_buffer *eb,                                \
+                                   type *s, u##bits val)               \
+{                                                                      \
+       unsigned long offset = (unsigned long)s +                       \
+                               offsetof(type, member);                 \
+       __le##bits *tmp;                                                \
+       /* ugly, but we want the fast path here */                      \
+       if (eb->map_token && offset >= eb->map_start &&                 \
+           offset + sizeof(((type *)0)->member) <= eb->map_start +     \
+           eb->map_len) {                                              \
+               tmp = (__le##bits *)(eb->kaddr + offset -               \
+                                    eb->map_start);                    \
+               *tmp = cpu_to_le##bits(val);                            \
+               return;                                                 \
+       }                                                               \
+       {                                                               \
+               int err;                                                \
+               char *map_token;                                        \
+               char *kaddr;                                            \
+               int unmap_on_exit = (eb->map_token == NULL);            \
+               unsigned long map_start;                                \
+               unsigned long map_len;                                  \
+               err = map_extent_buffer(eb, offset,                     \
+                               sizeof(((type *)0)->member),            \
+                               &map_token, &kaddr,                     \
+                               &map_start, &map_len, KM_USER1);        \
+               if (err) {                                              \
+                       val = cpu_to_le##bits(val);                     \
+                       write_eb_member(eb, s, type, member, &val);     \
+                       return;                                         \
+               }                                                       \
+               tmp = (__le##bits *)(kaddr + offset - map_start);       \
+               *tmp = cpu_to_le##bits(val);                            \
+               if (unmap_on_exit)                                      \
+                       unmap_extent_buffer(eb, map_token, KM_USER1);   \
+       }                                                               \
+}
+
+#include "ctree.h"
+

diff --git a/fs/btrfs/tree-defrag.c b/fs/btrfs/tree-defrag.c
index d23216aa4ab5a4b2e4a2e8c62a6eeaef8c458c62..0d1a1be0995cdbbd45fb8c1d994ce60d806c0527 100644 (file)
--- a/fs/btrfs/tree-defrag.c
+++ b/fs/btrfs/tree-defrag.c
@@ -239,7 +239,7 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
        for (i = 0; i <= orig_level; i++) {
                if (path->nodes[i]) {
                        free_extent_buffer(path->nodes[i]);
-                       path->nodes[i] = 0;
+                       path->nodes[i] = NULL;
                }
        }
 out: