summaryrefslogtreecommitdiffstats
path: root/xlators
diff options
context:
space:
mode:
Diffstat (limited to 'xlators')
-rw-r--r--xlators/storage/Makefile.am5
-rw-r--r--xlators/storage/bd_map/Makefile.am3
-rw-r--r--xlators/storage/bd_map/src/Makefile.am21
-rw-r--r--xlators/storage/bd_map/src/bd_map.c896
-rw-r--r--xlators/storage/bd_map/src/bd_map.h75
-rw-r--r--xlators/storage/bd_map/src/bd_map_help.c462
-rw-r--r--xlators/storage/bd_map/src/bd_map_help.h63
7 files changed, 1524 insertions, 1 deletions
diff --git a/xlators/storage/Makefile.am b/xlators/storage/Makefile.am
index 9cb9ded3035..e1316a12702 100644
--- a/xlators/storage/Makefile.am
+++ b/xlators/storage/Makefile.am
@@ -1,3 +1,6 @@
SUBDIRS = posix
-CLEANFILES =
+if ENABLE_BD_XLATOR
+SUBDIRS += bd_map
+endif
+CLEANFILES =
diff --git a/xlators/storage/bd_map/Makefile.am b/xlators/storage/bd_map/Makefile.am
new file mode 100644
index 00000000000..a985f42a877
--- /dev/null
+++ b/xlators/storage/bd_map/Makefile.am
@@ -0,0 +1,3 @@
+SUBDIRS = src
+
+CLEANFILES =
diff --git a/xlators/storage/bd_map/src/Makefile.am b/xlators/storage/bd_map/src/Makefile.am
new file mode 100644
index 00000000000..be43d2abb5b
--- /dev/null
+++ b/xlators/storage/bd_map/src/Makefile.am
@@ -0,0 +1,21 @@
+
+if ENABLE_BD_XLATOR
+xlator_LTLIBRARIES = bd_map.la
+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/storage
+
+bd_map_la_LDFLAGS = -module -avoidversion
+LIBBD = -llvm2app -lrt
+bd_map_la_SOURCES = bd_map.c bd_map_help.c
+bd_map_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la $(LIBBD)
+
+noinst_HEADERS = bd_map.h bd_map_help.h
+
+AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \
+ -I$(top_srcdir)/rpc/xdr/src \
+ -I$(top_srcdir)/rpc/rpc-lib/src
+
+AM_CFLAGS = -fno-strict-aliasing -Wall $(GF_CFLAGS)
+
+CLEANFILES =
+
+endif
diff --git a/xlators/storage/bd_map/src/bd_map.c b/xlators/storage/bd_map/src/bd_map.c
new file mode 100644
index 00000000000..e7a684c556d
--- /dev/null
+++ b/xlators/storage/bd_map/src/bd_map.c
@@ -0,0 +1,896 @@
+/*
+ BD translator - Exports Block devices on server side as regular
+ files to client
+
+ Now only exporting Logical volumes supported.
+
+ Copyright IBM, Corp. 2012
+
+ This file is part of GlusterFS.
+
+ Author:
+ M. Mohan Kumar <mohan@in.ibm.com>
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include <time.h>
+#include <lvm2app.h>
+#include <openssl/md5.h>
+
+#include "bd_map.h"
+#include "bd_map_help.h"
+#include "defaults.h"
+#include "glusterfs3-xdr.h"
+
+
+/* Regular fops */
+
+int32_t
+bd_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
+{
+ struct iatt buf = {0, };
+ int32_t op_ret = -1;
+ int32_t entry_ret = 0;
+ int32_t op_errno = 0;
+ char *pathdup = NULL;
+ bd_entry_t *bdentry = NULL;
+ struct iatt postparent = {0, };
+ bd_priv_t *priv = NULL;
+ char *p = NULL;
+
+ VALIDATE_OR_GOTO (frame, out);
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (loc, out);
+ VALIDATE_OR_GOTO (loc->path, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ BD_ENTRY (priv, bdentry, loc->path);
+ if (!bdentry) {
+ op_errno = ENOENT;
+ entry_ret = -1;
+ goto parent;
+ }
+ memcpy (&buf, bdentry->attr, sizeof(buf));
+ BD_PUT_ENTRY (priv, bdentry);
+
+parent:
+ if (loc->parent) {
+ pathdup = p = gf_strdup (loc->path);
+ if (!pathdup) {
+ op_errno = ENOMEM;
+ entry_ret = -1;
+ goto out;
+ }
+ p = strrchr (pathdup, '/');
+ if (p == pathdup)
+ *(p+1) = '\0';
+ else
+ *p = '\0';
+ BD_ENTRY (priv, bdentry, pathdup);
+ if (!bdentry) {
+ op_errno = ENOENT;
+ gf_log (this->name, GF_LOG_ERROR,
+ "post-operation lookup on parent of %s "
+ "failed: %s",
+ loc->path, strerror (op_errno));
+ goto out;
+ }
+ memcpy (&postparent, bdentry->attr, sizeof(postparent));
+ BD_PUT_ENTRY (priv, bdentry);
+ }
+
+ op_ret = entry_ret;
+out:
+ if (pathdup)
+ GF_FREE (pathdup);
+
+ STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno,
+ (loc)?loc->inode:NULL, &buf, NULL, &postparent);
+
+ return 0;
+}
+
+int32_t
+bd_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
+{
+ struct iatt buf = {0,};
+ int32_t op_ret = -1;
+ int32_t op_errno = 0;
+ bd_entry_t *bdentry = NULL;
+ bd_priv_t *priv = NULL;
+
+ VALIDATE_OR_GOTO (frame, out);
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (loc, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ BD_ENTRY (priv, bdentry, loc->path);
+ if (!bdentry) {
+ op_errno = ENOENT;
+ gf_log (this->name, GF_LOG_ERROR, "stat on %s failed: %s",
+ loc->path, strerror (op_errno));
+ goto out;
+ }
+ memcpy (&buf, bdentry->attr, sizeof(buf));
+ BD_PUT_ENTRY (priv, bdentry);
+ op_ret = 0;
+
+out:
+ STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, &buf, NULL);
+
+ return 0;
+}
+
+int32_t
+bd_opendir (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, fd_t *fd, dict_t *xdata)
+{
+ int32_t op_ret = -1;
+ int32_t op_errno = EINVAL;
+ bd_fd_t *bd_fd = NULL;
+ bd_entry_t *bdentry = NULL;
+ bd_priv_t *priv = NULL;
+
+ VALIDATE_OR_GOTO (frame, out);
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (loc, out);
+ VALIDATE_OR_GOTO (loc->path, out);
+ VALIDATE_OR_GOTO (fd, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ BD_ENTRY (priv, bdentry, loc->path);
+ if (!bdentry) {
+ op_errno = ENOENT;
+ gf_log (this->name, GF_LOG_ERROR, "opendir failed on %s: %s",
+ loc->path, strerror (op_errno));
+ goto out;
+ }
+ bd_fd = GF_CALLOC (1, sizeof(*bd_fd), gf_bd_fd);
+ if (!bd_fd) {
+ op_errno = errno;
+ BD_PUT_ENTRY (priv, bdentry);
+ goto out;
+ }
+
+ bd_fd->p_entry = bdentry;
+
+ bdentry = list_entry ((&bdentry->child)->next, typeof(*bdentry), child);
+ if (!bdentry) {
+ op_errno = EINVAL;
+ gf_log (this->name, GF_LOG_ERROR, "bd_entry NULL");
+ goto out;
+ }
+ bdentry = list_entry ((&bdentry->sibling), typeof(*bdentry), sibling);
+ if (!bdentry) {
+ op_errno = EINVAL;
+ gf_log (this->name, GF_LOG_ERROR, "bd_entry NULL");
+ goto out;
+ }
+
+ bd_fd->entry = bdentry;
+
+ op_ret = fd_ctx_set (fd, this, (uint64_t) (long)bd_fd);
+ if (op_ret) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "failed to set the fd context path=%s fd=%p",
+ loc->path, fd);
+ goto out;
+ }
+
+ op_ret = 0;
+out:
+ if (op_ret == -1) {
+ BD_PUT_ENTRY (priv, bd_fd->p_entry);
+ if (bd_fd)
+ GF_FREE (bd_fd);
+ }
+
+ STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, NULL);
+ return 0;
+}
+
+int32_t
+bd_releasedir (xlator_t *this, fd_t *fd)
+{
+ bd_fd_t *bd_fd = NULL;
+ uint64_t tmp_bd_fd = 0;
+ int ret = 0;
+ bd_priv_t *priv = NULL;
+
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (fd, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ ret = fd_ctx_del (fd, this, &tmp_bd_fd);
+ if (ret < 0) {
+ gf_log (this->name, GF_LOG_DEBUG, "bd_fd from fd=%p is NULL",
+ fd);
+ goto out;
+ }
+ bd_fd = (bd_fd_t *) (long)tmp_bd_fd;
+ BD_PUT_ENTRY (priv, bd_fd->p_entry);
+
+ bd_fd = (bd_fd_t *) (long)tmp_bd_fd;
+ GF_FREE (bd_fd);
+out:
+ return 0;
+}
+
+/*
+ * bd_statfs: Mimics statfs by returning used/free extents in the VG
+ * TODO: IF more than one VG allowed per volume, this functions needs some
+ * change
+ */
+int32_t
+bd_statfs (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, dict_t *xdata)
+{
+ int32_t op_ret = -1;
+ int32_t ret = -1;
+ int32_t op_errno = 0;
+ bd_priv_t *priv = NULL;
+ struct statvfs buf = {0, };
+ vg_t vg = NULL;
+ char *vg_name = NULL;
+ uint64_t size = 0;
+ uint64_t fr_size = 0;
+
+ VALIDATE_OR_GOTO (frame, out);
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (this->private, out);
+ VALIDATE_OR_GOTO (loc, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ ret = dict_get_str (this->options, "export", &vg_name);
+ if (ret) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: storage/bd does not specify volume groups");
+ op_errno = EINVAL;
+ goto out;
+ }
+
+ BD_RD_LOCK (&priv->lock);
+
+ vg = lvm_vg_open (priv->handle, vg_name, "r", 0);
+ size += lvm_vg_get_size (vg);
+ fr_size += lvm_vg_get_free_size (vg);
+ lvm_vg_close (vg);
+
+ BD_UNLOCK (&priv->lock);
+
+ if (statvfs ("/", &buf) < 0) {
+ op_errno = errno;
+ goto out;
+ }
+ op_ret = 0;
+ buf.f_blocks = size / buf.f_frsize;
+ buf.f_bfree = fr_size / buf.f_frsize;
+ buf.f_bavail = fr_size / buf.f_frsize;
+out:
+ STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, &buf, NULL);
+ return 0;
+}
+
+int
+__bd_fill_readdir (pthread_rwlock_t *bd_lock, bd_fd_t *bd_fd, off_t off,
+ size_t size, gf_dirent_t *entries)
+{
+ size_t filled = 0;
+ int count = 0;
+ struct dirent entry = {0, };
+ int32_t this_size = -1;
+ gf_dirent_t *this_entry = NULL;
+ bd_entry_t *bdentry = NULL;
+ bd_entry_t *cur_entry = NULL;
+ bd_entry_t *n_entry = NULL;
+
+ BD_RD_LOCK (bd_lock);
+
+ bdentry = list_entry ((&bd_fd->p_entry->child)->next, typeof(*n_entry),
+ child);
+
+ if (off) {
+ int i = 0;
+ list_for_each_entry (n_entry, &bd_fd->entry->sibling, sibling) {
+ if (i == off && strcmp (n_entry->name, "")) {
+ bd_fd->entry = n_entry;
+ break;
+ }
+ }
+ } else
+ bd_fd->entry = list_entry ((&bdentry->sibling),
+ typeof(*n_entry), sibling);
+
+ while (filled <= size) {
+ cur_entry = bd_fd->entry;
+
+ n_entry = list_entry ((&bd_fd->entry->sibling)->next,
+ typeof (*cur_entry), sibling);
+ if (&n_entry->sibling == (&bdentry->sibling))
+ break;
+
+ strcpy (entry.d_name, n_entry->name);
+ entry.d_ino = n_entry->attr->ia_ino;
+ entry.d_off = off;
+ if (n_entry->attr->ia_type == IA_IFDIR)
+ entry.d_type = DT_DIR;
+ else
+ entry.d_type = DT_REG;
+
+ this_size = max (sizeof(gf_dirent_t),
+ sizeof (gfs3_dirplist))
+ + strlen (entry.d_name) + 1;
+
+ if (this_size + filled > size)
+ break;
+
+ bd_fd->entry = n_entry;
+
+ this_entry = gf_dirent_for_name (entry.d_name);
+ if (!this_entry) {
+ gf_log (THIS->name, GF_LOG_ERROR,
+ "could not create gf_dirent for entry %s",
+ entry.d_name);
+ goto out;
+ }
+ this_entry->d_off = off;
+ this_entry->d_ino = entry.d_ino;
+ this_entry->d_type = entry.d_type;
+ off++;
+
+ list_add_tail (&this_entry->list, &entries->list);
+
+ filled += this_size;
+ count++;
+ }
+out:
+ BD_UNLOCK (bd_lock);
+ return count;
+}
+
+int32_t
+bd_do_readdir (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, size_t size, off_t off, int whichop)
+{
+ uint64_t tmp_bd_fd = 0;
+ bd_fd_t *bd_fd = NULL;
+ int ret = -1;
+ int count = 0;
+ int32_t op_ret = -1;
+ int32_t op_errno = 0;
+ gf_dirent_t entries;
+ gf_dirent_t *tmp_entry = NULL;
+ bd_entry_t *bdentry = NULL;
+ bd_priv_t *priv = NULL;
+ char *devpath = NULL;
+
+ VALIDATE_OR_GOTO (frame, out);
+ VALIDATE_OR_GOTO (this, out);
+ VALIDATE_OR_GOTO (fd, out);
+
+ priv = this->private;
+ VALIDATE_OR_GOTO (priv, out);
+
+ INIT_LIST_HEAD (&entries.list);
+
+ ret = fd_ctx_get (fd, this, &tmp_bd_fd);
+ if (ret < 0) {
+ gf_log (this->name, GF_LOG_WARNING, "bd_fd is NULL, fd=%p", fd);
+ op_errno = -EINVAL;
+ goto out;
+ }
+ bd_fd = (bd_fd_t *) (long)tmp_bd_fd;
+ LOCK (&fd->lock);
+ {
+ count = __bd_fill_readdir (&priv->lock, bd_fd, off,
+ size, &entries);
+ }
+ UNLOCK (&fd->lock);
+
+ /* pick ENOENT to indicate EOF */
+ op_errno = errno;
+ op_ret = count;
+
+ if (whichop != GF_FOP_READDIRP)
+ goto out;
+
+ BD_RD_LOCK (&priv->lock);
+ list_for_each_entry (tmp_entry, &entries.list, list) {
+ char path[PATH_MAX];
+ sprintf (path, "%s/%s", bd_fd->p_entry->name,
+ tmp_entry->d_name);
+ bdentry = bd_entry_get (path);
+ if (!bdentry) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "entry failed %s\n", tmp_entry->d_name);
+ continue;
+ }
+ if (bdentry->attr->ia_ino)
+ tmp_entry->d_ino = bdentry->attr->ia_ino;
+ memcpy (&tmp_entry->d_stat,
+ bdentry->attr, sizeof (tmp_entry->d_stat));
+ bd_entry_put (bdentry);
+ GF_FREE (devpath);
+ }
+ BD_UNLOCK (&priv->lock);
+
+out:
+ STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, &entries, NULL);
+
+ gf_dirent_free (&entries);
+
+ return 0;
+}
+
+int32_t
+bd_readdir (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, size_t size, off_t off, dict_t *dict)
+{
+ bd_do_readdir (frame, this, fd, size, off, GF_FOP_READDIR);
+ return 0;
+}
+
+
+int32_t
+bd_readdirp (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, size_t size, off_t off, dict_t *dict)
+{
+ bd_do_readdir (frame, this, fd, size, off, GF_FOP_READDIRP);
+ return 0;
+}
+
+int32_t
+bd_priv (xlator_t *this)
+{
+ return 0;
+}
+
+int32_t
+bd_inode (xlator_t *this)
+{
+ return 0;
+}
+
+/* unsupported interfaces */
+int bd_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
+ struct iatt *stbuf, int32_t valid, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (setattr, frame, -1, ENOSYS, NULL, NULL, NULL);
+ return 0;
+}
+
+int32_t
+bd_readlink (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, size_t size, dict_t *xdata)
+{
+ struct iatt stbuf = {0, };
+ char *dest = NULL;
+
+ dest = alloca (size + 1);
+ STACK_UNWIND_STRICT (readlink, frame, -1, ENOSYS, dest, &stbuf, NULL);
+ return 0;
+}
+
+int
+bd_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+ dev_t dev, mode_t umask, dict_t *xdata)
+{
+ struct iatt stbuf = {0, };
+ struct iatt preparent = {0, };
+ struct iatt postparent = {0, };
+
+ STACK_UNWIND_STRICT (mknod, frame, -1, ENOSYS,
+ (loc)?loc->inode:NULL, &stbuf, &preparent,
+ &postparent, NULL);
+ return 0;
+}
+
+int
+bd_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
+ mode_t umask, dict_t *xdata)
+{
+ struct iatt stbuf = {0, };
+ struct iatt preparent = {0, };
+ struct iatt postparent = {0, };
+
+ STACK_UNWIND_STRICT (mkdir, frame, -1, ENOSYS,
+ (loc)?loc->inode:NULL, &stbuf, &preparent,
+ &postparent, NULL);
+ return 0;
+}
+
+int
+bd_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+ dict_t *xdata)
+{
+ struct iatt preparent = {0, };
+ struct iatt postparent = {0, };
+
+ STACK_UNWIND_STRICT (rmdir, frame, -1, ENOSYS,
+ &preparent, &postparent, NULL);
+ return 0;
+}
+
+int
+bd_link (call_frame_t *frame, xlator_t *this,
+ loc_t *oldloc, loc_t *newloc, dict_t *xdata)
+{
+ struct iatt stbuf = {0, };
+ struct iatt preparent = {0,};
+ struct iatt postparent = {0,};
+
+ STACK_UNWIND_STRICT (link, frame, -1, ENOSYS,
+ (oldloc)?oldloc->inode:NULL, &stbuf, &preparent,
+ &postparent, NULL);
+
+ return 0;
+}
+
+int32_t
+bd_setxattr (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, dict_t *dict, int flags, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (setxattr, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_fsetxattr (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, dict_t *dict, int flags, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (setxattr, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_getxattr (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, const char *name, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (getxattr, frame, -1, ENOSYS, NULL, NULL);
+ return 0;
+}
+
+int32_t
+bd_fgetxattr (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, const char *name, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (fgetxattr, frame, -1, ENOSYS, NULL, NULL);
+
+ return 0;
+}
+
+int32_t
+bd_removexattr (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, const char *name, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (removexattr, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_fremovexattr (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, const char *name, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (fremovexattr, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_fsyncdir (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, int datasync, dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (fsyncdir, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+static int gf_bd_lk_log;
+int32_t
+bd_lk (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
+{
+ struct gf_flock nullock = {0, };
+
+ GF_LOG_OCCASIONALLY (gf_bd_lk_log, this->name, GF_LOG_CRITICAL,
+ "\"features/locks\" translator is "
+ "not loaded. You need to use it for proper "
+ "functioning of your application.");
+
+ STACK_UNWIND_STRICT (lk, frame, -1, ENOSYS, &nullock, NULL);
+ return 0;
+}
+
+int32_t
+bd_inodelk (call_frame_t *frame, xlator_t *this,
+ const char *volume, loc_t *loc, int32_t cmd,
+ struct gf_flock *lock, dict_t *xdata)
+{
+ GF_LOG_OCCASIONALLY (gf_bd_lk_log, this->name, GF_LOG_CRITICAL,
+ "\"features/locks\" translator is "
+ "not loaded. You need to use it for proper "
+ "functioning of your application.");
+
+ STACK_UNWIND_STRICT (inodelk, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_finodelk (call_frame_t *frame, xlator_t *this,
+ const char *volume, fd_t *fd, int32_t cmd,
+ struct gf_flock *lock, dict_t *xdata)
+{
+ GF_LOG_OCCASIONALLY (gf_bd_lk_log, this->name, GF_LOG_CRITICAL,
+ "\"features/locks\" translator is "
+ "not loaded. You need to use it for proper "
+ "functioning of your application.");
+
+ STACK_UNWIND_STRICT (finodelk, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+
+int32_t
+bd_entrylk (call_frame_t *frame, xlator_t *this,
+ const char *volume, loc_t *loc, const char *basename,
+ entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+{
+ GF_LOG_OCCASIONALLY (gf_bd_lk_log, this->name, GF_LOG_CRITICAL,
+ "\"features/locks\" translator is "
+ "not loaded. You need to use it for proper "
+ "functioning of your application.");
+
+ STACK_UNWIND_STRICT (entrylk, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_fentrylk (call_frame_t *frame, xlator_t *this,
+ const char *volume, fd_t *fd, const char *basename,
+ entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
+{
+ GF_LOG_OCCASIONALLY (gf_bd_lk_log, this->name, GF_LOG_CRITICAL,
+ "\"features/locks\" translator is "
+ "not loaded. You need to use it for proper "
+ "functioning of your application.");
+
+ STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOSYS, NULL);
+ return 0;
+}
+
+int32_t
+bd_rchecksum (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, off_t offset, int32_t len, dict_t *xdata)
+{
+ int32_t weak_checksum = 0;
+ unsigned char strong_checksum[MD5_DIGEST_LENGTH];
+
+ STACK_UNWIND_STRICT (rchecksum, frame, -1, ENOSYS,
+ weak_checksum, strong_checksum, NULL);
+ return 0;
+}
+
+int
+bd_xattrop (call_frame_t *frame, xlator_t *this,
+ loc_t *loc, gf_xattrop_flags_t optype, dict_t *xattr,
+ dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (xattrop, frame, -1, ENOSYS, xattr, NULL);
+ return 0;
+}
+
+
+int
+bd_fxattrop (call_frame_t *frame, xlator_t *this,
+ fd_t *fd, gf_xattrop_flags_t optype, dict_t *xattr,
+ dict_t *xdata)
+{
+ STACK_UNWIND_STRICT (xattrop, frame, -1, ENOSYS, xattr, NULL);
+ return 0;
+}
+
+/**
+ * notify - when parent sends PARENT_UP, send CHILD_UP event from here
+ */
+int32_t
+notify (xlator_t *this,
+ int32_t event,
+ void *data,
+ ...)
+{
+ switch (event)
+ {
+ case GF_EVENT_PARENT_UP:
+ {
+ /* Tell the parent that bd xlator is up */
+ default_notify (this, GF_EVENT_CHILD_UP, data);
+ }
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+int32_t
+mem_acct_init (xlator_t *this)
+{
+ int ret = -1;
+
+ if (!this)
+ return ret;
+
+ ret = xlator_mem_acct_init (this, gf_bd_mt_end + 1);
+
+ if (ret != 0) {
+ gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
+ "failed");
+ return ret;
+ }
+
+ return ret;
+}
+
+
+/**
+ * init - Constructs lists of LVs in the given VG
+ */
+int
+init (xlator_t *this)
+{
+ bd_priv_t *_private = NULL;
+ int ret = 0;
+ char *vg = NULL;
+ char *device = NULL;
+
+ LOCK_INIT (&inode_lk);
+
+ bd_rootp = bd_entry_add_root ();
+ if (!bd_rootp) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: adding root entry failed");
+ return -1;
+ }
+
+ if (this->children) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: storage/bd cannot have subvolumes");
+ ret = -1;
+ goto out;
+ }
+
+ if (!this->parents) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "Volume is dangling. Please check the volume file.");
+ }
+
+ ret = dict_get_str (this->options, "device", &device);
+ if (ret) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: storage/bd does not specify backend");
+ return -1;
+ }
+
+ /* Now we support only LV device */
+ if (strcasecmp (device, BACKEND_VG)) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: unknown %s backend %s", BD_XLATOR, device);
+ return -1;
+ }
+
+ ret = dict_get_str (this->options, "export", &vg);
+ if (ret) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "FATAL: storage/bd does not specify volume groups");
+ return -1;
+ }
+
+ ret = 0;
+ _private = GF_CALLOC (1, sizeof(*_private), gf_bd_private);
+ if (!_private)
+ goto error;
+
+ pthread_rwlock_init (&_private->lock, NULL);
+ this->private = (void *)_private;
+ _private->handle = NULL;
+ _private->vg = gf_strdup (vg);
+ if (!_private->vg) {
+ goto error;
+ }
+
+ if (bd_build_lv_list (this->private, vg) < 0)
+ goto error;
+
+out:
+ return 0;
+error:
+ BD_WR_LOCK (&_private->lock);
+ bd_entry_cleanup ();
+ lvm_quit (_private->handle);
+ if (_private->vg)
+ GF_FREE (_private->vg);
+ GF_FREE (_private);
+ return -1;
+}
+
+void
+fini (xlator_t *this)
+{
+ bd_priv_t *priv = this->private;
+ if (!priv)
+ return;
+ lvm_quit (priv->handle);
+ BD_WR_LOCK (&priv->lock);
+ bd_entry_cleanup ();
+ BD_UNLOCK (&priv->lock);
+ GF_FREE (priv->vg);
+ this->private = NULL;
+ GF_FREE (priv);
+ return;
+}
+
+struct xlator_dumpops dumpops = {
+ .priv = bd_priv,
+ .inode = bd_inode,
+};
+
+struct xlator_fops fops = {
+ /* Not supported */
+ .readlink = bd_readlink,
+ .mknod = bd_mknod,
+ .mkdir = bd_mkdir,
+ .rmdir = bd_rmdir,
+ .link = bd_link,
+ .setxattr = bd_setxattr,
+ .fsetxattr = bd_fsetxattr,
+ .getxattr = bd_getxattr,
+ .fgetxattr = bd_fgetxattr,
+ .removexattr = bd_removexattr,
+ .fremovexattr= bd_fremovexattr,
+ .fsyncdir = bd_fsyncdir,
+ .lk = bd_lk,
+ .inodelk = bd_inodelk,
+ .finodelk = bd_finodelk,
+ .entrylk = bd_entrylk,
+ .fentrylk = bd_fentrylk,
+ .rchecksum = bd_rchecksum,
+ .xattrop = bd_xattrop,
+ .setattr = bd_setattr,
+
+ /* Supported */
+ .lookup = bd_lookup,
+ .opendir = bd_opendir,
+ .readdir = bd_readdir,
+ .readdirp = bd_readdirp,
+ .stat = bd_stat,
+ .statfs = bd_statfs,
+};
+
+struct xlator_cbks cbks = {
+ .releasedir = bd_releasedir,
+};
+
+struct volume_options options[] = {
+ { .key = {"export"},
+ .type = GF_OPTION_TYPE_STR},
+ { .key = {"device"},
+ .type = GF_OPTION_TYPE_STR},
+ { .key = {NULL} }
+};
diff --git a/xlators/storage/bd_map/src/bd_map.h b/xlators/storage/bd_map/src/bd_map.h
new file mode 100644
index 00000000000..974ec928899
--- /dev/null
+++ b/xlators/storage/bd_map/src/bd_map.h
@@ -0,0 +1,75 @@
+/*
+ BD translator - Exports Block devices on server side as regular
+ files to client
+
+ Copyright IBM, Corp. 2012
+
+ This file is part of GlusterFS.
+
+ Author:
+ M. Mohan Kumar <mohan@in.ibm.com>
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
+
+#ifndef _BD_MAP_H
+#define _BD_MAP_H
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "xlator.h"
+#include "mem-types.h"
+
+#define BD_XLATOR "block device mapper xlator"
+
+#define BACKEND_VG "vg"
+
+enum gf_bd_mem_types_ {
+ gf_bd_fd = gf_common_mt_end + 1,
+ gf_bd_private,
+ gf_bd_entry,
+ gf_bd_attr,
+ gf_bd_mt_end
+};
+
+/*
+ * Each BD/LV is represented by this data structure
+ * Usually root entry will have only children and there is no sibling for that
+ * All other entries may have children and/or sibling entries
+ * If an entry is a Volume Group it will have child (. & .. and Logical
+ * Volumes) and also other Volume groups will be a sibling for this
+ */
+typedef struct bd_entry {
+ struct list_head child; /* List to child */
+ struct list_head sibling; /* List of siblings */
+ struct bd_entry *parent;/* Parent of this node */
+ struct bd_entry *link; /* Link to actual entry, if its . or .. */
+ char name[NAME_MAX];
+ struct iatt *attr;
+ int refcnt;
+ uint64_t size;
+ pthread_rwlock_t lock;
+} bd_entry_t;
+
+
+/**
+ * bd_fd - internal structure common to file and directory fd's
+ */
+typedef struct bd_fd {
+ bd_entry_t *entry;
+ bd_entry_t *p_entry; /* Parent entry */
+} bd_fd_t;
+
+typedef struct bd_priv {
+ lvm_t handle;
+ pthread_rwlock_t lock;
+ char *vg;
+} bd_priv_t;
+
+#endif
diff --git a/xlators/storage/bd_map/src/bd_map_help.c b/xlators/storage/bd_map/src/bd_map_help.c
new file mode 100644
index 00000000000..2b5c321f607
--- /dev/null
+++ b/xlators/storage/bd_map/src/bd_map_help.c
@@ -0,0 +1,462 @@
+/*
+ BD translator - Exports Block devices on server side as regular
+ files to client
+
+ Copyright IBM, Corp. 2012
+
+ This file is part of GlusterFS.
+
+ Author:
+ M. Mohan Kumar <mohan@in.ibm.com>
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#define __XOPEN_SOURCE 500
+
+#include <libgen.h>
+#include <time.h>
+#include <lvm2app.h>
+
+#include "bd_map.h"
+#include "bd_map_help.h"
+#include "defaults.h"
+#include "glusterfs3-xdr.h"
+
+#define CHILD_ENTRY(node) list_entry ((&node->child)->next, typeof(*node), \
+ child)
+
+bd_entry_t *bd_rootp;
+gf_lock_t inode_lk;
+static uint64_t bd_entry_ino = 5000; /* Starting inode */
+
+static void bd_entry_get_ino (uint64_t *inode)
+{
+ LOCK (&inode_lk);
+ {
+ *inode = bd_entry_ino++;
+ }
+ UNLOCK (&inode_lk);
+}
+
+static bd_entry_t *bd_entry_init (const char *name)
+{
+ bd_entry_t *bdentry;
+
+ bdentry = GF_MALLOC (sizeof(bd_entry_t), gf_bd_entry);
+ if (!bdentry)
+ return NULL;
+
+ bdentry->attr = GF_MALLOC (sizeof(struct iatt), gf_bd_attr);
+ if (!bdentry->attr) {
+ GF_FREE (bdentry);
+ return NULL;
+ }
+
+ strcpy (bdentry->name, name);
+ INIT_LIST_HEAD (&bdentry->sibling);
+ INIT_LIST_HEAD (&bdentry->child);
+ bdentry->link = NULL;
+ bdentry->refcnt = 0;
+ return bdentry;
+}
+
+static bd_entry_t *bd_entry_clone (bd_entry_t *orig, char *name)
+{
+ bd_entry_t *bdentry;
+
+ bdentry = GF_MALLOC (sizeof(bd_entry_t), gf_bd_entry);
+ if (!bdentry)
+ return NULL;
+
+ bdentry->attr = orig->attr;
+
+ strcpy (bdentry->name, name);
+ INIT_LIST_HEAD (&bdentry->sibling);
+ INIT_LIST_HEAD (&bdentry->child);
+ bdentry->link = orig;
+ bdentry->refcnt = 0;
+ return bdentry;
+}
+
+static void bd_entry_init_iattr (struct iatt *attr, int type)
+{
+ struct timespec ts = {0, };
+
+ clock_gettime (CLOCK_REALTIME, &ts);
+ attr->ia_dev = ia_makedev (0, 0); /* FIXME: */
+ attr->ia_type = type;
+ attr->ia_prot = ia_prot_from_st_mode (0750);
+ attr->ia_nlink = 2;
+ attr->ia_uid = 0;
+ attr->ia_gid = 0;
+ attr->ia_rdev = ia_makedev (0, 0);
+
+ attr->ia_size = 4096; /* FIXME */
+ attr->ia_blksize = 4096;
+ attr->ia_blocks = 0;
+
+ attr->ia_atime = ts.tv_sec;
+ attr->ia_atime_nsec = ts.tv_nsec;
+ attr->ia_mtime = ts.tv_sec;
+ attr->ia_mtime_nsec = ts.tv_nsec;
+ attr->ia_ctime = ts.tv_sec;
+ attr->ia_ctime_nsec = ts.tv_nsec;
+}
+
+/*
+ * bd_entry_istat: Initialize iatt strucutre for a given path on success
+ */
+void bd_entry_istat (const char *path, struct iatt *attr, int type)
+{
+ struct stat stbuf = {0, };
+
+ if (stat (path, &stbuf) < 0)
+ bd_entry_init_iattr (attr, type);
+ else
+ iatt_from_stat (attr, &stbuf);
+ sprintf ((char *)attr->ia_gfid, "%lx", stbuf.st_ino);
+}
+
+/*
+ * Adds the root entry and required entries
+ * ie header entry followed by . and .. entries
+ */
+bd_entry_t *bd_entry_add_root (void)
+{
+ bd_entry_t *bdentry = NULL;
+ bd_entry_t *h_entry = NULL;
+ bd_entry_t *d_entry = NULL;
+ bd_entry_t *dd_entry = NULL;
+
+ bdentry = bd_entry_init ("/");
+ if (!bdentry)
+ return NULL;
+
+ bdentry->parent = bdentry;
+
+ bd_entry_get_ino (&bdentry->attr->ia_ino);
+ sprintf ((char *)bdentry->attr->ia_gfid, "%ld",
+ bdentry->attr->ia_ino << 2);
+ bd_entry_init_iattr (bdentry->attr, IA_IFDIR);
+
+ h_entry = bd_entry_clone (bdentry, "");
+ bdentry->child.next = &h_entry->child;
+ bdentry->child.prev = &h_entry->child;
+
+ d_entry = bd_entry_clone (bdentry, ".");
+ dd_entry = bd_entry_clone (bdentry, "..");
+
+ list_add_tail (&d_entry->sibling, &h_entry->sibling);
+ list_add_tail (&dd_entry->sibling, &h_entry->sibling);
+ return bdentry;
+}
+
+bd_entry_t *bd_entry_add (bd_entry_t *parent, const char *name,
+ struct iatt *iattr, ia_type_t type)
+{
+ bd_entry_t *bdentry = NULL;
+ bd_entry_t *h_entry = NULL;
+ bd_entry_t *d_entry = NULL;
+ bd_entry_t *dd_entry = NULL;
+ bd_entry_t *sentry = NULL;
+ struct timespec ts = { 0, };
+
+ if (!parent)
+ parent = bd_rootp;
+
+ if (type != IA_IFREG && type != IA_IFDIR)
+ return NULL;
+
+ bdentry = bd_entry_init (name);
+ if (!bdentry)
+ return NULL;
+
+ bdentry->parent = parent;
+
+ iattr->ia_type = type;
+
+ bd_entry_get_ino (&iattr->ia_ino);
+ if (IA_ISDIR(type)) {
+ h_entry = bd_entry_clone (bdentry, "");
+ parent->attr->ia_nlink++;
+ bdentry->child.next = &h_entry->child;
+ bdentry->child.prev = &h_entry->child;
+
+ d_entry = bd_entry_clone (bdentry, ".");
+ dd_entry = bd_entry_clone (bdentry, "..");
+
+ list_add_tail (&d_entry->sibling, &h_entry->sibling);
+ list_add_tail (&dd_entry->sibling, &h_entry->sibling);
+ }
+ memcpy (bdentry->attr, iattr, sizeof(*iattr));
+
+ clock_gettime (CLOCK_REALTIME, &ts);
+ parent->attr->ia_mtime = ts.tv_sec;
+ parent->attr->ia_mtime_nsec = ts.tv_nsec;
+ bdentry->size = iattr->ia_size;
+
+ sentry = CHILD_ENTRY (parent);
+ list_add_tail (&bdentry->sibling, &sentry->sibling);
+ return bdentry;
+}
+
+bd_entry_t *bd_entry_get_list (const char *name, bd_entry_t *parent)
+{
+ bd_entry_t *centry = NULL;
+ bd_entry_t *bdentry = NULL;
+
+ if (!parent)
+ parent = bd_rootp;
+
+ if (parent->child.next == &parent->child)
+ return NULL;
+
+ centry = CHILD_ENTRY (parent);
+ if (!strcmp (centry->name, name))
+ return centry;
+
+ list_for_each_entry (bdentry, &centry->sibling, sibling) {
+ if (!strcmp (bdentry->name, name))
+ return bdentry;
+ }
+ return NULL;
+}
+
+/* FIXME: Do we need hashing here? */
+bd_entry_t *bd_entry_find_by_gfid (const char *path)
+{
+ bd_entry_t *h = NULL;
+ bd_entry_t *tmp = NULL;
+ bd_entry_t *tmp2 = NULL;
+ bd_entry_t *node = NULL;
+ bd_entry_t *cnode = NULL;
+ bd_entry_t *leaf = NULL;
+ char *gfid = NULL;
+ char *cp = NULL;
+ char *bgfid = NULL;
+ bd_entry_t *entry = NULL;
+
+ gfid = GF_MALLOC (strlen(path) + 1, gf_common_mt_char);
+ sscanf (path, "<gfid:%s", gfid);
+ if (!gfid)
+ return NULL;
+
+ cp = strchr(gfid, '>');
+ *cp = '\0';
+
+ node = CHILD_ENTRY (bd_rootp);
+
+ bgfid = GF_MALLOC (GF_UUID_BUF_SIZE, gf_common_mt_char);
+ if (!bgfid)
+ return NULL;
+
+ list_for_each_entry_safe (h, tmp, &node->sibling, sibling) {
+ uuid_utoa_r (h->attr->ia_gfid, bgfid);
+ if (!h->link && !strcmp (gfid, bgfid)) {
+ entry = h;
+ goto out;
+ }
+
+ /* if we have children for this node */
+ if (h->child.next != &h->child) {
+ cnode = CHILD_ENTRY (h);
+ uuid_utoa_r (cnode->attr->ia_gfid, bgfid);
+ if (!cnode->link && !strcmp (gfid, bgfid)) {
+ entry = cnode;
+ goto out;
+ }
+
+ list_for_each_entry_safe (leaf, tmp2, (&cnode->sibling),
+ sibling) {
+ uuid_utoa_r (leaf->attr->ia_gfid, bgfid);
+ if (!leaf->link && !strcmp (gfid, bgfid)) {
+ entry = leaf;
+ goto out;
+ }
+
+ }
+ }
+ }
+out:
+ if (bgfid)
+ GF_FREE (bgfid);
+
+ return entry;
+}
+
+/* Called with priv->bd_lock held */
+bd_entry_t *bd_entry_get (const char *name)
+{
+ bd_entry_t *pentry = NULL;
+ char *path = NULL;
+ char *comp = NULL;
+ char *save = NULL;
+
+ if (!strncmp (name, "<gfid:", 5)) {
+ pentry = bd_entry_find_by_gfid (name);
+ if (pentry)
+ pentry->refcnt++;
+ return pentry;
+ }
+
+ if (!strcmp (name, "/")) {
+ bd_rootp->refcnt++;
+ return bd_rootp;
+ }
+
+ path = gf_strdup (name);
+ comp = strtok_r (path, "/", &save);
+ pentry = bd_entry_get_list (comp, NULL);
+ if (!pentry)
+ goto out;
+ while (comp) {
+ comp = strtok_r (NULL, "/", &save);
+ if (!comp)
+ break;
+ pentry = bd_entry_get_list (comp, pentry);
+ if (!pentry)
+ goto out;
+ }
+
+ pentry->refcnt++;
+out:
+ GF_FREE (path);
+ return pentry;
+}
+
+/* Called with priv->bd_lock held */
+void bd_entry_put (bd_entry_t *entry)
+{
+ entry->refcnt--;
+}
+
+int bd_build_lv_list (bd_priv_t *priv, char *vg_name)
+{
+ struct dm_list *lv_dm_list = NULL;
+ struct lvm_lv_list *lv_list = NULL;
+ struct iatt iattr = {0, };
+ char path[PATH_MAX] = {0, };
+ vg_t vg = NULL;
+ bd_entry_t *vg_map = NULL;
+ bd_entry_t *bd = NULL;
+ int ret = -1;
+ const char *lv_name = NULL;
+
+ priv->handle = lvm_init (NULL);
+ if (!priv->handle) {
+ gf_log (THIS->name, GF_LOG_CRITICAL, "FATAL: bd_init failed");
+ return -1;
+ }
+
+ BD_WR_LOCK (&priv->lock);
+
+ vg = lvm_vg_open (priv->handle, vg_name, "r", 0);
+ if (!vg) {
+ gf_log (THIS->name, GF_LOG_CRITICAL,
+ "opening vg %s failed", vg_name);
+ goto out;
+ }
+ /* get list of LVs associated with this VG */
+ lv_dm_list = lvm_vg_list_lvs (vg);
+ sprintf (path, "/dev/%s", vg_name);
+ bd_entry_istat (path, &iattr, IA_IFDIR);
+ vg_map = bd_entry_add (bd_rootp, vg_name, &iattr,
+ IA_IFDIR);
+ if (!vg_map) {
+ gf_log (THIS->name, GF_LOG_CRITICAL,
+ "bd_add_entry failed");
+ goto out;
+ }
+ ret = 0;
+ if (!lv_dm_list) /* no lvs for this VG */
+ goto out;
+
+ dm_list_iterate_items (lv_list, lv_dm_list) {
+ if (!lv_list)
+ continue;
+ lv_name = lvm_lv_get_name (lv_list->lv);
+ /* snapshot%d is reserved name */
+ if (!strncmp (lv_name, "snapshot", 8))
+ continue;
+ /* get symbolic path for this LV */
+ sprintf (path, "/dev/%s/%s", vg_name, lv_name);
+ bd_entry_istat (path, &iattr, IA_IFREG);
+ /* Make the file size equivalant to BD size */
+ iattr.ia_size = lvm_lv_get_size (lv_list->lv);
+ /* got LV, add it to our tree */
+ bd = bd_entry_add (vg_map,
+ lvm_lv_get_name (lv_list->lv),
+ &iattr, IA_IFREG);
+ if (bd == NULL) {
+ gf_log (THIS->name, GF_LOG_ERROR,
+ "bd_add_entry failed");
+ goto out;
+ }
+ }
+out:
+ if (vg)
+ lvm_vg_close (vg);
+
+ BD_UNLOCK (&priv->lock);
+ return ret;
+}
+
+/*
+ * Called with bd_lock held to cleanup entire list. If there was a
+ * reference to any one of the entry, nothing cleared.
+ * Return 0 on success -1 in case if there is a reference to the entry
+ */
+int bd_entry_cleanup (void)
+{
+ bd_entry_t *node = NULL;
+ bd_entry_t *tmp = NULL;
+ bd_entry_t *tmp2 = NULL;
+ bd_entry_t *cnode = NULL;
+ bd_entry_t *h = NULL;
+ bd_entry_t *leaf = NULL;
+
+ if (!bd_rootp)
+ return 0;
+
+ node = CHILD_ENTRY (bd_rootp);
+ if (node->refcnt) {
+ gf_log (THIS->name, GF_LOG_WARNING,
+ "entry %s is inuse\n", node->name);
+ return -1;
+ }
+ list_for_each_entry_safe (h, tmp, &node->sibling, sibling) {
+ /* if we have children for this node */
+ if (h->child.next != &h->child) {
+ cnode = CHILD_ENTRY (h);
+ list_for_each_entry_safe (leaf, tmp2, (&cnode->sibling),
+ sibling) {
+ list_del_init (&leaf->sibling);
+ list_del_init (&leaf->child);
+ if (!leaf->link)
+ GF_FREE (leaf->attr);
+ GF_FREE (leaf);
+ }
+ list_del_init (&cnode->sibling);
+ list_del_init (&cnode->child);
+ if (!cnode->link)
+ GF_FREE (cnode->attr);
+ GF_FREE (cnode);
+ }
+ if (!h->link)
+ GF_FREE (h->attr);
+ GF_FREE (h);
+ }
+ GF_FREE (h);
+ GF_FREE (bd_rootp->attr);
+ GF_FREE (bd_rootp);
+ return 0;
+}
diff --git a/xlators/storage/bd_map/src/bd_map_help.h b/xlators/storage/bd_map/src/bd_map_help.h
new file mode 100644
index 00000000000..997b8b7162e
--- /dev/null
+++ b/xlators/storage/bd_map/src/bd_map_help.h
@@ -0,0 +1,63 @@
+/*
+ BD translator - Exports Block devices on server side as regular
+ files to client.
+
+ Copyright IBM, Corp. 2012
+
+ This file is part of GlusterFS.
+
+ Author:
+ M. Mohan Kumar <mohan@in.ibm.com>
+
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
+#ifndef _BD_MAP_HELP_H
+#define _BD_MAP_HELP_H
+
+#define BD_RD_LOCK(lock) \
+ pthread_rwlock_rdlock (lock);
+
+#define BD_WR_LOCK(lock) \
+ pthread_rwlock_wrlock (lock);
+
+#define BD_UNLOCK(lock) \
+ pthread_rwlock_unlock (lock);
+
+#define BD_WR_ENTRY(priv, bdentry, path) \
+ do { \
+ BD_WR_LOCK (&priv->lock); \
+ bdentry = bd_entry_get (path); \
+ BD_UNLOCK (&priv->lock); \
+ } while (0)
+
+#define BD_ENTRY(priv, bdentry, path) \
+ do { \
+ BD_RD_LOCK (&priv->lock); \
+ bdentry = bd_entry_get (path); \
+ BD_UNLOCK (&priv->lock); \
+ } while (0)
+
+#define BD_PUT_ENTRY(priv, bdentry) \
+ do { \
+ BD_RD_LOCK (&priv->lock); \
+ bd_entry_put (bdentry); \
+ BD_UNLOCK (&priv->lock); \
+ } while (0)
+
+extern bd_entry_t *bd_rootp;
+extern gf_lock_t inode_lk;
+
+void bd_entry_istat (const char *path, struct iatt *attr, int type);
+bd_entry_t *bd_entry_add_root (void);
+bd_entry_t *bd_entry_add (bd_entry_t *parent, const char *name,
+ struct iatt *iattr, ia_type_t type);
+bd_entry_t *bd_entry_get_list (const char *name, bd_entry_t *parent);
+bd_entry_t *bd_entry_get (const char *name);
+void bd_entry_put (bd_entry_t *entry);
+int bd_build_lv_list (bd_priv_t *priv, char *vg);
+int bd_entry_cleanup (void);
+
+#endif
generated by cgit (git 2.34.1) at 2024-11-05 19:08:27 +0000