Avoid conflict between contrib/uuid and system uuid

glusterfs relies on Linux uuid implementation, which
API is incompatible with most other systems's uuid. As
a result, libglusterfs has to embed contrib/uuid,
which is the Linux implementation, on non Linux systems.
This implementation is incompatible with systtem's
built in, but the symbols have the same names.

Usually this is not a problem because when we link
with -lglusterfs, libc's symbols are trumped. However
there is a problem when a program not linked with
-lglusterfs will dlopen() glusterfs component. In
such a case, libc's uuid implementation is already
loaded in the calling program, and it will be used
instead of libglusterfs's implementation, causing
crashes.

A possible workaround is to use pre-load libglusterfs
in the calling program (using LD_PRELOAD on NetBSD for
instance), but such a mechanism is not portable, nor
is it flexible. A much better approach is to rename
libglusterfs's uuid_* functions to gf_uuid_* to avoid
any possible conflict. This is what this change attempts.

BUG: 1206587
Change-Id: I9ccd3e13afed1c7fc18508e92c7beb0f5d49f31a
Signed-off-by: Emmanuel Dreyfus <manu@netbsd.org>
Reviewed-on: http://review.gluster.org/10017
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>

5 files changed, 23 insertions, 23 deletions

diff --git a/xlators/cluster/ec/src/ec-combine.c b/xlators/cluster/ec/src/ec-combine.c
index a644d26ce82..709da555627 100644
--- a/xlators/cluster/ec/src/ec-combine.c
+++ b/xlators/cluster/ec/src/ec-combine.c
@@ -64,7 +64,7 @@ int32_t ec_iatt_combine(struct iatt * dst, struct iatt * src, int32_t count)
              (dst[i].ia_size != src[i].ia_size)) ||
             (st_mode_from_ia(dst[i].ia_prot, dst[i].ia_type) !=
              st_mode_from_ia(src[i].ia_prot, src[i].ia_type)) ||
-            (uuid_compare(dst[i].ia_gfid, src[i].ia_gfid) != 0))
+            (gf_uuid_compare(dst[i].ia_gfid, src[i].ia_gfid) != 0))
         {
             gf_log(THIS->name, GF_LOG_WARNING,
                    "Failed to combine iatt (inode: %lu-%lu, links: %u-%u, "
diff --git a/xlators/cluster/ec/src/ec-common.c b/xlators/cluster/ec/src/ec-common.c
index 1cae44fd0c9..7354277da1b 100644
--- a/xlators/cluster/ec/src/ec-common.c
+++ b/xlators/cluster/ec/src/ec-common.c
@@ -603,7 +603,7 @@ ec_lock_t * ec_lock_allocate(xlator_t * xl, int32_t kind, loc_t * loc)
     ec_lock_t * lock;
 
     if ((loc->inode == NULL) ||
-        (uuid_is_null(loc->gfid) && uuid_is_null(loc->inode->gfid)))
+        (gf_uuid_is_null(loc->gfid) && gf_uuid_is_null(loc->inode->gfid)))
     {
         gf_log(xl->name, GF_LOG_ERROR, "Trying to lock based on an invalid "
                                        "inode");
@@ -636,7 +636,7 @@ void ec_lock_destroy(ec_lock_t * lock)
 
 int32_t ec_lock_compare(ec_lock_t * lock1, ec_lock_t * lock2)
 {
-    return uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
+    return gf_uuid_compare(lock1->loc.gfid, lock2->loc.gfid);
 }
 
 ec_lock_link_t *ec_lock_insert(ec_fop_data_t *fop, ec_lock_t *lock,
@@ -1156,7 +1156,7 @@ void ec_get_size_version(ec_fop_data_t * fop)
         {
             goto out;
         }
-        if (uuid_is_null(loc.pargfid))
+        if (gf_uuid_is_null(loc.pargfid))
         {
             if (loc.parent != NULL)
             {
diff --git a/xlators/cluster/ec/src/ec-heal.c b/xlators/cluster/ec/src/ec-heal.c
index 6b513df8fe7..d82592d666e 100644
--- a/xlators/cluster/ec/src/ec-heal.c
+++ b/xlators/cluster/ec/src/ec-heal.c
@@ -357,7 +357,7 @@ int32_t ec_heal_create(ec_heal_t * heal, uintptr_t mask, int32_t try_link)
     {
         memset(&loc, 0, sizeof(loc));
         loc.inode = heal->loc.inode;
-        uuid_copy(loc.gfid, heal->iatt.ia_gfid);
+        gf_uuid_copy(loc.gfid, heal->iatt.ia_gfid);
 
         ec_link(heal->fop->frame, heal->xl, mask, EC_MINIMUM_ONE,
                 ec_heal_link_cbk, heal, &loc, &heal->loc, xdata);
@@ -717,7 +717,7 @@ void ec_heal_prepare_others(ec_heal_t * heal)
         else
         {
             if ((heal->iatt.ia_type != cbk->iatt[0].ia_type) ||
-                (uuid_compare(heal->iatt.ia_gfid, cbk->iatt[0].ia_gfid) != 0))
+                (gf_uuid_compare(heal->iatt.ia_gfid, cbk->iatt[0].ia_gfid) != 0))
             {
                 ec_heal_remove(heal, cbk);
             }
@@ -846,7 +846,7 @@ int32_t ec_heal_open_others(ec_heal_t * heal)
         cbk = list_entry(item, ec_cbk_data_t, list);
 
         if ((cbk->op_ret < 0) || (cbk->iatt[0].ia_type != IA_IFREG) ||
-            (uuid_compare(heal->iatt.ia_gfid, cbk->iatt[0].ia_gfid) != 0))
+            (gf_uuid_compare(heal->iatt.ia_gfid, cbk->iatt[0].ia_gfid) != 0))
         {
             ec_heal_exclude(heal, cbk->mask);
         }
@@ -1293,7 +1293,7 @@ ec_manager_heal (ec_fop_data_t * fop, int32_t state)
             heal = fop->heal;
             /* root loc doesn't have pargfid/parent */
             if (loc_is_root (&heal->loc) ||
-                !uuid_is_null(heal->loc.pargfid) || heal->loc.parent) {
+                !gf_uuid_is_null(heal->loc.pargfid) || heal->loc.parent) {
                     heal->nameheal = _gf_true;
                     return EC_STATE_DISPATCH;
             } else {
@@ -1332,7 +1332,7 @@ ec_manager_heal (ec_fop_data_t * fop, int32_t state)
                     return EC_STATE_HEAL_DISPATCH;
 
             /* Only heal data/metadata if enough information is supplied. */
-            if (uuid_is_null(heal->loc.gfid))
+            if (gf_uuid_is_null(heal->loc.gfid))
             {
                 ec_heal_entrylk(heal, ENTRYLK_UNLOCK);
 
diff --git a/xlators/cluster/ec/src/ec-heald.c b/xlators/cluster/ec/src/ec-heald.c
index 6b899414d4d..c4b896a5fb3 100644
--- a/xlators/cluster/ec/src/ec-heald.c
+++ b/xlators/cluster/ec/src/ec-heald.c
@@ -144,7 +144,7 @@ ec_shd_inode_find (xlator_t *this, xlator_t *subvol, uuid_t gfid)
         loc.inode = inode_new (this->itable);
         if (!loc.inode)
                 goto out;
-        uuid_copy (loc.gfid, gfid);
+        gf_uuid_copy (loc.gfid, gfid);
 
         ret = syncop_lookup (subvol, &loc, NULL, &iatt, NULL, NULL);
         if (ret < 0)
@@ -169,7 +169,7 @@ ec_shd_index_inode (xlator_t *this, xlator_t *subvol)
         void    *index_gfid = NULL;
 
         rootloc.inode = inode_ref (this->itable->root);
-        uuid_copy (rootloc.gfid, rootloc.inode->gfid);
+        gf_uuid_copy (rootloc.gfid, rootloc.inode->gfid);
 
         ret = syncop_getxattr (subvol, &rootloc, &xattr,
                                GF_XATTROP_INDEX_GFID, NULL);
@@ -234,7 +234,7 @@ ec_shd_index_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
         gf_log (healer->this->name, GF_LOG_DEBUG, "got entry: %s",
                 entry->d_name);
 
-        ret = uuid_parse (entry->d_name, loc.gfid);
+        ret = gf_uuid_parse (entry->d_name, loc.gfid);
         if (ret)
                 return 0;
 
@@ -301,7 +301,7 @@ ec_shd_full_heal (xlator_t *subvol, gf_dirent_t *entry, loc_t *parent,
 
         loc.parent = inode_ref (parent->inode);
         loc.name   = entry->d_name;
-        uuid_copy (loc.gfid, entry->d_stat.ia_gfid);
+        gf_uuid_copy (loc.gfid, entry->d_stat.ia_gfid);
 
         /* If this fails with ENOENT/ESTALE index is stale */
         ret = syncop_gfid_to_path (this->itable, subvol, loc.gfid,
diff --git a/xlators/cluster/ec/src/ec-helpers.c b/xlators/cluster/ec/src/ec-helpers.c
index 139957b55c6..65deba63959 100644
--- a/xlators/cluster/ec/src/ec-helpers.c
+++ b/xlators/cluster/ec/src/ec-helpers.c
@@ -256,19 +256,19 @@ int32_t ec_dict_del_config(dict_t * dict, char * key, ec_config_t * config)
 
 int32_t ec_loc_gfid_check(xlator_t * xl, uuid_t dst, uuid_t src)
 {
-    if (uuid_is_null(src))
+    if (gf_uuid_is_null(src))
     {
         return 1;
     }
 
-    if (uuid_is_null(dst))
+    if (gf_uuid_is_null(dst))
     {
-        uuid_copy(dst, src);
+        gf_uuid_copy(dst, src);
 
         return 1;
     }
 
-    if (uuid_compare(dst, src) != 0)
+    if (gf_uuid_compare(dst, src) != 0)
     {
         gf_log(xl->name, GF_LOG_WARNING, "Mismatching GFID's in loc");
 
@@ -287,7 +287,7 @@ int32_t ec_loc_setup_inode(xlator_t *xl, loc_t *loc)
             goto out;
         }
     } else if (loc->parent != NULL) {
-        if (!uuid_is_null(loc->gfid)) {
+        if (!gf_uuid_is_null(loc->gfid)) {
             loc->inode = inode_find(loc->parent->table, loc->gfid);
         } else if (loc->path && strchr (loc->path, '/')) {
             loc->inode = inode_resolve(loc->parent->table, (char *)loc->path);
@@ -310,7 +310,7 @@ int32_t ec_loc_setup_parent(xlator_t *xl, loc_t *loc)
             goto out;
         }
     } else if (loc->inode != NULL) {
-        if (!uuid_is_null(loc->pargfid)) {
+        if (!gf_uuid_is_null(loc->pargfid)) {
             loc->parent = inode_find(loc->inode->table, loc->pargfid);
         } else if (loc->path && strchr (loc->path, '/')) {
             path = gf_strdup(loc->path);
@@ -385,8 +385,8 @@ int32_t ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
     if (loc->parent != NULL) {
         parent->inode = inode_ref(loc->parent);
     }
-    if (!uuid_is_null(loc->pargfid)) {
-        uuid_copy(parent->gfid, loc->pargfid);
+    if (!gf_uuid_is_null(loc->pargfid)) {
+        gf_uuid_copy(parent->gfid, loc->pargfid);
     }
     if (loc->path && strchr (loc->path, '/')) {
         str = gf_strdup(loc->path);
@@ -412,7 +412,7 @@ int32_t ec_loc_parent(xlator_t *xl, loc_t *loc, loc_t *parent)
     }
 
     if ((parent->inode == NULL) && (parent->path == NULL) &&
-        uuid_is_null(parent->gfid)) {
+        gf_uuid_is_null(parent->gfid)) {
         gf_log(xl->name, GF_LOG_ERROR, "Parent inode missing for loc_t");
 
         goto out;
@@ -441,7 +441,7 @@ int32_t ec_loc_update(xlator_t *xl, loc_t *loc, inode_t *inode,
             inode_unref(loc->inode);
         }
         loc->inode = inode_ref(inode);
-        uuid_copy(loc->gfid, inode->gfid);
+        gf_uuid_copy(loc->gfid, inode->gfid);
     }
 
     if (iatt != NULL) {