-SUBDIRS = cluster storage protocol performance debug features encryption mount nfs mgmt

-SUBDIRS = $(BINDINGS_SUBDIRS)

-

-xlator_PROGRAMS = python.so

-

-xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/bindings

-

-python_PYTHON = gluster.py glustertypes.py glusterstack.py

-

-pythondir = $(xlatordir)/python

-

-python_so_SOURCES = python.c

-

-AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall \

- -I$(top_srcdir)/libglusterfs/src -shared -nostartfiles \

- $(PYTHON_CPPLAGS) -DGLUSTER_PYTHON_PATH=\"$(pythondir)\"

-

-AM_LDFLAGS = $(PYTHON_LDFLAGS)

-

-CLEANFILES =

-

-# Copyright (c) 2007 Chris AtLee <chris@atlee.ca>

-# This file is part of GlusterFS.

-#

-# GlusterFS is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published

-# by the Free Software Foundation; either version 3 of the License,

-# or (at your option) any later version.

-#

-# GlusterFS 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, see

-# <http://www.gnu.org/licenses/>.

-from ctypes import *

-from glustertypes import *

-from glusterstack import *

-import sys

-import inspect

-

-libglusterfs = CDLL("libglusterfs.so")

-_gf_log = libglusterfs._gf_log

-_gf_log.restype = c_int32

-_gf_log.argtypes = [c_char_p, c_char_p, c_char_p, c_int32, c_int, c_char_p]

-

-gf_log_loglevel = c_int.in_dll(libglusterfs, "gf_log_loglevel")

-

-GF_LOG_NONE = 0

-GF_LOG_CRITICAL = 1

-GF_LOG_ERROR = 2

-GF_LOG_WARNING = 3

-GF_LOG_DEBUG = 4

-

-def gf_log(module, level, fmt, *params):

- if level <= gf_log_loglevel:

- frame = sys._getframe(1)

- _gf_log(module, frame.f_code.co_filename, frame.f_code.co_name,

- frame.f_lineno, level, fmt, *params)

-

-class ComplexTranslator(object):

- def __init__(self, xlator):

- self.xlator = xlator_t.from_address(xlator)

-

- def __getattr__(self, item):

- return getattr(self.xlator, item)

-# Copyright (c) 2007 Chris AtLee <chris@atlee.ca>

-# This file is part of GlusterFS.

-#

-# GlusterFS is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published

-# by the Free Software Foundation; either version 3 of the License,

-# or (at your option) any later version.

-#

-# GlusterFS 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, see

-# <http://www.gnu.org/licenses/>.

-from ctypes import *

-from glustertypes import *

-

-libc = CDLL("libc.so.6")

-calloc = libc.calloc

-calloc.argtypes = [c_int, c_int]

-calloc.restype = c_void_p

-

-# TODO: Can these be done in C somehow?

-def stack_wind(frame, rfn, obj, fn, *params):

- """Frame is a frame object"""

- _new = cast(calloc(1, sizeof(call_frame_t)), POINTER(call_frame_t))

- _new[0].root = frame.root

- _new[0].next = frame.root[0].frames.next

- _new[0].prev = pointer(frame.root[0].frames)

- if frame.root[0].frames.next:

- frame.root[0].frames.next[0].prev = _new

- frame.root[0].frames.next = _new

- _new[0].this = obj

- # TODO: Type checking like tmp_cbk?

- _new[0].ret = rfn

- _new[0].parent = pointer(frame)

- _new[0].cookie = cast(_new, c_void_p)

- # TODO: Initialize lock

- #_new.lock.init()

- frame.ref_count += 1

- fn(_new, obj, *params)

-

-def stack_unwind(frame, *params):

- """Frame is a frame object"""

- fn = frame[0].ret

- parent = frame[0].parent[0]

- parent.ref_count -= 1

-

- op_ret = params[0]

- op_err = params[1]

- params = params[2:]

- fn(parent, call_frame_t.from_address(frame[0].cookie), parent.this,

- op_ret, op_err, *params)

-# Copyright (c) 2007 Chris AtLee <chris@atlee.ca>

-# This file is part of GlusterFS.

-#

-# GlusterFS is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published

-# by the Free Software Foundation; either version 3 of the License,

-# or (at your option) any later version.

-#

-# GlusterFS 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, see

-# <http://www.gnu.org/licenses/>.

-from ctypes import *

-import collections

-

-#

-# Forward declaration of some gluster types

-#

-class call_frame_t(Structure):

- pass

-

-class call_ctx_t(Structure):

- pass

-

-class call_pool_t(Structure):

- pass

-

-class xlator_t(Structure):

- def _getFirstChild(self):

- return self.children[0].xlator

- firstChild = property(_getFirstChild)

-

-class xlator_list_t(Structure):

- pass

-

-class xlator_fops(Structure):

- pass

-

-class xlator_mops(Structure):

- pass

-

-class glusterfs_ctx_t(Structure):

- pass

-

-class list_head(Structure):

- pass

-

-class dict_t(Structure):

- pass

-

-class inode_table_t(Structure):

- pass

-

-class fd_t(Structure):

- pass

-

-class iovec(Structure):

- _fields_ = [

- ("iov_base", c_void_p),

- ("iov_len", c_size_t),

- ]

-

- def __init__(self, s):

- self.iov_base = cast(c_char_p(s), c_void_p)

- self.iov_len = len(s)

-

- def getBytes(self):

- return string_at(self.iov_base, self.iov_len)

-

-# This is a pthread_spinlock_t

-# TODO: what happens to volatile-ness?

-gf_lock_t = c_int

-

-uid_t = c_uint32

-gid_t = c_uint32

-pid_t = c_int32

-

-off_t = c_int64

-

-#

-# Function pointer types

-#

-ret_fn_t = CFUNCTYPE(c_int32, POINTER(call_frame_t), POINTER(call_frame_t),

- POINTER(xlator_t), c_int32, c_int32)

-

-fini_fn_t = CFUNCTYPE(None, POINTER(xlator_t))

-init_fn_t = CFUNCTYPE(c_int32, POINTER(xlator_t))

-event_notify_fn_t = CFUNCTYPE(c_int32, POINTER(xlator_t), c_int32, c_void_p)

-

-list_head._fields_ = [

- ("next", POINTER(list_head)),

- ("prev", POINTER(list_head)),

- ]

-

-call_frame_t._fields_ = [

- ("root", POINTER(call_ctx_t)),

- ("parent", POINTER(call_frame_t)),

- ("next", POINTER(call_frame_t)),

- ("prev", POINTER(call_frame_t)),

- ("local", c_void_p),

- ("this", POINTER(xlator_t)),

- ("ret", ret_fn_t),

- ("ref_count", c_int32),

- ("lock", gf_lock_t),

- ("cookie", c_void_p),

- ("op", c_int32),

- ("type", c_int8),

- ]

-

-call_ctx_t._fields_ = [

- ("all_frames", list_head),

- ("trans", c_void_p),

- ("pool", call_pool_t),

- ("unique", c_uint64),

- ("state", c_void_p),

- ("uid", uid_t),

- ("gid", gid_t),

- ("pid", pid_t),

- ("frames", call_frame_t),

- ("req_refs", POINTER(dict_t)),

- ("rsp_refs", POINTER(dict_t)),

- ]

-

-xlator_t._fields_ = [

- ("name", c_char_p),

- ("type", c_char_p),

- ("next", POINTER(xlator_t)),

- ("prev", POINTER(xlator_t)),

- ("parent", POINTER(xlator_t)),

- ("children", POINTER(xlator_list_t)),

- ("fops", POINTER(xlator_fops)),

- ("mops", POINTER(xlator_mops)),

- ("fini", fini_fn_t),

- ("init", init_fn_t),

- ("notify", event_notify_fn_t),

- ("options", POINTER(dict_t)),

- ("ctx", POINTER(glusterfs_ctx_t)),

- ("itable", POINTER(inode_table_t)),

- ("ready", c_char),

- ("private", c_void_p),

- ]

-

-xlator_list_t._fields_ = [

- ("xlator", POINTER(xlator_t)),

- ("next", POINTER(xlator_list_t)),

- ]

-

-fop_functions = collections.defaultdict(lambda: c_void_p)

-fop_function_names = ['lookup', 'forget', 'stat', 'fstat', 'chmod', 'fchmod',

- 'chown', 'fchown', 'truncate', 'ftruncate', 'utimens', 'access',

- 'readlink', 'mknod', 'mkdir', 'unlink', 'rmdir', 'symlink',

- 'rename', 'link', 'create', 'open', 'readv', 'writev', 'flush',

- 'close', 'fsync', 'opendir', 'readdir', 'closedir', 'fsyncdir',

- 'statfs', 'setxattr', 'getxattr', 'removexattr', 'lk', 'writedir',

- # TODO: Call backs?

- ]

-

-fop_writev_t = CFUNCTYPE(c_int32, POINTER(call_frame_t), POINTER(xlator_t),

- POINTER(fd_t), POINTER(iovec), c_int32,

- off_t)

-

-fop_functions['writev'] = fop_writev_t

-xlator_fops._fields_ = [(f, fop_functions[f]) for f in fop_function_names]

-/*

- Copyright (c) 2007-2010 Chris AtLee <chris@atlee.ca>

- This file is part of GlusterFS.

-

- GlusterFS is free software; you can redistribute it and/or modify

- it under the terms of the GNU General Public License as published

- by the Free Software Foundation; either version 3 of the License,

- or (at your option) any later version.

-

- GlusterFS 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, see

- <http://www.gnu.org/licenses/>.

-*/

-

-#include <Python.h>

-

-#ifndef _CONFIG_H

-#define _CONFIG_H

-#include "config.h"

-#endif

-

-#include "glusterfs.h"

-#include "xlator.h"

-#include "logging.h"

-#include "defaults.h"

-

-typedef struct

-{

- char *scriptname;

- PyObject *pXlator;

- PyObject *pScriptModule;

- PyObject *pGlusterModule;

- PyThreadState *pInterp;

-

- PyObject *pFrameType, *pVectorType, *pFdType;

-} python_private_t;

-

-int32_t

-python_writev (call_frame_t *frame,

- xlator_t *this,

- fd_t *fd,

- struct iovec *vector,

- int32_t count,

- off_t offset)

-{

- python_private_t *priv = (python_private_t *)this->private;

- gf_log("python", GF_LOG_DEBUG, "In writev");

- if (PyObject_HasAttrString(priv->pXlator, "writev"))

- {

-

- PyObject *retval = PyObject_CallMethod(priv->pXlator, "writev",

- "O O O i l",

- PyObject_CallMethod(priv->pFrameType, "from_address", "O&", PyLong_FromVoidPtr, frame),

- PyObject_CallMethod(priv->pFdType, "from_address", "O&", PyLong_FromVoidPtr, fd),

- PyObject_CallMethod(priv->pVectorType, "from_address", "O&", PyLong_FromVoidPtr, vector),

- count,

- offset);

- if (PyErr_Occurred())

- {

- PyErr_Print();

- }

- Py_XDECREF(retval);

- }

- else

- {

- return default_writev(frame, this, fd, vector, count, offset);

- }

- return 0;

-}

-

-struct xlator_fops fops = {

- .writev = python_writev

-};

-

-static PyObject *

-AnonModule_FromFile (const char* fname)

-{

- // Get the builtins

- PyThreadState* pThread = PyThreadState_Get();

- PyObject *pBuiltins = pThread->interp->builtins;

-

- if (PyErr_Occurred())

- {

- PyErr_Print();

- return NULL;

- }

-

- // Create a new dictionary for running code in

- PyObject *pModuleDict = PyDict_New();

- PyDict_SetItemString(pModuleDict, "__builtins__", pBuiltins);

- Py_INCREF(pBuiltins);

-

- // Run the file in the new context

- FILE* fp = fopen(fname, "r");

- PyRun_File(fp, fname, Py_file_input, pModuleDict, pModuleDict);

- fclose(fp);

- if (PyErr_Occurred())

- {

- PyErr_Print();

- Py_DECREF(pModuleDict);

- Py_DECREF(pBuiltins);

- return NULL;

- }

-

- // Create an object to hold the new context

- PyRun_String("class ModuleWrapper(object):\n\tpass\n", Py_single_input, pModuleDict, pModuleDict);

- if (PyErr_Occurred())

- {

- PyErr_Print();

- Py_DECREF(pModuleDict);

- Py_DECREF(pBuiltins);

- return NULL;

- }

- PyObject *pModule = PyRun_String("ModuleWrapper()", Py_eval_input, pModuleDict, pModuleDict);

- if (PyErr_Occurred())

- {

- PyErr_Print();

- Py_DECREF(pModuleDict);

- Py_DECREF(pBuiltins);

- Py_XDECREF(pModule);

- return NULL;

- }

-

- // Set the new context's dictionary to the one we used to run the code

- // inside

- PyObject_SetAttrString(pModule, "__dict__", pModuleDict);

- if (PyErr_Occurred())

- {

- PyErr_Print();

- Py_DECREF(pModuleDict);

- Py_DECREF(pBuiltins);

- Py_DECREF(pModule);

- return NULL;

- }

-

- return pModule;

-}

-

-int32_t

-init (xlator_t *this)

-{

- // This is ok to call more than once per process

- Py_InitializeEx(0);

-

- if (!this->children) {

- gf_log ("python", GF_LOG_ERROR,

- "FATAL: python should have exactly one child");

- return -1;

- }

-

- python_private_t *priv = CALLOC (sizeof (python_private_t), 1);

- ERR_ABORT (priv);

-

- data_t *scriptname = dict_get (this->options, "scriptname");

- if (scriptname) {

- priv->scriptname = data_to_str(scriptname);

- } else {

- gf_log("python", GF_LOG_ERROR,

- "FATAL: python requires the scriptname parameter");

- return -1;

- }

-

- priv->pInterp = Py_NewInterpreter();

-

- // Adjust python's path

- PyObject *syspath = PySys_GetObject("path");

- PyObject *path = PyString_FromString(GLUSTER_PYTHON_PATH);

- PyList_Append(syspath, path);

- Py_DECREF(path);

-

- gf_log("python", GF_LOG_DEBUG,

- "Loading gluster module");

-

- priv->pGlusterModule = PyImport_ImportModule("gluster");

- if (PyErr_Occurred())

- {

- PyErr_Print();

- return -1;

- }

-

- priv->pFrameType = PyObject_GetAttrString(priv->pGlusterModule, "call_frame_t");

- priv->pFdType = PyObject_GetAttrString(priv->pGlusterModule, "fd_t");

- priv->pVectorType = PyObject_GetAttrString(priv->pGlusterModule, "iovec");

-

- gf_log("python", GF_LOG_DEBUG, "Loading script...%s", priv->scriptname);

-

- priv->pScriptModule = AnonModule_FromFile(priv->scriptname);

- if (!priv->pScriptModule || PyErr_Occurred())

- {

- gf_log("python", GF_LOG_ERROR, "Error loading %s", priv->scriptname);

- PyErr_Print();

- return -1;

- }

-

- if (!PyObject_HasAttrString(priv->pScriptModule, "xlator"))

- {

- gf_log("python", GF_LOG_ERROR, "%s does not have a xlator attribute", priv->scriptname);

- return -1;

- }

- gf_log("python", GF_LOG_DEBUG, "Instantiating translator");

- priv->pXlator = PyObject_CallMethod(priv->pScriptModule, "xlator", "O&",

- PyLong_FromVoidPtr, this);

- if (PyErr_Occurred() || !priv->pXlator)

- {

- PyErr_Print();

- return -1;

- }

-

- this->private = priv;

-

- gf_log ("python", GF_LOG_DEBUG, "python xlator loaded");

- return 0;

-}

-

-void

-fini (xlator_t *this)

-{

- python_private_t *priv = (python_private_t*)(this->private);

- Py_DECREF(priv->pXlator);

- Py_DECREF(priv->pScriptModule);

- Py_DECREF(priv->pGlusterModule);

- Py_DECREF(priv->pFrameType);

- Py_DECREF(priv->pFdType);

- Py_DECREF(priv->pVectorType);

- Py_EndInterpreter(priv->pInterp);

- return;

-}

-# Copyright (c) 2007 Chris AtLee <chris@atlee.ca>

-# This file is part of GlusterFS.

-#

-# GlusterFS is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published

-# by the Free Software Foundation; either version 3 of the License,

-# or (at your option) any later version.

-#

-# GlusterFS 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, see

-# <http://www.gnu.org/licenses/>.

-

-"""

-This is a test translator written in python.

-

-Important things to note:

- This file must be import-able from glusterfsd. This probably means

- setting PYTHONPATH to where this file is located.

-

- This file must have a top-level xlator class object that will be

- used to instantiate individual translators.

-"""

-from gluster import *

-

-class MyXlator(ComplexTranslator):

- name = "MyXlator"

- def writev_cbk(self, frame, cookie, op_ret, op_errno, buf):

- stack_unwind(frame, op_ret, op_errno, buf)

- return 0

-

- def writev(self, frame, fd, vector, count, offset):

- gf_log(self.name, GF_LOG_WARNING, "writev %i bytes", vector.iov_len)

- # TODO: Use cookie to pass this to writev_cbk

- old_count = vector.iov_len

-

- data = vector.getBytes().encode("zlib")

-

- vector = iovec(data)

- gf_log(self.name, GF_LOG_WARNING, "writev %i bytes", vector.iov_len)

-

- @ret_fn_t

- def rfn(frame, prev, this, op_ret, op_errno, *params):

- if len(params) == 0:

- params = [0]

- return self.writev_cbk(frame, prev, old_count, op_errno, *params)

-

- stack_wind(frame, rfn, self.firstChild,

- self.firstChild[0].fops[0].writev, fd, vector, count, offset)

- return 0

-

-xlator = MyXlator

-afr_common_source = afr-dir-read.c afr-dir-write.c afr-inode-read.c afr-inode-write.c afr-open.c afr-transaction.c afr-self-heal-data.c afr-self-heal-common.c afr-self-heal-metadata.c afr-self-heal-entry.c afr-self-heal-algorithm.c afr-lk-common.c $(top_builddir)/xlators/lib/src/libxlator.c

-afr_la_LDFLAGS = -module -avoidversion

-afr_la_SOURCES = $(afr_common_source) afr.c

-pump_la_LDFLAGS = -module -avoidversion

-pump_la_SOURCES = $(afr_common_source) pump.c

-noinst_HEADERS = afr.h afr-transaction.h afr-inode-write.h afr-inode-read.h afr-dir-read.h afr-dir-write.h afr-self-heal.h afr-self-heal-common.h afr-self-heal-algorithm.h pump.h afr-mem-types.h afr-common.c $(top_builddir)/xlators/lib/src/libxlator.h

-AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS) \

- -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/contrib/md5 -shared -nostartfiles $(GF_CFLAGS) \

- -I$(top_srcdir)/xlators/lib/src

- rm -f $(DESTDIR)$(xlatordir)/pump.so

- Copyright (c) 2007-2010 Gluster, Inc. <http://www.gluster.com>

- This file is part of GlusterFS.

-

- GlusterFS is free software; you can redistribute it and/or modify

- it under the terms of the GNU Affero General Public License as published

- by the Free Software Foundation; either version 3 of the License,

- or (at your option) any later version.

-

- GlusterFS 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

- Affero General Public License for more details.

-

- You should have received a copy of the GNU Affero General Public License

- along with this program. If not, see

- <http://www.gnu.org/licenses/>.

-#include "afr-self-heal-common.h"

-#include "pump.h"

-#define AFR_ICTX_OPENDIR_DONE_MASK 0x0000000200000000ULL

-#define AFR_ICTX_SPLIT_BRAIN_MASK 0x0000000100000000ULL

-#define AFR_ICTX_READ_CHILD_MASK 0x00000000FFFFFFFFULL

-int32_t

-afr_set_dict_gfid (dict_t *dict, uuid_t gfid)

- int ret = 0;

- GF_ASSERT (gfid);

- ret = dict_set_static_bin (dict, "gfid-req", gfid, 16);

- if (ret)

- gf_log (THIS->name, GF_LOG_DEBUG, "gfid set failed");

- return ret;

-uint64_t

-afr_is_split_brain (xlator_t *this, inode_t *inode)

- int ret = 0;

- uint64_t ctx = 0;

- uint64_t split_brain = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0)

- goto unlock;

- split_brain = ctx & AFR_ICTX_SPLIT_BRAIN_MASK;

- }

-unlock:

- UNLOCK (&inode->lock);

-out:

- return split_brain;

-void

-afr_set_split_brain (xlator_t *this, inode_t *inode, gf_boolean_t set)

- uint64_t ctx = 0;

- int ret = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0) {

- ctx = 0;

- }

- if (set) {

- ctx = (~AFR_ICTX_SPLIT_BRAIN_MASK & ctx)

- | (0xFFFFFFFFFFFFFFFFULL & AFR_ICTX_SPLIT_BRAIN_MASK);

- } else {

- ctx = (~AFR_ICTX_SPLIT_BRAIN_MASK & ctx);

- }

- __inode_ctx_put (inode, this, ctx);

- }

- UNLOCK (&inode->lock);

-out:

- return;

-uint64_t

-afr_is_opendir_done (xlator_t *this, inode_t *inode)

- int ret = 0;

- uint64_t ctx = 0;

- uint64_t opendir_done = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0)

- goto unlock;

- opendir_done = ctx & AFR_ICTX_OPENDIR_DONE_MASK;

- }

-unlock:

- UNLOCK (&inode->lock);

-out:

- return opendir_done;

-void

-afr_set_opendir_done (xlator_t *this, inode_t *inode)

- uint64_t ctx = 0;

- int ret = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0) {

- ctx = 0;

- }

- ctx = (~AFR_ICTX_OPENDIR_DONE_MASK & ctx)

- | (0xFFFFFFFFFFFFFFFFULL & AFR_ICTX_OPENDIR_DONE_MASK);

- __inode_ctx_put (inode, this, ctx);

- }

- UNLOCK (&inode->lock);

-out:

- return;

-uint64_t

-afr_read_child (xlator_t *this, inode_t *inode)

- int ret = 0;

- uint64_t ctx = 0;

- uint64_t read_child = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0)

- goto unlock;

- read_child = ctx & AFR_ICTX_READ_CHILD_MASK;

- }

-unlock:

- UNLOCK (&inode->lock);

-out:

- return read_child;

-void

-afr_set_read_child (xlator_t *this, inode_t *inode, int32_t read_child)

- uint64_t ctx = 0;

- int ret = 0;

- VALIDATE_OR_GOTO (inode, out);

- LOCK (&inode->lock);

- {

- ret = __inode_ctx_get (inode, this, &ctx);

- if (ret < 0) {

- ctx = 0;

- }

- ctx = (~AFR_ICTX_READ_CHILD_MASK & ctx)

- | (AFR_ICTX_READ_CHILD_MASK & read_child);

- __inode_ctx_put (inode, this, ctx);

- }

- UNLOCK (&inode->lock);

-out:

- return;

-/**

- * afr_local_cleanup - cleanup everything in frame->local

- */

-void

-afr_local_sh_cleanup (afr_local_t *local, xlator_t *this)

- afr_self_heal_t *sh = NULL;

- afr_private_t *priv = NULL;

- int i = 0;

- sh = &local->self_heal;

- priv = this->private;

- if (sh->buf)

- GF_FREE (sh->buf);

- if (sh->xattr) {

- for (i = 0; i < priv->child_count; i++) {

- if (sh->xattr[i]) {

- dict_unref (sh->xattr[i]);

- sh->xattr[i] = NULL;

- }

- }

- GF_FREE (sh->xattr);

- if (sh->child_errno)

- GF_FREE (sh->child_errno);

- if (sh->pending_matrix) {

- for (i = 0; i < priv->child_count; i++) {

- GF_FREE (sh->pending_matrix[i]);

- }

- GF_FREE (sh->pending_matrix);

- if (sh->delta_matrix) {

- for (i = 0; i < priv->child_count; i++) {

- GF_FREE (sh->delta_matrix[i]);

- }

- GF_FREE (sh->delta_matrix);

- if (sh->sources)

- GF_FREE (sh->sources);

- if (sh->success)

- GF_FREE (sh->success);

- if (sh->locked_nodes)

- GF_FREE (sh->locked_nodes);

- if (sh->healing_fd && !sh->healing_fd_opened) {

- fd_unref (sh->healing_fd);

- sh->healing_fd = NULL;

- if (sh->linkname)

- GF_FREE ((char *)sh->linkname);

- loc_wipe (&sh->parent_loc);

- int i = 0;

- afr_private_t * priv = NULL;

- for (i = 0; i < priv->child_count; i++) {

- if (local->pending && local->pending[i])

- GF_FREE (local->pending[i]);

- }

-

- GF_FREE (local->pending);

-

- if (local->internal_lock.locked_nodes)

- GF_FREE (local->internal_lock.locked_nodes);

- if (local->internal_lock.inode_locked_nodes)

- GF_FREE (local->internal_lock.inode_locked_nodes);

- if (local->internal_lock.entry_locked_nodes)

- GF_FREE (local->internal_lock.entry_locked_nodes);

- if (local->internal_lock.lower_locked_nodes)

- GF_FREE (local->internal_lock.lower_locked_nodes);

- GF_FREE (local->transaction.child_errno);

- GF_FREE (local->child_errno);

- int i;

- afr_local_sh_cleanup (local, this);

- { /* lookup */

- if (local->cont.lookup.xattrs) {

- for (i = 0; i < priv->child_count; i++) {

- if (local->cont.lookup.xattrs[i]) {

- dict_unref (local->cont.lookup.xattrs[i]);

- local->cont.lookup.xattrs[i] = NULL;

- }

- }

- GF_FREE (local->cont.lookup.xattrs);

- local->cont.lookup.xattrs = NULL;

- }

- if (local->cont.lookup.xattr) {

- dict_unref (local->cont.lookup.xattr);

- }

- if (local->cont.lookup.inode) {

- inode_unref (local->cont.lookup.inode);

- }

- }

- if (local->cont.getxattr.name)

- GF_FREE (local->cont.getxattr.name);

- if (local->cont.lk.locked_nodes)

- GF_FREE (local->cont.lk.locked_nodes);

-

- if (local->cont.opendir.checksum)

- GF_FREE (local->cont.opendir.checksum);

-/**

- * up_children_count - return the number of children that are up

- */

-

-int

-afr_up_children_count (int child_count, unsigned char *child_up)

- int i = 0;

- int ret = 0;

- for (i = 0; i < child_count; i++)

- if (child_up[i])

- ret++;

- return ret;

-}

-ino64_t

-afr_itransform (ino64_t ino, int child_count, int child_index)

-{

- ino64_t scaled_ino = -1;

- if (ino == ((uint64_t) -1)) {

- scaled_ino = ((uint64_t) -1);

- goto out;

- }

- scaled_ino = (ino * child_count) + child_index;

-out:

- return scaled_ino;

-int

-afr_deitransform_orig (ino64_t ino, int child_count)

- int index = -1;

- index = ino % child_count;

- return index;