diff options
Diffstat (limited to 'xlators/features/glupy/src/glupy.c')
| -rw-r--r-- | xlators/features/glupy/src/glupy.c | 2987 |
1 files changed, 1444 insertions, 1543 deletions
diff --git a/xlators/features/glupy/src/glupy.c b/xlators/features/glupy/src/glupy.c index bacccfef686..d1a111eab4a 100644 --- a/xlators/features/glupy/src/glupy.c +++ b/xlators/features/glupy/src/glupy.c @@ -25,2521 +25,2422 @@ pthread_key_t gil_init_key; PyGILState_STATE -glupy_enter (void) +glupy_enter(void) { - if (!pthread_getspecific(gil_init_key)) { - PyEval_ReleaseLock(); - (void)pthread_setspecific(gil_init_key,(void *)1); - } + if (!pthread_getspecific(gil_init_key)) { + PyEval_ReleaseLock(); + (void)pthread_setspecific(gil_init_key, (void *)1); + } - return PyGILState_Ensure(); + return PyGILState_Ensure(); } void -glupy_leave (PyGILState_STATE gstate) +glupy_leave(PyGILState_STATE gstate) { - PyGILState_Release(gstate); + PyGILState_Release(gstate); } /* FOP: LOOKUP */ int32_t -glupy_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, struct iatt *postparent) +glupy_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, struct iatt *postparent) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_LOOKUP]) { - goto unwind; - } + if (!priv->cbks[GLUPY_LOOKUP]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_lookup_cbk_t)(priv->cbks[GLUPY_LOOKUP]))( - frame, cookie, this, op_ret, op_errno, - inode, buf, xdata, postparent); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_lookup_cbk_t)(priv->cbks[GLUPY_LOOKUP]))( + frame, cookie, this, op_ret, op_errno, inode, buf, xdata, postparent); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, - xdata, postparent); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, + postparent); + return 0; } int32_t -glupy_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +glupy_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_LOOKUP]) { - goto wind; - } + if (!priv->fops[GLUPY_LOOKUP]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_lookup_t)(priv->fops[GLUPY_LOOKUP]))( - frame, this, loc, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_lookup_t)(priv->fops[GLUPY_LOOKUP]))(frame, this, loc, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_lookup_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, loc, xdata); - return 0; + STACK_WIND(frame, glupy_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xdata); + return 0; } void -wind_lookup (call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) +wind_lookup(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_lookup_cbk,xl,xl->fops->lookup,loc,xdata); + STACK_WIND(frame, glupy_lookup_cbk, xl, xl->fops->lookup, loc, xdata); } void -unwind_lookup (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, struct iatt *postparent) +unwind_lookup(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata, + struct iatt *postparent) { - frame->local = NULL; - STACK_UNWIND_STRICT(lookup,frame,op_ret,op_errno, - inode,buf,xdata,postparent); + frame->local = NULL; + STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, + postparent); } void -set_lookup_fop (long py_this, fop_lookup_t fop) +set_lookup_fop(long py_this, fop_lookup_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_LOOKUP] = (long)fop; + priv->fops[GLUPY_LOOKUP] = (long)fop; } void -set_lookup_cbk (long py_this, fop_lookup_cbk_t cbk) +set_lookup_cbk(long py_this, fop_lookup_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_LOOKUP] = (long)cbk; + priv->cbks[GLUPY_LOOKUP] = (long)cbk; } /* FOP: CREATE */ int32_t -glupy_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +glupy_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_CREATE]) { - goto unwind; - } + if (!priv->cbks[GLUPY_CREATE]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_create_cbk_t)(priv->cbks[GLUPY_CREATE]))( - frame, cookie, this, op_ret, op_errno, - fd, inode, buf, preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_create_cbk_t)(priv->cbks[GLUPY_CREATE]))( + frame, cookie, this, op_ret, op_errno, fd, inode, buf, preparent, + postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); + return 0; } int32_t -glupy_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +glupy_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_CREATE]) { - goto wind; - } + if (!priv->fops[GLUPY_CREATE]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_create_t)(priv->fops[GLUPY_CREATE]))( - frame, this, loc, flags, mode, umask, fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_create_t)(priv->fops[GLUPY_CREATE]))(frame, this, loc, flags, + mode, umask, fd, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_create_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, - fd, xdata); - return 0; + STACK_WIND(frame, glupy_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); + return 0; } void -wind_create (call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +wind_create(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_create_cbk,xl, xl->fops->create, - loc, flags, mode, umask, fd, xdata); + STACK_WIND(frame, glupy_create_cbk, xl, xl->fops->create, loc, flags, mode, + umask, fd, xdata); } void -unwind_create (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +unwind_create(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); } void -set_create_fop (long py_this, fop_create_t fop) +set_create_fop(long py_this, fop_create_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_CREATE] = (long)fop; + priv->fops[GLUPY_CREATE] = (long)fop; } void -set_create_cbk (long py_this, fop_create_cbk_t cbk) +set_create_cbk(long py_this, fop_create_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_CREATE] = (long)cbk; + priv->cbks[GLUPY_CREATE] = (long)cbk; } /* FOP: OPEN */ int32_t -glupy_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +glupy_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_OPEN]) { - goto unwind; - } + if (!priv->cbks[GLUPY_OPEN]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_open_cbk_t)(priv->cbks[GLUPY_OPEN]))( - frame, cookie, this, op_ret, op_errno, - fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_open_cbk_t)(priv->cbks[GLUPY_OPEN]))( + frame, cookie, this, op_ret, op_errno, fd, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); + return 0; } int32_t -glupy_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, dict_t *xdata) +glupy_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_OPEN]) { - goto wind; - } + if (!priv->fops[GLUPY_OPEN]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_open_t)(priv->fops[GLUPY_OPEN]))( - frame, this, loc, flags, fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_open_t)(priv->fops[GLUPY_OPEN]))(frame, this, loc, flags, fd, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_open_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); - return 0; + STACK_WIND(frame, glupy_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); + return 0; } void -wind_open (call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, - fd_t *fd, dict_t *xdata) +wind_open(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_open_cbk, xl, xl->fops->open, loc, flags, - fd, xdata); + STACK_WIND(frame, glupy_open_cbk, xl, xl->fops->open, loc, flags, fd, + xdata); } void -unwind_open (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +unwind_open(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); } void -set_open_fop (long py_this, fop_open_t fop) +set_open_fop(long py_this, fop_open_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_OPEN] = (long)fop; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->fops[GLUPY_OPEN] = (long)fop; } void -set_open_cbk (long py_this, fop_open_cbk_t cbk) +set_open_cbk(long py_this, fop_open_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_OPEN] = (long)cbk; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->cbks[GLUPY_OPEN] = (long)cbk; } /* FOP: READV */ int32_t -glupy_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *stbuf, struct iobref *iobref, - dict_t *xdata) +glupy_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_READV]) { - goto unwind; - } + if (!priv->cbks[GLUPY_READV]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_readv_cbk_t)(priv->cbks[GLUPY_READV]))( - frame, cookie, this, op_ret, op_errno, - vector, count, stbuf, iobref, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_readv_cbk_t)(priv->cbks[GLUPY_READV]))( + frame, cookie, this, op_ret, op_errno, vector, count, stbuf, iobref, + xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, - count, stbuf, iobref, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, + iobref, xdata); + return 0; } int32_t -glupy_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, uint32_t flags, dict_t *xdata) +glupy_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_READV]) { - goto wind; - } + if (!priv->fops[GLUPY_READV]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_readv_t)(priv->fops[GLUPY_READV]))( - frame, this, fd, size, offset, flags, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_readv_t)(priv->fops[GLUPY_READV]))(frame, this, fd, size, + offset, flags, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_readv_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, fd, size, offset, - flags, xdata); - return 0; + STACK_WIND(frame, glupy_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); + return 0; } void -wind_readv (call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) +wind_readv(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_readv_cbk, xl, xl->fops->readv, fd, size, - offset, flags, xdata); + STACK_WIND(frame, glupy_readv_cbk, xl, xl->fops->readv, fd, size, offset, + flags, xdata); } void -unwind_readv (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *stbuf, struct iobref *iobref, - dict_t *xdata) +unwind_readv(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iovec *vector, int32_t count, + struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, - count, stbuf, iobref, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, + iobref, xdata); } void -set_readv_fop (long py_this, fop_readv_t fop) +set_readv_fop(long py_this, fop_readv_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_READV] = (long)fop; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->fops[GLUPY_READV] = (long)fop; } void -set_readv_cbk (long py_this, fop_readv_cbk_t cbk) +set_readv_cbk(long py_this, fop_readv_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_READV] = (long)cbk; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->cbks[GLUPY_READV] = (long)cbk; } /* FOP: WRITEV */ int32_t -glupy_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +glupy_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_WRITEV]) { - goto unwind; - } + if (!priv->cbks[GLUPY_WRITEV]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_writev_cbk_t)(priv->cbks[GLUPY_WRITEV]))( - frame, cookie, this, op_ret, op_errno, - prebuf, postbuf, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_writev_cbk_t)(priv->cbks[GLUPY_WRITEV]))( + frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } int32_t -glupy_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, off_t offset, - uint32_t flags, struct iobref *iobref, dict_t *xdata) +glupy_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t offset, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_WRITEV]) { - goto wind; - } + if (!priv->fops[GLUPY_WRITEV]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_writev_t)(priv->fops[GLUPY_WRITEV]))( - frame, this, fd, vector, count, offset, flags, - iobref, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_writev_t)(priv->fops[GLUPY_WRITEV]))( + frame, this, fd, vector, count, offset, flags, iobref, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_writev_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, fd, vector, count, - offset, flags, iobref, xdata); - return 0; + STACK_WIND(frame, glupy_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdata); + return 0; } void -wind_writev (call_frame_t *frame, xlator_t *xl, fd_t *fd, struct iovec *vector, - int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, - dict_t *xdata) +wind_writev(call_frame_t *frame, xlator_t *xl, fd_t *fd, struct iovec *vector, + int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_writev_cbk, xl, xl->fops->writev, fd, vector, - count, offset, flags, iobref, xdata); + STACK_WIND(frame, glupy_writev_cbk, xl, xl->fops->writev, fd, vector, count, + offset, flags, iobref, xdata); } void -unwind_writev (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +unwind_writev(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf, + dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, - postbuf, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); } void -set_writev_fop (long py_this, fop_writev_t fop) +set_writev_fop(long py_this, fop_writev_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_WRITEV] = (long)fop; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->fops[GLUPY_WRITEV] = (long)fop; } void -set_writev_cbk (long py_this, fop_writev_cbk_t cbk) +set_writev_cbk(long py_this, fop_writev_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_WRITEV] = (long)cbk; + glupy_private_t *priv = ((xlator_t *)py_this)->private; + priv->cbks[GLUPY_WRITEV] = (long)cbk; } - /* FOP: OPENDIR */ int32_t -glupy_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, - dict_t *xdata) +glupy_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_OPENDIR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_OPENDIR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_opendir_cbk_t)(priv->cbks[GLUPY_OPENDIR]))( - frame, cookie, this, op_ret, op_errno, - fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_opendir_cbk_t)(priv->cbks[GLUPY_OPENDIR]))( + frame, cookie, this, op_ret, op_errno, fd, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); + return 0; } int32_t -glupy_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, - fd_t *fd, dict_t *xdata) +glupy_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_OPENDIR]) { - goto wind; - } + if (!priv->fops[GLUPY_OPENDIR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_opendir_t)(priv->fops[GLUPY_OPENDIR]))( - frame, this, loc, fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_opendir_t)(priv->fops[GLUPY_OPENDIR]))(frame, this, loc, fd, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_opendir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); - return 0; + STACK_WIND(frame, glupy_opendir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); + return 0; } void -wind_opendir (call_frame_t *frame, xlator_t *xl, loc_t *loc, fd_t *fd, dict_t *xdata) +wind_opendir(call_frame_t *frame, xlator_t *xl, loc_t *loc, fd_t *fd, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_opendir_cbk,xl,xl->fops->opendir,loc,fd,xdata); + STACK_WIND(frame, glupy_opendir_cbk, xl, xl->fops->opendir, loc, fd, xdata); } void -unwind_opendir (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +unwind_opendir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(opendir,frame,op_ret,op_errno, - fd,xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); } void -set_opendir_fop (long py_this, fop_opendir_t fop) +set_opendir_fop(long py_this, fop_opendir_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_OPENDIR] = (long)fop; + priv->fops[GLUPY_OPENDIR] = (long)fop; } void -set_opendir_cbk (long py_this, fop_opendir_cbk_t cbk) +set_opendir_cbk(long py_this, fop_opendir_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_OPENDIR] = (long)cbk; + priv->cbks[GLUPY_OPENDIR] = (long)cbk; } /* FOP: READDIR */ int32_t -glupy_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +glupy_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_READDIR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_READDIR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_readdir_cbk_t)(priv->cbks[GLUPY_READDIR]))( - frame, cookie, this, op_ret, op_errno, - entries, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_readdir_cbk_t)(priv->cbks[GLUPY_READDIR]))( + frame, cookie, this, op_ret, op_errno, entries, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, - xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); + return 0; } int32_t -glupy_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, dict_t *xdata) +glupy_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_READDIR]) { - goto wind; - } + if (!priv->fops[GLUPY_READDIR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_readdir_t)(priv->fops[GLUPY_READDIR]))( - frame, this, fd, size, offset, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_readdir_t)(priv->fops[GLUPY_READDIR]))(frame, this, fd, size, + offset, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_readdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir,fd, size, offset, xdata); - return 0; + STACK_WIND(frame, glupy_readdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); + return 0; } void wind_readdir(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, off_t offset, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_readdir_cbk,xl,xl->fops->readdir,fd,size,offset,xdata); + STACK_WIND(frame, glupy_readdir_cbk, xl, xl->fops->readdir, fd, size, + offset, xdata); } void -unwind_readdir (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +unwind_readdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, gf_dirent_t *entries, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(readdir,frame,op_ret,op_errno, - entries, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); } void -set_readdir_fop (long py_this, fop_readdir_t fop) +set_readdir_fop(long py_this, fop_readdir_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_READDIR] = (long)fop; + priv->fops[GLUPY_READDIR] = (long)fop; } void -set_readdir_cbk (long py_this, fop_readdir_cbk_t cbk) +set_readdir_cbk(long py_this, fop_readdir_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_READDIR] = (long)cbk; + priv->cbks[GLUPY_READDIR] = (long)cbk; } - /* FOP: READDIRP */ int32_t -glupy_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +glupy_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_READDIRP]) { - goto unwind; - } + if (!priv->cbks[GLUPY_READDIRP]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_readdirp_cbk_t)(priv->cbks[GLUPY_READDIRP]))( - frame, cookie, this, op_ret, op_errno, - entries, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_readdirp_cbk_t)(priv->cbks[GLUPY_READDIRP]))( + frame, cookie, this, op_ret, op_errno, entries, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, - xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); + return 0; } int32_t -glupy_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, dict_t *xdata) +glupy_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_READDIRP]) { - goto wind; - } + if (!priv->fops[GLUPY_READDIRP]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_readdirp_t)(priv->fops[GLUPY_READDIRP]))( - frame, this, fd, size, offset, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_readdirp_t)(priv->fops[GLUPY_READDIRP]))(frame, this, fd, size, + offset, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_readdirp_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp,fd, size, offset, xdata); - return 0; + STACK_WIND(frame, glupy_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata); + return 0; } void -wind_readdirp (call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, - off_t offset, dict_t *xdata) +wind_readdirp(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_readdirp_cbk,xl,xl->fops->readdirp,fd,size,offset,xdata); + STACK_WIND(frame, glupy_readdirp_cbk, xl, xl->fops->readdirp, fd, size, + offset, xdata); } void -unwind_readdirp (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, - dict_t *xdata) +unwind_readdirp(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(readdirp,frame,op_ret,op_errno, - entries, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); } void -set_readdirp_fop (long py_this, fop_readdirp_t fop) +set_readdirp_fop(long py_this, fop_readdirp_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_READDIRP] = (long)fop; + priv->fops[GLUPY_READDIRP] = (long)fop; } void -set_readdirp_cbk (long py_this, fop_readdirp_cbk_t cbk) +set_readdirp_cbk(long py_this, fop_readdirp_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_READDIRP] = (long)cbk; + priv->cbks[GLUPY_READDIRP] = (long)cbk; } - /* FOP:STAT */ int32_t -glupy_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) +glupy_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_STAT]) { - goto unwind; - } + if (!priv->cbks[GLUPY_STAT]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_stat_cbk_t)(priv->cbks[GLUPY_STAT]))( - frame, cookie, this, op_ret, op_errno, - buf, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_stat_cbk_t)(priv->cbks[GLUPY_STAT]))( + frame, cookie, this, op_ret, op_errno, buf, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); + return 0; } int32_t -glupy_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +glupy_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_STAT]) { - goto wind; - } + if (!priv->fops[GLUPY_STAT]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_stat_t)(priv->fops[GLUPY_STAT]))( - frame, this, loc, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_stat_t)(priv->fops[GLUPY_STAT]))(frame, this, loc, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, xdata); - return 0; + STACK_WIND(frame, glupy_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + return 0; } void -wind_stat (call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) +wind_stat(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_stat_cbk,xl,xl->fops->stat,loc,xdata); + STACK_WIND(frame, glupy_stat_cbk, xl, xl->fops->stat, loc, xdata); } void -unwind_stat (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +unwind_stat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(stat,frame,op_ret,op_errno, - buf,xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); } void -set_stat_fop (long py_this, fop_stat_t fop) +set_stat_fop(long py_this, fop_stat_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_STAT] = (long)fop; + priv->fops[GLUPY_STAT] = (long)fop; } void -set_stat_cbk (long py_this, fop_stat_cbk_t cbk) +set_stat_cbk(long py_this, fop_stat_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_STAT] = (long)cbk; + priv->cbks[GLUPY_STAT] = (long)cbk; } - /* FOP: FSTAT */ int32_t -glupy_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) +glupy_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_FSTAT]) { - goto unwind; - } + if (!priv->cbks[GLUPY_FSTAT]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_fstat_cbk_t)(priv->cbks[GLUPY_FSTAT]))( - frame, cookie, this, op_ret, op_errno, - buf, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_fstat_cbk_t)(priv->cbks[GLUPY_FSTAT]))( + frame, cookie, this, op_ret, op_errno, buf, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } int32_t -glupy_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *xdata) +glupy_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_FSTAT]) { - goto wind; - } + if (!priv->fops[GLUPY_FSTAT]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_fstat_t)(priv->fops[GLUPY_FSTAT]))( - frame, this, fd, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_fstat_t)(priv->fops[GLUPY_FSTAT]))(frame, this, fd, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_fstat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd, xdata); - return 0; + STACK_WIND(frame, glupy_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; } void -wind_fstat (call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *xdata) +wind_fstat(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_fstat_cbk,xl,xl->fops->fstat,fd,xdata); + STACK_WIND(frame, glupy_fstat_cbk, xl, xl->fops->fstat, fd, xdata); } void -unwind_fstat (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +unwind_fstat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(fstat,frame,op_ret,op_errno, - buf,xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); } void -set_fstat_fop (long py_this, fop_fstat_t fop) +set_fstat_fop(long py_this, fop_fstat_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_FSTAT] = (long)fop; + priv->fops[GLUPY_FSTAT] = (long)fop; } void -set_fstat_cbk (long py_this, fop_fstat_cbk_t cbk) +set_fstat_cbk(long py_this, fop_fstat_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_FSTAT] = (long)cbk; + priv->cbks[GLUPY_FSTAT] = (long)cbk; } /* FOP:STATFS */ int32_t -glupy_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata) +glupy_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_STATFS]) { - goto unwind; - } + if (!priv->cbks[GLUPY_STATFS]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_statfs_cbk_t)(priv->cbks[GLUPY_STATFS]))( - frame, cookie, this, op_ret, op_errno, - buf, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_statfs_cbk_t)(priv->cbks[GLUPY_STATFS]))( + frame, cookie, this, op_ret, op_errno, buf, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); + return 0; } int32_t -glupy_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +glupy_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_STATFS]) { - goto wind; - } + if (!priv->fops[GLUPY_STATFS]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_statfs_t)(priv->fops[GLUPY_STATFS]))( - frame, this, loc, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_statfs_t)(priv->fops[GLUPY_STATFS]))(frame, this, loc, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_statfs_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, loc, xdata); - return 0; + STACK_WIND(frame, glupy_statfs_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; } void -wind_statfs (call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) +wind_statfs(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND(frame,glupy_statfs_cbk,xl,xl->fops->statfs,loc,xdata); + STACK_WIND(frame, glupy_statfs_cbk, xl, xl->fops->statfs, loc, xdata); } void -unwind_statfs (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, - dict_t *xdata) +unwind_statfs(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct statvfs *buf, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT(statfs,frame,op_ret,op_errno, - buf,xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); } void -set_statfs_fop (long py_this, fop_statfs_t fop) +set_statfs_fop(long py_this, fop_statfs_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_STATFS] = (long)fop; + priv->fops[GLUPY_STATFS] = (long)fop; } void -set_statfs_cbk (long py_this, fop_statfs_cbk_t cbk) +set_statfs_cbk(long py_this, fop_statfs_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_STATFS] = (long)cbk; + priv->cbks[GLUPY_STATFS] = (long)cbk; } - /* FOP: SETXATTR */ int32_t -glupy_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +glupy_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_SETXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_SETXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_setxattr_cbk_t)(priv->cbks[GLUPY_SETXATTR]))( - frame, cookie, this, op_ret, op_errno, - xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_setxattr_cbk_t)(priv->cbks[GLUPY_SETXATTR]))( + frame, cookie, this, op_ret, op_errno, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); + return 0; } int32_t -glupy_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags, dict_t *xdata) +glupy_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int32_t flags, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_SETXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_SETXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_setxattr_t)(priv->fops[GLUPY_SETXATTR]))( - frame, this, loc, dict, flags, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_setxattr_t)(priv->fops[GLUPY_SETXATTR]))(frame, this, loc, dict, + flags, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_setxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, loc, dict, - flags, xdata); - return 0; + STACK_WIND(frame, glupy_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); + return 0; } void -wind_setxattr (call_frame_t *frame, xlator_t *xl, loc_t *loc, - dict_t *dict, int32_t flags, dict_t *xdata) +wind_setxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *dict, + int32_t flags, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_setxattr_cbk, xl, xl->fops->setxattr, - loc, dict, flags, xdata); + STACK_WIND(frame, glupy_setxattr_cbk, xl, xl->fops->setxattr, loc, dict, + flags, xdata); } - void -unwind_setxattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +unwind_setxattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); } void -set_setxattr_fop (long py_this, fop_setxattr_t fop) +set_setxattr_fop(long py_this, fop_setxattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_SETXATTR] = (long)fop; + priv->fops[GLUPY_SETXATTR] = (long)fop; } void -set_setxattr_cbk (long py_this, fop_setxattr_cbk_t cbk) +set_setxattr_cbk(long py_this, fop_setxattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_SETXATTR] = (long)cbk; + priv->cbks[GLUPY_SETXATTR] = (long)cbk; } /* FOP: GETXATTR */ int32_t -glupy_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +glupy_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_GETXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_GETXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_getxattr_cbk_t)(priv->cbks[GLUPY_GETXATTR]))( - frame, cookie, this, op_ret, op_errno, dict, - xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_getxattr_cbk_t)(priv->cbks[GLUPY_GETXATTR]))( + frame, cookie, this, op_ret, op_errno, dict, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, - xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int32_t -glupy_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +glupy_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_GETXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_GETXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_getxattr_t)(priv->fops[GLUPY_GETXATTR]))( - frame, this, loc, name, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_getxattr_t)(priv->fops[GLUPY_GETXATTR]))(frame, this, loc, name, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_getxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, loc, name, - xdata); - return 0; + STACK_WIND(frame, glupy_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); + return 0; } void -wind_getxattr (call_frame_t *frame, xlator_t *xl, loc_t *loc, - const char *name, dict_t *xdata) +wind_getxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, const char *name, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_getxattr_cbk, xl, xl->fops->getxattr, - loc, name, xdata); + STACK_WIND(frame, glupy_getxattr_cbk, xl, xl->fops->getxattr, loc, name, + xdata); } - void -unwind_getxattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +unwind_getxattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, - xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); } - void -set_getxattr_fop (long py_this, fop_getxattr_t fop) +set_getxattr_fop(long py_this, fop_getxattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_GETXATTR] = (long)fop; + priv->fops[GLUPY_GETXATTR] = (long)fop; } - void -set_getxattr_cbk (long py_this, fop_getxattr_cbk_t cbk) +set_getxattr_cbk(long py_this, fop_getxattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_GETXATTR] = (long)cbk; + priv->cbks[GLUPY_GETXATTR] = (long)cbk; } /* FOP: FSETXATTR */ int32_t -glupy_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +glupy_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_FSETXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_FSETXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_fsetxattr_cbk_t)(priv->cbks[GLUPY_FSETXATTR]))( - frame, cookie, this, op_ret, op_errno, - xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_fsetxattr_cbk_t)(priv->cbks[GLUPY_FSETXATTR]))( + frame, cookie, this, op_ret, op_errno, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); + return 0; } int32_t -glupy_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags, dict_t *xdata) +glupy_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_FSETXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_FSETXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_fsetxattr_t)(priv->fops[GLUPY_FSETXATTR]))( - frame, this, fd, dict, flags, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_fsetxattr_t)(priv->fops[GLUPY_FSETXATTR]))(frame, this, fd, + dict, flags, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_fsetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, fd, dict, - flags, xdata); - return 0; + STACK_WIND(frame, glupy_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } void -wind_fsetxattr (call_frame_t *frame, xlator_t *xl, fd_t *fd, - dict_t *dict, int32_t flags, dict_t *xdata) +wind_fsetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_fsetxattr_cbk, xl, xl->fops->fsetxattr, - fd, dict, flags, xdata); + STACK_WIND(frame, glupy_fsetxattr_cbk, xl, xl->fops->fsetxattr, fd, dict, + flags, xdata); } - void -unwind_fsetxattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +unwind_fsetxattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); } void -set_fsetxattr_fop (long py_this, fop_fsetxattr_t fop) +set_fsetxattr_fop(long py_this, fop_fsetxattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_FSETXATTR] = (long)fop; + priv->fops[GLUPY_FSETXATTR] = (long)fop; } void -set_fsetxattr_cbk (long py_this, fop_fsetxattr_cbk_t cbk) +set_fsetxattr_cbk(long py_this, fop_fsetxattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_FSETXATTR] = (long)cbk; + priv->cbks[GLUPY_FSETXATTR] = (long)cbk; } /* FOP: FGETXATTR */ int32_t -glupy_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +glupy_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_FGETXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_FGETXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_fgetxattr_cbk_t)(priv->cbks[GLUPY_FGETXATTR]))( - frame, cookie, this, op_ret, op_errno, dict, - xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_fgetxattr_cbk_t)(priv->cbks[GLUPY_FGETXATTR]))( + frame, cookie, this, op_ret, op_errno, dict, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, - xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int32_t -glupy_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +glupy_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_FGETXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_FGETXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_fgetxattr_t)(priv->fops[GLUPY_FGETXATTR]))( - frame, this, fd, name, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_fgetxattr_t)(priv->fops[GLUPY_FGETXATTR]))(frame, this, fd, + name, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_fgetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, fd, name, - xdata); - return 0; + STACK_WIND(frame, glupy_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; } void -wind_fgetxattr (call_frame_t *frame, xlator_t *xl, fd_t *fd, - const char *name, dict_t *xdata) +wind_fgetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_fgetxattr_cbk, xl, xl->fops->fgetxattr, - fd, name, xdata); + STACK_WIND(frame, glupy_fgetxattr_cbk, xl, xl->fops->fgetxattr, fd, name, + xdata); } - void -unwind_fgetxattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, - dict_t *xdata) +unwind_fgetxattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, - xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); } - void -set_fgetxattr_fop (long py_this, fop_fgetxattr_t fop) +set_fgetxattr_fop(long py_this, fop_fgetxattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_FGETXATTR] = (long)fop; + priv->fops[GLUPY_FGETXATTR] = (long)fop; } - void -set_fgetxattr_cbk (long py_this, fop_fgetxattr_cbk_t cbk) +set_fgetxattr_cbk(long py_this, fop_fgetxattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_FGETXATTR] = (long)cbk; + priv->cbks[GLUPY_FGETXATTR] = (long)cbk; } /* FOP:REMOVEXATTR */ int32_t -glupy_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +glupy_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_REMOVEXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_REMOVEXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_removexattr_cbk_t)(priv->cbks[GLUPY_REMOVEXATTR]))( - frame, cookie, this, op_ret, op_errno, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_removexattr_cbk_t)(priv->cbks[GLUPY_REMOVEXATTR]))( + frame, cookie, this, op_ret, op_errno, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); + return 0; } int32_t -glupy_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +glupy_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_REMOVEXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_REMOVEXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_removexattr_t)(priv->fops[GLUPY_REMOVEXATTR]))( - frame, this, loc, name, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_removexattr_t)(priv->fops[GLUPY_REMOVEXATTR]))(frame, this, loc, + name, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_removexattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, loc, name, - xdata); - return 0; + STACK_WIND(frame, glupy_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } void -wind_removexattr (call_frame_t *frame, xlator_t *xl, loc_t *loc, - const char *name, dict_t *xdata) +wind_removexattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, + const char *name, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_removexattr_cbk, xl, xl->fops->removexattr, - loc, name, xdata); + STACK_WIND(frame, glupy_removexattr_cbk, xl, xl->fops->removexattr, loc, + name, xdata); } - void -unwind_removexattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +unwind_removexattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); } void -set_removexattr_fop (long py_this, fop_removexattr_t fop) +set_removexattr_fop(long py_this, fop_removexattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_REMOVEXATTR] = (long)fop; + priv->fops[GLUPY_REMOVEXATTR] = (long)fop; } void -set_removexattr_cbk (long py_this, fop_removexattr_cbk_t cbk) +set_removexattr_cbk(long py_this, fop_removexattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_REMOVEXATTR] = (long)cbk; + priv->cbks[GLUPY_REMOVEXATTR] = (long)cbk; } - /* FOP:FREMOVEXATTR */ int32_t -glupy_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +glupy_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_FREMOVEXATTR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_FREMOVEXATTR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_fremovexattr_cbk_t)(priv->cbks[GLUPY_FREMOVEXATTR]))( - frame, cookie, this, op_ret, op_errno, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_fremovexattr_cbk_t)(priv->cbks[GLUPY_FREMOVEXATTR]))( + frame, cookie, this, op_ret, op_errno, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); + return 0; } int32_t -glupy_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, +glupy_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_FREMOVEXATTR]) { - goto wind; - } + if (!priv->fops[GLUPY_FREMOVEXATTR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_fremovexattr_t)(priv->fops[GLUPY_FREMOVEXATTR]))( - frame, this, fd, name, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_fremovexattr_t)(priv->fops[GLUPY_FREMOVEXATTR]))( + frame, this, fd, name, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_fremovexattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, fd, name, - xdata); - return 0; + STACK_WIND(frame, glupy_fremovexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } void -wind_fremovexattr (call_frame_t *frame, xlator_t *xl, fd_t *fd, - const char *name, dict_t *xdata) +wind_fremovexattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_fremovexattr_cbk, xl, xl->fops->fremovexattr, - fd, name, xdata); + STACK_WIND(frame, glupy_fremovexattr_cbk, xl, xl->fops->fremovexattr, fd, + name, xdata); } - void -unwind_fremovexattr (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +unwind_fremovexattr(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); - + frame->local = NULL; + STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); } void -set_fremovexattr_fop (long py_this, fop_fremovexattr_t fop) +set_fremovexattr_fop(long py_this, fop_fremovexattr_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_FREMOVEXATTR] = (long)fop; + priv->fops[GLUPY_FREMOVEXATTR] = (long)fop; } void -set_fremovexattr_cbk (long py_this, fop_fremovexattr_cbk_t cbk) +set_fremovexattr_cbk(long py_this, fop_fremovexattr_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_FREMOVEXATTR] = (long)cbk; + priv->cbks[GLUPY_FREMOVEXATTR] = (long)cbk; } - /* FOP: LINK*/ int32_t -glupy_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +glupy_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_LINK]) { - goto unwind; - } + if (!priv->cbks[GLUPY_LINK]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_link_cbk_t)(priv->cbks[GLUPY_LINK]))( - frame, cookie, this, op_ret, op_errno, - inode, buf, preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_link_cbk_t)(priv->cbks[GLUPY_LINK]))( + frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } int32_t glupy_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_LINK]) { - goto wind; - } + if (!priv->fops[GLUPY_LINK]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_link_t)(priv->fops[GLUPY_LINK]))( - frame, this, oldloc, newloc, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_link_t)(priv->fops[GLUPY_LINK]))(frame, this, oldloc, newloc, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_link_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, oldloc, newloc, - xdata); - return 0; + STACK_WIND(frame, glupy_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } void -wind_link (call_frame_t *frame, xlator_t *xl, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +wind_link(call_frame_t *frame, xlator_t *xl, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_link_cbk, xl, xl->fops->link, - oldloc, newloc, xdata); + STACK_WIND(frame, glupy_link_cbk, xl, xl->fops->link, oldloc, newloc, + xdata); } void -unwind_link (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +unwind_link(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); } void -set_link_fop (long py_this, fop_link_t fop) +set_link_fop(long py_this, fop_link_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_LINK] = (long)fop; + priv->fops[GLUPY_LINK] = (long)fop; } void -set_link_cbk (long py_this, fop_link_cbk_t cbk) +set_link_cbk(long py_this, fop_link_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_LINK] = (long)cbk; + priv->cbks[GLUPY_LINK] = (long)cbk; } /* FOP: SYMLINK*/ int32_t -glupy_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +glupy_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_SYMLINK]) { - goto unwind; - } + if (!priv->cbks[GLUPY_SYMLINK]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_symlink_cbk_t)(priv->cbks[GLUPY_SYMLINK]))( - frame, cookie, this, op_ret, op_errno, - inode, buf, preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_symlink_cbk_t)(priv->cbks[GLUPY_SYMLINK]))( + frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } int32_t glupy_symlink(call_frame_t *frame, xlator_t *this, const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_SYMLINK]) { - goto wind; - } + if (!priv->fops[GLUPY_SYMLINK]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_symlink_t)(priv->fops[GLUPY_SYMLINK]))( - frame, this, linkname, loc, umask, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_symlink_t)(priv->fops[GLUPY_SYMLINK]))(frame, this, linkname, + loc, umask, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_symlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, linkname, loc, - umask, xdata); - return 0; + STACK_WIND(frame, glupy_symlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata); + return 0; } void -wind_symlink (call_frame_t *frame, xlator_t *xl, const char *linkname, - loc_t *loc, mode_t umask, dict_t *xdata) +wind_symlink(call_frame_t *frame, xlator_t *xl, const char *linkname, + loc_t *loc, mode_t umask, dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_symlink_cbk, xl, xl->fops->symlink, - linkname, loc, umask, xdata); + STACK_WIND(frame, glupy_symlink_cbk, xl, xl->fops->symlink, linkname, loc, + umask, xdata); } void -unwind_symlink (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +unwind_symlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); } void -set_symlink_fop (long py_this, fop_symlink_t fop) +set_symlink_fop(long py_this, fop_symlink_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_SYMLINK] = (long)fop; + priv->fops[GLUPY_SYMLINK] = (long)fop; } void -set_symlink_cbk (long py_this, fop_symlink_cbk_t cbk) +set_symlink_cbk(long py_this, fop_symlink_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_SYMLINK] = (long)cbk; + priv->cbks[GLUPY_SYMLINK] = (long)cbk; } - /* FOP: READLINK */ int32_t -glupy_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +glupy_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_READLINK]) { - goto unwind; - } + if (!priv->cbks[GLUPY_READLINK]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_readlink_cbk_t)(priv->cbks[GLUPY_READLINK]))( - frame, cookie, this, op_ret, op_errno, - path, buf, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_readlink_cbk_t)(priv->cbks[GLUPY_READLINK]))( + frame, cookie, this, op_ret, op_errno, path, buf, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, - buf, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); + return 0; } int32_t -glupy_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size, dict_t *xdata) +glupy_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_READLINK]) { - goto wind; - } + if (!priv->fops[GLUPY_READLINK]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_readlink_t)(priv->fops[GLUPY_READLINK]))( - frame, this, loc, size, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_readlink_t)(priv->fops[GLUPY_READLINK]))(frame, this, loc, size, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_readlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, loc, - size, xdata); - return 0; + STACK_WIND(frame, glupy_readlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, loc, size, xdata); + return 0; } void -wind_readlink (call_frame_t *frame, xlator_t *xl, loc_t *loc, - size_t size, dict_t *xdata) +wind_readlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, size_t size, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_readlink_cbk, xl, xl->fops->readlink, - loc, size, xdata); + STACK_WIND(frame, glupy_readlink_cbk, xl, xl->fops->readlink, loc, size, + xdata); } void -unwind_readlink (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +unwind_readlink(call_frame_t *frame, long cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, buf, - xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); } void -set_readlink_fop (long py_this, fop_readlink_t fop) +set_readlink_fop(long py_this, fop_readlink_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_READLINK] = (long)fop; + priv->fops[GLUPY_READLINK] = (long)fop; } void -set_readlink_cbk (long py_this, fop_readlink_cbk_t cbk) +set_readlink_cbk(long py_this, fop_readlink_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_READLINK] = (long)cbk; + priv->cbks[GLUPY_READLINK] = (long)cbk; } - /* FOP: UNLINK */ int32_t -glupy_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, - dict_t *xdata) +glupy_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_UNLINK]) { - goto unwind; - } + if (!priv->cbks[GLUPY_UNLINK]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_unlink_cbk_t)(priv->cbks[GLUPY_UNLINK]))( - frame, cookie, this, op_ret, op_errno, - preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_unlink_cbk_t)(priv->cbks[GLUPY_UNLINK]))( + frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, preparent, - postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } int32_t -glupy_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - int xflags, dict_t *xdata) +glupy_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_UNLINK]) { - goto wind; - } + if (!priv->fops[GLUPY_UNLINK]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_unlink_t)(priv->fops[GLUPY_UNLINK]))( - frame, this, loc, xflags, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_unlink_t)(priv->fops[GLUPY_UNLINK]))(frame, this, loc, xflags, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_unlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, loc, - xflags, xdata); - return 0; + STACK_WIND(frame, glupy_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflags, xdata); + return 0; } void -wind_unlink (call_frame_t *frame, xlator_t *xl, loc_t *loc, - int xflags, dict_t *xdata) +wind_unlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, + dict_t *xdata) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_unlink_cbk, xl, xl->fops->unlink, - loc, xflags, xdata); + STACK_WIND(frame, glupy_unlink_cbk, xl, xl->fops->unlink, loc, xflags, + xdata); } void -unwind_unlink (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, - dict_t *xdata) +unwind_unlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, + xdata); } void -set_unlink_fop (long py_this, fop_unlink_t fop) +set_unlink_fop(long py_this, fop_unlink_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_UNLINK] = (long)fop; + priv->fops[GLUPY_UNLINK] = (long)fop; } void -set_unlink_cbk (long py_this, fop_unlink_cbk_t cbk) +set_unlink_cbk(long py_this, fop_unlink_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_UNLINK] = (long)cbk; + priv->cbks[GLUPY_UNLINK] = (long)cbk; } - /* FOP: MKDIR */ int32_t -glupy_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +glupy_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_MKDIR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_MKDIR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_mkdir_cbk_t)(priv->cbks[GLUPY_MKDIR]))( - frame, cookie, this, op_ret, op_errno, - inode, buf, preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_mkdir_cbk_t)(priv->cbks[GLUPY_MKDIR]))( + frame, cookie, this, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } int32_t -glupy_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - mode_t umask, dict_t *xdata) +glupy_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_MKDIR]) { - goto wind; - } + if (!priv->fops[GLUPY_MKDIR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_mkdir_t)(priv->fops[GLUPY_MKDIR]))( - frame, this, loc, mode, umask, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_mkdir_t)(priv->fops[GLUPY_MKDIR]))(frame, this, loc, mode, + umask, xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_mkdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, - xdata); - return 0; + STACK_WIND(frame, glupy_mkdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); + return 0; } void -wind_mkdir (call_frame_t *frame, xlator_t *xl, loc_t *loc, mode_t mode, - mode_t umask, dict_t *xdata) +wind_mkdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { + xlator_t *this = THIS; - xlator_t *this = THIS; - - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - STACK_WIND (frame, glupy_mkdir_cbk, xl, xl->fops->mkdir, - loc, mode, umask, xdata); + STACK_WIND(frame, glupy_mkdir_cbk, xl, xl->fops->mkdir, loc, mode, umask, + xdata); } void -unwind_mkdir (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +unwind_mkdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); } void -set_mkdir_fop (long py_this, fop_mkdir_t fop) +set_mkdir_fop(long py_this, fop_mkdir_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_MKDIR] = (long)fop; + priv->fops[GLUPY_MKDIR] = (long)fop; } void -set_mkdir_cbk (long py_this, fop_mkdir_cbk_t cbk) +set_mkdir_cbk(long py_this, fop_mkdir_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_MKDIR] = (long)cbk; + priv->cbks[GLUPY_MKDIR] = (long)cbk; } - /* FOP: RMDIR */ int32_t -glupy_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, - dict_t *xdata) +glupy_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; - if (!priv->cbks[GLUPY_RMDIR]) { - goto unwind; - } + if (!priv->cbks[GLUPY_RMDIR]) { + goto unwind; + } - gstate = glupy_enter(); - ret = ((fop_rmdir_cbk_t)(priv->cbks[GLUPY_RMDIR]))( - frame, cookie, this, op_ret, op_errno, - preparent, postparent, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + ret = ((fop_rmdir_cbk_t)(priv->cbks[GLUPY_RMDIR]))( + frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); + glupy_leave(gstate); - return ret; + return ret; unwind: - frame->local = NULL; - STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, preparent, - postparent, xdata); - return 0; + frame->local = NULL; + STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } int32_t -glupy_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, - int xflags, dict_t *xdata) +glupy_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, + dict_t *xdata) { - glupy_private_t *priv = this->private; - PyGILState_STATE gstate; - int32_t ret; - static long next_id = 0; + glupy_private_t *priv = this->private; + PyGILState_STATE gstate; + int32_t ret; + static long next_id = 0; - if (!priv->fops[GLUPY_RMDIR]) { - goto wind; - } + if (!priv->fops[GLUPY_RMDIR]) { + goto wind; + } - gstate = glupy_enter(); - frame->local = (void *)++next_id; - ret = ((fop_rmdir_t)(priv->fops[GLUPY_RMDIR]))( - frame, this, loc, xflags, xdata); - glupy_leave(gstate); + gstate = glupy_enter(); + frame->local = (void *)++next_id; + ret = ((fop_rmdir_t)(priv->fops[GLUPY_RMDIR]))(frame, this, loc, xflags, + xdata); + glupy_leave(gstate); - return ret; + return ret; wind: - STACK_WIND (frame, glupy_rmdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rmdir, loc, - xflags, xdata); - return 0; + STACK_WIND(frame, glupy_rmdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, loc, xflags, xdata); + return 0; } void -wind_rmdir (call_frame_t *frame, xlator_t *xl, loc_t *loc, - int xflags, dict_t *xdata) +wind_rmdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, + dict_t *xdata) { + xlator_t *this = THIS; - xlator_t *this = THIS; + if (!xl || (xl == this)) { + xl = FIRST_CHILD(this); + } - if (!xl || (xl == this)) { - xl = FIRST_CHILD(this); - } - - STACK_WIND (frame, glupy_rmdir_cbk, xl, xl->fops->rmdir, - loc, xflags, xdata); + STACK_WIND(frame, glupy_rmdir_cbk, xl, xl->fops->rmdir, loc, xflags, xdata); } void -unwind_rmdir (call_frame_t *frame, long cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, - dict_t *xdata) +unwind_rmdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { - frame->local = NULL; - STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent, xdata); + frame->local = NULL; + STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, + xdata); } void -set_rmdir_fop (long py_this, fop_rmdir_t fop) +set_rmdir_fop(long py_this, fop_rmdir_t fop) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->fops[GLUPY_RMDIR] = (long)fop; + priv->fops[GLUPY_RMDIR] = (long)fop; } void -set_rmdir_cbk (long py_this, fop_rmdir_cbk_t cbk) +set_rmdir_cbk(long py_this, fop_rmdir_cbk_t cbk) { - glupy_private_t *priv = ((xlator_t *)py_this)->private; + glupy_private_t *priv = ((xlator_t *)py_this)->private; - priv->cbks[GLUPY_RMDIR] = (long)cbk; + priv->cbks[GLUPY_RMDIR] = (long)cbk; } - /* NON-FOP-SPECIFIC CODE */ - long -get_id (call_frame_t *frame) +get_id(call_frame_t *frame) { - return (long)(frame->local); + return (long)(frame->local); } uint64_t -get_rootunique (call_frame_t *frame) +get_rootunique(call_frame_t *frame) { - return frame->root->unique; + return frame->root->unique; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; + if (!this) + return ret; - ret = xlator_mem_acct_init (this, gf_glupy_mt_end); - - if (ret != 0) { - gf_log(this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_glupy_mt_end); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); return ret; + } + + return ret; } static void py_error_log(const char *name, PyObject *pystr) { #if PY_MAJOR_VERSION > 2 - char scr[256]; - if (PyUnicode_Check(pystr)) { - PyObject *tmp = - PyUnicode_AsEncodedString(pystr, "UTF-8", "strict"); - if (tmp != NULL) { - strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); - Py_DECREF(tmp); - } else { - strncpy(scr, "string encoding error", sizeof(scr)); - } - } else if (PyBytes_Check(pystr)) { - strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); + char scr[256]; + if (PyUnicode_Check(pystr)) { + PyObject *tmp = PyUnicode_AsEncodedString(pystr, "UTF-8", "strict"); + if (tmp != NULL) { + strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); + Py_DECREF(tmp); } else { - strncpy(scr, "string encoding error", sizeof(scr)); - } - gf_log (name, GF_LOG_ERROR, "Python error: %s", scr); + strncpy(scr, "string encoding error", sizeof(scr)); + } + } else if (PyBytes_Check(pystr)) { + strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); + } else { + strncpy(scr, "string encoding error", sizeof(scr)); + } + gf_log(name, GF_LOG_ERROR, "Python error: %s", scr); #else - gf_log (name, GF_LOG_ERROR, "Python error: %s", PyString_AsString(pystr)); + gf_log(name, GF_LOG_ERROR, "Python error: %s", PyString_AsString(pystr)); #endif } static PyObject * -encode (const char *str) +encode(const char *str) { #if PY_MAJOR_VERSION > 2 - return PyUnicode_FromString(str); + return PyUnicode_FromString(str); #else - return PyString_FromString(str); + return PyString_FromString(str); #endif } int32_t -init (xlator_t *this) -{ - glupy_private_t *priv = NULL; - char *module_name = NULL; - PyObject *py_mod_name = NULL; - PyObject *py_init_func = NULL; - PyObject *py_args = NULL; - PyObject *syspath = NULL; - PyObject *path = NULL; - PyObject *error_type = NULL; - PyObject *error_msg = NULL; - PyObject *error_bt = NULL; - static gf_boolean_t py_inited = _gf_false; - void * err_cleanup = &&err_return; - char libpython[16]; - - if (dict_get_str(this->options,"module-name",&module_name) != 0) { - gf_log (this->name, GF_LOG_ERROR, "missing module-name"); - return -1; - } - - priv = GF_CALLOC (1, sizeof (glupy_private_t), gf_glupy_mt_priv); - if (!priv) { - goto *err_cleanup; - } - this->private = priv; - err_cleanup = &&err_free_priv; - - if (!py_inited) { - /* FIXME: - * This hack is necessary because glusterfs (rightly) loads - * glupy.so with RTLD_LOCAL but glupy needs libpython to be - * loaded with RTLD_GLOBAL even though glupy is correctly - * linked with libpython. - * This is needed because one of the internal modules of - * python 2.x (lib-dynload/_struct.so) does not explicitly - * link with libpython. - */ - snprintf(libpython, sizeof(libpython), "libpython%d.%d.so", - PY_MAJOR_VERSION, PY_MINOR_VERSION); - if (!dlopen (libpython, RTLD_NOW|RTLD_GLOBAL)) { - gf_msg (this->name, GF_LOG_WARNING, 0, - LG_MSG_DLOPEN_FAILED, "dlopen(%s) failed: %s", - libpython, dlerror ()); - } - - /* - * This must be done before Py_Initialize(), - * because it will duplicate the environment, - * and fail to see later environment updates. - */ - setenv("PATH_GLUSTERFS_GLUPY_MODULE", - PATH_GLUSTERFS_GLUPY_MODULE, 1); - - Py_Initialize(); - PyEval_InitThreads(); - - (void)pthread_key_create(&gil_init_key,NULL); - (void)pthread_setspecific(gil_init_key,(void *)1); - - /* PyEval_InitThreads takes this "for" us. No thanks. */ - PyEval_ReleaseLock(); - py_inited = _gf_true; - } - - /* Adjust python's path */ - syspath = PySys_GetObject("path"); - path = encode(GLUSTER_PYTHON_PATH); - PyList_Append(syspath, path); - Py_DECREF(path); - - py_mod_name = encode(module_name); - if (!py_mod_name) { - gf_log (this->name, GF_LOG_ERROR, "could not create name"); - if (PyErr_Occurred()) { - PyErr_Fetch (&error_type, &error_msg, &error_bt); - py_error_log(this->name, error_msg); - } - goto *err_cleanup; - } - - gf_log (this->name, GF_LOG_DEBUG, "py_mod_name = %s", module_name); - priv->py_module = PyImport_Import(py_mod_name); - Py_DECREF(py_mod_name); - if (!priv->py_module) { - gf_log (this->name, GF_LOG_ERROR, "Python import of %s failed", - module_name); - if (PyErr_Occurred()) { - PyErr_Fetch (&error_type, &error_msg, &error_bt); - py_error_log (this->name, error_msg); - } - goto *err_cleanup; - } - gf_log (this->name, GF_LOG_INFO, "Import of %s succeeded", module_name); - err_cleanup = &&err_deref_module; - - py_init_func = PyObject_GetAttrString(priv->py_module, "xlator"); - if (!py_init_func || !PyCallable_Check(py_init_func)) { - gf_log (this->name, GF_LOG_ERROR, "missing init func"); - if (PyErr_Occurred()) { - PyErr_Fetch (&error_type, &error_msg, &error_bt); - py_error_log (this->name, error_msg); - } - goto *err_cleanup; - } - err_cleanup = &&err_deref_init; - - py_args = PyTuple_New(1); - if (!py_args) { - gf_log (this->name, GF_LOG_ERROR, "could not create args"); - if (PyErr_Occurred()) { - PyErr_Fetch (&error_type, &error_msg, &error_bt); - py_error_log (this->name, error_msg); - } - goto *err_cleanup; - } - PyTuple_SetItem(py_args,0,PyLong_FromLong((long)this)); - - /* TBD: pass in list of children */ - priv->py_xlator = PyObject_CallObject(py_init_func, py_args); - Py_DECREF(py_args); - if (!priv->py_xlator) { - gf_log (this->name, GF_LOG_ERROR, "Python init failed"); - if (PyErr_Occurred()) { - PyErr_Fetch (&error_type, &error_msg, &error_bt); - py_error_log (this->name, error_msg); - } - goto *err_cleanup; - } - gf_log (this->name, GF_LOG_DEBUG, "init returned %p", priv->py_xlator); - - return 0; +init(xlator_t *this) +{ + glupy_private_t *priv = NULL; + char *module_name = NULL; + PyObject *py_mod_name = NULL; + PyObject *py_init_func = NULL; + PyObject *py_args = NULL; + PyObject *syspath = NULL; + PyObject *path = NULL; + PyObject *error_type = NULL; + PyObject *error_msg = NULL; + PyObject *error_bt = NULL; + static gf_boolean_t py_inited = _gf_false; + void *err_cleanup = &&err_return; + char libpython[16]; + + if (dict_get_str(this->options, "module-name", &module_name) != 0) { + gf_log(this->name, GF_LOG_ERROR, "missing module-name"); + return -1; + } + + priv = GF_CALLOC(1, sizeof(glupy_private_t), gf_glupy_mt_priv); + if (!priv) { + goto *err_cleanup; + } + this->private = priv; + err_cleanup = &&err_free_priv; + + if (!py_inited) { + /* FIXME: + * This hack is necessary because glusterfs (rightly) loads + * glupy.so with RTLD_LOCAL but glupy needs libpython to be + * loaded with RTLD_GLOBAL even though glupy is correctly + * linked with libpython. + * This is needed because one of the internal modules of + * python 2.x (lib-dynload/_struct.so) does not explicitly + * link with libpython. + */ + snprintf(libpython, sizeof(libpython), "libpython%d.%d.so", + PY_MAJOR_VERSION, PY_MINOR_VERSION); + if (!dlopen(libpython, RTLD_NOW | RTLD_GLOBAL)) { + gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, + "dlopen(%s) failed: %s", libpython, dlerror()); + } + + /* + * This must be done before Py_Initialize(), + * because it will duplicate the environment, + * and fail to see later environment updates. + */ + setenv("PATH_GLUSTERFS_GLUPY_MODULE", PATH_GLUSTERFS_GLUPY_MODULE, 1); + + Py_Initialize(); + PyEval_InitThreads(); + + (void)pthread_key_create(&gil_init_key, NULL); + (void)pthread_setspecific(gil_init_key, (void *)1); + + /* PyEval_InitThreads takes this "for" us. No thanks. */ + PyEval_ReleaseLock(); + py_inited = _gf_true; + } + + /* Adjust python's path */ + syspath = PySys_GetObject("path"); + path = encode(GLUSTER_PYTHON_PATH); + PyList_Append(syspath, path); + Py_DECREF(path); + + py_mod_name = encode(module_name); + if (!py_mod_name) { + gf_log(this->name, GF_LOG_ERROR, "could not create name"); + if (PyErr_Occurred()) { + PyErr_Fetch(&error_type, &error_msg, &error_bt); + py_error_log(this->name, error_msg); + } + goto *err_cleanup; + } + + gf_log(this->name, GF_LOG_DEBUG, "py_mod_name = %s", module_name); + priv->py_module = PyImport_Import(py_mod_name); + Py_DECREF(py_mod_name); + if (!priv->py_module) { + gf_log(this->name, GF_LOG_ERROR, "Python import of %s failed", + module_name); + if (PyErr_Occurred()) { + PyErr_Fetch(&error_type, &error_msg, &error_bt); + py_error_log(this->name, error_msg); + } + goto *err_cleanup; + } + gf_log(this->name, GF_LOG_INFO, "Import of %s succeeded", module_name); + err_cleanup = &&err_deref_module; + + py_init_func = PyObject_GetAttrString(priv->py_module, "xlator"); + if (!py_init_func || !PyCallable_Check(py_init_func)) { + gf_log(this->name, GF_LOG_ERROR, "missing init func"); + if (PyErr_Occurred()) { + PyErr_Fetch(&error_type, &error_msg, &error_bt); + py_error_log(this->name, error_msg); + } + goto *err_cleanup; + } + err_cleanup = &&err_deref_init; + + py_args = PyTuple_New(1); + if (!py_args) { + gf_log(this->name, GF_LOG_ERROR, "could not create args"); + if (PyErr_Occurred()) { + PyErr_Fetch(&error_type, &error_msg, &error_bt); + py_error_log(this->name, error_msg); + } + goto *err_cleanup; + } + PyTuple_SetItem(py_args, 0, PyLong_FromLong((long)this)); + + /* TBD: pass in list of children */ + priv->py_xlator = PyObject_CallObject(py_init_func, py_args); + Py_DECREF(py_args); + if (!priv->py_xlator) { + gf_log(this->name, GF_LOG_ERROR, "Python init failed"); + if (PyErr_Occurred()) { + PyErr_Fetch(&error_type, &error_msg, &error_bt); + py_error_log(this->name, error_msg); + } + goto *err_cleanup; + } + gf_log(this->name, GF_LOG_DEBUG, "init returned %p", priv->py_xlator); + + return 0; err_deref_init: - Py_DECREF(py_init_func); + Py_DECREF(py_init_func); err_deref_module: - Py_DECREF(priv->py_module); + Py_DECREF(priv->py_module); err_free_priv: - GF_FREE(priv); + GF_FREE(priv); err_return: - return -1; + return -1; } void -fini (xlator_t *this) +fini(xlator_t *this) { - glupy_private_t *priv = this->private; - - if (!priv) - return; - Py_DECREF(priv->py_xlator); - Py_DECREF(priv->py_module); - this->private = NULL; - GF_FREE (priv); + glupy_private_t *priv = this->private; + if (!priv) return; -} - -struct xlator_fops fops = { - .lookup = glupy_lookup, - .create = glupy_create, - .open = glupy_open, - .readv = glupy_readv, - .writev = glupy_writev, - .opendir = glupy_opendir, - .readdir = glupy_readdir, - .stat = glupy_stat, - .fstat = glupy_fstat, - .setxattr = glupy_setxattr, - .getxattr = glupy_getxattr, - .fsetxattr = glupy_fsetxattr, - .fgetxattr = glupy_fgetxattr, - .removexattr = glupy_removexattr, - .fremovexattr = glupy_fremovexattr, - .link = glupy_link, - .unlink = glupy_unlink, - .readlink = glupy_readlink, - .symlink = glupy_symlink, - .mkdir = glupy_mkdir, - .rmdir = glupy_rmdir, - .statfs = glupy_statfs, - .readdirp = glupy_readdirp -}; - -struct xlator_cbks cbks = { -}; + Py_DECREF(priv->py_xlator); + Py_DECREF(priv->py_module); + this->private = NULL; + GF_FREE(priv); + + return; +} + +struct xlator_fops fops = {.lookup = glupy_lookup, + .create = glupy_create, + .open = glupy_open, + .readv = glupy_readv, + .writev = glupy_writev, + .opendir = glupy_opendir, + .readdir = glupy_readdir, + .stat = glupy_stat, + .fstat = glupy_fstat, + .setxattr = glupy_setxattr, + .getxattr = glupy_getxattr, + .fsetxattr = glupy_fsetxattr, + .fgetxattr = glupy_fgetxattr, + .removexattr = glupy_removexattr, + .fremovexattr = glupy_fremovexattr, + .link = glupy_link, + .unlink = glupy_unlink, + .readlink = glupy_readlink, + .symlink = glupy_symlink, + .mkdir = glupy_mkdir, + .rmdir = glupy_rmdir, + .statfs = glupy_statfs, + .readdirp = glupy_readdirp}; + +struct xlator_cbks cbks = {}; struct volume_options options[] = { - { .key = {NULL} }, + {.key = {NULL}}, }; |