BUG();
        }
 
-       size = __btrfs_getxattr(inode, name, "", 0);
+       size = btrfs_getxattr(inode, name, "", 0);
        if (size > 0) {
                value = kzalloc(size, GFP_KERNEL);
                if (!value)
                        return ERR_PTR(-ENOMEM);
-               size = __btrfs_getxattr(inode, name, value, size);
+               size = btrfs_getxattr(inode, name, value, size);
        }
        if (size > 0) {
                acl = posix_acl_from_xattr(&init_user_ns, value, size);
                        goto out;
        }
 
-       ret = __btrfs_setxattr(trans, inode, name, value, size, 0);
+       ret = btrfs_setxattr(trans, inode, name, value, size, 0);
 out:
        kfree(value);
 
 
                return -EINVAL;
 
        if (value_len == 0) {
-               ret = __btrfs_setxattr(trans, inode, handler->xattr_name,
+               ret = btrfs_setxattr(trans, inode, handler->xattr_name,
                                       NULL, 0, flags);
                if (ret)
                        return ret;
        ret = handler->validate(value, value_len);
        if (ret)
                return ret;
-       ret = __btrfs_setxattr(trans, inode, handler->xattr_name,
+       ret = btrfs_setxattr(trans, inode, handler->xattr_name,
                               value, value_len, flags);
        if (ret)
                return ret;
        ret = handler->apply(inode, value, value_len);
        if (ret) {
-               __btrfs_setxattr(trans, inode, handler->xattr_name,
+               btrfs_setxattr(trans, inode, handler->xattr_name,
                                 NULL, 0, flags);
                return ret;
        }
 
 #include "locking.h"
 
 
-ssize_t __btrfs_getxattr(struct inode *inode, const char *name,
+ssize_t btrfs_getxattr(struct inode *inode, const char *name,
                                void *buffer, size_t size)
 {
        struct btrfs_dir_item *di;
 /*
  * @value: "" makes the attribute to empty, NULL removes it
  */
-int __btrfs_setxattr(struct btrfs_trans_handle *trans,
+int btrfs_setxattr(struct btrfs_trans_handle *trans,
                     struct inode *inode, const char *name,
                     const void *value, size_t size, int flags)
 {
                                   const char *name, void *buffer, size_t size)
 {
        name = xattr_full_name(handler, name);
-       return __btrfs_getxattr(inode, name, buffer, size);
+       return btrfs_getxattr(inode, name, buffer, size);
 }
 
 static int btrfs_xattr_handler_set(const struct xattr_handler *handler,
                                   size_t size, int flags)
 {
        name = xattr_full_name(handler, name);
-       return __btrfs_setxattr(NULL, inode, name, buffer, size, flags);
+       return btrfs_setxattr(NULL, inode, name, buffer, size, flags);
 }
 
 static int btrfs_xattr_handler_set_prop(const struct xattr_handler *handler,
                }
                strcpy(name, XATTR_SECURITY_PREFIX);
                strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
-               err = __btrfs_setxattr(trans, inode, name,
-                                      xattr->value, xattr->value_len, 0);
+               err = btrfs_setxattr(trans, inode, name, xattr->value,
+                               xattr->value_len, 0);
                kfree(name);
                if (err < 0)
                        break;
 
 
 extern const struct xattr_handler *btrfs_xattr_handlers[];
 
-extern ssize_t __btrfs_getxattr(struct inode *inode, const char *name,
+extern ssize_t btrfs_getxattr(struct inode *inode, const char *name,
                void *buffer, size_t size);
-extern int __btrfs_setxattr(struct btrfs_trans_handle *trans,
+extern int btrfs_setxattr(struct btrfs_trans_handle *trans,
                            struct inode *inode, const char *name,
                            const void *value, size_t size, int flags);