kclient: prefix frag_ functions with ceph_

It was suggested this would avoid any potential conflict with TCP.
It's a good idea to keep the namespace clean anyway.

diff --git a/src/include/ceph_fs.h b/src/include/ceph_fs.h
index 5ee7f546b047f20c000df9a376f8e4e5528d630e..06a901ea9a78bacef79cd1f86420ab15abb072b9 100644 (file)
--- a/src/include/ceph_fs.h
+++ b/src/include/ceph_fs.h
@@ -66,102 +66,102 @@
  * can't sort encoded frags numerically.  However, it does allow you
  * to feed encoded frags as values into frag_contains_value.
  */
-static inline __u32 frag_make(__u32 b, __u32 v)
+static inline __u32 ceph_frag_make(__u32 b, __u32 v)
 {
        return (b << 24) |
                (v & (0xffffffu << (24-b)) & 0xffffffu);
 }
-static inline __u32 frag_bits(__u32 f)
+static inline __u32 ceph_frag_bits(__u32 f)
 {
        return f >> 24;
 }
-static inline __u32 frag_value(__u32 f)
+static inline __u32 ceph_frag_value(__u32 f)
 {
        return f & 0xffffffu;
 }
-static inline __u32 frag_mask(__u32 f)
+static inline __u32 ceph_frag_mask(__u32 f)
 {
-       return (0xffffffu << (24-frag_bits(f))) & 0xffffffu;
+       return (0xffffffu << (24-ceph_frag_bits(f))) & 0xffffffu;
 }
-static inline __u32 frag_mask_shift(__u32 f)
+static inline __u32 ceph_frag_mask_shift(__u32 f)
 {
-       return 24 - frag_bits(f);
+       return 24 - ceph_frag_bits(f);
 }
 
-static inline int frag_contains_value(__u32 f, __u32 v)
+static inline int ceph_frag_contains_value(__u32 f, __u32 v)
 {
-       return (v & frag_mask(f)) == frag_value(f);
+       return (v & ceph_frag_mask(f)) == ceph_frag_value(f);
 }
-static inline int frag_contains_frag(__u32 f, __u32 sub)
+static inline int ceph_frag_contains_frag(__u32 f, __u32 sub)
 {
        /* is sub as specific as us, and contained by us? */
-       return frag_bits(sub) >= frag_bits(f) &&
-               (frag_value(sub) & frag_mask(f)) == frag_value(f);
+       return ceph_frag_bits(sub) >= ceph_frag_bits(f) &&
+              (ceph_frag_value(sub) & ceph_frag_mask(f)) == ceph_frag_value(f);
 }
 
-static inline __u32 frag_parent(__u32 f)
+static inline __u32 ceph_frag_parent(__u32 f)
 {
-       return frag_make(frag_bits(f) - 1,
-                        frag_value(f) & (frag_mask(f) << 1));
+       return ceph_frag_make(ceph_frag_bits(f) - 1,
+                        ceph_frag_value(f) & (ceph_frag_mask(f) << 1));
 }
-static inline int frag_is_left_child(__u32 f)
+static inline int ceph_frag_is_left_child(__u32 f)
 {
-       return frag_bits(f) > 0 &&
-               (frag_value(f) & (0x1000000 >> frag_bits(f))) == 0;
+       return ceph_frag_bits(f) > 0 &&
+               (ceph_frag_value(f) & (0x1000000 >> ceph_frag_bits(f))) == 0;
 }
-static inline int frag_is_right_child(__u32 f)
+static inline int ceph_frag_is_right_child(__u32 f)
 {
-       return frag_bits(f) > 0 &&
-               (frag_value(f) & (0x1000000 >> frag_bits(f))) == 1;
+       return ceph_frag_bits(f) > 0 &&
+               (ceph_frag_value(f) & (0x1000000 >> ceph_frag_bits(f))) == 1;
 }
-static inline __u32 frag_sibling(__u32 f)
+static inline __u32 ceph_frag_sibling(__u32 f)
 {
-       return frag_make(frag_bits(f),
-                        frag_value(f) ^ (0x1000000 >> frag_bits(f)));
+       return ceph_frag_make(ceph_frag_bits(f),
+                     ceph_frag_value(f) ^ (0x1000000 >> ceph_frag_bits(f)));
 }
-static inline __u32 frag_left_child(__u32 f)
+static inline __u32 ceph_frag_left_child(__u32 f)
 {
-       return frag_make(frag_bits(f)+1, frag_value(f));
+       return ceph_frag_make(ceph_frag_bits(f)+1, ceph_frag_value(f));
 }
-static inline __u32 frag_right_child(__u32 f)
+static inline __u32 ceph_frag_right_child(__u32 f)
 {
-       return frag_make(frag_bits(f)+1,
-                        frag_value(f) | (0x1000000 >> (1+frag_bits(f))));
+       return ceph_frag_make(ceph_frag_bits(f)+1,
+             ceph_frag_value(f) | (0x1000000 >> (1+ceph_frag_bits(f))));
 }
-static inline __u32 frag_make_child(__u32 f, int by, int i)
+static inline __u32 ceph_frag_make_child(__u32 f, int by, int i)
 {
-       int newbits = frag_bits(f) + by;
-       return frag_make(newbits,
-                        frag_value(f) | (i << (24 - newbits)));
+       int newbits = ceph_frag_bits(f) + by;
+       return ceph_frag_make(newbits,
+                        ceph_frag_value(f) | (i << (24 - newbits)));
 }
-static inline int frag_is_leftmost(__u32 f)
+static inline int ceph_frag_is_leftmost(__u32 f)
 {
-       return frag_value(f) == 0;
+       return ceph_frag_value(f) == 0;
 }
-static inline int frag_is_rightmost(__u32 f)
+static inline int ceph_frag_is_rightmost(__u32 f)
 {
-       return frag_value(f) == frag_mask(f);
+       return ceph_frag_value(f) == ceph_frag_mask(f);
 }
-static inline __u32 frag_next(__u32 f)
+static inline __u32 ceph_frag_next(__u32 f)
 {
-       return frag_make(frag_bits(f),
-                        frag_value(f) + (0x1000000 >> frag_bits(f)));
+       return ceph_frag_make(ceph_frag_bits(f),
+                        ceph_frag_value(f) + (0x1000000 >> ceph_frag_bits(f)));
 }
 
 /*
  * comparator to sort frags logically, as when traversing the
  * number space in ascending order...
  */
-static inline int frag_compare(__u32 a, __u32 b)
+static inline int ceph_frag_compare(__u32 a, __u32 b)
 {
-       unsigned va = frag_value(a);
-       unsigned vb = frag_value(b);
+       unsigned va = ceph_frag_value(a);
+       unsigned vb = ceph_frag_value(b);
        if (va < vb)
                return -1;
        if (va > vb)
                return 1;
-       va = frag_bits(a);
-       vb = frag_bits(b);
+       va = ceph_frag_bits(a);
+       vb = ceph_frag_bits(b);
        if (va < vb)
                return -1;
        if (va > vb)

diff --git a/src/include/frag.h b/src/include/frag.h
index 07d7fa1dd4b4ab962f32ff9a1583a25e5c4382e9..f5d3dc78b32dcb6161d66bb687daeb58e4a1e804 100644 (file)
--- a/src/include/frag.h
+++ b/src/include/frag.h
@@ -77,33 +77,33 @@ class frag_t {
   _frag_t _enc;  
   
   frag_t() : _enc(0) { }
-  frag_t(unsigned v, unsigned b) : _enc(frag_make(b, v)) { }
+  frag_t(unsigned v, unsigned b) : _enc(ceph_frag_make(b, v)) { }
   frag_t(_frag_t e) : _enc(e) { }
 
   // constructors
   void from_unsigned(unsigned e) { _enc = e; }
   
   // accessors
-  unsigned value() const { return frag_value(_enc); }
-  unsigned bits() const { return frag_bits(_enc); }
-  unsigned mask() const { return frag_mask(_enc); }
-  unsigned mask_shift() const { return frag_mask_shift(_enc); }
+  unsigned value() const { return ceph_frag_value(_enc); }
+  unsigned bits() const { return ceph_frag_bits(_enc); }
+  unsigned mask() const { return ceph_frag_mask(_enc); }
+  unsigned mask_shift() const { return ceph_frag_mask_shift(_enc); }
 
   operator _frag_t() const { return _enc; }
 
   // tests
-  bool contains(unsigned v) const { return frag_contains_value(_enc, v); }
-  bool contains(frag_t sub) const { return frag_contains_frag(_enc, sub._enc); }
+  bool contains(unsigned v) const { return ceph_frag_contains_value(_enc, v); }
+  bool contains(frag_t sub) const { return ceph_frag_contains_frag(_enc, sub._enc); }
   bool is_root() const { return bits() == 0; }
   frag_t parent() const {
     assert(bits() > 0);
-    return frag_t(frag_parent(_enc));
+    return frag_t(ceph_frag_parent(_enc));
   }
 
   // splitting
   frag_t make_child(int i, int nb) const {
     assert(i < (1<<nb));
-    return frag_t(frag_make_child(_enc, nb, i));
+    return frag_t(ceph_frag_make_child(_enc, nb, i));
   }
   void split(int nb, std::list<frag_t>& fragments) const {
     assert(nb > 0);
@@ -113,22 +113,22 @@ class frag_t {
   }
 
   // binary splitting
-  frag_t left_child() const { return frag_t(frag_left_child(_enc)); }
-  frag_t right_child() const { return frag_t(frag_right_child(_enc)); }
+  frag_t left_child() const { return frag_t(ceph_frag_left_child(_enc)); }
+  frag_t right_child() const { return frag_t(ceph_frag_right_child(_enc)); }
 
-  bool is_left() const { return frag_is_left_child(_enc); }
-  bool is_right() const { return frag_is_right_child(_enc); }
+  bool is_left() const { return ceph_frag_is_left_child(_enc); }
+  bool is_right() const { return ceph_frag_is_right_child(_enc); }
   frag_t get_sibling() const {
     assert(!is_root());
-    return frag_t(frag_sibling(_enc));
+    return frag_t(ceph_frag_sibling(_enc));
   }
 
   // sequencing
-  bool is_leftmost() const { return frag_is_leftmost(_enc); }
-  bool is_rightmost() const { return frag_is_rightmost(_enc); }
+  bool is_leftmost() const { return ceph_frag_is_leftmost(_enc); }
+  bool is_rightmost() const { return ceph_frag_is_rightmost(_enc); }
   frag_t next() const {
     assert(!is_rightmost());
-    return frag_t(frag_next(_enc));
+    return frag_t(ceph_frag_next(_enc));
   }
 };
 

diff --git a/src/kernel/dir.c b/src/kernel/dir.c
index 294bbb4de25c376f748f89f2a059327ee7e31ac4..41eb9f5382a09f410c1d37598d2c4cb5c7b10e49 100644 (file)
--- a/src/kernel/dir.c
+++ b/src/kernel/dir.c
@@ -264,7 +264,7 @@ more:
                req->r_dentry = dget(filp->f_dentry);
                /* hints to request -> mds selection code */
                req->r_direct_mode = USE_AUTH_MDS;
-               req->r_direct_hash = frag_value(frag);
+               req->r_direct_hash = ceph_frag_value(frag);
                req->r_direct_is_hash = true;
                req->r_path2 = kstrdup(fi->last_name, GFP_NOFS);
                req->r_readdir_offset = fi->next_offset;
@@ -338,8 +338,8 @@ more:
        }
 
        /* more frags? */
-       if (!frag_is_rightmost(frag)) {
-               frag = frag_next(frag);
+       if (!ceph_frag_is_rightmost(frag)) {
+               frag = ceph_frag_next(frag);
                off = 0;
                filp->f_pos = ceph_make_fpos(frag, off);
                dout("readdir next frag is %x\n", frag);

diff --git a/src/kernel/inode.c b/src/kernel/inode.c
index 43031b0d38ed76222a2464d1fc985fe3a1ff948f..96362268e8e665878adb7debfcbc176a3c22d8d5 100644 (file)
--- a/src/kernel/inode.c
+++ b/src/kernel/inode.c
@@ -109,7 +109,7 @@ static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci,
        while (*p) {
                parent = *p;
                frag = rb_entry(parent, struct ceph_inode_frag, node);
-               c = frag_compare(f, frag->frag);
+               c = ceph_frag_compare(f, frag->frag);
                if (c < 0)
                        p = &(*p)->rb_left;
                else if (c > 0)
@@ -147,7 +147,7 @@ u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
                     struct ceph_inode_frag *pfrag,
                     int *found)
 {
-       u32 t = frag_make(0, 0);
+       u32 t = ceph_frag_make(0, 0);
        struct ceph_inode_frag *frag;
        unsigned nway, i;
        u32 n;
@@ -157,7 +157,7 @@ u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
 
        mutex_lock(&ci->i_fragtree_mutex);
        while (1) {
-               WARN_ON(!frag_contains_value(t, v));
+               WARN_ON(!ceph_frag_contains_value(t, v));
                frag = __ceph_find_frag(ci, t);
                if (!frag)
                        break; /* t is a leaf */
@@ -174,8 +174,8 @@ u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
                dout("choose_frag(%x) %x splits by %d (%d ways)\n", v, t,
                     frag->split_by, nway);
                for (i = 0; i < nway; i++) {
-                       n = frag_make_child(t, frag->split_by, i);
-                       if (frag_contains_value(n, v)) {
+                       n = ceph_frag_make_child(t, frag->split_by, i);
+                       if (ceph_frag_contains_value(n, v)) {
                                t = n;
                                break;
                        }

diff --git a/src/kernel/super.h b/src/kernel/super.h
index 2753b10a4df388222f2fe58d4882569a60562731..ad54e7e764ae795c45f770379a2adc28b6606fb6 100644 (file)
--- a/src/kernel/super.h
+++ b/src/kernel/super.h
@@ -405,7 +405,7 @@ __ceph_find_frag(struct ceph_inode_info *ci, u32 f)
        while (n) {
                struct ceph_inode_frag *frag =
                        rb_entry(n, struct ceph_inode_frag, node);
-               int c = frag_compare(f, frag->frag);
+               int c = ceph_frag_compare(f, frag->frag);
                if (c < 0)
                        n = n->rb_left;
                else if (c > 0)