diff options
Diffstat (limited to 'xlators/storage')
| -rw-r--r-- | xlators/storage/bd/src/bd-aio.c | 835 | ||||
| -rw-r--r-- | xlators/storage/bd/src/bd-helper.c | 1685 | ||||
| -rw-r--r-- | xlators/storage/bd/src/bd.c | 3593 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-aio.c | 970 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-common.c | 2208 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-entry-ops.c | 3943 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-gfid-path.c | 501 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-handle.c | 1607 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-helpers.c | 5180 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-inode-fd-ops.c | 8575 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix-metadata.c | 1063 | ||||
| -rw-r--r-- | xlators/storage/posix/src/posix.c | 118 |
12 files changed, 15018 insertions, 15260 deletions
diff --git a/xlators/storage/bd/src/bd-aio.c b/xlators/storage/bd/src/bd-aio.c index 6f5c90f457e..6bc7d4a104c 100644 --- a/xlators/storage/bd/src/bd-aio.c +++ b/xlators/storage/bd/src/bd-aio.c @@ -27,495 +27,492 @@ #include "bd-mem-types.h" struct bd_aio_cb { - struct iocb iocb; - call_frame_t *frame; - struct iobuf *iobuf; - struct iobref *iobref; - struct iatt prebuf; - int op; - off_t offset; - fd_t *fd; + struct iocb iocb; + call_frame_t *frame; + struct iobuf *iobuf; + struct iobref *iobref; + struct iatt prebuf; + int op; + off_t offset; + fd_t *fd; }; void -__bd_fd_set_odirect (fd_t *fd, bd_fd_t *bd_fd, int opflags, - off_t offset, size_t size) +__bd_fd_set_odirect(fd_t *fd, bd_fd_t *bd_fd, int opflags, off_t offset, + size_t size) { - int odirect = 0; - int flags = 0; - int ret = 0; - - odirect = bd_fd->odirect; - - if ((fd->flags|opflags) & O_DIRECT) { - /* if instructed, use O_DIRECT always */ - odirect = 1; - } else { - /* else use O_DIRECT when feasible */ - if ((offset|size) & 0xfff) - odirect = 0; - else - odirect = 1; - } - - if (!odirect && bd_fd->odirect) { - flags = fcntl (bd_fd->fd, F_GETFL); - ret = fcntl (bd_fd->fd, F_SETFL, (flags & (~O_DIRECT))); - bd_fd->odirect = 0; - } - - if (odirect && !bd_fd->odirect) { - flags = fcntl (bd_fd->fd, F_GETFL); - ret = fcntl (bd_fd->fd, F_SETFL, (flags | O_DIRECT)); - bd_fd->odirect = 1; - } - - if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, - "fcntl() failed (%s). fd=%d flags=%d pfd->odirect=%d", - strerror (errno), bd_fd->fd, flags, bd_fd->odirect); - } + int odirect = 0; + int flags = 0; + int ret = 0; + + odirect = bd_fd->odirect; + + if ((fd->flags | opflags) & O_DIRECT) { + /* if instructed, use O_DIRECT always */ + odirect = 1; + } else { + /* else use O_DIRECT when feasible */ + if ((offset | size) & 0xfff) + odirect = 0; + else + odirect = 1; + } + + if (!odirect && bd_fd->odirect) { + flags = fcntl(bd_fd->fd, F_GETFL); + ret = fcntl(bd_fd->fd, F_SETFL, (flags & (~O_DIRECT))); + bd_fd->odirect = 0; + } + + if (odirect && !bd_fd->odirect) { + flags = fcntl(bd_fd->fd, F_GETFL); + ret = fcntl(bd_fd->fd, F_SETFL, (flags | O_DIRECT)); + bd_fd->odirect = 1; + } + + if (ret) { + gf_log(THIS->name, GF_LOG_WARNING, + "fcntl() failed (%s). fd=%d flags=%d pfd->odirect=%d", + strerror(errno), bd_fd->fd, flags, bd_fd->odirect); + } } int -bd_aio_readv_complete (struct bd_aio_cb *paiocb, int res, int res2) +bd_aio_readv_complete(struct bd_aio_cb *paiocb, int res, int res2) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - struct iobuf *iobuf = NULL; - struct iatt postbuf = {0,}; - int op_ret = -1; - int op_errno = 0; - struct iovec iov; - struct iobref *iobref = NULL; - off_t offset = 0; - bd_attr_t *bdatt = NULL; - - frame = paiocb->frame; - this = frame->this; - iobuf = paiocb->iobuf; - offset = paiocb->offset; - - if (res < 0) { - op_ret = -1; - op_errno = -res; - gf_log (this->name, GF_LOG_ERROR, - "readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)", - paiocb->fd, paiocb->iocb.u.c.nbytes, - (unsigned long long) paiocb->offset, - res, strerror (op_errno)); - goto out; - } - - bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt); - memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt)); - - op_ret = res; - op_errno = 0; - - iobref = iobref_new (); - if (!iobref) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - iobref_add (iobref, iobuf); - - iov.iov_base = iobuf_ptr (iobuf); - iov.iov_len = op_ret; - - /* Hack to notify higher layers of EOF. */ - if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size) - op_errno = ENOENT; + call_frame_t *frame = NULL; + xlator_t *this = NULL; + struct iobuf *iobuf = NULL; + struct iatt postbuf = { + 0, + }; + int op_ret = -1; + int op_errno = 0; + struct iovec iov; + struct iobref *iobref = NULL; + off_t offset = 0; + bd_attr_t *bdatt = NULL; + + frame = paiocb->frame; + this = frame->this; + iobuf = paiocb->iobuf; + offset = paiocb->offset; + + if (res < 0) { + op_ret = -1; + op_errno = -res; + gf_log(this->name, GF_LOG_ERROR, + "readv(async) failed fd=%p,size=%lu,offset=%llu (%d/%s)", + paiocb->fd, paiocb->iocb.u.c.nbytes, + (unsigned long long)paiocb->offset, res, strerror(op_errno)); + goto out; + } + + bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt); + memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt)); + + op_ret = res; + op_errno = 0; + + iobref = iobref_new(); + if (!iobref) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + + iobref_add(iobref, iobuf); + + iov.iov_base = iobuf_ptr(iobuf); + iov.iov_len = op_ret; + + /* Hack to notify higher layers of EOF. */ + if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size) + op_errno = ENOENT; out: - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &iov, 1, - &postbuf, iobref, NULL); - if (iobuf) - iobuf_unref (iobuf); - if (iobref) - iobref_unref (iobref); + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, &iov, 1, &postbuf, + iobref, NULL); + if (iobuf) + iobuf_unref(iobuf); + if (iobref) + iobref_unref(iobref); - GF_FREE (paiocb); + GF_FREE(paiocb); - return 0; + return 0; } int -bd_aio_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, uint32_t flags, dict_t *xdata) +bd_aio_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - int32_t op_errno = EINVAL; - int _fd = -1; - struct iobuf *iobuf = NULL; - bd_fd_t *bd_fd = NULL; - int ret = -1; - struct bd_aio_cb *paiocb = NULL; - bd_priv_t *priv = NULL; - struct iocb *iocb = NULL; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - priv = this->private; - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { - STACK_WIND (frame, default_readv_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->readv, fd, size, offset, - flags, xdata); - return 0; - } - _fd = bd_fd->fd; - bd_inode_ctx_get (fd->inode, this, &bdatt); - if (!size) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_WARNING, "size=%"GF_PRI_SIZET, size); - goto err; - } - - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (!iobuf) { - op_errno = ENOMEM; - goto err; - } - - paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_bd_aio_cb); - if (!paiocb) { - op_errno = ENOMEM; - goto err; - } - - paiocb->frame = frame; - paiocb->iobuf = iobuf; - paiocb->offset = offset; - paiocb->op = GF_FOP_READ; - paiocb->fd = fd; - - paiocb->iocb.data = paiocb; - paiocb->iocb.aio_fildes = _fd; - paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD; - paiocb->iocb.aio_reqprio = 0; - paiocb->iocb.u.c.buf = iobuf_ptr (iobuf); - paiocb->iocb.u.c.nbytes = size; - paiocb->iocb.u.c.offset = offset; - - iocb = &paiocb->iocb; - - LOCK (&fd->lock); - { - __bd_fd_set_odirect (fd, bd_fd, flags, offset, size); - - ret = io_submit (priv->ctxp, 1, &iocb); - } - UNLOCK (&fd->lock); - - if (ret != 1) { - gf_log (this->name, GF_LOG_ERROR, - "io_submit() returned %d", ret); - op_errno = -ret; - goto err; - } - + int32_t op_errno = EINVAL; + int _fd = -1; + struct iobuf *iobuf = NULL; + bd_fd_t *bd_fd = NULL; + int ret = -1; + struct bd_aio_cb *paiocb = NULL; + bd_priv_t *priv = NULL; + struct iocb *iocb = NULL; + bd_attr_t *bdatt = NULL; + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + priv = this->private; + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { + STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, + xdata); return 0; + } + _fd = bd_fd->fd; + bd_inode_ctx_get(fd->inode, this, &bdatt); + if (!size) { + op_errno = EINVAL; + gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size); + goto err; + } + + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (!iobuf) { + op_errno = ENOMEM; + goto err; + } + + paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb); + if (!paiocb) { + op_errno = ENOMEM; + goto err; + } + + paiocb->frame = frame; + paiocb->iobuf = iobuf; + paiocb->offset = offset; + paiocb->op = GF_FOP_READ; + paiocb->fd = fd; + + paiocb->iocb.data = paiocb; + paiocb->iocb.aio_fildes = _fd; + paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD; + paiocb->iocb.aio_reqprio = 0; + paiocb->iocb.u.c.buf = iobuf_ptr(iobuf); + paiocb->iocb.u.c.nbytes = size; + paiocb->iocb.u.c.offset = offset; + + iocb = &paiocb->iocb; + + LOCK(&fd->lock); + { + __bd_fd_set_odirect(fd, bd_fd, flags, offset, size); + + ret = io_submit(priv->ctxp, 1, &iocb); + } + UNLOCK(&fd->lock); + + if (ret != 1) { + gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret); + op_errno = -ret; + goto err; + } + + return 0; err: - STACK_UNWIND_STRICT (readv, frame, -1, op_errno, 0, 0, 0, 0, 0); - if (iobuf) - iobuf_unref (iobuf); + STACK_UNWIND_STRICT(readv, frame, -1, op_errno, 0, 0, 0, 0, 0); + if (iobuf) + iobuf_unref(iobuf); - if (paiocb) - GF_FREE (paiocb); + if (paiocb) + GF_FREE(paiocb); - return 0; + return 0; } int -bd_aio_writev_complete (struct bd_aio_cb *paiocb, int res, int res2) +bd_aio_writev_complete(struct bd_aio_cb *paiocb, int res, int res2) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - struct iatt prebuf = {0,}; - struct iatt postbuf = {0,}; - int op_ret = -1; - int op_errno = 0; - bd_attr_t *bdatt = NULL; - - frame = paiocb->frame; - prebuf = paiocb->prebuf; - this = frame->this; - - if (res < 0) { - op_ret = -1; - op_errno = -res; - gf_log (this->name, GF_LOG_ERROR, - "writev(async) failed fd=%p,offset=%llu (%d/%s)", - paiocb->fd, (unsigned long long) paiocb->offset, res, - strerror (op_errno)); - - goto out; - } - - bd_inode_ctx_get (paiocb->fd->inode, this, &bdatt); - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME); - memcpy (&postbuf, &bdatt->iatt, sizeof (struct iatt)); - - op_ret = res; - op_errno = 0; + call_frame_t *frame = NULL; + xlator_t *this = NULL; + struct iatt prebuf = { + 0, + }; + struct iatt postbuf = { + 0, + }; + int op_ret = -1; + int op_errno = 0; + bd_attr_t *bdatt = NULL; + + frame = paiocb->frame; + prebuf = paiocb->prebuf; + this = frame->this; + + if (res < 0) { + op_ret = -1; + op_errno = -res; + gf_log(this->name, GF_LOG_ERROR, + "writev(async) failed fd=%p,offset=%llu (%d/%s)", paiocb->fd, + (unsigned long long)paiocb->offset, res, strerror(op_errno)); + + goto out; + } + + bd_inode_ctx_get(paiocb->fd->inode, this, &bdatt); + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME); + memcpy(&postbuf, &bdatt->iatt, sizeof(struct iatt)); + + op_ret = res; + op_errno = 0; out: - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, &prebuf, &postbuf, - NULL); + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, &prebuf, &postbuf, + NULL); - if (paiocb->iobref) - iobref_unref (paiocb->iobref); - GF_FREE (paiocb); + if (paiocb->iobref) + iobref_unref(paiocb->iobref); + GF_FREE(paiocb); - return 0; + return 0; } int -bd_aio_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *iov, int count, off_t offset, uint32_t flags, - struct iobref *iobref, dict_t *xdata) +bd_aio_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *iov, + int count, off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - int32_t op_errno = EINVAL; - int _fd = -1; - bd_fd_t *bd_fd = NULL; - int ret = -1; - struct bd_aio_cb *paiocb = NULL; - bd_priv_t *priv = NULL; - struct iocb *iocb = NULL; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - priv = this->private; - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { - STACK_WIND (frame, default_writev_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, iov, count, offset, flags, iobref, xdata); - return 0; - } - - bd_inode_ctx_get (fd->inode, this, &bdatt); - - _fd = bd_fd->fd; - - paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_bd_aio_cb); - if (!paiocb) { - op_errno = ENOMEM; - goto err; - } - - - paiocb->frame = frame; - paiocb->offset = offset; - paiocb->op = GF_FOP_WRITE; - paiocb->fd = fd; - - paiocb->iocb.data = paiocb; - paiocb->iocb.aio_fildes = _fd; - paiocb->iobref = iobref_ref (iobref); - paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV; - paiocb->iocb.aio_reqprio = 0; - paiocb->iocb.u.v.vec = iov; - paiocb->iocb.u.v.nr = count; - paiocb->iocb.u.v.offset = offset; - - iocb = &paiocb->iocb; - - memcpy (&paiocb->prebuf, &bdatt->iatt, sizeof (struct iatt)); - LOCK (&fd->lock); - { - __bd_fd_set_odirect (fd, bd_fd, flags, offset, - iov_length (iov, count)); - - ret = io_submit (priv->ctxp, 1, &iocb); - } - UNLOCK (&fd->lock); - - if (ret != 1) { - gf_log (this->name, GF_LOG_ERROR, - "io_submit() returned %d", ret); - op_errno = -ret; - goto err; - } - + int32_t op_errno = EINVAL; + int _fd = -1; + bd_fd_t *bd_fd = NULL; + int ret = -1; + struct bd_aio_cb *paiocb = NULL; + bd_priv_t *priv = NULL; + struct iocb *iocb = NULL; + bd_attr_t *bdatt = NULL; + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + priv = this->private; + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { + STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, iov, count, offset, + flags, iobref, xdata); return 0; + } + + bd_inode_ctx_get(fd->inode, this, &bdatt); + + _fd = bd_fd->fd; + + paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_bd_aio_cb); + if (!paiocb) { + op_errno = ENOMEM; + goto err; + } + + paiocb->frame = frame; + paiocb->offset = offset; + paiocb->op = GF_FOP_WRITE; + paiocb->fd = fd; + + paiocb->iocb.data = paiocb; + paiocb->iocb.aio_fildes = _fd; + paiocb->iobref = iobref_ref(iobref); + paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV; + paiocb->iocb.aio_reqprio = 0; + paiocb->iocb.u.v.vec = iov; + paiocb->iocb.u.v.nr = count; + paiocb->iocb.u.v.offset = offset; + + iocb = &paiocb->iocb; + + memcpy(&paiocb->prebuf, &bdatt->iatt, sizeof(struct iatt)); + LOCK(&fd->lock); + { + __bd_fd_set_odirect(fd, bd_fd, flags, offset, iov_length(iov, count)); + + ret = io_submit(priv->ctxp, 1, &iocb); + } + UNLOCK(&fd->lock); + + if (ret != 1) { + gf_log(this->name, GF_LOG_ERROR, "io_submit() returned %d", ret); + op_errno = -ret; + goto err; + } + + return 0; err: - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, 0, 0, 0); + STACK_UNWIND_STRICT(writev, frame, -1, op_errno, 0, 0, 0); - if (paiocb) { - if (paiocb->iobref) - iobref_unref (paiocb->iobref); - GF_FREE (paiocb); - } + if (paiocb) { + if (paiocb->iobref) + iobref_unref(paiocb->iobref); + GF_FREE(paiocb); + } - return 0; + return 0; } void * -bd_aio_thread (void *data) +bd_aio_thread(void *data) { - xlator_t *this = NULL; - bd_priv_t *priv = NULL; - int ret = 0; - int i = 0; - struct io_event *event = NULL; - struct bd_aio_cb *paiocb = NULL; - struct io_event events[BD_AIO_MAX_NR_GETEVENTS]; - struct timespec ts = {0, }; - - this = data; - THIS = this; - priv = this->private; - - ts.tv_sec = 5; - for (;;) { - memset (&events[0], 0, sizeof (events)); - ret = io_getevents (priv->ctxp, 1, BD_AIO_MAX_NR_GETEVENTS, - &events[0], &ts); - if (ret < 0) { - if (ret == -EINTR) - continue; - gf_log (this->name, GF_LOG_ERROR, - "io_getevents() returned %d, exiting", ret); - break; - } - - for (i = 0; i < ret; i++) { - event = &events[i]; - - paiocb = event->data; - - switch (paiocb->op) { - case GF_FOP_READ: - bd_aio_readv_complete (paiocb, event->res, - event->res2); - break; - case GF_FOP_WRITE: - bd_aio_writev_complete (paiocb, event->res, - event->res2); - break; - default: - gf_log (this->name, GF_LOG_ERROR, - "unknown op %d found in piocb", - paiocb->op); - break; - } - } + xlator_t *this = NULL; + bd_priv_t *priv = NULL; + int ret = 0; + int i = 0; + struct io_event *event = NULL; + struct bd_aio_cb *paiocb = NULL; + struct io_event events[BD_AIO_MAX_NR_GETEVENTS]; + struct timespec ts = { + 0, + }; + + this = data; + THIS = this; + priv = this->private; + + ts.tv_sec = 5; + for (;;) { + memset(&events[0], 0, sizeof(events)); + ret = io_getevents(priv->ctxp, 1, BD_AIO_MAX_NR_GETEVENTS, &events[0], + &ts); + if (ret < 0) { + if (ret == -EINTR) + continue; + gf_log(this->name, GF_LOG_ERROR, + "io_getevents() returned %d, exiting", ret); + break; } - return NULL; + for (i = 0; i < ret; i++) { + event = &events[i]; + + paiocb = event->data; + + switch (paiocb->op) { + case GF_FOP_READ: + bd_aio_readv_complete(paiocb, event->res, event->res2); + break; + case GF_FOP_WRITE: + bd_aio_writev_complete(paiocb, event->res, event->res2); + break; + default: + gf_log(this->name, GF_LOG_ERROR, + "unknown op %d found in piocb", paiocb->op); + break; + } + } + } + + return NULL; } int -bd_aio_init (xlator_t *this) +bd_aio_init(xlator_t *this) { - bd_priv_t *priv = NULL; - int ret = 0; - - priv = this->private; - - ret = io_setup (BD_AIO_MAX_NR_EVENTS, &priv->ctxp); - if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) { - gf_log (this->name, GF_LOG_WARNING, - "Linux AIO not available at run-time." - " Continuing with synchronous IO"); - ret = 0; - goto out; - } - - if (ret < 0) { - gf_log (this->name, GF_LOG_WARNING, - "io_setup() failed. ret=%d, errno=%d", - ret, errno); - goto out; - } - - ret = gf_thread_create (&priv->aiothread, NULL, - bd_aio_thread, this, "bdaio"); - if (ret != 0) { - io_destroy (priv->ctxp); - goto out; - } - - this->fops->readv = bd_aio_readv; - this->fops->writev = bd_aio_writev; + bd_priv_t *priv = NULL; + int ret = 0; + + priv = this->private; + + ret = io_setup(BD_AIO_MAX_NR_EVENTS, &priv->ctxp); + if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) { + gf_log(this->name, GF_LOG_WARNING, + "Linux AIO not available at run-time." + " Continuing with synchronous IO"); + ret = 0; + goto out; + } + + if (ret < 0) { + gf_log(this->name, GF_LOG_WARNING, + "io_setup() failed. ret=%d, errno=%d", ret, errno); + goto out; + } + + ret = gf_thread_create(&priv->aiothread, NULL, bd_aio_thread, this, + "bdaio"); + if (ret != 0) { + io_destroy(priv->ctxp); + goto out; + } + + this->fops->readv = bd_aio_readv; + this->fops->writev = bd_aio_writev; out: - return ret; + return ret; } - int -bd_aio_on (xlator_t *this) +bd_aio_on(xlator_t *this) { - bd_priv_t *priv = NULL; - int ret = 0; - - priv = this->private; - - if (!priv->aio_init_done) { - ret = bd_aio_init (this); - if (ret == 0) - priv->aio_capable = _gf_true; - else - priv->aio_capable = _gf_false; - priv->aio_init_done = _gf_true; - } - - if (priv->aio_capable) { - this->fops->readv = bd_aio_readv; - this->fops->writev = bd_aio_writev; - } + bd_priv_t *priv = NULL; + int ret = 0; + + priv = this->private; + + if (!priv->aio_init_done) { + ret = bd_aio_init(this); + if (ret == 0) + priv->aio_capable = _gf_true; + else + priv->aio_capable = _gf_false; + priv->aio_init_done = _gf_true; + } + + if (priv->aio_capable) { + this->fops->readv = bd_aio_readv; + this->fops->writev = bd_aio_writev; + } - return ret; + return ret; } int -bd_aio_off (xlator_t *this) +bd_aio_off(xlator_t *this) { - this->fops->readv = bd_readv; - this->fops->writev = bd_writev; + this->fops->readv = bd_readv; + this->fops->writev = bd_writev; - return 0; + return 0; } #else int -bd_aio_on (xlator_t *this) +bd_aio_on(xlator_t *this) { - gf_log (this->name, GF_LOG_INFO, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return 0; + gf_log(this->name, GF_LOG_INFO, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return 0; } int -bd_aio_off (xlator_t *this) +bd_aio_off(xlator_t *this) { - gf_log (this->name, GF_LOG_INFO, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return 0; + gf_log(this->name, GF_LOG_INFO, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return 0; } void -__bd_fd_set_odirect (fd_t *fd, struct bd_fd *pfd, int opflags, - off_t offset, size_t size) +__bd_fd_set_odirect(fd_t *fd, struct bd_fd *pfd, int opflags, off_t offset, + size_t size) { - xlator_t *this = THIS; - gf_log (this->name, GF_LOG_INFO, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return; + xlator_t *this = THIS; + gf_log(this->name, GF_LOG_INFO, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return; } #endif diff --git a/xlators/storage/bd/src/bd-helper.c b/xlators/storage/bd/src/bd-helper.c index b2bcf0609da..895c6500acf 100644 --- a/xlators/storage/bd/src/bd-helper.c +++ b/xlators/storage/bd/src/bd-helper.c @@ -11,65 +11,65 @@ #include "syscall.h" int -bd_inode_ctx_set (inode_t *inode, xlator_t *this, bd_attr_t *ctx) +bd_inode_ctx_set(inode_t *inode, xlator_t *this, bd_attr_t *ctx) { - int ret = -1; - uint64_t ctx_int = 0; + int ret = -1; + uint64_t ctx_int = 0; - GF_VALIDATE_OR_GOTO (this->name, inode, out); - GF_VALIDATE_OR_GOTO (this->name, ctx, out); + GF_VALIDATE_OR_GOTO(this->name, inode, out); + GF_VALIDATE_OR_GOTO(this->name, ctx, out); - ctx_int = (long)ctx; - ret = inode_ctx_set (inode, this, &ctx_int); + ctx_int = (long)ctx; + ret = inode_ctx_set(inode, this, &ctx_int); out: - return ret; + return ret; } int -bd_inode_ctx_get (inode_t *inode, xlator_t *this, bd_attr_t **ctx) +bd_inode_ctx_get(inode_t *inode, xlator_t *this, bd_attr_t **ctx) { - int ret = -1; - uint64_t ctx_int = 0; - - GF_VALIDATE_OR_GOTO (this->name, inode, out); - ret = inode_ctx_get (inode, this, &ctx_int); - if (ret) - return ret; - if (ctx) - *ctx = (bd_attr_t *) ctx_int; -out: + int ret = -1; + uint64_t ctx_int = 0; + + GF_VALIDATE_OR_GOTO(this->name, inode, out); + ret = inode_ctx_get(inode, this, &ctx_int); + if (ret) return ret; + if (ctx) + *ctx = (bd_attr_t *)ctx_int; +out: + return ret; } void -bd_local_free (xlator_t *this, bd_local_t *local) +bd_local_free(xlator_t *this, bd_local_t *local) { - if (!local) - return; - if (local->fd) - fd_unref (local->fd); - else if (local->loc.path) - loc_wipe (&local->loc); - if (local->dict) - dict_unref (local->dict); - if (local->inode) - inode_unref (local->inode); - if (local->bdatt) { - GF_FREE (local->bdatt->type); - GF_FREE (local->bdatt); - } - mem_put (local); - local = NULL; + if (!local) + return; + if (local->fd) + fd_unref(local->fd); + else if (local->loc.path) + loc_wipe(&local->loc); + if (local->dict) + dict_unref(local->dict); + if (local->inode) + inode_unref(local->inode); + if (local->bdatt) { + GF_FREE(local->bdatt->type); + GF_FREE(local->bdatt); + } + mem_put(local); + local = NULL; } bd_local_t * -bd_local_init (call_frame_t *frame, xlator_t *this) +bd_local_init(call_frame_t *frame, xlator_t *this) { - frame->local = mem_get0 (this->local_pool); - if (!frame->local) - return NULL; + frame->local = mem_get0(this->local_pool); + if (!frame->local) + return NULL; - return frame->local; + return frame->local; } /* @@ -77,218 +77,229 @@ bd_local_init (call_frame_t *frame, xlator_t *this) * This function validates this tag against volume-uuid. Also goes * through LV list to find out if a thin-pool is configured or not. */ -int bd_scan_vg (xlator_t *this, bd_priv_t *priv) +int +bd_scan_vg(xlator_t *this, bd_priv_t *priv) { - vg_t brick = NULL; - data_t *tmp_data = NULL; - struct dm_list *tags = NULL; - int op_ret = -1; - uuid_t dict_uuid = {0, }; - uuid_t vg_uuid = {0, }; - gf_boolean_t uuid = _gf_false; - lvm_str_list_t *strl = NULL; - struct dm_list *lv_dm_list = NULL; - lv_list_t *lv_list = NULL; - struct dm_list *dm_seglist = NULL; - lvseg_list_t *seglist = NULL; - lvm_property_value_t prop = {0, }; - gf_boolean_t thin = _gf_false; - const char *lv_name = NULL; - - brick = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!brick) { - gf_log (this->name, GF_LOG_CRITICAL, "VG %s is not found", - priv->vg); - return ENOENT; - } - - lv_dm_list = lvm_vg_list_lvs (brick); - if (!lv_dm_list) - goto check; - - dm_list_iterate_items (lv_list, lv_dm_list) { - dm_seglist = lvm_lv_list_lvsegs (lv_list->lv); - if (!dm_seglist) - continue; - dm_list_iterate_items (seglist, dm_seglist) { - prop = lvm_lvseg_get_property (seglist->lvseg, - "segtype"); - if (!prop.is_valid || !prop.value.string) - continue; - if (!strcmp (prop.value.string, "thin-pool")) { - thin = _gf_true; - lv_name = lvm_lv_get_name (lv_list->lv); - priv->pool = gf_strdup (lv_name); - gf_log (THIS->name, GF_LOG_INFO, "Thin Pool " - "\"%s\" will be used for thin LVs", - lv_name); - break; - } - } + vg_t brick = NULL; + data_t *tmp_data = NULL; + struct dm_list *tags = NULL; + int op_ret = -1; + uuid_t dict_uuid = { + 0, + }; + uuid_t vg_uuid = { + 0, + }; + gf_boolean_t uuid = _gf_false; + lvm_str_list_t *strl = NULL; + struct dm_list *lv_dm_list = NULL; + lv_list_t *lv_list = NULL; + struct dm_list *dm_seglist = NULL; + lvseg_list_t *seglist = NULL; + lvm_property_value_t prop = { + 0, + }; + gf_boolean_t thin = _gf_false; + const char *lv_name = NULL; + + brick = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!brick) { + gf_log(this->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg); + return ENOENT; + } + + lv_dm_list = lvm_vg_list_lvs(brick); + if (!lv_dm_list) + goto check; + + dm_list_iterate_items(lv_list, lv_dm_list) + { + dm_seglist = lvm_lv_list_lvsegs(lv_list->lv); + if (!dm_seglist) + continue; + dm_list_iterate_items(seglist, dm_seglist) + { + prop = lvm_lvseg_get_property(seglist->lvseg, "segtype"); + if (!prop.is_valid || !prop.value.string) + continue; + if (!strcmp(prop.value.string, "thin-pool")) { + thin = _gf_true; + lv_name = lvm_lv_get_name(lv_list->lv); + priv->pool = gf_strdup(lv_name); + gf_log(THIS->name, GF_LOG_INFO, + "Thin Pool " + "\"%s\" will be used for thin LVs", + lv_name); + break; + } } + } check: - /* If there is no volume-id set in dict, we can't validate */ - tmp_data = dict_get (this->options, "volume-id"); - if (!tmp_data) { - op_ret = 0; - goto out; - } - - op_ret = gf_uuid_parse (tmp_data->data, dict_uuid); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_ERROR, - "wrong volume-id (%s) set in volume file", - tmp_data->data); - op_ret = -1; - goto out; - } - - tags = lvm_vg_get_tags (brick); - if (!tags) { /* no tags in the VG */ - gf_log (this->name, GF_LOG_ERROR, - "Extended attribute trusted.glusterfs." - "volume-id is absent"); - op_ret = -1; - goto out; - } - dm_list_iterate_items (strl, tags) { - if (!strncmp (strl->str, GF_XATTR_VOL_ID_KEY, - SLEN (GF_XATTR_VOL_ID_KEY))) { - uuid = _gf_true; - break; - } - } - /* UUID tag is not set in VG */ - if (!uuid) { - gf_log (this->name, GF_LOG_ERROR, - "Extended attribute trusted.glusterfs." - "volume-id is absent"); - op_ret = -1; - goto out; - } - - op_ret = gf_uuid_parse (strl->str + SLEN (GF_XATTR_VOL_ID_KEY) + 1, - vg_uuid); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_ERROR, - "wrong volume-id (%s) set in VG", strl->str); - op_ret = -1; - goto out; - } - if (gf_uuid_compare (dict_uuid, vg_uuid)) { - gf_log (this->name, GF_LOG_ERROR, - "mismatching volume-id (%s) received. " - "already is a part of volume %s ", - tmp_data->data, vg_uuid); - op_ret = -1; - goto out; - } - + /* If there is no volume-id set in dict, we can't validate */ + tmp_data = dict_get(this->options, "volume-id"); + if (!tmp_data) { op_ret = 0; + goto out; + } + + op_ret = gf_uuid_parse(tmp_data->data, dict_uuid); + if (op_ret < 0) { + gf_log(this->name, GF_LOG_ERROR, + "wrong volume-id (%s) set in volume file", tmp_data->data); + op_ret = -1; + goto out; + } + + tags = lvm_vg_get_tags(brick); + if (!tags) { /* no tags in the VG */ + gf_log(this->name, GF_LOG_ERROR, + "Extended attribute trusted.glusterfs." + "volume-id is absent"); + op_ret = -1; + goto out; + } + dm_list_iterate_items(strl, tags) + { + if (!strncmp(strl->str, GF_XATTR_VOL_ID_KEY, + SLEN(GF_XATTR_VOL_ID_KEY))) { + uuid = _gf_true; + break; + } + } + /* UUID tag is not set in VG */ + if (!uuid) { + gf_log(this->name, GF_LOG_ERROR, + "Extended attribute trusted.glusterfs." + "volume-id is absent"); + op_ret = -1; + goto out; + } + + op_ret = gf_uuid_parse(strl->str + SLEN(GF_XATTR_VOL_ID_KEY) + 1, vg_uuid); + if (op_ret < 0) { + gf_log(this->name, GF_LOG_ERROR, "wrong volume-id (%s) set in VG", + strl->str); + op_ret = -1; + goto out; + } + if (gf_uuid_compare(dict_uuid, vg_uuid)) { + gf_log(this->name, GF_LOG_ERROR, + "mismatching volume-id (%s) received. " + "already is a part of volume %s ", + tmp_data->data, vg_uuid); + op_ret = -1; + goto out; + } + + op_ret = 0; out: - lvm_vg_close (brick); + lvm_vg_close(brick); - if (!thin) - gf_log (THIS->name, GF_LOG_WARNING, "No thin pool found in " - "VG %s\n", priv->vg); - else - priv->caps |= BD_CAPS_THIN; + if (!thin) + gf_log(THIS->name, GF_LOG_WARNING, + "No thin pool found in " + "VG %s\n", + priv->vg); + else + priv->caps |= BD_CAPS_THIN; - return op_ret; + return op_ret; } /* FIXME: Move this code to common place, so posix and bd xlator can use */ char * -page_aligned_alloc (size_t size, char **aligned_buf) +page_aligned_alloc(size_t size, char **aligned_buf) { - char *alloc_buf = NULL; - char *buf = NULL; + char *alloc_buf = NULL; + char *buf = NULL; - alloc_buf = GF_CALLOC (1, (size + ALIGN_SIZE), gf_common_mt_char); - if (!alloc_buf) - return NULL; - /* page aligned buffer */ - buf = GF_ALIGN_BUF (alloc_buf, ALIGN_SIZE); - *aligned_buf = buf; + alloc_buf = GF_CALLOC(1, (size + ALIGN_SIZE), gf_common_mt_char); + if (!alloc_buf) + return NULL; + /* page aligned buffer */ + buf = GF_ALIGN_BUF(alloc_buf, ALIGN_SIZE); + *aligned_buf = buf; - return alloc_buf; + return alloc_buf; } static int -__bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd_p) +__bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd_p) { - int ret = -1; - int _fd = -1; - char *devpath = NULL; - bd_fd_t *bdfd = NULL; - uint64_t tmp_bdfd = 0; - bd_priv_t *priv = this->private; - bd_gfid_t gfid = {0, }; - bd_attr_t *bdatt = NULL; - - /* not bd file */ - if (fd->inode->ia_type != IA_IFREG || - bd_inode_ctx_get (fd->inode, this, &bdatt)) - return 0; - - ret = __fd_ctx_get (fd, this, &tmp_bdfd); - if (ret == 0) { - bdfd = (void *)(long) tmp_bdfd; - *bdfd_p = bdfd; - return 0; - } - - uuid_utoa_r (fd->inode->gfid, gfid); - gf_asprintf (&devpath, "/dev/%s/%s", priv->vg, gfid); - if (!devpath) - goto out; - - _fd = open (devpath, O_RDWR | O_LARGEFILE, 0); - if (_fd < 0) { - ret = errno; - gf_log (this->name, GF_LOG_ERROR, "open on %s: %s", devpath, - strerror (ret)); - goto out; - } - bdfd = GF_CALLOC (1, sizeof(bd_fd_t), gf_bd_fd); - BD_VALIDATE_MEM_ALLOC (bdfd, ret, out); - - bdfd->fd = _fd; - bdfd->flag = O_RDWR | O_LARGEFILE; - if (__fd_ctx_set (fd, this, (uint64_t)(long)bdfd) < 0) { - gf_log (this->name, GF_LOG_WARNING, - "failed to set the fd context fd=%p", fd); - goto out; - } + int ret = -1; + int _fd = -1; + char *devpath = NULL; + bd_fd_t *bdfd = NULL; + uint64_t tmp_bdfd = 0; + bd_priv_t *priv = this->private; + bd_gfid_t gfid = { + 0, + }; + bd_attr_t *bdatt = NULL; + + /* not bd file */ + if (fd->inode->ia_type != IA_IFREG || + bd_inode_ctx_get(fd->inode, this, &bdatt)) + return 0; + ret = __fd_ctx_get(fd, this, &tmp_bdfd); + if (ret == 0) { + bdfd = (void *)(long)tmp_bdfd; *bdfd_p = bdfd; - - ret = 0; + return 0; + } + + uuid_utoa_r(fd->inode->gfid, gfid); + gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid); + if (!devpath) + goto out; + + _fd = open(devpath, O_RDWR | O_LARGEFILE, 0); + if (_fd < 0) { + ret = errno; + gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath, + strerror(ret)); + goto out; + } + bdfd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd); + BD_VALIDATE_MEM_ALLOC(bdfd, ret, out); + + bdfd->fd = _fd; + bdfd->flag = O_RDWR | O_LARGEFILE; + if (__fd_ctx_set(fd, this, (uint64_t)(long)bdfd) < 0) { + gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p", + fd); + goto out; + } + + *bdfd_p = bdfd; + + ret = 0; out: - GF_FREE (devpath); - if (ret) { - if (_fd >= 0) - sys_close (_fd); - GF_FREE (bdfd); - } - return ret; + GF_FREE(devpath); + if (ret) { + if (_fd >= 0) + sys_close(_fd); + GF_FREE(bdfd); + } + return ret; } int -bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd) +bd_fd_ctx_get(xlator_t *this, fd_t *fd, bd_fd_t **bdfd) { - int ret; + int ret; - /* FIXME: Is it ok to fd->lock here ? */ - LOCK (&fd->lock); - { - ret = __bd_fd_ctx_get (this, fd, bdfd); - } - UNLOCK (&fd->lock); + /* FIXME: Is it ok to fd->lock here ? */ + LOCK(&fd->lock); + { + ret = __bd_fd_ctx_get(this, fd, bdfd); + } + UNLOCK(&fd->lock); - return ret; + return ret; } /* @@ -299,579 +310,606 @@ bd_fd_ctx_get (xlator_t *this, fd_t *fd, bd_fd_t **bdfd) * size */ int -bd_validate_bd_xattr (xlator_t *this, char *bd, char **type, - uint64_t *lv_size, uuid_t uuid) +bd_validate_bd_xattr(xlator_t *this, char *bd, char **type, uint64_t *lv_size, + uuid_t uuid) { - char *path = NULL; - int ret = -1; - bd_gfid_t gfid = {0, }; - bd_priv_t *priv = this->private; - struct stat stbuf = {0, }; - uint64_t size = 0; - vg_t vg = NULL; - lv_t lv = NULL; - char *bytes = NULL; - - bytes = strrchr (bd, ':'); - if (bytes) { - *bytes = '\0'; - bytes++; - gf_string2bytesize (bytes, &size); - } - - if (strcmp (bd, BD_LV) && strcmp (bd, BD_THIN)) { - gf_log (this->name, GF_LOG_WARNING, - "invalid xattr %s", bd); - return -1; - } - *type = gf_strdup (bd); - - /* - * Check if LV really exist, there could be a failure - * after setxattr and successful LV creation - */ - uuid_utoa_r (uuid, gfid); - gf_asprintf (&path, "/dev/%s/%s", priv->vg, gfid); - if (!path) { - gf_log (this->name, GF_LOG_WARNING, - "insufficient memory"); - return 0; - } - - /* Destination file does not exist */ - if (sys_stat (path, &stbuf)) { - gf_log (this->name, GF_LOG_WARNING, - "lstat failed for path %s", path); - GF_FREE (path); - return -1; - } - - vg = lvm_vg_open (priv->handle, priv->vg, "r", 0); - if (!vg) { - gf_log (this->name, GF_LOG_WARNING, - "VG %s does not exist?", priv->vg); - ret = -1; - goto out; - } - - lv = lvm_lv_from_name (vg, gfid); - if (!lv) { - gf_log (this->name, GF_LOG_WARNING, - "LV %s does not exist", gfid); - ret = -1; - goto out; - } - - *lv_size = lvm_lv_get_size (lv); - if (size == *lv_size) { - ret = 0; - goto out; - } + char *path = NULL; + int ret = -1; + bd_gfid_t gfid = { + 0, + }; + bd_priv_t *priv = this->private; + struct stat stbuf = { + 0, + }; + uint64_t size = 0; + vg_t vg = NULL; + lv_t lv = NULL; + char *bytes = NULL; + + bytes = strrchr(bd, ':'); + if (bytes) { + *bytes = '\0'; + bytes++; + gf_string2bytesize(bytes, &size); + } + + if (strcmp(bd, BD_LV) && strcmp(bd, BD_THIN)) { + gf_log(this->name, GF_LOG_WARNING, "invalid xattr %s", bd); + return -1; + } + *type = gf_strdup(bd); + + /* + * Check if LV really exist, there could be a failure + * after setxattr and successful LV creation + */ + uuid_utoa_r(uuid, gfid); + gf_asprintf(&path, "/dev/%s/%s", priv->vg, gfid); + if (!path) { + gf_log(this->name, GF_LOG_WARNING, "insufficient memory"); + return 0; + } + + /* Destination file does not exist */ + if (sys_stat(path, &stbuf)) { + gf_log(this->name, GF_LOG_WARNING, "lstat failed for path %s", path); + GF_FREE(path); + return -1; + } + + vg = lvm_vg_open(priv->handle, priv->vg, "r", 0); + if (!vg) { + gf_log(this->name, GF_LOG_WARNING, "VG %s does not exist?", priv->vg); + ret = -1; + goto out; + } + + lv = lvm_lv_from_name(vg, gfid); + if (!lv) { + gf_log(this->name, GF_LOG_WARNING, "LV %s does not exist", gfid); + ret = -1; + goto out; + } + + *lv_size = lvm_lv_get_size(lv); + if (size == *lv_size) { + ret = 0; + goto out; + } - ret = 1; + ret = 1; out: - if (vg) - lvm_vg_close (vg); + if (vg) + lvm_vg_close(vg); - GF_FREE (path); - return ret; + GF_FREE(path); + return ret; } static int -create_thin_lv (char *vg, char *pool, char *lv, uint64_t extent) +create_thin_lv(char *vg, char *pool, char *lv, uint64_t extent) { - int ret = -1; - runner_t runner = {0, }; - char *path = NULL; - struct stat stat = {0, }; - - runinit (&runner); - runner_add_args (&runner, LVM_CREATE, NULL); - runner_add_args (&runner, "--thin", NULL); - runner_argprintf (&runner, "%s/%s", vg, pool); - runner_add_args (&runner, "--name", NULL); - runner_argprintf (&runner, "%s", lv); - runner_add_args (&runner, "--virtualsize", NULL); - runner_argprintf (&runner, "%ldB", extent); - runner_start (&runner); - runner_end (&runner); - - gf_asprintf (&path, "/dev/%s/%s", vg, lv); - if (!path) { - ret = ENOMEM; - goto out; - } - if (sys_lstat (path, &stat) < 0) - ret = EAGAIN; - else - ret = 0; + int ret = -1; + runner_t runner = { + 0, + }; + char *path = NULL; + struct stat stat = { + 0, + }; + + runinit(&runner); + runner_add_args(&runner, LVM_CREATE, NULL); + runner_add_args(&runner, "--thin", NULL); + runner_argprintf(&runner, "%s/%s", vg, pool); + runner_add_args(&runner, "--name", NULL); + runner_argprintf(&runner, "%s", lv); + runner_add_args(&runner, "--virtualsize", NULL); + runner_argprintf(&runner, "%ldB", extent); + runner_start(&runner); + runner_end(&runner); + + gf_asprintf(&path, "/dev/%s/%s", vg, lv); + if (!path) { + ret = ENOMEM; + goto out; + } + if (sys_lstat(path, &stat) < 0) + ret = EAGAIN; + else + ret = 0; out: - GF_FREE (path); - return ret; + GF_FREE(path); + return ret; } int -bd_create (uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv) +bd_create(uuid_t uuid, uint64_t size, char *type, bd_priv_t *priv) { - int ret = 0; - vg_t vg = NULL; - bd_gfid_t gfid = {0, }; + int ret = 0; + vg_t vg = NULL; + bd_gfid_t gfid = { + 0, + }; - uuid_utoa_r (uuid, gfid); + uuid_utoa_r(uuid, gfid); - if (!strcmp (type, BD_THIN)) - return create_thin_lv (priv->vg, priv->pool, gfid, - size); + if (!strcmp(type, BD_THIN)) + return create_thin_lv(priv->vg, priv->pool, gfid, size); - vg = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!vg) { - gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed", - priv->vg); - return ENOENT; - } + vg = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!vg) { + gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg); + return ENOENT; + } - if (!lvm_vg_create_lv_linear (vg, gfid, size)) { - gf_log (THIS->name, GF_LOG_WARNING, "lvm_vg_create_lv_linear " - "failed"); - ret = errno; - } + if (!lvm_vg_create_lv_linear(vg, gfid, size)) { + gf_log(THIS->name, GF_LOG_WARNING, + "lvm_vg_create_lv_linear " + "failed"); + ret = errno; + } - lvm_vg_close (vg); + lvm_vg_close(vg); - return ret; + return ret; } int32_t -bd_resize (bd_priv_t *priv, uuid_t uuid, size_t size) +bd_resize(bd_priv_t *priv, uuid_t uuid, size_t size) { - uint64_t new_size = 0; - runner_t runner = {0, }; - bd_gfid_t gfid = {0, }; - int ret = 0; - vg_t vg = NULL; - lv_t lv = NULL; - - uuid_utoa_r (uuid, gfid); - - runinit (&runner); - - runner_add_args (&runner, LVM_RESIZE, NULL); - runner_argprintf (&runner, "%s/%s", priv->vg, gfid); - runner_argprintf (&runner, "-L%ldb", size); - runner_add_args (&runner, "-f", NULL); - - runner_start (&runner); - runner_end (&runner); - - vg = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!vg) { - gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed", - priv->vg); - return EAGAIN; - } - - lv = lvm_lv_from_name (vg, gfid); - if (!lv) { - gf_log (THIS->name, GF_LOG_WARNING, "LV %s not found", gfid); - ret = EIO; - goto out; - } - new_size = lvm_lv_get_size (lv); - - if (new_size != size) { - gf_log (THIS->name, GF_LOG_WARNING, - "resized LV size %" PRIu64 " does " - "not match requested size %zd", new_size, size); - ret = EIO; - } + uint64_t new_size = 0; + runner_t runner = { + 0, + }; + bd_gfid_t gfid = { + 0, + }; + int ret = 0; + vg_t vg = NULL; + lv_t lv = NULL; + + uuid_utoa_r(uuid, gfid); + + runinit(&runner); + + runner_add_args(&runner, LVM_RESIZE, NULL); + runner_argprintf(&runner, "%s/%s", priv->vg, gfid); + runner_argprintf(&runner, "-L%ldb", size); + runner_add_args(&runner, "-f", NULL); + + runner_start(&runner); + runner_end(&runner); + + vg = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!vg) { + gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg); + return EAGAIN; + } + + lv = lvm_lv_from_name(vg, gfid); + if (!lv) { + gf_log(THIS->name, GF_LOG_WARNING, "LV %s not found", gfid); + ret = EIO; + goto out; + } + new_size = lvm_lv_get_size(lv); + + if (new_size != size) { + gf_log(THIS->name, GF_LOG_WARNING, + "resized LV size %" PRIu64 + " does " + "not match requested size %zd", + new_size, size); + ret = EIO; + } out: - lvm_vg_close (vg); - return ret; + lvm_vg_close(vg); + return ret; } uint64_t -bd_get_default_extent (bd_priv_t *priv) +bd_get_default_extent(bd_priv_t *priv) { - vg_t vg = NULL; - uint64_t size = 0; - - vg = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!vg) { - gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed", - priv->vg); - return 0; - } + vg_t vg = NULL; + uint64_t size = 0; + + vg = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!vg) { + gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg); + return 0; + } - size = lvm_vg_get_extent_size (vg); + size = lvm_vg_get_extent_size(vg); - lvm_vg_close (vg); + lvm_vg_close(vg); - return size; + return size; } /* * Adjusts the user specified size to VG specific extent size */ uint64_t -bd_adjust_size (bd_priv_t *priv, size_t size) +bd_adjust_size(bd_priv_t *priv, size_t size) { - uint64_t extent = 0; - uint64_t nr_ex = 0; + uint64_t extent = 0; + uint64_t nr_ex = 0; - extent = bd_get_default_extent (priv); - if (!extent) - return 0; + extent = bd_get_default_extent(priv); + if (!extent) + return 0; - nr_ex = size / extent; - if (size % extent) - nr_ex++; + nr_ex = size / extent; + if (size % extent) + nr_ex++; - size = extent * nr_ex; + size = extent * nr_ex; - return size; + return size; } int -bd_delete_lv (bd_priv_t *priv, const char *lv_name, int *op_errno) +bd_delete_lv(bd_priv_t *priv, const char *lv_name, int *op_errno) { - vg_t vg = NULL; - lv_t lv = NULL; - int ret = -1; - - *op_errno = 0; - vg = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!vg) { - gf_log (THIS->name, GF_LOG_WARNING, "opening VG %s failed", - priv->vg); - *op_errno = ENOENT; - return -1; - } - lv = lvm_lv_from_name (vg, lv_name); - if (!lv) { - gf_log (THIS->name, GF_LOG_WARNING, "No such LV %s", lv_name); - *op_errno = ENOENT; - goto out; - } - ret = lvm_vg_remove_lv (lv); - if (ret < 0) { - gf_log (THIS->name, GF_LOG_WARNING, "removing LV %s failed", - lv_name); - *op_errno = errno; - goto out; - } + vg_t vg = NULL; + lv_t lv = NULL; + int ret = -1; + + *op_errno = 0; + vg = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!vg) { + gf_log(THIS->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg); + *op_errno = ENOENT; + return -1; + } + lv = lvm_lv_from_name(vg, lv_name); + if (!lv) { + gf_log(THIS->name, GF_LOG_WARNING, "No such LV %s", lv_name); + *op_errno = ENOENT; + goto out; + } + ret = lvm_vg_remove_lv(lv); + if (ret < 0) { + gf_log(THIS->name, GF_LOG_WARNING, "removing LV %s failed", lv_name); + *op_errno = errno; + goto out; + } out: - lvm_vg_close (vg); + lvm_vg_close(vg); - return ret; + return ret; } void bd_update_amtime(struct iatt *iatt, int flag) { - struct timespec ts = {0, }; - - clock_gettime (CLOCK_REALTIME, &ts); - if (flag & GF_SET_ATTR_ATIME) { - iatt->ia_atime = ts.tv_sec; - iatt->ia_atime_nsec = ts.tv_nsec; - } - if (flag & GF_SET_ATTR_MTIME) { - iatt->ia_mtime = ts.tv_sec; - iatt->ia_mtime_nsec = ts.tv_nsec; - } + struct timespec ts = { + 0, + }; + + clock_gettime(CLOCK_REALTIME, &ts); + if (flag & GF_SET_ATTR_ATIME) { + iatt->ia_atime = ts.tv_sec; + iatt->ia_atime_nsec = ts.tv_nsec; + } + if (flag & GF_SET_ATTR_MTIME) { + iatt->ia_mtime = ts.tv_sec; + iatt->ia_mtime_nsec = ts.tv_nsec; + } } int -bd_snapshot_create (bd_local_t *local, bd_priv_t *priv) +bd_snapshot_create(bd_local_t *local, bd_priv_t *priv) { - char *path = NULL; - bd_gfid_t dest = {0, }; - bd_gfid_t origin = {0, }; - int ret = 0; - runner_t runner = {0, }; - struct stat stat = {0, }; - - uuid_utoa_r (local->dloc->gfid, dest); - uuid_utoa_r (local->loc.gfid, origin); - - gf_asprintf (&path, "/dev/%s/%s", priv->vg, dest); - if (!path) { - gf_log (THIS->name, GF_LOG_WARNING, - "Insufficient memory"); - return ENOMEM; - } - - runinit (&runner); - runner_add_args (&runner, LVM_CREATE, NULL); - runner_add_args (&runner, "--snapshot", NULL); - runner_argprintf (&runner, "/dev/%s/%s", priv->vg, origin); - runner_add_args (&runner, "--name", NULL); - runner_argprintf (&runner, "%s", dest); - if (strcmp (local->bdatt->type, BD_THIN)) - runner_argprintf (&runner, "-L%ldB", local->size); - runner_start (&runner); - runner_end (&runner); - - if (sys_lstat (path, &stat) < 0) - ret = EIO; - - GF_FREE (path); - return ret; + char *path = NULL; + bd_gfid_t dest = { + 0, + }; + bd_gfid_t origin = { + 0, + }; + int ret = 0; + runner_t runner = { + 0, + }; + struct stat stat = { + 0, + }; + + uuid_utoa_r(local->dloc->gfid, dest); + uuid_utoa_r(local->loc.gfid, origin); + + gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest); + if (!path) { + gf_log(THIS->name, GF_LOG_WARNING, "Insufficient memory"); + return ENOMEM; + } + + runinit(&runner); + runner_add_args(&runner, LVM_CREATE, NULL); + runner_add_args(&runner, "--snapshot", NULL); + runner_argprintf(&runner, "/dev/%s/%s", priv->vg, origin); + runner_add_args(&runner, "--name", NULL); + runner_argprintf(&runner, "%s", dest); + if (strcmp(local->bdatt->type, BD_THIN)) + runner_argprintf(&runner, "-L%ldB", local->size); + runner_start(&runner); + runner_end(&runner); + + if (sys_lstat(path, &stat) < 0) + ret = EIO; + + GF_FREE(path); + return ret; } int -bd_clone (bd_local_t *local, bd_priv_t *priv) +bd_clone(bd_local_t *local, bd_priv_t *priv) { - int ret = ENOMEM; - int fd1 = -1; - int fd2 = -1; - int i = 0; - char *buff = NULL; - ssize_t bytes = 0; - char *spath = NULL; - char *dpath = NULL; - struct iovec *vec = NULL; - bd_gfid_t source = {0, }; - bd_gfid_t dest = {0, }; - void *bufp[IOV_NR] = {0, }; - - vec = GF_CALLOC (IOV_NR, sizeof (struct iovec), gf_common_mt_iovec); - if (!vec) - return ENOMEM; - - for (i = 0; i < IOV_NR; i++) { - bufp[i] = page_aligned_alloc (IOV_SIZE, &buff); - if (!buff) - goto out; - vec[i].iov_base = buff; - vec[i].iov_len = IOV_SIZE; - } - - uuid_utoa_r (local->loc.gfid, source); - uuid_utoa_r (local->dloc->gfid, dest); - - gf_asprintf (&spath, "/dev/%s/%s", priv->vg, source); - gf_asprintf (&dpath, "/dev/%s/%s", priv->vg, dest); - if (!spath || !dpath) - goto out; - - ret = bd_create (local->dloc->gfid, local->size, - local->bdatt->type, priv); - if (ret) - goto out; - - fd1 = open (spath, O_RDONLY | O_DIRECT); - if (fd1 < 0) { - ret = errno; - goto out; + int ret = ENOMEM; + int fd1 = -1; + int fd2 = -1; + int i = 0; + char *buff = NULL; + ssize_t bytes = 0; + char *spath = NULL; + char *dpath = NULL; + struct iovec *vec = NULL; + bd_gfid_t source = { + 0, + }; + bd_gfid_t dest = { + 0, + }; + void *bufp[IOV_NR] = { + 0, + }; + + vec = GF_CALLOC(IOV_NR, sizeof(struct iovec), gf_common_mt_iovec); + if (!vec) + return ENOMEM; + + for (i = 0; i < IOV_NR; i++) { + bufp[i] = page_aligned_alloc(IOV_SIZE, &buff); + if (!buff) + goto out; + vec[i].iov_base = buff; + vec[i].iov_len = IOV_SIZE; + } + + uuid_utoa_r(local->loc.gfid, source); + uuid_utoa_r(local->dloc->gfid, dest); + + gf_asprintf(&spath, "/dev/%s/%s", priv->vg, source); + gf_asprintf(&dpath, "/dev/%s/%s", priv->vg, dest); + if (!spath || !dpath) + goto out; + + ret = bd_create(local->dloc->gfid, local->size, local->bdatt->type, priv); + if (ret) + goto out; + + fd1 = open(spath, O_RDONLY | O_DIRECT); + if (fd1 < 0) { + ret = errno; + goto out; + } + fd2 = open(dpath, O_WRONLY | O_DIRECT); + if (fd2 < 0) { + ret = errno; + goto out; + } + + while (1) { + bytes = sys_readv(fd1, vec, IOV_NR); + if (bytes < 0) { + ret = errno; + gf_log(THIS->name, GF_LOG_WARNING, "read failed: %s", + strerror(ret)); + goto out; } - fd2 = open (dpath, O_WRONLY | O_DIRECT); - if (fd2 < 0) { - ret = errno; - goto out; + if (!bytes) + break; + bytes = sys_writev(fd2, vec, IOV_NR); + if (bytes < 0) { + ret = errno; + gf_log(THIS->name, GF_LOG_WARNING, "write failed: %s", + strerror(ret)); + goto out; } - - while (1) { - bytes = sys_readv (fd1, vec, IOV_NR); - if (bytes < 0) { - ret = errno; - gf_log (THIS->name, GF_LOG_WARNING, "read failed: %s", - strerror (ret)); - goto out; - } - if (!bytes) - break; - bytes = sys_writev (fd2, vec, IOV_NR); - if (bytes < 0) { - ret = errno; - gf_log (THIS->name, GF_LOG_WARNING, - "write failed: %s", strerror (ret)); - goto out; - } - } - ret = 0; + } + ret = 0; out: - for (i = 0; i < IOV_NR; i++) - GF_FREE (bufp[i]); - GF_FREE (vec); + for (i = 0; i < IOV_NR; i++) + GF_FREE(bufp[i]); + GF_FREE(vec); - if (fd1 != -1) - sys_close (fd1); - if (fd2 != -1) - sys_close (fd2); + if (fd1 != -1) + sys_close(fd1); + if (fd2 != -1) + sys_close(fd2); - GF_FREE (spath); - GF_FREE (dpath); + GF_FREE(spath); + GF_FREE(dpath); - return ret; + return ret; } /* * Merges snapshot LV to origin LV and returns status */ int -bd_merge (bd_priv_t *priv, uuid_t gfid) +bd_merge(bd_priv_t *priv, uuid_t gfid) { - bd_gfid_t dest = {0, }; - char *path = NULL; - struct stat stat = {0, }; - runner_t runner = {0, }; - int ret = 0; - - uuid_utoa_r (gfid, dest); - gf_asprintf (&path, "/dev/%s/%s", priv->vg, dest); - - runinit (&runner); - runner_add_args (&runner, LVM_CONVERT, NULL); - runner_add_args (&runner, "--merge", NULL); - runner_argprintf (&runner, "%s", path); - runner_start (&runner); - runner_end (&runner); - - if (!sys_lstat (path, &stat)) - ret = EIO; - - GF_FREE (path); - - return ret; + bd_gfid_t dest = { + 0, + }; + char *path = NULL; + struct stat stat = { + 0, + }; + runner_t runner = { + 0, + }; + int ret = 0; + + uuid_utoa_r(gfid, dest); + gf_asprintf(&path, "/dev/%s/%s", priv->vg, dest); + + runinit(&runner); + runner_add_args(&runner, LVM_CONVERT, NULL); + runner_add_args(&runner, "--merge", NULL); + runner_argprintf(&runner, "%s", path); + runner_start(&runner); + runner_end(&runner); + + if (!sys_lstat(path, &stat)) + ret = EIO; + + GF_FREE(path); + + return ret; } int -bd_get_origin (bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict) +bd_get_origin(bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict) { - vg_t brick = NULL; - lvm_property_value_t prop = {0, }; - lv_t lv = NULL; - int ret = -1; - bd_gfid_t gfid = {0, }; - inode_t *inode = NULL; - char *origin = NULL; - - brick = lvm_vg_open (priv->handle, priv->vg, "w", 0); - if (!brick) { - gf_log (THIS->name, GF_LOG_CRITICAL, "VG %s is not found", - priv->vg); - return ENOENT; - } - - if (fd) - inode = fd->inode; - else - inode = loc->inode; - - uuid_utoa_r (inode->gfid, gfid); - lv = lvm_lv_from_name (brick, gfid); - if (!lv) { - gf_log (THIS->name, GF_LOG_CRITICAL, "LV %s not found", gfid); - ret = ENOENT; - goto out; - } - - prop = lvm_lv_get_property (lv, "origin"); - if (!prop.is_valid || !prop.value.string) { - ret = ENODATA; - goto out; - } - - origin = gf_strdup (prop.value.string); - ret = dict_set_dynstr (dict, BD_ORIGIN, origin); + vg_t brick = NULL; + lvm_property_value_t prop = { + 0, + }; + lv_t lv = NULL; + int ret = -1; + bd_gfid_t gfid = { + 0, + }; + inode_t *inode = NULL; + char *origin = NULL; + + brick = lvm_vg_open(priv->handle, priv->vg, "w", 0); + if (!brick) { + gf_log(THIS->name, GF_LOG_CRITICAL, "VG %s is not found", priv->vg); + return ENOENT; + } + + if (fd) + inode = fd->inode; + else + inode = loc->inode; + + uuid_utoa_r(inode->gfid, gfid); + lv = lvm_lv_from_name(brick, gfid); + if (!lv) { + gf_log(THIS->name, GF_LOG_CRITICAL, "LV %s not found", gfid); + ret = ENOENT; + goto out; + } + + prop = lvm_lv_get_property(lv, "origin"); + if (!prop.is_valid || !prop.value.string) { + ret = ENODATA; + goto out; + } + + origin = gf_strdup(prop.value.string); + ret = dict_set_dynstr(dict, BD_ORIGIN, origin); out: - lvm_vg_close (brick); - return ret; + lvm_vg_close(brick); + return ret; } #ifndef BLKZEROOUT int -bd_do_manual_zerofill (int fd, off_t offset, off_t len, int o_direct) +bd_do_manual_zerofill(int fd, off_t offset, off_t len, int o_direct) { - off_t num_vect = 0; - off_t num_loop = 1; - int idx = 0; - int op_ret = -1; - int vect_size = IOV_SIZE; - off_t remain = 0; - off_t extra = 0; - struct iovec *vector = NULL; - char *iov_base = NULL; - char *alloc_buf = NULL; - - if (len == 0) - return 0; - - if (len < IOV_SIZE) - vect_size = len; - - num_vect = len / (vect_size); - remain = len % vect_size ; - - if (num_vect > MAX_NO_VECT) { - extra = num_vect % MAX_NO_VECT; - num_loop = num_vect / MAX_NO_VECT; - num_vect = MAX_NO_VECT; - } - - vector = GF_CALLOC (num_vect, sizeof(struct iovec), - gf_common_mt_iovec); - if (!vector) - return -1; - - if (o_direct) { - alloc_buf = page_aligned_alloc (vect_size, &iov_base); - if (!alloc_buf) { - gf_log ("bd_do_manual_zerofill", GF_LOG_DEBUG, - "memory alloc failed, vect_size %d: %s", - vect_size, strerror (errno)); - GF_FREE (vector); - return -1; - } - } else { - iov_base = GF_CALLOC (vect_size, sizeof(char), - gf_common_mt_char); - if (!iov_base) { - GF_FREE (vector); - return -1; - } - } - - for (idx = 0; idx < num_vect; idx++) { - vector[idx].iov_base = iov_base; - vector[idx].iov_len = vect_size; - } - - if (sys_lseek (fd, offset, SEEK_SET) < 0) { - op_ret = -1; - goto err; - } + off_t num_vect = 0; + off_t num_loop = 1; + int idx = 0; + int op_ret = -1; + int vect_size = IOV_SIZE; + off_t remain = 0; + off_t extra = 0; + struct iovec *vector = NULL; + char *iov_base = NULL; + char *alloc_buf = NULL; + + if (len == 0) + return 0; - for (idx = 0; idx < num_loop; idx++) { - op_ret = sys_writev (fd, vector, num_vect); - if (op_ret < 0) - goto err; - } - if (extra) { - op_ret = sys_writev (fd, vector, extra); - if (op_ret < 0) - goto err; + if (len < IOV_SIZE) + vect_size = len; + + num_vect = len / (vect_size); + remain = len % vect_size; + + if (num_vect > MAX_NO_VECT) { + extra = num_vect % MAX_NO_VECT; + num_loop = num_vect / MAX_NO_VECT; + num_vect = MAX_NO_VECT; + } + + vector = GF_CALLOC(num_vect, sizeof(struct iovec), gf_common_mt_iovec); + if (!vector) + return -1; + + if (o_direct) { + alloc_buf = page_aligned_alloc(vect_size, &iov_base); + if (!alloc_buf) { + gf_log("bd_do_manual_zerofill", GF_LOG_DEBUG, + "memory alloc failed, vect_size %d: %s", vect_size, + strerror(errno)); + GF_FREE(vector); + return -1; } - if (remain) { - vector[0].iov_len = remain; - op_ret = sys_writev (fd, vector , 1); - if (op_ret < 0) - goto err; + } else { + iov_base = GF_CALLOC(vect_size, sizeof(char), gf_common_mt_char); + if (!iov_base) { + GF_FREE(vector); + return -1; } - op_ret = 0; + } + + for (idx = 0; idx < num_vect; idx++) { + vector[idx].iov_base = iov_base; + vector[idx].iov_len = vect_size; + } + + if (sys_lseek(fd, offset, SEEK_SET) < 0) { + op_ret = -1; + goto err; + } + + for (idx = 0; idx < num_loop; idx++) { + op_ret = sys_writev(fd, vector, num_vect); + if (op_ret < 0) + goto err; + } + if (extra) { + op_ret = sys_writev(fd, vector, extra); + if (op_ret < 0) + goto err; + } + if (remain) { + vector[0].iov_len = remain; + op_ret = sys_writev(fd, vector, 1); + if (op_ret < 0) + goto err; + } + op_ret = 0; err: - if (o_direct) - GF_FREE (alloc_buf); - else - GF_FREE (iov_base); - GF_FREE (vector); - return op_ret; + if (o_direct) + GF_FREE(alloc_buf); + else + GF_FREE(iov_base); + GF_FREE(vector); + return op_ret; } #else @@ -886,145 +924,150 @@ err: * /sys/block/<block-device>/queue/write_same_max_bytes */ int -bd_do_ioctl_zerofill (bd_priv_t *priv, bd_attr_t *bdatt, int fd, char *vg, - off_t offset, off_t len) +bd_do_ioctl_zerofill(bd_priv_t *priv, bd_attr_t *bdatt, int fd, char *vg, + off_t offset, off_t len) { - char *dm = NULL; - char dmname[4096] = {0, }; - char lvname[4096] = {0, }; - char sysfs[4096] = {0, }; - bd_gfid_t uuid = {0, }; - char *p = NULL; - off_t max_bytes = 0; - int sysfd = -1; - int ret = 0; - uint64_t param[2] = {0, 0}; - off_t nr_loop = 0; - char buff[16] = {0, }; - - uuid_utoa_r (bdatt->iatt.ia_gfid, uuid); - sprintf (lvname, "/dev/%s/%s", vg, uuid); - - ret = sys_readlink(lvname, dmname, 4096); - if (ret < 0) { - gf_log("bd", GF_LOG_DEBUG, - "Failed to read symbolic link '%s': %s", - lvname, strerror(errno)); - goto skip; - } - - dmname[ret] = '\0'; - - p = strrchr (dmname, '/'); - if (p) - dm = p + 1; - else - dm = dmname; - - sprintf(sysfs, "/sys/block/%s/queue/write_same_max_bytes", dm); - sysfd = open (sysfs, O_RDONLY); - if (sysfd < 0) { - gf_log ("bd_do_ioctl_zerofill", GF_LOG_DEBUG, - "sysfs file %s does not exist", lvname); - goto skip; - } - - sys_read (sysfd, buff, sizeof (buff)); - sys_close (sysfd); - - max_bytes = atoll (buff); + char *dm = NULL; + char dmname[4096] = { + 0, + }; + char lvname[4096] = { + 0, + }; + char sysfs[4096] = { + 0, + }; + bd_gfid_t uuid = { + 0, + }; + char *p = NULL; + off_t max_bytes = 0; + int sysfd = -1; + int ret = 0; + uint64_t param[2] = {0, 0}; + off_t nr_loop = 0; + char buff[16] = { + 0, + }; + + uuid_utoa_r(bdatt->iatt.ia_gfid, uuid); + sprintf(lvname, "/dev/%s/%s", vg, uuid); + + ret = sys_readlink(lvname, dmname, 4096); + if (ret < 0) { + gf_log("bd", GF_LOG_DEBUG, "Failed to read symbolic link '%s': %s", + lvname, strerror(errno)); + goto skip; + } + + dmname[ret] = '\0'; + + p = strrchr(dmname, '/'); + if (p) + dm = p + 1; + else + dm = dmname; + + sprintf(sysfs, "/sys/block/%s/queue/write_same_max_bytes", dm); + sysfd = open(sysfs, O_RDONLY); + if (sysfd < 0) { + gf_log("bd_do_ioctl_zerofill", GF_LOG_DEBUG, + "sysfs file %s does not exist", lvname); + goto skip; + } + + sys_read(sysfd, buff, sizeof(buff)); + sys_close(sysfd); + + max_bytes = atoll(buff); skip: - /* - * If requested len is less than write_same_max_bytes, - * issue single ioctl to zeroout. Otherwise split the ioctls - */ - if (!max_bytes || len <= max_bytes) { - param[0] = offset; - param[1] = len; - - if (ioctl (fd, BLKZEROOUT, param) < 0) - return errno; - return 0; - } + /* + * If requested len is less than write_same_max_bytes, + * issue single ioctl to zeroout. Otherwise split the ioctls + */ + if (!max_bytes || len <= max_bytes) { + param[0] = offset; + param[1] = len; - /* Split ioctls to max write_same_max_bytes */ - nr_loop = len / max_bytes; - for (; nr_loop; nr_loop--) { - param[0] = offset; - param[1] = max_bytes; + if (ioctl(fd, BLKZEROOUT, param) < 0) + return errno; + return 0; + } - if (ioctl (fd, BLKZEROOUT, param) < 0) - return errno; + /* Split ioctls to max write_same_max_bytes */ + nr_loop = len / max_bytes; + for (; nr_loop; nr_loop--) { + param[0] = offset; + param[1] = max_bytes; - offset += max_bytes; - } + if (ioctl(fd, BLKZEROOUT, param) < 0) + return errno; - if (!(len % max_bytes)) - return 0; + offset += max_bytes; + } - param[0] = offset; - param[1] = len % max_bytes; + if (!(len % max_bytes)) + return 0; - if (ioctl (fd, BLKZEROOUT, param) < 0) - return errno; + param[0] = offset; + param[1] = len % max_bytes; - return 0; + if (ioctl(fd, BLKZEROOUT, param) < 0) + return errno; + + return 0; } #endif int -bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, size_t len, struct iatt *prebuf, - struct iatt *postbuf) +bd_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, struct iatt *prebuf, struct iatt *postbuf) { - int ret = -1; - bd_fd_t *bd_fd = NULL; - bd_priv_t *priv = this->private; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (priv, out); - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "bd_fd is NULL from fd=%p", fd); - goto out; - } - - bd_inode_ctx_get (fd->inode, this, &bdatt); + int ret = -1; + bd_fd_t *bd_fd = NULL; + bd_priv_t *priv = this->private; + bd_attr_t *bdatt = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(priv, out); + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0) { + gf_log(this->name, GF_LOG_DEBUG, "bd_fd is NULL from fd=%p", fd); + goto out; + } + + bd_inode_ctx_get(fd->inode, this, &bdatt); #ifndef BLKZEROOUT - ret = bd_do_manual_zerofill(bd_fd->fd, offset, len, - bd_fd->flag & O_DIRECT); + ret = bd_do_manual_zerofill(bd_fd->fd, offset, len, bd_fd->flag & O_DIRECT); #else - ret = bd_do_ioctl_zerofill(priv, bdatt, bd_fd->fd, priv->vg, offset, - len); + ret = bd_do_ioctl_zerofill(priv, bdatt, bd_fd->fd, priv->vg, offset, len); #endif + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "zerofill failed on fd %d length %zu %s", bd_fd->fd, len, + strerror(ret)); + goto out; + } + + if (bd_fd->flag & (O_SYNC | O_DSYNC)) { + ret = sys_fsync(bd_fd->fd); if (ret) { - gf_log(this->name, GF_LOG_ERROR, - "zerofill failed on fd %d length %zu %s", - bd_fd->fd, len, strerror (ret)); - goto out; - } - - if (bd_fd->flag & (O_SYNC|O_DSYNC)) { - ret = sys_fsync (bd_fd->fd); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "fsync() in writev on fd %d failed: %s", - bd_fd->fd, strerror (errno)); - return errno; - } + gf_log(this->name, GF_LOG_ERROR, + "fsync() in writev on fd %d failed: %s", bd_fd->fd, + strerror(errno)); + return errno; } + } - memcpy (prebuf, &bdatt->iatt, sizeof (struct iatt)); - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME); - memcpy (postbuf, &bdatt->iatt, sizeof (struct iatt)); + memcpy(prebuf, &bdatt->iatt, sizeof(struct iatt)); + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME); + memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt)); out: - return ret; + return ret; } diff --git a/xlators/storage/bd/src/bd.c b/xlators/storage/bd/src/bd.c index ccb4219785e..c66ce93b79e 100644 --- a/xlators/storage/bd/src/bd.c +++ b/xlators/storage/bd/src/bd.c @@ -42,206 +42,208 @@ * does not do anything. FIXME: How to handle remove/setxattr failure */ int -bd_null_rmsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_null_rmsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - STACK_DESTROY (frame->root); - return 0; + STACK_DESTROY(frame->root); + return 0; } /* * returns 0 if a file is mapped to BD or not. */ int -bd_get_bd_info (call_frame_t *frame, xlator_t *this, dict_t *xattr, uuid_t gfid, - char **type, uint64_t *size) +bd_get_bd_info(call_frame_t *frame, xlator_t *this, dict_t *xattr, uuid_t gfid, + char **type, uint64_t *size) { - char *bd_xattr = NULL; - char *bd = NULL; - int ret = -1; - loc_t loc = {0, }; - dict_t *dict = NULL; - char *p = NULL; - call_frame_t *bd_frame = NULL; + char *bd_xattr = NULL; + char *bd = NULL; + int ret = -1; + loc_t loc = { + 0, + }; + dict_t *dict = NULL; + char *p = NULL; + call_frame_t *bd_frame = NULL; - if (!xattr) - return 1; + if (!xattr) + return 1; - if (dict_get_str (xattr, BD_XATTR, &p)) - return 1; + if (dict_get_str(xattr, BD_XATTR, &p)) + return 1; - bd_xattr = gf_strdup (p); + bd_xattr = gf_strdup(p); - memcpy (loc.gfid, gfid, sizeof (uuid_t)); + memcpy(loc.gfid, gfid, sizeof(uuid_t)); - bd_frame = copy_frame (frame); - BD_VALIDATE_MEM_ALLOC (bd_frame, ret, out); + bd_frame = copy_frame(frame); + BD_VALIDATE_MEM_ALLOC(bd_frame, ret, out); - ret = bd_validate_bd_xattr (this, bd_xattr, type, size, gfid); - if (ret < 0) {/* LV does not exist */ - STACK_WIND (bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->removexattr, &loc, - BD_XATTR, NULL); + ret = bd_validate_bd_xattr(this, bd_xattr, type, size, gfid); + if (ret < 0) { /* LV does not exist */ + STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, &loc, BD_XATTR, NULL); - gf_log (this->name, GF_LOG_WARNING, - "Mapped LV not available for posix file <gfid:%s>, " - "deleting mapping", uuid_utoa (gfid)); - } else if (ret == 1) { - /* BD_XATTR size and LV size mismatch. Update BD_XATTR */ - gf_asprintf (&bd, "%s:%ld", *type, *size); + gf_log(this->name, GF_LOG_WARNING, + "Mapped LV not available for posix file <gfid:%s>, " + "deleting mapping", + uuid_utoa(gfid)); + } else if (ret == 1) { + /* BD_XATTR size and LV size mismatch. Update BD_XATTR */ + gf_asprintf(&bd, "%s:%ld", *type, *size); - dict = dict_new (); - BD_VALIDATE_MEM_ALLOC (dict, ret, out); + dict = dict_new(); + BD_VALIDATE_MEM_ALLOC(dict, ret, out); - ret = dict_set_dynstr (dict, BD_XATTR, bd); - if (ret) - goto out; + ret = dict_set_dynstr(dict, BD_XATTR, bd); + if (ret) + goto out; - STACK_WIND (bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setxattr, &loc, dict, 0, - NULL); - } + STACK_WIND(bd_frame, bd_null_rmsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, &loc, dict, 0, NULL); + } out: - dict_del (xattr, BD_XATTR); - GF_FREE (bd_xattr); - GF_FREE (bd); - return ret; + dict_del(xattr, BD_XATTR); + GF_FREE(bd_xattr); + GF_FREE(bd); + return ret; } /* * bd_lookup_cbk: Call back from posix_lookup. */ int32_t -bd_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, inode_t *inode, struct iatt *buf, dict_t *xattr, - struct iatt *postparent) -{ - int ret = -1; - bd_attr_t *bdatt = NULL; - uint64_t size = 0; - char *type = NULL; - - /* only regular files are part of BD object */ - if (op_ret < 0 || buf->ia_type != IA_IFREG) - goto out; - - /* iatt already cached */ - if (!bd_inode_ctx_get (inode, this, &bdatt)) - goto next; - - if (bd_get_bd_info (frame, this, xattr, buf->ia_gfid, &type, &size)) - goto out; - - /* BD file, update buf */ - bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - if (!bdatt) { - op_errno = ENOMEM; - goto out; - } - memcpy (&bdatt->iatt, buf, sizeof (struct iatt)); - bdatt->type = type; - - /* Cache LV size in inode_ctx */ - ret = bd_inode_ctx_set (inode, this, bdatt); - if (ret < 0) { - GF_FREE (bdatt); - op_errno = EINVAL; - goto out; - } - - bdatt->iatt.ia_size = size; - bdatt->iatt.ia_blocks = size / 512; +bd_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, inode_t *inode, struct iatt *buf, dict_t *xattr, + struct iatt *postparent) +{ + int ret = -1; + bd_attr_t *bdatt = NULL; + uint64_t size = 0; + char *type = NULL; + + /* only regular files are part of BD object */ + if (op_ret < 0 || buf->ia_type != IA_IFREG) + goto out; + + /* iatt already cached */ + if (!bd_inode_ctx_get(inode, this, &bdatt)) + goto next; + + if (bd_get_bd_info(frame, this, xattr, buf->ia_gfid, &type, &size)) + goto out; + + /* BD file, update buf */ + bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + if (!bdatt) { + op_errno = ENOMEM; + goto out; + } + memcpy(&bdatt->iatt, buf, sizeof(struct iatt)); + bdatt->type = type; + + /* Cache LV size in inode_ctx */ + ret = bd_inode_ctx_set(inode, this, bdatt); + if (ret < 0) { + GF_FREE(bdatt); + op_errno = EINVAL; + goto out; + } + + bdatt->iatt.ia_size = size; + bdatt->iatt.ia_blocks = size / 512; next: - dict_del (xattr, GF_CONTENT_KEY); - memcpy (buf, &bdatt->iatt, sizeof (struct iatt)); + dict_del(xattr, GF_CONTENT_KEY); + memcpy(buf, &bdatt->iatt, sizeof(struct iatt)); out: - BD_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, buf, - xattr, postparent); - return 0; + BD_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xattr, + postparent); + return 0; } /* * bd_lookup: Issues posix_lookup to find out if file is mapped to BD * bd_lookup -> posix_lookup -> bd_lookup_cbk -*/ + */ int32_t -bd_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req) -{ - dict_t *bd_xattr = NULL; - bd_attr_t *bdatt = NULL; - int op_errno = EINVAL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (loc->path, out); - VALIDATE_OR_GOTO (this->private, out); - - if (bd_inode_ctx_get (loc->inode, this, &bdatt) < 0) { - if (!xattr_req) { - bd_xattr = dict_new (); - BD_VALIDATE_MEM_ALLOC (bd_xattr, op_errno, out); - xattr_req = bd_xattr; - } - if (dict_set_int8 (xattr_req, BD_XATTR, 1) < 0) - goto out; +bd_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req) +{ + dict_t *bd_xattr = NULL; + bd_attr_t *bdatt = NULL; + int op_errno = EINVAL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(loc->path, out); + VALIDATE_OR_GOTO(this->private, out); + + if (bd_inode_ctx_get(loc->inode, this, &bdatt) < 0) { + if (!xattr_req) { + bd_xattr = dict_new(); + BD_VALIDATE_MEM_ALLOC(bd_xattr, op_errno, out); + xattr_req = bd_xattr; } + if (dict_set_int8(xattr_req, BD_XATTR, 1) < 0) + goto out; + } - STACK_WIND (frame, bd_lookup_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->lookup, loc, xattr_req); + STACK_WIND(frame, bd_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xattr_req); - if (bd_xattr) - dict_unref (bd_xattr); - return 0; + if (bd_xattr) + dict_unref(bd_xattr); + return 0; out: - BD_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL); + BD_STACK_UNWIND(lookup, frame, -1, op_errno, NULL, NULL, NULL, NULL); - return 0; + return 0; } int -bd_forget (xlator_t *this, inode_t *inode) +bd_forget(xlator_t *this, inode_t *inode) { - int ret = -1; - uint64_t ctx = 0; - bd_attr_t *bdatt = NULL; + int ret = -1; + uint64_t ctx = 0; + bd_attr_t *bdatt = NULL; - ret = bd_inode_ctx_get (inode, this, &bdatt); - if (!ret) { - inode_ctx_del (inode, this, &ctx); - GF_FREE (bdatt); - } - return 0; + ret = bd_inode_ctx_get(inode, this, &bdatt); + if (!ret) { + inode_ctx_del(inode, this, &ctx); + GF_FREE(bdatt); + } + return 0; } int -bd_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, gf_dirent_t *entries, dict_t *xdata) -{ - gf_dirent_t *entry = NULL; - uint64_t size = 0; - char *type = NULL; - - if (op_ret < 0) - goto out; - - list_for_each_entry (entry, &entries->list, list) { - if (entry->d_type != DT_REG) - continue; - if (!bd_get_bd_info (frame, this, entry->dict, - entry->d_stat.ia_gfid, &type, &size)) { - entry->d_stat.ia_size = size; - entry->d_stat.ia_blocks = size / 512; - GF_FREE (type); - } +bd_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, gf_dirent_t *entries, dict_t *xdata) +{ + gf_dirent_t *entry = NULL; + uint64_t size = 0; + char *type = NULL; + + if (op_ret < 0) + goto out; + + list_for_each_entry(entry, &entries->list, list) + { + if (entry->d_type != DT_REG) + continue; + if (!bd_get_bd_info(frame, this, entry->dict, entry->d_stat.ia_gfid, + &type, &size)) { + entry->d_stat.ia_size = size; + entry->d_stat.ia_blocks = size / 512; + GF_FREE(type); } + } out: - BD_STACK_UNWIND (readdirp, frame, op_ret, op_errno, entries, xdata); - return 0; + BD_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata); + return 0; } /* @@ -249,198 +251,196 @@ out: * ia_size is updated with the LV(BD_XATTR_SIZE) size */ int32_t -bd_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off, dict_t *dict) -{ - int op_errno = EINVAL; - bd_local_t *local = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); - - if (!dict) { - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); - local->dict = dict_new (); - BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out); - dict = local->dict; - } - - if (dict_set_int8 (dict, BD_XATTR, 0)) { - gf_log (this->name, GF_LOG_WARNING, - "failed to set key %s", BD_XATTR); - goto out; - } - - STACK_WIND (frame, bd_readdirp_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict); - - return 0; +bd_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *dict) +{ + int op_errno = EINVAL; + bd_local_t *local = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); + + if (!dict) { + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); + local->dict = dict_new(); + BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out); + dict = local->dict; + } + + if (dict_set_int8(dict, BD_XATTR, 0)) { + gf_log(this->name, GF_LOG_WARNING, "failed to set key %s", BD_XATTR); + goto out; + } + + STACK_WIND(frame, bd_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict); + + return 0; out: - BD_STACK_UNWIND (readdirp, frame, -1, op_errno, NULL, dict); - return 0; + BD_STACK_UNWIND(readdirp, frame, -1, op_errno, NULL, dict); + return 0; } int -bd_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, struct iatt *buf, dict_t *xdata) +bd_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct iatt *buf, dict_t *xdata) { - bd_local_t *local = frame->local; - bd_attr_t *bdatt = NULL; + bd_local_t *local = frame->local; + bd_attr_t *bdatt = NULL; - /* only regular files are part of BD object */ - if (op_ret < 0 || buf->ia_type != IA_IFREG) - goto out; + /* only regular files are part of BD object */ + if (op_ret < 0 || buf->ia_type != IA_IFREG) + goto out; - BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out); + BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out); - /* update buf with LV size */ - if (!bd_inode_ctx_get (local->inode, this, &bdatt)) - memcpy (buf, bdatt, sizeof (struct iatt)); + /* update buf with LV size */ + if (!bd_inode_ctx_get(local->inode, this, &bdatt)) + memcpy(buf, bdatt, sizeof(struct iatt)); out: - BD_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata); - return 0; + BD_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -bd_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +bd_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = EINVAL; - bd_local_t *local = NULL; - bd_attr_t *bdatt = NULL; + int op_errno = EINVAL; + bd_local_t *local = NULL; + bd_attr_t *bdatt = NULL; - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (loc->path, out); - VALIDATE_OR_GOTO (this->private, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(loc->path, out); + VALIDATE_OR_GOTO(this->private, out); - if (!bd_inode_ctx_get (loc->inode, this, &bdatt)) { - BD_STACK_UNWIND (stat, frame, 0, 0, &bdatt->iatt, xdata); - return 0; - } + if (!bd_inode_ctx_get(loc->inode, this, &bdatt)) { + BD_STACK_UNWIND(stat, frame, 0, 0, &bdatt->iatt, xdata); + return 0; + } - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); - local->inode = inode_ref (loc->inode); + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); + local->inode = inode_ref(loc->inode); - STACK_WIND(frame, bd_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, xdata); - return 0; + STACK_WIND(frame, bd_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + return 0; out: - BD_STACK_UNWIND (stat, frame, -1, op_errno, NULL, xdata); - return 0; + BD_STACK_UNWIND(stat, frame, -1, op_errno, NULL, xdata); + return 0; } int -bd_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, struct statvfs *buff, dict_t *xdata) -{ - uint64_t size = 0; - uint64_t fr_size = 0; - bd_priv_t *priv = NULL; - vg_t vg = NULL; - - if (op_ret < 0) - goto out; - - priv = this->private; - - vg = lvm_vg_open (priv->handle, priv->vg, "r", 0); - if (!vg) { - gf_log (this->name, GF_LOG_WARNING, "opening VG %s failed", - priv->vg); - op_ret = -1; - op_errno = EAGAIN; - goto out; - } - size = lvm_vg_get_size (vg); - fr_size = lvm_vg_get_free_size (vg); - lvm_vg_close (vg); - - buff->f_blocks += size / buff->f_frsize; - buff->f_bfree += fr_size / buff->f_frsize; - buff->f_bavail += fr_size / buff->f_frsize; +bd_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct statvfs *buff, dict_t *xdata) +{ + uint64_t size = 0; + uint64_t fr_size = 0; + bd_priv_t *priv = NULL; + vg_t vg = NULL; + + if (op_ret < 0) + goto out; + + priv = this->private; + + vg = lvm_vg_open(priv->handle, priv->vg, "r", 0); + if (!vg) { + gf_log(this->name, GF_LOG_WARNING, "opening VG %s failed", priv->vg); + op_ret = -1; + op_errno = EAGAIN; + goto out; + } + size = lvm_vg_get_size(vg); + fr_size = lvm_vg_get_free_size(vg); + lvm_vg_close(vg); + + buff->f_blocks += size / buff->f_frsize; + buff->f_bfree += fr_size / buff->f_frsize; + buff->f_bavail += fr_size / buff->f_frsize; out: - BD_STACK_UNWIND (statfs, frame, op_ret, op_errno, buff, xdata); - return 0; + BD_STACK_UNWIND(statfs, frame, op_ret, op_errno, buff, xdata); + return 0; } /* * bd_statfs: Mimics statfs by returning used/free extents in the VG */ int -bd_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +bd_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); - STACK_WIND (frame, bd_statfs_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, loc, xdata); - return 0; + STACK_WIND(frame, bd_statfs_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; out: - BD_STACK_UNWIND (statfs, frame, -1, EINVAL, NULL, NULL); - return 0; + BD_STACK_UNWIND(statfs, frame, -1, EINVAL, NULL, NULL); + return 0; } int -bd_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, struct iatt *buf, dict_t *xdata) +bd_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct iatt *buf, dict_t *xdata) { - bd_attr_t *bdatt = NULL; - bd_local_t *local = frame->local; + bd_attr_t *bdatt = NULL; + bd_local_t *local = frame->local; - /* only regular files are part of BD object */ - if (op_ret < 0 || buf->ia_type != IA_IFREG) - goto out; + /* only regular files are part of BD object */ + if (op_ret < 0 || buf->ia_type != IA_IFREG) + goto out; - BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out); + BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out); - /* update buf with LV size */ - if (!bd_inode_ctx_get (local->inode, this, &bdatt)) - memcpy (buf, &bdatt->iatt, sizeof (struct iatt)); + /* update buf with LV size */ + if (!bd_inode_ctx_get(local->inode, this, &bdatt)) + memcpy(buf, &bdatt->iatt, sizeof(struct iatt)); out: - BD_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + BD_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -bd_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +bd_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int op_errno = EINVAL; - bd_local_t *local = NULL; - bd_attr_t *bdatt = NULL; + int op_errno = EINVAL; + bd_local_t *local = NULL; + bd_attr_t *bdatt = NULL; - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); - /* if its already cached return it */ - if (!bd_inode_ctx_get (fd->inode, this, &bdatt)) { - BD_STACK_UNWIND (fstat, frame, 0, 0, &bdatt->iatt, xdata); - return 0; - } + /* if its already cached return it */ + if (!bd_inode_ctx_get(fd->inode, this, &bdatt)) { + BD_STACK_UNWIND(fstat, frame, 0, 0, &bdatt->iatt, xdata); + return 0; + } - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); - local->inode = inode_ref (fd->inode); + local->inode = inode_ref(fd->inode); - STACK_WIND (frame, bd_fstat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd, xdata); + STACK_WIND(frame, bd_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); - return 0; + return 0; out: - BD_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, xdata); - return 0; + BD_STACK_UNWIND(fstat, frame, -1, op_errno, NULL, xdata); + return 0; } /* @@ -448,80 +448,81 @@ out: * file */ int -bd_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) -{ - int ret = -1; - int _fd = -1; - int32_t op_ret = -1; - int32_t op_errno = 0; - bd_fd_t *bd_fd = NULL; - struct iovec vec = {0, }; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - uint64_t bd_size = 0; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { - STACK_WIND (frame, default_readv_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags, xdata); - return 0; - } - if (!size) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_WARNING, "size=%"GF_PRI_SIZET, size); - goto out; - } - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (!iobuf) { - op_errno = ENOMEM; - goto out; - } - _fd = bd_fd->fd; - op_ret = sys_pread (_fd, iobuf->ptr, size, offset); - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_ERROR, - "read failed on fd=%p: %s", fd, - strerror (op_errno)); - goto out; - } - - vec.iov_base = iobuf->ptr; - vec.iov_len = op_ret; - - iobref = iobref_new (); - iobref_add (iobref, iobuf); - - if (bd_inode_ctx_get (fd->inode, this, &bdatt)) { - op_errno = EINVAL; - op_ret = -1; - goto out; - } - bd_size = bdatt->iatt.ia_size; - if (!bd_size || (offset + vec.iov_len) >= bd_size) - op_errno = ENOENT; - - op_ret = vec.iov_len; - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_ATIME); +bd_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) +{ + int ret = -1; + int _fd = -1; + int32_t op_ret = -1; + int32_t op_errno = 0; + bd_fd_t *bd_fd = NULL; + struct iovec vec = { + 0, + }; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + uint64_t bd_size = 0; + bd_attr_t *bdatt = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { + STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, + xdata); + return 0; + } + if (!size) { + op_errno = EINVAL; + gf_log(this->name, GF_LOG_WARNING, "size=%" GF_PRI_SIZET, size); + goto out; + } + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (!iobuf) { + op_errno = ENOMEM; + goto out; + } + _fd = bd_fd->fd; + op_ret = sys_pread(_fd, iobuf->ptr, size, offset); + if (op_ret == -1) { + op_errno = errno; + gf_log(this->name, GF_LOG_ERROR, "read failed on fd=%p: %s", fd, + strerror(op_errno)); + goto out; + } + + vec.iov_base = iobuf->ptr; + vec.iov_len = op_ret; + + iobref = iobref_new(); + iobref_add(iobref, iobuf); + + if (bd_inode_ctx_get(fd->inode, this, &bdatt)) { + op_errno = EINVAL; + op_ret = -1; + goto out; + } + bd_size = bdatt->iatt.ia_size; + if (!bd_size || (offset + vec.iov_len) >= bd_size) + op_errno = ENOENT; + + op_ret = vec.iov_len; + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_ATIME); out: - BD_STACK_UNWIND (readv, frame, op_ret, op_errno, - &vec, 1, &bdatt->iatt, iobref, NULL); + BD_STACK_UNWIND(readv, frame, op_ret, op_errno, &vec, 1, &bdatt->iatt, + iobref, NULL); - if (iobref) - iobref_unref (iobref); - if (iobuf) - iobuf_unref (iobuf); + if (iobref) + iobref_unref(iobref); + if (iobuf) + iobuf_unref(iobuf); - return 0; + return 0; } #ifdef BLKDISCARD @@ -529,64 +530,67 @@ out: * bd_discard: Sends BLKDISCARD ioctl to the block device */ int -bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) -{ - int ret = -1; - int op_errno = EINVAL; - bd_fd_t *bd_fd = NULL; - uint64_t param[2] = {0, }; - bd_attr_t *bdatt = NULL; - struct iatt prebuf = {0, }; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (fd, out); - - /* posix */ - if (bd_inode_ctx_get (fd->inode, this, &bdatt)) { - STACK_WIND (frame, default_discard_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->discard, - fd, offset, len, xdata); - return 0; - } - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { - op_errno = EINVAL; - goto out; - } - - param[0] = offset; - param[1] = len; - ret = ioctl (bd_fd->fd, BLKDISCARD, param); - if (ret < 0) { - if (errno == ENOTTY) - op_errno = ENOSYS; - else - op_errno = errno; - goto out; - } - memcpy (&prebuf, &bdatt->iatt, sizeof (prebuf)); - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME); +bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + int ret = -1; + int op_errno = EINVAL; + bd_fd_t *bd_fd = NULL; + uint64_t param[2] = { + 0, + }; + bd_attr_t *bdatt = NULL; + struct iatt prebuf = { + 0, + }; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(fd, out); + + /* posix */ + if (bd_inode_ctx_get(fd->inode, this, &bdatt)) { + STACK_WIND(frame, default_discard_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); + return 0; + } + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { + op_errno = EINVAL; + goto out; + } + + param[0] = offset; + param[1] = len; + ret = ioctl(bd_fd->fd, BLKDISCARD, param); + if (ret < 0) { + if (errno == ENOTTY) + op_errno = ENOSYS; + else + op_errno = errno; + goto out; + } + memcpy(&prebuf, &bdatt->iatt, sizeof(prebuf)); + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME); - BD_STACK_UNWIND (discard, frame, ret, op_errno, &prebuf, - &bdatt->iatt, xdata); - return 0; + BD_STACK_UNWIND(discard, frame, ret, op_errno, &prebuf, &bdatt->iatt, + xdata); + return 0; out: - BD_STACK_UNWIND (discard, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(discard, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } #else int -bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) +bd_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) { - BD_STACK_UNWIND (discard, frame, -1, ENOSYS, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(discard, frame, -1, ENOSYS, NULL, NULL, NULL); + return 0; } #endif @@ -595,32 +599,31 @@ bd_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, * If it failed, close BD fd */ int -bd_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, fd_t *fd, dict_t *xdata) +bd_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, fd_t *fd, dict_t *xdata) { - bd_fd_t *bd_fd = NULL; - bd_attr_t *bdatt = NULL; + bd_fd_t *bd_fd = NULL; + bd_attr_t *bdatt = NULL; - if (!op_ret) - goto out; + if (!op_ret) + goto out; - bd_inode_ctx_get (fd->inode, this, &bdatt); - if (!bdatt) /* posix file */ - goto out; + bd_inode_ctx_get(fd->inode, this, &bdatt); + if (!bdatt) /* posix file */ + goto out; - /* posix open failed */ - if (bd_fd_ctx_get (this, fd, &bd_fd) < 0) { - gf_log (this->name, GF_LOG_WARNING, - "bd_fd is NULL from fd=%p", fd); - goto out; - } - sys_close (bd_fd->fd); - GF_FREE (bd_fd); + /* posix open failed */ + if (bd_fd_ctx_get(this, fd, &bd_fd) < 0) { + gf_log(this->name, GF_LOG_WARNING, "bd_fd is NULL from fd=%p", fd); + goto out; + } + sys_close(bd_fd->fd); + GF_FREE(bd_fd); out: - BD_STACK_UNWIND (open, frame, op_ret, op_errno, fd, NULL); + BD_STACK_UNWIND(open, frame, op_ret, op_errno, fd, NULL); - return 0; + return 0; } /* @@ -629,270 +632,270 @@ out: * fd contains both posix and BD fd */ int32_t -bd_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - fd_t *fd, dict_t *xdata) -{ - int32_t ret = EINVAL; - bd_fd_t *bd_fd = NULL; - bd_attr_t *bdatt = NULL; - bd_gfid_t gfid = {0, }; - char *devpath = NULL; - bd_priv_t *priv = this->private; - int _fd = -1; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (fd, out); - - /* not bd file */ - if (fd->inode->ia_type != IA_IFREG || - bd_inode_ctx_get (fd->inode, this, &bdatt)) - goto posix; - - uuid_utoa_r (fd->inode->gfid, gfid); - gf_asprintf (&devpath, "/dev/%s/%s", priv->vg, gfid); - BD_VALIDATE_MEM_ALLOC (devpath, ret, out); - - _fd = open (devpath, flags | O_LARGEFILE, 0); - if (_fd < 0) { - ret = errno; - gf_log (this->name, GF_LOG_ERROR, "open on %s: %s", devpath, - strerror (ret)); - goto out; - } - bd_fd = GF_CALLOC (1, sizeof(bd_fd_t), gf_bd_fd); - BD_VALIDATE_MEM_ALLOC (bd_fd, ret, out); - - bd_fd->fd = _fd; - bd_fd->flag = flags | O_LARGEFILE; - - if (fd_ctx_set (fd, this, (uint64_t)(long)bd_fd) < 0) { - gf_log (this->name, GF_LOG_WARNING, - "failed to set the fd context fd=%p", fd); - goto out; - } - - ret = 0; +bd_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) +{ + int32_t ret = EINVAL; + bd_fd_t *bd_fd = NULL; + bd_attr_t *bdatt = NULL; + bd_gfid_t gfid = { + 0, + }; + char *devpath = NULL; + bd_priv_t *priv = this->private; + int _fd = -1; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(fd, out); + + /* not bd file */ + if (fd->inode->ia_type != IA_IFREG || + bd_inode_ctx_get(fd->inode, this, &bdatt)) + goto posix; + + uuid_utoa_r(fd->inode->gfid, gfid); + gf_asprintf(&devpath, "/dev/%s/%s", priv->vg, gfid); + BD_VALIDATE_MEM_ALLOC(devpath, ret, out); + + _fd = open(devpath, flags | O_LARGEFILE, 0); + if (_fd < 0) { + ret = errno; + gf_log(this->name, GF_LOG_ERROR, "open on %s: %s", devpath, + strerror(ret)); + goto out; + } + bd_fd = GF_CALLOC(1, sizeof(bd_fd_t), gf_bd_fd); + BD_VALIDATE_MEM_ALLOC(bd_fd, ret, out); + + bd_fd->fd = _fd; + bd_fd->flag = flags | O_LARGEFILE; + + if (fd_ctx_set(fd, this, (uint64_t)(long)bd_fd) < 0) { + gf_log(this->name, GF_LOG_WARNING, "failed to set the fd context fd=%p", + fd); + goto out; + } + + ret = 0; posix: - /* open posix equivalent of this file, fd needed for fd related - operations like fsetxattr, ftruncate etc */ - STACK_WIND (frame, bd_open_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); + /* open posix equivalent of this file, fd needed for fd related + operations like fsetxattr, ftruncate etc */ + STACK_WIND(frame, bd_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); - GF_FREE (devpath); - return 0; + GF_FREE(devpath); + return 0; out: - BD_STACK_UNWIND (open, frame, -1, ret, fd, NULL); + BD_STACK_UNWIND(open, frame, -1, ret, fd, NULL); - GF_FREE (devpath); - if (ret) { - if (_fd >= 0) - sys_close (_fd); - GF_FREE (bd_fd); - } + GF_FREE(devpath); + if (ret) { + if (_fd >= 0) + sys_close(_fd); + GF_FREE(bd_fd); + } - return 0; + return 0; } /* * call back from posix_setattr after updating iatt to posix file. */ int -bd_fsync_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *pre, - struct iatt *post, dict_t *xdata) +bd_fsync_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) { - bd_local_t *local = frame->local; - bd_attr_t *bdatt = local->bdatt; + bd_local_t *local = frame->local; + bd_attr_t *bdatt = local->bdatt; - BD_STACK_UNWIND (fsync, frame, op_ret, op_errno, &bdatt->iatt, - &bdatt->iatt, NULL); - return 0; + BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &bdatt->iatt, &bdatt->iatt, + NULL); + return 0; } int -bd_do_fsync (int fd, int datasync) +bd_do_fsync(int fd, int datasync) { - int op_errno = 0; + int op_errno = 0; - if (datasync) { - if (sys_fdatasync (fd)) { - op_errno = errno; - gf_log (THIS->name, GF_LOG_ERROR, - "fdatasync on fd=%d failed: %s", - fd, strerror (errno)); - } + if (datasync) { + if (sys_fdatasync(fd)) { + op_errno = errno; + gf_log(THIS->name, GF_LOG_ERROR, "fdatasync on fd=%d failed: %s", + fd, strerror(errno)); + } - } else + } else - { - if (sys_fsync (fd)) { - op_errno = errno; - gf_log (THIS->name, GF_LOG_ERROR, - "fsync on fd=%d failed: %s", - fd, strerror (op_errno)); - } + { + if (sys_fsync(fd)) { + op_errno = errno; + gf_log(THIS->name, GF_LOG_ERROR, "fsync on fd=%d failed: %s", fd, + strerror(op_errno)); } + } - return op_errno; + return op_errno; } /* * bd_fsync: Syncs if BD fd, forwards the request to posix * fsync -> posix_setattr -> posix_fsync -*/ + */ int32_t -bd_fsync (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync, dict_t *xdata) -{ - int ret = -1; - int32_t op_ret = -1; - int32_t op_errno = 0; - bd_fd_t *bd_fd = NULL; - bd_attr_t *bdatt = NULL; - bd_local_t *local = NULL; - int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; - struct iatt prebuf = {0, }; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); - - ret = bd_inode_ctx_get (fd->inode, this, &bdatt); - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd || !bdatt) { - STACK_WIND (frame, default_fsync_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsync, fd, datasync, - xdata); - return 0; - } - - memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt)); - - op_errno = bd_do_fsync (bd_fd->fd, datasync); - if (op_errno) - goto out; - - /* For BD, Update the a|mtime during full fsync only */ - if (!datasync) { - local = bd_local_init (frame, this); - /* In case of mem failure, should posix flush called ? */ - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); - - local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out); - - local->bdatt->type = gf_strdup (bdatt->type); - memcpy (&local->bdatt->iatt, &bdatt->iatt, sizeof (struct iatt)); - bd_update_amtime (&local->bdatt->iatt, valid); - gf_uuid_copy (local->loc.gfid, fd->inode->gfid); - STACK_WIND (frame, bd_fsync_setattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setattr, &local->loc, - &local->bdatt->iatt, - valid, NULL); - return 0; - } +bd_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) +{ + int ret = -1; + int32_t op_ret = -1; + int32_t op_errno = 0; + bd_fd_t *bd_fd = NULL; + bd_attr_t *bdatt = NULL; + bd_local_t *local = NULL; + int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; + struct iatt prebuf = { + 0, + }; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); + + ret = bd_inode_ctx_get(fd->inode, this, &bdatt); + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd || !bdatt) { + STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata); + return 0; + } + + memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt)); + + op_errno = bd_do_fsync(bd_fd->fd, datasync); + if (op_errno) + goto out; + + /* For BD, Update the a|mtime during full fsync only */ + if (!datasync) { + local = bd_local_init(frame, this); + /* In case of mem failure, should posix flush called ? */ + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); + + local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out); + + local->bdatt->type = gf_strdup(bdatt->type); + memcpy(&local->bdatt->iatt, &bdatt->iatt, sizeof(struct iatt)); + bd_update_amtime(&local->bdatt->iatt, valid); + gf_uuid_copy(local->loc.gfid, fd->inode->gfid); + STACK_WIND(frame, bd_fsync_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, &local->loc, + &local->bdatt->iatt, valid, NULL); + return 0; + } out: - BD_STACK_UNWIND (fsync, frame, op_ret, op_errno, &prebuf, - &bdatt->iatt, NULL); - return 0; + BD_STACK_UNWIND(fsync, frame, op_ret, op_errno, &prebuf, &bdatt->iatt, + NULL); + return 0; } int -bd_flush_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *pre, - struct iatt *post, dict_t *xdata) +bd_flush_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) { - BD_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata); - return 0; + BD_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata); + return 0; } int -bd_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) -{ - int ret = -1; - bd_fd_t *bd_fd = NULL; - bd_attr_t *bdatt = NULL; - int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; - bd_local_t *local = NULL; - loc_t loc = {0, }; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); - - ret = bd_inode_ctx_get (fd->inode, this, &bdatt); - if (!bdatt) - goto out; - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd || !bdatt) { - gf_log (this->name, GF_LOG_WARNING, - "bdfd/bdatt is NULL from fd=%p", fd); - goto out; - } - - local = bd_local_init (frame, this); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, "out of memory"); - goto out; - } - - local->fd = fd_ref (fd); - gf_uuid_copy (loc.gfid, bdatt->iatt.ia_gfid); - - /* Update the a|mtime during flush */ - STACK_WIND (frame, bd_flush_setattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setattr, &loc, &bdatt->iatt, - valid, NULL); - - return 0; +bd_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +{ + int ret = -1; + bd_fd_t *bd_fd = NULL; + bd_attr_t *bdatt = NULL; + int valid = GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME; + bd_local_t *local = NULL; + loc_t loc = { + 0, + }; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); + + ret = bd_inode_ctx_get(fd->inode, this, &bdatt); + if (!bdatt) + goto out; + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd || !bdatt) { + gf_log(this->name, GF_LOG_WARNING, "bdfd/bdatt is NULL from fd=%p", fd); + goto out; + } + + local = bd_local_init(frame, this); + if (!local) { + gf_log(this->name, GF_LOG_ERROR, "out of memory"); + goto out; + } + + local->fd = fd_ref(fd); + gf_uuid_copy(loc.gfid, bdatt->iatt.ia_gfid); + + /* Update the a|mtime during flush */ + STACK_WIND(frame, bd_flush_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, &loc, &bdatt->iatt, valid, + NULL); + + return 0; out: - STACK_WIND (frame, default_flush_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->flush, fd, xdata); + STACK_WIND(frame, default_flush_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, fd, xdata); - return 0; + return 0; } int32_t -bd_release (xlator_t *this, fd_t *fd) +bd_release(xlator_t *this, fd_t *fd) { - int ret = -1; - bd_fd_t *bd_fd = NULL; - uint64_t tmp_bfd = 0; - bd_attr_t *bdatt = NULL; - bd_priv_t *priv = this->private; + int ret = -1; + bd_fd_t *bd_fd = NULL; + uint64_t tmp_bfd = 0; + bd_attr_t *bdatt = NULL; + bd_priv_t *priv = this->private; - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (priv, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(priv, out); - ret = bd_inode_ctx_get (fd->inode, this, &bdatt); - if (ret || !bdatt) /* posix file */ - goto out; + ret = bd_inode_ctx_get(fd->inode, this, &bdatt); + if (ret || !bdatt) /* posix file */ + goto out; - /* FIXME: Update amtime during release */ + /* FIXME: Update amtime during release */ - ret = fd_ctx_del (fd, this, &tmp_bfd); - if (ret < 0) { - gf_log (this->name, GF_LOG_WARNING, - "bfd is NULL from fd=%p", fd); - goto out; - } - bd_fd = (bd_fd_t *)(long)tmp_bfd; + ret = fd_ctx_del(fd, this, &tmp_bfd); + if (ret < 0) { + gf_log(this->name, GF_LOG_WARNING, "bfd is NULL from fd=%p", fd); + goto out; + } + bd_fd = (bd_fd_t *)(long)tmp_bfd; - sys_close (bd_fd->fd); - GF_FREE (bd_fd); + sys_close(bd_fd->fd); + GF_FREE(bd_fd); out: - return 0; + return 0; } /* @@ -900,17 +903,16 @@ out: * bd create failure */ int -bd_setx_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_setx_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - bd_local_t *local = frame->local; - - if (local->fd) - BD_STACK_UNWIND (setxattr, frame, -1, EIO, xdata); - else - BD_STACK_UNWIND (setxattr, frame, -1, EIO, xdata); - return 0; + bd_local_t *local = frame->local; + if (local->fd) + BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata); + else + BD_STACK_UNWIND(setxattr, frame, -1, EIO, xdata); + return 0; } /* @@ -918,426 +920,423 @@ bd_setx_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, * invokes posix_removexattr to remove created BD_XATTR */ int -bd_setx_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) -{ - bd_local_t *local = frame->local; - bd_attr_t *bdatt = NULL; - - if (op_ret < 0) - goto next; - - /* Create LV */ - op_errno = bd_create (local->inode->gfid, local->bdatt->iatt.ia_size, - local->bdatt->type, this->private); - if (!op_errno) - goto out; - - /* LV creation failed, remove BD_XATTR */ - if (local->fd) - STACK_WIND (frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, - local->fd, BD_XATTR, NULL); - else - STACK_WIND (frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - &local->loc, BD_XATTR, NULL); - - return 0; +bd_setx_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, dict_t *xdata) +{ + bd_local_t *local = frame->local; + bd_attr_t *bdatt = NULL; + + if (op_ret < 0) + goto next; + + /* Create LV */ + op_errno = bd_create(local->inode->gfid, local->bdatt->iatt.ia_size, + local->bdatt->type, this->private); + if (!op_errno) + goto out; + + /* LV creation failed, remove BD_XATTR */ + if (local->fd) + STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, local->fd, BD_XATTR, + NULL); + else + STACK_WIND(frame, bd_setx_rm_xattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, &local->loc, BD_XATTR, + NULL); + + return 0; out: - bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - if (!bdatt) { - op_ret = -1; - op_errno = ENOMEM; - goto next; - } + bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + if (!bdatt) { + op_ret = -1; + op_errno = ENOMEM; + goto next; + } - memcpy (&bdatt->iatt, &local->bdatt->iatt, sizeof (struct iatt)); - bdatt->type = gf_strdup (local->bdatt->type); + memcpy(&bdatt->iatt, &local->bdatt->iatt, sizeof(struct iatt)); + bdatt->type = gf_strdup(local->bdatt->type); - bd_inode_ctx_set (local->inode, THIS, bdatt); + bd_inode_ctx_set(local->inode, THIS, bdatt); next: - if (local->fd) - BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); - else - BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); - return 0; - + if (local->fd) + BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata); + else + BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata); + return 0; } /* * Call back from posix_stat */ int -bd_setx_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *iatt, - dict_t *xdata) -{ - char *param = NULL; - char *type = NULL; - char *s_size = NULL; - char *p = NULL; - char *copy = NULL; - bd_local_t *local = frame->local; - bd_priv_t *priv = this->private; - char *bd = NULL; - uint64_t size = 0; - - if (op_ret < 0) - goto out; - - if (!IA_ISREG (iatt->ia_type)) { - op_errno = EOPNOTSUPP; - goto out; - } - - param = copy = GF_MALLOC (local->data->len + 1, gf_common_mt_char); - BD_VALIDATE_MEM_ALLOC (param, op_errno, out); - - strncpy (param, local->data->data, local->data->len); - param[local->data->len] = '\0'; - - type = strtok_r (param, ":", &p); - if (!type) { - op_errno = EINVAL; - goto out; - } - - if (strcmp (type, BD_LV) && strcmp (type, BD_THIN)) { - gf_log (this->name, GF_LOG_WARNING, "Invalid bd type %s given", - type); - op_errno = EINVAL; - goto out; - } - - if (!strcmp (type, BD_THIN) && !(priv->caps & BD_CAPS_THIN)) { - gf_log (this->name, GF_LOG_WARNING, "THIN lv not supported by " - "this volume"); - op_errno = EOPNOTSUPP; - goto out; - } - - s_size = strtok_r (NULL, ":", &p); - - /* If size not specified get default size */ - if (!s_size) - size = bd_get_default_extent (priv); - else - gf_string2bytesize (s_size, &size); - - gf_asprintf (&bd, "%s:%ld", type, size); - BD_VALIDATE_MEM_ALLOC (bd, op_errno, out); - - local->dict = dict_new (); - BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out); - - local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out); - - if (dict_set_dynstr (local->dict, BD_XATTR, bd) < 0) { - op_errno = EINVAL; - goto out; - } - - local->bdatt->type = gf_strdup (type); - memcpy (&local->bdatt->iatt, iatt, sizeof (struct iatt)); - local->bdatt->iatt.ia_size = size; - - if (local->fd) - STACK_WIND (frame, bd_setx_setx_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - local->fd, local->dict, 0, NULL); - else - STACK_WIND (frame, bd_setx_setx_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - &local->loc, local->dict, 0, NULL); - - return 0; +bd_setx_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct iatt *iatt, dict_t *xdata) +{ + char *param = NULL; + char *type = NULL; + char *s_size = NULL; + char *p = NULL; + char *copy = NULL; + bd_local_t *local = frame->local; + bd_priv_t *priv = this->private; + char *bd = NULL; + uint64_t size = 0; + + if (op_ret < 0) + goto out; + + if (!IA_ISREG(iatt->ia_type)) { + op_errno = EOPNOTSUPP; + goto out; + } + + param = copy = GF_MALLOC(local->data->len + 1, gf_common_mt_char); + BD_VALIDATE_MEM_ALLOC(param, op_errno, out); + + strncpy(param, local->data->data, local->data->len); + param[local->data->len] = '\0'; + + type = strtok_r(param, ":", &p); + if (!type) { + op_errno = EINVAL; + goto out; + } + + if (strcmp(type, BD_LV) && strcmp(type, BD_THIN)) { + gf_log(this->name, GF_LOG_WARNING, "Invalid bd type %s given", type); + op_errno = EINVAL; + goto out; + } + + if (!strcmp(type, BD_THIN) && !(priv->caps & BD_CAPS_THIN)) { + gf_log(this->name, GF_LOG_WARNING, + "THIN lv not supported by " + "this volume"); + op_errno = EOPNOTSUPP; + goto out; + } + + s_size = strtok_r(NULL, ":", &p); + + /* If size not specified get default size */ + if (!s_size) + size = bd_get_default_extent(priv); + else + gf_string2bytesize(s_size, &size); + + gf_asprintf(&bd, "%s:%ld", type, size); + BD_VALIDATE_MEM_ALLOC(bd, op_errno, out); + + local->dict = dict_new(); + BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out); + + local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out); + + if (dict_set_dynstr(local->dict, BD_XATTR, bd) < 0) { + op_errno = EINVAL; + goto out; + } + + local->bdatt->type = gf_strdup(type); + memcpy(&local->bdatt->iatt, iatt, sizeof(struct iatt)); + local->bdatt->iatt.ia_size = size; + + if (local->fd) + STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict, + 0, NULL); + else + STACK_WIND(frame, bd_setx_setx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict, + 0, NULL); + + return 0; out: - if (local->fd) - BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, xdata); - else - BD_STACK_UNWIND (setxattr, frame, -1, op_errno, xdata); + if (local->fd) + BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, xdata); + else + BD_STACK_UNWIND(setxattr, frame, -1, op_errno, xdata); - GF_FREE (bd); - GF_FREE (copy); - return 0; + GF_FREE(bd); + GF_FREE(copy); + return 0; } int -bd_offload_rm_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_offload_rm_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - bd_local_t *local = frame->local; + bd_local_t *local = frame->local; - if (local->fd) - BD_STACK_UNWIND (fsetxattr, frame, -1, EIO, NULL); - else - BD_STACK_UNWIND (setxattr, frame, -1, EIO, NULL); + if (local->fd) + BD_STACK_UNWIND(fsetxattr, frame, -1, EIO, NULL); + else + BD_STACK_UNWIND(setxattr, frame, -1, EIO, NULL); - return 0; + return 0; } int -bd_offload_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_offload_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - bd_local_t *local = frame->local; + bd_local_t *local = frame->local; - if (op_ret < 0) - goto out; + if (op_ret < 0) + goto out; - if (local->offload == BD_OF_SNAPSHOT) - op_ret = bd_snapshot_create (frame->local, this->private); - else - op_ret = bd_clone (frame->local, this->private); + if (local->offload == BD_OF_SNAPSHOT) + op_ret = bd_snapshot_create(frame->local, this->private); + else + op_ret = bd_clone(frame->local, this->private); - if (op_ret) { - STACK_WIND (frame, bd_offload_rm_xattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - local->dloc, BD_XATTR, NULL); - return 0; - } + if (op_ret) { + STACK_WIND(frame, bd_offload_rm_xattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, local->dloc, BD_XATTR, + NULL); + return 0; + } out: - if (local->fd) - BD_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL); - else - BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL); + if (local->fd) + BD_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL); + else + BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL); - return 0; + return 0; } int -bd_offload_getx_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xattr, dict_t *xdata) -{ - char *bd = NULL; - bd_local_t *local = frame->local; - char *type = NULL; - char *p = NULL; - - if (op_ret < 0) - goto out; - - if (dict_get_str (xattr, BD_XATTR, &p)) { - op_errno = EINVAL; - goto out; - } - - type = gf_strdup (p); - BD_VALIDATE_MEM_ALLOC (type, op_errno, out); - - p = strrchr (type, ':'); - if (!p) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_WARNING, - "source file xattr %s corrupted?", type); - goto out; - } - - *p='\0'; - - /* For clone size is taken from source LV */ - if (!local->size) { - p++; - gf_string2bytesize (p, &local->size); - } - gf_asprintf (&bd, "%s:%ld", type, local->size); - local->bdatt->type = gf_strdup (type); - dict_del (local->dict, LINKTO); - if (dict_set_dynstr (local->dict, BD_XATTR, bd)) { - op_errno = EINVAL; - goto out; - } - - STACK_WIND (frame, bd_offload_setx_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - local->dloc, local->dict, 0, NULL); - - return 0; +bd_offload_getx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xattr, dict_t *xdata) +{ + char *bd = NULL; + bd_local_t *local = frame->local; + char *type = NULL; + char *p = NULL; + + if (op_ret < 0) + goto out; + + if (dict_get_str(xattr, BD_XATTR, &p)) { + op_errno = EINVAL; + goto out; + } + + type = gf_strdup(p); + BD_VALIDATE_MEM_ALLOC(type, op_errno, out); + + p = strrchr(type, ':'); + if (!p) { + op_errno = EINVAL; + gf_log(this->name, GF_LOG_WARNING, "source file xattr %s corrupted?", + type); + goto out; + } + + *p = '\0'; + + /* For clone size is taken from source LV */ + if (!local->size) { + p++; + gf_string2bytesize(p, &local->size); + } + gf_asprintf(&bd, "%s:%ld", type, local->size); + local->bdatt->type = gf_strdup(type); + dict_del(local->dict, LINKTO); + if (dict_set_dynstr(local->dict, BD_XATTR, bd)) { + op_errno = EINVAL; + goto out; + } + + STACK_WIND(frame, bd_offload_setx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, local->dloc, local->dict, 0, + NULL); + + return 0; out: - if (local->fd) - BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL); - else - BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL); + if (local->fd) + BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL); + else + BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL); - GF_FREE (type); - GF_FREE (bd); + GF_FREE(type); + GF_FREE(bd); - return 0; + return 0; } int -bd_offload_dest_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, - inode_t *inode, struct iatt *iatt, - dict_t *xattr, struct iatt *postparent) -{ - bd_local_t *local = frame->local; - char *bd = NULL; - char *linkto = NULL; - int ret = -1; - - if (op_ret < 0 && op_errno != ENODATA) { - op_errno = EINVAL; - goto out; - } - - if (!IA_ISREG (iatt->ia_type)) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_WARNING, "destination gfid is not a " - "regular file"); - goto out; - } - - ret = dict_get_str (xattr, LINKTO, &linkto); - if (linkto) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_WARNING, "destination file not " - "present in same brick"); - goto out; - } - - ret = dict_get_str (xattr, BD_XATTR, &bd); - if (bd) { - op_errno = EEXIST; - goto out; - } - - local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out); - - STACK_WIND (frame, bd_offload_getx_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - &local->loc, BD_XATTR, NULL); - - return 0; +bd_offload_dest_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, inode_t *inode, + struct iatt *iatt, dict_t *xattr, + struct iatt *postparent) +{ + bd_local_t *local = frame->local; + char *bd = NULL; + char *linkto = NULL; + int ret = -1; + + if (op_ret < 0 && op_errno != ENODATA) { + op_errno = EINVAL; + goto out; + } + + if (!IA_ISREG(iatt->ia_type)) { + op_errno = EINVAL; + gf_log(this->name, GF_LOG_WARNING, + "destination gfid is not a " + "regular file"); + goto out; + } + + ret = dict_get_str(xattr, LINKTO, &linkto); + if (linkto) { + op_errno = EINVAL; + gf_log(this->name, GF_LOG_WARNING, + "destination file not " + "present in same brick"); + goto out; + } + + ret = dict_get_str(xattr, BD_XATTR, &bd); + if (bd) { + op_errno = EEXIST; + goto out; + } + + local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out); + + STACK_WIND(frame, bd_offload_getx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, &local->loc, BD_XATTR, NULL); + + return 0; out: - if (local->fd) - BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL); - else - BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL); + if (local->fd) + BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL); + else + BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL); - return (ret == 0) ? 0 : ret; + return (ret == 0) ? 0 : ret; } int -bd_merge_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +bd_merge_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - /* FIXME: if delete failed, remove xattr */ + /* FIXME: if delete failed, remove xattr */ - BD_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL); - return 0; + BD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL); + return 0; } int bd_do_merge(call_frame_t *frame, xlator_t *this) { - bd_local_t *local = frame->local; - inode_t *parent = NULL; - char *p = NULL; - int op_errno = 0; - - op_errno = bd_merge (this->private, local->inode->gfid); - if (op_errno) - goto out; - + bd_local_t *local = frame->local; + inode_t *parent = NULL; + char *p = NULL; + int op_errno = 0; + + op_errno = bd_merge(this->private, local->inode->gfid); + if (op_errno) + goto out; + + /* + * posix_unlink needs loc->pargfid to be valid, but setxattr FOP does + * not have loc->pargfid set. Get parent's gfid by getting parents inode + */ + parent = inode_parent(local->inode, NULL, NULL); + if (!parent) { /* - * posix_unlink needs loc->pargfid to be valid, but setxattr FOP does - * not have loc->pargfid set. Get parent's gfid by getting parents inode + * FIXME: Snapshot LV already deleted. + * remove xattr, instead of returning failure */ - parent = inode_parent (local->inode, NULL, NULL); - if (!parent) { - /* - * FIXME: Snapshot LV already deleted. - * remove xattr, instead of returning failure - */ - op_errno = EINVAL; - goto out; - } - gf_uuid_copy (local->loc.pargfid, parent->gfid); + op_errno = EINVAL; + goto out; + } + gf_uuid_copy(local->loc.pargfid, parent->gfid); - p = strrchr (local->loc.path, '/'); - if (p) - p++; - local->loc.name = p; + p = strrchr(local->loc.path, '/'); + if (p) + p++; + local->loc.name = p; - STACK_WIND (frame, bd_merge_unlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - &local->loc, 0, NULL); + STACK_WIND(frame, bd_merge_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL); - return 0; + return 0; out: - BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL); + BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL); - return op_errno; + return op_errno; } int -bd_offload (call_frame_t *frame, xlator_t *this, loc_t *loc, - fd_t *fd, bd_offload_t offload) -{ - char *param = NULL; - char *param_copy = NULL; - char *p = NULL; - char *size = NULL; - char *gfid = NULL; - int op_errno = 0; - bd_local_t *local = frame->local; - - param = GF_MALLOC (local->data->len + 1, gf_common_mt_char); - BD_VALIDATE_MEM_ALLOC (param, op_errno, out); - param_copy = param; - - local->dict = dict_new (); - BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out); - - local->dloc = GF_CALLOC (1, sizeof (loc_t), gf_bd_loc_t); - BD_VALIDATE_MEM_ALLOC (local->dloc, op_errno, out); - - strncpy (param, local->data->data, local->data->len); - param[local->data->len] = '\0'; - - gfid = strtok_r (param, ":", &p); - size = strtok_r (NULL, ":", &p); - if (size) - gf_string2bytesize (size, &local->size); - else if (offload != BD_OF_CLONE) - local->size = bd_get_default_extent (this->private); - - if (dict_set_int8 (local->dict, BD_XATTR, 1) < 0) { - op_errno = EINVAL; - goto out; - } - if (dict_set_int8 (local->dict, LINKTO, 1) < 0) { - op_errno = EINVAL; - goto out; - } - - gf_uuid_parse (gfid, local->dloc->gfid); - local->offload = offload; - - STACK_WIND (frame, bd_offload_dest_lookup_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->lookup, local->dloc, - local->dict); - - return 0; +bd_offload(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + bd_offload_t offload) +{ + char *param = NULL; + char *param_copy = NULL; + char *p = NULL; + char *size = NULL; + char *gfid = NULL; + int op_errno = 0; + bd_local_t *local = frame->local; + + param = GF_MALLOC(local->data->len + 1, gf_common_mt_char); + BD_VALIDATE_MEM_ALLOC(param, op_errno, out); + param_copy = param; + + local->dict = dict_new(); + BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out); + + local->dloc = GF_CALLOC(1, sizeof(loc_t), gf_bd_loc_t); + BD_VALIDATE_MEM_ALLOC(local->dloc, op_errno, out); + + strncpy(param, local->data->data, local->data->len); + param[local->data->len] = '\0'; + + gfid = strtok_r(param, ":", &p); + size = strtok_r(NULL, ":", &p); + if (size) + gf_string2bytesize(size, &local->size); + else if (offload != BD_OF_CLONE) + local->size = bd_get_default_extent(this->private); + + if (dict_set_int8(local->dict, BD_XATTR, 1) < 0) { + op_errno = EINVAL; + goto out; + } + if (dict_set_int8(local->dict, LINKTO, 1) < 0) { + op_errno = EINVAL; + goto out; + } + + gf_uuid_parse(gfid, local->dloc->gfid); + local->offload = offload; + + STACK_WIND(frame, bd_offload_dest_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, local->dloc, local->dict); + + return 0; out: - if (fd) - BD_STACK_UNWIND (fsetxattr, frame, -1, op_errno, NULL); - else - BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL); + if (fd) + BD_STACK_UNWIND(fsetxattr, frame, -1, op_errno, NULL); + else + BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL); - GF_FREE (param_copy); - return 0; + GF_FREE(param_copy); + return 0; } /* @@ -1348,71 +1347,70 @@ out: * if create_lv failed, posix_removexattr -> bd_setx_rm_xattr_cbk */ int -bd_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, - int flags, dict_t *xdata) -{ - int op_errno = 0; - data_t *data = NULL; - bd_local_t *local = NULL; - bd_attr_t *bdatt = NULL; - bd_offload_t cl_type = BD_OF_NONE; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - - if ((data = dict_get (dict, BD_XATTR))) - cl_type = BD_OF_NONE; - else if ((data = dict_get (dict, BD_CLONE))) - cl_type = BD_OF_CLONE; - else if ((data = dict_get (dict, BD_SNAPSHOT))) - cl_type = BD_OF_SNAPSHOT; - else if ((data = dict_get (dict, BD_MERGE))) - cl_type = BD_OF_MERGE; - - bd_inode_ctx_get (loc->inode, this, &bdatt); - if (!cl_type && !data) { - STACK_WIND (frame, default_setxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setxattr, loc, dict, - flags, xdata); - return 0; +bd_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int flags, dict_t *xdata) +{ + int op_errno = 0; + data_t *data = NULL; + bd_local_t *local = NULL; + bd_attr_t *bdatt = NULL; + bd_offload_t cl_type = BD_OF_NONE; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + + if ((data = dict_get(dict, BD_XATTR))) + cl_type = BD_OF_NONE; + else if ((data = dict_get(dict, BD_CLONE))) + cl_type = BD_OF_CLONE; + else if ((data = dict_get(dict, BD_SNAPSHOT))) + cl_type = BD_OF_SNAPSHOT; + else if ((data = dict_get(dict, BD_MERGE))) + cl_type = BD_OF_MERGE; + + bd_inode_ctx_get(loc->inode, this, &bdatt); + if (!cl_type && !data) { + STACK_WIND(frame, default_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); + return 0; + } + + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); + + local->data = data; + loc_copy(&local->loc, loc); + local->inode = inode_ref(loc->inode); + + if (cl_type) { + /* For cloning/snapshot, source file must be mapped to LV */ + if (!bdatt) { + gf_log(this->name, GF_LOG_WARNING, "%s not mapped to BD", + loc->path); + op_errno = EINVAL; + goto out; } - - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); - - local->data = data; - loc_copy (&local->loc, loc); - local->inode = inode_ref (loc->inode); - - if (cl_type) { - /* For cloning/snapshot, source file must be mapped to LV */ - if (!bdatt) { - gf_log (this->name, GF_LOG_WARNING, - "%s not mapped to BD", loc->path); - op_errno = EINVAL; - goto out; - } - if (cl_type == BD_OF_MERGE) - bd_do_merge (frame, this); - else - bd_offload (frame, this, loc, NULL, cl_type); - } else if (data) { - if (bdatt) { - gf_log (this->name, GF_LOG_WARNING, - "%s already mapped to BD", loc->path); - op_errno = EEXIST; - goto out; - } - STACK_WIND (frame, bd_setx_stat_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->stat, loc, xdata); + if (cl_type == BD_OF_MERGE) + bd_do_merge(frame, this); + else + bd_offload(frame, this, loc, NULL, cl_type); + } else if (data) { + if (bdatt) { + gf_log(this->name, GF_LOG_WARNING, "%s already mapped to BD", + loc->path); + op_errno = EEXIST; + goto out; } + STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + } - return 0; + return 0; out: - if (op_errno) - STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata); + if (op_errno) + STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata); - return 0; + return 0; } /* @@ -1424,194 +1422,189 @@ out: * -> bd_fsetxattr_cbk */ int32_t -bd_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, - int flags, dict_t *xdata) -{ - int op_errno = 0; - data_t *data = NULL; - bd_attr_t *bdatt = NULL; - bd_local_t *local = NULL; - bd_offload_t cl_type = BD_OF_NONE; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (fd, out); - - bd_inode_ctx_get (fd->inode, this, &bdatt); - - if ((data = dict_get (dict, BD_XATTR))) - cl_type = BD_OF_NONE; - else if ((data = dict_get (dict, BD_CLONE))) - cl_type = BD_OF_CLONE; - else if ((data = dict_get (dict, BD_SNAPSHOT))) - cl_type = BD_OF_SNAPSHOT; - else if ((data = dict_get (dict, BD_MERGE))) { - /* - * bd_merge is not supported for fsetxattr, because snapshot LV - * is opened and it causes problem in snapshot merge - */ - op_errno = EOPNOTSUPP; - goto out; - } - - bd_inode_ctx_get (fd->inode, this, &bdatt); +bd_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int flags, dict_t *xdata) +{ + int op_errno = 0; + data_t *data = NULL; + bd_attr_t *bdatt = NULL; + bd_local_t *local = NULL; + bd_offload_t cl_type = BD_OF_NONE; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(fd, out); + + bd_inode_ctx_get(fd->inode, this, &bdatt); + + if ((data = dict_get(dict, BD_XATTR))) + cl_type = BD_OF_NONE; + else if ((data = dict_get(dict, BD_CLONE))) + cl_type = BD_OF_CLONE; + else if ((data = dict_get(dict, BD_SNAPSHOT))) + cl_type = BD_OF_SNAPSHOT; + else if ((data = dict_get(dict, BD_MERGE))) { + /* + * bd_merge is not supported for fsetxattr, because snapshot LV + * is opened and it causes problem in snapshot merge + */ + op_errno = EOPNOTSUPP; + goto out; + } - if (!cl_type && !data) { - /* non bd file object */ - STACK_WIND (frame, default_fsetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags, xdata); - return 0; - } + bd_inode_ctx_get(fd->inode, this, &bdatt); - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); + if (!cl_type && !data) { + /* non bd file object */ + STACK_WIND(frame, default_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; + } - local->inode = inode_ref (fd->inode); - local->fd = fd_ref (fd); - local->data = data; + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); - if (cl_type) { - /* For cloning/snapshot, source file must be mapped to LV */ - if (!bdatt) { - gf_log (this->name, GF_LOG_WARNING, - "fd %p not mapped to BD", fd); - op_errno = EINVAL; - goto out; + local->inode = inode_ref(fd->inode); + local->fd = fd_ref(fd); + local->data = data; - } - bd_offload (frame, this, NULL, fd, cl_type); - } else if (data) { - if (bdatt) { - gf_log (this->name, GF_LOG_WARNING, - "fd %p already mapped to BD", fd); - op_errno = EEXIST; - goto out; - } - STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd, xdata); + if (cl_type) { + /* For cloning/snapshot, source file must be mapped to LV */ + if (!bdatt) { + gf_log(this->name, GF_LOG_WARNING, "fd %p not mapped to BD", fd); + op_errno = EINVAL; + goto out; } + bd_offload(frame, this, NULL, fd, cl_type); + } else if (data) { + if (bdatt) { + gf_log(this->name, GF_LOG_WARNING, "fd %p already mapped to BD", + fd); + op_errno = EEXIST; + goto out; + } + STACK_WIND(frame, bd_setx_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + } - return 0; + return 0; out: - BD_STACK_UNWIND (setxattr, frame, -1, op_errno, NULL); + BD_STACK_UNWIND(setxattr, frame, -1, op_errno, NULL); - return 0; + return 0; } int32_t -bd_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +bd_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - if (!strcmp (name, BD_XATTR)) - goto out; + if (!strcmp(name, BD_XATTR)) + goto out; - STACK_WIND (frame, default_removexattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); - return 0; + STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; out: - BD_STACK_UNWIND (removexattr, frame, -1, ENODATA, NULL); - return 0; + BD_STACK_UNWIND(removexattr, frame, -1, ENODATA, NULL); + return 0; } int32_t -bd_fremovexattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +bd_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - if (!strcmp (name, BD_XATTR)) - goto out; + if (!strcmp(name, BD_XATTR)) + goto out; - STACK_WIND (frame, default_removexattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + STACK_WIND(frame, default_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); - return 0; + return 0; out: - BD_STACK_UNWIND (fremovexattr, frame, -1, ENODATA, NULL); - return 0; + BD_STACK_UNWIND(fremovexattr, frame, -1, ENODATA, NULL); + return 0; } int -bd_trunc_setxattr_setx_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_trunc_setxattr_setx_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - bd_local_t *local = frame->local; + bd_local_t *local = frame->local; - if (local->fd) - BD_STACK_UNWIND (ftruncate, frame, -1, EIO, NULL, NULL, NULL); - else - BD_STACK_UNWIND (truncate, frame, -1, EIO, NULL, NULL, NULL); + if (local->fd) + BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL); + else + BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL); - return 0; + return 0; } /* * Call back for setxattr after setting BD_XATTR_SIZE. */ int -bd_trunc_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, dict_t *xdata) +bd_trunc_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - bd_local_t *local = frame->local; - bd_attr_t *bdatt = NULL; - struct iatt prebuf = {0, }; - char *bd = NULL; + bd_local_t *local = frame->local; + bd_attr_t *bdatt = NULL; + struct iatt prebuf = { + 0, + }; + char *bd = NULL; - if (op_ret < 0) - goto out; + if (op_ret < 0) + goto out; - bd_inode_ctx_get (local->inode, this, &bdatt); - if (!bdatt) - goto revert_xattr; + bd_inode_ctx_get(local->inode, this, &bdatt); + if (!bdatt) + goto revert_xattr; - op_errno = bd_resize (this->private, local->inode->gfid, - local->bdatt->iatt.ia_size); - if (op_errno) - goto revert_xattr; + op_errno = bd_resize(this->private, local->inode->gfid, + local->bdatt->iatt.ia_size); + if (op_errno) + goto revert_xattr; - memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt)); - /* LV resized, update new size in the cache */ - bdatt->iatt.ia_size = local->bdatt->iatt.ia_size; + memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt)); + /* LV resized, update new size in the cache */ + bdatt->iatt.ia_size = local->bdatt->iatt.ia_size; - if (local->fd) - BD_STACK_UNWIND (ftruncate, frame, 0, 0, &prebuf, &bdatt->iatt, - NULL); - else - BD_STACK_UNWIND (truncate, frame, 0, 0, &prebuf, &bdatt->iatt, - NULL); + if (local->fd) + BD_STACK_UNWIND(ftruncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL); + else + BD_STACK_UNWIND(truncate, frame, 0, 0, &prebuf, &bdatt->iatt, NULL); - return 0; + return 0; revert_xattr: - /* revert setxattr */ - op_ret = dict_get_str (local->dict, BD_XATTR, &bd); - GF_FREE (bd); - bd = NULL; - if (bdatt) - gf_asprintf (&bd, "%s:%ld", bdatt->type, bdatt->iatt.ia_size); - - if (local->fd) - STACK_WIND (frame, bd_trunc_setxattr_setx_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - local->fd, local->dict, 0, NULL); - else - STACK_WIND (frame, bd_trunc_setxattr_setx_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - &local->loc, local->dict, 0, NULL); - - if (bd) - GF_FREE (bd); - return 0; + /* revert setxattr */ + op_ret = dict_get_str(local->dict, BD_XATTR, &bd); + GF_FREE(bd); + bd = NULL; + if (bdatt) + gf_asprintf(&bd, "%s:%ld", bdatt->type, bdatt->iatt.ia_size); + + if (local->fd) + STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict, + 0, NULL); + else + STACK_WIND(frame, bd_trunc_setxattr_setx_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict, + 0, NULL); + + if (bd) + GF_FREE(bd); + return 0; out: - if (local->fd) - BD_STACK_UNWIND (ftruncate, frame, -1, EIO, NULL, NULL, NULL); - else - BD_STACK_UNWIND (truncate, frame, -1, EIO, NULL, NULL, NULL); + if (local->fd) + BD_STACK_UNWIND(ftruncate, frame, -1, EIO, NULL, NULL, NULL); + else + BD_STACK_UNWIND(truncate, frame, -1, EIO, NULL, NULL, NULL); - return 0; + return 0; } /* @@ -1621,182 +1614,175 @@ out: * the posix file so that truncate fop behaves properly */ int -bd_trunc_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *buf, dict_t *xdata) -{ - char *bd = NULL; - bd_local_t *local = frame->local; - bd_attr_t *bdatt = NULL; - - if (op_ret < 0) - goto out; - - local->dict = dict_new (); - BD_VALIDATE_MEM_ALLOC (local->dict, op_errno, out); - - bd_inode_ctx_get (local->inode, this, &bdatt); - if (!bdatt) { - op_errno = EINVAL; - goto out; - } - - gf_asprintf (&bd, "%s:%ld", bdatt->type, local->bdatt->iatt.ia_size); - if (dict_set_dynstr (local->dict, BD_XATTR, bd)) { - op_errno = EINVAL; - goto out; - } - - if (local->fd) - STACK_WIND (frame, bd_trunc_setxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - local->fd, local->dict, 0, NULL); - else - STACK_WIND (frame, bd_trunc_setxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - &local->loc, local->dict, 0, NULL); - - return 0; +bd_trunc_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct iatt *buf, dict_t *xdata) +{ + char *bd = NULL; + bd_local_t *local = frame->local; + bd_attr_t *bdatt = NULL; + + if (op_ret < 0) + goto out; + + local->dict = dict_new(); + BD_VALIDATE_MEM_ALLOC(local->dict, op_errno, out); + + bd_inode_ctx_get(local->inode, this, &bdatt); + if (!bdatt) { + op_errno = EINVAL; + goto out; + } + + gf_asprintf(&bd, "%s:%ld", bdatt->type, local->bdatt->iatt.ia_size); + if (dict_set_dynstr(local->dict, BD_XATTR, bd)) { + op_errno = EINVAL; + goto out; + } + + if (local->fd) + STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, local->fd, local->dict, + 0, NULL); + else + STACK_WIND(frame, bd_trunc_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, &local->loc, local->dict, + 0, NULL); + + return 0; out: - if (local->fd) - BD_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, - NULL); - else - BD_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, - NULL); - GF_FREE (bd); - return 0; + if (local->fd) + BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL); + else + BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL); + GF_FREE(bd); + return 0; } void -bd_do_trunc (call_frame_t *frame, xlator_t *this, fd_t *fd, loc_t *loc, - off_t offset, bd_attr_t *bdatt) -{ - bd_local_t *local = NULL; - struct iatt prebuf = {0, }; - int op_errno = 0; - int op_ret = -1; - - /* If requested size is less than LV size, return success */ - if (offset <= bdatt->iatt.ia_size) { - memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt)); - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME); - op_ret = 0; - goto out; - } +bd_do_trunc(call_frame_t *frame, xlator_t *this, fd_t *fd, loc_t *loc, + off_t offset, bd_attr_t *bdatt) +{ + bd_local_t *local = NULL; + struct iatt prebuf = { + 0, + }; + int op_errno = 0; + int op_ret = -1; + + /* If requested size is less than LV size, return success */ + if (offset <= bdatt->iatt.ia_size) { + memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt)); + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME); + op_ret = 0; + goto out; + } - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); - local->bdatt = GF_CALLOC (1, sizeof (bd_attr_t), gf_bd_attr); - BD_VALIDATE_MEM_ALLOC (local->bdatt, op_errno, out); + local->bdatt = GF_CALLOC(1, sizeof(bd_attr_t), gf_bd_attr); + BD_VALIDATE_MEM_ALLOC(local->bdatt, op_errno, out); - if (fd) { - local->inode = inode_ref (fd->inode); - local->fd = fd_ref (fd); - } else { - local->inode = inode_ref (loc->inode); - loc_copy (&local->loc, loc); - } + if (fd) { + local->inode = inode_ref(fd->inode); + local->fd = fd_ref(fd); + } else { + local->inode = inode_ref(loc->inode); + loc_copy(&local->loc, loc); + } - local->bdatt->iatt.ia_size = - bd_adjust_size (this->private, offset); + local->bdatt->iatt.ia_size = bd_adjust_size(this->private, offset); - STACK_WIND (frame, bd_trunc_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd, NULL); + STACK_WIND(frame, bd_trunc_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, NULL); - return; + return; out: - if (fd) - BD_STACK_UNWIND (ftruncate, frame, op_ret, op_errno, - &prebuf, &bdatt->iatt, NULL); - else - BD_STACK_UNWIND (truncate, frame, op_ret, op_errno, - &prebuf, &bdatt->iatt, NULL); - return; + if (fd) + BD_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, &prebuf, + &bdatt->iatt, NULL); + else + BD_STACK_UNWIND(truncate, frame, op_ret, op_errno, &prebuf, + &bdatt->iatt, NULL); + return; } /* * bd_ftruncate: Resizes a LV if fd belongs to BD. */ int32_t -bd_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - dict_t *xdata) -{ - int op_errno = 0; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - if (bd_inode_ctx_get (fd->inode, this, &bdatt)) { - STACK_WIND (frame, default_ftruncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, fd, - offset, xdata); - return 0; - } +bd_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) +{ + int op_errno = 0; + bd_attr_t *bdatt = NULL; - bd_do_trunc (frame, this, fd, NULL, offset, bdatt); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + if (bd_inode_ctx_get(fd->inode, this, &bdatt)) { + STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); return 0; + } + + bd_do_trunc(frame, this, fd, NULL, offset, bdatt); + return 0; out: - BD_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(ftruncate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } /* * bd_truncate: Resizes a LV if file maps to LV. */ int32_t -bd_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) +bd_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - int op_errno = 0; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); + int op_errno = 0; + bd_attr_t *bdatt = NULL; - if (bd_inode_ctx_get (loc->inode, this, &bdatt)) { - STACK_WIND (frame, default_truncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, loc, - offset, xdata); - return 0; - } + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); - bd_do_trunc (frame, this, NULL, loc, offset, bdatt); + if (bd_inode_ctx_get(loc->inode, this, &bdatt)) { + STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); return 0; + } + + bd_do_trunc(frame, this, NULL, loc, offset, bdatt); + return 0; out: - BD_STACK_UNWIND (truncate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(truncate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int32_t -__bd_pwritev (int fd, struct iovec *vector, int count, off_t offset, - uint64_t bd_size) -{ - int index = 0; - int retval = 0; - - if (!vector) - return -EFAULT; - - retval = sys_pwritev (fd, vector, count, offset); - if (retval == -1) { - int64_t off = offset; - gf_log (THIS->name, GF_LOG_WARNING, - "base %p, length %zd, offset %" PRId64 ", message %s", - vector[index].iov_base, vector[index].iov_len, - off, strerror (errno)); - retval = -errno; - goto err; - } +__bd_pwritev(int fd, struct iovec *vector, int count, off_t offset, + uint64_t bd_size) +{ + int index = 0; + int retval = 0; + + if (!vector) + return -EFAULT; + + retval = sys_pwritev(fd, vector, count, offset); + if (retval == -1) { + int64_t off = offset; + gf_log(THIS->name, GF_LOG_WARNING, + "base %p, length %zd, offset %" PRId64 ", message %s", + vector[index].iov_base, vector[index].iov_len, off, + strerror(errno)); + retval = -errno; + goto err; + } /* @@ -1827,7 +1813,7 @@ __bd_pwritev (int fd, struct iovec *vector, int count, off_t offset, } */ err: - return retval; + return retval; } /* @@ -1835,615 +1821,600 @@ err: * bd_writev -> posix_writev -> bd_writev_cbk */ int -bd_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 *xdict) -{ - int32_t op_ret = -1; - int32_t op_errno = 0; - int _fd = -1; - bd_fd_t *bd_fd = NULL; - int ret = -1; - uint64_t size = 0; - struct iatt prebuf = {0, }; - bd_attr_t *bdatt = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (vector, out); - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { /* posix fd */ - STACK_WIND (frame, default_writev_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, fd, vector, count, - offset, flags, iobref, xdict); - return 0; - } - - _fd = bd_fd->fd; - - if (bd_inode_ctx_get (fd->inode, this, &bdatt)) { - op_ret = -1; - op_errno = EINVAL; - goto out; - } - size = bdatt->iatt.ia_size; - - op_ret = __bd_pwritev (_fd, vector, count, offset, size); - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - gf_log (this->name, GF_LOG_ERROR, "write failed: offset %"PRIu64 - ", %s", offset, strerror (op_errno)); - goto out; - } - - memcpy (&prebuf, &bdatt->iatt, sizeof (struct iatt)); - bd_update_amtime (&bdatt->iatt, GF_SET_ATTR_MTIME); +bd_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 *xdict) +{ + int32_t op_ret = -1; + int32_t op_errno = 0; + int _fd = -1; + bd_fd_t *bd_fd = NULL; + int ret = -1; + uint64_t size = 0; + struct iatt prebuf = { + 0, + }; + bd_attr_t *bdatt = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(vector, out); + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { /* posix fd */ + STACK_WIND(frame, default_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdict); + return 0; + } + + _fd = bd_fd->fd; + + if (bd_inode_ctx_get(fd->inode, this, &bdatt)) { + op_ret = -1; + op_errno = EINVAL; + goto out; + } + size = bdatt->iatt.ia_size; + + op_ret = __bd_pwritev(_fd, vector, count, offset, size); + if (op_ret < 0) { + op_errno = -op_ret; + op_ret = -1; + gf_log(this->name, GF_LOG_ERROR, "write failed: offset %" PRIu64 ", %s", + offset, strerror(op_errno)); + goto out; + } + + memcpy(&prebuf, &bdatt->iatt, sizeof(struct iatt)); + bd_update_amtime(&bdatt->iatt, GF_SET_ATTR_MTIME); out: - BD_STACK_UNWIND (writev, frame, op_ret, op_errno, &prebuf, - &bdatt->iatt, NULL); - return 0; + BD_STACK_UNWIND(writev, frame, op_ret, op_errno, &prebuf, &bdatt->iatt, + NULL); + return 0; } int -bd_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, struct iatt *prebuf, struct iatt *postbuf, - dict_t *xdata) -{ - bd_attr_t *bdatt = NULL; - int *valid = cookie; - bd_local_t *local = frame->local; - - if (op_ret < 0 || !valid || !local) - goto out; - - if (bd_inode_ctx_get (local->inode, this, &bdatt)) - goto out; - - if (*valid & GF_SET_ATTR_UID) - bdatt->iatt.ia_uid = postbuf->ia_uid; - else if (*valid & GF_SET_ATTR_GID) - bdatt->iatt.ia_gid = postbuf->ia_gid; - else if (*valid & GF_SET_ATTR_MODE) { - bdatt->iatt.ia_type = postbuf->ia_type; - bdatt->iatt.ia_prot = postbuf->ia_prot; - } else if (*valid & GF_SET_ATTR_ATIME) { - bdatt->iatt.ia_atime = postbuf->ia_atime; - bdatt->iatt.ia_atime_nsec = postbuf->ia_atime_nsec; - } else if (*valid & GF_SET_ATTR_MTIME) { - bdatt->iatt.ia_mtime = postbuf->ia_mtime; - bdatt->iatt.ia_mtime_nsec = postbuf->ia_mtime_nsec; - } - - bdatt->iatt.ia_ctime = postbuf->ia_ctime; - bdatt->iatt.ia_ctime_nsec = postbuf->ia_ctime_nsec; - - memcpy (postbuf, &bdatt->iatt, sizeof (struct iatt)); +bd_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, struct iatt *prebuf, struct iatt *postbuf, + dict_t *xdata) +{ + bd_attr_t *bdatt = NULL; + int *valid = cookie; + bd_local_t *local = frame->local; + + if (op_ret < 0 || !valid || !local) + goto out; + + if (bd_inode_ctx_get(local->inode, this, &bdatt)) + goto out; + + if (*valid & GF_SET_ATTR_UID) + bdatt->iatt.ia_uid = postbuf->ia_uid; + else if (*valid & GF_SET_ATTR_GID) + bdatt->iatt.ia_gid = postbuf->ia_gid; + else if (*valid & GF_SET_ATTR_MODE) { + bdatt->iatt.ia_type = postbuf->ia_type; + bdatt->iatt.ia_prot = postbuf->ia_prot; + } else if (*valid & GF_SET_ATTR_ATIME) { + bdatt->iatt.ia_atime = postbuf->ia_atime; + bdatt->iatt.ia_atime_nsec = postbuf->ia_atime_nsec; + } else if (*valid & GF_SET_ATTR_MTIME) { + bdatt->iatt.ia_mtime = postbuf->ia_mtime; + bdatt->iatt.ia_mtime_nsec = postbuf->ia_mtime_nsec; + } + + bdatt->iatt.ia_ctime = postbuf->ia_ctime; + bdatt->iatt.ia_ctime_nsec = postbuf->ia_ctime_nsec; + + memcpy(postbuf, &bdatt->iatt, sizeof(struct iatt)); out: - GF_FREE (valid); - BD_STACK_UNWIND (setattr, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + GF_FREE(valid); + BD_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } int -bd_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf, - int32_t valid, dict_t *xdata) -{ - bd_local_t *local = NULL; - bd_attr_t *bdatt = NULL; - int *ck_valid = NULL; - - if (bd_inode_ctx_get (loc->inode, this, &bdatt)) { - STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); - return 0; - } - - local = bd_local_init (frame, this); - if (!local) { - gf_log (this->name, GF_LOG_ERROR, "out of memory"); - goto out; - } - - ck_valid = GF_CALLOC (1, sizeof (valid), gf_bd_int32_t); - if (!ck_valid) { - gf_log (this->name, GF_LOG_ERROR, "out of memory"); - goto out; - } - - local->inode = inode_ref (loc->inode); - *ck_valid = valid; - - STACK_WIND_COOKIE (frame, bd_setattr_cbk, ck_valid, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); - GF_FREE (ck_valid); - return 0; +bd_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf, + int32_t valid, dict_t *xdata) +{ + bd_local_t *local = NULL; + bd_attr_t *bdatt = NULL; + int *ck_valid = NULL; + + if (bd_inode_ctx_get(loc->inode, this, &bdatt)) { + STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata); + return 0; + } + + local = bd_local_init(frame, this); + if (!local) { + gf_log(this->name, GF_LOG_ERROR, "out of memory"); + goto out; + } + + ck_valid = GF_CALLOC(1, sizeof(valid), gf_bd_int32_t); + if (!ck_valid) { + gf_log(this->name, GF_LOG_ERROR, "out of memory"); + goto out; + } + + local->inode = inode_ref(loc->inode); + *ck_valid = valid; + + STACK_WIND_COOKIE(frame, bd_setattr_cbk, ck_valid, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, + xdata); + GF_FREE(ck_valid); + return 0; out: - BD_STACK_UNWIND (setattr, frame, -1, ENOMEM, NULL, NULL, xdata); - return 0; + BD_STACK_UNWIND(setattr, frame, -1, ENOMEM, NULL, NULL, xdata); + return 0; } int -bd_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) +bd_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - bd_attr_t *bdatt = NULL; + bd_attr_t *bdatt = NULL; - if (op_ret < 0) - goto out; + if (op_ret < 0) + goto out; - if (bd_inode_ctx_get (inode, this, &bdatt)) - goto out; + if (bd_inode_ctx_get(inode, this, &bdatt)) + goto out; - bdatt->iatt.ia_ctime = buf->ia_ctime; - bdatt->iatt.ia_ctime_nsec = buf->ia_ctime_nsec; - bdatt->iatt.ia_nlink = buf->ia_nlink; - memcpy (buf, &bdatt->iatt, sizeof (struct iatt)); + bdatt->iatt.ia_ctime = buf->ia_ctime; + bdatt->iatt.ia_ctime_nsec = buf->ia_ctime_nsec; + bdatt->iatt.ia_nlink = buf->ia_nlink; + memcpy(buf, &bdatt->iatt, sizeof(struct iatt)); out: - BD_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, NULL); - return 0; + BD_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, NULL); + return 0; } int -bd_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +bd_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - STACK_WIND (frame, bd_link_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, bd_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } int -bd_handle_special_xattrs (call_frame_t *frame, xlator_t *this, loc_t *loc, - fd_t *fd, const char *name, dict_t *xdata) -{ - dict_t *xattr = NULL; - int op_ret = -1; - int op_errno = ENOMEM;; - bd_priv_t *priv = this->private; - - xattr = dict_new (); - if (!xattr) - goto out; - - if (!strcmp (name, VOL_TYPE)) - op_ret = dict_set_int64 (xattr, (char *)name, 1); - else if (!strcmp (name, VOL_CAPS)) - op_ret = dict_set_int64 (xattr, (char *)name, priv->caps); - else - op_ret = bd_get_origin (this->private, loc, fd, xattr); +bd_handle_special_xattrs(call_frame_t *frame, xlator_t *this, loc_t *loc, + fd_t *fd, const char *name, dict_t *xdata) +{ + dict_t *xattr = NULL; + int op_ret = -1; + int op_errno = ENOMEM; + ; + bd_priv_t *priv = this->private; + + xattr = dict_new(); + if (!xattr) + goto out; + + if (!strcmp(name, VOL_TYPE)) + op_ret = dict_set_int64(xattr, (char *)name, 1); + else if (!strcmp(name, VOL_CAPS)) + op_ret = dict_set_int64(xattr, (char *)name, priv->caps); + else + op_ret = bd_get_origin(this->private, loc, fd, xattr); out: - if (loc) - BD_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, - xdata); - else - BD_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, xattr, - xdata); + if (loc) + BD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata); + else + BD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata); - op_ret = dict_reset (xattr); - dict_unref (xattr); + op_ret = dict_reset(xattr); + dict_unref(xattr); - return 0; + return 0; } int -bd_fgetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +bd_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - if (name && (!strcmp (name, VOL_TYPE) || !strcmp (name, VOL_CAPS) - || !strcmp (name, BD_ORIGIN))) - bd_handle_special_xattrs (frame, this, NULL, fd, name, xdata); - else - STACK_WIND (frame, default_fgetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); - return 0; + if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) || + !strcmp(name, BD_ORIGIN))) + bd_handle_special_xattrs(frame, this, NULL, fd, name, xdata); + else + STACK_WIND(frame, default_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; } int -bd_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +bd_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name, + dict_t *xdata) { - if (name && (!strcmp (name, VOL_TYPE) || !strcmp (name, VOL_CAPS) - || !strcmp (name, BD_ORIGIN))) - bd_handle_special_xattrs (frame, this, loc, NULL, name, xdata); - else - STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); + if (name && (!strcmp(name, VOL_TYPE) || !strcmp(name, VOL_CAPS) || + !strcmp(name, BD_ORIGIN))) + bd_handle_special_xattrs(frame, this, loc, NULL, name, xdata); + else + STACK_WIND(frame, default_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); - return 0; + return 0; } int -bd_unlink_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, inode_t *inode, - struct iatt *buf, dict_t *xattr, - struct iatt *postparent) +bd_unlink_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, inode_t *inode, struct iatt *buf, + dict_t *xattr, struct iatt *postparent) { - bd_gfid_t gfid = {0, }; - bd_local_t *local = frame->local; + bd_gfid_t gfid = { + 0, + }; + bd_local_t *local = frame->local; - if (buf->ia_nlink > 1) - goto posix; + if (buf->ia_nlink > 1) + goto posix; - BD_VALIDATE_LOCAL_OR_GOTO (local, op_errno, out); + BD_VALIDATE_LOCAL_OR_GOTO(local, op_errno, out); - uuid_utoa_r (inode->gfid, gfid); - if (bd_delete_lv (this->private, gfid, &op_errno) < 0) { - if (op_errno != ENOENT) - goto out; - } + uuid_utoa_r(inode->gfid, gfid); + if (bd_delete_lv(this->private, gfid, &op_errno) < 0) { + if (op_errno != ENOENT) + goto out; + } posix: - /* remove posix */ - STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - &local->loc, 0, NULL); + /* remove posix */ + STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, &local->loc, 0, NULL); - return 0; + return 0; out: - BD_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int -bd_unlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, int xflag, dict_t *xdata) -{ - int op_errno = 0; - bd_attr_t *bdatt = NULL; - bd_local_t *local = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - if (bd_inode_ctx_get (loc->inode, this, &bdatt)) { - STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); - return 0; - } - - local = bd_local_init (frame, this); - BD_VALIDATE_MEM_ALLOC (local, op_errno, out); +bd_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) +{ + int op_errno = 0; + bd_attr_t *bdatt = NULL; + bd_local_t *local = NULL; - loc_copy (&local->loc, loc); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); - STACK_WIND (frame, bd_unlink_lookup_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, loc, NULL); + if (bd_inode_ctx_get(loc->inode, this, &bdatt)) { + STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); return 0; + } + + local = bd_local_init(frame, this); + BD_VALIDATE_MEM_ALLOC(local, op_errno, out); + + loc_copy(&local->loc, loc); + + STACK_WIND(frame, bd_unlink_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, NULL); + return 0; out: - BD_STACK_UNWIND (unlink, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + BD_STACK_UNWIND(unlink, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } int32_t -bd_priv (xlator_t *this) +bd_priv(xlator_t *this) { - return 0; + return 0; } int32_t -bd_inode (xlator_t *this) +bd_inode(xlator_t *this) { - return 0; + return 0; } int32_t -bd_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - int32_t len, dict_t *xdata) -{ - int op_ret = -1; - int op_errno = 0; - int ret = 0; - int _fd = -1; - char *alloc_buf = NULL; - char *buf = NULL; - int32_t weak_checksum = 0; - bd_fd_t *bd_fd = NULL; - unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0}; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - ret = bd_fd_ctx_get (this, fd, &bd_fd); - if (ret < 0 || !bd_fd) { - STACK_WIND (frame, default_rchecksum_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->rchecksum, fd, offset, - len, xdata); - return 0; - } - - alloc_buf = page_aligned_alloc (len, &buf); - if (!alloc_buf) { - op_errno = ENOMEM; - goto out; - } - - _fd = bd_fd->fd; - - LOCK (&fd->lock); - { - ret = sys_pread (_fd, buf, len, offset); - if (ret < 0) { - gf_log (this->name, GF_LOG_WARNING, - "pread of %d bytes returned %d (%s)", - len, ret, strerror (errno)); - op_errno = errno; - } +bd_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + int32_t len, dict_t *xdata) +{ + int op_ret = -1; + int op_errno = 0; + int ret = 0; + int _fd = -1; + char *alloc_buf = NULL; + char *buf = NULL; + int32_t weak_checksum = 0; + bd_fd_t *bd_fd = NULL; + unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0}; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + ret = bd_fd_ctx_get(this, fd, &bd_fd); + if (ret < 0 || !bd_fd) { + STACK_WIND(frame, default_rchecksum_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata); + return 0; + } + + alloc_buf = page_aligned_alloc(len, &buf); + if (!alloc_buf) { + op_errno = ENOMEM; + goto out; + } + + _fd = bd_fd->fd; + + LOCK(&fd->lock); + { + ret = sys_pread(_fd, buf, len, offset); + if (ret < 0) { + gf_log(this->name, GF_LOG_WARNING, + "pread of %d bytes returned %d (%s)", len, ret, + strerror(errno)); + op_errno = errno; } - UNLOCK (&fd->lock); + } + UNLOCK(&fd->lock); - if (ret < 0) - goto out; + if (ret < 0) + goto out; - weak_checksum = gf_rsync_weak_checksum ((unsigned char *) buf, - (size_t) len); - gf_rsync_strong_checksum ((unsigned char *) buf, (size_t) len, - (unsigned char *) strong_checksum); + weak_checksum = gf_rsync_weak_checksum((unsigned char *)buf, (size_t)len); + gf_rsync_strong_checksum((unsigned char *)buf, (size_t)len, + (unsigned char *)strong_checksum); - op_ret = 0; + op_ret = 0; out: - BD_STACK_UNWIND (rchecksum, frame, op_ret, op_errno, - weak_checksum, strong_checksum, NULL); + BD_STACK_UNWIND(rchecksum, frame, op_ret, op_errno, weak_checksum, + strong_checksum, NULL); - GF_FREE (alloc_buf); + GF_FREE(alloc_buf); - return 0; + return 0; } static int bd_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, off_t len, dict_t *xdata) { - int32_t ret = 0; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; - bd_attr_t *bdatt = NULL; - - /* iatt already cached */ - if (bd_inode_ctx_get (fd->inode, this, &bdatt) < 0) { - STACK_WIND (frame, default_zerofill_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->zerofill, - fd, offset, len, xdata); - return 0; - } - - ret = bd_do_zerofill(frame, this, fd, offset, len, - &statpre, &statpost); - if (ret) - goto err; + int32_t ret = 0; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; + bd_attr_t *bdatt = NULL; - STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL); + /* iatt already cached */ + if (bd_inode_ctx_get(fd->inode, this, &bdatt) < 0) { + STACK_WIND(frame, default_zerofill_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); return 0; + } + + ret = bd_do_zerofill(frame, this, fd, offset, len, &statpre, &statpost); + if (ret) + goto err; + + STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL); + return 0; err: - STACK_UNWIND_STRICT(zerofill, frame, -1, (ret == -1 ? 0 : ret), - NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(zerofill, frame, -1, (ret == -1 ? 0 : ret), NULL, NULL, + NULL); + return 0; } /** * notify - when parent sends PARENT_UP, send CHILD_UP event from here */ int32_t -notify (xlator_t *this, - int32_t event, - void *data, - ...) -{ - switch (event) - { - case GF_EVENT_PARENT_UP: - { - /* Tell the parent that bd xlator is up */ - default_notify (this, GF_EVENT_CHILD_UP, data); - } - break; +notify(xlator_t *this, int32_t event, void *data, ...) +{ + switch (event) { + case GF_EVENT_PARENT_UP: { + /* Tell the parent that bd xlator is up */ + default_notify(this, GF_EVENT_CHILD_UP, data); + } break; default: - break; - } - return 0; + break; + } + return 0; } 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_bd_mt_end + 1); + ret = xlator_mem_acct_init(this, gf_bd_mt_end + 1); - if (ret != 0) - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - "failed"); + if (ret != 0) + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + "failed"); - return ret; + return ret; } int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - int ret = -1; - bd_priv_t *priv = this->private; + int ret = -1; + bd_priv_t *priv = this->private; - GF_OPTION_RECONF ("bd-aio", priv->aio_configured, options, - bool, out); + GF_OPTION_RECONF("bd-aio", priv->aio_configured, options, bool, out); - if (priv->aio_configured) - bd_aio_on (this); - else - bd_aio_off (this); + if (priv->aio_configured) + bd_aio_on(this); + else + bd_aio_off(this); - ret = 0; + ret = 0; out: - return ret; + return ret; } /** * bd xlator init - Validate configured VG */ int -init (xlator_t *this) +init(xlator_t *this) { - char *vg_data = NULL; - char *device = NULL; - bd_priv_t *_private = NULL; + char *vg_data = NULL; + char *device = NULL; + bd_priv_t *_private = NULL; - if (!this->children) { - gf_log (this->name, GF_LOG_CRITICAL, - "FATAL: storage/bd needs posix as subvolume"); - return -1; - } + if (!this->children) { + gf_log(this->name, GF_LOG_CRITICAL, + "FATAL: storage/bd needs posix as subvolume"); + return -1; + } - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "Volume is dangling. Please check the volume file."); - } + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, + "Volume is dangling. Please check the volume file."); + } - GF_OPTION_INIT ("export", vg_data, str, error); - GF_OPTION_INIT ("device", device, str, error); + GF_OPTION_INIT("export", vg_data, str, error); + GF_OPTION_INIT("device", device, str, error); - /* Now we support only LV device */ - if (strcasecmp (device, BACKEND_VG)) { - gf_log (this->name, GF_LOG_CRITICAL, - "FATAL: unknown %s backend %s", BD_XLATOR, device); - return -1; - } + /* Now we support only LV device */ + if (strcasecmp(device, BACKEND_VG)) { + gf_log(this->name, GF_LOG_CRITICAL, "FATAL: unknown %s backend %s", + BD_XLATOR, device); + return -1; + } - this->local_pool = mem_pool_new (bd_local_t, 64); - if (!this->local_pool) { - gf_log (this->name, GF_LOG_CRITICAL, - "FATAL: Failed to create bd memory pool"); - return -1; - } + this->local_pool = mem_pool_new(bd_local_t, 64); + if (!this->local_pool) { + gf_log(this->name, GF_LOG_CRITICAL, + "FATAL: Failed to create bd memory pool"); + return -1; + } - _private = GF_CALLOC (1, sizeof (*_private), gf_bd_private); - if (!_private) - goto error; + _private = GF_CALLOC(1, sizeof(*_private), gf_bd_private); + if (!_private) + goto error; - this->private = _private; - _private->vg = gf_strdup (vg_data); - if (!_private->vg) - goto error; + this->private = _private; + _private->vg = gf_strdup(vg_data); + if (!_private->vg) + goto error; - _private->handle = lvm_init (NULL); - if (!_private->handle) { - gf_log (this->name, GF_LOG_CRITICAL, "lvm_init failed"); - goto error; - } - _private->caps = BD_CAPS_BD; - if (bd_scan_vg (this, _private)) - goto error; - - _private->aio_init_done = _gf_false; - _private->aio_capable = _gf_false; - - GF_OPTION_INIT ("bd-aio", _private->aio_configured, bool, error); - if (_private->aio_configured) { - if (bd_aio_on (this)) { - gf_log (this->name, GF_LOG_ERROR, - "BD AIO init failed"); - goto error; - } + _private->handle = lvm_init(NULL); + if (!_private->handle) { + gf_log(this->name, GF_LOG_CRITICAL, "lvm_init failed"); + goto error; + } + _private->caps = BD_CAPS_BD; + if (bd_scan_vg(this, _private)) + goto error; + + _private->aio_init_done = _gf_false; + _private->aio_capable = _gf_false; + + GF_OPTION_INIT("bd-aio", _private->aio_configured, bool, error); + if (_private->aio_configured) { + if (bd_aio_on(this)) { + gf_log(this->name, GF_LOG_ERROR, "BD AIO init failed"); + goto error; } + } - _private->caps |= BD_CAPS_OFFLOAD_COPY | BD_CAPS_OFFLOAD_SNAPSHOT | - BD_CAPS_OFFLOAD_ZERO; + _private->caps |= BD_CAPS_OFFLOAD_COPY | BD_CAPS_OFFLOAD_SNAPSHOT | + BD_CAPS_OFFLOAD_ZERO; - return 0; + return 0; error: - if (_private) { - GF_FREE (_private->vg); - if (_private->handle) - lvm_quit (_private->handle); - GF_FREE (_private); - } + if (_private) { + GF_FREE(_private->vg); + if (_private->handle) + lvm_quit(_private->handle); + GF_FREE(_private); + } - mem_pool_destroy (this->local_pool); + mem_pool_destroy(this->local_pool); - return -1; + return -1; } void -fini (xlator_t *this) -{ - bd_priv_t *priv = this->private; - mem_pool_destroy (this->local_pool); - this->local_pool = NULL; - if (!priv) - return; - lvm_quit (priv->handle); - GF_FREE (priv->vg); - this->private = NULL; - GF_FREE (priv); +fini(xlator_t *this) +{ + bd_priv_t *priv = this->private; + mem_pool_destroy(this->local_pool); + this->local_pool = NULL; + if (!priv) return; + lvm_quit(priv->handle); + GF_FREE(priv->vg); + this->private = NULL; + GF_FREE(priv); + return; } struct xlator_dumpops dumpops = { - .priv = bd_priv, - .inode = bd_inode, + .priv = bd_priv, + .inode = bd_inode, }; struct xlator_fops fops = { - .readdirp = bd_readdirp, - .lookup = bd_lookup, - .stat = bd_stat, - .statfs = bd_statfs, - .open = bd_open, - .fstat = bd_fstat, - .rchecksum = bd_rchecksum, - .readv = bd_readv, - .fsync = bd_fsync, - .setxattr = bd_setxattr, - .fsetxattr = bd_fsetxattr, - .removexattr = bd_removexattr, - .fremovexattr=bd_fremovexattr, - .truncate = bd_truncate, - .ftruncate = bd_ftruncate, - .writev = bd_writev, - .getxattr = bd_getxattr, - .fgetxattr = bd_fgetxattr, - .unlink = bd_unlink, - .link = bd_link, - .flush = bd_flush, - .setattr = bd_setattr, - .discard = bd_discard, - .zerofill = bd_zerofill, + .readdirp = bd_readdirp, + .lookup = bd_lookup, + .stat = bd_stat, + .statfs = bd_statfs, + .open = bd_open, + .fstat = bd_fstat, + .rchecksum = bd_rchecksum, + .readv = bd_readv, + .fsync = bd_fsync, + .setxattr = bd_setxattr, + .fsetxattr = bd_fsetxattr, + .removexattr = bd_removexattr, + .fremovexattr = bd_fremovexattr, + .truncate = bd_truncate, + .ftruncate = bd_ftruncate, + .writev = bd_writev, + .getxattr = bd_getxattr, + .fgetxattr = bd_fgetxattr, + .unlink = bd_unlink, + .link = bd_link, + .flush = bd_flush, + .setattr = bd_setattr, + .discard = bd_discard, + .zerofill = bd_zerofill, }; struct xlator_cbks cbks = { - .release = bd_release, - .forget = bd_forget, + .release = bd_release, + .forget = bd_forget, }; struct volume_options options[] = { - { .key = {"export"}, - .type = GF_OPTION_TYPE_STR}, - { .key = {"device"}, - .type = GF_OPTION_TYPE_STR, - .default_value = BACKEND_VG}, - { - .key = {"bd-aio"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Support for native Linux AIO" - }, - - { .key = {NULL} } -}; + {.key = {"export"}, .type = GF_OPTION_TYPE_STR}, + {.key = {"device"}, + .type = GF_OPTION_TYPE_STR, + .default_value = BACKEND_VG}, + {.key = {"bd-aio"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Support for native Linux AIO"}, + + {.key = {NULL}}}; diff --git a/xlators/storage/posix/src/posix-aio.c b/xlators/storage/posix/src/posix-aio.c index f8d568becac..cf570d5be41 100644 --- a/xlators/storage/posix/src/posix-aio.c +++ b/xlators/storage/posix/src/posix-aio.c @@ -16,571 +16,545 @@ #ifdef HAVE_LIBAIO #include <libaio.h> - void -__posix_fd_set_odirect (fd_t *fd, struct posix_fd *pfd, int opflags, - off_t offset, size_t size) +__posix_fd_set_odirect(fd_t *fd, struct posix_fd *pfd, int opflags, + off_t offset, size_t size) { - int odirect = 0; - int flags = 0; - int ret = 0; - - odirect = pfd->odirect; - - if ((fd->flags|opflags) & O_DIRECT) { - /* if instructed, use O_DIRECT always */ - odirect = 1; - } else { - /* else use O_DIRECT when feasible */ - if ((offset|size) & 0xfff) - odirect = 0; - else - odirect = 1; - } - - if (!odirect && pfd->odirect) { - flags = fcntl (pfd->fd, F_GETFL); - ret = fcntl (pfd->fd, F_SETFL, (flags & (~O_DIRECT))); - pfd->odirect = 0; - } - - if (odirect && !pfd->odirect) { - flags = fcntl (pfd->fd, F_GETFL); - ret = fcntl (pfd->fd, F_SETFL, (flags | O_DIRECT)); - pfd->odirect = 1; - } - - if (ret) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, P_MSG_FCNTL_FAILED, - "fcntl() failed. fd=%d flags=%d pfd->odirect=%d", - pfd->fd, flags, pfd->odirect); - } + int odirect = 0; + int flags = 0; + int ret = 0; + + odirect = pfd->odirect; + + if ((fd->flags | opflags) & O_DIRECT) { + /* if instructed, use O_DIRECT always */ + odirect = 1; + } else { + /* else use O_DIRECT when feasible */ + if ((offset | size) & 0xfff) + odirect = 0; + else + odirect = 1; + } + + if (!odirect && pfd->odirect) { + flags = fcntl(pfd->fd, F_GETFL); + ret = fcntl(pfd->fd, F_SETFL, (flags & (~O_DIRECT))); + pfd->odirect = 0; + } + + if (odirect && !pfd->odirect) { + flags = fcntl(pfd->fd, F_GETFL); + ret = fcntl(pfd->fd, F_SETFL, (flags | O_DIRECT)); + pfd->odirect = 1; + } + + if (ret) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, P_MSG_FCNTL_FAILED, + "fcntl() failed. fd=%d flags=%d pfd->odirect=%d", pfd->fd, flags, + pfd->odirect); + } } - struct posix_aio_cb { - struct iocb iocb; - call_frame_t *frame; - struct iobuf *iobuf; - struct iobref *iobref; - struct iatt prebuf; - int _fd; - fd_t *fd; - int op; - off_t offset; + struct iocb iocb; + call_frame_t *frame; + struct iobuf *iobuf; + struct iobref *iobref; + struct iatt prebuf; + int _fd; + fd_t *fd; + int op; + off_t offset; }; - int -posix_aio_readv_complete (struct posix_aio_cb *paiocb, int res, int res2) +posix_aio_readv_complete(struct posix_aio_cb *paiocb, int res, int res2) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - struct iobuf *iobuf = NULL; - struct iatt postbuf = {0,}; - int _fd = -1; - int op_ret = -1; - int op_errno = 0; - struct iovec iov; - struct iobref *iobref = NULL; - int ret = 0; - off_t offset = 0; - struct posix_private * priv = NULL; - fd_t *fd = NULL; - - - frame = paiocb->frame; - this = frame->this; - priv = this->private; - iobuf = paiocb->iobuf; - fd = paiocb->fd; - _fd = paiocb->_fd; - offset = paiocb->offset; - - if (res < 0) { - op_ret = -1; - op_errno = -res; - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_READV_FAILED, - "readv(async) failed fd=%d,size=%lu,offset=%llu (%d)", - _fd, paiocb->iocb.u.c.nbytes, - (unsigned long long) paiocb->offset, - res); - goto out; - } - - ret = posix_fdstat (this, fd->inode, _fd, &postbuf); - if (ret != 0) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, - "fstat failed on fd=%d", _fd); - goto out; - } - - op_ret = res; - op_errno = 0; - - iobref = iobref_new (); - if (!iobref) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - iobref_add (iobref, iobuf); - - iov.iov_base = iobuf_ptr (iobuf); - iov.iov_len = op_ret; - - - /* Hack to notify higher layers of EOF. */ - if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size) - op_errno = ENOENT; - - LOCK (&priv->lock); - { - priv->read_value += op_ret; - } - UNLOCK (&priv->lock); + call_frame_t *frame = NULL; + xlator_t *this = NULL; + struct iobuf *iobuf = NULL; + struct iatt postbuf = { + 0, + }; + int _fd = -1; + int op_ret = -1; + int op_errno = 0; + struct iovec iov; + struct iobref *iobref = NULL; + int ret = 0; + off_t offset = 0; + struct posix_private *priv = NULL; + fd_t *fd = NULL; + + frame = paiocb->frame; + this = frame->this; + priv = this->private; + iobuf = paiocb->iobuf; + fd = paiocb->fd; + _fd = paiocb->_fd; + offset = paiocb->offset; + + if (res < 0) { + op_ret = -1; + op_errno = -res; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_READV_FAILED, + "readv(async) failed fd=%d,size=%lu,offset=%llu (%d)", _fd, + paiocb->iocb.u.c.nbytes, (unsigned long long)paiocb->offset, + res); + goto out; + } + + ret = posix_fdstat(this, fd->inode, _fd, &postbuf); + if (ret != 0) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, + "fstat failed on fd=%d", _fd); + goto out; + } + + op_ret = res; + op_errno = 0; + + iobref = iobref_new(); + if (!iobref) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + + iobref_add(iobref, iobuf); + + iov.iov_base = iobuf_ptr(iobuf); + iov.iov_len = op_ret; + + /* Hack to notify higher layers of EOF. */ + if (!postbuf.ia_size || (offset + iov.iov_len) >= postbuf.ia_size) + op_errno = ENOENT; + + LOCK(&priv->lock); + { + priv->read_value += op_ret; + } + UNLOCK(&priv->lock); out: - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &iov, 1, - &postbuf, iobref, NULL); - if (iobuf) - iobuf_unref (iobuf); - if (iobref) - iobref_unref (iobref); + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, &iov, 1, &postbuf, + iobref, NULL); + if (iobuf) + iobuf_unref(iobuf); + if (iobref) + iobref_unref(iobref); - if (paiocb->fd) - fd_unref (paiocb->fd); + if (paiocb->fd) + fd_unref(paiocb->fd); - GF_FREE (paiocb); + GF_FREE(paiocb); - return 0; + return 0; } - int -posix_aio_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, uint32_t flags, dict_t *xdata) +posix_aio_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - int32_t op_errno = EINVAL; - int _fd = -1; - struct iobuf *iobuf = NULL; - struct posix_fd * pfd = NULL; - int ret = -1; - struct posix_aio_cb *paiocb = NULL; - struct posix_private *priv = NULL; - struct iocb *iocb = NULL; - - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - priv = this->private; - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto err; - } - _fd = pfd->fd; - - if (!size) { - op_errno = EINVAL; - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_INVALID_ARGUMENT, "size=%"GF_PRI_SIZET, size); - goto err; - } - - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (!iobuf) { - op_errno = ENOMEM; - goto err; - } - - paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_posix_mt_paiocb); - if (!paiocb) { - op_errno = ENOMEM; - goto err; - } - - - paiocb->frame = frame; - paiocb->iobuf = iobuf; - paiocb->offset = offset; - paiocb->fd = fd_ref(fd); - paiocb->_fd = _fd; - paiocb->op = GF_FOP_READ; - - paiocb->iocb.data = paiocb; - paiocb->iocb.aio_fildes = _fd; - paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD; - paiocb->iocb.aio_reqprio = 0; - paiocb->iocb.u.c.buf = iobuf_ptr (iobuf); - paiocb->iocb.u.c.nbytes = size; - paiocb->iocb.u.c.offset = offset; - - iocb = &paiocb->iocb; - - LOCK (&fd->lock); - { - __posix_fd_set_odirect (fd, pfd, flags, offset, size); - - ret = io_submit (priv->ctxp, 1, &iocb); - } - UNLOCK (&fd->lock); - - if (ret != 1) { - op_errno = -ret; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_IO_SUBMIT_FAILED, - "io_submit() returned %d", ret); - goto err; - } - - return 0; + int32_t op_errno = EINVAL; + int _fd = -1; + struct iobuf *iobuf = NULL; + struct posix_fd *pfd = NULL; + int ret = -1; + struct posix_aio_cb *paiocb = NULL; + struct posix_private *priv = NULL; + struct iocb *iocb = NULL; + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + priv = this->private; + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto err; + } + _fd = pfd->fd; + + if (!size) { + op_errno = EINVAL; + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_INVALID_ARGUMENT, + "size=%" GF_PRI_SIZET, size); + goto err; + } + + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (!iobuf) { + op_errno = ENOMEM; + goto err; + } + + paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_posix_mt_paiocb); + if (!paiocb) { + op_errno = ENOMEM; + goto err; + } + + paiocb->frame = frame; + paiocb->iobuf = iobuf; + paiocb->offset = offset; + paiocb->fd = fd_ref(fd); + paiocb->_fd = _fd; + paiocb->op = GF_FOP_READ; + + paiocb->iocb.data = paiocb; + paiocb->iocb.aio_fildes = _fd; + paiocb->iocb.aio_lio_opcode = IO_CMD_PREAD; + paiocb->iocb.aio_reqprio = 0; + paiocb->iocb.u.c.buf = iobuf_ptr(iobuf); + paiocb->iocb.u.c.nbytes = size; + paiocb->iocb.u.c.offset = offset; + + iocb = &paiocb->iocb; + + LOCK(&fd->lock); + { + __posix_fd_set_odirect(fd, pfd, flags, offset, size); + + ret = io_submit(priv->ctxp, 1, &iocb); + } + UNLOCK(&fd->lock); + + if (ret != 1) { + op_errno = -ret; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_IO_SUBMIT_FAILED, + "io_submit() returned %d", ret); + goto err; + } + + return 0; err: - STACK_UNWIND_STRICT (readv, frame, -1, op_errno, 0, 0, 0, 0, 0); - if (iobuf) - iobuf_unref (iobuf); - - if (paiocb) { - if (paiocb->fd) - fd_unref(paiocb->fd); - GF_FREE (paiocb); - } + STACK_UNWIND_STRICT(readv, frame, -1, op_errno, 0, 0, 0, 0, 0); + if (iobuf) + iobuf_unref(iobuf); - return 0; -} + if (paiocb) { + if (paiocb->fd) + fd_unref(paiocb->fd); + GF_FREE(paiocb); + } + return 0; +} int -posix_aio_writev_complete (struct posix_aio_cb *paiocb, int res, int res2) +posix_aio_writev_complete(struct posix_aio_cb *paiocb, int res, int res2) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - struct iatt prebuf = {0,}; - struct iatt postbuf = {0,}; - int _fd = -1; - int op_ret = -1; - int op_errno = 0; - int ret = 0; - struct posix_private * priv = NULL; - fd_t *fd = NULL; - - - frame = paiocb->frame; - this = frame->this; - priv = this->private; - prebuf = paiocb->prebuf; - fd = paiocb->fd; - _fd = paiocb->_fd; - - if (res < 0) { - op_ret = -1; - op_errno = -res; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_WRITEV_FAILED, - "writev(async) failed fd=%d,offset=%llu (%d)", - _fd, (unsigned long long) paiocb->offset, res); - - goto out; - } - - ret = posix_fdstat (this, fd->inode, _fd, &postbuf); - if (ret != 0) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, - "fstat failed on fd=%d", _fd); - goto out; - } - - - op_ret = res; - op_errno = 0; - - LOCK (&priv->lock); - { - priv->write_value += op_ret; - } - UNLOCK (&priv->lock); + call_frame_t *frame = NULL; + xlator_t *this = NULL; + struct iatt prebuf = { + 0, + }; + struct iatt postbuf = { + 0, + }; + int _fd = -1; + int op_ret = -1; + int op_errno = 0; + int ret = 0; + struct posix_private *priv = NULL; + fd_t *fd = NULL; + + frame = paiocb->frame; + this = frame->this; + priv = this->private; + prebuf = paiocb->prebuf; + fd = paiocb->fd; + _fd = paiocb->_fd; + + if (res < 0) { + op_ret = -1; + op_errno = -res; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_WRITEV_FAILED, + "writev(async) failed fd=%d,offset=%llu (%d)", _fd, + (unsigned long long)paiocb->offset, res); + + goto out; + } + + ret = posix_fdstat(this, fd->inode, _fd, &postbuf); + if (ret != 0) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, + "fstat failed on fd=%d", _fd); + goto out; + } + + op_ret = res; + op_errno = 0; + + LOCK(&priv->lock); + { + priv->write_value += op_ret; + } + UNLOCK(&priv->lock); out: - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, &prebuf, &postbuf, - NULL); - - if (paiocb) { - if (paiocb->iobref) - iobref_unref (paiocb->iobref); - if (paiocb->fd) - fd_unref(paiocb->fd); - GF_FREE (paiocb); - } + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, &prebuf, &postbuf, + NULL); - return 0; -} + if (paiocb) { + if (paiocb->iobref) + iobref_unref(paiocb->iobref); + if (paiocb->fd) + fd_unref(paiocb->fd); + GF_FREE(paiocb); + } + return 0; +} int -posix_aio_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *iov, int count, off_t offset, uint32_t flags, - struct iobref *iobref, dict_t *xdata) +posix_aio_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *iov, int count, off_t offset, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { - int32_t op_errno = EINVAL; - int _fd = -1; - struct posix_fd *pfd = NULL; - int ret = -1; - struct posix_aio_cb *paiocb = NULL; - struct posix_private *priv = NULL; - struct iocb *iocb = NULL; - - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - priv = this->private; - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_errno, op_errno, err); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto err; - } - _fd = pfd->fd; - - paiocb = GF_CALLOC (1, sizeof (*paiocb), gf_posix_mt_paiocb); - if (!paiocb) { - op_errno = ENOMEM; - goto err; - } - - - paiocb->frame = frame; - paiocb->offset = offset; - paiocb->fd = fd_ref(fd); - paiocb->_fd = _fd; - paiocb->op = GF_FOP_WRITE; - - paiocb->iocb.data = paiocb; - paiocb->iocb.aio_fildes = _fd; - paiocb->iobref = iobref_ref (iobref); - paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV; - paiocb->iocb.aio_reqprio = 0; - paiocb->iocb.u.v.vec = iov; - paiocb->iocb.u.v.nr = count; - paiocb->iocb.u.v.offset = offset; - - iocb = &paiocb->iocb; - - ret = posix_fdstat (this, fd->inode, _fd, &paiocb->prebuf); - if (ret != 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, - "fstat failed on fd=%p", fd); - goto err; - } - - - LOCK (&fd->lock); - { - __posix_fd_set_odirect (fd, pfd, flags, offset, - iov_length (iov, count)); - - ret = io_submit (priv->ctxp, 1, &iocb); - } - UNLOCK (&fd->lock); - - if (ret != 1) { - op_errno = -ret; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_IO_SUBMIT_FAILED, - "io_submit() returned %d,gfid=%s", ret, - uuid_utoa(fd->inode->gfid)); - goto err; - } - - return 0; + int32_t op_errno = EINVAL; + int _fd = -1; + struct posix_fd *pfd = NULL; + int ret = -1; + struct posix_aio_cb *paiocb = NULL; + struct posix_private *priv = NULL; + struct iocb *iocb = NULL; + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + priv = this->private; + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_errno, op_errno, err); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto err; + } + _fd = pfd->fd; + + paiocb = GF_CALLOC(1, sizeof(*paiocb), gf_posix_mt_paiocb); + if (!paiocb) { + op_errno = ENOMEM; + goto err; + } + + paiocb->frame = frame; + paiocb->offset = offset; + paiocb->fd = fd_ref(fd); + paiocb->_fd = _fd; + paiocb->op = GF_FOP_WRITE; + + paiocb->iocb.data = paiocb; + paiocb->iocb.aio_fildes = _fd; + paiocb->iobref = iobref_ref(iobref); + paiocb->iocb.aio_lio_opcode = IO_CMD_PWRITEV; + paiocb->iocb.aio_reqprio = 0; + paiocb->iocb.u.v.vec = iov; + paiocb->iocb.u.v.nr = count; + paiocb->iocb.u.v.offset = offset; + + iocb = &paiocb->iocb; + + ret = posix_fdstat(this, fd->inode, _fd, &paiocb->prebuf); + if (ret != 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, + "fstat failed on fd=%p", fd); + goto err; + } + + LOCK(&fd->lock); + { + __posix_fd_set_odirect(fd, pfd, flags, offset, iov_length(iov, count)); + + ret = io_submit(priv->ctxp, 1, &iocb); + } + UNLOCK(&fd->lock); + + if (ret != 1) { + op_errno = -ret; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_IO_SUBMIT_FAILED, + "io_submit() returned %d,gfid=%s", ret, + uuid_utoa(fd->inode->gfid)); + goto err; + } + + return 0; err: - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, 0, 0, 0); - - if (paiocb) { - if (paiocb->iobref) - iobref_unref (paiocb->iobref); - if (paiocb->fd) - fd_unref(paiocb->fd); - GF_FREE (paiocb); - } + STACK_UNWIND_STRICT(writev, frame, -1, op_errno, 0, 0, 0); - return 0; -} + if (paiocb) { + if (paiocb->iobref) + iobref_unref(paiocb->iobref); + if (paiocb->fd) + fd_unref(paiocb->fd); + GF_FREE(paiocb); + } + return 0; +} void * -posix_aio_thread (void *data) +posix_aio_thread(void *data) { - xlator_t *this = NULL; - struct posix_private *priv = NULL; - int ret = 0; - int i = 0; - struct io_event events[POSIX_AIO_MAX_NR_GETEVENTS]; - struct io_event *event = NULL; - struct posix_aio_cb *paiocb = NULL; - - this = data; - THIS = this; - priv = this->private; - - for (;;) { - memset (&events[0], 0, sizeof (events)); - ret = io_getevents (priv->ctxp, 1, POSIX_AIO_MAX_NR_GETEVENTS, - &events[0], NULL); - if (ret <= 0) { - gf_msg (this->name, GF_LOG_ERROR, -ret, - P_MSG_IO_GETEVENTS_FAILED, - "io_getevents() returned %d", ret); - if (ret == -EINTR) - continue; - break; - } - - for (i = 0; i < ret; i++) { - event = &events[i]; - - paiocb = event->data; - - switch (paiocb->op) { - case GF_FOP_READ: - posix_aio_readv_complete (paiocb, event->res, - event->res2); - break; - case GF_FOP_WRITE: - posix_aio_writev_complete (paiocb, event->res, - event->res2); - break; - default: - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_UNKNOWN_OP, - "unknown op %d found in piocb", - paiocb->op); - break; - } - } + xlator_t *this = NULL; + struct posix_private *priv = NULL; + int ret = 0; + int i = 0; + struct io_event events[POSIX_AIO_MAX_NR_GETEVENTS]; + struct io_event *event = NULL; + struct posix_aio_cb *paiocb = NULL; + + this = data; + THIS = this; + priv = this->private; + + for (;;) { + memset(&events[0], 0, sizeof(events)); + ret = io_getevents(priv->ctxp, 1, POSIX_AIO_MAX_NR_GETEVENTS, + &events[0], NULL); + if (ret <= 0) { + gf_msg(this->name, GF_LOG_ERROR, -ret, P_MSG_IO_GETEVENTS_FAILED, + "io_getevents() returned %d", ret); + if (ret == -EINTR) + continue; + break; } - return NULL; -} + for (i = 0; i < ret; i++) { + event = &events[i]; + + paiocb = event->data; + + switch (paiocb->op) { + case GF_FOP_READ: + posix_aio_readv_complete(paiocb, event->res, event->res2); + break; + case GF_FOP_WRITE: + posix_aio_writev_complete(paiocb, event->res, event->res2); + break; + default: + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_UNKNOWN_OP, + "unknown op %d found in piocb", paiocb->op); + break; + } + } + } + return NULL; +} int -posix_aio_init (xlator_t *this) +posix_aio_init(xlator_t *this) { - struct posix_private *priv = NULL; - int ret = 0; - - priv = this->private; - - ret = io_setup (POSIX_AIO_MAX_NR_EVENTS, &priv->ctxp); - if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_AIO_UNAVAILABLE, - "Linux AIO not available at run-time." - " Continuing with synchronous IO"); - ret = 0; - goto out; - } - - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, -ret, - P_MSG_IO_SETUP_FAILED, - "io_setup() failed. ret=%d", - ret); - goto out; - } - - ret = gf_thread_create (&priv->aiothread, NULL, - posix_aio_thread, this, "posixaio"); - if (ret != 0) { - io_destroy (priv->ctxp); - goto out; - } - - this->fops->readv = posix_aio_readv; - this->fops->writev = posix_aio_writev; + struct posix_private *priv = NULL; + int ret = 0; + + priv = this->private; + + ret = io_setup(POSIX_AIO_MAX_NR_EVENTS, &priv->ctxp); + if ((ret == -1 && errno == ENOSYS) || ret == -ENOSYS) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_AIO_UNAVAILABLE, + "Linux AIO not available at run-time." + " Continuing with synchronous IO"); + ret = 0; + goto out; + } + + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_IO_SETUP_FAILED, + "io_setup() failed. ret=%d", ret); + goto out; + } + + ret = gf_thread_create(&priv->aiothread, NULL, posix_aio_thread, this, + "posixaio"); + if (ret != 0) { + io_destroy(priv->ctxp); + goto out; + } + + this->fops->readv = posix_aio_readv; + this->fops->writev = posix_aio_writev; out: - return ret; + return ret; } - int -posix_aio_on (xlator_t *this) +posix_aio_on(xlator_t *this) { - struct posix_private *priv = NULL; - int ret = 0; - - priv = this->private; - - if (!priv->aio_init_done) { - ret = posix_aio_init (this); - if (ret == 0) - priv->aio_capable = _gf_true; - else - priv->aio_capable = _gf_false; - priv->aio_init_done = _gf_true; - } - - if (priv->aio_capable) { - this->fops->readv = posix_aio_readv; - this->fops->writev = posix_aio_writev; - } - - return ret; + struct posix_private *priv = NULL; + int ret = 0; + + priv = this->private; + + if (!priv->aio_init_done) { + ret = posix_aio_init(this); + if (ret == 0) + priv->aio_capable = _gf_true; + else + priv->aio_capable = _gf_false; + priv->aio_init_done = _gf_true; + } + + if (priv->aio_capable) { + this->fops->readv = posix_aio_readv; + this->fops->writev = posix_aio_writev; + } + + return ret; } int -posix_aio_off (xlator_t *this) +posix_aio_off(xlator_t *this) { - this->fops->readv = posix_readv; - this->fops->writev = posix_writev; + this->fops->readv = posix_readv; + this->fops->writev = posix_writev; - return 0; + return 0; } - #else - int -posix_aio_on (xlator_t *this) +posix_aio_on(xlator_t *this) { - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return 0; + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return 0; } int -posix_aio_off (xlator_t *this) +posix_aio_off(xlator_t *this) { - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return 0; + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return 0; } void -__posix_fd_set_odirect (fd_t *fd, struct posix_fd *pfd, int opflags, - off_t offset, size_t size) +__posix_fd_set_odirect(fd_t *fd, struct posix_fd *pfd, int opflags, + off_t offset, size_t size) { - xlator_t *this = THIS; - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, - "Linux AIO not available at build-time." - " Continuing with synchronous IO"); - return; + xlator_t *this = THIS; + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_AIO_UNAVAILABLE, + "Linux AIO not available at build-time." + " Continuing with synchronous IO"); + return; } #endif diff --git a/xlators/storage/posix/src/posix-common.c b/xlators/storage/posix/src/posix-common.c index 24e990cafe2..2bbf6570a97 100644 --- a/xlators/storage/posix/src/posix-common.c +++ b/xlators/storage/posix/src/posix-common.c @@ -67,17 +67,21 @@ extern char *marker_xattrs[]; #undef HAVE_SET_FSID #ifdef HAVE_SET_FSID -#define DECLARE_OLD_FS_ID_VAR uid_t old_fsuid; gid_t old_fsgid; - -#define SET_FS_ID(uid, gid) do { \ - old_fsuid = setfsuid (uid); \ - old_fsgid = setfsgid (gid); \ - } while (0) - -#define SET_TO_OLD_FS_ID() do { \ - setfsuid (old_fsuid); \ - setfsgid (old_fsgid); \ - } while (0) +#define DECLARE_OLD_FS_ID_VAR \ + uid_t old_fsuid; \ + gid_t old_fsgid; + +#define SET_FS_ID(uid, gid) \ + do { \ + old_fsuid = setfsuid(uid); \ + old_fsgid = setfsgid(gid); \ + } while (0) + +#define SET_TO_OLD_FS_ID() \ + do { \ + setfsuid(old_fsuid); \ + setfsgid(old_fsgid); \ + } while (0) #else @@ -94,1314 +98,1230 @@ extern char *marker_xattrs[]; struct timeval otherwise. */ #if HAVE_UTIMENSAT -#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ - tv.tv_nsec = nanosecs +#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) tv.tv_nsec = nanosecs #else -#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ - tv.tv_usec = nanosecs / 1000 +#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ + tv.tv_usec = nanosecs / 1000 #endif - int32_t -posix_priv (xlator_t *this) +posix_priv(xlator_t *this) { - struct posix_private *priv = NULL; - char key_prefix[GF_DUMP_MAX_BUF_LEN]; + struct posix_private *priv = NULL; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; - (void) snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", - this->type, this->name); - gf_proc_dump_add_section(key_prefix); + (void)snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, + this->name); + gf_proc_dump_add_section(key_prefix); - if (!this) - return 0; + if (!this) + return 0; - priv = this->private; + priv = this->private; - if (!priv) - return 0; + if (!priv) + return 0; - gf_proc_dump_write("base_path", "%s", priv->base_path); - gf_proc_dump_write("base_path_length", "%d", priv->base_path_length); - gf_proc_dump_write("max_read", "%d", priv->read_value); - gf_proc_dump_write("max_write", "%d", priv->write_value); - gf_proc_dump_write("nr_files", "%ld", priv->nr_files); + gf_proc_dump_write("base_path", "%s", priv->base_path); + gf_proc_dump_write("base_path_length", "%d", priv->base_path_length); + gf_proc_dump_write("max_read", "%d", priv->read_value); + gf_proc_dump_write("max_write", "%d", priv->write_value); + gf_proc_dump_write("nr_files", "%ld", priv->nr_files); - return 0; + return 0; } int32_t -posix_inode (xlator_t *this) +posix_inode(xlator_t *this) { - return 0; + return 0; } /** * notify - when parent sends PARENT_UP, send CHILD_UP event from here */ int32_t -posix_notify (xlator_t *this, - int32_t event, - void *data, - ...) +posix_notify(xlator_t *this, int32_t event, void *data, ...) { - switch (event) - { - case GF_EVENT_PARENT_UP: - { - /* Tell the parent that posix xlator is up */ - default_notify (this, GF_EVENT_CHILD_UP, data); - } - break; + switch (event) { + case GF_EVENT_PARENT_UP: { + /* Tell the parent that posix xlator is up */ + default_notify(this, GF_EVENT_CHILD_UP, data); + } break; default: - /* */ - break; - } - return 0; + /* */ + break; + } + return 0; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; - - if (!this) - return ret; + int ret = -1; - ret = xlator_mem_acct_init (this, gf_posix_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - return ret; - } + ret = xlator_mem_acct_init(this, gf_posix_mt_end + 1); + if (ret != 0) { return ret; + } + + return ret; } static int -posix_set_owner (xlator_t *this, uid_t uid, gid_t gid) +posix_set_owner(xlator_t *this, uid_t uid, gid_t gid) { - struct posix_private *priv = NULL; - int ret = -1; - struct stat st = {0,}; - - priv = this->private; - - ret = sys_lstat (priv->base_path, &st); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_DIR_OPERATION_FAILED, "Failed to stat " - "brick path %s", - priv->base_path); - return ret; - } + struct posix_private *priv = NULL; + int ret = -1; + struct stat st = { + 0, + }; + + priv = this->private; + + ret = sys_lstat(priv->base_path, &st); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_DIR_OPERATION_FAILED, + "Failed to stat " + "brick path %s", + priv->base_path); + return ret; + } - if ((uid == -1 || st.st_uid == uid) && - (gid == -1 || st.st_gid == gid)) - return 0; + if ((uid == -1 || st.st_uid == uid) && (gid == -1 || st.st_gid == gid)) + return 0; - ret = sys_chown (priv->base_path, uid, gid); - if (ret) - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_DIR_OPERATION_FAILED, "Failed to set uid/gid for" - " brick path %s", priv->base_path); + ret = sys_chown(priv->base_path, uid, gid); + if (ret) + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_DIR_OPERATION_FAILED, + "Failed to set uid/gid for" + " brick path %s", + priv->base_path); - return ret; + return ret; } static int -set_gfid2path_separator (struct posix_private *priv, const char *str) +set_gfid2path_separator(struct posix_private *priv, const char *str) { - int str_len = 0; + int str_len = 0; - str_len = strlen(str); - if (str_len > 0 && str_len < 8) { - strcpy (priv->gfid2path_sep, str); - return 0; - } + str_len = strlen(str); + if (str_len > 0 && str_len < 8) { + strcpy(priv->gfid2path_sep, str); + return 0; + } - return -1; + return -1; } static int -set_batch_fsync_mode (struct posix_private *priv, const char *str) +set_batch_fsync_mode(struct posix_private *priv, const char *str) { - if (strcmp (str, "none") == 0) - priv->batch_fsync_mode = BATCH_NONE; - else if (strcmp (str, "syncfs") == 0) - priv->batch_fsync_mode = BATCH_SYNCFS; - else if (strcmp (str, "syncfs-single-fsync") == 0) - priv->batch_fsync_mode = BATCH_SYNCFS_SINGLE_FSYNC; - else if (strcmp (str, "syncfs-reverse-fsync") == 0) - priv->batch_fsync_mode = BATCH_SYNCFS_REVERSE_FSYNC; - else if (strcmp (str, "reverse-fsync") == 0) - priv->batch_fsync_mode = BATCH_REVERSE_FSYNC; - else - return -1; + if (strcmp(str, "none") == 0) + priv->batch_fsync_mode = BATCH_NONE; + else if (strcmp(str, "syncfs") == 0) + priv->batch_fsync_mode = BATCH_SYNCFS; + else if (strcmp(str, "syncfs-single-fsync") == 0) + priv->batch_fsync_mode = BATCH_SYNCFS_SINGLE_FSYNC; + else if (strcmp(str, "syncfs-reverse-fsync") == 0) + priv->batch_fsync_mode = BATCH_SYNCFS_REVERSE_FSYNC; + else if (strcmp(str, "reverse-fsync") == 0) + priv->batch_fsync_mode = BATCH_REVERSE_FSYNC; + else + return -1; - return 0; + return 0; } #ifdef GF_DARWIN_HOST_OS static int -set_xattr_user_namespace_mode (struct posix_private *priv, const char *str) +set_xattr_user_namespace_mode(struct posix_private *priv, const char *str) { - if (strcmp (str, "none") == 0) - priv->xattr_user_namespace = XATTR_NONE; - else if (strcmp (str, "strip") == 0) - priv->xattr_user_namespace = XATTR_STRIP; - else if (strcmp (str, "append") == 0) - priv->xattr_user_namespace = XATTR_APPEND; - else if (strcmp (str, "both") == 0) - priv->xattr_user_namespace = XATTR_BOTH; - else - return -1; - return 0; + if (strcmp(str, "none") == 0) + priv->xattr_user_namespace = XATTR_NONE; + else if (strcmp(str, "strip") == 0) + priv->xattr_user_namespace = XATTR_STRIP; + else if (strcmp(str, "append") == 0) + priv->xattr_user_namespace = XATTR_APPEND; + else if (strcmp(str, "both") == 0) + priv->xattr_user_namespace = XATTR_BOTH; + else + return -1; + return 0; } #endif int -posix_reconfigure (xlator_t *this, dict_t *options) +posix_reconfigure(xlator_t *this, dict_t *options) { - int ret = -1; - struct posix_private *priv = NULL; - int32_t uid = -1; - int32_t gid = -1; - char *batch_fsync_mode_str = NULL; - char *gfid2path_sep = NULL; - int32_t force_create_mode = -1; - int32_t force_directory_mode = -1; - int32_t create_mask = -1; - int32_t create_directory_mask = -1; - - priv = this->private; - - GF_OPTION_RECONF ("brick-uid", uid, options, int32, out); - GF_OPTION_RECONF ("brick-gid", gid, options, int32, out); - if (uid != -1 || gid != -1) - posix_set_owner (this, uid, gid); - - GF_OPTION_RECONF ("batch-fsync-delay-usec", priv->batch_fsync_delay_usec, - options, uint32, out); - - GF_OPTION_RECONF ("batch-fsync-mode", batch_fsync_mode_str, - options, str, out); - - if (set_batch_fsync_mode (priv, batch_fsync_mode_str) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, - "Unknown mode string: %s", batch_fsync_mode_str); - goto out; - } - - GF_OPTION_RECONF ("gfid2path-separator", gfid2path_sep, options, - str, out); - if (set_gfid2path_separator (priv, gfid2path_sep) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, - "Length of separator exceeds 7: %s", gfid2path_sep); - goto out; - } + int ret = -1; + struct posix_private *priv = NULL; + int32_t uid = -1; + int32_t gid = -1; + char *batch_fsync_mode_str = NULL; + char *gfid2path_sep = NULL; + int32_t force_create_mode = -1; + int32_t force_directory_mode = -1; + int32_t create_mask = -1; + int32_t create_directory_mask = -1; + + priv = this->private; + + GF_OPTION_RECONF("brick-uid", uid, options, int32, out); + GF_OPTION_RECONF("brick-gid", gid, options, int32, out); + if (uid != -1 || gid != -1) + posix_set_owner(this, uid, gid); + + GF_OPTION_RECONF("batch-fsync-delay-usec", priv->batch_fsync_delay_usec, + options, uint32, out); + + GF_OPTION_RECONF("batch-fsync-mode", batch_fsync_mode_str, options, str, + out); + + if (set_batch_fsync_mode(priv, batch_fsync_mode_str) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, + "Unknown mode string: %s", batch_fsync_mode_str); + goto out; + } + + GF_OPTION_RECONF("gfid2path-separator", gfid2path_sep, options, str, out); + if (set_gfid2path_separator(priv, gfid2path_sep) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, + "Length of separator exceeds 7: %s", gfid2path_sep); + goto out; + } #ifdef GF_DARWIN_HOST_OS - char *xattr_user_namespace_mode_str = NULL; + char *xattr_user_namespace_mode_str = NULL; - GF_OPTION_RECONF ("xattr-user-namespace-mode", xattr_user_namespace_mode_str, - options, str, out); + GF_OPTION_RECONF("xattr-user-namespace-mode", xattr_user_namespace_mode_str, + options, str, out); - if (set_xattr_user_namespace_mode (priv, xattr_user_namespace_mode_str) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_UNKNOWN_ARGUMENT, - "Unknown xattr user namespace mode string: %s", - xattr_user_namespace_mode_str); - goto out; - } + if (set_xattr_user_namespace_mode(priv, xattr_user_namespace_mode_str) != + 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_UNKNOWN_ARGUMENT, + "Unknown xattr user namespace mode string: %s", + xattr_user_namespace_mode_str); + goto out; + } #endif - GF_OPTION_RECONF ("linux-aio", priv->aio_configured, - options, bool, out); + GF_OPTION_RECONF("linux-aio", priv->aio_configured, options, bool, out); - if (priv->aio_configured) - posix_aio_on (this); - else - posix_aio_off (this); + if (priv->aio_configured) + posix_aio_on(this); + else + posix_aio_off(this); - GF_OPTION_RECONF ("update-link-count-parent", priv->update_pgfid_nlinks, - options, bool, out); + GF_OPTION_RECONF("update-link-count-parent", priv->update_pgfid_nlinks, + options, bool, out); - GF_OPTION_RECONF ("gfid2path", priv->gfid2path, - options, bool, out); + GF_OPTION_RECONF("gfid2path", priv->gfid2path, options, bool, out); - GF_OPTION_RECONF ("node-uuid-pathinfo", priv->node_uuid_pathinfo, - options, bool, out); + GF_OPTION_RECONF("node-uuid-pathinfo", priv->node_uuid_pathinfo, options, + bool, out); - if (priv->node_uuid_pathinfo && - (gf_uuid_is_null (priv->glusterd_uuid))) { - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_UUID_NULL, - "glusterd uuid is NULL, pathinfo xattr would" - " fallback to <hostname>:<export>"); - } + if (priv->node_uuid_pathinfo && (gf_uuid_is_null(priv->glusterd_uuid))) { + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_UUID_NULL, + "glusterd uuid is NULL, pathinfo xattr would" + " fallback to <hostname>:<export>"); + } - GF_OPTION_RECONF ("reserve", priv->disk_reserve, - options, uint32, out); - if (priv->disk_reserve) - posix_spawn_disk_space_check_thread (this); - - GF_OPTION_RECONF ("health-check-interval", priv->health_check_interval, - options, uint32, out); - GF_OPTION_RECONF ("health-check-timeout", priv->health_check_timeout, - options, uint32, out); - posix_spawn_health_check_thread (this); - - GF_OPTION_RECONF ("shared-brick-count", priv->shared_brick_count, - options, int32, out); - - GF_OPTION_RECONF ("disable-landfill-purge", - priv->disable_landfill_purge, - options, bool, out); - if (priv->disable_landfill_purge) { - gf_log (this->name, GF_LOG_WARNING, - "Janitor WILL NOT purge the landfill directory. " - "Your landfill directory" - " may fill up this brick."); - } else { - gf_msg_debug (this->name, 0, "Janitor will purge the landfill " - "directory, which is default behavior"); - } + GF_OPTION_RECONF("reserve", priv->disk_reserve, options, uint32, out); + if (priv->disk_reserve) + posix_spawn_disk_space_check_thread(this); + + GF_OPTION_RECONF("health-check-interval", priv->health_check_interval, + options, uint32, out); + GF_OPTION_RECONF("health-check-timeout", priv->health_check_timeout, + options, uint32, out); + posix_spawn_health_check_thread(this); + + GF_OPTION_RECONF("shared-brick-count", priv->shared_brick_count, options, + int32, out); + + GF_OPTION_RECONF("disable-landfill-purge", priv->disable_landfill_purge, + options, bool, out); + if (priv->disable_landfill_purge) { + gf_log(this->name, GF_LOG_WARNING, + "Janitor WILL NOT purge the landfill directory. " + "Your landfill directory" + " may fill up this brick."); + } else { + gf_msg_debug(this->name, 0, + "Janitor will purge the landfill " + "directory, which is default behavior"); + } - GF_OPTION_RECONF ("force-create-mode", force_create_mode, - options, int32, out); - priv->force_create_mode = force_create_mode; + GF_OPTION_RECONF("force-create-mode", force_create_mode, options, int32, + out); + priv->force_create_mode = force_create_mode; - GF_OPTION_RECONF ("force-directory-mode", force_directory_mode, - options, int32, out); - priv->force_directory_mode = force_directory_mode; + GF_OPTION_RECONF("force-directory-mode", force_directory_mode, options, + int32, out); + priv->force_directory_mode = force_directory_mode; - GF_OPTION_RECONF ("create-mask", create_mask, - options, int32, out); - priv->create_mask = create_mask; + GF_OPTION_RECONF("create-mask", create_mask, options, int32, out); + priv->create_mask = create_mask; - GF_OPTION_RECONF ("create-directory-mask", create_directory_mask, - options, int32, out); - priv->create_directory_mask = create_directory_mask; + GF_OPTION_RECONF("create-directory-mask", create_directory_mask, options, + int32, out); + priv->create_directory_mask = create_directory_mask; - GF_OPTION_RECONF ("max-hardlinks", priv->max_hardlinks, - options, uint32, out); + GF_OPTION_RECONF("max-hardlinks", priv->max_hardlinks, options, uint32, + out); - GF_OPTION_RECONF ("fips-mode-rchecksum", priv->fips_mode_rchecksum, - options, bool, out); + GF_OPTION_RECONF("fips-mode-rchecksum", priv->fips_mode_rchecksum, options, + bool, out); - GF_OPTION_RECONF ("ctime", priv->ctime, options, bool, out); + GF_OPTION_RECONF("ctime", priv->ctime, options, bool, out); - ret = 0; + ret = 0; out: - return ret; + return ret; } int32_t -posix_delete_unlink_entry (const char *fpath, const struct stat *sb, - int typeflag, struct FTW *ftwbuf) { - - int ret = 0; +posix_delete_unlink_entry(const char *fpath, const struct stat *sb, + int typeflag, struct FTW *ftwbuf) +{ + int ret = 0; - if (!fpath) - goto out; + if (!fpath) + goto out; - switch (typeflag) { + switch (typeflag) { case FTW_SL: case FTW_NS: case FTW_F: case FTW_SLN: - ret = sys_unlink(fpath); - break; + ret = sys_unlink(fpath); + break; case FTW_D: case FTW_DP: case FTW_DNR: - if (ftwbuf->level != 0) { - ret = sys_rmdir(fpath); - } - break; + if (ftwbuf->level != 0) { + ret = sys_rmdir(fpath); + } + break; default: - break; - } - if (ret) { - gf_msg ("posix_delete_unlink_entry", GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "Deletion of entries %s failed" - "Please delete it manually", - fpath); - } + break; + } + if (ret) { + gf_msg("posix_delete_unlink_entry", GF_LOG_WARNING, errno, + P_MSG_HANDLE_CREATE, + "Deletion of entries %s failed" + "Please delete it manually", + fpath); + } out: - return 0; + return 0; } int32_t -posix_delete_unlink (const char *unlink_path) { - - int ret = -1; - int flags = 0; +posix_delete_unlink(const char *unlink_path) +{ + int ret = -1; + int flags = 0; - flags |= (FTW_DEPTH | FTW_PHYS); + flags |= (FTW_DEPTH | FTW_PHYS); - ret = nftw(unlink_path, posix_delete_unlink_entry, 2, flags); - if (ret) { - gf_msg ("posix_delete_unlink", GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Deleting files from %s failed", - unlink_path); - } - return ret; + ret = nftw(unlink_path, posix_delete_unlink_entry, 2, flags); + if (ret) { + gf_msg("posix_delete_unlink", GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Deleting files from %s failed", unlink_path); + } + return ret; } int32_t -posix_create_unlink_dir (xlator_t *this) { - - struct posix_private *priv = NULL; - struct stat stbuf; - int ret = -1; - uuid_t gfid = {0}; - char gfid_str[64] = {0}; - char unlink_path[PATH_MAX] = {0,}; - char landfill_path[PATH_MAX] = {0,}; - - priv = this->private; - - (void) snprintf (unlink_path, sizeof(unlink_path), "%s/%s", - priv->base_path, GF_UNLINK_PATH); - - gf_uuid_generate (gfid); - uuid_utoa_r (gfid, gfid_str); - - (void) snprintf (landfill_path, sizeof(landfill_path), "%s/%s/%s", - priv->base_path, GF_LANDFILL_PATH, gfid_str); - - ret = sys_stat (unlink_path, &stbuf); - switch (ret) { +posix_create_unlink_dir(xlator_t *this) +{ + struct posix_private *priv = NULL; + struct stat stbuf; + int ret = -1; + uuid_t gfid = {0}; + char gfid_str[64] = {0}; + char unlink_path[PATH_MAX] = { + 0, + }; + char landfill_path[PATH_MAX] = { + 0, + }; + + priv = this->private; + + (void)snprintf(unlink_path, sizeof(unlink_path), "%s/%s", priv->base_path, + GF_UNLINK_PATH); + + gf_uuid_generate(gfid); + uuid_utoa_r(gfid, gfid_str); + + (void)snprintf(landfill_path, sizeof(landfill_path), "%s/%s/%s", + priv->base_path, GF_LANDFILL_PATH, gfid_str); + + ret = sys_stat(unlink_path, &stbuf); + switch (ret) { case -1: - if (errno != ENOENT) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "Checking for %s failed", - unlink_path); - return -1; - } - break; + if (errno != ENOENT) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "Checking for %s failed", unlink_path); + return -1; + } + break; case 0: - if (!S_ISDIR (stbuf.st_mode)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Not a directory: %s", - unlink_path); - return -1; - } - ret = posix_delete_unlink (unlink_path); - return 0; - default: - break; - } - ret = sys_mkdir (unlink_path, 0600); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "Creating directory %s failed", - unlink_path); + if (!S_ISDIR(stbuf.st_mode)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Not a directory: %s", unlink_path); return -1; - } + } + ret = posix_delete_unlink(unlink_path); + return 0; + default: + break; + } + ret = sys_mkdir(unlink_path, 0600); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "Creating directory %s failed", unlink_path); + return -1; + } - return 0; + return 0; } /** * init - */ int -posix_init (xlator_t *this) +posix_init(xlator_t *this) { - struct posix_private *_private = NULL; - data_t *dir_data = NULL; - data_t *tmp_data = NULL; - struct stat buf = {0,}; - gf_boolean_t tmp_bool = 0; - int ret = 0; - int op_ret = -1; - int op_errno = 0; - ssize_t size = -1; - uuid_t old_uuid = {0,}; - uuid_t dict_uuid = {0,}; - uuid_t gfid = {0,}; - uuid_t rootgfid = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; - char *guuid = NULL; - int32_t uid = -1; - int32_t gid = -1; - char *batch_fsync_mode_str; - char *gfid2path_sep = NULL; - int force_create = -1; - int force_directory = -1; - int create_mask = -1; - int create_directory_mask = -1; - - dir_data = dict_get (this->options, "directory"); - - if (this->children) { - gf_msg (this->name, GF_LOG_CRITICAL, 0, P_MSG_SUBVOLUME_ERROR, - "FATAL: storage/posix cannot have subvolumes"); - ret = -1; - goto out; + struct posix_private *_private = NULL; + data_t *dir_data = NULL; + data_t *tmp_data = NULL; + struct stat buf = { + 0, + }; + gf_boolean_t tmp_bool = 0; + int ret = 0; + int op_ret = -1; + int op_errno = 0; + ssize_t size = -1; + uuid_t old_uuid = { + 0, + }; + uuid_t dict_uuid = { + 0, + }; + uuid_t gfid = { + 0, + }; + uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + char *guuid = NULL; + int32_t uid = -1; + int32_t gid = -1; + char *batch_fsync_mode_str; + char *gfid2path_sep = NULL; + int force_create = -1; + int force_directory = -1; + int create_mask = -1; + int create_directory_mask = -1; + + dir_data = dict_get(this->options, "directory"); + + if (this->children) { + gf_msg(this->name, GF_LOG_CRITICAL, 0, P_MSG_SUBVOLUME_ERROR, + "FATAL: storage/posix cannot have subvolumes"); + ret = -1; + goto out; + } + + if (!this->parents) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_VOLUME_DANGLING, + "Volume is dangling. Please check the volume file."); + } + + if (!dir_data) { + gf_msg(this->name, GF_LOG_CRITICAL, 0, P_MSG_EXPORT_DIR_MISSING, + "Export directory not specified in volume file."); + ret = -1; + goto out; + } + + umask(000); // umask `masking' is done at the client side + + /* Check whether the specified directory exists, if not log it. */ + op_ret = sys_stat(dir_data->data, &buf); + if ((op_ret != 0) || !S_ISDIR(buf.st_mode)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_DIR_OPERATION_FAILED, + "Directory '%s' doesn't exist, exiting.", dir_data->data); + ret = -1; + goto out; + } + + _private = GF_CALLOC(1, sizeof(*_private), gf_posix_mt_posix_private); + if (!_private) { + ret = -1; + goto out; + } + + _private->base_path = gf_strdup(dir_data->data); + _private->base_path_length = strlen(_private->base_path); + + ret = dict_get_str(this->options, "hostname", &_private->hostname); + if (ret) { + _private->hostname = GF_CALLOC(256, sizeof(char), gf_common_mt_char); + if (!_private->hostname) { + goto out; } - - if (!this->parents) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_VOLUME_DANGLING, - "Volume is dangling. Please check the volume file."); + ret = gethostname(_private->hostname, 256); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HOSTNAME_MISSING, + "could not find hostname "); } + } - if (!dir_data) { - gf_msg (this->name, GF_LOG_CRITICAL, 0, - P_MSG_EXPORT_DIR_MISSING, - "Export directory not specified in volume file."); - ret = -1; - goto out; + /* Check for Extended attribute support, if not present, log it */ + op_ret = sys_lsetxattr(dir_data->data, "trusted.glusterfs.test", "working", + 8, 0); + if (op_ret != -1) { + ret = sys_lremovexattr(dir_data->data, "trusted.glusterfs.test"); + if (ret) { + gf_msg(this->name, GF_LOG_DEBUG, errno, P_MSG_INVALID_OPTION, + "failed to remove xattr: " + "trusted.glusterfs.test"); } - - umask (000); // umask `masking' is done at the client side - - /* Check whether the specified directory exists, if not log it. */ - op_ret = sys_stat (dir_data->data, &buf); - if ((op_ret != 0) || !S_ISDIR (buf.st_mode)) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_DIR_OPERATION_FAILED, - "Directory '%s' doesn't exist, exiting.", - dir_data->data); + } else { + tmp_data = dict_get(this->options, "mandate-attribute"); + if (tmp_data) { + if (gf_string2boolean(tmp_data->data, &tmp_bool) == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION, + "wrong option provided for key " + "\"mandate-attribute\""); ret = -1; goto out; - } - - _private = GF_CALLOC (1, sizeof (*_private), - gf_posix_mt_posix_private); - if (!_private) { + } + if (!tmp_bool) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_NOTSUP, + "Extended attribute not supported, " + "starting as per option"); + } else { + gf_msg(this->name, GF_LOG_CRITICAL, 0, P_MSG_XATTR_NOTSUP, + "Extended attribute not supported, " + "exiting."); ret = -1; goto out; - } - - _private->base_path = gf_strdup (dir_data->data); - _private->base_path_length = strlen (_private->base_path); - - ret = dict_get_str (this->options, "hostname", &_private->hostname); - if (ret) { - _private->hostname = GF_CALLOC (256, sizeof (char), - gf_common_mt_char); - if (!_private->hostname) { - goto out; - } - ret = gethostname (_private->hostname, 256); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HOSTNAME_MISSING, - "could not find hostname "); - } - } - - /* Check for Extended attribute support, if not present, log it */ - op_ret = sys_lsetxattr (dir_data->data, - "trusted.glusterfs.test", "working", 8, 0); - if (op_ret != -1) { - ret = sys_lremovexattr (dir_data->data, - "trusted.glusterfs.test"); - if (ret) { - gf_msg (this->name, GF_LOG_DEBUG, errno, - P_MSG_INVALID_OPTION, - "failed to remove xattr: " - "trusted.glusterfs.test"); - } + } } else { - tmp_data = dict_get (this->options, - "mandate-attribute"); - if (tmp_data) { - if (gf_string2boolean (tmp_data->data, - &tmp_bool) == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION, - "wrong option provided for key " - "\"mandate-attribute\""); - ret = -1; - goto out; - } - if (!tmp_bool) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_NOTSUP, - "Extended attribute not supported, " - "starting as per option"); - } else { - gf_msg (this->name, GF_LOG_CRITICAL, 0, - P_MSG_XATTR_NOTSUP, - "Extended attribute not supported, " - "exiting."); - ret = -1; - goto out; - } - } else { - gf_msg (this->name, GF_LOG_CRITICAL, 0, - P_MSG_XATTR_NOTSUP, - "Extended attribute not supported, exiting."); - ret = -1; - goto out; - } + gf_msg(this->name, GF_LOG_CRITICAL, 0, P_MSG_XATTR_NOTSUP, + "Extended attribute not supported, exiting."); + ret = -1; + goto out; } + } - tmp_data = dict_get (this->options, "volume-id"); - if (tmp_data) { - op_ret = gf_uuid_parse (tmp_data->data, dict_uuid); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_VOLUME_ID, - "wrong volume-id (%s) set" - " in volume file", tmp_data->data); - ret = -1; - goto out; - } - size = sys_lgetxattr (dir_data->data, - "trusted.glusterfs.volume-id", old_uuid, 16); - if (size == 16) { - if (gf_uuid_compare (old_uuid, dict_uuid)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_VOLUME_ID, - "mismatching volume-id (%s) received. " - "already is a part of volume %s ", - tmp_data->data, uuid_utoa (old_uuid)); - gf_event (EVENT_POSIX_ALREADY_PART_OF_VOLUME, - "volume-id=%s;brick=%s:%s", - uuid_utoa (old_uuid), - _private->hostname, _private->base_path); - ret = -1; - goto out; - } - } else if ((size == -1) && - (errno == ENODATA || errno == ENOATTR)) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_VOLUME_ID_ABSENT, - "Extended attribute trusted.glusterfs." - "volume-id is absent"); - gf_event (EVENT_POSIX_BRICK_NOT_IN_VOLUME, - "brick=%s:%s", - _private->hostname, _private->base_path); - ret = -1; - goto out; - - } else if ((size == -1) && (errno != ENODATA) && - (errno != ENOATTR)) { - /* Wrong 'volume-id' is set, it should be error */ - gf_event (EVENT_POSIX_BRICK_VERIFICATION_FAILED, - "brick=%s:%s", - _private->hostname, _private->base_path); - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_VOLUME_ID_FETCH_FAILED, - "%s: failed to fetch volume-id", - dir_data->data); - ret = -1; - goto out; - } else { - ret = -1; - gf_event (EVENT_POSIX_BRICK_VERIFICATION_FAILED, - "brick=%s:%s", - _private->hostname, _private->base_path); - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_VOLUME_ID_FETCH_FAILED, - "failed to fetch proper volume id from export"); - goto out; - } + tmp_data = dict_get(this->options, "volume-id"); + if (tmp_data) { + op_ret = gf_uuid_parse(tmp_data->data, dict_uuid); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_VOLUME_ID, + "wrong volume-id (%s) set" + " in volume file", + tmp_data->data); + ret = -1; + goto out; } - - /* Now check if the export directory has some other 'gfid', - other than that of root '/' */ - size = sys_lgetxattr (dir_data->data, "trusted.gfid", gfid, 16); + size = sys_lgetxattr(dir_data->data, "trusted.glusterfs.volume-id", + old_uuid, 16); if (size == 16) { - if (!__is_root_gfid (gfid)) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GFID_SET_FAILED, - "%s: gfid (%s) is not that of glusterfs '/' ", - dir_data->data, uuid_utoa (gfid)); - ret = -1; - goto out; - } - } else if (size != -1) { - /* Wrong 'gfid' is set, it should be error */ - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GFID_SET_FAILED, - "%s: wrong value set as gfid", - dir_data->data); - ret = -1; - goto out; - } else if ((size == -1) && (errno != ENODATA) && - (errno != ENOATTR)) { - /* Wrong 'gfid' is set, it should be error */ - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GFID_SET_FAILED, - "%s: failed to fetch gfid", - dir_data->data); + if (gf_uuid_compare(old_uuid, dict_uuid)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_VOLUME_ID, + "mismatching volume-id (%s) received. " + "already is a part of volume %s ", + tmp_data->data, uuid_utoa(old_uuid)); + gf_event(EVENT_POSIX_ALREADY_PART_OF_VOLUME, + "volume-id=%s;brick=%s:%s", uuid_utoa(old_uuid), + _private->hostname, _private->base_path); ret = -1; goto out; + } + } else if ((size == -1) && (errno == ENODATA || errno == ENOATTR)) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_VOLUME_ID_ABSENT, + "Extended attribute trusted.glusterfs." + "volume-id is absent"); + gf_event(EVENT_POSIX_BRICK_NOT_IN_VOLUME, "brick=%s:%s", + _private->hostname, _private->base_path); + ret = -1; + goto out; + + } else if ((size == -1) && (errno != ENODATA) && (errno != ENOATTR)) { + /* Wrong 'volume-id' is set, it should be error */ + gf_event(EVENT_POSIX_BRICK_VERIFICATION_FAILED, "brick=%s:%s", + _private->hostname, _private->base_path); + gf_msg(this->name, GF_LOG_WARNING, errno, + P_MSG_VOLUME_ID_FETCH_FAILED, + "%s: failed to fetch volume-id", dir_data->data); + ret = -1; + goto out; } else { - /* First time volume, set the GFID */ - size = sys_lsetxattr (dir_data->data, "trusted.gfid", rootgfid, - 16, XATTR_CREATE); - if (size == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_GFID_SET_FAILED, - "%s: failed to set gfid", - dir_data->data); - ret = -1; - goto out; - } - } - - ret = 0; - - size = sys_lgetxattr (dir_data->data, POSIX_ACL_ACCESS_XATTR, - NULL, 0); - if ((size < 0) && (errno == ENOTSUP)) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_ACL_NOTSUP, - "Posix access control list is not supported."); - gf_event (EVENT_POSIX_ACL_NOT_SUPPORTED, - "brick=%s:%s", _private->hostname, _private->base_path); + ret = -1; + gf_event(EVENT_POSIX_BRICK_VERIFICATION_FAILED, "brick=%s:%s", + _private->hostname, _private->base_path); + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_VOLUME_ID_FETCH_FAILED, + "failed to fetch proper volume id from export"); + goto out; } - - /* - * _XOPEN_PATH_MAX is the longest file path len we MUST - * support according to POSIX standard. When prepended - * by the brick base path it may exceed backed filesystem - * capacity (which MAY be bigger than _XOPEN_PATH_MAX). If - * this is the case, chdir() to the brick base path and - * use relative paths when they are too long. See also - * MAKE_REAL_PATH in posix-handle.h - */ - _private->path_max = pathconf(_private->base_path, _PC_PATH_MAX); - if (_private->path_max != -1 && - _XOPEN_PATH_MAX + _private->base_path_length > _private->path_max) { - ret = chdir(_private->base_path); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_BASEPATH_CHDIR_FAILED, - "chdir() to \"%s\" failed", - _private->base_path); - goto out; - } -#ifdef __NetBSD__ - /* - * At least on NetBSD, the chdir() above uncovers a - * race condition which cause file lookup to fail - * with ENODATA for a few seconds. The volume quickly - * reaches a sane state, but regression tests are fast - * enough to choke on it. The reason is obscure (as - * often with race conditions), but sleeping here for - * a second seems to workaround the problem. - */ - sleep(1); -#endif + } + + /* Now check if the export directory has some other 'gfid', + other than that of root '/' */ + size = sys_lgetxattr(dir_data->data, "trusted.gfid", gfid, 16); + if (size == 16) { + if (!__is_root_gfid(gfid)) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GFID_SET_FAILED, + "%s: gfid (%s) is not that of glusterfs '/' ", + dir_data->data, uuid_utoa(gfid)); + ret = -1; + goto out; } - - - LOCK_INIT (&_private->lock); - - _private->export_statfs = 1; - tmp_data = dict_get (this->options, "export-statfs-size"); - if (tmp_data) { - if (gf_string2boolean (tmp_data->data, - &_private->export_statfs) == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION_VAL, - "'export-statfs-size' takes only boolean " - "options"); - goto out; - } - if (!_private->export_statfs) - gf_msg_debug (this->name, 0, - "'statfs()' returns dummy size"); + } else if (size != -1) { + /* Wrong 'gfid' is set, it should be error */ + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GFID_SET_FAILED, + "%s: wrong value set as gfid", dir_data->data); + ret = -1; + goto out; + } else if ((size == -1) && (errno != ENODATA) && (errno != ENOATTR)) { + /* Wrong 'gfid' is set, it should be error */ + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GFID_SET_FAILED, + "%s: failed to fetch gfid", dir_data->data); + ret = -1; + goto out; + } else { + /* First time volume, set the GFID */ + size = sys_lsetxattr(dir_data->data, "trusted.gfid", rootgfid, 16, + XATTR_CREATE); + if (size == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_GFID_SET_FAILED, + "%s: failed to set gfid", dir_data->data); + ret = -1; + goto out; } - - _private->background_unlink = 0; - tmp_data = dict_get (this->options, "background-unlink"); - if (tmp_data) { - if (gf_string2boolean (tmp_data->data, - &_private->background_unlink) == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION_VAL, "'background-unlink'" - " takes only boolean options"); - goto out; - } - - if (_private->background_unlink) - gf_msg_debug (this->name, 0, - "unlinks will be performed in background"); + } + + ret = 0; + + size = sys_lgetxattr(dir_data->data, POSIX_ACL_ACCESS_XATTR, NULL, 0); + if ((size < 0) && (errno == ENOTSUP)) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_ACL_NOTSUP, + "Posix access control list is not supported."); + gf_event(EVENT_POSIX_ACL_NOT_SUPPORTED, "brick=%s:%s", + _private->hostname, _private->base_path); + } + + /* + * _XOPEN_PATH_MAX is the longest file path len we MUST + * support according to POSIX standard. When prepended + * by the brick base path it may exceed backed filesystem + * capacity (which MAY be bigger than _XOPEN_PATH_MAX). If + * this is the case, chdir() to the brick base path and + * use relative paths when they are too long. See also + * MAKE_REAL_PATH in posix-handle.h + */ + _private->path_max = pathconf(_private->base_path, _PC_PATH_MAX); + if (_private->path_max != -1 && + _XOPEN_PATH_MAX + _private->base_path_length > _private->path_max) { + ret = chdir(_private->base_path); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_BASEPATH_CHDIR_FAILED, + "chdir() to \"%s\" failed", _private->base_path); + goto out; } - - tmp_data = dict_get (this->options, "o-direct"); - if (tmp_data) { - if (gf_string2boolean (tmp_data->data, - &_private->o_direct) == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION_VAL, - "wrong option provided for 'o-direct'"); - goto out; - } - if (_private->o_direct) - gf_msg_debug (this->name, 0, "o-direct mode is enabled" - " (O_DIRECT for every open)"); +#ifdef __NetBSD__ + /* + * At least on NetBSD, the chdir() above uncovers a + * race condition which cause file lookup to fail + * with ENODATA for a few seconds. The volume quickly + * reaches a sane state, but regression tests are fast + * enough to choke on it. The reason is obscure (as + * often with race conditions), but sleeping here for + * a second seems to workaround the problem. + */ + sleep(1); +#endif + } + + LOCK_INIT(&_private->lock); + + _private->export_statfs = 1; + tmp_data = dict_get(this->options, "export-statfs-size"); + if (tmp_data) { + if (gf_string2boolean(tmp_data->data, &_private->export_statfs) == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION_VAL, + "'export-statfs-size' takes only boolean " + "options"); + goto out; } - - tmp_data = dict_get (this->options, "update-link-count-parent"); - if (tmp_data) { - if (gf_string2boolean (tmp_data->data, - &_private->update_pgfid_nlinks) == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION, "wrong value provided " - "for 'update-link-count-parent'"); - goto out; - } - if (_private->update_pgfid_nlinks) - gf_msg_debug (this->name, 0, "update-link-count-parent" - " is enabled. Thus for each file an " - "extended attribute representing the " - "number of hardlinks for that file " - "within the same parent directory is" - " set."); + if (!_private->export_statfs) + gf_msg_debug(this->name, 0, "'statfs()' returns dummy size"); + } + + _private->background_unlink = 0; + tmp_data = dict_get(this->options, "background-unlink"); + if (tmp_data) { + if (gf_string2boolean(tmp_data->data, &_private->background_unlink) == + -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION_VAL, + "'background-unlink'" + " takes only boolean options"); + goto out; } - ret = dict_get_str (this->options, "glusterd-uuid", &guuid); - if (!ret) { - if (gf_uuid_parse (guuid, _private->glusterd_uuid)) - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_INVALID_NODE_UUID, "Cannot parse " - "glusterd (node) UUID, node-uuid xattr " - "request would return - \"No such attribute\""); - } else { - gf_msg_debug (this->name, 0, "No glusterd (node) UUID passed -" - " node-uuid xattr request will return \"No such" - " attribute\""); + if (_private->background_unlink) + gf_msg_debug(this->name, 0, + "unlinks will be performed in background"); + } + + tmp_data = dict_get(this->options, "o-direct"); + if (tmp_data) { + if (gf_string2boolean(tmp_data->data, &_private->o_direct) == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION_VAL, + "wrong option provided for 'o-direct'"); + goto out; } - ret = 0; - - GF_OPTION_INIT ("janitor-sleep-duration", - _private->janitor_sleep_duration, int32, out); - - /* performing open dir on brick dir locks the brick dir - * and prevents it from being unmounted - */ - _private->mount_lock = sys_opendir (dir_data->data); - if (!_private->mount_lock) { - ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_DIR_OPERATION_FAILED, - "Could not lock brick directory (%s)", - strerror (op_errno)); - goto out; + if (_private->o_direct) + gf_msg_debug(this->name, 0, + "o-direct mode is enabled" + " (O_DIRECT for every open)"); + } + + tmp_data = dict_get(this->options, "update-link-count-parent"); + if (tmp_data) { + if (gf_string2boolean(tmp_data->data, &_private->update_pgfid_nlinks) == + -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION, + "wrong value provided " + "for 'update-link-count-parent'"); + goto out; } + if (_private->update_pgfid_nlinks) + gf_msg_debug(this->name, 0, + "update-link-count-parent" + " is enabled. Thus for each file an " + "extended attribute representing the " + "number of hardlinks for that file " + "within the same parent directory is" + " set."); + } + + ret = dict_get_str(this->options, "glusterd-uuid", &guuid); + if (!ret) { + if (gf_uuid_parse(guuid, _private->glusterd_uuid)) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_INVALID_NODE_UUID, + "Cannot parse " + "glusterd (node) UUID, node-uuid xattr " + "request would return - \"No such attribute\""); + } else { + gf_msg_debug(this->name, 0, + "No glusterd (node) UUID passed -" + " node-uuid xattr request will return \"No such" + " attribute\""); + } + ret = 0; + + GF_OPTION_INIT("janitor-sleep-duration", _private->janitor_sleep_duration, + int32, out); + + /* performing open dir on brick dir locks the brick dir + * and prevents it from being unmounted + */ + _private->mount_lock = sys_opendir(dir_data->data); + if (!_private->mount_lock) { + ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_DIR_OPERATION_FAILED, + "Could not lock brick directory (%s)", strerror(op_errno)); + goto out; + } #ifndef GF_DARWIN_HOST_OS - { - struct rlimit lim; - lim.rlim_cur = 1048576; - lim.rlim_max = 1048576; - - if (setrlimit (RLIMIT_NOFILE, &lim) == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SET_ULIMIT_FAILED, - "Failed to set 'ulimit -n " - " 1048576'"); - lim.rlim_cur = 65536; - lim.rlim_max = 65536; - - if (setrlimit (RLIMIT_NOFILE, &lim) == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SET_FILE_MAX_FAILED, - "Failed to set maximum allowed open " - "file descriptors to 64k"); - } - else { - gf_msg (this->name, GF_LOG_INFO, 0, - P_MSG_MAX_FILE_OPEN, "Maximum allowed " - "open file descriptors set to 65536"); - } - } + { + struct rlimit lim; + lim.rlim_cur = 1048576; + lim.rlim_max = 1048576; + + if (setrlimit(RLIMIT_NOFILE, &lim) == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SET_ULIMIT_FAILED, + "Failed to set 'ulimit -n " + " 1048576'"); + lim.rlim_cur = 65536; + lim.rlim_max = 65536; + + if (setrlimit(RLIMIT_NOFILE, &lim) == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, + P_MSG_SET_FILE_MAX_FAILED, + "Failed to set maximum allowed open " + "file descriptors to 64k"); + } else { + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_MAX_FILE_OPEN, + "Maximum allowed " + "open file descriptors set to 65536"); + } } + } #endif - _private->shared_brick_count = 1; - ret = dict_get_int32 (this->options, "shared-brick-count", - &_private->shared_brick_count); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_INVALID_OPTION_VAL, - "'shared-brick-count' takes only integer " - "values"); - goto out; - } + _private->shared_brick_count = 1; + ret = dict_get_int32(this->options, "shared-brick-count", + &_private->shared_brick_count); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_OPTION_VAL, + "'shared-brick-count' takes only integer " + "values"); + goto out; + } + + this->private = (void *)_private; + + op_ret = posix_handle_init(this); + if (op_ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Posix handle setup failed"); + ret = -1; + goto out; + } + + op_ret = posix_handle_trash_init(this); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE_TRASH, + "Posix landfill setup failed"); + ret = -1; + goto out; + } + + op_ret = posix_create_unlink_dir(this); + if (op_ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Creation of unlink directory failed"); + ret = -1; + goto out; + } + + _private->aio_init_done = _gf_false; + _private->aio_capable = _gf_false; + + GF_OPTION_INIT("brick-uid", uid, int32, out); + GF_OPTION_INIT("brick-gid", gid, int32, out); + if (uid != -1 || gid != -1) + posix_set_owner(this, uid, gid); + + GF_OPTION_INIT("linux-aio", _private->aio_configured, bool, out); + + if (_private->aio_configured) { + op_ret = posix_aio_on(this); - this->private = (void *)_private; - - op_ret = posix_handle_init (this); if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, - "Posix handle setup failed"); - ret = -1; - goto out; - } - - op_ret = posix_handle_trash_init (this); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE_TRASH, - "Posix landfill setup failed"); - ret = -1; - goto out; - } - - op_ret = posix_create_unlink_dir (this); - if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Creation of unlink directory failed"); - ret = -1; - goto out; - } - - _private->aio_init_done = _gf_false; - _private->aio_capable = _gf_false; - - GF_OPTION_INIT ("brick-uid", uid, int32, out); - GF_OPTION_INIT ("brick-gid", gid, int32, out); - if (uid != -1 || gid != -1) - posix_set_owner (this, uid, gid); - - GF_OPTION_INIT ("linux-aio", _private->aio_configured, bool, out); - - if (_private->aio_configured) { - op_ret = posix_aio_on (this); - - if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_POSIX_AIO, - "Posix AIO init failed"); - ret = -1; - goto out; - } - } - - GF_OPTION_INIT ("node-uuid-pathinfo", - _private->node_uuid_pathinfo, bool, out); - if (_private->node_uuid_pathinfo && - (gf_uuid_is_null (_private->glusterd_uuid))) { - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_UUID_NULL, - "glusterd uuid is NULL, pathinfo xattr would" - " fallback to <hostname>:<export>"); - } - - _private->disk_space_check_active = _gf_false; - _private->disk_space_full = 0; - GF_OPTION_INIT ("reserve", - _private->disk_reserve, uint32, out); - if (_private->disk_reserve) - posix_spawn_disk_space_check_thread (this); - - _private->health_check_active = _gf_false; - GF_OPTION_INIT ("health-check-interval", - _private->health_check_interval, uint32, out); - GF_OPTION_INIT ("health-check-timeout", - _private->health_check_timeout, uint32, out); - if (_private->health_check_interval) - posix_spawn_health_check_thread (this); - - pthread_mutex_init (&_private->janitor_lock, NULL); - pthread_cond_init (&_private->janitor_cond, NULL); - INIT_LIST_HEAD (&_private->janitor_fds); - - posix_spawn_janitor_thread (this); - - pthread_mutex_init (&_private->fsync_mutex, NULL); - pthread_cond_init (&_private->fsync_cond, NULL); - INIT_LIST_HEAD (&_private->fsyncs); - - ret = gf_thread_create (&_private->fsyncer, NULL, posix_fsyncer, this, - "posixfsy"); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FSYNCER_THREAD_CREATE_FAILED, - "fsyncer thread creation failed"); - goto out; - } - - GF_OPTION_INIT ("batch-fsync-mode", batch_fsync_mode_str, str, out); - - if (set_batch_fsync_mode (_private, batch_fsync_mode_str) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, - "Unknown mode string: %s", batch_fsync_mode_str); - goto out; - } - - GF_OPTION_INIT ("gfid2path", _private->gfid2path, bool, out); - - GF_OPTION_INIT ("gfid2path-separator", gfid2path_sep, str, out); - if (set_gfid2path_separator (_private, gfid2path_sep) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, - "Length of separator exceeds 7: %s", gfid2path_sep); - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_POSIX_AIO, + "Posix AIO init failed"); + ret = -1; + goto out; } + } + + GF_OPTION_INIT("node-uuid-pathinfo", _private->node_uuid_pathinfo, bool, + out); + if (_private->node_uuid_pathinfo && + (gf_uuid_is_null(_private->glusterd_uuid))) { + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_UUID_NULL, + "glusterd uuid is NULL, pathinfo xattr would" + " fallback to <hostname>:<export>"); + } + + _private->disk_space_check_active = _gf_false; + _private->disk_space_full = 0; + GF_OPTION_INIT("reserve", _private->disk_reserve, uint32, out); + if (_private->disk_reserve) + posix_spawn_disk_space_check_thread(this); + + _private->health_check_active = _gf_false; + GF_OPTION_INIT("health-check-interval", _private->health_check_interval, + uint32, out); + GF_OPTION_INIT("health-check-timeout", _private->health_check_timeout, + uint32, out); + if (_private->health_check_interval) + posix_spawn_health_check_thread(this); + + pthread_mutex_init(&_private->janitor_lock, NULL); + pthread_cond_init(&_private->janitor_cond, NULL); + INIT_LIST_HEAD(&_private->janitor_fds); + + posix_spawn_janitor_thread(this); + + pthread_mutex_init(&_private->fsync_mutex, NULL); + pthread_cond_init(&_private->fsync_cond, NULL); + INIT_LIST_HEAD(&_private->fsyncs); + + ret = gf_thread_create(&_private->fsyncer, NULL, posix_fsyncer, this, + "posixfsy"); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_FSYNCER_THREAD_CREATE_FAILED, + "fsyncer thread creation failed"); + goto out; + } + + GF_OPTION_INIT("batch-fsync-mode", batch_fsync_mode_str, str, out); + + if (set_batch_fsync_mode(_private, batch_fsync_mode_str) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, + "Unknown mode string: %s", batch_fsync_mode_str); + goto out; + } + + GF_OPTION_INIT("gfid2path", _private->gfid2path, bool, out); + + GF_OPTION_INIT("gfid2path-separator", gfid2path_sep, str, out); + if (set_gfid2path_separator(_private, gfid2path_sep) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, + "Length of separator exceeds 7: %s", gfid2path_sep); + goto out; + } #ifdef GF_DARWIN_HOST_OS - char *xattr_user_namespace_mode_str = NULL; + char *xattr_user_namespace_mode_str = NULL; - GF_OPTION_INIT ("xattr-user-namespace-mode", - xattr_user_namespace_mode_str, str, out); + GF_OPTION_INIT("xattr-user-namespace-mode", xattr_user_namespace_mode_str, + str, out); - if (set_xattr_user_namespace_mode (_private, - xattr_user_namespace_mode_str) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, - "Unknown xattr user namespace mode string: %s", - xattr_user_namespace_mode_str); - goto out; - } + if (set_xattr_user_namespace_mode(_private, + xattr_user_namespace_mode_str) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_INVALID_ARGUMENT, + "Unknown xattr user namespace mode string: %s", + xattr_user_namespace_mode_str); + goto out; + } #endif - GF_OPTION_INIT ("batch-fsync-delay-usec", _private->batch_fsync_delay_usec, - uint32, out); + GF_OPTION_INIT("batch-fsync-delay-usec", _private->batch_fsync_delay_usec, + uint32, out); - GF_OPTION_INIT ("disable-landfill-purge", - _private->disable_landfill_purge, bool, out); - if (_private->disable_landfill_purge) { - gf_msg (this->name, GF_LOG_WARNING, 0, 0, - "Janitor WILL NOT purge the landfill directory. " - "Your landfill directory" - " may fill up this brick."); - } + GF_OPTION_INIT("disable-landfill-purge", _private->disable_landfill_purge, + bool, out); + if (_private->disable_landfill_purge) { + gf_msg(this->name, GF_LOG_WARNING, 0, 0, + "Janitor WILL NOT purge the landfill directory. " + "Your landfill directory" + " may fill up this brick."); + } - GF_OPTION_INIT ("force-create-mode", force_create, int32, out); - _private->force_create_mode = force_create; + GF_OPTION_INIT("force-create-mode", force_create, int32, out); + _private->force_create_mode = force_create; - GF_OPTION_INIT ("force-directory-mode", force_directory, int32, out); - _private->force_directory_mode = force_directory; + GF_OPTION_INIT("force-directory-mode", force_directory, int32, out); + _private->force_directory_mode = force_directory; - GF_OPTION_INIT ("create-mask", - create_mask, int32, out); - _private->create_mask = create_mask; + GF_OPTION_INIT("create-mask", create_mask, int32, out); + _private->create_mask = create_mask; - GF_OPTION_INIT ("create-directory-mask", - create_directory_mask, int32, out); - _private->create_directory_mask = create_directory_mask; + GF_OPTION_INIT("create-directory-mask", create_directory_mask, int32, out); + _private->create_directory_mask = create_directory_mask; - GF_OPTION_INIT ("max-hardlinks", _private->max_hardlinks, uint32, out); + GF_OPTION_INIT("max-hardlinks", _private->max_hardlinks, uint32, out); - GF_OPTION_INIT ("fips-mode-rchecksum", _private->fips_mode_rchecksum, - bool, out); + GF_OPTION_INIT("fips-mode-rchecksum", _private->fips_mode_rchecksum, bool, + out); - GF_OPTION_INIT ("ctime", _private->ctime, bool, out); + GF_OPTION_INIT("ctime", _private->ctime, bool, out); out: - if (ret) { - if (_private) { - GF_FREE (_private->base_path); + if (ret) { + if (_private) { + GF_FREE(_private->base_path); - GF_FREE (_private->hostname); + GF_FREE(_private->hostname); - GF_FREE (_private->trash_path); + GF_FREE(_private->trash_path); - GF_FREE (_private); - } - - this->private = NULL; + GF_FREE(_private); } - return ret; + + this->private = NULL; + } + return ret; } void -posix_fini (xlator_t *this) +posix_fini(xlator_t *this) { - struct posix_private *priv = this->private; - if (!priv) - return; - LOCK (&priv->lock); - if (priv->health_check_active) { - priv->health_check_active = _gf_false; - pthread_cancel (priv->health_check); - priv->health_check = 0; - } - UNLOCK (&priv->lock); - if (priv->disk_space_check) { - priv->disk_space_check_active = _gf_false; - pthread_cancel (priv->disk_space_check); - priv->disk_space_check = 0; - } - if (priv->janitor) { - (void) gf_thread_cleanup_xint (priv->janitor); - priv->janitor = 0; - } - if (priv->fsyncer) { - (void) gf_thread_cleanup_xint (priv->fsyncer); - priv->fsyncer = 0; - } - /*unlock brick dir*/ - if (priv->mount_lock) - (void) sys_closedir (priv->mount_lock); - - GF_FREE (priv->base_path); - LOCK_DESTROY (&priv->lock); - pthread_mutex_destroy (&priv->janitor_lock); - pthread_mutex_destroy (&priv->fsync_mutex); - GF_FREE (priv->hostname); - GF_FREE (priv->trash_path); - GF_FREE (priv); - this->private = NULL; - + struct posix_private *priv = this->private; + if (!priv) return; + LOCK(&priv->lock); + if (priv->health_check_active) { + priv->health_check_active = _gf_false; + pthread_cancel(priv->health_check); + priv->health_check = 0; + } + UNLOCK(&priv->lock); + if (priv->disk_space_check) { + priv->disk_space_check_active = _gf_false; + pthread_cancel(priv->disk_space_check); + priv->disk_space_check = 0; + } + if (priv->janitor) { + (void)gf_thread_cleanup_xint(priv->janitor); + priv->janitor = 0; + } + if (priv->fsyncer) { + (void)gf_thread_cleanup_xint(priv->fsyncer); + priv->fsyncer = 0; + } + /*unlock brick dir*/ + if (priv->mount_lock) + (void)sys_closedir(priv->mount_lock); + + GF_FREE(priv->base_path); + LOCK_DESTROY(&priv->lock); + pthread_mutex_destroy(&priv->janitor_lock); + pthread_mutex_destroy(&priv->fsync_mutex); + GF_FREE(priv->hostname); + GF_FREE(priv->trash_path); + GF_FREE(priv); + this->private = NULL; + + return; } struct volume_options options[] = { - { .key = {"o-direct"}, - .type = GF_OPTION_TYPE_BOOL }, - { .key = {"directory"}, - .type = GF_OPTION_TYPE_PATH, - .default_value = "{{brick.path}}" - }, - { .key = {"hostname"}, - .type = GF_OPTION_TYPE_ANY }, - { .key = {"export-statfs-size"}, - .type = GF_OPTION_TYPE_BOOL }, - { .key = {"mandate-attribute"}, - .type = GF_OPTION_TYPE_BOOL }, - { .key = {"background-unlink"}, - .type = GF_OPTION_TYPE_BOOL }, - { .key = {"janitor-sleep-duration"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .validate = GF_OPT_VALIDATE_MIN, - .default_value = "10", - .description = "Interval (in seconds) between times the internal " - "'landfill' directory is emptied." - }, - { .key = {"volume-id"}, - .type = GF_OPTION_TYPE_ANY, - .default_value = "{{brick.volumeid}}" - }, - { .key = {"glusterd-uuid"}, - .type = GF_OPTION_TYPE_STR }, - { - .key = {"linux-aio"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Support for native Linux AIO", - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { - .key = {"brick-uid"}, - .type = GF_OPTION_TYPE_INT, - .min = -1, - .validate = GF_OPT_VALIDATE_MIN, - .default_value = "-1", - .description = "Support for setting uid of brick's owner", - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { - .key = {"brick-gid"}, - .type = GF_OPTION_TYPE_INT, - .min = -1, - .validate = GF_OPT_VALIDATE_MIN, - .default_value = "-1", - .description = "Support for setting gid of brick's owner", - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { .key = {"node-uuid-pathinfo"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "return glusterd's node-uuid in pathinfo xattr" - " string instead of hostname", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { - .key = {"health-check-interval"}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .default_value = "30", - .validate = GF_OPT_VALIDATE_MIN, - .description = "Interval in seconds for a filesystem health check, " - "set to 0 to disable", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { - .key = {"health-check-timeout"}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .default_value = "10", - .validate = GF_OPT_VALIDATE_MIN, - .description = "Interval in seconds to wait aio_write finish for health check, " - "set to 0 to disable", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { - .key = {"reserve"}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .default_value = "1", - .validate = GF_OPT_VALIDATE_MIN, - .description = "Percentage of disk space to be reserved." - " Set to 0 to disable", - .op_version = {GD_OP_VERSION_3_13_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { .key = {"batch-fsync-mode"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "reverse-fsync", - .description = "Possible values:\n" - "\t- syncfs: Perform one syncfs() on behalf oa batch" - "of fsyncs.\n" - "\t- syncfs-single-fsync: Perform one syncfs() on behalf of a batch" - " of fsyncs and one fsync() per batch.\n" - "\t- syncfs-reverse-fsync: Perform one syncfs() on behalf of a batch" - " of fsyncs and fsync() each file in the batch in reverse order.\n" - " in reverse order.\n" - "\t- reverse-fsync: Perform fsync() of each file in the batch in" - " reverse order.", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { .key = {"batch-fsync-delay-usec"}, - .type = GF_OPTION_TYPE_INT, - .default_value = "0", - .description = "Num of usecs to wait for aggregating fsync" - " requests", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { .key = {"update-link-count-parent"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Enable placeholders for gfid to path conversion", - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, - { .key = {"gfid2path"}, - .type = GF_OPTION_TYPE_BOOL, + {.key = {"o-direct"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"directory"}, + .type = GF_OPTION_TYPE_PATH, + .default_value = "{{brick.path}}"}, + {.key = {"hostname"}, .type = GF_OPTION_TYPE_ANY}, + {.key = {"export-statfs-size"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"mandate-attribute"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"background-unlink"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"janitor-sleep-duration"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .validate = GF_OPT_VALIDATE_MIN, + .default_value = "10", + .description = "Interval (in seconds) between times the internal " + "'landfill' directory is emptied."}, + {.key = {"volume-id"}, + .type = GF_OPTION_TYPE_ANY, + .default_value = "{{brick.volumeid}}"}, + {.key = {"glusterd-uuid"}, .type = GF_OPTION_TYPE_STR}, + {.key = {"linux-aio"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Support for native Linux AIO", + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"brick-uid"}, + .type = GF_OPTION_TYPE_INT, + .min = -1, + .validate = GF_OPT_VALIDATE_MIN, + .default_value = "-1", + .description = "Support for setting uid of brick's owner", + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"brick-gid"}, + .type = GF_OPTION_TYPE_INT, + .min = -1, + .validate = GF_OPT_VALIDATE_MIN, + .default_value = "-1", + .description = "Support for setting gid of brick's owner", + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"node-uuid-pathinfo"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "return glusterd's node-uuid in pathinfo xattr" + " string instead of hostname", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"health-check-interval"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .default_value = "30", + .validate = GF_OPT_VALIDATE_MIN, + .description = "Interval in seconds for a filesystem health check, " + "set to 0 to disable", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"health-check-timeout"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .default_value = "10", + .validate = GF_OPT_VALIDATE_MIN, + .description = + "Interval in seconds to wait aio_write finish for health check, " + "set to 0 to disable", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"reserve"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .default_value = "1", + .validate = GF_OPT_VALIDATE_MIN, + .description = "Percentage of disk space to be reserved." + " Set to 0 to disable", + .op_version = {GD_OP_VERSION_3_13_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"batch-fsync-mode"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "reverse-fsync", + .description = + "Possible values:\n" + "\t- syncfs: Perform one syncfs() on behalf oa batch" + "of fsyncs.\n" + "\t- syncfs-single-fsync: Perform one syncfs() on behalf of a batch" + " of fsyncs and one fsync() per batch.\n" + "\t- syncfs-reverse-fsync: Perform one syncfs() on behalf of a batch" + " of fsyncs and fsync() each file in the batch in reverse order.\n" + " in reverse order.\n" + "\t- reverse-fsync: Perform fsync() of each file in the batch in" + " reverse order.", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"batch-fsync-delay-usec"}, + .type = GF_OPTION_TYPE_INT, + .default_value = "0", + .description = "Num of usecs to wait for aggregating fsync" + " requests", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"update-link-count-parent"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Enable placeholders for gfid to path conversion", + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, + {.key = {"gfid2path"}, + .type = GF_OPTION_TYPE_BOOL, #ifdef __NetBSD__ - /* - * NetBSD storage of extended attributes for UFS1 badly - * scales when the list of extended attributes names rises. - * This option can add as many extended attributes names - * as we have files, hence we keep it disabled for performance - * sake. - */ - .default_value = "off", + /* + * NetBSD storage of extended attributes for UFS1 badly + * scales when the list of extended attributes names rises. + * This option can add as many extended attributes names + * as we have files, hence we keep it disabled for performance + * sake. + */ + .default_value = "off", #else - .default_value = "on", + .default_value = "on", #endif - .description = "Enable logging metadata for gfid to path conversion", - .op_version = {GD_OP_VERSION_3_12_0}, - .flags = OPT_FLAG_SETTABLE - }, - { .key = {"gfid2path-separator"}, - .type = GF_OPTION_TYPE_STR, - .default_value = ":", - .description = "Path separator for glusterfs.gfidtopath virt xattr", - .op_version = {GD_OP_VERSION_3_12_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, + .description = "Enable logging metadata for gfid to path conversion", + .op_version = {GD_OP_VERSION_3_12_0}, + .flags = OPT_FLAG_SETTABLE}, + {.key = {"gfid2path-separator"}, + .type = GF_OPTION_TYPE_STR, + .default_value = ":", + .description = "Path separator for glusterfs.gfidtopath virt xattr", + .op_version = {GD_OP_VERSION_3_12_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, #if GF_DARWIN_HOST_OS - { .key = {"xattr-user-namespace-mode"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "none", - .description = "Option to control XATTR user namespace on the raw filesystem: " - "\t- None: Will use the user namespace, so files will be exchangeable with Linux.\n" - " The raw filesystem will not be compatible with OS X Finder.\n" - "\t- Strip: Will strip the user namespace before setting. The raw filesystem will work in OS X.\n", - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC - }, + {.key = {"xattr-user-namespace-mode"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "none", + .description = + "Option to control XATTR user namespace on the raw filesystem: " + "\t- None: Will use the user namespace, so files will be exchangeable " + "with Linux.\n" + " The raw filesystem will not be compatible with OS X Finder.\n" + "\t- Strip: Will strip the user namespace before setting. The raw " + "filesystem will work in OS X.\n", + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC}, #endif - { .key = {"shared-brick-count"}, - .type = GF_OPTION_TYPE_INT, - .default_value = "1", - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .description = "Number of bricks sharing the same backend export." - " Useful for displaying the proper usable size through statvfs() " - "call (df command)", - }, - { - .key = {"disable-landfill-purge"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Disable glusterfs/landfill purges. " - "WARNING: This can fill up a brick.", - .op_version = {GD_OP_VERSION_4_0_0}, - .tags = {"diagnosis"}, - }, - { .key = {"force-create-mode"}, - .type = GF_OPTION_TYPE_INT, - .min = 0000, - .max = 0777, - .default_value = "0000", - .validate = GF_OPT_VALIDATE_MIN, - .validate = GF_OPT_VALIDATE_MAX, - .description = "Mode bit permission that will always be set on a file." - }, - { .key = {"force-directory-mode"}, - .type = GF_OPTION_TYPE_INT, - .min = 0000, - .max = 0777, - .default_value = "0000", - .validate = GF_OPT_VALIDATE_MIN, - .validate = GF_OPT_VALIDATE_MAX, - .description = "Mode bit permission that will be always set on directory" - }, - { .key = {"create-mask"}, - .type = GF_OPTION_TYPE_INT, - .min = 0000, - .max = 0777, - .default_value = "0777", - .validate = GF_OPT_VALIDATE_MIN, - .validate = GF_OPT_VALIDATE_MAX, - .description = "Any bit not set here will be removed from the" - "modes set on a file when it is created" - }, - { .key = {"create-directory-mask"}, - .type = GF_OPTION_TYPE_INT, - .min = 0000, - .max = 0777, - .default_value = "0777", - .validate = GF_OPT_VALIDATE_MIN, - .validate = GF_OPT_VALIDATE_MAX, - .description = "Any bit not set here will be removed from the" - "modes set on a directory when it is created" - }, - { - .key = {"max-hardlinks"}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .default_value = "100", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"posix"}, - .validate = GF_OPT_VALIDATE_MIN, - .description = "max number of hardlinks allowed on any one inode.\n" - "0 is unlimited, 1 prevents any hardlinking at all." - }, - { - .key = {"fips-mode-rchecksum"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE, - .tags = {"posix"}, - .description = "If enabled, posix_rchecksum uses the FIPS compliant" - "SHA256 checksum. MD5 otherwise." - }, - { .key = {"ctime"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .op_version = { GD_OP_VERSION_4_1_0 }, - .tags = { "ctime" }, - .description = "When this option is enabled, time attributes (ctime,mtime,atime) " - "are stored in xattr to keep it consistent across replica and " - "distribute set. The time attributes stored at the backend are " - "not considered " - }, - { .key = {NULL} } -}; + { + .key = {"shared-brick-count"}, + .type = GF_OPTION_TYPE_INT, + .default_value = "1", + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .description = + "Number of bricks sharing the same backend export." + " Useful for displaying the proper usable size through statvfs() " + "call (df command)", + }, + { + .key = {"disable-landfill-purge"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Disable glusterfs/landfill purges. " + "WARNING: This can fill up a brick.", + .op_version = {GD_OP_VERSION_4_0_0}, + .tags = {"diagnosis"}, + }, + {.key = {"force-create-mode"}, + .type = GF_OPTION_TYPE_INT, + .min = 0000, + .max = 0777, + .default_value = "0000", + .validate = GF_OPT_VALIDATE_MIN, + .validate = GF_OPT_VALIDATE_MAX, + .description = "Mode bit permission that will always be set on a file."}, + {.key = {"force-directory-mode"}, + .type = GF_OPTION_TYPE_INT, + .min = 0000, + .max = 0777, + .default_value = "0000", + .validate = GF_OPT_VALIDATE_MIN, + .validate = GF_OPT_VALIDATE_MAX, + .description = "Mode bit permission that will be always set on directory"}, + {.key = {"create-mask"}, + .type = GF_OPTION_TYPE_INT, + .min = 0000, + .max = 0777, + .default_value = "0777", + .validate = GF_OPT_VALIDATE_MIN, + .validate = GF_OPT_VALIDATE_MAX, + .description = "Any bit not set here will be removed from the" + "modes set on a file when it is created"}, + {.key = {"create-directory-mask"}, + .type = GF_OPTION_TYPE_INT, + .min = 0000, + .max = 0777, + .default_value = "0777", + .validate = GF_OPT_VALIDATE_MIN, + .validate = GF_OPT_VALIDATE_MAX, + .description = "Any bit not set here will be removed from the" + "modes set on a directory when it is created"}, + {.key = {"max-hardlinks"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .default_value = "100", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"posix"}, + .validate = GF_OPT_VALIDATE_MIN, + .description = "max number of hardlinks allowed on any one inode.\n" + "0 is unlimited, 1 prevents any hardlinking at all."}, + {.key = {"fips-mode-rchecksum"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE, + .tags = {"posix"}, + .description = "If enabled, posix_rchecksum uses the FIPS compliant" + "SHA256 checksum. MD5 otherwise."}, + {.key = {"ctime"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .op_version = {GD_OP_VERSION_4_1_0}, + .tags = {"ctime"}, + .description = + "When this option is enabled, time attributes (ctime,mtime,atime) " + "are stored in xattr to keep it consistent across replica and " + "distribute set. The time attributes stored at the backend are " + "not considered "}, + {.key = {NULL}}}; diff --git a/xlators/storage/posix/src/posix-entry-ops.c b/xlators/storage/posix/src/posix-entry-ops.c index 34dff4bd726..1888de7db9b 100644 --- a/xlators/storage/posix/src/posix-entry-ops.c +++ b/xlators/storage/posix/src/posix-entry-ops.c @@ -69,17 +69,21 @@ extern char *marker_xattrs[]; #undef HAVE_SET_FSID #ifdef HAVE_SET_FSID -#define DECLARE_OLD_FS_ID_VAR uid_t old_fsuid; gid_t old_fsgid; - -#define SET_FS_ID(uid, gid) do { \ - old_fsuid = setfsuid (uid); \ - old_fsgid = setfsgid (gid); \ - } while (0) - -#define SET_TO_OLD_FS_ID() do { \ - setfsuid (old_fsuid); \ - setfsgid (old_fsgid); \ - } while (0) +#define DECLARE_OLD_FS_ID_VAR \ + uid_t old_fsuid; \ + gid_t old_fsgid; + +#define SET_FS_ID(uid, gid) \ + do { \ + old_fsuid = setfsuid(uid); \ + old_fsgid = setfsgid(gid); \ + } while (0) + +#define SET_TO_OLD_FS_ID() \ + do { \ + setfsuid(old_fsuid); \ + setfsgid(old_fsgid); \ + } while (0) #else @@ -90,2174 +94,2139 @@ extern char *marker_xattrs[]; #endif gf_boolean_t -posix_symlinks_match (xlator_t *this, loc_t *loc, uuid_t gfid) +posix_symlinks_match(xlator_t *this, loc_t *loc, uuid_t gfid) { - struct posix_private *priv = NULL; - char linkname_actual[PATH_MAX] = {0,}; - char linkname_expected[PATH_MAX] = {0}; - char *dir_handle = NULL; - ssize_t len = 0; - size_t handle_size = 0; - gf_boolean_t ret = _gf_false; - - priv = this->private; - handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); - dir_handle = alloca0 (handle_size); - - snprintf (linkname_expected, PATH_MAX, "../../%02x/%02x/%s/%s", - loc->pargfid[0], loc->pargfid[1], uuid_utoa (loc->pargfid), - loc->name); - - MAKE_HANDLE_GFID_PATH (dir_handle, this, gfid, NULL); - len = sys_readlink (dir_handle, linkname_actual, PATH_MAX); - if (len < 0 || len == PATH_MAX) { - if (len == PATH_MAX) { - errno = EINVAL; - } - - if (errno != ENOENT) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LSTAT_FAILED, "readlink[%s] failed", - dir_handle); - } - goto out; - } - linkname_actual[len] = '\0'; - - if (!strcmp (linkname_actual, linkname_expected)) - ret = _gf_true; + struct posix_private *priv = NULL; + char linkname_actual[PATH_MAX] = { + 0, + }; + char linkname_expected[PATH_MAX] = {0}; + char *dir_handle = NULL; + ssize_t len = 0; + size_t handle_size = 0; + gf_boolean_t ret = _gf_false; + + priv = this->private; + handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); + dir_handle = alloca0(handle_size); + + snprintf(linkname_expected, PATH_MAX, "../../%02x/%02x/%s/%s", + loc->pargfid[0], loc->pargfid[1], uuid_utoa(loc->pargfid), + loc->name); + + MAKE_HANDLE_GFID_PATH(dir_handle, this, gfid, NULL); + len = sys_readlink(dir_handle, linkname_actual, PATH_MAX); + if (len < 0 || len == PATH_MAX) { + if (len == PATH_MAX) { + errno = EINVAL; + } + + if (errno != ENOENT) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "readlink[%s] failed", dir_handle); + } + goto out; + } + linkname_actual[len] = '\0'; + + if (!strcmp(linkname_actual, linkname_expected)) + ret = _gf_true; out: - return ret; + return ret; } -dict_t* -posix_dict_set_nlink (dict_t *req, dict_t *res, int32_t nlink) +dict_t * +posix_dict_set_nlink(dict_t *req, dict_t *res, int32_t nlink) { - int ret = -1; + int ret = -1; - if (req == NULL || !dict_get (req, GF_REQUEST_LINK_COUNT_XDATA)) - goto out; + if (req == NULL || !dict_get(req, GF_REQUEST_LINK_COUNT_XDATA)) + goto out; - if (res == NULL) - res = dict_new (); - if (res == NULL) - goto out; + if (res == NULL) + res = dict_new(); + if (res == NULL) + goto out; - ret = dict_set_uint32 (res, GF_RESPONSE_LINK_COUNT_XDATA, nlink); - if (ret == -1) - gf_msg ("posix", GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, - "Failed to set GF_RESPONSE_LINK_COUNT_XDATA"); + ret = dict_set_uint32(res, GF_RESPONSE_LINK_COUNT_XDATA, nlink); + if (ret == -1) + gf_msg("posix", GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, + "Failed to set GF_RESPONSE_LINK_COUNT_XDATA"); out: - return res; + return res; } /* Regular fops */ int32_t -posix_lookup (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xdata) +posix_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - struct iatt buf = {0, }; - int32_t op_ret = -1; - int32_t entry_ret = 0; - int32_t op_errno = 0; - dict_t * xattr = NULL; - char * real_path = NULL; - char * par_path = NULL; - char *gfid_path = NULL; - uuid_t gfid = {0}; - struct iatt postparent = {0,}; - struct stat statbuf = {0}; - int32_t gfidless = 0; - char *pgfid_xattr_key = NULL; - int32_t nlink_samepgfid = 0; - struct posix_private *priv = NULL; - posix_inode_ctx_t *ctx = NULL; - int ret = 0; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (this->private, out); - - priv = this->private; - - /* The Hidden directory should be for housekeeping purpose and it - should not get any gfid on it */ - if (__is_root_gfid (loc->pargfid) && loc->name - && (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { - gf_msg (this->name, GF_LOG_WARNING, EPERM, - P_MSG_LOOKUP_NOT_PERMITTED, "Lookup issued on %s," - " which is not permitted", GF_HIDDEN_PATH); - op_errno = EPERM; + struct iatt buf = { + 0, + }; + int32_t op_ret = -1; + int32_t entry_ret = 0; + int32_t op_errno = 0; + dict_t *xattr = NULL; + char *real_path = NULL; + char *par_path = NULL; + char *gfid_path = NULL; + uuid_t gfid = {0}; + struct iatt postparent = { + 0, + }; + struct stat statbuf = {0}; + int32_t gfidless = 0; + char *pgfid_xattr_key = NULL; + int32_t nlink_samepgfid = 0; + struct posix_private *priv = NULL; + posix_inode_ctx_t *ctx = NULL; + int ret = 0; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(this->private, out); + + priv = this->private; + + /* The Hidden directory should be for housekeeping purpose and it + should not get any gfid on it */ + if (__is_root_gfid(loc->pargfid) && loc->name && + (strcmp(loc->name, GF_HIDDEN_PATH) == 0)) { + gf_msg(this->name, GF_LOG_WARNING, EPERM, P_MSG_LOOKUP_NOT_PERMITTED, + "Lookup issued on %s," + " which is not permitted", + GF_HIDDEN_PATH); + op_errno = EPERM; + op_ret = -1; + goto out; + } + + op_ret = dict_get_int32(xdata, GF_GFIDLESS_LOOKUP, &gfidless); + op_ret = -1; + if (gf_uuid_is_null(loc->pargfid) || (loc->name == NULL)) { + /* nameless lookup */ + MAKE_INODE_HANDLE(real_path, this, loc, &buf); + } else { + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &buf); + + if (gf_uuid_is_null(loc->inode->gfid)) { + op_ret = posix_gfid_heal(this, real_path, loc, xdata); + if (op_ret < 0) { + op_errno = -op_ret; op_ret = -1; goto out; + } + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &buf); } + } - op_ret = dict_get_int32 (xdata, GF_GFIDLESS_LOOKUP, &gfidless); - op_ret = -1; - if (gf_uuid_is_null (loc->pargfid) || (loc->name == NULL)) { - /* nameless lookup */ - MAKE_INODE_HANDLE (real_path, this, loc, &buf); - } else { - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &buf); - - if (gf_uuid_is_null (loc->inode->gfid)) { - op_ret = posix_gfid_heal (this, real_path, loc, xdata); - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - goto out; - } - MAKE_ENTRY_HANDLE (real_path, par_path, this, - loc, &buf); - } - } - - op_errno = errno; - - if (op_ret == -1) { - if (op_errno != ENOENT) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_LSTAT_FAILED, - "lstat on %s failed", - real_path ? real_path : "null"); - } - entry_ret = -1; - if (loc_is_nameless(loc)) { - if (!op_errno) - op_errno = ESTALE; - loc_gfid (loc, gfid); - MAKE_HANDLE_ABSPATH (gfid_path, this, gfid); - ret = sys_stat(gfid_path, &statbuf); - if (ret == 0 && ((statbuf.st_mode & S_IFMT) == S_IFDIR)) - /*Don't unset if it was a symlink to a dir.*/ - goto parent; - ret = sys_lstat(gfid_path, &statbuf); - if (ret == 0 && statbuf.st_nlink == 1) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_HANDLE_DELETE, "Found stale gfid " - "handle %s, removing it.", gfid_path); - posix_handle_unset (this, gfid, NULL); - } - } - goto parent; - } + op_errno = errno; - if (xdata && (op_ret == 0)) { - xattr = posix_xattr_fill (this, real_path, loc, NULL, -1, xdata, - &buf); - - posix_cs_maintenance (this, NULL, loc, NULL, &buf, real_path, - xdata, &xattr, _gf_true); - - if (dict_get (xdata, GF_CLEAN_WRITE_PROTECTION)) { - ret = sys_lremovexattr (real_path, - GF_PROTECT_FROM_EXTERNAL_WRITES); - if (ret == -1 && (errno != ENODATA && errno != ENOATTR)) - gf_msg (this->name, GF_LOG_ERROR, - P_MSG_XATTR_NOT_REMOVED, errno, - "removexattr failed. key %s path %s", - GF_PROTECT_FROM_EXTERNAL_WRITES, - loc->path); - } + if (op_ret == -1) { + if (op_errno != ENOENT) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_path ? real_path : "null"); } + entry_ret = -1; + if (loc_is_nameless(loc)) { + if (!op_errno) + op_errno = ESTALE; + loc_gfid(loc, gfid); + MAKE_HANDLE_ABSPATH(gfid_path, this, gfid); + ret = sys_stat(gfid_path, &statbuf); + if (ret == 0 && ((statbuf.st_mode & S_IFMT) == S_IFDIR)) + /*Don't unset if it was a symlink to a dir.*/ + goto parent; + ret = sys_lstat(gfid_path, &statbuf); + if (ret == 0 && statbuf.st_nlink == 1) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, + P_MSG_HANDLE_DELETE, + "Found stale gfid " + "handle %s, removing it.", + gfid_path); + posix_handle_unset(this, gfid, NULL); + } + } + goto parent; + } + + if (xdata && (op_ret == 0)) { + xattr = posix_xattr_fill(this, real_path, loc, NULL, -1, xdata, &buf); + + posix_cs_maintenance(this, NULL, loc, NULL, &buf, real_path, xdata, + &xattr, _gf_true); + + if (dict_get(xdata, GF_CLEAN_WRITE_PROTECTION)) { + ret = sys_lremovexattr(real_path, GF_PROTECT_FROM_EXTERNAL_WRITES); + if (ret == -1 && (errno != ENODATA && errno != ENOATTR)) + gf_msg(this->name, GF_LOG_ERROR, P_MSG_XATTR_NOT_REMOVED, errno, + "removexattr failed. key %s path %s", + GF_PROTECT_FROM_EXTERNAL_WRITES, loc->path); + } + } + + if (priv->update_pgfid_nlinks) { + if (!gf_uuid_is_null(loc->pargfid) && !IA_ISDIR(buf.ia_type)) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + loc->pargfid); + + op_ret = posix_inode_ctx_get_all(loc->inode, this, &ctx); + if (op_ret < 0) { + op_errno = ENOMEM; + goto out; + } - if (priv->update_pgfid_nlinks) { - if (!gf_uuid_is_null (loc->pargfid) && !IA_ISDIR (buf.ia_type)) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, - PGFID_XATTR_KEY_PREFIX, - loc->pargfid); - - op_ret = posix_inode_ctx_get_all (loc->inode, this, - &ctx); - if (op_ret < 0) { - op_errno = ENOMEM; - goto out; - } - - pthread_mutex_lock (&ctx->pgfid_lock); - { - SET_PGFID_XATTR_IF_ABSENT (real_path, - pgfid_xattr_key, - nlink_samepgfid, - XATTR_CREATE, op_ret, - this, unlock); - } -unlock: - pthread_mutex_unlock (&ctx->pgfid_lock); - } + pthread_mutex_lock(&ctx->pgfid_lock); + { + SET_PGFID_XATTR_IF_ABSENT(real_path, pgfid_xattr_key, + nlink_samepgfid, XATTR_CREATE, op_ret, + this, unlock); + } + unlock: + pthread_mutex_unlock(&ctx->pgfid_lock); } + } parent: - if (par_path) { - op_ret = posix_pstat (this, loc->parent, loc->pargfid, - par_path, &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LSTAT_FAILED, "post-operation lstat on" - " parent %s failed", par_path); - if (op_errno == ENOENT) - /* If parent directory is missing in a lookup, - errno should be ESTALE (bad handle) and not - ENOENT (missing entry) - */ - op_errno = ESTALE; - goto out; - } + if (par_path) { + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, + &postparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on" + " parent %s failed", + par_path); + if (op_errno == ENOENT) + /* If parent directory is missing in a lookup, + errno should be ESTALE (bad handle) and not + ENOENT (missing entry) + */ + op_errno = ESTALE; + goto out; } + } - op_ret = entry_ret; + op_ret = entry_ret; out: - if (!op_ret && !gfidless && gf_uuid_is_null (buf.ia_gfid)) { - gf_msg (this->name, GF_LOG_ERROR, ENODATA, P_MSG_NULL_GFID, - "buf->ia_gfid is null for " - "%s", (real_path) ? real_path: ""); - op_ret = -1; - op_errno = ENODATA; - } + if (!op_ret && !gfidless && gf_uuid_is_null(buf.ia_gfid)) { + gf_msg(this->name, GF_LOG_ERROR, ENODATA, P_MSG_NULL_GFID, + "buf->ia_gfid is null for " + "%s", + (real_path) ? real_path : ""); + op_ret = -1; + op_errno = ENODATA; + } - if (op_ret == 0) - op_errno = 0; - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, - (loc)?loc->inode:NULL, &buf, xattr, &postparent); + if (op_ret == 0) + op_errno = 0; + STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, + (loc) ? loc->inode : NULL, &buf, xattr, &postparent); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - return 0; + return 0; } int -posix_mknod (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) +posix_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t dev, mode_t umask, dict_t *xdata) { - int tmp_fd = 0; - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = 0; - char *par_path = 0; - struct iatt stbuf = { 0, }; - struct posix_private *priv = NULL; - gid_t gid = 0; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - uuid_t uuid_req = {0,}; - int32_t nlink_samepgfid = 0; - char *pgfid_xattr_key = NULL; - gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; - gf_boolean_t linked = _gf_false; - gf_loglevel_t level = GF_LOG_NONE; - mode_t mode_bit = 0; - posix_inode_ctx_t *ctx = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - GFID_NULL_CHECK_AND_GOTO (frame, this, loc, xdata, op_ret, op_errno, - out); - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, NULL); - - mode_bit = (priv->create_mask & mode) | priv->force_create_mode; - mode = posix_override_umask (mode, mode_bit); - - gid = frame->root->gid; - - SET_FS_ID (frame->root->uid, gid); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent of %s failed", - real_path); - goto out; - } + int tmp_fd = 0; + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = 0; + char *par_path = 0; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + gid_t gid = 0; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + uuid_t uuid_req = { + 0, + }; + int32_t nlink_samepgfid = 0; + char *pgfid_xattr_key = NULL; + gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; + gf_boolean_t linked = _gf_false; + gf_loglevel_t level = GF_LOG_NONE; + mode_t mode_bit = 0; + posix_inode_ctx_t *ctx = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + GFID_NULL_CHECK_AND_GOTO(frame, this, loc, xdata, op_ret, op_errno, out); + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, NULL); + + mode_bit = (priv->create_mask & mode) | priv->force_create_mode; + mode = posix_override_umask(mode, mode_bit); + + gid = frame->root->gid; + + SET_FS_ID(frame->root->uid, gid); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - if (preparent.ia_prot.sgid) { - gid = preparent.ia_gid; + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent of %s failed", real_path); + goto out; + } + + if (preparent.ia_prot.sgid) { + gid = preparent.ia_gid; + } + + /* Check if the 'gfid' already exists, because this mknod may be an + internal call from distribute for creating 'linkfile', and that + linkfile may be for a hardlinked file */ + if (dict_get(xdata, GLUSTERFS_INTERNAL_FOP_KEY)) { + dict_del(xdata, GLUSTERFS_INTERNAL_FOP_KEY); + op_ret = dict_get_gfuuid(xdata, "gfid-req", &uuid_req); + if (op_ret) { + gf_msg_debug(this->name, 0, + "failed to get the gfid from " + "dict for %s", + loc->path); + goto real_op; } - - /* Check if the 'gfid' already exists, because this mknod may be an - internal call from distribute for creating 'linkfile', and that - linkfile may be for a hardlinked file */ - if (dict_get (xdata, GLUSTERFS_INTERNAL_FOP_KEY)) { - dict_del (xdata, GLUSTERFS_INTERNAL_FOP_KEY); - op_ret = dict_get_gfuuid (xdata, "gfid-req", &uuid_req); - if (op_ret) { - gf_msg_debug (this->name, 0, "failed to get the gfid from " - "dict for %s", loc->path); - goto real_op; - } - op_ret = posix_create_link_if_gfid_exists (this, uuid_req, - real_path, - loc->inode->table); - if (!op_ret) { - linked = _gf_true; - goto post_op; - } + op_ret = posix_create_link_if_gfid_exists(this, uuid_req, real_path, + loc->inode->table); + if (!op_ret) { + linked = _gf_true; + goto post_op; } + } real_op: #ifdef __NetBSD__ - if (S_ISFIFO(mode)) - op_ret = mkfifo (real_path, mode); - else + if (S_ISFIFO(mode)) + op_ret = mkfifo(real_path, mode); + else #endif /* __NetBSD__ */ - op_ret = sys_mknod (real_path, mode, dev); + op_ret = sys_mknod(real_path, mode, dev); - if (op_ret == -1) { - op_errno = errno; - if ((op_errno == EINVAL) && S_ISREG (mode)) { - /* Over Darwin, mknod with (S_IFREG|mode) - doesn't work */ - tmp_fd = sys_creat (real_path, mode); - if (tmp_fd == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_CREATE_FAILED, "create failed on" - "%s", real_path); - goto out; - } - sys_close (tmp_fd); - } else { - if (op_errno == EEXIST) - level = GF_LOG_DEBUG; - else - level = GF_LOG_ERROR; - gf_msg (this->name, level, errno, P_MSG_MKNOD_FAILED, - "mknod on %s failed", real_path); - goto out; - } + if (op_ret == -1) { + op_errno = errno; + if ((op_errno == EINVAL) && S_ISREG(mode)) { + /* Over Darwin, mknod with (S_IFREG|mode) + doesn't work */ + tmp_fd = sys_creat(real_path, mode); + if (tmp_fd == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CREATE_FAILED, + "create failed on" + "%s", + real_path); + goto out; + } + sys_close(tmp_fd); + } else { + if (op_errno == EEXIST) + level = GF_LOG_DEBUG; + else + level = GF_LOG_ERROR; + gf_msg(this->name, level, errno, P_MSG_MKNOD_FAILED, + "mknod on %s failed", real_path); + goto out; } + } - entry_created = _gf_true; + entry_created = _gf_true; #ifndef HAVE_SET_FSID - op_ret = sys_lchown (real_path, frame->root->uid, gid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LCHOWN_FAILED, - "lchown on %s failed", real_path); - goto out; - } + op_ret = sys_lchown(real_path, frame->root->uid, gid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LCHOWN_FAILED, + "lchown on %s failed", real_path); + goto out; + } #endif post_op: - op_ret = posix_acl_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_ACL_FAILED, - "setting ACLs on %s failed", real_path); - } - - if (priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, - loc->pargfid); - op_ret = posix_inode_ctx_get_all (loc->inode, this, &ctx); - if (op_ret < 0) { - op_errno = ENOMEM; - goto out; - } - - pthread_mutex_lock (&ctx->pgfid_lock); - { - LINK_MODIFY_PGFID_XATTR (real_path, pgfid_xattr_key, - nlink_samepgfid, 0, op_ret, - this, unlock); - } -unlock: - pthread_mutex_unlock (&ctx->pgfid_lock); + op_ret = posix_acl_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_ACL_FAILED, + "setting ACLs on %s failed", real_path); + } + + if (priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + loc->pargfid); + op_ret = posix_inode_ctx_get_all(loc->inode, this, &ctx); + if (op_ret < 0) { + op_errno = ENOMEM; + goto out; } - if (priv->gfid2path) { - posix_set_gfid2path_xattr (this, real_path, loc->pargfid, - loc->name); - } + pthread_mutex_lock(&ctx->pgfid_lock); + { + LINK_MODIFY_PGFID_XATTR(real_path, pgfid_xattr_key, nlink_samepgfid, + 0, op_ret, this, unlock); + } + unlock: + pthread_mutex_unlock(&ctx->pgfid_lock); + } + + if (priv->gfid2path) { + posix_set_gfid2path_xattr(this, real_path, loc->pargfid, loc->name); + } + + op_ret = posix_entry_create_xattr_set(this, real_path, xdata); + if (op_ret) { + if (errno != EEXIST) + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setting xattrs on %s failed", real_path); + else + gf_msg_debug(this->name, 0, "setting xattrs on %s failed", + real_path); + } - op_ret = posix_entry_create_xattr_set (this, real_path, xdata); + if (!linked) { + op_ret = posix_gfid_set(this, real_path, loc, xdata, frame->root->pid, + &op_errno); if (op_ret) { - if (errno != EEXIST) - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, - "setting xattrs on %s failed", real_path); - else - gf_msg_debug (this->name, 0, - "setting xattrs on %s failed", real_path); - } - - if (!linked) { - op_ret = posix_gfid_set (this, real_path, loc, xdata, - frame->root->pid, &op_errno); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_GFID_FAILED, "setting gfid on %s failed", - real_path); - goto out; - } else { - gfid_set = _gf_true; - } + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, + "setting gfid on %s failed", real_path); + goto out; + } else { + gfid_set = _gf_true; } + } - op_ret = posix_pstat (this, loc->inode, NULL, real_path, &stbuf, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_MKNOD_FAILED, - "mknod on %s failed", real_path); - goto out; - } + op_ret = posix_pstat(this, loc->inode, NULL, real_path, &stbuf, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_MKNOD_FAILED, + "mknod on %s failed", real_path); + goto out; + } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &stbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &stbuf); - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_path); - goto out; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - if (op_ret < 0) { - if (entry_created) { - if (S_ISREG (mode)) - sys_unlink (real_path); - else - sys_rmdir (real_path); - } - - if (gfid_set) - posix_gfid_unset (this, xdata); + if (op_ret < 0) { + if (entry_created) { + if (S_ISREG(mode)) + sys_unlink(real_path); + else + sys_rmdir(real_path); } - STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, - (loc)?loc->inode:NULL, &stbuf, &preparent, - &postparent, NULL); + if (gfid_set) + posix_gfid_unset(this, xdata); + } - return 0; + STACK_UNWIND_STRICT(mknod, frame, op_ret, op_errno, + (loc) ? loc->inode : NULL, &stbuf, &preparent, + &postparent, NULL); + + return 0; } int -posix_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) +posix_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = NULL, *gfid_path = NULL; - char *par_path = NULL, *xattr_name = NULL; - struct iatt stbuf = {0, }; - struct posix_private *priv = NULL; - gid_t gid = 0; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; - uuid_t uuid_req = {0,}; - ssize_t size = 0; - dict_t *xdata_rsp = NULL; - void *disk_xattr = NULL; - data_t *arg_data = NULL; - char pgfid[GF_UUID_BUF_SIZE] = {0}; - char value_buf[4096] = {0,}; - gf_boolean_t have_val = _gf_false; - mode_t mode_bit = 0; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - /* The Hidden directory should be for housekeeping purpose and it - should not get created from a user request */ - if (__is_root_gfid (loc->pargfid) && - (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { - gf_msg (this->name, GF_LOG_WARNING, EPERM, - P_MSG_MKDIR_NOT_PERMITTED, "mkdir issued on %s, which" - "is not permitted", GF_HIDDEN_PATH); - op_errno = EPERM; - op_ret = -1; - goto out; - } - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - GFID_NULL_CHECK_AND_GOTO (frame, this, loc, xdata, op_ret, op_errno, - out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, NULL); - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - if (loc->parent) - gf_uuid_unparse (loc->parent->gfid, pgfid); - else - gf_uuid_unparse (loc->pargfid, pgfid); - - gid = frame->root->gid; - - op_ret = posix_pstat (this, loc->inode, NULL, real_path, &stbuf, _gf_false); - - SET_FS_ID (frame->root->uid, gid); + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL, *gfid_path = NULL; + char *par_path = NULL, *xattr_name = NULL; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + gid_t gid = 0; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; + uuid_t uuid_req = { + 0, + }; + ssize_t size = 0; + dict_t *xdata_rsp = NULL; + void *disk_xattr = NULL; + data_t *arg_data = NULL; + char pgfid[GF_UUID_BUF_SIZE] = {0}; + char value_buf[4096] = { + 0, + }; + gf_boolean_t have_val = _gf_false; + mode_t mode_bit = 0; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + + /* The Hidden directory should be for housekeeping purpose and it + should not get created from a user request */ + if (__is_root_gfid(loc->pargfid) && + (strcmp(loc->name, GF_HIDDEN_PATH) == 0)) { + gf_msg(this->name, GF_LOG_WARNING, EPERM, P_MSG_MKDIR_NOT_PERMITTED, + "mkdir issued on %s, which" + "is not permitted", + GF_HIDDEN_PATH); + op_errno = EPERM; + op_ret = -1; + goto out; + } - mode_bit = (priv->create_directory_mask & mode) - | priv->force_directory_mode; - mode = posix_override_umask (mode, mode_bit); + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + GFID_NULL_CHECK_AND_GOTO(frame, this, loc, xdata, op_ret, op_errno, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); - if (xdata) { - op_ret = dict_get_gfuuid (xdata, "gfid-req", &uuid_req); - if (!op_ret && !gf_uuid_compare (stbuf.ia_gfid, uuid_req)) { - op_ret = -1; - op_errno = EEXIST; - goto out; + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, NULL); + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } + + if (loc->parent) + gf_uuid_unparse(loc->parent->gfid, pgfid); + else + gf_uuid_unparse(loc->pargfid, pgfid); + + gid = frame->root->gid; + + op_ret = posix_pstat(this, loc->inode, NULL, real_path, &stbuf, _gf_false); + + SET_FS_ID(frame->root->uid, gid); + + mode_bit = (priv->create_directory_mask & mode) | + priv->force_directory_mode; + mode = posix_override_umask(mode, mode_bit); + + if (xdata) { + op_ret = dict_get_gfuuid(xdata, "gfid-req", &uuid_req); + if (!op_ret && !gf_uuid_compare(stbuf.ia_gfid, uuid_req)) { + op_ret = -1; + op_errno = EEXIST; + goto out; + } + } + + if (!gf_uuid_is_null(uuid_req)) { + op_ret = posix_istat(this, loc->inode, uuid_req, NULL, &stbuf); + if ((op_ret == 0) && IA_ISDIR(stbuf.ia_type)) { + size = posix_handle_path(this, uuid_req, NULL, NULL, 0); + if (size > 0) + gfid_path = alloca(size); + + if (gfid_path) + posix_handle_path(this, uuid_req, NULL, gfid_path, size); + + if (frame->root->pid != GF_CLIENT_PID_SELF_HEALD) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DIR_OF_SAME_ID, + "mkdir (%s): " + "gfid (%s) is already associated with " + "directory (%s). Hence, both " + "directories will share same gfid and " + "this can lead to inconsistencies.", + loc->path, uuid_utoa(uuid_req), + gfid_path ? gfid_path : "<NULL>"); + + gf_event(EVENT_POSIX_SAME_GFID, + "gfid=%s;" + "path=%s;newpath=%s;brick=%s:%s", + uuid_utoa(uuid_req), gfid_path ? gfid_path : "<NULL>", + loc->path, priv->hostname, priv->base_path); + } + if (!posix_symlinks_match(this, loc, uuid_req)) + /* For afr selfheal of dir renames, we need to + * remove the old symlink in order for + * posix_gfid_set to set the symlink to the + * new dir.*/ + posix_handle_unset(this, stbuf.ia_gfid, NULL); + } + } else if (frame->root->pid != GF_SERVER_PID_TRASH) { + op_ret = -1; + op_errno = EPERM; + gf_msg_callingfn(this->name, GF_LOG_WARNING, op_errno, P_MSG_NULL_GFID, + "mkdir (%s): is issued without " + "gfid-req %p", + loc->path, xdata); + goto out; + } + + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } + + if (preparent.ia_prot.sgid) { + gid = preparent.ia_gid; + mode |= S_ISGID; + } + + op_ret = dict_get_str(xdata, GF_PREOP_PARENT_KEY, &xattr_name); + if (xattr_name != NULL) { + arg_data = dict_get(xdata, xattr_name); + if (arg_data) { + size = sys_lgetxattr(par_path, xattr_name, value_buf, + sizeof(value_buf) - 1); + if (size >= 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, + P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): getxattr on key " + "(%s) path (%s) failed due to " + " buffer overflow", + pgfid, loc->name, xattr_name, par_path); + size = sys_lgetxattr(par_path, xattr_name, NULL, 0); } - } - - if (!gf_uuid_is_null (uuid_req)) { - op_ret = posix_istat (this, loc->inode, uuid_req, NULL, &stbuf); - if ((op_ret == 0) && IA_ISDIR (stbuf.ia_type)) { - size = posix_handle_path (this, uuid_req, NULL, NULL, - 0); - if (size > 0) - gfid_path = alloca (size); - - if (gfid_path) - posix_handle_path (this, uuid_req, NULL, - gfid_path, size); - - if (frame->root->pid != GF_CLIENT_PID_SELF_HEALD) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DIR_OF_SAME_ID, "mkdir (%s): " - "gfid (%s) is already associated with " - "directory (%s). Hence, both " - "directories will share same gfid and " - "this can lead to inconsistencies.", - loc->path, uuid_utoa (uuid_req), - gfid_path ? gfid_path : "<NULL>"); - - gf_event (EVENT_POSIX_SAME_GFID, "gfid=%s;" - "path=%s;newpath=%s;brick=%s:%s", - uuid_utoa (uuid_req), - gfid_path ? gfid_path : "<NULL>", - loc->path, priv->hostname, - priv->base_path); - } - if (!posix_symlinks_match (this, loc, uuid_req)) - /* For afr selfheal of dir renames, we need to - * remove the old symlink in order for - * posix_gfid_set to set the symlink to the - * new dir.*/ - posix_handle_unset (this, stbuf.ia_gfid, NULL); + if (size < 0) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): getxattr on key (%s)" + " path (%s) failed ", + pgfid, loc->name, xattr_name, par_path); + goto out; } - } else if (frame->root->pid != GF_SERVER_PID_TRASH) { + } + disk_xattr = alloca(size); + if (disk_xattr == NULL) { op_ret = -1; - op_errno = EPERM; - gf_msg_callingfn (this->name, GF_LOG_WARNING, op_errno, - P_MSG_NULL_GFID, "mkdir (%s): is issued without " - "gfid-req %p", loc->path, xdata); - goto out; - } - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): alloca failed during" + " preop of mkdir (%s)", + pgfid, loc->name, real_path); + goto out; + } + if (have_val) { + memcpy(disk_xattr, value_buf, size); + } else { + size = sys_lgetxattr(par_path, xattr_name, disk_xattr, size); + if (size < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): getxattr on " + " key (%s) path (%s) failed " + "(%s)", + pgfid, loc->name, xattr_name, par_path, + strerror(errno)); + goto out; + } + } + if ((arg_data->len != size) || + (memcmp(arg_data->data, disk_xattr, size))) { + gf_msg(this->name, GF_LOG_INFO, EIO, P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): failing preop of " + "mkdir (%s) as on-disk" + " xattr value differs from argument " + "value for key %s", + pgfid, loc->name, real_path, xattr_name); + op_ret = -1; + op_errno = EIO; + + xdata_rsp = dict_new(); + if (xdata_rsp == NULL) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, + P_MSG_PREOP_CHECK_FAILED, + "mkdir (%s/%s): " + "dict allocation failed", + pgfid, loc->name); + op_errno = ENOMEM; + goto out; + } + + op_errno = dict_set_int8(xdata_rsp, GF_PREOP_CHECK_FAILED, 1); goto out; - } + } - if (preparent.ia_prot.sgid) { - gid = preparent.ia_gid; - mode |= S_ISGID; + dict_del(xdata, xattr_name); } - op_ret = dict_get_str (xdata, GF_PREOP_PARENT_KEY, &xattr_name); - if (xattr_name != NULL) { - arg_data = dict_get (xdata, xattr_name); - if (arg_data) { - size = sys_lgetxattr (par_path, xattr_name, value_buf, - sizeof(value_buf) - 1); - if (size >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): getxattr on key " - "(%s) path (%s) failed due to " - " buffer overflow", pgfid, - loc->name, xattr_name, - par_path); - size = sys_lgetxattr (par_path, - xattr_name, NULL, - 0); - } - if (size < 0) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): getxattr on key (%s)" - " path (%s) failed ", pgfid, - loc->name, xattr_name, - par_path); - goto out; - } - } - disk_xattr = alloca (size); - if (disk_xattr == NULL) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): alloca failed during" - " preop of mkdir (%s)", pgfid, - loc->name, real_path); - goto out; - } - if (have_val) { - memcpy (disk_xattr, value_buf, size); - } else { - size = sys_lgetxattr (par_path, xattr_name, - disk_xattr, size); - if (size < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): getxattr on " - " key (%s) path (%s) failed " - "(%s)", pgfid, loc->name, - xattr_name, par_path, - strerror (errno)); - goto out; - } - } - if ((arg_data->len != size) - || (memcmp (arg_data->data, disk_xattr, size))) { - gf_msg (this->name, GF_LOG_INFO, EIO, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): failing preop of " - "mkdir (%s) as on-disk" - " xattr value differs from argument " - "value for key %s", pgfid, loc->name, - real_path, xattr_name); - op_ret = -1; - op_errno = EIO; - - xdata_rsp = dict_new (); - if (xdata_rsp == NULL) { - gf_msg (this->name, GF_LOG_ERROR, - ENOMEM, - P_MSG_PREOP_CHECK_FAILED, - "mkdir (%s/%s): " - "dict allocation failed", pgfid, - loc->name); - op_errno = ENOMEM; - goto out; - } - - op_errno = dict_set_int8 (xdata_rsp, - GF_PREOP_CHECK_FAILED, 1); - goto out; - } - - dict_del (xdata, xattr_name); - } - - dict_del (xdata, GF_PREOP_PARENT_KEY); - } + dict_del(xdata, GF_PREOP_PARENT_KEY); + } - op_ret = sys_mkdir (real_path, mode); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_MKDIR_FAILED, - "mkdir of %s failed", real_path); - goto out; - } + op_ret = sys_mkdir(real_path, mode); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_MKDIR_FAILED, + "mkdir of %s failed", real_path); + goto out; + } - entry_created = _gf_true; + entry_created = _gf_true; #ifndef HAVE_SET_FSID - op_ret = sys_chown (real_path, frame->root->uid, gid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_CHOWN_FAILED, - "chown on %s failed", real_path); - goto out; - } + op_ret = sys_chown(real_path, frame->root->uid, gid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CHOWN_FAILED, + "chown on %s failed", real_path); + goto out; + } #endif - op_ret = posix_acl_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, - "setting ACLs on %s failed ", real_path); - } - - op_ret = posix_entry_create_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, - "setting xattrs on %s failed", real_path); - } - - op_ret = posix_gfid_set (this, real_path, loc, xdata, frame->root->pid, - &op_errno); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, - "setting gfid on %s failed", real_path); - goto out; - } else { - gfid_set = _gf_true; - } - - op_ret = posix_pstat (this, loc->inode, NULL, real_path, &stbuf, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat on %s failed", real_path); - goto out; - } + op_ret = posix_acl_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, + "setting ACLs on %s failed ", real_path); + } + + op_ret = posix_entry_create_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setting xattrs on %s failed", real_path); + } + + op_ret = posix_gfid_set(this, real_path, loc, xdata, frame->root->pid, + &op_errno); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, + "setting gfid on %s failed", real_path); + goto out; + } else { + gfid_set = _gf_true; + } + + op_ret = posix_pstat(this, loc->inode, NULL, real_path, &stbuf, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_path); + goto out; + } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &stbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &stbuf); - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent of %s failed", - real_path); - goto out; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent of %s failed", real_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - if (op_ret < 0) { - if (entry_created) - sys_rmdir (real_path); + if (op_ret < 0) { + if (entry_created) + sys_rmdir(real_path); - if (gfid_set) - posix_gfid_unset (this, xdata); - } + if (gfid_set) + posix_gfid_unset(this, xdata); + } - STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, - (loc)?loc->inode:NULL, &stbuf, &preparent, - &postparent, xdata_rsp); + STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, + (loc) ? loc->inode : NULL, &stbuf, &preparent, + &postparent, xdata_rsp); - if (xdata_rsp) - dict_unref (xdata_rsp); + if (xdata_rsp) + dict_unref(xdata_rsp); - return 0; + return 0; } int -posix_add_unlink_to_ctx (inode_t *inode, xlator_t *this, char *unlink_path) +posix_add_unlink_to_ctx(inode_t *inode, xlator_t *this, char *unlink_path) { - uint64_t ctx = GF_UNLINK_FALSE; - int ret = 0; - - if (!unlink_path) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - P_MSG_UNLINK_FAILED, - "Creation of unlink entry failed for gfid: %s", - unlink_path); - ret = -1; - goto out; - } - - ctx = GF_UNLINK_TRUE; - ret = posix_inode_ctx_set_unlink_flag (inode, this, ctx); - if (ret < 0) { - goto out; - } + uint64_t ctx = GF_UNLINK_FALSE; + int ret = 0; + + if (!unlink_path) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, P_MSG_UNLINK_FAILED, + "Creation of unlink entry failed for gfid: %s", unlink_path); + ret = -1; + goto out; + } + + ctx = GF_UNLINK_TRUE; + ret = posix_inode_ctx_set_unlink_flag(inode, this, ctx); + if (ret < 0) { + goto out; + } out: - return ret; + return ret; } int32_t -posix_move_gfid_to_unlink (xlator_t *this, uuid_t gfid, loc_t *loc) +posix_move_gfid_to_unlink(xlator_t *this, uuid_t gfid, loc_t *loc) { - char *unlink_path = NULL; - char *gfid_path = NULL; - int ret = 0; - struct posix_private *priv_posix = NULL; - - priv_posix = (struct posix_private *) this->private; - - MAKE_HANDLE_GFID_PATH (gfid_path, this, gfid, NULL); - - POSIX_GET_FILE_UNLINK_PATH (priv_posix->base_path, - loc->inode->gfid, unlink_path); - if (!unlink_path) { - ret = -1; - goto out; - } - gf_msg_debug (this->name, 0, - "Moving gfid: %s to unlink_path : %s", - gfid_path, unlink_path); - ret = sys_rename (gfid_path, unlink_path); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_UNLINK_FAILED, - "Creation of unlink entry failed for gfid: %s", - unlink_path); - goto out; - } - ret = posix_add_unlink_to_ctx (loc->inode, this, unlink_path); - if (ret < 0) - goto out; + char *unlink_path = NULL; + char *gfid_path = NULL; + int ret = 0; + struct posix_private *priv_posix = NULL; + + priv_posix = (struct posix_private *)this->private; + + MAKE_HANDLE_GFID_PATH(gfid_path, this, gfid, NULL); + + POSIX_GET_FILE_UNLINK_PATH(priv_posix->base_path, loc->inode->gfid, + unlink_path); + if (!unlink_path) { + ret = -1; + goto out; + } + gf_msg_debug(this->name, 0, "Moving gfid: %s to unlink_path : %s", + gfid_path, unlink_path); + ret = sys_rename(gfid_path, unlink_path); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_UNLINK_FAILED, + "Creation of unlink entry failed for gfid: %s", unlink_path); + goto out; + } + ret = posix_add_unlink_to_ctx(loc->inode, this, unlink_path); + if (ret < 0) + goto out; out: - return ret; + return ret; } int32_t -posix_unlink_gfid_handle_and_entry (call_frame_t *frame, xlator_t *this, - const char *real_path, struct iatt *stbuf, - int32_t *op_errno, loc_t *loc, - gf_boolean_t get_link_count, - dict_t *rsp_dict) +posix_unlink_gfid_handle_and_entry(call_frame_t *frame, xlator_t *this, + const char *real_path, struct iatt *stbuf, + int32_t *op_errno, loc_t *loc, + gf_boolean_t get_link_count, + dict_t *rsp_dict) { - int32_t ret = 0; - struct iatt prebuf = {0,}; - gf_boolean_t locked = _gf_false; - gf_boolean_t update_ctime = _gf_false; - - /* Unlink the gfid_handle_first */ - if (stbuf && stbuf->ia_nlink == 1) { - - LOCK (&loc->inode->lock); - - if (loc->inode->fd_count == 0) { - UNLOCK (&loc->inode->lock); - ret = posix_handle_unset (this, stbuf->ia_gfid, NULL); - } else { - UNLOCK (&loc->inode->lock); - ret = posix_move_gfid_to_unlink (this, stbuf->ia_gfid, - loc); - } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_UNLINK_FAILED, "unlink of gfid handle " - "failed for path:%s with gfid %s", - real_path, uuid_utoa (stbuf->ia_gfid)); - } + int32_t ret = 0; + struct iatt prebuf = { + 0, + }; + gf_boolean_t locked = _gf_false; + gf_boolean_t update_ctime = _gf_false; + + /* Unlink the gfid_handle_first */ + if (stbuf && stbuf->ia_nlink == 1) { + LOCK(&loc->inode->lock); + + if (loc->inode->fd_count == 0) { + UNLOCK(&loc->inode->lock); + ret = posix_handle_unset(this, stbuf->ia_gfid, NULL); } else { - update_ctime = _gf_true; - } - - if (get_link_count) { - LOCK (&loc->inode->lock); - locked = _gf_true; - /* Since this stat is to get link count and not for time - * attributes, intentionally passing inode as NULL - */ - ret = posix_pstat (this, NULL, loc->gfid, real_path, - &prebuf, _gf_true); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LSTAT_FAILED, "lstat on %s failed", - real_path); - goto err; - } - } - - /* Unlink the actual file */ - ret = sys_unlink (real_path); - if (ret == -1) { - if (op_errno) - *op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_UNLINK_FAILED, - "unlink of %s failed", real_path); - goto err; - } - - if (locked) { - UNLOCK (&loc->inode->lock); - locked = _gf_false; - } - - if (update_ctime) { - posix_set_ctime (frame, this, NULL, -1, loc->inode, stbuf); - } - - ret = dict_set_uint32 (rsp_dict, GET_LINK_COUNT, prebuf.ia_nlink); - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, - "failed to set "GET_LINK_COUNT" for %s", real_path); - - return 0; + UNLOCK(&loc->inode->lock); + ret = posix_move_gfid_to_unlink(this, stbuf->ia_gfid, loc); + } + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_UNLINK_FAILED, + "unlink of gfid handle " + "failed for path:%s with gfid %s", + real_path, uuid_utoa(stbuf->ia_gfid)); + } + } else { + update_ctime = _gf_true; + } + + if (get_link_count) { + LOCK(&loc->inode->lock); + locked = _gf_true; + /* Since this stat is to get link count and not for time + * attributes, intentionally passing inode as NULL + */ + ret = posix_pstat(this, NULL, loc->gfid, real_path, &prebuf, _gf_true); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_path); + goto err; + } + } + + /* Unlink the actual file */ + ret = sys_unlink(real_path); + if (ret == -1) { + if (op_errno) + *op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_UNLINK_FAILED, + "unlink of %s failed", real_path); + goto err; + } + + if (locked) { + UNLOCK(&loc->inode->lock); + locked = _gf_false; + } + + if (update_ctime) { + posix_set_ctime(frame, this, NULL, -1, loc->inode, stbuf); + } + + ret = dict_set_uint32(rsp_dict, GET_LINK_COUNT, prebuf.ia_nlink); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, + "failed to set " GET_LINK_COUNT " for %s", real_path); + + return 0; err: - if (locked) { - UNLOCK (&loc->inode->lock); - locked = _gf_false; - } - return -1; + if (locked) { + UNLOCK(&loc->inode->lock); + locked = _gf_false; + } + return -1; } gf_boolean_t -posix_skip_non_linkto_unlink (dict_t *xdata, loc_t *loc, char *key, - const char *linkto_xattr, struct iatt *stbuf, - const char *real_path) +posix_skip_non_linkto_unlink(dict_t *xdata, loc_t *loc, char *key, + const char *linkto_xattr, struct iatt *stbuf, + const char *real_path) { - gf_boolean_t skip_unlink = _gf_false; - gf_boolean_t is_dht_linkto_file = _gf_false; - int unlink_if_linkto = 0; - ssize_t xattr_size = -1; - int op_ret = -1; - - op_ret = dict_get_int32 (xdata, key, - &unlink_if_linkto); + gf_boolean_t skip_unlink = _gf_false; + gf_boolean_t is_dht_linkto_file = _gf_false; + int unlink_if_linkto = 0; + ssize_t xattr_size = -1; + int op_ret = -1; - if (!op_ret && unlink_if_linkto) { + op_ret = dict_get_int32(xdata, key, &unlink_if_linkto); - is_dht_linkto_file = IS_DHT_LINKFILE_MODE (stbuf); - if (!is_dht_linkto_file) - return _gf_true; + if (!op_ret && unlink_if_linkto) { + is_dht_linkto_file = IS_DHT_LINKFILE_MODE(stbuf); + if (!is_dht_linkto_file) + return _gf_true; - LOCK (&loc->inode->lock); + LOCK(&loc->inode->lock); - xattr_size = sys_lgetxattr (real_path, linkto_xattr, NULL, 0); + xattr_size = sys_lgetxattr(real_path, linkto_xattr, NULL, 0); - if (xattr_size <= 0) - skip_unlink = _gf_true; + if (xattr_size <= 0) + skip_unlink = _gf_true; - UNLOCK (&loc->inode->lock); - - gf_msg ("posix", GF_LOG_INFO, 0, P_MSG_XATTR_STATUS, - "linkto_xattr status: %"PRIu32" for %s", skip_unlink, - real_path); - } - return skip_unlink; + UNLOCK(&loc->inode->lock); + gf_msg("posix", GF_LOG_INFO, 0, P_MSG_XATTR_STATUS, + "linkto_xattr status: %" PRIu32 " for %s", skip_unlink, + real_path); + } + return skip_unlink; } int32_t -posix_unlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, int xflag, dict_t *xdata) +posix_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = NULL; - char *par_path = NULL; - int32_t fd = -1; - struct iatt stbuf = {0,}; - struct iatt postbuf = {0,}; - struct posix_private *priv = NULL; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - char *pgfid_xattr_key = NULL; - int32_t nlink_samepgfid = 0; - int32_t check_open_fd = 0; - int32_t skip_unlink = 0; - int32_t fdstat_requested = 0; - dict_t *unwind_dict = NULL; - void *uuid = NULL; - char uuid_str[GF_UUID_BUF_SIZE] = {0}; - char gfid_str[GF_UUID_BUF_SIZE] = {0}; - gf_boolean_t get_link_count = _gf_false; - posix_inode_ctx_t *ctx = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); - goto out; - } - - priv = this->private; - - op_ret = dict_get_ptr (xdata, TIER_LINKFILE_GFID, &uuid); - - if (!op_ret && gf_uuid_compare (uuid, stbuf.ia_gfid)) { - op_errno = ENOENT; - op_ret = -1; - gf_uuid_unparse (uuid, uuid_str); - gf_uuid_unparse (stbuf.ia_gfid, gfid_str); - gf_msg_debug (this->name, op_errno, "Mismatch in gfid for path " - "%s. Aborting the unlink. loc->gfid = %s, " - "stbuf->ia_gfid = %s", real_path, - uuid_str, gfid_str); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL; + char *par_path = NULL; + int32_t fd = -1; + struct iatt stbuf = { + 0, + }; + struct iatt postbuf = { + 0, + }; + struct posix_private *priv = NULL; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + char *pgfid_xattr_key = NULL; + int32_t nlink_samepgfid = 0; + int32_t check_open_fd = 0; + int32_t skip_unlink = 0; + int32_t fdstat_requested = 0; + dict_t *unwind_dict = NULL; + void *uuid = NULL; + char uuid_str[GF_UUID_BUF_SIZE] = {0}; + char gfid_str[GF_UUID_BUF_SIZE] = {0}; + gf_boolean_t get_link_count = _gf_false; + posix_inode_ctx_t *ctx = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &stbuf); + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - op_ret = dict_get_int32 (xdata, DHT_SKIP_OPEN_FD_UNLINK, - &check_open_fd); + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } - if (!op_ret && check_open_fd) { + priv = this->private; - LOCK (&loc->inode->lock); + op_ret = dict_get_ptr(xdata, TIER_LINKFILE_GFID, &uuid); - if (loc->inode->fd_count) { - skip_unlink = 1; - } + if (!op_ret && gf_uuid_compare(uuid, stbuf.ia_gfid)) { + op_errno = ENOENT; + op_ret = -1; + gf_uuid_unparse(uuid, uuid_str); + gf_uuid_unparse(stbuf.ia_gfid, gfid_str); + gf_msg_debug(this->name, op_errno, + "Mismatch in gfid for path " + "%s. Aborting the unlink. loc->gfid = %s, " + "stbuf->ia_gfid = %s", + real_path, uuid_str, gfid_str); + goto out; + } - UNLOCK (&loc->inode->lock); + op_ret = dict_get_int32(xdata, DHT_SKIP_OPEN_FD_UNLINK, &check_open_fd); - gf_msg (this->name, GF_LOG_INFO, 0, P_MSG_KEY_STATUS_INFO, - "open-fd-key-status: %"PRIu32" for %s", skip_unlink, - real_path); + if (!op_ret && check_open_fd) { + LOCK(&loc->inode->lock); - if (skip_unlink) { - op_ret = -1; - op_errno = EBUSY; - goto out; - } - } - /* - * If either of the function return true, skip_unlink. - * If first first function itself return true, - * we don't need to call second function, skip unlink. - */ - skip_unlink = posix_skip_non_linkto_unlink (xdata, loc, - DHT_SKIP_NON_LINKTO_UNLINK, - DHT_LINKTO, &stbuf, - real_path); - skip_unlink = skip_unlink || posix_skip_non_linkto_unlink (xdata, loc, - TIER_SKIP_NON_LINKTO_UNLINK, - TIER_LINKTO, &stbuf, - real_path); - if (skip_unlink) { - op_ret = -1; - op_errno = EBUSY; - goto out; + if (loc->inode->fd_count) { + skip_unlink = 1; } - if (IA_ISREG (loc->inode->ia_type) && - xdata && dict_get (xdata, DHT_IATT_IN_XDATA_KEY)) { - fdstat_requested = 1; - } + UNLOCK(&loc->inode->lock); - if (fdstat_requested || - (priv->background_unlink && IA_ISREG (loc->inode->ia_type))) { - fd = sys_open (real_path, O_RDONLY, 0); - if (fd == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_OPEN_FAILED, - "open of %s failed", real_path); - goto out; - } - } + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_KEY_STATUS_INFO, + "open-fd-key-status: %" PRIu32 " for %s", skip_unlink, + real_path); - if (priv->update_pgfid_nlinks && (stbuf.ia_nlink > 1)) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, - loc->pargfid); - op_ret = posix_inode_ctx_get_all (loc->inode, this, &ctx); - if (op_ret < 0) { - op_errno = ENOMEM; - goto out; - } - pthread_mutex_lock (&ctx->pgfid_lock); - { - UNLINK_MODIFY_PGFID_XATTR (real_path, pgfid_xattr_key, - nlink_samepgfid, 0, op_ret, - this, unlock); - } - unlock: - pthread_mutex_unlock (&ctx->pgfid_lock); - - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_FAILED, "modification of " - "parent gfid xattr failed (path:%s gfid:%s)", - real_path, uuid_utoa (loc->inode->gfid)); - if (op_errno != ENOATTR) - /* Allow unlink if pgfid xattr is not set. */ - goto out; - } + if (skip_unlink) { + op_ret = -1; + op_errno = EBUSY; + goto out; + } + } + /* + * If either of the function return true, skip_unlink. + * If first first function itself return true, + * we don't need to call second function, skip unlink. + */ + skip_unlink = posix_skip_non_linkto_unlink( + xdata, loc, DHT_SKIP_NON_LINKTO_UNLINK, DHT_LINKTO, &stbuf, real_path); + skip_unlink = skip_unlink || posix_skip_non_linkto_unlink( + xdata, loc, TIER_SKIP_NON_LINKTO_UNLINK, + TIER_LINKTO, &stbuf, real_path); + if (skip_unlink) { + op_ret = -1; + op_errno = EBUSY; + goto out; + } + + if (IA_ISREG(loc->inode->ia_type) && xdata && + dict_get(xdata, DHT_IATT_IN_XDATA_KEY)) { + fdstat_requested = 1; + } + + if (fdstat_requested || + (priv->background_unlink && IA_ISREG(loc->inode->ia_type))) { + fd = sys_open(real_path, O_RDONLY, 0); + if (fd == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_OPEN_FAILED, + "open of %s failed", real_path); + goto out; + } + } + + if (priv->update_pgfid_nlinks && (stbuf.ia_nlink > 1)) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + loc->pargfid); + op_ret = posix_inode_ctx_get_all(loc->inode, this, &ctx); + if (op_ret < 0) { + op_errno = ENOMEM; + goto out; } - - if (priv->gfid2path && (stbuf.ia_nlink > 1)) { - op_ret = posix_remove_gfid2path_xattr (this, real_path, - loc->pargfid, - loc->name); - if (op_ret < 0) { - /* Allow unlink if pgfid xattr is not set. */ - if (errno != ENOATTR) - goto out; - } + pthread_mutex_lock(&ctx->pgfid_lock); + { + UNLINK_MODIFY_PGFID_XATTR(real_path, pgfid_xattr_key, + nlink_samepgfid, 0, op_ret, this, unlock); } + unlock: + pthread_mutex_unlock(&ctx->pgfid_lock); - unwind_dict = dict_new (); - if (!unwind_dict) { - op_errno = -ENOMEM; - op_ret = -1; + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_FAILED, + "modification of " + "parent gfid xattr failed (path:%s gfid:%s)", + real_path, uuid_utoa(loc->inode->gfid)); + if (op_errno != ENOATTR) + /* Allow unlink if pgfid xattr is not set. */ goto out; } + } - if (xdata && dict_get (xdata, GET_LINK_COUNT)) - get_link_count = _gf_true; - op_ret = posix_unlink_gfid_handle_and_entry (frame, this, real_path, - &stbuf, &op_errno, loc, - get_link_count, - unwind_dict); - if (op_ret == -1) { + if (priv->gfid2path && (stbuf.ia_nlink > 1)) { + op_ret = posix_remove_gfid2path_xattr(this, real_path, loc->pargfid, + loc->name); + if (op_ret < 0) { + /* Allow unlink if pgfid xattr is not set. */ + if (errno != ENOATTR) goto out; } + } - if (fdstat_requested) { - op_ret = posix_fdstat (this, loc->inode, fd, &postbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FSTAT_FAILED, "post operation " - "fstat failed on fd=%d", fd); - goto out; - } - op_ret = posix_set_iatt_in_dict (unwind_dict, NULL, &postbuf); - } - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); + unwind_dict = dict_new(); + if (!unwind_dict) { + op_errno = -ENOMEM; + op_ret = -1; + goto out; + } + + if (xdata && dict_get(xdata, GET_LINK_COUNT)) + get_link_count = _gf_true; + op_ret = posix_unlink_gfid_handle_and_entry(frame, this, real_path, &stbuf, + &op_errno, loc, get_link_count, + unwind_dict); + if (op_ret == -1) { + goto out; + } + + if (fdstat_requested) { + op_ret = posix_fdstat(this, loc->inode, fd, &postbuf); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_path); - goto out; - } + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "post operation " + "fstat failed on fd=%d", + fd); + goto out; + } + op_ret = posix_set_iatt_in_dict(unwind_dict, NULL, &postbuf); + } + + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); - unwind_dict = posix_dict_set_nlink (xdata, unwind_dict, stbuf.ia_nlink); - op_ret = 0; + unwind_dict = posix_dict_set_nlink(xdata, unwind_dict, stbuf.ia_nlink); + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - &preparent, &postparent, unwind_dict); + STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, &preparent, + &postparent, unwind_dict); - if (fd != -1) { - sys_close (fd); - } + if (fd != -1) { + sys_close(fd); + } - /* unref unwind_dict*/ - if (unwind_dict) { - dict_unref (unwind_dict); - } + /* unref unwind_dict*/ + if (unwind_dict) { + dict_unref(unwind_dict); + } - return 0; + return 0; } - int -posix_rmdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, int flags, dict_t *xdata) +posix_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = NULL; - char *par_path = NULL; - char *gfid_str = NULL; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - struct iatt stbuf = {0,}; - struct posix_private *priv = NULL; - char tmp_path[PATH_MAX] = {0,}; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - - /* The Hidden directory should be for housekeeping purpose and it - should not get deleted from inside process */ - if (__is_root_gfid (loc->pargfid) && - (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { - gf_msg (this->name, GF_LOG_WARNING, EPERM, - P_MSG_RMDIR_NOT_PERMITTED, "rmdir issued on %s, which" - "is not permitted", GF_HIDDEN_PATH); - op_errno = EPERM; - op_ret = -1; - goto out; - } - - priv = this->private; + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL; + char *par_path = NULL; + char *gfid_str = NULL; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + char tmp_path[PATH_MAX] = { + 0, + }; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + + /* The Hidden directory should be for housekeeping purpose and it + should not get deleted from inside process */ + if (__is_root_gfid(loc->pargfid) && + (strcmp(loc->name, GF_HIDDEN_PATH) == 0)) { + gf_msg(this->name, GF_LOG_WARNING, EPERM, P_MSG_RMDIR_NOT_PERMITTED, + "rmdir issued on %s, which" + "is not permitted", + GF_HIDDEN_PATH); + op_errno = EPERM; + op_ret = -1; + goto out; + } - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } + priv = this->private; - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); - goto out; - } + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &stbuf); + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - if (flags) { - gfid_str = uuid_utoa (stbuf.ia_gfid); - - op_ret = sys_mkdir (priv->trash_path, 0755); - if (errno != EEXIST && op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_MKDIR_FAILED, - "mkdir of %s failed", priv->trash_path); - } else { - (void) snprintf (tmp_path, sizeof(tmp_path), "%s/%s", - priv->trash_path, gfid_str); - gf_msg_debug (this->name, 0, - "Moving %s to %s", real_path, tmp_path); - op_ret = sys_rename (real_path, tmp_path); - pthread_cond_signal (&priv->janitor_cond); - } - } else { - op_ret = sys_rmdir (real_path); - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { op_errno = errno; - - if (op_ret == 0) { - if (posix_symlinks_match (this, loc, stbuf.ia_gfid)) - posix_handle_unset (this, stbuf.ia_gfid, NULL); - } - - if (op_errno == EEXIST) - /* Solaris sets errno = EEXIST instead of ENOTEMPTY */ - op_errno = ENOTEMPTY; - - /* No need to log a common error as ENOTEMPTY */ - if (op_ret == -1 && op_errno != ENOTEMPTY) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_RMDIR_FAILED, - "rmdir of %s failed", real_path); - } - - if (op_ret == -1) { - if (op_errno == ENOTEMPTY) { - gf_msg_debug (this->name, 0, "%s on %s failed", (flags) - ? "rename" : "rmdir", real_path); - } else { - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_DIR_OPERATION_FAILED, "%s on %s failed", - (flags) ? "rename" : "rmdir", real_path); - } - goto out; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } + + if (flags) { + gfid_str = uuid_utoa(stbuf.ia_gfid); + + op_ret = sys_mkdir(priv->trash_path, 0755); + if (errno != EEXIST && op_ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_MKDIR_FAILED, + "mkdir of %s failed", priv->trash_path); + } else { + (void)snprintf(tmp_path, sizeof(tmp_path), "%s/%s", + priv->trash_path, gfid_str); + gf_msg_debug(this->name, 0, "Moving %s to %s", real_path, tmp_path); + op_ret = sys_rename(real_path, tmp_path); + pthread_cond_signal(&priv->janitor_cond); + } + } else { + op_ret = sys_rmdir(real_path); + } + op_errno = errno; + + if (op_ret == 0) { + if (posix_symlinks_match(this, loc, stbuf.ia_gfid)) + posix_handle_unset(this, stbuf.ia_gfid, NULL); + } + + if (op_errno == EEXIST) + /* Solaris sets errno = EEXIST instead of ENOTEMPTY */ + op_errno = ENOTEMPTY; + + /* No need to log a common error as ENOTEMPTY */ + if (op_ret == -1 && op_errno != ENOTEMPTY) { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_RMDIR_FAILED, + "rmdir of %s failed", real_path); + } + + if (op_ret == -1) { + if (op_errno == ENOTEMPTY) { + gf_msg_debug(this->name, 0, "%s on %s failed", + (flags) ? "rename" : "rmdir", real_path); + } else { + gf_msg(this->name, GF_LOG_ERROR, op_errno, + P_MSG_DIR_OPERATION_FAILED, "%s on %s failed", + (flags) ? "rename" : "rmdir", real_path); } + goto out; + } - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent of %s failed", - par_path); - goto out; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent of %s failed", par_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - &preparent, &postparent, NULL); + STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, &preparent, &postparent, + NULL); - return 0; + return 0; } - int -posix_symlink (call_frame_t *frame, xlator_t *this, - const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata) +posix_symlink(call_frame_t *frame, xlator_t *this, const char *linkname, + loc_t *loc, mode_t umask, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char * real_path = 0; - char * par_path = 0; - struct iatt stbuf = { 0, }; - struct posix_private *priv = NULL; - gid_t gid = 0; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - char *pgfid_xattr_key = NULL; - int32_t nlink_samepgfid = 0; - gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (linkname, out); - VALIDATE_OR_GOTO (loc, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - GFID_NULL_CHECK_AND_GOTO (frame, this, loc, xdata, op_ret, op_errno, - out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); - - gid = frame->root->gid; - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = 0; + char *par_path = 0; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + gid_t gid = 0; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + char *pgfid_xattr_key = NULL; + int32_t nlink_samepgfid = 0; + gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(linkname, out); + VALIDATE_OR_GOTO(loc, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + GFID_NULL_CHECK_AND_GOTO(frame, this, loc, xdata, op_ret, op_errno, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &stbuf); + + gid = frame->root->gid; + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - SET_FS_ID (frame->root->uid, gid); + SET_FS_ID(frame->root->uid, gid); - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); - goto out; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } - if (preparent.ia_prot.sgid) { - gid = preparent.ia_gid; - } + if (preparent.ia_prot.sgid) { + gid = preparent.ia_gid; + } - op_ret = sys_symlink (linkname, real_path); + op_ret = sys_symlink(linkname, real_path); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_SYMLINK_FAILED, - "symlink of %s --> %s failed", - real_path, linkname); - goto out; - } + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_SYMLINK_FAILED, + "symlink of %s --> %s failed", real_path, linkname); + goto out; + } - entry_created = _gf_true; + entry_created = _gf_true; - posix_set_ctime (frame, this, real_path, -1, loc->inode, &stbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &stbuf); #ifndef HAVE_SET_FSID - op_ret = sys_lchown (real_path, frame->root->uid, gid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LCHOWN_FAILED, - "lchown failed on %s", real_path); - goto out; - } + op_ret = sys_lchown(real_path, frame->root->uid, gid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LCHOWN_FAILED, + "lchown failed on %s", real_path); + goto out; + } #endif - op_ret = posix_acl_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, - "setting ACLs on %s failed", real_path); - } - - if (priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, - loc->pargfid); - nlink_samepgfid = 1; - SET_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, - XATTR_CREATE, op_ret, this, ignore); - } - - if (priv->gfid2path) { - posix_set_gfid2path_xattr (this, real_path, loc->pargfid, - loc->name); - } + op_ret = posix_acl_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, + "setting ACLs on %s failed", real_path); + } + + if (priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + loc->pargfid); + nlink_samepgfid = 1; + SET_PGFID_XATTR(real_path, pgfid_xattr_key, nlink_samepgfid, + XATTR_CREATE, op_ret, this, ignore); + } + + if (priv->gfid2path) { + posix_set_gfid2path_xattr(this, real_path, loc->pargfid, loc->name); + } ignore: - op_ret = posix_entry_create_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, - "setting xattrs on %s failed ", real_path); - } - - op_ret = posix_gfid_set (this, real_path, loc, xdata, frame->root->pid, - &op_errno); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, - "setting gfid on %s failed", real_path); - goto out; - } else { - gfid_set = _gf_true; - } - - op_ret = posix_pstat (this, loc->inode, NULL, real_path, &stbuf, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat failed on %s", real_path); - goto out; - } - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_path); - goto out; - } + op_ret = posix_entry_create_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setting xattrs on %s failed ", real_path); + } + + op_ret = posix_gfid_set(this, real_path, loc, xdata, frame->root->pid, + &op_errno); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, + "setting gfid on %s failed", real_path); + goto out; + } else { + gfid_set = _gf_true; + } + + op_ret = posix_pstat(this, loc->inode, NULL, real_path, &stbuf, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat failed on %s", real_path); + goto out; + } + + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - if (op_ret < 0) { - if (entry_created) - sys_unlink (real_path); + if (op_ret < 0) { + if (entry_created) + sys_unlink(real_path); - if (gfid_set) - posix_gfid_unset (this, xdata); - } + if (gfid_set) + posix_gfid_unset(this, xdata); + } - STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, - (loc)?loc->inode:NULL, &stbuf, &preparent, - &postparent, NULL); + STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, + (loc) ? loc->inode : NULL, &stbuf, &preparent, + &postparent, NULL); - return 0; + return 0; } - int -posix_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +posix_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_oldpath = NULL; - char *real_newpath = NULL; - char *par_oldpath = NULL; - char *par_newpath = NULL; - struct iatt stbuf = {0, }; - struct posix_private *priv = NULL; - char was_present = 1; - struct iatt preoldparent = {0, }; - struct iatt postoldparent = {0, }; - struct iatt prenewparent = {0, }; - struct iatt postnewparent = {0, }; - char olddirid[64]; - char newdirid[64]; - uuid_t victim = {0}; - int was_dir = 0; - int nlink = 0; - char *pgfid_xattr_key = NULL; - int32_t nlink_samepgfid = 0; - char *gfid_path = NULL; - dict_t *unwind_dict = NULL; - gf_boolean_t locked = _gf_false; - gf_boolean_t get_link_count = _gf_false; - posix_inode_ctx_t *ctx_old = NULL; - posix_inode_ctx_t *ctx_new = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (oldloc, out); - VALIDATE_OR_GOTO (newloc, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_ENTRY_HANDLE (real_oldpath, par_oldpath, this, oldloc, NULL); - if (!real_oldpath || !par_oldpath) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - MAKE_ENTRY_HANDLE (real_newpath, par_newpath, this, newloc, &stbuf); - if (!real_newpath || !par_newpath) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - unwind_dict = dict_new (); - if (!unwind_dict) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - op_ret = posix_pstat (this, oldloc->parent, oldloc->pargfid, - par_oldpath, &preoldparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_oldpath); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_oldpath = NULL; + char *real_newpath = NULL; + char *par_oldpath = NULL; + char *par_newpath = NULL; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + char was_present = 1; + struct iatt preoldparent = { + 0, + }; + struct iatt postoldparent = { + 0, + }; + struct iatt prenewparent = { + 0, + }; + struct iatt postnewparent = { + 0, + }; + char olddirid[64]; + char newdirid[64]; + uuid_t victim = {0}; + int was_dir = 0; + int nlink = 0; + char *pgfid_xattr_key = NULL; + int32_t nlink_samepgfid = 0; + char *gfid_path = NULL; + dict_t *unwind_dict = NULL; + gf_boolean_t locked = _gf_false; + gf_boolean_t get_link_count = _gf_false; + posix_inode_ctx_t *ctx_old = NULL; + posix_inode_ctx_t *ctx_new = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(oldloc, out); + VALIDATE_OR_GOTO(newloc, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_ENTRY_HANDLE(real_oldpath, par_oldpath, this, oldloc, NULL); + if (!real_oldpath || !par_oldpath) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - op_ret = posix_pstat (this, newloc->parent, newloc->pargfid, - par_newpath, &prenewparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent of %s failed", - par_newpath); - goto out; - } + MAKE_ENTRY_HANDLE(real_newpath, par_newpath, this, newloc, &stbuf); + if (!real_newpath || !par_newpath) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - op_ret = posix_pstat (this, newloc->inode, NULL, real_newpath, &stbuf, - _gf_false); - if ((op_ret == -1) && (errno == ENOENT)){ - was_present = 0; - } else { - gf_uuid_copy (victim, stbuf.ia_gfid); - if (IA_ISDIR (stbuf.ia_type)) - was_dir = 1; - nlink = stbuf.ia_nlink; - } + unwind_dict = dict_new(); + if (!unwind_dict) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } - if (was_present && IA_ISDIR(stbuf.ia_type) && !newloc->inode) { - gf_msg (this->name, GF_LOG_WARNING, EEXIST, P_MSG_DIR_FOUND, - "found directory at %s while expecting ENOENT", - real_newpath); - op_ret = -1; - op_errno = EEXIST; - goto out; - } + op_ret = posix_pstat(this, oldloc->parent, oldloc->pargfid, par_oldpath, + &preoldparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_oldpath); + goto out; + } + + op_ret = posix_pstat(this, newloc->parent, newloc->pargfid, par_newpath, + &prenewparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent of %s failed", par_newpath); + goto out; + } + + op_ret = posix_pstat(this, newloc->inode, NULL, real_newpath, &stbuf, + _gf_false); + if ((op_ret == -1) && (errno == ENOENT)) { + was_present = 0; + } else { + gf_uuid_copy(victim, stbuf.ia_gfid); + if (IA_ISDIR(stbuf.ia_type)) + was_dir = 1; + nlink = stbuf.ia_nlink; + } + + if (was_present && IA_ISDIR(stbuf.ia_type) && !newloc->inode) { + gf_msg(this->name, GF_LOG_WARNING, EEXIST, P_MSG_DIR_FOUND, + "found directory at %s while expecting ENOENT", real_newpath); + op_ret = -1; + op_errno = EEXIST; + goto out; + } + + if (was_present && IA_ISDIR(stbuf.ia_type) && + gf_uuid_compare(newloc->inode->gfid, stbuf.ia_gfid)) { + gf_msg(this->name, GF_LOG_WARNING, EEXIST, P_MSG_DIR_FOUND, + "found directory %s at %s while renaming %s", + uuid_utoa_r(newloc->inode->gfid, olddirid), real_newpath, + uuid_utoa_r(stbuf.ia_gfid, newdirid)); + op_ret = -1; + op_errno = EEXIST; + goto out; + } - if (was_present && IA_ISDIR(stbuf.ia_type) && - gf_uuid_compare (newloc->inode->gfid, stbuf.ia_gfid)) { - gf_msg (this->name, GF_LOG_WARNING, EEXIST, P_MSG_DIR_FOUND, - "found directory %s at %s while renaming %s", - uuid_utoa_r (newloc->inode->gfid, olddirid), - real_newpath, - uuid_utoa_r (stbuf.ia_gfid, newdirid)); - op_ret = -1; - op_errno = EEXIST; - goto out; - } + op_ret = posix_inode_ctx_get_all(oldloc->inode, this, &ctx_old); + if (op_ret < 0) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } - op_ret = posix_inode_ctx_get_all (oldloc->inode, this, &ctx_old); + if (newloc->inode) { + op_ret = posix_inode_ctx_get_all(newloc->inode, this, &ctx_new); if (op_ret < 0) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (newloc->inode) { - op_ret = posix_inode_ctx_get_all (newloc->inode, this, &ctx_new); - if (op_ret < 0) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + } + + if (IA_ISDIR(oldloc->inode->ia_type)) + posix_handle_unset(this, oldloc->inode->gfid, NULL); + + pthread_mutex_lock(&ctx_old->pgfid_lock); + { + if (!IA_ISDIR(oldloc->inode->ia_type) && priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + oldloc->pargfid); + UNLINK_MODIFY_PGFID_XATTR(real_oldpath, pgfid_xattr_key, + nlink_samepgfid, 0, op_ret, this, unlock); + } + + if ((xdata) && (dict_get(xdata, GET_LINK_COUNT)) && (real_newpath) && + (was_present) && ctx_new) { + pthread_mutex_lock(&ctx_new->pgfid_lock); + locked = _gf_true; + get_link_count = _gf_true; + op_ret = posix_pstat(this, newloc->inode, newloc->gfid, + real_newpath, &stbuf, _gf_false); + if ((op_ret == -1) && (errno != ENOENT)) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_newpath); + goto unlock; + } } - if (IA_ISDIR (oldloc->inode->ia_type)) - posix_handle_unset (this, oldloc->inode->gfid, NULL); - - pthread_mutex_lock (&ctx_old->pgfid_lock); - { - if (!IA_ISDIR (oldloc->inode->ia_type) - && priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, - PGFID_XATTR_KEY_PREFIX, - oldloc->pargfid); - UNLINK_MODIFY_PGFID_XATTR (real_oldpath, - pgfid_xattr_key, - nlink_samepgfid, 0, - op_ret, - this, unlock); - } - - if ((xdata) && (dict_get (xdata, GET_LINK_COUNT)) - && (real_newpath) && (was_present) && ctx_new) { - pthread_mutex_lock (&ctx_new->pgfid_lock); - locked = _gf_true; - get_link_count = _gf_true; - op_ret = posix_pstat (this, newloc->inode, newloc->gfid, - real_newpath, &stbuf, _gf_false); - if ((op_ret == -1) && (errno != ENOENT)) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LSTAT_FAILED, - "lstat on %s failed", real_newpath); - goto unlock; - } - } - - op_ret = sys_rename (real_oldpath, real_newpath); - if (op_ret == -1) { - op_errno = errno; - if (op_errno == ENOTEMPTY) { - gf_msg_debug (this->name, 0, "rename of %s to" - " %s failed: %s", real_oldpath, - real_newpath, - strerror (op_errno)); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_RENAME_FAILED, - "rename of %s to %s failed", - real_oldpath, real_newpath); - } - - if (priv->update_pgfid_nlinks - && !IA_ISDIR (oldloc->inode->ia_type)) { - LINK_MODIFY_PGFID_XATTR (real_oldpath, - pgfid_xattr_key, - nlink_samepgfid, 0, - op_ret, - this, unlock); - } - - goto unlock; - } - - if (locked) { - pthread_mutex_unlock (&ctx_new->pgfid_lock); - locked = _gf_false; - } - - if ((get_link_count) && - (dict_set_uint32 (unwind_dict, GET_LINK_COUNT, - stbuf.ia_nlink))) - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_SET_XDATA_FAIL, "failed to set " - GET_LINK_COUNT" for %s", real_newpath); - - if (!IA_ISDIR (oldloc->inode->ia_type) - && priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, - PGFID_XATTR_KEY_PREFIX, - newloc->pargfid); - LINK_MODIFY_PGFID_XATTR (real_newpath, - pgfid_xattr_key, - nlink_samepgfid, 0, - op_ret, - this, unlock); - } - - if (!IA_ISDIR (oldloc->inode->ia_type) && priv->gfid2path) { - MAKE_HANDLE_ABSPATH (gfid_path, this, - oldloc->inode->gfid); - - posix_remove_gfid2path_xattr (this, gfid_path, - oldloc->pargfid, - oldloc->name); - posix_set_gfid2path_xattr (this, gfid_path, - newloc->pargfid, - newloc->name); - } + op_ret = sys_rename(real_oldpath, real_newpath); + if (op_ret == -1) { + op_errno = errno; + if (op_errno == ENOTEMPTY) { + gf_msg_debug(this->name, 0, + "rename of %s to" + " %s failed: %s", + real_oldpath, real_newpath, strerror(op_errno)); + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_RENAME_FAILED, + "rename of %s to %s failed", real_oldpath, real_newpath); + } + + if (priv->update_pgfid_nlinks && + !IA_ISDIR(oldloc->inode->ia_type)) { + LINK_MODIFY_PGFID_XATTR(real_oldpath, pgfid_xattr_key, + nlink_samepgfid, 0, op_ret, this, + unlock); + } + + goto unlock; } -unlock: if (locked) { - pthread_mutex_unlock (&ctx_new->pgfid_lock); - locked = _gf_false; - } - pthread_mutex_unlock (&ctx_old->pgfid_lock); - - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_FAILED, - "modification of " - "parent gfid xattr failed (gfid:%s)", - uuid_utoa (oldloc->inode->gfid)); - goto out; + pthread_mutex_unlock(&ctx_new->pgfid_lock); + locked = _gf_false; } - if (was_dir) - posix_handle_unset (this, victim, NULL); - - if (was_present && !was_dir && nlink == 1) - posix_handle_unset (this, victim, NULL); + if ((get_link_count) && + (dict_set_uint32(unwind_dict, GET_LINK_COUNT, stbuf.ia_nlink))) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, + "failed to set " GET_LINK_COUNT " for %s", real_newpath); - if (IA_ISDIR (oldloc->inode->ia_type)) { - posix_handle_soft (this, real_newpath, newloc, - oldloc->inode->gfid, NULL); + if (!IA_ISDIR(oldloc->inode->ia_type) && priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + newloc->pargfid); + LINK_MODIFY_PGFID_XATTR(real_newpath, pgfid_xattr_key, + nlink_samepgfid, 0, op_ret, this, unlock); } - op_ret = posix_pstat (this, newloc->inode, NULL, real_newpath, &stbuf, - _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat on %s failed", real_newpath); - goto out; - } - - /* Since the same inode is later used and dst inode is not present, - * update ctime on source inode. It can't use old path because it - * doesn't exist and xattr has to be stored on disk */ - posix_set_ctime (frame, this, real_newpath, -1, oldloc->inode, &stbuf); + if (!IA_ISDIR(oldloc->inode->ia_type) && priv->gfid2path) { + MAKE_HANDLE_ABSPATH(gfid_path, this, oldloc->inode->gfid); - op_ret = posix_pstat (this, oldloc->parent, oldloc->pargfid, - par_oldpath, &postoldparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_oldpath); - goto out; + posix_remove_gfid2path_xattr(this, gfid_path, oldloc->pargfid, + oldloc->name); + posix_set_gfid2path_xattr(this, gfid_path, newloc->pargfid, + newloc->name); } + } - posix_set_parent_ctime (frame, this, par_oldpath, -1, oldloc->parent, - &postoldparent); +unlock: + if (locked) { + pthread_mutex_unlock(&ctx_new->pgfid_lock); + locked = _gf_false; + } + pthread_mutex_unlock(&ctx_old->pgfid_lock); + + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_FAILED, + "modification of " + "parent gfid xattr failed (gfid:%s)", + uuid_utoa(oldloc->inode->gfid)); + goto out; + } + + if (was_dir) + posix_handle_unset(this, victim, NULL); + + if (was_present && !was_dir && nlink == 1) + posix_handle_unset(this, victim, NULL); + + if (IA_ISDIR(oldloc->inode->ia_type)) { + posix_handle_soft(this, real_newpath, newloc, oldloc->inode->gfid, + NULL); + } + + op_ret = posix_pstat(this, newloc->inode, NULL, real_newpath, &stbuf, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_newpath); + goto out; + } + + /* Since the same inode is later used and dst inode is not present, + * update ctime on source inode. It can't use old path because it + * doesn't exist and xattr has to be stored on disk */ + posix_set_ctime(frame, this, real_newpath, -1, oldloc->inode, &stbuf); + + op_ret = posix_pstat(this, oldloc->parent, oldloc->pargfid, par_oldpath, + &postoldparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_oldpath); + goto out; + } - op_ret = posix_pstat (this, newloc->parent, newloc->pargfid, - par_newpath, &postnewparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_newpath); - goto out; - } + posix_set_parent_ctime(frame, this, par_oldpath, -1, oldloc->parent, + &postoldparent); + + op_ret = posix_pstat(this, newloc->parent, newloc->pargfid, par_newpath, + &postnewparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_newpath); + goto out; + } - posix_set_parent_ctime (frame, this, par_newpath, -1, newloc->parent, - &postnewparent); + posix_set_parent_ctime(frame, this, par_newpath, -1, newloc->parent, + &postnewparent); - if (was_present) - unwind_dict = posix_dict_set_nlink (xdata, unwind_dict, nlink); - op_ret = 0; + if (was_present) + unwind_dict = posix_dict_set_nlink(xdata, unwind_dict, nlink); + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, &stbuf, - &preoldparent, &postoldparent, - &prenewparent, &postnewparent, unwind_dict); + STACK_UNWIND_STRICT(rename, frame, op_ret, op_errno, &stbuf, &preoldparent, + &postoldparent, &prenewparent, &postnewparent, + unwind_dict); - if (unwind_dict) - dict_unref (unwind_dict); + if (unwind_dict) + dict_unref(unwind_dict); - return 0; + return 0; } - int -posix_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +posix_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_oldpath = 0; - char *real_newpath = 0; - char *par_newpath = 0; - struct iatt stbuf = {0, }; - struct posix_private *priv = NULL; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - int32_t nlink_samepgfid = 0; - char *pgfid_xattr_key = NULL; - gf_boolean_t entry_created = _gf_false; - posix_inode_ctx_t *ctx = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (oldloc, out); - VALIDATE_OR_GOTO (newloc, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_INODE_HANDLE (real_oldpath, this, oldloc, &stbuf); - if (!real_oldpath) { - op_errno = errno; - goto out; - } - - if (priv->max_hardlinks && stbuf.ia_nlink >= priv->max_hardlinks) { - op_ret = -1; - op_errno = EMLINK; - gf_log (this->name, GF_LOG_ERROR, - "hardlink failed: %s exceeds max link count (%u/%u).", - real_oldpath, stbuf.ia_nlink, priv->max_hardlinks); - goto out; - } - - MAKE_ENTRY_HANDLE (real_newpath, par_newpath, this, newloc, &stbuf); - if (!real_newpath || !par_newpath) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - op_ret = posix_pstat (this, newloc->parent, newloc->pargfid, - par_newpath, &preparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat failed: %s", par_newpath); - goto out; - } - - - op_ret = sys_link (real_oldpath, real_newpath); - - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LINK_FAILED, - "link %s to %s failed", - real_oldpath, real_newpath); - goto out; - } - - entry_created = _gf_true; - - op_ret = posix_pstat (this, newloc->inode, NULL, real_newpath, &stbuf, - _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat on %s failed", real_newpath); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_oldpath = 0; + char *real_newpath = 0; + char *par_newpath = 0; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + int32_t nlink_samepgfid = 0; + char *pgfid_xattr_key = NULL; + gf_boolean_t entry_created = _gf_false; + posix_inode_ctx_t *ctx = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(oldloc, out); + VALIDATE_OR_GOTO(newloc, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_INODE_HANDLE(real_oldpath, this, oldloc, &stbuf); + if (!real_oldpath) { + op_errno = errno; + goto out; + } - posix_set_ctime (frame, this, real_newpath, -1, newloc->inode, &stbuf); + if (priv->max_hardlinks && stbuf.ia_nlink >= priv->max_hardlinks) { + op_ret = -1; + op_errno = EMLINK; + gf_log(this->name, GF_LOG_ERROR, + "hardlink failed: %s exceeds max link count (%u/%u).", + real_oldpath, stbuf.ia_nlink, priv->max_hardlinks); + goto out; + } + + MAKE_ENTRY_HANDLE(real_newpath, par_newpath, this, newloc, &stbuf); + if (!real_newpath || !par_newpath) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - op_ret = posix_pstat (this, newloc->parent, newloc->pargfid, - par_newpath, &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat failed: %s", par_newpath); - goto out; - } + op_ret = posix_pstat(this, newloc->parent, newloc->pargfid, par_newpath, + &preparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat failed: %s", par_newpath); + goto out; + } - posix_set_parent_ctime (frame, this, par_newpath, -1, newloc->parent, - &postparent); + op_ret = sys_link(real_oldpath, real_newpath); - if (priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, - newloc->pargfid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LINK_FAILED, + "link %s to %s failed", real_oldpath, real_newpath); + goto out; + } - op_ret = posix_inode_ctx_get_all (newloc->inode, this, &ctx); - if (op_ret < 0) { - op_errno = ENOMEM; - goto out; - } + entry_created = _gf_true; - pthread_mutex_lock (&ctx->pgfid_lock); - { - LINK_MODIFY_PGFID_XATTR (real_newpath, pgfid_xattr_key, - nlink_samepgfid, 0, op_ret, - this, unlock); - } - unlock: - pthread_mutex_unlock (&ctx->pgfid_lock); - - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_FAILED, "modification of " - "parent gfid xattr failed (path:%s gfid:%s)", - real_newpath, uuid_utoa (newloc->inode->gfid)); - goto out; - } - } + op_ret = posix_pstat(this, newloc->inode, NULL, real_newpath, &stbuf, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_newpath); + goto out; + } - if (priv->gfid2path) { - if (stbuf.ia_nlink <= MAX_GFID2PATH_LINK_SUP) { - op_ret = posix_set_gfid2path_xattr (this, real_newpath, - newloc->pargfid, - newloc->name); - if (op_ret) { - op_errno = errno; - goto out; - } - } else { - gf_msg (this->name, GF_LOG_INFO, 0, - P_MSG_XATTR_NOTSUP, "Link count exceeded. " - "gfid2path xattr not set (path:%s gfid:%s)", - real_newpath, uuid_utoa (newloc->inode->gfid)); - } - } + posix_set_ctime(frame, this, real_newpath, -1, newloc->inode, &stbuf); - op_ret = 0; + op_ret = posix_pstat(this, newloc->parent, newloc->pargfid, par_newpath, + &postparent, _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat failed: %s", par_newpath); + goto out; + } -out: - SET_TO_OLD_FS_ID (); + posix_set_parent_ctime(frame, this, par_newpath, -1, newloc->parent, + &postparent); - STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, - (oldloc)?oldloc->inode:NULL, &stbuf, &preparent, - &postparent, NULL); + if (priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + newloc->pargfid); + op_ret = posix_inode_ctx_get_all(newloc->inode, this, &ctx); if (op_ret < 0) { - if (entry_created) - sys_unlink (real_newpath); + op_errno = ENOMEM; + goto out; } - return 0; -} - -int -posix_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) -{ - int32_t op_ret = -1; - int32_t op_errno = 0; - int32_t _fd = -1; - int _flags = 0; - char * real_path = NULL; - char * par_path = NULL; - struct iatt stbuf = {0, }; - struct posix_fd * pfd = NULL; - struct posix_private * priv = NULL; - char was_present = 1; - - gid_t gid = 0; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - - int nlink_samepgfid = 0; - char * pgfid_xattr_key = NULL; - gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; - mode_t mode_bit = 0; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (fd, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - GFID_NULL_CHECK_AND_GOTO (frame, this, loc, xdata, op_ret, op_errno, - out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); - - gid = frame->root->gid; - - SET_FS_ID (frame->root->uid, gid); - if (!real_path || !par_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; + pthread_mutex_lock(&ctx->pgfid_lock); + { + LINK_MODIFY_PGFID_XATTR(real_newpath, pgfid_xattr_key, + nlink_samepgfid, 0, op_ret, this, unlock); } + unlock: + pthread_mutex_unlock(&ctx->pgfid_lock); - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret == -1) { + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_FAILED, + "modification of " + "parent gfid xattr failed (path:%s gfid:%s)", + real_newpath, uuid_utoa(newloc->inode->gfid)); + goto out; + } + } + + if (priv->gfid2path) { + if (stbuf.ia_nlink <= MAX_GFID2PATH_LINK_SUP) { + op_ret = posix_set_gfid2path_xattr(this, real_newpath, + newloc->pargfid, newloc->name); + if (op_ret) { op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); goto out; + } + } else { + gf_msg(this->name, GF_LOG_INFO, 0, P_MSG_XATTR_NOTSUP, + "Link count exceeded. " + "gfid2path xattr not set (path:%s gfid:%s)", + real_newpath, uuid_utoa(newloc->inode->gfid)); } + } - if (preparent.ia_prot.sgid) { - gid = preparent.ia_gid; - } + op_ret = 0; - if (!flags) { - _flags = O_CREAT | O_RDWR | O_EXCL; - } - else { - _flags = flags | O_CREAT; - } +out: + SET_TO_OLD_FS_ID(); - op_ret = posix_pstat (this, loc->inode, NULL, real_path, &stbuf, - _gf_false); - if ((op_ret == -1) && (errno == ENOENT)) { - was_present = 0; - } + STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, + (oldloc) ? oldloc->inode : NULL, &stbuf, &preparent, + &postparent, NULL); - if (priv->o_direct) - _flags |= O_DIRECT; + if (op_ret < 0) { + if (entry_created) + sys_unlink(real_newpath); + } - mode_bit = (priv->create_mask & mode) | priv->force_create_mode; - mode = posix_override_umask (mode, mode_bit); - _fd = sys_open (real_path, _flags, mode); + return 0; +} - if (_fd == -1) { - op_errno = errno; - op_ret = -1; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_OPEN_FAILED, - "open on %s failed", real_path); - goto out; - } +int +posix_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) +{ + int32_t op_ret = -1; + int32_t op_errno = 0; + int32_t _fd = -1; + int _flags = 0; + char *real_path = NULL; + char *par_path = NULL; + struct iatt stbuf = { + 0, + }; + struct posix_fd *pfd = NULL; + struct posix_private *priv = NULL; + char was_present = 1; + + gid_t gid = 0; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + + int nlink_samepgfid = 0; + char *pgfid_xattr_key = NULL; + gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; + mode_t mode_bit = 0; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(fd, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + GFID_NULL_CHECK_AND_GOTO(frame, this, loc, xdata, op_ret, op_errno, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &stbuf); + + gid = frame->root->gid; + + SET_FS_ID(frame->root->uid, gid); + if (!real_path || !par_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - if ((_flags & O_CREAT) && (_flags & O_EXCL)) { - entry_created = _gf_true; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } + + if (preparent.ia_prot.sgid) { + gid = preparent.ia_gid; + } + + if (!flags) { + _flags = O_CREAT | O_RDWR | O_EXCL; + } else { + _flags = flags | O_CREAT; + } + + op_ret = posix_pstat(this, loc->inode, NULL, real_path, &stbuf, _gf_false); + if ((op_ret == -1) && (errno == ENOENT)) { + was_present = 0; + } + + if (priv->o_direct) + _flags |= O_DIRECT; + + mode_bit = (priv->create_mask & mode) | priv->force_create_mode; + mode = posix_override_umask(mode, mode_bit); + _fd = sys_open(real_path, _flags, mode); + + if (_fd == -1) { + op_errno = errno; + op_ret = -1; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_OPEN_FAILED, + "open on %s failed", real_path); + goto out; + } + if ((_flags & O_CREAT) && (_flags & O_EXCL)) { + entry_created = _gf_true; + } - if (was_present) - goto fill_stat; + if (was_present) + goto fill_stat; #ifndef HAVE_SET_FSID - op_ret = sys_chown (real_path, frame->root->uid, gid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_CHOWN_FAILED, - "chown on %s failed", real_path); - } + op_ret = sys_chown(real_path, frame->root->uid, gid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CHOWN_FAILED, + "chown on %s failed", real_path); + } #endif - op_ret = posix_acl_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, - "setting ACLs on %s failed", real_path); - } - - if (priv->update_pgfid_nlinks) { - MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, - loc->pargfid); - nlink_samepgfid = 1; - SET_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, - XATTR_CREATE, op_ret, this, ignore); - } - - if (priv->gfid2path) { - posix_set_gfid2path_xattr (this, real_path, loc->pargfid, - loc->name); - } + op_ret = posix_acl_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_ACL_FAILED, + "setting ACLs on %s failed", real_path); + } + + if (priv->update_pgfid_nlinks) { + MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, + loc->pargfid); + nlink_samepgfid = 1; + SET_PGFID_XATTR(real_path, pgfid_xattr_key, nlink_samepgfid, + XATTR_CREATE, op_ret, this, ignore); + } + + if (priv->gfid2path) { + posix_set_gfid2path_xattr(this, real_path, loc->pargfid, loc->name); + } ignore: - op_ret = posix_entry_create_xattr_set (this, real_path, xdata); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, - "setting xattrs on %s failed ", real_path); - } + op_ret = posix_entry_create_xattr_set(this, real_path, xdata); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setting xattrs on %s failed ", real_path); + } fill_stat: - op_ret = posix_gfid_set (this, real_path, loc, xdata, frame->root->pid, - &op_errno); - if (op_ret) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, - "setting gfid on %s failed", real_path); - goto out; - } else { - gfid_set = _gf_true; - } - - op_ret = posix_fdstat (this, loc->inode, _fd, &stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fstat on %d failed", _fd); - goto out; - } + op_ret = posix_gfid_set(this, real_path, loc, xdata, frame->root->pid, + &op_errno); + if (op_ret) { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_GFID_FAILED, + "setting gfid on %s failed", real_path); + goto out; + } else { + gfid_set = _gf_true; + } + + op_ret = posix_fdstat(this, loc->inode, _fd, &stbuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fstat on %d failed", _fd); + goto out; + } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &stbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &stbuf); - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_path); - goto out; - } + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_path); + goto out; + } - posix_set_parent_ctime (frame, this, par_path, -1, loc->parent, - &postparent); + posix_set_parent_ctime(frame, this, par_path, -1, loc->parent, &postparent); - op_ret = -1; - pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); - if (!pfd) { - op_errno = errno; - goto out; - } + op_ret = -1; + pfd = GF_CALLOC(1, sizeof(*pfd), gf_posix_mt_posix_fd); + if (!pfd) { + op_errno = errno; + goto out; + } - pfd->flags = flags; - pfd->fd = _fd; + pfd->flags = flags; + pfd->fd = _fd; - op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); - if (op_ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_FD_PATH_SETTING_FAILED, - "failed to set the fd context path=%s fd=%p", - real_path, fd); + op_ret = fd_ctx_set(fd, this, (uint64_t)(long)pfd); + if (op_ret) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_FD_PATH_SETTING_FAILED, + "failed to set the fd context path=%s fd=%p", real_path, fd); - LOCK (&priv->lock); - { - priv->nr_files++; - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + priv->nr_files++; + } + UNLOCK(&priv->lock); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - if (op_ret < 0) { - if (_fd != -1) - sys_close (_fd); + if (op_ret < 0) { + if (_fd != -1) + sys_close(_fd); - if (entry_created) - sys_unlink (real_path); + if (entry_created) + sys_unlink(real_path); - if (gfid_set) - posix_gfid_unset (this, xdata); - } + if (gfid_set) + posix_gfid_unset(this, xdata); + } - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, - fd, (loc)?loc->inode:NULL, &stbuf, &preparent, - &postparent, xdata); + STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, + (loc) ? loc->inode : NULL, &stbuf, &preparent, + &postparent, xdata); - return 0; + return 0; } /* TODO: Ensure atomocity of put, and rollback in case of failure @@ -2265,97 +2234,101 @@ out: * and rename it to the specified location, if the put was successful */ int32_t -posix_put (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, mode_t umask, uint32_t flags, - struct iovec *vector, int32_t count, off_t offset, - struct iobref *iobref, dict_t *xattr, dict_t *xdata) +posix_put(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, uint32_t flags, struct iovec *vector, int32_t count, + off_t offset, struct iobref *iobref, dict_t *xattr, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - fd_t *fd = NULL; - char *real_path = NULL; - char *par_path = NULL; - struct iatt stbuf = {0, }; - struct iatt preparent = {0,}; - struct iatt postparent = {0,}; - - MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &preparent, _gf_false); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on parent %s failed", - par_path); - goto out; - } - fd = fd_create (loc->inode, getpid()); - if (!fd) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - fd->flags = flags; - - /* No xlators are expected below posix, but we cannot still call sys_create() - * directly here, as posix_create does many other things like chmod, setxattr - * etc. along with sys_create(). But we cannot also directly call posix_create() - * as it calls STACK_UNWIND. Hence using syncop() - */ - op_ret = syncop_create (this, loc, flags, mode, fd, &stbuf, xdata, NULL); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_CREATE_FAILED, - "create of %s failed", loc->path); - goto out; - } - - op_ret = posix_pstat (this, loc->parent, loc->pargfid, par_path, - &postparent, _gf_false); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on parent %s failed", - par_path); - goto out; - } - - op_ret = syncop_writev (this, fd, vector, count, offset, iobref, - flags, NULL, NULL, xdata, NULL); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_WRITE_FAILED, - "write on file %s failed", loc->path); - goto out; - } - - op_ret = syncop_fsetxattr (this, fd, xattr, flags, xdata, NULL); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, - "setxattr on file %s failed", loc->path); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + fd_t *fd = NULL; + char *real_path = NULL; + char *par_path = NULL; + struct iatt stbuf = { + 0, + }; + struct iatt preparent = { + 0, + }; + struct iatt postparent = { + 0, + }; + + MAKE_ENTRY_HANDLE(real_path, par_path, this, loc, &stbuf); + + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &preparent, + _gf_false); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on parent %s failed", par_path); + goto out; + } + fd = fd_create(loc->inode, getpid()); + if (!fd) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + fd->flags = flags; + + /* No xlators are expected below posix, but we cannot still call + * sys_create() directly here, as posix_create does many other things like + * chmod, setxattr etc. along with sys_create(). But we cannot also directly + * call posix_create() as it calls STACK_UNWIND. Hence using syncop() + */ + op_ret = syncop_create(this, loc, flags, mode, fd, &stbuf, xdata, NULL); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CREATE_FAILED, + "create of %s failed", loc->path); + goto out; + } + + op_ret = posix_pstat(this, loc->parent, loc->pargfid, par_path, &postparent, + _gf_false); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on parent %s failed", par_path); + goto out; + } + + op_ret = syncop_writev(this, fd, vector, count, offset, iobref, flags, NULL, + NULL, xdata, NULL); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_WRITE_FAILED, + "write on file %s failed", loc->path); + goto out; + } - op_ret = syncop_flush (this, fd, xdata, NULL); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_CLOSE_FAILED, - "setxattr on file %s failed", loc->path); - goto out; - } + op_ret = syncop_fsetxattr(this, fd, xattr, flags, xdata, NULL); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setxattr on file %s failed", loc->path); + goto out; + } - op_ret = posix_pstat (this, loc->inode, loc->gfid, real_path, &stbuf, _gf_false); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "post-operation lstat on %s failed", real_path); - goto out; - } + op_ret = syncop_flush(this, fd, xdata, NULL); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CLOSE_FAILED, + "setxattr on file %s failed", loc->path); + goto out; + } + + op_ret = posix_pstat(this, loc->inode, loc->gfid, real_path, &stbuf, + _gf_false); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "post-operation lstat on %s failed", real_path); + goto out; + } out: - STACK_UNWIND_STRICT (put, frame, op_ret, op_errno, loc->inode, &stbuf, - &preparent, &postparent, NULL); + STACK_UNWIND_STRICT(put, frame, op_ret, op_errno, loc->inode, &stbuf, + &preparent, &postparent, NULL); - return 0; + return 0; } diff --git a/xlators/storage/posix/src/posix-gfid-path.c b/xlators/storage/posix/src/posix-gfid-path.c index a08168a3bd4..4a81be28169 100644 --- a/xlators/storage/posix/src/posix-gfid-path.c +++ b/xlators/storage/posix/src/posix-gfid-path.c @@ -18,291 +18,300 @@ #include "posix.h" int32_t -posix_set_gfid2path_xattr (xlator_t *this, const char *path, uuid_t pgfid, - const char *bname) +posix_set_gfid2path_xattr(xlator_t *this, const char *path, uuid_t pgfid, + const char *bname) { - char xxh64[GF_XXH64_DIGEST_LENGTH*2+1] = {0,}; - char pgfid_bname[1024] = {0,}; - char *key = NULL; - char *val = NULL; - size_t key_size = 0; - size_t val_size = 0; - int ret = 0; + char xxh64[GF_XXH64_DIGEST_LENGTH * 2 + 1] = { + 0, + }; + char pgfid_bname[1024] = { + 0, + }; + char *key = NULL; + char *val = NULL; + size_t key_size = 0; + size_t val_size = 0; + int ret = 0; - GF_VALIDATE_OR_GOTO ("posix", this, err); + GF_VALIDATE_OR_GOTO("posix", this, err); - snprintf (pgfid_bname, sizeof (pgfid_bname), "%s/%s", uuid_utoa (pgfid), - bname); - gf_xxh64_wrapper ((unsigned char *) pgfid_bname, - strlen(pgfid_bname), GF_XXHSUM64_DEFAULT_SEED, xxh64); - key_size = GFID2PATH_XATTR_KEY_PREFIX_LENGTH + - GF_XXH64_DIGEST_LENGTH*2 + 1; - key = alloca (key_size); - snprintf (key, key_size, GFID2PATH_XATTR_KEY_PREFIX"%s", xxh64); + snprintf(pgfid_bname, sizeof(pgfid_bname), "%s/%s", uuid_utoa(pgfid), + bname); + gf_xxh64_wrapper((unsigned char *)pgfid_bname, strlen(pgfid_bname), + GF_XXHSUM64_DEFAULT_SEED, xxh64); + key_size = GFID2PATH_XATTR_KEY_PREFIX_LENGTH + GF_XXH64_DIGEST_LENGTH * 2 + + 1; + key = alloca(key_size); + snprintf(key, key_size, GFID2PATH_XATTR_KEY_PREFIX "%s", xxh64); - val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2; - val = alloca (val_size); - snprintf (val, val_size, "%s/%s", uuid_utoa (pgfid), bname); + val_size = UUID_CANONICAL_FORM_LEN + NAME_MAX + 2; + val = alloca(val_size); + snprintf(val, val_size, "%s/%s", uuid_utoa(pgfid), bname); - ret = sys_lsetxattr (path, key, val, strlen(val), XATTR_CREATE); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_PGFID_OP, - "setting gfid2path xattr failed on %s: key = %s ", - path, key); - goto err; - } - return 0; - err: - return -1; + ret = sys_lsetxattr(path, key, val, strlen(val), XATTR_CREATE); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_PGFID_OP, + "setting gfid2path xattr failed on %s: key = %s ", path, key); + goto err; + } + return 0; +err: + return -1; } int32_t -posix_remove_gfid2path_xattr (xlator_t *this, const char *path, - uuid_t pgfid, const char *bname) +posix_remove_gfid2path_xattr(xlator_t *this, const char *path, uuid_t pgfid, + const char *bname) { - char xxh64[GF_XXH64_DIGEST_LENGTH*2+1] = {0,}; - char pgfid_bname[1024] = {0,}; - int ret = 0; - char *key = NULL; - size_t key_size = 0; + char xxh64[GF_XXH64_DIGEST_LENGTH * 2 + 1] = { + 0, + }; + char pgfid_bname[1024] = { + 0, + }; + int ret = 0; + char *key = NULL; + size_t key_size = 0; - GF_VALIDATE_OR_GOTO ("posix", this, err); + GF_VALIDATE_OR_GOTO("posix", this, err); - snprintf (pgfid_bname, sizeof (pgfid_bname), "%s/%s", uuid_utoa (pgfid), - bname); - gf_xxh64_wrapper ((unsigned char *) pgfid_bname, - strlen(pgfid_bname), GF_XXHSUM64_DEFAULT_SEED, xxh64); - key_size = GFID2PATH_XATTR_KEY_PREFIX_LENGTH + - GF_XXH64_DIGEST_LENGTH*2 + 1; - key = alloca (key_size); - snprintf (key, key_size, GFID2PATH_XATTR_KEY_PREFIX"%s", xxh64); + snprintf(pgfid_bname, sizeof(pgfid_bname), "%s/%s", uuid_utoa(pgfid), + bname); + gf_xxh64_wrapper((unsigned char *)pgfid_bname, strlen(pgfid_bname), + GF_XXHSUM64_DEFAULT_SEED, xxh64); + key_size = GFID2PATH_XATTR_KEY_PREFIX_LENGTH + GF_XXH64_DIGEST_LENGTH * 2 + + 1; + key = alloca(key_size); + snprintf(key, key_size, GFID2PATH_XATTR_KEY_PREFIX "%s", xxh64); - ret = sys_lremovexattr (path, key); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_PGFID_OP, - "removing gfid2path xattr failed on %s: key = %s", - path, key); - goto err; - } - return 0; - err: - return -1; + ret = sys_lremovexattr(path, key); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_PGFID_OP, + "removing gfid2path xattr failed on %s: key = %s", path, key); + goto err; + } + return 0; +err: + return -1; } gf_boolean_t -posix_is_gfid2path_xattr (const char *name) +posix_is_gfid2path_xattr(const char *name) { - if (name && strncmp (GFID2PATH_XATTR_KEY_PREFIX, name, - GFID2PATH_XATTR_KEY_PREFIX_LENGTH) == 0) { - return _gf_true; - } else { - return _gf_false; - } + if (name && strncmp(GFID2PATH_XATTR_KEY_PREFIX, name, + GFID2PATH_XATTR_KEY_PREFIX_LENGTH) == 0) { + return _gf_true; + } else { + return _gf_false; + } } static int gf_posix_xattr_enotsup_log; int32_t -posix_get_gfid2path (xlator_t *this, inode_t *inode, const char *real_path, - int *op_errno, dict_t *dict) +posix_get_gfid2path(xlator_t *this, inode_t *inode, const char *real_path, + int *op_errno, dict_t *dict) { - int ret = 0; - char *path = NULL; - ssize_t size = 0; - char *list = NULL; - int32_t list_offset = 0; - int32_t i = 0; - int32_t j = 0; - char *paths[MAX_GFID2PATH_LINK_SUP] = {NULL,}; - char *value = NULL; - size_t remaining_size = 0; - size_t bytes = 0; - char keybuffer[4096] = {0,}; - char value_buf[8192] = {0,}; - uuid_t pargfid = {0,}; - gf_boolean_t have_val = _gf_false; - struct posix_private *priv = NULL; - char pargfid_str[UUID_CANONICAL_FORM_LEN + 1] = {0,}; - gf_boolean_t found = _gf_false; - int len; + int ret = 0; + char *path = NULL; + ssize_t size = 0; + char *list = NULL; + int32_t list_offset = 0; + int32_t i = 0; + int32_t j = 0; + char *paths[MAX_GFID2PATH_LINK_SUP] = { + NULL, + }; + char *value = NULL; + size_t remaining_size = 0; + size_t bytes = 0; + char keybuffer[4096] = { + 0, + }; + char value_buf[8192] = { + 0, + }; + uuid_t pargfid = { + 0, + }; + gf_boolean_t have_val = _gf_false; + struct posix_private *priv = NULL; + char pargfid_str[UUID_CANONICAL_FORM_LEN + 1] = { + 0, + }; + gf_boolean_t found = _gf_false; + int len; - priv = this->private; + priv = this->private; - if (IA_ISDIR (inode->ia_type)) { - ret = posix_resolve_dirgfid_to_path (inode->gfid, - priv->base_path, - NULL, &path); - if (ret < 0) { - ret = -1; - goto err; - } - ret = dict_set_dynstr (dict, GFID2PATH_VIRT_XATTR_KEY, path); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, -ret, - P_MSG_DICT_SET_FAILED, "could not set " - "value for key (%s)", GFID2PATH_VIRT_XATTR_KEY); - goto err; - } - found = _gf_true; + if (IA_ISDIR(inode->ia_type)) { + ret = posix_resolve_dirgfid_to_path(inode->gfid, priv->base_path, NULL, + &path); + if (ret < 0) { + ret = -1; + goto err; + } + ret = dict_set_dynstr(dict, GFID2PATH_VIRT_XATTR_KEY, path); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_DICT_SET_FAILED, + "could not set " + "value for key (%s)", + GFID2PATH_VIRT_XATTR_KEY); + goto err; + } + found = _gf_true; + } else { + have_val = _gf_false; + size = sys_llistxattr(real_path, value_buf, sizeof(value_buf) - 1); + if (size > 0) { + have_val = _gf_true; } else { - have_val = _gf_false; - size = sys_llistxattr (real_path, value_buf, - sizeof (value_buf) - 1); - if (size > 0) { - have_val = _gf_true; + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_DEBUG, errno, P_MSG_XATTR_FAILED, + "listxattr failed due to overflow of" + " buffer on %s ", + real_path); + size = sys_llistxattr(real_path, NULL, 0); + } + if (size == -1) { + *op_errno = errno; + if ((errno == ENOTSUP) || (errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting" + " brick with 'user_xattr' " + "flag)"); } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_DEBUG, errno, - P_MSG_XATTR_FAILED, - "listxattr failed due to overflow of" - " buffer on %s ", real_path); - size = sys_llistxattr (real_path, NULL, 0); - } - if (size == -1) { - *op_errno = errno; - if ((errno == ENOTSUP) || (errno == ENOSYS)) { - GF_LOG_OCCASIONALLY ( - gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting" - " brick with 'user_xattr' " - "flag)"); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, - "listxattr failed on %s", - real_path); - } - goto err; - } - if (size == 0) - goto done; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "listxattr failed on %s", real_path); } - list = alloca (size); - if (!list) { - *op_errno = errno; - goto err; - } - if (have_val) { - memcpy (list, value_buf, size); - } else { - size = sys_llistxattr (real_path, list, size); - if (size < 0) { - ret = -1; - *op_errno = errno; - goto err; - } - } - remaining_size = size; - list_offset = 0; - while (remaining_size > 0) { - snprintf (keybuffer, sizeof (keybuffer), "%s", - list + list_offset); + goto err; + } + if (size == 0) + goto done; + } + list = alloca(size); + if (!list) { + *op_errno = errno; + goto err; + } + if (have_val) { + memcpy(list, value_buf, size); + } else { + size = sys_llistxattr(real_path, list, size); + if (size < 0) { + ret = -1; + *op_errno = errno; + goto err; + } + } + remaining_size = size; + list_offset = 0; + while (remaining_size > 0) { + snprintf(keybuffer, sizeof(keybuffer), "%s", list + list_offset); - if (!posix_is_gfid2path_xattr (keybuffer)) { - goto ignore; - } + if (!posix_is_gfid2path_xattr(keybuffer)) { + goto ignore; + } - found = _gf_true; - size = sys_lgetxattr (real_path, keybuffer, value_buf, - sizeof (value_buf) - 1); - if (size == -1) { - ret = -1; - *op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "getxattr failed on" - " %s: key = %s ", real_path, keybuffer); - break; - } + found = _gf_true; + size = sys_lgetxattr(real_path, keybuffer, value_buf, + sizeof(value_buf) - 1); + if (size == -1) { + ret = -1; + *op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on" + " %s: key = %s ", + real_path, keybuffer); + break; + } - /* Parse pargfid from xattr value*/ - strncpy (pargfid_str, value_buf, 36); - pargfid_str[36] = '\0'; - gf_uuid_parse (pargfid_str, pargfid); + /* Parse pargfid from xattr value*/ + strncpy(pargfid_str, value_buf, 36); + pargfid_str[36] = '\0'; + gf_uuid_parse(pargfid_str, pargfid); - /* Convert pargfid to path */ - ret = posix_resolve_dirgfid_to_path (pargfid, - priv->base_path, - &value_buf[37], - &paths[i]); - i++; + /* Convert pargfid to path */ + ret = posix_resolve_dirgfid_to_path(pargfid, priv->base_path, + &value_buf[37], &paths[i]); + i++; -ignore: - len = strlen (keybuffer); - remaining_size -= (len + 1); - list_offset += (len + 1); - } /* while (remaining_size > 0) */ + ignore: + len = strlen(keybuffer); + remaining_size -= (len + 1); + list_offset += (len + 1); + } /* while (remaining_size > 0) */ - /* gfid2path xattr is absent in the list of xattrs */ - if (!found) { - ret = -1; - /* - * ENODATA because xattr is not present in the - * list of xattrs. Thus the consumer should - * face error instead of a success and a empty - * string in the dict for the key. - */ - *op_errno = ENODATA; - goto err; - } + /* gfid2path xattr is absent in the list of xattrs */ + if (!found) { + ret = -1; + /* + * ENODATA because xattr is not present in the + * list of xattrs. Thus the consumer should + * face error instead of a success and a empty + * string in the dict for the key. + */ + *op_errno = ENODATA; + goto err; + } - /* - * gfid2path xattr is found in list of xattrs, but getxattr - * on the 1st gfid2path xattr itself failed and the while - * loop above broke. So there is nothing in the value. So - * it would be better not to send "" as the value for any - * key, as it is not true. - */ - if (found && !i) - goto err; /* both errno and ret are set before beak */ + /* + * gfid2path xattr is found in list of xattrs, but getxattr + * on the 1st gfid2path xattr itself failed and the while + * loop above broke. So there is nothing in the value. So + * it would be better not to send "" as the value for any + * key, as it is not true. + */ + if (found && !i) + goto err; /* both errno and ret are set before beak */ - /* Calculate memory to be allocated */ - for (j = 0; j < i; j++) { - bytes += strlen(paths[j]); - if (j < i-1) - bytes += strlen(priv->gfid2path_sep); - } - value = GF_CALLOC (bytes + 1, sizeof(char), gf_posix_mt_char); - if (!value) { - ret = -1; - *op_errno = errno; - goto err; - } + /* Calculate memory to be allocated */ + for (j = 0; j < i; j++) { + bytes += strlen(paths[j]); + if (j < i - 1) + bytes += strlen(priv->gfid2path_sep); + } + value = GF_CALLOC(bytes + 1, sizeof(char), gf_posix_mt_char); + if (!value) { + ret = -1; + *op_errno = errno; + goto err; + } - for (j = 0; j < i; j++) { - strcat (value, paths[j]); - if (j != i - 1) - strcat (value, priv->gfid2path_sep); - } - value[bytes] = '\0'; + for (j = 0; j < i; j++) { + strcat(value, paths[j]); + if (j != i - 1) + strcat(value, priv->gfid2path_sep); + } + value[bytes] = '\0'; - ret = dict_set_dynptr (dict, GFID2PATH_VIRT_XATTR_KEY, - value, bytes); - if (ret < 0) { - *op_errno = -ret; - gf_msg (this->name, GF_LOG_ERROR, *op_errno, - P_MSG_DICT_SET_FAILED, "dict set operation " - "on %s for the key %s failed.", - real_path, GFID2PATH_VIRT_XATTR_KEY); - GF_FREE (value); - goto err; - } + ret = dict_set_dynptr(dict, GFID2PATH_VIRT_XATTR_KEY, value, bytes); + if (ret < 0) { + *op_errno = -ret; + gf_msg(this->name, GF_LOG_ERROR, *op_errno, P_MSG_DICT_SET_FAILED, + "dict set operation " + "on %s for the key %s failed.", + real_path, GFID2PATH_VIRT_XATTR_KEY); + GF_FREE(value); + goto err; } + } done: - for (j = 0; j < i; j++) { - if (paths[j]) - GF_FREE (paths[j]); - } - ret = 0; - return ret; + for (j = 0; j < i; j++) { + if (paths[j]) + GF_FREE(paths[j]); + } + ret = 0; + return ret; err: - if (path) - GF_FREE (path); - for (j = 0; j < i; j++) { - if (paths[j]) - GF_FREE (paths[j]); - } - return ret; + if (path) + GF_FREE(path); + for (j = 0; j < i; j++) { + if (paths[j]) + GF_FREE(paths[j]); + } + return ret; } diff --git a/xlators/storage/posix/src/posix-handle.c b/xlators/storage/posix/src/posix-handle.c index 802dcf1cc2a..bc34e3e5dba 100644 --- a/xlators/storage/posix/src/posix-handle.c +++ b/xlators/storage/posix/src/posix-handle.c @@ -28,366 +28,358 @@ #include "compat-errno.h" int -posix_handle_mkdir_hashes (xlator_t *this, const char *newpath); +posix_handle_mkdir_hashes(xlator_t *this, const char *newpath); inode_t * -posix_resolve (xlator_t *this, inode_table_t *itable, inode_t *parent, - char *bname, struct iatt *iabuf) +posix_resolve(xlator_t *this, inode_table_t *itable, inode_t *parent, + char *bname, struct iatt *iabuf) { - inode_t *inode = NULL; - int ret = -1; - - ret = posix_istat (this, NULL, parent->gfid, bname, iabuf); - if (ret < 0) { - gf_log (this->name, GF_LOG_WARNING, "gfid: %s, bname: %s " - "failed", uuid_utoa (parent->gfid), bname); - goto out; - } - - if (__is_root_gfid (iabuf->ia_gfid) && !strcmp (bname, "/")) { - inode = itable->root; - } else { - inode = inode_find (itable, iabuf->ia_gfid); - if (inode == NULL) { - inode = inode_new (itable); - gf_uuid_copy (inode->gfid, iabuf->ia_gfid); - } - } - - /* posix_istat wouldn't have fetched posix_mdata_t i.e., - * time attributes as inode is passed as NULL, hence get - * here once you got the inode - */ - ret = posix_get_mdata_xattr (this, NULL, -1, inode, iabuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GETMDATA_FAILED, - "posix get mdata failed on gfid:%s", - uuid_utoa (inode->gfid)); - goto out; - } - - /* Linking an inode here, can cause a race in posix_acl. - Parent inode gets linked here, but before - it reaches posix_acl_readdirp_cbk, create/lookup can - come on a leaf-inode, as parent-inode-ctx not yet updated - in posix_acl_readdirp_cbk, create and lookup can fail - with EACCESS. So do the inode linking in the quota xlator - - if (__is_root_gfid (iabuf->ia_gfid) && !strcmp (bname, "/")) - linked_inode = itable->root; - else - linked_inode = inode_link (inode, parent, bname, iabuf); - - inode_unref (inode);*/ + inode_t *inode = NULL; + int ret = -1; + + ret = posix_istat(this, NULL, parent->gfid, bname, iabuf); + if (ret < 0) { + gf_log(this->name, GF_LOG_WARNING, + "gfid: %s, bname: %s " + "failed", + uuid_utoa(parent->gfid), bname); + goto out; + } + + if (__is_root_gfid(iabuf->ia_gfid) && !strcmp(bname, "/")) { + inode = itable->root; + } else { + inode = inode_find(itable, iabuf->ia_gfid); + if (inode == NULL) { + inode = inode_new(itable); + gf_uuid_copy(inode->gfid, iabuf->ia_gfid); + } + } + + /* posix_istat wouldn't have fetched posix_mdata_t i.e., + * time attributes as inode is passed as NULL, hence get + * here once you got the inode + */ + ret = posix_get_mdata_xattr(this, NULL, -1, inode, iabuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GETMDATA_FAILED, + "posix get mdata failed on gfid:%s", uuid_utoa(inode->gfid)); + goto out; + } + + /* Linking an inode here, can cause a race in posix_acl. + Parent inode gets linked here, but before + it reaches posix_acl_readdirp_cbk, create/lookup can + come on a leaf-inode, as parent-inode-ctx not yet updated + in posix_acl_readdirp_cbk, create and lookup can fail + with EACCESS. So do the inode linking in the quota xlator + + if (__is_root_gfid (iabuf->ia_gfid) && !strcmp (bname, "/")) + linked_inode = itable->root; + else + linked_inode = inode_link (inode, parent, bname, iabuf); + + inode_unref (inode);*/ out: - return inode; + return inode; } int -posix_make_ancestral_node (const char *priv_base_path, char *path, int pathsize, - gf_dirent_t *head, - char *dir_name, struct iatt *iabuf, inode_t *inode, - int type, dict_t *xdata) +posix_make_ancestral_node(const char *priv_base_path, char *path, int pathsize, + gf_dirent_t *head, char *dir_name, struct iatt *iabuf, + inode_t *inode, int type, dict_t *xdata) { - gf_dirent_t *entry = NULL; - char real_path[PATH_MAX + 1] = {0, }, len = 0; - loc_t loc = {0, }; - int ret = -1; - - len = strlen (path) + strlen (dir_name) + 1; - if (len > pathsize) { - goto out; - } - - strcat (path, dir_name); - if (*dir_name != '/') - strcat (path, "/"); - - if (type & POSIX_ANCESTRY_DENTRY) { - entry = gf_dirent_for_name (dir_name); - if (!entry) - goto out; - - entry->d_stat = *iabuf; - entry->inode = inode_ref (inode); - - list_add_tail (&entry->list, &head->list); - snprintf(real_path, sizeof (real_path), "%s/%s", priv_base_path, path); - loc.inode = inode_ref (inode); - gf_uuid_copy (loc.gfid, inode->gfid); - - entry->dict = posix_xattr_fill (THIS, real_path, &loc, NULL, -1, - xdata, iabuf); - loc_wipe (&loc); - } - - ret = 0; + gf_dirent_t *entry = NULL; + char real_path[PATH_MAX + 1] = + { + 0, + }, + len = 0; + loc_t loc = { + 0, + }; + int ret = -1; + + len = strlen(path) + strlen(dir_name) + 1; + if (len > pathsize) { + goto out; + } + + strcat(path, dir_name); + if (*dir_name != '/') + strcat(path, "/"); + + if (type & POSIX_ANCESTRY_DENTRY) { + entry = gf_dirent_for_name(dir_name); + if (!entry) + goto out; + + entry->d_stat = *iabuf; + entry->inode = inode_ref(inode); + + list_add_tail(&entry->list, &head->list); + snprintf(real_path, sizeof(real_path), "%s/%s", priv_base_path, path); + loc.inode = inode_ref(inode); + gf_uuid_copy(loc.gfid, inode->gfid); + + entry->dict = posix_xattr_fill(THIS, real_path, &loc, NULL, -1, xdata, + iabuf); + loc_wipe(&loc); + } + + ret = 0; out: - return ret; + return ret; } int -posix_make_ancestryfromgfid (xlator_t *this, char *path, int pathsize, - gf_dirent_t *head, int type, uuid_t gfid, - const size_t handle_size, - const char *priv_base_path, inode_table_t *itable, - inode_t **parent, dict_t *xdata, int32_t *op_errno) +posix_make_ancestryfromgfid(xlator_t *this, char *path, int pathsize, + gf_dirent_t *head, int type, uuid_t gfid, + const size_t handle_size, + const char *priv_base_path, inode_table_t *itable, + inode_t **parent, dict_t *xdata, int32_t *op_errno) { - char *linkname = NULL; /* "../../<gfid[0]>/<gfid[1]/" - "<gfidstr>/<NAME_MAX>" */ - char *dir_handle = NULL; - char *pgfidstr = NULL; - char *saveptr = NULL; - ssize_t len = 0; - inode_t *inode = NULL; - struct iatt iabuf = {0, }; - int ret = -1; - uuid_t tmp_gfid = {0, }; - char *dir_stack[PATH_MAX/2 + 1]; /* Since PATH_MAX/2 also gives - an upper bound on depth of - directories tree */ - uuid_t gfid_stack[PATH_MAX/2 + 1]; - - char *dir_name = NULL; - char *saved_dir = NULL; - int top = -1; - - if (!path || !parent || !priv_base_path || gf_uuid_is_null (gfid)) { - *op_errno = EINVAL; - goto out; - } - - dir_handle = alloca (handle_size); - linkname = alloca (PATH_MAX); - gf_uuid_copy(tmp_gfid, gfid); - - while (top < PATH_MAX/2) { - - gf_uuid_copy(gfid_stack[++top], tmp_gfid); - if (__is_root_gfid (tmp_gfid)) { - - *parent = inode_ref (itable->root); - - saved_dir = alloca(sizeof ("/")); - strcpy(saved_dir, "/"); - dir_stack[top] = saved_dir; - break; - } else { - snprintf (dir_handle, handle_size, "%s/%s/%02x/%02x/%s", - priv_base_path, GF_HIDDEN_PATH, tmp_gfid[0], - tmp_gfid[1], uuid_utoa (tmp_gfid)); - - len = sys_readlink (dir_handle, linkname, PATH_MAX); - if (len < 0) { - *op_errno = errno; - gf_msg (this->name, (errno == ENOENT || - errno == ESTALE) - ? GF_LOG_DEBUG:GF_LOG_ERROR, errno, - P_MSG_READLINK_FAILED, "could not read" - " the link from the gfid handle %s ", - dir_handle); - ret = -1; - goto out; - } - - linkname[len] = '\0'; - - pgfidstr = strtok_r (linkname + SLEN("../../00/00/"), - "/", &saveptr); - dir_name = strtok_r (NULL, "/", &saveptr); - saved_dir = alloca(strlen(dir_name) + 1); - gf_uuid_parse (pgfidstr, tmp_gfid); - strcpy(saved_dir, dir_name); - dir_stack[top] = saved_dir; - } - } - if (top == PATH_MAX/2) { - gf_msg (this->name, GF_LOG_ERROR, - P_MSG_ANCESTORY_FAILED, - 0, "build ancestry failed due to " - "deep directory hierarchy, depth: %d.", top); - *op_errno = EINVAL; + char *linkname = NULL; /* "../../<gfid[0]>/<gfid[1]/" + "<gfidstr>/<NAME_MAX>" */ + char *dir_handle = NULL; + char *pgfidstr = NULL; + char *saveptr = NULL; + ssize_t len = 0; + inode_t *inode = NULL; + struct iatt iabuf = { + 0, + }; + int ret = -1; + uuid_t tmp_gfid = { + 0, + }; + char *dir_stack[PATH_MAX / 2 + 1]; /* Since PATH_MAX/2 also gives + an upper bound on depth of + directories tree */ + uuid_t gfid_stack[PATH_MAX / 2 + 1]; + + char *dir_name = NULL; + char *saved_dir = NULL; + int top = -1; + + if (!path || !parent || !priv_base_path || gf_uuid_is_null(gfid)) { + *op_errno = EINVAL; + goto out; + } + + dir_handle = alloca(handle_size); + linkname = alloca(PATH_MAX); + gf_uuid_copy(tmp_gfid, gfid); + + while (top < PATH_MAX / 2) { + gf_uuid_copy(gfid_stack[++top], tmp_gfid); + if (__is_root_gfid(tmp_gfid)) { + *parent = inode_ref(itable->root); + + saved_dir = alloca(sizeof("/")); + strcpy(saved_dir, "/"); + dir_stack[top] = saved_dir; + break; + } else { + snprintf(dir_handle, handle_size, "%s/%s/%02x/%02x/%s", + priv_base_path, GF_HIDDEN_PATH, tmp_gfid[0], tmp_gfid[1], + uuid_utoa(tmp_gfid)); + + len = sys_readlink(dir_handle, linkname, PATH_MAX); + if (len < 0) { + *op_errno = errno; + gf_msg(this->name, + (errno == ENOENT || errno == ESTALE) ? GF_LOG_DEBUG + : GF_LOG_ERROR, + errno, P_MSG_READLINK_FAILED, + "could not read" + " the link from the gfid handle %s ", + dir_handle); ret = -1; goto out; + } + + linkname[len] = '\0'; + + pgfidstr = strtok_r(linkname + SLEN("../../00/00/"), "/", &saveptr); + dir_name = strtok_r(NULL, "/", &saveptr); + saved_dir = alloca(strlen(dir_name) + 1); + gf_uuid_parse(pgfidstr, tmp_gfid); + strcpy(saved_dir, dir_name); + dir_stack[top] = saved_dir; + } + } + if (top == PATH_MAX / 2) { + gf_msg(this->name, GF_LOG_ERROR, P_MSG_ANCESTORY_FAILED, 0, + "build ancestry failed due to " + "deep directory hierarchy, depth: %d.", + top); + *op_errno = EINVAL; + ret = -1; + goto out; + } + + while (top >= 0) { + if (!*parent) { + /* There's no real "root" cause for how we end up here, + * so for now let's log this and bail out to prevent + * crashes. + */ + gf_msg(this->name, GF_LOG_WARNING, P_MSG_INODE_RESOLVE_FAILED, 0, + "OOPS: *parent is null (path: %s), bailing!", path); + goto out; + } + + memset(&iabuf, 0, sizeof(iabuf)); + inode = posix_resolve(this, itable, *parent, dir_stack[top], &iabuf); + if (inode == NULL) { + gf_msg(this->name, GF_LOG_ERROR, P_MSG_INODE_RESOLVE_FAILED, 0, + "posix resolve on the inode %s failed", + uuid_utoa(gfid_stack[top])); + *op_errno = ESTALE; + ret = -1; + goto out; + } + + ret = posix_make_ancestral_node(priv_base_path, path, pathsize, head, + dir_stack[top], &iabuf, inode, type, + xdata); + if (ret < 0) { + *op_errno = ENOMEM; + goto out; } - while (top >= 0) { - - if (!*parent) { - /* There's no real "root" cause for how we end up here, - * so for now let's log this and bail out to prevent - * crashes. - */ - gf_msg (this->name, GF_LOG_WARNING, - P_MSG_INODE_RESOLVE_FAILED, 0, - "OOPS: *parent is null (path: %s), bailing!", - path); - goto out; - } - - memset (&iabuf, 0, sizeof (iabuf)); - inode = posix_resolve (this, itable, *parent, - dir_stack[top], &iabuf); - if (inode == NULL) { - gf_msg (this->name, GF_LOG_ERROR, - P_MSG_INODE_RESOLVE_FAILED, - 0, "posix resolve on the inode %s failed", - uuid_utoa (gfid_stack[top])); - *op_errno = ESTALE; - ret = -1; - goto out; - } - - ret = posix_make_ancestral_node (priv_base_path, path, - pathsize, head, - dir_stack[top], &iabuf, - inode, type, xdata); - if (ret < 0) { - *op_errno = ENOMEM; - goto out; - } - - inode_unref (*parent); - *parent = inode; - top--; - } + inode_unref(*parent); + *parent = inode; + top--; + } out: - return ret; + return ret; } int -posix_handle_relpath (xlator_t *this, uuid_t gfid, const char *basename, - char *buf, size_t buflen) +posix_handle_relpath(xlator_t *this, uuid_t gfid, const char *basename, + char *buf, size_t buflen) { - char *uuid_str = NULL; - int len = 0; + char *uuid_str = NULL; + int len = 0; - len = SLEN("../") - + SLEN("../") - + SLEN("00/") - + SLEN("00/") - + SLEN(UUID0_STR) - + 1 /* '\0' */ - ; + len = SLEN("../") + SLEN("../") + SLEN("00/") + SLEN("00/") + + SLEN(UUID0_STR) + 1 /* '\0' */ + ; - if (basename) { - len += (strlen (basename) + 1); - } + if (basename) { + len += (strlen(basename) + 1); + } - if (buflen < len || !buf) - return len; + if (buflen < len || !buf) + return len; - uuid_str = uuid_utoa (gfid); + uuid_str = uuid_utoa(gfid); - if (basename) { - len = snprintf (buf, buflen, "../../%02x/%02x/%s/%s", - gfid[0], gfid[1], uuid_str, basename); - } else { - len = snprintf (buf, buflen, "../../%02x/%02x/%s", - gfid[0], gfid[1], uuid_str); - } + if (basename) { + len = snprintf(buf, buflen, "../../%02x/%02x/%s/%s", gfid[0], gfid[1], + uuid_str, basename); + } else { + len = snprintf(buf, buflen, "../../%02x/%02x/%s", gfid[0], gfid[1], + uuid_str); + } - return len; + return len; } - /* TODO: explain how this pump fixes ELOOP */ gf_boolean_t -posix_is_malformed_link (xlator_t *this, char *base_str, char *linkname, - size_t len) +posix_is_malformed_link(xlator_t *this, char *base_str, char *linkname, + size_t len) { - if ((len == 8) && strcmp (linkname, "../../..")) /*for root*/ - goto err; + if ((len == 8) && strcmp(linkname, "../../..")) /*for root*/ + goto err; - if (len < 50 || len >= 512) - goto err; + if (len < 50 || len >= 512) + goto err; - if (memcmp (linkname, "../../", 6) != 0) - goto err; + if (memcmp(linkname, "../../", 6) != 0) + goto err; - if ((linkname[2] != '/') || - (linkname[5] != '/') || - (linkname[8] != '/') || - (linkname[11] != '/') || - (linkname[48] != '/')) { - goto err; - } + if ((linkname[2] != '/') || (linkname[5] != '/') || (linkname[8] != '/') || + (linkname[11] != '/') || (linkname[48] != '/')) { + goto err; + } - if ((linkname[20] != '-') || - (linkname[25] != '-') || - (linkname[30] != '-') || - (linkname[35] != '-')) { - goto err; - } + if ((linkname[20] != '-') || (linkname[25] != '-') || + (linkname[30] != '-') || (linkname[35] != '-')) { + goto err; + } - return _gf_false; + return _gf_false; err: - gf_log_callingfn (this->name, GF_LOG_ERROR, "malformed internal link " - "%s for %s", linkname, base_str); - return _gf_true; + gf_log_callingfn(this->name, GF_LOG_ERROR, + "malformed internal link " + "%s for %s", + linkname, base_str); + return _gf_true; } int -posix_handle_pump (xlator_t *this, char *buf, int len, int maxlen, - char *base_str, int base_len, int pfx_len) +posix_handle_pump(xlator_t *this, char *buf, int len, int maxlen, + char *base_str, int base_len, int pfx_len) { - char linkname[512] = {0,}; /* "../../<gfid>/<NAME_MAX>" */ - int ret = 0; - int blen = 0; - int link_len = 0; - - /* is a directory's symlink-handle */ - ret = sys_readlink (base_str, linkname, 512); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_READLINK_FAILED, - "internal readlink failed on %s ", - base_str); - goto err; - } + char linkname[512] = { + 0, + }; /* "../../<gfid>/<NAME_MAX>" */ + int ret = 0; + int blen = 0; + int link_len = 0; - if (ret < 512) - linkname[ret] = 0; + /* is a directory's symlink-handle */ + ret = sys_readlink(base_str, linkname, 512); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_READLINK_FAILED, + "internal readlink failed on %s ", base_str); + goto err; + } - link_len = ret; + if (ret < 512) + linkname[ret] = 0; - if ((ret == 8) && memcmp (linkname, "../../..", 8) == 0) { - if (strcmp (base_str, buf) == 0) { - strcpy (buf + pfx_len, ".."); - } - goto out; + link_len = ret; + + if ((ret == 8) && memcmp(linkname, "../../..", 8) == 0) { + if (strcmp(base_str, buf) == 0) { + strcpy(buf + pfx_len, ".."); } + goto out; + } - if (posix_is_malformed_link (this, base_str, linkname, ret)) - goto err; + if (posix_is_malformed_link(this, base_str, linkname, ret)) + goto err; - blen = link_len - 48; + blen = link_len - 48; - if (len + blen >= maxlen) { - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_HANDLEPATH_FAILED, - "Unable to form handle path for %s (maxlen = %d)", - buf, maxlen); - goto err; - } + if (len + blen >= maxlen) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLEPATH_FAILED, + "Unable to form handle path for %s (maxlen = %d)", buf, maxlen); + goto err; + } - memmove (buf + base_len + blen, buf + base_len, - (strlen (buf) - base_len) + 1); + memmove(buf + base_len + blen, buf + base_len, + (strlen(buf) - base_len) + 1); - strncpy (base_str + pfx_len, linkname + 6, 42); + strncpy(base_str + pfx_len, linkname + 6, 42); - strncpy (buf + pfx_len, linkname + 6, link_len - 6); + strncpy(buf + pfx_len, linkname + 6, link_len - 6); out: - return len + blen; + return len + blen; err: - return -1; + return -1; } - /* posix_handle_path differs from posix_handle_gfid_path in the way that the path filled in @buf by posix_handle_path will return type IA_IFDIR when @@ -398,651 +390,606 @@ err: */ int -posix_handle_path (xlator_t *this, uuid_t gfid, const char *basename, - char *ubuf, size_t size) +posix_handle_path(xlator_t *this, uuid_t gfid, const char *basename, char *ubuf, + size_t size) { - struct posix_private *priv = NULL; - char *uuid_str = NULL; - int len = 0; - int ret = -1; - struct stat stat; - char *base_str = NULL; - int base_len = 0; - int pfx_len; - int maxlen; - char *buf; - - priv = this->private; - - uuid_str = uuid_utoa (gfid); - - if (ubuf) { - buf = ubuf; - maxlen = size; - } else { - maxlen = PATH_MAX; - buf = alloca (maxlen); - } - - base_len = (priv->base_path_length + SLEN(GF_HIDDEN_PATH) + 45); - base_str = alloca (base_len + 1); - base_len = snprintf (base_str, base_len + 1, "%s/%s/%02x/%02x/%s", - priv->base_path, GF_HIDDEN_PATH, gfid[0], gfid[1], - uuid_str); - - pfx_len = priv->base_path_length + 1 + SLEN(GF_HIDDEN_PATH) + 1; - - if (basename) { - len = snprintf (buf, maxlen, "%s/%s", base_str, basename); - } else { - len = snprintf (buf, maxlen, "%s", base_str); - } - - ret = sys_lstat (base_str, &stat); - - if (!(ret == 0 && S_ISLNK(stat.st_mode) && stat.st_nlink == 1)) - goto out; - - do { - errno = 0; - ret = posix_handle_pump (this, buf, len, maxlen, - base_str, base_len, pfx_len); - len = ret; - - if (ret == -1) - break; - - ret = sys_lstat (buf, &stat); - } while ((ret == -1) && errno == ELOOP); + struct posix_private *priv = NULL; + char *uuid_str = NULL; + int len = 0; + int ret = -1; + struct stat stat; + char *base_str = NULL; + int base_len = 0; + int pfx_len; + int maxlen; + char *buf; + + priv = this->private; + + uuid_str = uuid_utoa(gfid); + + if (ubuf) { + buf = ubuf; + maxlen = size; + } else { + maxlen = PATH_MAX; + buf = alloca(maxlen); + } + + base_len = (priv->base_path_length + SLEN(GF_HIDDEN_PATH) + 45); + base_str = alloca(base_len + 1); + base_len = snprintf(base_str, base_len + 1, "%s/%s/%02x/%02x/%s", + priv->base_path, GF_HIDDEN_PATH, gfid[0], gfid[1], + uuid_str); + + pfx_len = priv->base_path_length + 1 + SLEN(GF_HIDDEN_PATH) + 1; + + if (basename) { + len = snprintf(buf, maxlen, "%s/%s", base_str, basename); + } else { + len = snprintf(buf, maxlen, "%s", base_str); + } + + ret = sys_lstat(base_str, &stat); + + if (!(ret == 0 && S_ISLNK(stat.st_mode) && stat.st_nlink == 1)) + goto out; + + do { + errno = 0; + ret = posix_handle_pump(this, buf, len, maxlen, base_str, base_len, + pfx_len); + len = ret; + + if (ret == -1) + break; + + ret = sys_lstat(buf, &stat); + } while ((ret == -1) && errno == ELOOP); out: - return len + 1; + return len + 1; } - int -posix_handle_gfid_path (xlator_t *this, uuid_t gfid, const char *basename, - char *buf, size_t buflen) +posix_handle_gfid_path(xlator_t *this, uuid_t gfid, const char *basename, + char *buf, size_t buflen) { - struct posix_private *priv = NULL; - char *uuid_str = NULL; - int len = 0; - - priv = this->private; - - len = priv->base_path_length /* option directory "/export" */ - + SLEN("/") - + SLEN(GF_HIDDEN_PATH) - + SLEN("/") - + SLEN("00/") - + SLEN("00/") - + SLEN(UUID0_STR) - + 1 /* '\0' */ - ; + struct posix_private *priv = NULL; + char *uuid_str = NULL; + int len = 0; - if (basename) { - len += (strlen (basename) + 1); - } else { - len += 256; /* worst-case for directory's symlink-handle expansion */ - } + priv = this->private; - if ((buflen < len) || !buf) - return len; + len = priv->base_path_length /* option directory "/export" */ + + SLEN("/") + SLEN(GF_HIDDEN_PATH) + SLEN("/") + SLEN("00/") + + SLEN("00/") + SLEN(UUID0_STR) + 1 /* '\0' */ + ; - uuid_str = uuid_utoa (gfid); + if (basename) { + len += (strlen(basename) + 1); + } else { + len += 256; /* worst-case for directory's symlink-handle expansion */ + } - if (__is_root_gfid (gfid)) { - if (basename) { - len = snprintf (buf, buflen, "%s/%s", priv->base_path, - basename); - } else { - len = snprintf (buf, buflen, "%s", priv->base_path); - } - goto out; - } + if ((buflen < len) || !buf) + return len; + uuid_str = uuid_utoa(gfid); + + if (__is_root_gfid(gfid)) { if (basename) { - len = snprintf (buf, buflen, "%s/%s/%02x/%02x/%s/%s", priv->base_path, - GF_HIDDEN_PATH, gfid[0], gfid[1], uuid_str, basename); + len = snprintf(buf, buflen, "%s/%s", priv->base_path, basename); } else { - len = snprintf (buf, buflen, "%s/%s/%02x/%02x/%s", priv->base_path, - GF_HIDDEN_PATH, gfid[0], gfid[1], uuid_str); - } + len = snprintf(buf, buflen, "%s", priv->base_path); + } + goto out; + } + + if (basename) { + len = snprintf(buf, buflen, "%s/%s/%02x/%02x/%s/%s", priv->base_path, + GF_HIDDEN_PATH, gfid[0], gfid[1], uuid_str, basename); + } else { + len = snprintf(buf, buflen, "%s/%s/%02x/%02x/%s", priv->base_path, + GF_HIDDEN_PATH, gfid[0], gfid[1], uuid_str); + } out: - return len; + return len; } int -posix_handle_init (xlator_t *this) +posix_handle_init(xlator_t *this) { - struct posix_private *priv = NULL; - char *handle_pfx = NULL; - int ret = 0; - struct stat stbuf; - struct stat rootbuf; - struct stat exportbuf; - char *rootstr = NULL; - uuid_t gfid = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; - - priv = this->private; - - ret = sys_stat (priv->base_path, &exportbuf); - if (ret || !S_ISDIR (exportbuf.st_mode)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Not a directory: %s", priv->base_path); - return -1; - } + struct posix_private *priv = NULL; + char *handle_pfx = NULL; + int ret = 0; + struct stat stbuf; + struct stat rootbuf; + struct stat exportbuf; + char *rootstr = NULL; + uuid_t gfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + + priv = this->private; + + ret = sys_stat(priv->base_path, &exportbuf); + if (ret || !S_ISDIR(exportbuf.st_mode)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Not a directory: %s", priv->base_path); + return -1; + } - handle_pfx = alloca (priv->base_path_length + 1 + - SLEN (GF_HIDDEN_PATH) + 1); + handle_pfx = alloca(priv->base_path_length + 1 + SLEN(GF_HIDDEN_PATH) + 1); - sprintf (handle_pfx, "%s/%s", priv->base_path, GF_HIDDEN_PATH); + sprintf(handle_pfx, "%s/%s", priv->base_path, GF_HIDDEN_PATH); - ret = sys_stat (handle_pfx, &stbuf); - switch (ret) { + ret = sys_stat(handle_pfx, &stbuf); + switch (ret) { case -1: - if (errno == ENOENT) { - ret = sys_mkdir (handle_pfx, 0600); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "Creating directory %s failed", - handle_pfx); - return -1; - } - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "Checking for %s failed", - handle_pfx); - return -1; + if (errno == ENOENT) { + ret = sys_mkdir(handle_pfx, 0600); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "Creating directory %s failed", handle_pfx); + return -1; } - break; + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "Checking for %s failed", handle_pfx); + return -1; + } + break; case 0: - if (!S_ISDIR (stbuf.st_mode)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Not a directory: %s", - handle_pfx); - return -1; - } - break; + if (!S_ISDIR(stbuf.st_mode)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Not a directory: %s", handle_pfx); + return -1; + } + break; default: - break; - } - - ret = sys_stat (handle_pfx, &priv->handledir); + break; + } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, - "stat for %s failed", handle_pfx); - return -1; - } + ret = sys_stat(handle_pfx, &priv->handledir); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "stat for %s failed", handle_pfx); + return -1; + } - MAKE_HANDLE_ABSPATH(rootstr, this, gfid); + MAKE_HANDLE_ABSPATH(rootstr, this, gfid); - ret = sys_stat (rootstr, &rootbuf); - switch (ret) { + ret = sys_stat(rootstr, &rootbuf); + switch (ret) { case -1: - if (errno != ENOENT) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "%s", priv->base_path); - return -1; - } + if (errno != ENOENT) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "%s", priv->base_path); + return -1; + } - ret = posix_handle_mkdir_hashes (this, rootstr); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "mkdir %s failed", rootstr); - return -1; - } + ret = posix_handle_mkdir_hashes(this, rootstr); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "mkdir %s failed", rootstr); + return -1; + } - ret = sys_symlink ("../../..", rootstr); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "symlink %s creation failed", - rootstr); - return -1; - } - break; - case 0: - if ((exportbuf.st_ino == rootbuf.st_ino) && - (exportbuf.st_dev == rootbuf.st_dev)) - return 0; - - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_HANDLE_CREATE, - "Different dirs %s (%lld/%lld) != %s (%lld/%lld)", - priv->base_path, (long long) exportbuf.st_ino, - (long long) exportbuf.st_dev, rootstr, - (long long) rootbuf.st_ino, (long long) rootbuf.st_dev); + ret = sys_symlink("../../..", rootstr); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "symlink %s creation failed", rootstr); return -1; + } + break; + case 0: + if ((exportbuf.st_ino == rootbuf.st_ino) && + (exportbuf.st_dev == rootbuf.st_dev)) + return 0; - break; - } + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_HANDLE_CREATE, + "Different dirs %s (%lld/%lld) != %s (%lld/%lld)", + priv->base_path, (long long)exportbuf.st_ino, + (long long)exportbuf.st_dev, rootstr, + (long long)rootbuf.st_ino, (long long)rootbuf.st_dev); + return -1; - return 0; + break; + } + + return 0; } gf_boolean_t -posix_does_old_trash_exists (char *old_trash) +posix_does_old_trash_exists(char *old_trash) { - uuid_t gfid = {0}; - gf_boolean_t exists = _gf_false; - struct stat stbuf = {0}; - int ret = 0; - - ret = sys_lstat (old_trash, &stbuf); - if ((ret == 0) && S_ISDIR (stbuf.st_mode)) { - ret = sys_lgetxattr (old_trash, "trusted.gfid", gfid, 16); - if ((ret < 0) && (errno == ENODATA || errno == ENOATTR) ) - exists = _gf_true; - } - return exists; + uuid_t gfid = {0}; + gf_boolean_t exists = _gf_false; + struct stat stbuf = {0}; + int ret = 0; + + ret = sys_lstat(old_trash, &stbuf); + if ((ret == 0) && S_ISDIR(stbuf.st_mode)) { + ret = sys_lgetxattr(old_trash, "trusted.gfid", gfid, 16); + if ((ret < 0) && (errno == ENODATA || errno == ENOATTR)) + exists = _gf_true; + } + return exists; } int -posix_handle_new_trash_init (xlator_t *this, char *trash) +posix_handle_new_trash_init(xlator_t *this, char *trash) { - int ret = 0; - struct stat stbuf = {0}; + int ret = 0; + struct stat stbuf = {0}; - ret = sys_lstat (trash, &stbuf); - switch (ret) { + ret = sys_lstat(trash, &stbuf); + switch (ret) { case -1: - if (errno == ENOENT) { - ret = sys_mkdir (trash, 0755); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_TRASH_CREATE, - "Creating directory %s failed", - trash); - } - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_TRASH_CREATE, - "Checking for %s failed", trash); + if (errno == ENOENT) { + ret = sys_mkdir(trash, 0755); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_HANDLE_TRASH_CREATE, + "Creating directory %s failed", trash); } - break; + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_HANDLE_TRASH_CREATE, "Checking for %s failed", + trash); + } + break; case 0: - if (!S_ISDIR (stbuf.st_mode)) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_TRASH_CREATE, - "Not a directory: %s", trash); - ret = -1; - } - break; + if (!S_ISDIR(stbuf.st_mode)) { + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_HANDLE_TRASH_CREATE, "Not a directory: %s", trash); + ret = -1; + } + break; default: - break; - } - return ret; + break; + } + return ret; } int -posix_mv_old_trash_into_new_trash (xlator_t *this, char *old, char *new) +posix_mv_old_trash_into_new_trash(xlator_t *this, char *old, char *new) { - char dest_old[PATH_MAX] = {0}; - int ret = 0; - uuid_t dest_name = {0}; - - if (!posix_does_old_trash_exists (old)) - goto out; - gf_uuid_generate (dest_name); - snprintf (dest_old, sizeof (dest_old), "%s/%s", new, - uuid_utoa (dest_name)); - ret = sys_rename (old, dest_old); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_TRASH_CREATE, - "Not able to move %s -> %s ", old, dest_old); - } + char dest_old[PATH_MAX] = {0}; + int ret = 0; + uuid_t dest_name = {0}; + + if (!posix_does_old_trash_exists(old)) + goto out; + gf_uuid_generate(dest_name); + snprintf(dest_old, sizeof(dest_old), "%s/%s", new, uuid_utoa(dest_name)); + ret = sys_rename(old, dest_old); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_TRASH_CREATE, + "Not able to move %s -> %s ", old, dest_old); + } out: - return ret; + return ret; } int -posix_handle_trash_init (xlator_t *this) +posix_handle_trash_init(xlator_t *this) { - int ret = -1; - struct posix_private *priv = NULL; - char old_trash[PATH_MAX] = {0}; - - priv = this->private; - - priv->trash_path = GF_MALLOC (priv->base_path_length + SLEN ("/") - + SLEN (GF_HIDDEN_PATH) + SLEN ("/") - + SLEN (TRASH_DIR) + 1, - gf_posix_mt_trash_path); - - if (!priv->trash_path) - goto out; - - snprintf (priv->trash_path, priv->base_path_length - + SLEN (GF_HIDDEN_PATH) + SLEN (TRASH_DIR) + 3, - "%s/%s/%s", priv->base_path, GF_HIDDEN_PATH, TRASH_DIR); - - ret = posix_handle_new_trash_init (this, priv->trash_path); - if (ret) - goto out; - snprintf (old_trash, sizeof (old_trash), "%s/.landfill", - priv->base_path); - ret = posix_mv_old_trash_into_new_trash (this, old_trash, - priv->trash_path); + int ret = -1; + struct posix_private *priv = NULL; + char old_trash[PATH_MAX] = {0}; + + priv = this->private; + + priv->trash_path = GF_MALLOC(priv->base_path_length + SLEN("/") + + SLEN(GF_HIDDEN_PATH) + SLEN("/") + + SLEN(TRASH_DIR) + 1, + gf_posix_mt_trash_path); + + if (!priv->trash_path) + goto out; + + snprintf( + priv->trash_path, + priv->base_path_length + SLEN(GF_HIDDEN_PATH) + SLEN(TRASH_DIR) + 3, + "%s/%s/%s", priv->base_path, GF_HIDDEN_PATH, TRASH_DIR); + + ret = posix_handle_new_trash_init(this, priv->trash_path); + if (ret) + goto out; + snprintf(old_trash, sizeof(old_trash), "%s/.landfill", priv->base_path); + ret = posix_mv_old_trash_into_new_trash(this, old_trash, priv->trash_path); out: - return ret; + return ret; } int -posix_handle_mkdir_hashes (xlator_t *this, const char *newpath) +posix_handle_mkdir_hashes(xlator_t *this, const char *newpath) { - char *duppath = NULL; - char *parpath = NULL; - int ret = 0; - - duppath = strdupa (newpath); - parpath = dirname (duppath); - parpath = dirname (duppath); - - ret = sys_mkdir (parpath, 0700); - if (ret == -1 && errno != EEXIST) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "error mkdir hash-1 %s ", parpath); - return -1; - } + char *duppath = NULL; + char *parpath = NULL; + int ret = 0; + + duppath = strdupa(newpath); + parpath = dirname(duppath); + parpath = dirname(duppath); + + ret = sys_mkdir(parpath, 0700); + if (ret == -1 && errno != EEXIST) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "error mkdir hash-1 %s ", parpath); + return -1; + } - strcpy (duppath, newpath); - parpath = dirname (duppath); + strcpy(duppath, newpath); + parpath = dirname(duppath); - ret = sys_mkdir (parpath, 0700); - if (ret == -1 && errno != EEXIST) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_HANDLE_CREATE, - "error mkdir hash-2 %s ", parpath); - return -1; - } + ret = sys_mkdir(parpath, 0700); + if (ret == -1 && errno != EEXIST) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_HANDLE_CREATE, + "error mkdir hash-2 %s ", parpath); + return -1; + } - return 0; + return 0; } - int -posix_handle_hard (xlator_t *this, const char *oldpath, uuid_t gfid, struct stat *oldbuf) +posix_handle_hard(xlator_t *this, const char *oldpath, uuid_t gfid, + struct stat *oldbuf) { - char *newpath = NULL; - struct stat newbuf; - int ret = -1; + char *newpath = NULL; + struct stat newbuf; + int ret = -1; + MAKE_HANDLE_ABSPATH(newpath, this, gfid); - MAKE_HANDLE_ABSPATH (newpath, this, gfid); + ret = sys_lstat(newpath, &newbuf); + if (ret == -1 && errno != ENOENT) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, "%s", + newpath); + return -1; + } - ret = sys_lstat (newpath, &newbuf); - if (ret == -1 && errno != ENOENT) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "%s", newpath); - return -1; + if (ret == -1 && errno == ENOENT) { + ret = posix_handle_mkdir_hashes(this, newpath); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "mkdir %s failed ", newpath); + return -1; } - if (ret == -1 && errno == ENOENT) { - ret = posix_handle_mkdir_hashes (this, newpath); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, "mkdir %s failed ", - newpath); - return -1; - } - - ret = sys_link (oldpath, newpath); - - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, "link %s -> %s" - "failed ", oldpath, newpath); - return -1; - } + ret = sys_link(oldpath, newpath); - ret = sys_lstat (newpath, &newbuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "lstat on %s failed", newpath); - return -1; - } - } - - if (newbuf.st_ino != oldbuf->st_ino || - newbuf.st_dev != oldbuf->st_dev) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_HANDLE_CREATE, - "mismatching ino/dev between file %s (%lld/%lld) " - "and handle %s (%lld/%lld)", - oldpath, (long long) oldbuf->st_ino, (long long) oldbuf->st_dev, - newpath, (long long) newbuf.st_ino, (long long) newbuf.st_dev); - ret = -1; + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "link %s -> %s" + "failed ", + oldpath, newpath); + return -1; } - return ret; + ret = sys_lstat(newpath, &newbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "lstat on %s failed", newpath); + return -1; + } + } + + if (newbuf.st_ino != oldbuf->st_ino || newbuf.st_dev != oldbuf->st_dev) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLE_CREATE, + "mismatching ino/dev between file %s (%lld/%lld) " + "and handle %s (%lld/%lld)", + oldpath, (long long)oldbuf->st_ino, (long long)oldbuf->st_dev, + newpath, (long long)newbuf.st_ino, (long long)newbuf.st_dev); + ret = -1; + } + + return ret; } - int -posix_handle_soft (xlator_t *this, const char *real_path, loc_t *loc, - uuid_t gfid, struct stat *oldbuf) +posix_handle_soft(xlator_t *this, const char *real_path, loc_t *loc, + uuid_t gfid, struct stat *oldbuf) { - char *oldpath = NULL; - char *newpath = NULL; - struct stat newbuf; - int ret = -1; - - MAKE_HANDLE_ABSPATH (newpath, this, gfid); - MAKE_HANDLE_RELPATH (oldpath, this, loc->pargfid, loc->name); - - ret = sys_lstat (newpath, &newbuf); - if (ret == -1 && errno != ENOENT) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, "%s", newpath); - return -1; - } - - if (ret == -1 && errno == ENOENT) { - if (posix_is_malformed_link (this, newpath, oldpath, - strlen (oldpath))) { - GF_ASSERT (!"Malformed link"); - errno = EINVAL; - return -1; - } - ret = posix_handle_mkdir_hashes (this, newpath); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "mkdir %s failed ", newpath); - return -1; - } - - ret = sys_symlink (oldpath, newpath); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "symlink %s -> %s failed", - oldpath, newpath); - return -1; - } + char *oldpath = NULL; + char *newpath = NULL; + struct stat newbuf; + int ret = -1; + + MAKE_HANDLE_ABSPATH(newpath, this, gfid); + MAKE_HANDLE_RELPATH(oldpath, this, loc->pargfid, loc->name); + + ret = sys_lstat(newpath, &newbuf); + if (ret == -1 && errno != ENOENT) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, "%s", + newpath); + return -1; + } - ret = sys_lstat (newpath, &newbuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "stat on %s failed ", newpath); - return -1; - } + if (ret == -1 && errno == ENOENT) { + if (posix_is_malformed_link(this, newpath, oldpath, strlen(oldpath))) { + GF_ASSERT(!"Malformed link"); + errno = EINVAL; + return -1; + } + ret = posix_handle_mkdir_hashes(this, newpath); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "mkdir %s failed ", newpath); + return -1; } - ret = sys_stat (real_path, &newbuf); + ret = sys_symlink(oldpath, newpath); if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, - "stat on %s failed ", newpath); - return -1; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "symlink %s -> %s failed", oldpath, newpath); + return -1; } - if (!oldbuf) - return ret; - - if (newbuf.st_ino != oldbuf->st_ino || - newbuf.st_dev != oldbuf->st_dev) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_HANDLE_CREATE, - "mismatching ino/dev between file %s (%lld/%lld) " - "and handle %s (%lld/%lld)", - oldpath, (long long) oldbuf->st_ino, (long long) oldbuf->st_dev, - newpath, (long long) newbuf.st_ino, (long long) newbuf.st_dev); - ret = -1; + ret = sys_lstat(newpath, &newbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "stat on %s failed ", newpath); + return -1; } + } + ret = sys_stat(real_path, &newbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "stat on %s failed ", newpath); + return -1; + } + + if (!oldbuf) return ret; -} + if (newbuf.st_ino != oldbuf->st_ino || newbuf.st_dev != oldbuf->st_dev) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLE_CREATE, + "mismatching ino/dev between file %s (%lld/%lld) " + "and handle %s (%lld/%lld)", + oldpath, (long long)oldbuf->st_ino, (long long)oldbuf->st_dev, + newpath, (long long)newbuf.st_ino, (long long)newbuf.st_dev); + ret = -1; + } + + return ret; +} int -posix_handle_unset_gfid (xlator_t *this, uuid_t gfid) +posix_handle_unset_gfid(xlator_t *this, uuid_t gfid) { - char *path = NULL; - int ret = 0; - struct stat stat; + char *path = NULL; + int ret = 0; + struct stat stat; - MAKE_HANDLE_GFID_PATH (path, this, gfid, NULL); + MAKE_HANDLE_GFID_PATH(path, this, gfid, NULL); - ret = sys_lstat (path, &stat); + ret = sys_lstat(path, &stat); - if (ret == -1) { - if (errno != ENOENT) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_DELETE, "%s", path); - } - goto out; + if (ret == -1) { + if (errno != ENOENT) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_DELETE, "%s", + path); } + goto out; + } - ret = sys_unlink (path); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_DELETE, "unlink %s failed ", path); - } + ret = sys_unlink(path); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_DELETE, + "unlink %s failed ", path); + } out: - return ret; + return ret; } - int -posix_handle_unset (xlator_t *this, uuid_t gfid, const char *basename) +posix_handle_unset(xlator_t *this, uuid_t gfid, const char *basename) { - int ret; - struct iatt stat; - char *path = NULL; - - if (!basename) { - ret = posix_handle_unset_gfid (this, gfid); - return ret; - } + int ret; + struct iatt stat; + char *path = NULL; - MAKE_HANDLE_PATH (path, this, gfid, basename); - if (!path) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_HANDLE_DELETE, - "Failed to create handle path for %s (%s)", - basename, uuid_utoa(gfid)); - return -1; - } + if (!basename) { + ret = posix_handle_unset_gfid(this, gfid); + return ret; + } - /* stat is being used only for gfid, so passing a NULL inode - * doesn't fetch time attributes which is fine - */ - ret = posix_istat (this, NULL, gfid, basename, &stat); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_DELETE, "%s", path); - return -1; - } + MAKE_HANDLE_PATH(path, this, gfid, basename); + if (!path) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLE_DELETE, + "Failed to create handle path for %s (%s)", basename, + uuid_utoa(gfid)); + return -1; + } + + /* stat is being used only for gfid, so passing a NULL inode + * doesn't fetch time attributes which is fine + */ + ret = posix_istat(this, NULL, gfid, basename, &stat); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_DELETE, "%s", + path); + return -1; + } - ret = posix_handle_unset_gfid (this, stat.ia_gfid); + ret = posix_handle_unset_gfid(this, stat.ia_gfid); - return ret; + return ret; } - int -posix_create_link_if_gfid_exists (xlator_t *this, uuid_t gfid, char *real_path, - inode_table_t *itable) +posix_create_link_if_gfid_exists(xlator_t *this, uuid_t gfid, char *real_path, + inode_table_t *itable) { - int ret = -1; - char *newpath = NULL; - char *unlink_path = NULL; - uint64_t ctx_int = 0; - inode_t *inode = NULL; - struct stat stbuf = {0,}; - struct posix_private *priv = NULL; - posix_inode_ctx_t *ctx = NULL; - - priv = this->private; - - MAKE_HANDLE_PATH (newpath, this, gfid, NULL); - if (!newpath) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_HANDLE_CREATE, - "Failed to create handle path (%s)", uuid_utoa(gfid)); - return ret; - } - - ret = sys_lstat (newpath, &stbuf); - if (!ret) { - ret = sys_link (newpath, real_path); - } else { - inode = inode_find (itable, gfid); - if (!inode) - return -1; - - LOCK (&inode->lock); - { - ret = __posix_inode_ctx_get_all (inode, this, &ctx); - if (ret) - goto unlock; - - if (ctx->unlink_flag != GF_UNLINK_TRUE) { - ret = -1; - goto unlock; - } - - POSIX_GET_FILE_UNLINK_PATH (priv->base_path, gfid, - unlink_path); - ret = sys_link (unlink_path, real_path); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, "Failed to link " - "%s with %s", real_path, unlink_path); - goto unlock; - } - ret = sys_rename (unlink_path, newpath); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HANDLE_CREATE, "Failed to link " - "%s with %s", real_path, unlink_path); - goto unlock; - } - ctx_int = GF_UNLINK_FALSE; - ret = __posix_inode_ctx_set_unlink_flag (inode, this, - ctx_int); - } -unlock: - UNLOCK (&inode->lock); - - inode_unref (inode); - } - + int ret = -1; + char *newpath = NULL; + char *unlink_path = NULL; + uint64_t ctx_int = 0; + inode_t *inode = NULL; + struct stat stbuf = { + 0, + }; + struct posix_private *priv = NULL; + posix_inode_ctx_t *ctx = NULL; + + priv = this->private; + + MAKE_HANDLE_PATH(newpath, this, gfid, NULL); + if (!newpath) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLE_CREATE, + "Failed to create handle path (%s)", uuid_utoa(gfid)); return ret; + } + + ret = sys_lstat(newpath, &stbuf); + if (!ret) { + ret = sys_link(newpath, real_path); + } else { + inode = inode_find(itable, gfid); + if (!inode) + return -1; + + LOCK(&inode->lock); + { + ret = __posix_inode_ctx_get_all(inode, this, &ctx); + if (ret) + goto unlock; + + if (ctx->unlink_flag != GF_UNLINK_TRUE) { + ret = -1; + goto unlock; + } + + POSIX_GET_FILE_UNLINK_PATH(priv->base_path, gfid, unlink_path); + ret = sys_link(unlink_path, real_path); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "Failed to link " + "%s with %s", + real_path, unlink_path); + goto unlock; + } + ret = sys_rename(unlink_path, newpath); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HANDLE_CREATE, + "Failed to link " + "%s with %s", + real_path, unlink_path); + goto unlock; + } + ctx_int = GF_UNLINK_FALSE; + ret = __posix_inode_ctx_set_unlink_flag(inode, this, ctx_int); + } + unlock: + UNLOCK(&inode->lock); + + inode_unref(inode); + } + + return ret; } diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c index 8c0355e918f..99ee094c114 100644 --- a/xlators/storage/posix/src/posix-helpers.c +++ b/xlators/storage/posix/src/posix-helpers.c @@ -60,2218 +60,2173 @@ #include <sys/types.h> char *marker_xattrs[] = {"trusted.glusterfs.quota.*", - "trusted.glusterfs.*.xtime", - NULL}; + "trusted.glusterfs.*.xtime", NULL}; char *marker_contri_key = "trusted.*.*.contri"; -static char* posix_ignore_xattrs[] = { - "gfid-req", - GLUSTERFS_ENTRYLK_COUNT, - GLUSTERFS_INODELK_COUNT, - GLUSTERFS_POSIXLK_COUNT, - GLUSTERFS_PARENT_ENTRYLK, - GF_GFIDLESS_LOOKUP, - GLUSTERFS_INODELK_DOM_COUNT, - GLUSTERFS_INTERNAL_FOP_KEY, - NULL -}; - -static char* list_xattr_ignore_xattrs[] = { - GF_SELINUX_XATTR_KEY, - GF_XATTR_VOL_ID_KEY, - GFID_XATTR_KEY, - NULL -}; +static char *posix_ignore_xattrs[] = {"gfid-req", + GLUSTERFS_ENTRYLK_COUNT, + GLUSTERFS_INODELK_COUNT, + GLUSTERFS_POSIXLK_COUNT, + GLUSTERFS_PARENT_ENTRYLK, + GF_GFIDLESS_LOOKUP, + GLUSTERFS_INODELK_DOM_COUNT, + GLUSTERFS_INTERNAL_FOP_KEY, + NULL}; + +static char *list_xattr_ignore_xattrs[] = { + GF_SELINUX_XATTR_KEY, GF_XATTR_VOL_ID_KEY, GFID_XATTR_KEY, NULL}; gf_boolean_t -posix_special_xattr (char **pattern, char *key) +posix_special_xattr(char **pattern, char *key) { - int i = 0; - gf_boolean_t flag = _gf_false; + int i = 0; + gf_boolean_t flag = _gf_false; - GF_VALIDATE_OR_GOTO ("posix", pattern, out); - GF_VALIDATE_OR_GOTO ("posix", key, out); + GF_VALIDATE_OR_GOTO("posix", pattern, out); + GF_VALIDATE_OR_GOTO("posix", key, out); - for (i = 0; pattern[i]; i++) { - if (!fnmatch (pattern[i], key, 0)) { - flag = _gf_true; - break; - } + for (i = 0; pattern[i]; i++) { + if (!fnmatch(pattern[i], key, 0)) { + flag = _gf_true; + break; } + } out: - return flag; + return flag; } int -posix_handle_mdata_xattr (call_frame_t *frame, const char *name, int *op_errno) -{ - int i = 0; - int ret = 0; - int pid = 1; - static const char * const internal_xattr[] = { GF_XATTR_MDATA_KEY, - NULL - }; - if (frame && frame->root) { - pid = frame->root->pid; - } - - if (!name || pid < GF_CLIENT_PID_MAX) { - /* No need to do anything here */ - ret = 0; - goto out; - } +posix_handle_mdata_xattr(call_frame_t *frame, const char *name, int *op_errno) +{ + int i = 0; + int ret = 0; + int pid = 1; + static const char *const internal_xattr[] = {GF_XATTR_MDATA_KEY, NULL}; + if (frame && frame->root) { + pid = frame->root->pid; + } + + if (!name || pid < GF_CLIENT_PID_MAX) { + /* No need to do anything here */ + ret = 0; + goto out; + } - for (i = 0; internal_xattr[i]; i++) { - if (fnmatch (internal_xattr[i] , name, FNM_PERIOD) == 0) { - ret = -1; - if (op_errno) { - *op_errno = ENOATTR; - } + for (i = 0; internal_xattr[i]; i++) { + if (fnmatch(internal_xattr[i], name, FNM_PERIOD) == 0) { + ret = -1; + if (op_errno) { + *op_errno = ENOATTR; + } - gf_msg_debug ("posix", ENOATTR, - "Ignoring the key %s as an internal " - "xattrs.", name); - goto out; - } + gf_msg_debug("posix", ENOATTR, + "Ignoring the key %s as an internal " + "xattrs.", + name); + goto out; } + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int -posix_handle_georep_xattrs (call_frame_t *frame, const char *name, - int *op_errno, gf_boolean_t is_getxattr) -{ - - int i = 0; - int ret = 0; - int pid = 1; - gf_boolean_t filter_xattr = _gf_true; - static const char *georep_xattr[] = { "*.glusterfs.*.stime", - "*.glusterfs.*.xtime", - "*.glusterfs.*.entry_stime", - "*.glusterfs.volume-mark.*", - NULL - }; - if (frame && frame->root) { - pid = frame->root->pid; - } - - if (!name) { - /* No need to do anything here */ - ret = 0; - goto out; - } +posix_handle_georep_xattrs(call_frame_t *frame, const char *name, int *op_errno, + gf_boolean_t is_getxattr) +{ + int i = 0; + int ret = 0; + int pid = 1; + gf_boolean_t filter_xattr = _gf_true; + static const char *georep_xattr[] = { + "*.glusterfs.*.stime", "*.glusterfs.*.xtime", + "*.glusterfs.*.entry_stime", "*.glusterfs.volume-mark.*", NULL}; + if (frame && frame->root) { + pid = frame->root->pid; + } + + if (!name) { + /* No need to do anything here */ + ret = 0; + goto out; + } - if (pid == GF_CLIENT_PID_GSYNCD && is_getxattr) { - filter_xattr = _gf_false; + if (pid == GF_CLIENT_PID_GSYNCD && is_getxattr) { + filter_xattr = _gf_false; - /* getxattr from gsyncd process should return all the - * internal xattr. In other cases ignore such xattrs - */ - } + /* getxattr from gsyncd process should return all the + * internal xattr. In other cases ignore such xattrs + */ + } - for (i = 0; filter_xattr && georep_xattr[i]; i++) { - if (fnmatch (georep_xattr[i] , name, FNM_PERIOD) == 0) { - ret = -1; - if (op_errno) - *op_errno = ENOATTR; + for (i = 0; filter_xattr && georep_xattr[i]; i++) { + if (fnmatch(georep_xattr[i], name, FNM_PERIOD) == 0) { + ret = -1; + if (op_errno) + *op_errno = ENOATTR; - gf_msg_debug ("posix", ENOATTR, - "Ignoring the key %s as an internal " - "xattrs.", name); - goto out; - } + gf_msg_debug("posix", ENOATTR, + "Ignoring the key %s as an internal " + "xattrs.", + name); + goto out; } + } - ret = 0; + ret = 0; out: - return ret; + return ret; } - int32_t -posix_set_mode_in_dict (dict_t *in_dict, dict_t *out_dict, - struct iatt *in_stbuf) +posix_set_mode_in_dict(dict_t *in_dict, dict_t *out_dict, struct iatt *in_stbuf) { - int ret = -1; - mode_t mode = 0; + int ret = -1; + mode_t mode = 0; - if ((!in_dict) || (!in_stbuf) || (!out_dict)) { - goto out; - } + if ((!in_dict) || (!in_stbuf) || (!out_dict)) { + goto out; + } - /* We need this only for files */ - if (!(IA_ISREG (in_stbuf->ia_type))) { - ret = 0; - goto out; - } + /* We need this only for files */ + if (!(IA_ISREG(in_stbuf->ia_type))) { + ret = 0; + goto out; + } - /* Nobody asked for this */ - if (!dict_get (in_dict, DHT_MODE_IN_XDATA_KEY)) { - ret = 0; - goto out; - } - mode = st_mode_from_ia (in_stbuf->ia_prot, in_stbuf->ia_type); + /* Nobody asked for this */ + if (!dict_get(in_dict, DHT_MODE_IN_XDATA_KEY)) { + ret = 0; + goto out; + } + mode = st_mode_from_ia(in_stbuf->ia_prot, in_stbuf->ia_type); - ret = dict_set_int32 (out_dict, DHT_MODE_IN_XDATA_KEY, mode); + ret = dict_set_int32(out_dict, DHT_MODE_IN_XDATA_KEY, mode); out: - return ret; + return ret; } - static gf_boolean_t -posix_xattr_ignorable (char *key) +posix_xattr_ignorable(char *key) { - return gf_get_index_by_elem (posix_ignore_xattrs, key) >= 0; + return gf_get_index_by_elem(posix_ignore_xattrs, key) >= 0; } static int -_posix_xattr_get_set_from_backend (posix_xattr_filler_t *filler, char *key) -{ - ssize_t xattr_size = -1; - int ret = 0; - char *value = NULL; - char val_buf[256] = {0}; - gf_boolean_t have_val = _gf_false; - - if (!gf_is_valid_xattr_namespace (key)) { - ret = -1; - goto out; - } - - /* Most of the gluster internal xattrs don't exceed 256 bytes. So try - * getxattr with ~256 bytes. If it gives ERANGE then go the old way - * of getxattr with NULL buf to find the length and then getxattr with - * allocated buf to fill the data. This way we reduce lot of getxattrs. - */ - if (filler->real_path) - xattr_size = sys_lgetxattr (filler->real_path, key, val_buf, - sizeof (val_buf) - 1); - else - xattr_size = sys_fgetxattr (filler->fdnum, key, val_buf, - sizeof (val_buf) - 1); +_posix_xattr_get_set_from_backend(posix_xattr_filler_t *filler, char *key) +{ + ssize_t xattr_size = -1; + int ret = 0; + char *value = NULL; + char val_buf[256] = {0}; + gf_boolean_t have_val = _gf_false; + + if (!gf_is_valid_xattr_namespace(key)) { + ret = -1; + goto out; + } + + /* Most of the gluster internal xattrs don't exceed 256 bytes. So try + * getxattr with ~256 bytes. If it gives ERANGE then go the old way + * of getxattr with NULL buf to find the length and then getxattr with + * allocated buf to fill the data. This way we reduce lot of getxattrs. + */ + if (filler->real_path) + xattr_size = sys_lgetxattr(filler->real_path, key, val_buf, + sizeof(val_buf) - 1); + else + xattr_size = sys_fgetxattr(filler->fdnum, key, val_buf, + sizeof(val_buf) - 1); - if (xattr_size >= 0) { - have_val = _gf_true; - } else if (xattr_size == -1 && errno != ERANGE) { - ret = -1; - goto out; - } + if (xattr_size >= 0) { + have_val = _gf_true; + } else if (xattr_size == -1 && errno != ERANGE) { + ret = -1; + goto out; + } + + if (have_val) { + /*No need to do getxattr*/ + } else if (filler->real_path) { + xattr_size = sys_lgetxattr(filler->real_path, key, NULL, 0); + } else { + xattr_size = sys_fgetxattr(filler->fdnum, key, NULL, 0); + } + + if (xattr_size != -1) { + value = GF_MALLOC(xattr_size + 1, gf_posix_mt_char); + if (!value) + goto out; if (have_val) { - /*No need to do getxattr*/ - } else if (filler->real_path) { - xattr_size = sys_lgetxattr (filler->real_path, key, NULL, 0); + memcpy(value, val_buf, xattr_size); } else { - xattr_size = sys_fgetxattr (filler->fdnum, key, NULL, 0); - } - - if (xattr_size != -1) { - value = GF_MALLOC (xattr_size + 1, gf_posix_mt_char); - if (!value) - goto out; - - if (have_val) { - memcpy (value, val_buf, xattr_size); - } else { - bzero(value, xattr_size + 1); - if (filler->real_path) { - xattr_size = sys_lgetxattr (filler->real_path, - key, value, xattr_size); - } else { - xattr_size = sys_fgetxattr (filler->fdnum, key, - value, xattr_size); - } - } - if (xattr_size == -1) { - if (filler->real_path) - gf_msg (filler->this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_FAILED, - "getxattr failed. path: %s, key: %s", - filler->real_path, key); - else - gf_msg (filler->this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_FAILED, - "getxattr failed. gfid: %s, key: %s", - uuid_utoa (filler->fd->inode->gfid), - key); - GF_FREE (value); - goto out; - } - - value[xattr_size] = '\0'; - ret = dict_set_bin (filler->xattr, key, value, xattr_size); - if (ret < 0) { - if (filler->real_path) - gf_msg_debug (filler->this->name, 0, - "dict set failed. path: %s, key: %s", - filler->real_path, key); - else - gf_msg_debug (filler->this->name, 0, - "dict set failed. gfid: %s, key: %s", - uuid_utoa (filler->fd->inode->gfid), - key); - GF_FREE (value); - goto out; - } - } - ret = 0; + bzero(value, xattr_size + 1); + if (filler->real_path) { + xattr_size = sys_lgetxattr(filler->real_path, key, value, + xattr_size); + } else { + xattr_size = sys_fgetxattr(filler->fdnum, key, value, + xattr_size); + } + } + if (xattr_size == -1) { + if (filler->real_path) + gf_msg(filler->this->name, GF_LOG_WARNING, 0, + P_MSG_XATTR_FAILED, "getxattr failed. path: %s, key: %s", + filler->real_path, key); + else + gf_msg(filler->this->name, GF_LOG_WARNING, 0, + P_MSG_XATTR_FAILED, "getxattr failed. gfid: %s, key: %s", + uuid_utoa(filler->fd->inode->gfid), key); + GF_FREE(value); + goto out; + } + + value[xattr_size] = '\0'; + ret = dict_set_bin(filler->xattr, key, value, xattr_size); + if (ret < 0) { + if (filler->real_path) + gf_msg_debug(filler->this->name, 0, + "dict set failed. path: %s, key: %s", + filler->real_path, key); + else + gf_msg_debug(filler->this->name, 0, + "dict set failed. gfid: %s, key: %s", + uuid_utoa(filler->fd->inode->gfid), key); + GF_FREE(value); + goto out; + } + } + ret = 0; out: - return ret; + return ret; } static int gf_posix_xattr_enotsup_log; static int -_posix_get_marker_all_contributions (posix_xattr_filler_t *filler) -{ - ssize_t size = -1, remaining_size = -1, list_offset = 0; - int ret = -1; - int len; - char *list = NULL, key[4096] = {0, }; - - if (filler->real_path) - size = sys_llistxattr (filler->real_path, NULL, 0); - else - size = sys_flistxattr (filler->fdnum, NULL, 0); - if (size == -1) { - if ((errno == ENOTSUP) || (errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - THIS->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting brick" - " with 'user_xattr' flag)"); - } else { - if (filler->real_path) - gf_msg (THIS->name, GF_LOG_WARNING, errno, - P_MSG_XATTR_FAILED, - "listxattr failed on %s", - filler->real_path); - else - gf_msg (THIS->name, GF_LOG_WARNING, errno, - P_MSG_XATTR_FAILED, - "listxattr failed on %s", - uuid_utoa (filler->fd->inode->gfid)); - } - goto out; - } - - if (size == 0) { - ret = 0; - goto out; - } - - list = alloca (size); - if (!list) { - goto out; - } - - if (filler->real_path) - size = sys_llistxattr (filler->real_path, list, size); - else - size = sys_flistxattr (filler->fdnum, list, size); - if (size <= 0) { - ret = size; - goto out; - } - - remaining_size = size; - list_offset = 0; - - while (remaining_size > 0) { - strcpy (key, list + list_offset); - if (fnmatch (marker_contri_key, key, 0) == 0) { - ret = _posix_xattr_get_set_from_backend (filler, key); - } - len = strlen (key); - remaining_size -= (len + 1); - list_offset += (len + 1); - } - +_posix_get_marker_all_contributions(posix_xattr_filler_t *filler) +{ + ssize_t size = -1, remaining_size = -1, list_offset = 0; + int ret = -1; + int len; + char *list = NULL, key[4096] = { + 0, + }; + + if (filler->real_path) + size = sys_llistxattr(filler->real_path, NULL, 0); + else + size = sys_flistxattr(filler->fdnum, NULL, 0); + if (size == -1) { + if ((errno == ENOTSUP) || (errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, THIS->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting brick" + " with 'user_xattr' flag)"); + } else { + if (filler->real_path) + gf_msg(THIS->name, GF_LOG_WARNING, errno, P_MSG_XATTR_FAILED, + "listxattr failed on %s", filler->real_path); + else + gf_msg(THIS->name, GF_LOG_WARNING, errno, P_MSG_XATTR_FAILED, + "listxattr failed on %s", + uuid_utoa(filler->fd->inode->gfid)); + } + goto out; + } + + if (size == 0) { ret = 0; + goto out; + } + + list = alloca(size); + if (!list) { + goto out; + } + + if (filler->real_path) + size = sys_llistxattr(filler->real_path, list, size); + else + size = sys_flistxattr(filler->fdnum, list, size); + if (size <= 0) { + ret = size; + goto out; + } + + remaining_size = size; + list_offset = 0; + + while (remaining_size > 0) { + strcpy(key, list + list_offset); + if (fnmatch(marker_contri_key, key, 0) == 0) { + ret = _posix_xattr_get_set_from_backend(filler, key); + } + len = strlen(key); + remaining_size -= (len + 1); + list_offset += (len + 1); + } + + ret = 0; out: - return ret; + return ret; } static int -_posix_get_marker_quota_contributions (posix_xattr_filler_t *filler, char *key) +_posix_get_marker_quota_contributions(posix_xattr_filler_t *filler, char *key) { - char *saveptr = NULL, *token = NULL, *tmp_key = NULL; - char *ptr = NULL; - int i = 0, ret = 0; + char *saveptr = NULL, *token = NULL, *tmp_key = NULL; + char *ptr = NULL; + int i = 0, ret = 0; - tmp_key = ptr = gf_strdup (key); - for (i = 0; i < 4; i++) { - token = strtok_r (tmp_key, ".", &saveptr); - tmp_key = NULL; - } + tmp_key = ptr = gf_strdup(key); + for (i = 0; i < 4; i++) { + token = strtok_r(tmp_key, ".", &saveptr); + tmp_key = NULL; + } - if (strncmp (token, "contri", SLEN ("contri")) == 0) { - ret = _posix_get_marker_all_contributions (filler); - } else { - ret = _posix_xattr_get_set_from_backend (filler, key); - } + if (strncmp(token, "contri", SLEN("contri")) == 0) { + ret = _posix_get_marker_all_contributions(filler); + } else { + ret = _posix_xattr_get_set_from_backend(filler, key); + } - GF_FREE (ptr); + GF_FREE(ptr); - return ret; + return ret; } static inode_t * -_get_filler_inode (posix_xattr_filler_t *filler) +_get_filler_inode(posix_xattr_filler_t *filler) { - if (filler->fd) - return filler->fd->inode; - else if (filler->loc && filler->loc->inode) - return filler->loc->inode; - else - return NULL; + if (filler->fd) + return filler->fd->inode; + else if (filler->loc && filler->loc->inode) + return filler->loc->inode; + else + return NULL; } static int -_posix_xattr_get_set (dict_t *xattr_req, char *key, data_t *data, - void *xattrargs) -{ - posix_xattr_filler_t *filler = xattrargs; - int ret = -1; - int len; - char *databuf = NULL; - int _fd = -1; - ssize_t req_size = 0; - int32_t list_offset = 0; - ssize_t remaining_size = 0; - char *xattr = NULL; - inode_t *inode = NULL; - - if (posix_xattr_ignorable (key)) - goto out; - /* should size be put into the data_t ? */ - if (!strcmp (key, GF_CONTENT_KEY) - && IA_ISREG (filler->stbuf->ia_type)) { - if (!filler->real_path) - goto out; - - /* file content request */ - req_size = data_to_uint64 (data); - if (req_size >= filler->stbuf->ia_size) { - _fd = open (filler->real_path, O_RDONLY); - if (_fd == -1) { - gf_msg (filler->this->name, GF_LOG_ERROR, errno, - P_MSG_XDATA_GETXATTR, - "Opening file %s failed", - filler->real_path); - goto err; - } - - /* - * There could be a situation where the ia_size is - * zero. GF_CALLOC will return a pointer to the - * memory initialized by gf_mem_set_acct_info. - * This function adds a header and a footer to - * the allocated memory. The returned pointer - * points to the memory just after the header, but - * when size is zero, there is no space for user - * data. The memory can be freed by calling GF_FREE. - */ - databuf = GF_CALLOC (1, filler->stbuf->ia_size, - gf_posix_mt_char); - if (!databuf) { - goto err; - } - - ret = sys_read (_fd, databuf, filler->stbuf->ia_size); - if (ret == -1) { - gf_msg (filler->this->name, GF_LOG_ERROR, errno, - P_MSG_XDATA_GETXATTR, - "Read on file %s failed", - filler->real_path); - goto err; - } - - ret = sys_close (_fd); - _fd = -1; - if (ret == -1) { - gf_msg (filler->this->name, GF_LOG_ERROR, errno, - P_MSG_XDATA_GETXATTR, - "Close on file %s failed", - filler->real_path); - goto err; - } - - ret = dict_set_bin (filler->xattr, key, - databuf, filler->stbuf->ia_size); - if (ret < 0) { - gf_msg (filler->this->name, GF_LOG_ERROR, 0, - P_MSG_XDATA_GETXATTR, - "failed to set dict value. key: %s," - "path: %s", - key, filler->real_path); - goto err; - } - - /* To avoid double free in cleanup below */ - databuf = NULL; - err: - if (_fd != -1) - sys_close (_fd); - GF_FREE (databuf); - } - } else if (!strcmp (key, GLUSTERFS_OPEN_FD_COUNT)) { - inode = _get_filler_inode (filler); - if (!inode || gf_uuid_is_null (inode->gfid)) - goto out; - ret = dict_set_uint32 (filler->xattr, key, inode->fd_count); - if (ret < 0) { - gf_msg (filler->this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, - "Failed to set dictionary value for %s", key); - } - } else if (!strcmp (key, GLUSTERFS_ACTIVE_FD_COUNT)) { - inode = _get_filler_inode (filler); - if (!inode || gf_uuid_is_null (inode->gfid)) - goto out; - ret = dict_set_uint32 (filler->xattr, key, - inode->active_fd_count); - if (ret < 0) { - gf_msg (filler->this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, - "Failed to set dictionary value for %s", key); - } - } else if (!strcmp (key, GET_ANCESTRY_PATH_KEY)) { - /* As of now, the only consumers of POSIX_ANCESTRY_PATH attempt - * fetching it via path-based fops. Hence, leaving it as it is - * for now. - */ - if (!filler->real_path) - goto out; - char *path = NULL; - ret = posix_get_ancestry (filler->this, filler->loc->inode, - NULL, &path, POSIX_ANCESTRY_PATH, - &filler->op_errno, xattr_req); - if (ret < 0) { - goto out; - } +_posix_xattr_get_set(dict_t *xattr_req, char *key, data_t *data, + void *xattrargs) +{ + posix_xattr_filler_t *filler = xattrargs; + int ret = -1; + int len; + char *databuf = NULL; + int _fd = -1; + ssize_t req_size = 0; + int32_t list_offset = 0; + ssize_t remaining_size = 0; + char *xattr = NULL; + inode_t *inode = NULL; + + if (posix_xattr_ignorable(key)) + goto out; + /* should size be put into the data_t ? */ + if (!strcmp(key, GF_CONTENT_KEY) && IA_ISREG(filler->stbuf->ia_type)) { + if (!filler->real_path) + goto out; + + /* file content request */ + req_size = data_to_uint64(data); + if (req_size >= filler->stbuf->ia_size) { + _fd = open(filler->real_path, O_RDONLY); + if (_fd == -1) { + gf_msg(filler->this->name, GF_LOG_ERROR, errno, + P_MSG_XDATA_GETXATTR, "Opening file %s failed", + filler->real_path); + goto err; + } + + /* + * There could be a situation where the ia_size is + * zero. GF_CALLOC will return a pointer to the + * memory initialized by gf_mem_set_acct_info. + * This function adds a header and a footer to + * the allocated memory. The returned pointer + * points to the memory just after the header, but + * when size is zero, there is no space for user + * data. The memory can be freed by calling GF_FREE. + */ + databuf = GF_CALLOC(1, filler->stbuf->ia_size, gf_posix_mt_char); + if (!databuf) { + goto err; + } + + ret = sys_read(_fd, databuf, filler->stbuf->ia_size); + if (ret == -1) { + gf_msg(filler->this->name, GF_LOG_ERROR, errno, + P_MSG_XDATA_GETXATTR, "Read on file %s failed", + filler->real_path); + goto err; + } + + ret = sys_close(_fd); + _fd = -1; + if (ret == -1) { + gf_msg(filler->this->name, GF_LOG_ERROR, errno, + P_MSG_XDATA_GETXATTR, "Close on file %s failed", + filler->real_path); + goto err; + } + + ret = dict_set_bin(filler->xattr, key, databuf, + filler->stbuf->ia_size); + if (ret < 0) { + gf_msg(filler->this->name, GF_LOG_ERROR, 0, + P_MSG_XDATA_GETXATTR, + "failed to set dict value. key: %s," + "path: %s", + key, filler->real_path); + goto err; + } + + /* To avoid double free in cleanup below */ + databuf = NULL; + err: + if (_fd != -1) + sys_close(_fd); + GF_FREE(databuf); + } + } else if (!strcmp(key, GLUSTERFS_OPEN_FD_COUNT)) { + inode = _get_filler_inode(filler); + if (!inode || gf_uuid_is_null(inode->gfid)) + goto out; + ret = dict_set_uint32(filler->xattr, key, inode->fd_count); + if (ret < 0) { + gf_msg(filler->this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "Failed to set dictionary value for %s", key); + } + } else if (!strcmp(key, GLUSTERFS_ACTIVE_FD_COUNT)) { + inode = _get_filler_inode(filler); + if (!inode || gf_uuid_is_null(inode->gfid)) + goto out; + ret = dict_set_uint32(filler->xattr, key, inode->active_fd_count); + if (ret < 0) { + gf_msg(filler->this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "Failed to set dictionary value for %s", key); + } + } else if (!strcmp(key, GET_ANCESTRY_PATH_KEY)) { + /* As of now, the only consumers of POSIX_ANCESTRY_PATH attempt + * fetching it via path-based fops. Hence, leaving it as it is + * for now. + */ + if (!filler->real_path) + goto out; + char *path = NULL; + ret = posix_get_ancestry(filler->this, filler->loc->inode, NULL, &path, + POSIX_ANCESTRY_PATH, &filler->op_errno, + xattr_req); + if (ret < 0) { + goto out; + } - ret = dict_set_dynstr (filler->xattr, GET_ANCESTRY_PATH_KEY, - path); - if (ret < 0) { - GF_FREE (path); - goto out; - } + ret = dict_set_dynstr(filler->xattr, GET_ANCESTRY_PATH_KEY, path); + if (ret < 0) { + GF_FREE(path); + goto out; + } - } else if (fnmatch (marker_contri_key, key, 0) == 0) { - ret = _posix_get_marker_quota_contributions (filler, key); - } else if (strcmp(key, GF_REQUEST_LINK_COUNT_XDATA) == 0) { - ret = dict_set (filler->xattr, - GF_REQUEST_LINK_COUNT_XDATA, data); - } else if (strcmp (key, GF_GET_SIZE) == 0) { - if (filler->stbuf && IA_ISREG (filler->stbuf->ia_type)) { - ret = dict_set_uint64 (filler->xattr, GF_GET_SIZE, - filler->stbuf->ia_size); - } - } else { - remaining_size = filler->list_size; - while (remaining_size > 0) { - xattr = filler->list + list_offset; - if (fnmatch (key, xattr, 0) == 0) - ret = _posix_xattr_get_set_from_backend (filler, - xattr); - len = strlen (xattr); - remaining_size -= (len + 1); - list_offset += (len + 1); - } + } else if (fnmatch(marker_contri_key, key, 0) == 0) { + ret = _posix_get_marker_quota_contributions(filler, key); + } else if (strcmp(key, GF_REQUEST_LINK_COUNT_XDATA) == 0) { + ret = dict_set(filler->xattr, GF_REQUEST_LINK_COUNT_XDATA, data); + } else if (strcmp(key, GF_GET_SIZE) == 0) { + if (filler->stbuf && IA_ISREG(filler->stbuf->ia_type)) { + ret = dict_set_uint64(filler->xattr, GF_GET_SIZE, + filler->stbuf->ia_size); } + } else { + remaining_size = filler->list_size; + while (remaining_size > 0) { + xattr = filler->list + list_offset; + if (fnmatch(key, xattr, 0) == 0) + ret = _posix_xattr_get_set_from_backend(filler, xattr); + len = strlen(xattr); + remaining_size -= (len + 1); + list_offset += (len + 1); + } + } out: - return 0; + return 0; } int -posix_fill_gfid_path (xlator_t *this, const char *path, struct iatt *iatt) +posix_fill_gfid_path(xlator_t *this, const char *path, struct iatt *iatt) { - int ret = 0; - ssize_t size = 0; + int ret = 0; + ssize_t size = 0; - if (!iatt) - return 0; + if (!iatt) + return 0; - size = sys_lgetxattr (path, GFID_XATTR_KEY, iatt->ia_gfid, 16); - /* Return value of getxattr */ - if ((size == 16) || (size == -1)) - ret = 0; - else - ret = size; + size = sys_lgetxattr(path, GFID_XATTR_KEY, iatt->ia_gfid, 16); + /* Return value of getxattr */ + if ((size == 16) || (size == -1)) + ret = 0; + else + ret = size; - return ret; + return ret; } - int -posix_fill_gfid_fd (xlator_t *this, int fd, struct iatt *iatt) +posix_fill_gfid_fd(xlator_t *this, int fd, struct iatt *iatt) { - int ret = 0; - ssize_t size = 0; + int ret = 0; + ssize_t size = 0; - if (!iatt) - return 0; + if (!iatt) + return 0; - size = sys_fgetxattr (fd, GFID_XATTR_KEY, iatt->ia_gfid, 16); - /* Return value of getxattr */ - if ((size == 16) || (size == -1)) - ret = 0; - else - ret = size; + size = sys_fgetxattr(fd, GFID_XATTR_KEY, iatt->ia_gfid, 16); + /* Return value of getxattr */ + if ((size == 16) || (size == -1)) + ret = 0; + else + ret = size; - return ret; + return ret; } void -posix_fill_ino_from_gfid (xlator_t *this, struct iatt *buf) -{ - /* consider least significant 8 bytes of value out of gfid */ - if (gf_uuid_is_null (buf->ia_gfid)) { - buf->ia_ino = -1; - goto out; - } - buf->ia_ino = gfid_to_ino (buf->ia_gfid); - buf->ia_flags |= IATT_INO; +posix_fill_ino_from_gfid(xlator_t *this, struct iatt *buf) +{ + /* consider least significant 8 bytes of value out of gfid */ + if (gf_uuid_is_null(buf->ia_gfid)) { + buf->ia_ino = -1; + goto out; + } + buf->ia_ino = gfid_to_ino(buf->ia_gfid); + buf->ia_flags |= IATT_INO; out: - return; + return; } int -posix_fdstat (xlator_t *this, inode_t *inode, int fd, struct iatt *stbuf_p) +posix_fdstat(xlator_t *this, inode_t *inode, int fd, struct iatt *stbuf_p) { - int ret = 0; - struct stat fstatbuf = {0, }; - struct iatt stbuf = {0, }; - struct posix_private *priv = NULL; + int ret = 0; + struct stat fstatbuf = { + 0, + }; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; - priv = this->private; + priv = this->private; - ret = sys_fstat (fd, &fstatbuf); - if (ret == -1) - goto out; + ret = sys_fstat(fd, &fstatbuf); + if (ret == -1) + goto out; - if (fstatbuf.st_nlink && !S_ISDIR (fstatbuf.st_mode)) - fstatbuf.st_nlink--; + if (fstatbuf.st_nlink && !S_ISDIR(fstatbuf.st_mode)) + fstatbuf.st_nlink--; - iatt_from_stat (&stbuf, &fstatbuf); + iatt_from_stat(&stbuf, &fstatbuf); - if (inode && priv->ctime) { - ret = posix_get_mdata_xattr (this, NULL, fd, inode, &stbuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GETMDATA_FAILED, - "posix get mdata failed on gfid: %s", - uuid_utoa(inode->gfid)); - goto out; - } + if (inode && priv->ctime) { + ret = posix_get_mdata_xattr(this, NULL, fd, inode, &stbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GETMDATA_FAILED, + "posix get mdata failed on gfid: %s", + uuid_utoa(inode->gfid)); + goto out; } - ret = posix_fill_gfid_fd (this, fd, &stbuf); - stbuf.ia_flags |= IATT_GFID; + } + ret = posix_fill_gfid_fd(this, fd, &stbuf); + stbuf.ia_flags |= IATT_GFID; - posix_fill_ino_from_gfid (this, &stbuf); + posix_fill_ino_from_gfid(this, &stbuf); - if (stbuf_p) - *stbuf_p = stbuf; + if (stbuf_p) + *stbuf_p = stbuf; out: - return ret; + return ret; } - /* The inode here is expected to update posix_mdata stored on disk. * Don't use it as a general purpose inode and don't expect it to * be always exists */ int -posix_istat (xlator_t *this, inode_t *inode, uuid_t gfid, const char *basename, - struct iatt *buf_p) -{ - char *real_path = NULL; - struct stat lstatbuf = {0, }; - struct iatt stbuf = {0, }; - int ret = 0; - struct posix_private *priv = NULL; - - priv = this->private; - - MAKE_HANDLE_PATH (real_path, this, gfid, basename); - if (!real_path) { - gf_msg (this->name, GF_LOG_ERROR, ESTALE, - P_MSG_HANDLE_PATH_CREATE, - "Failed to create handle path for %s/%s", - uuid_utoa (gfid), basename ? basename : ""); - errno = ESTALE; - ret = -1; - goto out; - } - - ret = sys_lstat (real_path, &lstatbuf); - - if (ret != 0) { - if (ret == -1) { - if (errno != ENOENT && errno != ELOOP) - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_LSTAT_FAILED, - "lstat failed on %s", - real_path); - } else { - // may be some backend filesystem issue - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_LSTAT_FAILED, - "lstat failed on %s and return value is %d " - "instead of -1. Please see dmesg output to " - "check whether the failure is due to backend " - "filesystem issue", real_path, ret); - ret = -1; - } - goto out; - } - - if ((lstatbuf.st_ino == priv->handledir.st_ino) && - (lstatbuf.st_dev == priv->handledir.st_dev)) { - errno = ENOENT; - return -1; - } +posix_istat(xlator_t *this, inode_t *inode, uuid_t gfid, const char *basename, + struct iatt *buf_p) +{ + char *real_path = NULL; + struct stat lstatbuf = { + 0, + }; + struct iatt stbuf = { + 0, + }; + int ret = 0; + struct posix_private *priv = NULL; + + priv = this->private; + + MAKE_HANDLE_PATH(real_path, this, gfid, basename); + if (!real_path) { + gf_msg(this->name, GF_LOG_ERROR, ESTALE, P_MSG_HANDLE_PATH_CREATE, + "Failed to create handle path for %s/%s", uuid_utoa(gfid), + basename ? basename : ""); + errno = ESTALE; + ret = -1; + goto out; + } + + ret = sys_lstat(real_path, &lstatbuf); + + if (ret != 0) { + if (ret == -1) { + if (errno != ENOENT && errno != ELOOP) + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_LSTAT_FAILED, + "lstat failed on %s", real_path); + } else { + // may be some backend filesystem issue + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_LSTAT_FAILED, + "lstat failed on %s and return value is %d " + "instead of -1. Please see dmesg output to " + "check whether the failure is due to backend " + "filesystem issue", + real_path, ret); + ret = -1; + } + goto out; + } + + if ((lstatbuf.st_ino == priv->handledir.st_ino) && + (lstatbuf.st_dev == priv->handledir.st_dev)) { + errno = ENOENT; + return -1; + } - if (!S_ISDIR (lstatbuf.st_mode)) - lstatbuf.st_nlink --; + if (!S_ISDIR(lstatbuf.st_mode)) + lstatbuf.st_nlink--; - iatt_from_stat (&stbuf, &lstatbuf); + iatt_from_stat(&stbuf, &lstatbuf); - if (inode && priv->ctime) { - ret = posix_get_mdata_xattr (this, real_path, -1, inode, - &stbuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GETMDATA_FAILED, - "posix get mdata failed on %s", real_path); - goto out; - } + if (inode && priv->ctime) { + ret = posix_get_mdata_xattr(this, real_path, -1, inode, &stbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GETMDATA_FAILED, + "posix get mdata failed on %s", real_path); + goto out; } + } - if (basename) - posix_fill_gfid_path (this, real_path, &stbuf); - else - gf_uuid_copy (stbuf.ia_gfid, gfid); - stbuf.ia_flags |= IATT_GFID; + if (basename) + posix_fill_gfid_path(this, real_path, &stbuf); + else + gf_uuid_copy(stbuf.ia_gfid, gfid); + stbuf.ia_flags |= IATT_GFID; - posix_fill_ino_from_gfid (this, &stbuf); + posix_fill_ino_from_gfid(this, &stbuf); - if (buf_p) - *buf_p = stbuf; + if (buf_p) + *buf_p = stbuf; out: - return ret; + return ret; } - - int -posix_pstat (xlator_t *this, inode_t *inode, uuid_t gfid, const char *path, - struct iatt *buf_p, gf_boolean_t inode_locked) -{ - struct stat lstatbuf = {0, }; - struct iatt stbuf = {0, }; - int ret = 0; - int op_errno = 0; - struct posix_private *priv = NULL; - - - priv = this->private; +posix_pstat(xlator_t *this, inode_t *inode, uuid_t gfid, const char *path, + struct iatt *buf_p, gf_boolean_t inode_locked) +{ + struct stat lstatbuf = { + 0, + }; + struct iatt stbuf = { + 0, + }; + int ret = 0; + int op_errno = 0; + struct posix_private *priv = NULL; + + priv = this->private; + + if (gfid && !gf_uuid_is_null(gfid)) + gf_uuid_copy(stbuf.ia_gfid, gfid); + else + posix_fill_gfid_path(this, path, &stbuf); + stbuf.ia_flags |= IATT_GFID; + + ret = sys_lstat(path, &lstatbuf); + if (ret == -1) { + if (errno != ENOENT) { + op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_LSTAT_FAILED, + "lstat failed on %s", path); + errno = op_errno; /*gf_msg could have changed errno*/ + } + goto out; + } + + if ((lstatbuf.st_ino == priv->handledir.st_ino) && + (lstatbuf.st_dev == priv->handledir.st_dev)) { + errno = ENOENT; + return -1; + } - if (gfid && !gf_uuid_is_null (gfid)) - gf_uuid_copy (stbuf.ia_gfid, gfid); - else - posix_fill_gfid_path (this, path, &stbuf); - stbuf.ia_flags |= IATT_GFID; + if (!S_ISDIR(lstatbuf.st_mode)) + lstatbuf.st_nlink--; - ret = sys_lstat (path, &lstatbuf); - if (ret == -1) { - if (errno != ENOENT) { - op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_LSTAT_FAILED, "lstat failed on %s", path); - errno = op_errno;/*gf_msg could have changed errno*/ - } - goto out; - } + iatt_from_stat(&stbuf, &lstatbuf); - if ((lstatbuf.st_ino == priv->handledir.st_ino) && - (lstatbuf.st_dev == priv->handledir.st_dev)) { - errno = ENOENT; - return -1; + if (inode && priv->ctime) { + if (!inode_locked) { + ret = posix_get_mdata_xattr(this, path, -1, inode, &stbuf); + } else { + ret = __posix_get_mdata_xattr(this, path, -1, inode, &stbuf); } - - if (!S_ISDIR (lstatbuf.st_mode)) - lstatbuf.st_nlink --; - - iatt_from_stat (&stbuf, &lstatbuf); - - if (inode && priv->ctime) { - if (!inode_locked) { - ret = posix_get_mdata_xattr (this, path, -1, inode, &stbuf); - } else { - ret = __posix_get_mdata_xattr (this, path, -1, inode, &stbuf); - } - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GETMDATA_FAILED, - "posix get mdata failed on gfid: %s", - uuid_utoa(inode->gfid)); - goto out; - } + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GETMDATA_FAILED, + "posix get mdata failed on gfid: %s", + uuid_utoa(inode->gfid)); + goto out; } + } - posix_fill_ino_from_gfid (this, &stbuf); + posix_fill_ino_from_gfid(this, &stbuf); - if (buf_p) - *buf_p = stbuf; + if (buf_p) + *buf_p = stbuf; out: - return ret; + return ret; } - static void -_get_list_xattr (posix_xattr_filler_t *filler) +_get_list_xattr(posix_xattr_filler_t *filler) { - ssize_t size = 0; + ssize_t size = 0; - if ((!filler) || ((!filler->real_path) && (filler->fdnum < 0))) - goto out; + if ((!filler) || ((!filler->real_path) && (filler->fdnum < 0))) + goto out; - if (filler->real_path) - size = sys_llistxattr (filler->real_path, NULL, 0); - else - size = sys_flistxattr (filler->fdnum, NULL, 0); + if (filler->real_path) + size = sys_llistxattr(filler->real_path, NULL, 0); + else + size = sys_flistxattr(filler->fdnum, NULL, 0); - if (size <= 0) - goto out; + if (size <= 0) + goto out; - filler->list = GF_CALLOC (1, size, gf_posix_mt_char); - if (!filler->list) - goto out; + filler->list = GF_CALLOC(1, size, gf_posix_mt_char); + if (!filler->list) + goto out; - if (filler->real_path) - size = sys_llistxattr (filler->real_path, filler->list, size); - else - size = sys_flistxattr (filler->fdnum, filler->list, size); + if (filler->real_path) + size = sys_llistxattr(filler->real_path, filler->list, size); + else + size = sys_flistxattr(filler->fdnum, filler->list, size); - filler->list_size = size; + filler->list_size = size; out: - return; + return; } - static void -_handle_list_xattr (dict_t *xattr_req, const char *real_path, int fdnum, - posix_xattr_filler_t *filler) +_handle_list_xattr(dict_t *xattr_req, const char *real_path, int fdnum, + posix_xattr_filler_t *filler) { - int32_t list_offset = 0; - ssize_t remaining_size = 0; - char *key = NULL; - int len; + int32_t list_offset = 0; + ssize_t remaining_size = 0; + char *key = NULL; + int len; - list_offset = 0; - remaining_size = filler->list_size; - while (remaining_size > 0) { - key = filler->list + list_offset; + list_offset = 0; + remaining_size = filler->list_size; + while (remaining_size > 0) { + key = filler->list + list_offset; - if (gf_get_index_by_elem (list_xattr_ignore_xattrs, key) >= 0) - goto next; + if (gf_get_index_by_elem(list_xattr_ignore_xattrs, key) >= 0) + goto next; - if (posix_special_xattr (marker_xattrs, key)) - goto next; + if (posix_special_xattr(marker_xattrs, key)) + goto next; - if (posix_handle_georep_xattrs (NULL, key, NULL, _gf_false)) - goto next; + if (posix_handle_georep_xattrs(NULL, key, NULL, _gf_false)) + goto next; - if (posix_is_gfid2path_xattr (key)) - goto next; + if (posix_is_gfid2path_xattr(key)) + goto next; - if (dict_get (filler->xattr, key)) - goto next; + if (dict_get(filler->xattr, key)) + goto next; - (void) _posix_xattr_get_set_from_backend (filler, key); -next: - len = strlen (key); - remaining_size -= (len + 1); - list_offset += (len + 1); + (void)_posix_xattr_get_set_from_backend(filler, key); + next: + len = strlen(key); + remaining_size -= (len + 1); + list_offset += (len + 1); - } /* while (remaining_size > 0) */ - return; + } /* while (remaining_size > 0) */ + return; } dict_t * -posix_xattr_fill (xlator_t *this, const char *real_path, loc_t *loc, fd_t *fd, - int fdnum, dict_t *xattr_req, struct iatt *buf) -{ - dict_t *xattr = NULL; - posix_xattr_filler_t filler = {0, }; - gf_boolean_t list = _gf_false; - - if (dict_get (xattr_req, "list-xattr")) { - dict_del (xattr_req, "list-xattr"); - list = _gf_true; - } - - xattr = dict_new (); - if (!xattr) { - goto out; - } - - filler.this = this; - filler.real_path = real_path; - filler.xattr = xattr; - filler.stbuf = buf; - filler.loc = loc; - filler.fd = fd; - filler.fdnum = fdnum; - - _get_list_xattr (&filler); - dict_foreach (xattr_req, _posix_xattr_get_set, &filler); - if (list) - _handle_list_xattr (xattr_req, real_path, fdnum, &filler); - - GF_FREE (filler.list); +posix_xattr_fill(xlator_t *this, const char *real_path, loc_t *loc, fd_t *fd, + int fdnum, dict_t *xattr_req, struct iatt *buf) +{ + dict_t *xattr = NULL; + posix_xattr_filler_t filler = { + 0, + }; + gf_boolean_t list = _gf_false; + + if (dict_get(xattr_req, "list-xattr")) { + dict_del(xattr_req, "list-xattr"); + list = _gf_true; + } + + xattr = dict_new(); + if (!xattr) { + goto out; + } + + filler.this = this; + filler.real_path = real_path; + filler.xattr = xattr; + filler.stbuf = buf; + filler.loc = loc; + filler.fd = fd; + filler.fdnum = fdnum; + + _get_list_xattr(&filler); + dict_foreach(xattr_req, _posix_xattr_get_set, &filler); + if (list) + _handle_list_xattr(xattr_req, real_path, fdnum, &filler); + + GF_FREE(filler.list); out: - return xattr; + return xattr; } void -posix_gfid_unset (xlator_t *this, dict_t *xdata) +posix_gfid_unset(xlator_t *this, dict_t *xdata) { - uuid_t uuid = {0, }; - int ret = 0; + uuid_t uuid = { + 0, + }; + int ret = 0; - if (xdata == NULL) - goto out; + if (xdata == NULL) + goto out; - ret = dict_get_gfuuid (xdata, "gfid-req", &uuid); - if (ret) { - goto out; - } + ret = dict_get_gfuuid(xdata, "gfid-req", &uuid); + if (ret) { + goto out; + } - posix_handle_unset (this, uuid, NULL); + posix_handle_unset(this, uuid, NULL); out: - return; + return; } int -posix_gfid_set (xlator_t *this, const char *path, loc_t *loc, - dict_t *xattr_req, pid_t pid, int *op_errno) -{ - uuid_t uuid_req; - uuid_t uuid_curr; - int ret = 0; - ssize_t size = 0; - struct stat stat = {0, }; - - *op_errno = 0; - - if (!xattr_req) { - if (pid != GF_SERVER_PID_TRASH) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_INVALID_ARGUMENT, "xattr_req is null"); - *op_errno = EINVAL; - ret = -1; - } - goto out; - } - - if (sys_lstat (path, &stat) != 0) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LSTAT_FAILED, "lsatat on %s failed", path); - goto out; - } - - size = sys_lgetxattr (path, GFID_XATTR_KEY, uuid_curr, 16); - if (size == 16) { - ret = 0; - goto verify_handle; - } - - ret = dict_get_gfuuid (xattr_req, "gfid-req", &uuid_req); - if (ret) { - gf_msg_debug (this->name, 0, - "failed to get the gfid from dict for %s", - loc->path); - *op_errno = -ret; - ret = -1; - goto out; - } - if (gf_uuid_is_null (uuid_req)) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, P_MSG_NULL_GFID, - "gfid is null for %s", loc ? loc->path : ""); - ret = -1; - *op_errno = EINVAL; - goto out; - } - - ret = sys_lsetxattr (path, GFID_XATTR_KEY, uuid_req, 16, XATTR_CREATE); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_GFID_FAILED, - "setting GFID on %s failed ", path); - goto out; - } - gf_uuid_copy (uuid_curr, uuid_req); +posix_gfid_set(xlator_t *this, const char *path, loc_t *loc, dict_t *xattr_req, + pid_t pid, int *op_errno) +{ + uuid_t uuid_req; + uuid_t uuid_curr; + int ret = 0; + ssize_t size = 0; + struct stat stat = { + 0, + }; + + *op_errno = 0; + + if (!xattr_req) { + if (pid != GF_SERVER_PID_TRASH) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_INVALID_ARGUMENT, + "xattr_req is null"); + *op_errno = EINVAL; + ret = -1; + } + goto out; + } + + if (sys_lstat(path, &stat) != 0) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lsatat on %s failed", path); + goto out; + } + + size = sys_lgetxattr(path, GFID_XATTR_KEY, uuid_curr, 16); + if (size == 16) { + ret = 0; + goto verify_handle; + } + + ret = dict_get_gfuuid(xattr_req, "gfid-req", &uuid_req); + if (ret) { + gf_msg_debug(this->name, 0, "failed to get the gfid from dict for %s", + loc->path); + *op_errno = -ret; + ret = -1; + goto out; + } + if (gf_uuid_is_null(uuid_req)) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_NULL_GFID, + "gfid is null for %s", loc ? loc->path : ""); + ret = -1; + *op_errno = EINVAL; + goto out; + } + + ret = sys_lsetxattr(path, GFID_XATTR_KEY, uuid_req, 16, XATTR_CREATE); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GFID_FAILED, + "setting GFID on %s failed ", path); + goto out; + } + gf_uuid_copy(uuid_curr, uuid_req); verify_handle: - if (!S_ISDIR (stat.st_mode)) - ret = posix_handle_hard (this, path, uuid_curr, &stat); - else - ret = posix_handle_soft (this, path, loc, uuid_curr, &stat); + if (!S_ISDIR(stat.st_mode)) + ret = posix_handle_hard(this, path, uuid_curr, &stat); + else + ret = posix_handle_soft(this, path, loc, uuid_curr, &stat); out: - if (!(*op_errno)) - *op_errno = errno; - return ret; + if (!(*op_errno)) + *op_errno = errno; + return ret; } - #ifdef HAVE_SYS_ACL_H int -posix_pacl_set (const char *path, const char *key, const char *acl_s) +posix_pacl_set(const char *path, const char *key, const char *acl_s) { - int ret = -1; - acl_t acl = NULL; - acl_type_t type = 0; + int ret = -1; + acl_t acl = NULL; + acl_type_t type = 0; - type = gf_posix_acl_get_type (key); + type = gf_posix_acl_get_type(key); - acl = acl_from_text (acl_s); - ret = acl_set_file (path, type, acl); - if (ret) - /* posix_handle_pair expects ret to be the errno */ - ret = -errno; + acl = acl_from_text(acl_s); + ret = acl_set_file(path, type, acl); + if (ret) + /* posix_handle_pair expects ret to be the errno */ + ret = -errno; - acl_free (acl); + acl_free(acl); - return ret; + return ret; } int -posix_pacl_get (const char *path, const char *key, char **acl_s) +posix_pacl_get(const char *path, const char *key, char **acl_s) { - int ret = -1; - acl_t acl = NULL; - acl_type_t type = 0; - char *acl_tmp = NULL; + int ret = -1; + acl_t acl = NULL; + acl_type_t type = 0; + char *acl_tmp = NULL; - type = gf_posix_acl_get_type (key); - if (!type) - return -1; + type = gf_posix_acl_get_type(key); + if (!type) + return -1; - acl = acl_get_file (path, type); - if (!acl) - return -1; + acl = acl_get_file(path, type); + if (!acl) + return -1; #ifdef HAVE_ACL_LIBACL_H - acl_tmp = acl_to_any_text (acl, NULL, ',', - TEXT_ABBREVIATE | TEXT_NUMERIC_IDS); + acl_tmp = acl_to_any_text(acl, NULL, ',', + TEXT_ABBREVIATE | TEXT_NUMERIC_IDS); #else /* FreeBSD and the like */ - acl_tmp = acl_to_text_np (acl, NULL, ACL_TEXT_NUMERIC_IDS); + acl_tmp = acl_to_text_np(acl, NULL, ACL_TEXT_NUMERIC_IDS); #endif - if (!acl_tmp) - goto free_acl; + if (!acl_tmp) + goto free_acl; - *acl_s = gf_strdup (acl_tmp); - if (*acl_s) - ret = 0; + *acl_s = gf_strdup(acl_tmp); + if (*acl_s) + ret = 0; - acl_free (acl_tmp); + acl_free(acl_tmp); free_acl: - acl_free (acl); + acl_free(acl); - return ret; + return ret; } #else /* !HAVE_SYS_ACL_H (NetBSD) */ int -posix_pacl_set (const char *path, const char *key, const char *acl_s) +posix_pacl_set(const char *path, const char *key, const char *acl_s) { - errno = ENOTSUP; - return -1; + errno = ENOTSUP; + return -1; } int -posix_pacl_get (const char *path, const char *key, char **acl_s) +posix_pacl_get(const char *path, const char *key, char **acl_s) { - errno = ENOTSUP; - return -1; + errno = ENOTSUP; + return -1; } #endif - #ifdef GF_DARWIN_HOST_OS -static -void posix_dump_buffer (xlator_t *this, const char *real_path, const char *key, - data_t *value, int flags) -{ - char buffer[3*value->len+1]; - int index = 0; - buffer[0] = 0; - gf_loglevel_t log_level = gf_log_get_loglevel (); - if (log_level == GF_LOG_TRACE) { - char *data = (char *) value->data; - for (index = 0; index < value->len; index++) - sprintf(buffer+3*index, " %02x", data[index]); - } - gf_msg_debug (this->name, 0, - "Dump %s: key:%s flags: %u length:%u data:%s ", - real_path, key, flags, value->len, - (log_level == GF_LOG_TRACE ? buffer : "<skipped in DEBUG>")); +static void +posix_dump_buffer(xlator_t *this, const char *real_path, const char *key, + data_t *value, int flags) +{ + char buffer[3 * value->len + 1]; + int index = 0; + buffer[0] = 0; + gf_loglevel_t log_level = gf_log_get_loglevel(); + if (log_level == GF_LOG_TRACE) { + char *data = (char *)value->data; + for (index = 0; index < value->len; index++) + sprintf(buffer + 3 * index, " %02x", data[index]); + } + gf_msg_debug(this->name, 0, "Dump %s: key:%s flags: %u length:%u data:%s ", + real_path, key, flags, value->len, + (log_level == GF_LOG_TRACE ? buffer : "<skipped in DEBUG>")); } #endif int -posix_handle_pair (xlator_t *this, const char *real_path, - char *key, data_t *value, int flags, struct iatt *stbuf) +posix_handle_pair(xlator_t *this, const char *real_path, char *key, + data_t *value, int flags, struct iatt *stbuf) { - int sys_ret = -1; - int ret = 0; + int sys_ret = -1; + int ret = 0; #ifdef GF_DARWIN_HOST_OS - const int error_code = EINVAL; + const int error_code = EINVAL; #else - const int error_code = EEXIST; + const int error_code = EEXIST; #endif - if (XATTR_IS_PATHINFO (key)) { - ret = -EACCES; - goto out; - } else if (posix_is_gfid2path_xattr (key)) { - ret = -ENOTSUP; - goto out; - } else if (GF_POSIX_ACL_REQUEST (key)) { - if (stbuf && IS_DHT_LINKFILE_MODE (stbuf)) - goto out; - ret = posix_pacl_set (real_path, key, value->data); - } else if (!strncmp(key, POSIX_ACL_ACCESS_XATTR, strlen(key)) - && stbuf && IS_DHT_LINKFILE_MODE (stbuf)) { - goto out; - } else if (!strncmp(key, GF_INTERNAL_CTX_KEY, strlen(key))) { - /* ignore this key value pair */ - ret = 0; - goto out; - } else { - sys_ret = sys_lsetxattr (real_path, key, value->data, - value->len, flags); + if (XATTR_IS_PATHINFO(key)) { + ret = -EACCES; + goto out; + } else if (posix_is_gfid2path_xattr(key)) { + ret = -ENOTSUP; + goto out; + } else if (GF_POSIX_ACL_REQUEST(key)) { + if (stbuf && IS_DHT_LINKFILE_MODE(stbuf)) + goto out; + ret = posix_pacl_set(real_path, key, value->data); + } else if (!strncmp(key, POSIX_ACL_ACCESS_XATTR, strlen(key)) && stbuf && + IS_DHT_LINKFILE_MODE(stbuf)) { + goto out; + } else if (!strncmp(key, GF_INTERNAL_CTX_KEY, strlen(key))) { + /* ignore this key value pair */ + ret = 0; + goto out; + } else { + sys_ret = sys_lsetxattr(real_path, key, value->data, value->len, flags); #ifdef GF_DARWIN_HOST_OS - posix_dump_buffer(this, real_path, key, value, flags); + posix_dump_buffer(this, real_path, key, value, flags); #endif - if (sys_ret < 0) { - ret = -errno; - if (errno == ENOENT) { - if (!posix_special_xattr (marker_xattrs, - key)) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, - "setxattr on %s failed", - real_path); - } - } else { - if (errno == error_code) { - gf_msg_debug (this->name, 0, - "%s: key:%s" - "flags: %u length:%d", - real_path, key, flags, - value->len); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "%s: key:%s" - "flags: %u length:%d", - real_path, key, flags, - value->len); - } - } - - goto out; + if (sys_ret < 0) { + ret = -errno; + if (errno == ENOENT) { + if (!posix_special_xattr(marker_xattrs, key)) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "setxattr on %s failed", real_path); + } + } else { + if (errno == error_code) { + gf_msg_debug(this->name, 0, + "%s: key:%s" + "flags: %u length:%d", + real_path, key, flags, value->len); + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "%s: key:%s" + "flags: %u length:%d", + real_path, key, flags, value->len); } + } + + goto out; } + } out: - return ret; + return ret; } int -posix_fhandle_pair (call_frame_t *frame, xlator_t *this, int fd, char *key, - data_t *value, int flags, struct iatt *stbuf, fd_t *_fd) -{ - int sys_ret = -1; - int ret = 0; - - if (XATTR_IS_PATHINFO (key)) { - ret = -EACCES; - goto out; - } else if (posix_is_gfid2path_xattr (key)) { - ret = -ENOTSUP; - goto out; - } else if (!strncmp(key, POSIX_ACL_ACCESS_XATTR, strlen(key)) - && stbuf && IS_DHT_LINKFILE_MODE (stbuf)) { - goto out; - } - - sys_ret = sys_fsetxattr (fd, key, value->data, - value->len, flags); - - if (sys_ret < 0) { - ret = -errno; - if (errno == ENOENT) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fsetxattr on fd=%d" - " failed", fd); - } else { - +posix_fhandle_pair(call_frame_t *frame, xlator_t *this, int fd, char *key, + data_t *value, int flags, struct iatt *stbuf, fd_t *_fd) +{ + int sys_ret = -1; + int ret = 0; + + if (XATTR_IS_PATHINFO(key)) { + ret = -EACCES; + goto out; + } else if (posix_is_gfid2path_xattr(key)) { + ret = -ENOTSUP; + goto out; + } else if (!strncmp(key, POSIX_ACL_ACCESS_XATTR, strlen(key)) && stbuf && + IS_DHT_LINKFILE_MODE(stbuf)) { + goto out; + } + + sys_ret = sys_fsetxattr(fd, key, value->data, value->len, flags); + + if (sys_ret < 0) { + ret = -errno; + if (errno == ENOENT) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fsetxattr on fd=%d" + " failed", + fd); + } else { #ifdef GF_DARWIN_HOST_OS - if (errno == EINVAL) { - gf_msg_debug (this->name, 0, "fd=%d: key:%s " - "error:%s", fd, key, - strerror (errno)); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fd=%d: key:%s", - fd, key); - } - -#else /* ! DARWIN */ - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fd=%d: key:%s", - fd, key); + if (errno == EINVAL) { + gf_msg_debug(this->name, 0, + "fd=%d: key:%s " + "error:%s", + fd, key, strerror(errno)); + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fd=%d: key:%s", fd, key); + } + +#else /* ! DARWIN */ + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fd=%d: key:%s", fd, key); #endif /* DARWIN */ - } - - goto out; - } else if (_fd) { - posix_set_ctime (frame, this, NULL, fd, _fd->inode, NULL); } + goto out; + } else if (_fd) { + posix_set_ctime(frame, this, NULL, fd, _fd->inode, NULL); + } + out: - return ret; + return ret; } static void -del_stale_dir_handle (xlator_t *this, uuid_t gfid) -{ - char newpath[PATH_MAX] = {0, }; - uuid_t gfid_curr = {0, }; - ssize_t size = -1; - gf_boolean_t stale = _gf_false; - char *hpath = NULL; - struct stat stbuf = {0, }; - struct iatt iabuf = {0, }; - - MAKE_HANDLE_GFID_PATH (hpath, this, gfid, NULL); - - /* check that it is valid directory handle */ - size = sys_lstat (hpath, &stbuf); - if (size < 0) { - gf_msg_debug (this->name, 0, "%s: Handle stat failed: " - "%s", hpath, strerror (errno)); - goto out; - } - - iatt_from_stat (&iabuf, &stbuf); - if (iabuf.ia_nlink != 1 || !IA_ISLNK (iabuf.ia_type)) { - gf_msg_debug (this->name, 0, "%s: Handle nlink %d %d", - hpath, iabuf.ia_nlink, IA_ISLNK (iabuf.ia_type)); - goto out; - } - - size = posix_handle_path (this, gfid, NULL, newpath, sizeof (newpath)); - if (size <= 0) { - if (errno == ENOENT) { - gf_msg_debug (this->name, 0, "%s: %s", newpath, - strerror (ENOENT)); - stale = _gf_true; - } - goto out; - } - - size = sys_lgetxattr (newpath, GFID_XATTR_KEY, gfid_curr, 16); - if (size < 0 && errno == ENOENT) { - gf_msg_debug (this->name, 0, "%s: %s", newpath, - strerror (ENOENT)); - stale = _gf_true; - } else if (size == 16 && gf_uuid_compare (gfid, gfid_curr)) { - gf_msg_debug (this->name, 0, "%s: mismatching gfid: %s, " - "at %s", hpath, uuid_utoa (gfid_curr), newpath); - stale = _gf_true; - } +del_stale_dir_handle(xlator_t *this, uuid_t gfid) +{ + char newpath[PATH_MAX] = { + 0, + }; + uuid_t gfid_curr = { + 0, + }; + ssize_t size = -1; + gf_boolean_t stale = _gf_false; + char *hpath = NULL; + struct stat stbuf = { + 0, + }; + struct iatt iabuf = { + 0, + }; + + MAKE_HANDLE_GFID_PATH(hpath, this, gfid, NULL); + + /* check that it is valid directory handle */ + size = sys_lstat(hpath, &stbuf); + if (size < 0) { + gf_msg_debug(this->name, 0, + "%s: Handle stat failed: " + "%s", + hpath, strerror(errno)); + goto out; + } + + iatt_from_stat(&iabuf, &stbuf); + if (iabuf.ia_nlink != 1 || !IA_ISLNK(iabuf.ia_type)) { + gf_msg_debug(this->name, 0, "%s: Handle nlink %d %d", hpath, + iabuf.ia_nlink, IA_ISLNK(iabuf.ia_type)); + goto out; + } + + size = posix_handle_path(this, gfid, NULL, newpath, sizeof(newpath)); + if (size <= 0) { + if (errno == ENOENT) { + gf_msg_debug(this->name, 0, "%s: %s", newpath, strerror(ENOENT)); + stale = _gf_true; + } + goto out; + } + + size = sys_lgetxattr(newpath, GFID_XATTR_KEY, gfid_curr, 16); + if (size < 0 && errno == ENOENT) { + gf_msg_debug(this->name, 0, "%s: %s", newpath, strerror(ENOENT)); + stale = _gf_true; + } else if (size == 16 && gf_uuid_compare(gfid, gfid_curr)) { + gf_msg_debug(this->name, 0, + "%s: mismatching gfid: %s, " + "at %s", + hpath, uuid_utoa(gfid_curr), newpath); + stale = _gf_true; + } out: - if (stale) { - size = sys_unlink (hpath); - if (size < 0 && errno != ENOENT) - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_STALE_HANDLE_REMOVE_FAILED, "%s: Failed" - "to remove handle to %s", hpath, newpath); - } else if (size == 16) { - gf_msg_debug (this->name, 0, "%s: Fresh handle for " - "%s with gfid %s", hpath, newpath, - uuid_utoa (gfid_curr)); - } - return; + if (stale) { + size = sys_unlink(hpath); + if (size < 0 && errno != ENOENT) + gf_msg(this->name, GF_LOG_ERROR, errno, + P_MSG_STALE_HANDLE_REMOVE_FAILED, + "%s: Failed" + "to remove handle to %s", + hpath, newpath); + } else if (size == 16) { + gf_msg_debug(this->name, 0, + "%s: Fresh handle for " + "%s with gfid %s", + hpath, newpath, uuid_utoa(gfid_curr)); + } + return; } static int -janitor_walker (const char *fpath, const struct stat *sb, - int typeflag, struct FTW *ftwbuf) -{ - struct iatt stbuf = {0, }; - xlator_t *this = NULL; - - this = THIS; - /* posix_mdata_t is not filled, no time or size attributes - * are being used, so fine. - */ - posix_pstat (this, NULL, NULL, fpath, &stbuf, _gf_false); - switch (sb->st_mode & S_IFMT) { +janitor_walker(const char *fpath, const struct stat *sb, int typeflag, + struct FTW *ftwbuf) +{ + struct iatt stbuf = { + 0, + }; + xlator_t *this = NULL; + + this = THIS; + /* posix_mdata_t is not filled, no time or size attributes + * are being used, so fine. + */ + posix_pstat(this, NULL, NULL, fpath, &stbuf, _gf_false); + switch (sb->st_mode & S_IFMT) { case S_IFREG: case S_IFBLK: case S_IFLNK: case S_IFCHR: case S_IFIFO: case S_IFSOCK: - gf_msg_trace (THIS->name, 0, - "unlinking %s", fpath); - sys_unlink (fpath); - if (stbuf.ia_nlink == 1) - posix_handle_unset (this, stbuf.ia_gfid, NULL); - break; + gf_msg_trace(THIS->name, 0, "unlinking %s", fpath); + sys_unlink(fpath); + if (stbuf.ia_nlink == 1) + posix_handle_unset(this, stbuf.ia_gfid, NULL); + break; case S_IFDIR: - if (ftwbuf->level) { /* don't remove top level dir */ - gf_msg_debug (THIS->name, 0, - "removing directory %s", fpath); + if (ftwbuf->level) { /* don't remove top level dir */ + gf_msg_debug(THIS->name, 0, "removing directory %s", fpath); - sys_rmdir (fpath); - del_stale_dir_handle (this, stbuf.ia_gfid); - } - break; - } + sys_rmdir(fpath); + del_stale_dir_handle(this, stbuf.ia_gfid); + } + break; + } - return 0; /* 0 = FTW_CONTINUE */ + return 0; /* 0 = FTW_CONTINUE */ } - static struct posix_fd * -janitor_get_next_fd (xlator_t *this) +janitor_get_next_fd(xlator_t *this) { - struct posix_private *priv = NULL; - struct posix_fd *pfd = NULL; + struct posix_private *priv = NULL; + struct posix_fd *pfd = NULL; - struct timespec timeout; + struct timespec timeout; - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->janitor_lock); - { - if (list_empty (&priv->janitor_fds)) { - time (&timeout.tv_sec); - timeout.tv_sec += priv->janitor_sleep_duration; - timeout.tv_nsec = 0; - - pthread_cond_timedwait (&priv->janitor_cond, - &priv->janitor_lock, - &timeout); - goto unlock; - } + pthread_mutex_lock(&priv->janitor_lock); + { + if (list_empty(&priv->janitor_fds)) { + time(&timeout.tv_sec); + timeout.tv_sec += priv->janitor_sleep_duration; + timeout.tv_nsec = 0; - pfd = list_entry (priv->janitor_fds.next, struct posix_fd, - list); - - list_del (priv->janitor_fds.next); + pthread_cond_timedwait(&priv->janitor_cond, &priv->janitor_lock, + &timeout); + goto unlock; } + + pfd = list_entry(priv->janitor_fds.next, struct posix_fd, list); + + list_del(priv->janitor_fds.next); + } unlock: - pthread_mutex_unlock (&priv->janitor_lock); + pthread_mutex_unlock(&priv->janitor_lock); - return pfd; + return pfd; } - static void * -posix_janitor_thread_proc (void *data) -{ - xlator_t * this = NULL; - struct posix_private *priv = NULL; - struct posix_fd *pfd; - - time_t now; - - this = data; - priv = this->private; - - THIS = this; - - while (1) { - - time (&now); - if ((now - priv->last_landfill_check) > priv->janitor_sleep_duration) { - if (priv->disable_landfill_purge) { - gf_msg_debug (this->name, 0, - "Janitor would have " - "cleaned out %s, but purge" - "is disabled.", - priv->trash_path); - } else { - gf_msg_trace (this->name, 0, - "janitor cleaning out %s", - priv->trash_path); - - nftw (priv->trash_path, - janitor_walker, - 32, - FTW_DEPTH | FTW_PHYS); - } - priv->last_landfill_check = now; - } +posix_janitor_thread_proc(void *data) +{ + xlator_t *this = NULL; + struct posix_private *priv = NULL; + struct posix_fd *pfd; - pfd = janitor_get_next_fd (this); - if (pfd) { - if (pfd->dir == NULL) { - gf_msg_trace (this->name, 0, - "janitor: closing file fd=%d", pfd->fd); - sys_close (pfd->fd); - } else { - gf_msg_debug (this->name, 0, "janitor: closing" - " dir fd=%p", pfd->dir); - sys_closedir (pfd->dir); - } - - GF_FREE (pfd); - } + time_t now; + + this = data; + priv = this->private; + + THIS = this; + + while (1) { + time(&now); + if ((now - priv->last_landfill_check) > priv->janitor_sleep_duration) { + if (priv->disable_landfill_purge) { + gf_msg_debug(this->name, 0, + "Janitor would have " + "cleaned out %s, but purge" + "is disabled.", + priv->trash_path); + } else { + gf_msg_trace(this->name, 0, "janitor cleaning out %s", + priv->trash_path); + + nftw(priv->trash_path, janitor_walker, 32, + FTW_DEPTH | FTW_PHYS); + } + priv->last_landfill_check = now; } - return NULL; -} + pfd = janitor_get_next_fd(this); + if (pfd) { + if (pfd->dir == NULL) { + gf_msg_trace(this->name, 0, "janitor: closing file fd=%d", + pfd->fd); + sys_close(pfd->fd); + } else { + gf_msg_debug(this->name, 0, + "janitor: closing" + " dir fd=%p", + pfd->dir); + sys_closedir(pfd->dir); + } + GF_FREE(pfd); + } + } + + return NULL; +} void -posix_spawn_janitor_thread (xlator_t *this) +posix_spawn_janitor_thread(xlator_t *this) { - struct posix_private *priv = NULL; - int ret = 0; + struct posix_private *priv = NULL; + int ret = 0; - priv = this->private; + priv = this->private; - LOCK (&priv->lock); - { - if (!priv->janitor_present) { - ret = gf_thread_create (&priv->janitor, NULL, - posix_janitor_thread_proc, - this, "posixjan"); - - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_THREAD_FAILED, "spawning janitor " - "thread failed"); - goto unlock; - } - - priv->janitor_present = _gf_true; - } + LOCK(&priv->lock); + { + if (!priv->janitor_present) { + ret = gf_thread_create(&priv->janitor, NULL, + posix_janitor_thread_proc, this, "posixjan"); + + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_THREAD_FAILED, + "spawning janitor " + "thread failed"); + goto unlock; + } + + priv->janitor_present = _gf_true; } + } unlock: - UNLOCK (&priv->lock); + UNLOCK(&priv->lock); } static int -is_fresh_file (int64_t ctime_sec) +is_fresh_file(int64_t ctime_sec) { - struct timeval tv; + struct timeval tv; - gettimeofday (&tv, NULL); + gettimeofday(&tv, NULL); - if ((ctime_sec >= (tv.tv_sec - 1)) - && (ctime_sec <= tv.tv_sec)) - return 1; + if ((ctime_sec >= (tv.tv_sec - 1)) && (ctime_sec <= tv.tv_sec)) + return 1; - return 0; + return 0; } - int -posix_gfid_heal (xlator_t *this, const char *path, loc_t *loc, dict_t *xattr_req) -{ - /* The purpose of this function is to prevent a race - where an inode creation FOP (like mkdir/mknod/create etc) - races with lookup in the following way: - - {create thread} | {lookup thread} - | - t0 - mkdir ("name") | - t1 - | posix_gfid_set ("name", 2); - t2 - posix_gfid_set ("name", 1); | - t3 - lstat ("name"); | lstat ("name"); - - In the above case mkdir FOP would have resulted with GFID 2 while - it should have been GFID 1. It matters in the case where GFID would - have gotten set to 1 on other subvolumes of replciate/distribute - - The "solution" here is that, if we detect lookup is attempting to - set a GFID on a file which is created very recently, but does not - yet have a GFID (i.e, between t1 and t2), then "fake" it as though - posix_gfid_heal was called at t0 instead. - */ - - uuid_t uuid_curr; - int ret = 0; - struct stat stat = {0, }; - struct iatt stbuf = {0, }; - struct posix_private *priv = NULL; - - priv = this->private; - - if (!xattr_req) - return 0; +posix_gfid_heal(xlator_t *this, const char *path, loc_t *loc, dict_t *xattr_req) +{ + /* The purpose of this function is to prevent a race + where an inode creation FOP (like mkdir/mknod/create etc) + races with lookup in the following way: + + {create thread} | {lookup thread} + | + t0 + mkdir ("name") | + t1 + | posix_gfid_set ("name", 2); + t2 + posix_gfid_set ("name", 1); | + t3 + lstat ("name"); | lstat ("name"); + + In the above case mkdir FOP would have resulted with GFID 2 while + it should have been GFID 1. It matters in the case where GFID would + have gotten set to 1 on other subvolumes of replciate/distribute + + The "solution" here is that, if we detect lookup is attempting to + set a GFID on a file which is created very recently, but does not + yet have a GFID (i.e, between t1 and t2), then "fake" it as though + posix_gfid_heal was called at t0 instead. + */ + + uuid_t uuid_curr; + int ret = 0; + struct stat stat = { + 0, + }; + struct iatt stbuf = { + 0, + }; + struct posix_private *priv = NULL; + + priv = this->private; + + if (!xattr_req) + return 0; - if (loc->inode && priv->ctime) { - if (sys_lstat (path, &stat) != 0) { - return -errno; - } - /* stbuf is only to compare ctime, don't use it to access - * other fields as they are zero. */ - ret = posix_get_mdata_xattr (this, path, -1, loc->inode, - &stbuf); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_GETMDATA_FAILED, - "posix get mdata failed on gfid: %s", - uuid_utoa(loc->inode->gfid)); - return -ENOENT; - } - ret = sys_lgetxattr (path, GFID_XATTR_KEY, uuid_curr, 16); - if (ret != 16) { - if (is_fresh_file (stbuf.ia_ctime)) { - gf_msg (this->name, GF_LOG_ERROR, ENOENT, - P_MSG_FRESHFILE, - "Fresh file: %s", path); - return -ENOENT; - } - } - } else { - if (sys_lstat (path, &stat) != 0) { - return -errno; - } - ret = sys_lgetxattr (path, GFID_XATTR_KEY, uuid_curr, 16); - if (ret != 16) { - if (is_fresh_file (stat.st_ctime)) { - gf_msg (this->name, GF_LOG_ERROR, ENOENT, - P_MSG_FRESHFILE, - "Fresh file: %s", path); - return -ENOENT; - } - } + if (loc->inode && priv->ctime) { + if (sys_lstat(path, &stat) != 0) { + return -errno; + } + /* stbuf is only to compare ctime, don't use it to access + * other fields as they are zero. */ + ret = posix_get_mdata_xattr(this, path, -1, loc->inode, &stbuf); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_GETMDATA_FAILED, + "posix get mdata failed on gfid: %s", + uuid_utoa(loc->inode->gfid)); + return -ENOENT; + } + ret = sys_lgetxattr(path, GFID_XATTR_KEY, uuid_curr, 16); + if (ret != 16) { + if (is_fresh_file(stbuf.ia_ctime)) { + gf_msg(this->name, GF_LOG_ERROR, ENOENT, P_MSG_FRESHFILE, + "Fresh file: %s", path); + return -ENOENT; + } } + } else { + if (sys_lstat(path, &stat) != 0) { + return -errno; + } + ret = sys_lgetxattr(path, GFID_XATTR_KEY, uuid_curr, 16); + if (ret != 16) { + if (is_fresh_file(stat.st_ctime)) { + gf_msg(this->name, GF_LOG_ERROR, ENOENT, P_MSG_FRESHFILE, + "Fresh file: %s", path); + return -ENOENT; + } + } + } - posix_gfid_set (this, path, loc, xattr_req, GF_CLIENT_PID_MAX, &ret); - return 0; + posix_gfid_set(this, path, loc, xattr_req, GF_CLIENT_PID_MAX, &ret); + return 0; } - int -posix_acl_xattr_set (xlator_t *this, const char *path, dict_t *xattr_req) +posix_acl_xattr_set(xlator_t *this, const char *path, dict_t *xattr_req) { - int ret = 0; - data_t *data = NULL; - struct stat stat = {0, }; + int ret = 0; + data_t *data = NULL; + struct stat stat = { + 0, + }; - if (!xattr_req) - goto out; + if (!xattr_req) + goto out; - if (sys_lstat (path, &stat) != 0) - goto out; + if (sys_lstat(path, &stat) != 0) + goto out; - data = dict_get (xattr_req, POSIX_ACL_ACCESS_XATTR); - if (data) { - ret = sys_lsetxattr (path, POSIX_ACL_ACCESS_XATTR, - data->data, data->len, 0); + data = dict_get(xattr_req, POSIX_ACL_ACCESS_XATTR); + if (data) { + ret = sys_lsetxattr(path, POSIX_ACL_ACCESS_XATTR, data->data, data->len, + 0); #ifdef __FreeBSD__ - if (ret != -1) { - ret = 0; - } -#endif /* __FreeBSD__ */ - if (ret != 0) - goto out; + if (ret != -1) { + ret = 0; } - - data = dict_get (xattr_req, POSIX_ACL_DEFAULT_XATTR); - if (data) { - ret = sys_lsetxattr (path, POSIX_ACL_DEFAULT_XATTR, - data->data, data->len, 0); -#ifdef __FreeBSD__ - if (ret != -1) { - ret = 0; - } #endif /* __FreeBSD__ */ - if (ret != 0) - goto out; + if (ret != 0) + goto out; + } + + data = dict_get(xattr_req, POSIX_ACL_DEFAULT_XATTR); + if (data) { + ret = sys_lsetxattr(path, POSIX_ACL_DEFAULT_XATTR, data->data, + data->len, 0); +#ifdef __FreeBSD__ + if (ret != -1) { + ret = 0; } +#endif /* __FreeBSD__ */ + if (ret != 0) + goto out; + } out: - return ret; + return ret; } static int -_handle_entry_create_keyvalue_pair (dict_t *d, char *k, data_t *v, - void *tmp) +_handle_entry_create_keyvalue_pair(dict_t *d, char *k, data_t *v, void *tmp) { - int ret = -1; - posix_xattr_filler_t *filler = NULL; + int ret = -1; + posix_xattr_filler_t *filler = NULL; - filler = tmp; + filler = tmp; - if (!strcmp (GFID_XATTR_KEY, k) || - !strcmp ("gfid-req", k) || - !strcmp (POSIX_ACL_DEFAULT_XATTR, k) || - !strcmp (POSIX_ACL_ACCESS_XATTR, k) || - posix_xattr_ignorable (k)) { - return 0; - } - - ret = posix_handle_pair (filler->this, filler->real_path, k, v, - XATTR_CREATE, filler->stbuf); - if (ret < 0) { - errno = -ret; - return -1; - } + if (!strcmp(GFID_XATTR_KEY, k) || !strcmp("gfid-req", k) || + !strcmp(POSIX_ACL_DEFAULT_XATTR, k) || + !strcmp(POSIX_ACL_ACCESS_XATTR, k) || posix_xattr_ignorable(k)) { return 0; + } + + ret = posix_handle_pair(filler->this, filler->real_path, k, v, XATTR_CREATE, + filler->stbuf); + if (ret < 0) { + errno = -ret; + return -1; + } + return 0; } int -posix_entry_create_xattr_set (xlator_t *this, const char *path, - dict_t *dict) +posix_entry_create_xattr_set(xlator_t *this, const char *path, dict_t *dict) { - int ret = -1; + int ret = -1; - posix_xattr_filler_t filler = {0,}; + posix_xattr_filler_t filler = { + 0, + }; - if (!dict) - goto out; + if (!dict) + goto out; - filler.this = this; - filler.real_path = path; - filler.stbuf = NULL; + filler.this = this; + filler.real_path = path; + filler.stbuf = NULL; - ret = dict_foreach (dict, _handle_entry_create_keyvalue_pair, &filler); + ret = dict_foreach(dict, _handle_entry_create_keyvalue_pair, &filler); out: - return ret; + return ret; } static int -__posix_fd_ctx_get (fd_t *fd, xlator_t *this, struct posix_fd **pfd_p, - int *op_errno_p) -{ - uint64_t tmp_pfd = 0; - struct posix_fd *pfd = NULL; - int ret = -1; - char *real_path = NULL; - char *unlink_path = NULL; - int _fd = -1; - int op_errno = 0; - DIR *dir = NULL; - - struct posix_private *priv = NULL; - - priv = this->private; - - ret = __fd_ctx_get (fd, this, &tmp_pfd); - if (ret == 0) { - pfd = (void *)(long) tmp_pfd; - goto out; - } - if (!fd_is_anonymous(fd)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_READ_FAILED, - "Failed to get fd context for a non-anonymous fd, " - "file: %s, gfid: %s", real_path, - uuid_utoa (fd->inode->gfid)); - op_errno = EINVAL; - goto out; - } - - MAKE_HANDLE_PATH (real_path, this, fd->inode->gfid, NULL); - if (!real_path) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_READ_FAILED, - "Failed to create handle path (%s)", - uuid_utoa (fd->inode->gfid)); - ret = -1; - op_errno = EINVAL; - goto out; - } - pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); - if (!pfd) { - op_errno = ENOMEM; - goto out; - } - pfd->fd = -1; - - if (fd->inode->ia_type == IA_IFDIR) { - dir = sys_opendir (real_path); - if (!dir) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_READ_FAILED, - "Failed to get anonymous fd for " - "real_path: %s.", real_path); - GF_FREE (pfd); - pfd = NULL; - goto out; - } - _fd = dirfd (dir); - } - - /* Using fd->flags in case we choose to have anonymous - * fds with different flags some day. As of today it - * would be GF_ANON_FD_FLAGS and nothing else. - */ - if (fd->inode->ia_type == IA_IFREG) { - _fd = open (real_path, fd->flags); - if ((_fd == -1) && (errno == ENOENT)) { - POSIX_GET_FILE_UNLINK_PATH (priv->base_path, - fd->inode->gfid, - unlink_path); - _fd = open (unlink_path, fd->flags); - } - if (_fd == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_READ_FAILED, - "Failed to get anonymous fd for " - "real_path: %s.", real_path); - GF_FREE (pfd); - pfd = NULL; - goto out; - } - } - - pfd->fd = _fd; - pfd->dir = dir; - pfd->flags = fd->flags; - - ret = __fd_ctx_set (fd, this, (uint64_t) (long) pfd); - if (ret != 0) { - op_errno = ENOMEM; - if (_fd != -1) - sys_close (_fd); - if (dir) - sys_closedir (dir); - GF_FREE (pfd); - pfd = NULL; - goto out; - } - - ret = 0; +__posix_fd_ctx_get(fd_t *fd, xlator_t *this, struct posix_fd **pfd_p, + int *op_errno_p) +{ + uint64_t tmp_pfd = 0; + struct posix_fd *pfd = NULL; + int ret = -1; + char *real_path = NULL; + char *unlink_path = NULL; + int _fd = -1; + int op_errno = 0; + DIR *dir = NULL; + + struct posix_private *priv = NULL; + + priv = this->private; + + ret = __fd_ctx_get(fd, this, &tmp_pfd); + if (ret == 0) { + pfd = (void *)(long)tmp_pfd; + goto out; + } + if (!fd_is_anonymous(fd)) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_READ_FAILED, + "Failed to get fd context for a non-anonymous fd, " + "file: %s, gfid: %s", + real_path, uuid_utoa(fd->inode->gfid)); + op_errno = EINVAL; + goto out; + } + + MAKE_HANDLE_PATH(real_path, this, fd->inode->gfid, NULL); + if (!real_path) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_READ_FAILED, + "Failed to create handle path (%s)", uuid_utoa(fd->inode->gfid)); + ret = -1; + op_errno = EINVAL; + goto out; + } + pfd = GF_CALLOC(1, sizeof(*pfd), gf_posix_mt_posix_fd); + if (!pfd) { + op_errno = ENOMEM; + goto out; + } + pfd->fd = -1; + + if (fd->inode->ia_type == IA_IFDIR) { + dir = sys_opendir(real_path); + if (!dir) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_READ_FAILED, + "Failed to get anonymous fd for " + "real_path: %s.", + real_path); + GF_FREE(pfd); + pfd = NULL; + goto out; + } + _fd = dirfd(dir); + } + + /* Using fd->flags in case we choose to have anonymous + * fds with different flags some day. As of today it + * would be GF_ANON_FD_FLAGS and nothing else. + */ + if (fd->inode->ia_type == IA_IFREG) { + _fd = open(real_path, fd->flags); + if ((_fd == -1) && (errno == ENOENT)) { + POSIX_GET_FILE_UNLINK_PATH(priv->base_path, fd->inode->gfid, + unlink_path); + _fd = open(unlink_path, fd->flags); + } + if (_fd == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_READ_FAILED, + "Failed to get anonymous fd for " + "real_path: %s.", + real_path); + GF_FREE(pfd); + pfd = NULL; + goto out; + } + } + + pfd->fd = _fd; + pfd->dir = dir; + pfd->flags = fd->flags; + + ret = __fd_ctx_set(fd, this, (uint64_t)(long)pfd); + if (ret != 0) { + op_errno = ENOMEM; + if (_fd != -1) + sys_close(_fd); + if (dir) + sys_closedir(dir); + GF_FREE(pfd); + pfd = NULL; + goto out; + } + + ret = 0; out: - if (ret < 0 && op_errno_p) - *op_errno_p = op_errno; + if (ret < 0 && op_errno_p) + *op_errno_p = op_errno; - if (pfd_p) - *pfd_p = pfd; - return ret; + if (pfd_p) + *pfd_p = pfd; + return ret; } - int -posix_fd_ctx_get (fd_t *fd, xlator_t *this, struct posix_fd **pfd, - int *op_errno) +posix_fd_ctx_get(fd_t *fd, xlator_t *this, struct posix_fd **pfd, int *op_errno) { - int ret; + int ret; - LOCK (&fd->inode->lock); - { - ret = __posix_fd_ctx_get (fd, this, pfd, op_errno); - } - UNLOCK (&fd->inode->lock); + LOCK(&fd->inode->lock); + { + ret = __posix_fd_ctx_get(fd, this, pfd, op_errno); + } + UNLOCK(&fd->inode->lock); - return ret; + return ret; } int -posix_fs_health_check (xlator_t *this) -{ - struct posix_private *priv = NULL; - int ret = -1; - char *subvol_path = NULL; - char timestamp[256] = {0,}; - int fd = -1; - int timelen = -1; - time_t time_sec = {0,}; - char buff[256] = {0}; - char file_path[PATH_MAX] = {0}; - char *op = NULL; - int op_errno = 0; - int cnt = 0; - int timeout = 0; - struct aiocb aiocb; - - GF_VALIDATE_OR_GOTO (this->name, this, out); - priv = this->private; - GF_VALIDATE_OR_GOTO ("posix-helpers", priv, out); - - subvol_path = priv->base_path; - timeout = priv->health_check_timeout; - snprintf (file_path, sizeof (file_path)-1, "%s/%s/health_check", - subvol_path, GF_HIDDEN_PATH); - - time_sec = time (NULL); - gf_time_fmt (timestamp, sizeof timestamp, time_sec, gf_timefmt_FT); - timelen = strlen (timestamp); - - fd = open (file_path, O_CREAT|O_WRONLY|O_TRUNC, 0644); - if (fd == -1) { - op_errno = errno; - op = "open_for_write"; - goto out; - } - memset(&aiocb, 0, sizeof(struct aiocb)); - aiocb.aio_fildes = fd; - aiocb.aio_buf = timestamp; - aiocb.aio_nbytes = timelen; - aiocb.aio_sigevent.sigev_notify = SIGEV_NONE; - if (aio_write(&aiocb) == -1) { - op_errno = errno; - op = "aio_write"; - goto out; - } - - /* Wait until write completion */ - while ((aio_error (&aiocb) == EINPROGRESS) && (++cnt <= timeout)) - sleep (1); - - ret = aio_error (&aiocb); - if (ret != 0) { - op_errno = errno; - op = "aio_write_error"; - ret = -1; - goto out; - } - - ret = aio_return (&aiocb); - if (ret != timelen) { - op_errno = errno; - op = "aio_write_buf"; - ret = -1; - goto out; - } - - sys_close (fd); - - fd = open (file_path, O_RDONLY); - if (fd == -1) { - op_errno = errno; - op = "open_for_read"; - goto out; - } - - memset(&aiocb, 0, sizeof(struct aiocb)); - aiocb.aio_fildes = fd; - aiocb.aio_buf = buff; - aiocb.aio_nbytes = sizeof(buff); - if (aio_read(&aiocb) == -1) { - op_errno = errno; - op = "aio_read"; - goto out; - } - cnt = 0; - /* Wait until read completion */ - while ((aio_error (&aiocb) == EINPROGRESS) && (++cnt <= timeout)) - sleep (1); - - ret = aio_error (&aiocb); - if (ret != 0) { - op_errno = errno; - op = "aio_read_error"; - ret = -1; - goto out; - } - - ret = aio_return (&aiocb); - if (ret != timelen) { - op_errno = errno; - op = "aio_read_buf"; - ret = -1; - goto out; - } - - if (memcmp (timestamp, buff, ret)) { - op_errno = EUCLEAN; - op = "aio_read_cmp_buf"; - ret = -1; - goto out; - } - ret = 0; +posix_fs_health_check(xlator_t *this) +{ + struct posix_private *priv = NULL; + int ret = -1; + char *subvol_path = NULL; + char timestamp[256] = { + 0, + }; + int fd = -1; + int timelen = -1; + time_t time_sec = { + 0, + }; + char buff[256] = {0}; + char file_path[PATH_MAX] = {0}; + char *op = NULL; + int op_errno = 0; + int cnt = 0; + int timeout = 0; + struct aiocb aiocb; + + GF_VALIDATE_OR_GOTO(this->name, this, out); + priv = this->private; + GF_VALIDATE_OR_GOTO("posix-helpers", priv, out); + + subvol_path = priv->base_path; + timeout = priv->health_check_timeout; + snprintf(file_path, sizeof(file_path) - 1, "%s/%s/health_check", + subvol_path, GF_HIDDEN_PATH); + + time_sec = time(NULL); + gf_time_fmt(timestamp, sizeof timestamp, time_sec, gf_timefmt_FT); + timelen = strlen(timestamp); + + fd = open(file_path, O_CREAT | O_WRONLY | O_TRUNC, 0644); + if (fd == -1) { + op_errno = errno; + op = "open_for_write"; + goto out; + } + memset(&aiocb, 0, sizeof(struct aiocb)); + aiocb.aio_fildes = fd; + aiocb.aio_buf = timestamp; + aiocb.aio_nbytes = timelen; + aiocb.aio_sigevent.sigev_notify = SIGEV_NONE; + if (aio_write(&aiocb) == -1) { + op_errno = errno; + op = "aio_write"; + goto out; + } + + /* Wait until write completion */ + while ((aio_error(&aiocb) == EINPROGRESS) && (++cnt <= timeout)) + sleep(1); + + ret = aio_error(&aiocb); + if (ret != 0) { + op_errno = errno; + op = "aio_write_error"; + ret = -1; + goto out; + } + + ret = aio_return(&aiocb); + if (ret != timelen) { + op_errno = errno; + op = "aio_write_buf"; + ret = -1; + goto out; + } + + sys_close(fd); + + fd = open(file_path, O_RDONLY); + if (fd == -1) { + op_errno = errno; + op = "open_for_read"; + goto out; + } + + memset(&aiocb, 0, sizeof(struct aiocb)); + aiocb.aio_fildes = fd; + aiocb.aio_buf = buff; + aiocb.aio_nbytes = sizeof(buff); + if (aio_read(&aiocb) == -1) { + op_errno = errno; + op = "aio_read"; + goto out; + } + cnt = 0; + /* Wait until read completion */ + while ((aio_error(&aiocb) == EINPROGRESS) && (++cnt <= timeout)) + sleep(1); + + ret = aio_error(&aiocb); + if (ret != 0) { + op_errno = errno; + op = "aio_read_error"; + ret = -1; + goto out; + } + + ret = aio_return(&aiocb); + if (ret != timelen) { + op_errno = errno; + op = "aio_read_buf"; + ret = -1; + goto out; + } + + if (memcmp(timestamp, buff, ret)) { + op_errno = EUCLEAN; + op = "aio_read_cmp_buf"; + ret = -1; + goto out; + } + ret = 0; out: - if (fd != -1) { - sys_close (fd); - } - if (ret && file_path[0]) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_HEALTHCHECK_FAILED, - "%s() on %s returned", op, file_path); - gf_event (EVENT_POSIX_HEALTH_CHECK_FAILED, - "op=%s;path=%s;error=%s;brick=%s:%s timeout is %d", - op, file_path, strerror (op_errno), priv->hostname, - priv->base_path, timeout); - } - return ret; - + if (fd != -1) { + sys_close(fd); + } + if (ret && file_path[0]) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_HEALTHCHECK_FAILED, + "%s() on %s returned", op, file_path); + gf_event(EVENT_POSIX_HEALTH_CHECK_FAILED, + "op=%s;path=%s;error=%s;brick=%s:%s timeout is %d", op, + file_path, strerror(op_errno), priv->hostname, priv->base_path, + timeout); + } + return ret; } static void * -posix_health_check_thread_proc (void *data) -{ - xlator_t *this = NULL; - struct posix_private *priv = NULL; - uint32_t interval = 0; - int ret = -1; - xlator_t *top = NULL; - xlator_t *victim = NULL; - xlator_list_t **trav_p = NULL; - int count = 0; - gf_boolean_t victim_found = _gf_false; - glusterfs_ctx_t *ctx = NULL; - - this = data; - priv = this->private; - ctx = THIS->ctx; - - /* prevent races when the interval is updated */ - interval = priv->health_check_interval; - if (interval == 0) - goto out; - - gf_msg_debug (this->name, 0, "health-check thread started, " - "interval = %d seconds", interval); - while (1) { - /* aborting sleep() is a request to exit this thread, sleep() - * will normally not return when cancelled */ - ret = sleep (interval); - if (ret > 0) - break; - /* prevent thread errors while doing the health-check(s) */ - pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL); - - /* Do the health-check.*/ - ret = posix_fs_health_check (this); - if (ret < 0 && priv->health_check_active) - goto abort; - if (!priv->health_check_active) - goto out; - pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL); - } +posix_health_check_thread_proc(void *data) +{ + xlator_t *this = NULL; + struct posix_private *priv = NULL; + uint32_t interval = 0; + int ret = -1; + xlator_t *top = NULL; + xlator_t *victim = NULL; + xlator_list_t **trav_p = NULL; + int count = 0; + gf_boolean_t victim_found = _gf_false; + glusterfs_ctx_t *ctx = NULL; + + this = data; + priv = this->private; + ctx = THIS->ctx; + + /* prevent races when the interval is updated */ + interval = priv->health_check_interval; + if (interval == 0) + goto out; + + gf_msg_debug(this->name, 0, + "health-check thread started, " + "interval = %d seconds", + interval); + while (1) { + /* aborting sleep() is a request to exit this thread, sleep() + * will normally not return when cancelled */ + ret = sleep(interval); + if (ret > 0) + break; + /* prevent thread errors while doing the health-check(s) */ + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + + /* Do the health-check.*/ + ret = posix_fs_health_check(this); + if (ret < 0 && priv->health_check_active) + goto abort; + if (!priv->health_check_active) + goto out; + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + } out: - gf_msg_debug (this->name, 0, "health-check thread exiting"); + gf_msg_debug(this->name, 0, "health-check thread exiting"); - LOCK (&priv->lock); - { - priv->health_check_active = _gf_false; - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + priv->health_check_active = _gf_false; + } + UNLOCK(&priv->lock); - return NULL; + return NULL; abort: - LOCK (&priv->lock); - { - priv->health_check_active = _gf_false; + LOCK(&priv->lock); + { + priv->health_check_active = _gf_false; + } + UNLOCK(&priv->lock); + + /* health-check failed */ + gf_msg(this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, + "health-check failed, going down"); + + xlator_notify(this->parents->xlator, GF_EVENT_CHILD_DOWN, this); + + /* Below code is use to ensure if brick multiplexing is enabled if + count is more than 1 it means brick mux has enabled + */ + if (this->ctx->active) { + top = this->ctx->active->first; + LOCK(&ctx->volfile_lock); + for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) { + count++; + } + UNLOCK(&ctx->volfile_lock); + } + + if (count == 1) { + gf_msg(this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, + "still alive! -> SIGTERM"); + ret = sleep(30); + + /* Need to kill the process only while brick mux has not enabled + */ + if (ret == 0) + kill(getpid(), SIGTERM); + + ret = sleep(30); + gf_msg(this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, + "still alive! -> SIGKILL"); + if (ret == 0) + kill(getpid(), SIGKILL); + + } else { + LOCK(&ctx->volfile_lock); + for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) { + victim = (*trav_p)->xlator; + if (!victim->call_cleanup && + strcmp(victim->name, priv->base_path) == 0) { + victim_found = _gf_true; + break; + } } - UNLOCK (&priv->lock); - - /* health-check failed */ - gf_msg (this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, - "health-check failed, going down"); - - xlator_notify (this->parents->xlator, GF_EVENT_CHILD_DOWN, this); - - /* Below code is use to ensure if brick multiplexing is enabled if - count is more than 1 it means brick mux has enabled - */ - if (this->ctx->active) { - top = this->ctx->active->first; - LOCK (&ctx->volfile_lock); - for (trav_p = &top->children; *trav_p; - trav_p = &(*trav_p)->next) { - count++; - } - UNLOCK (&ctx->volfile_lock); - } - - if (count == 1) { - gf_msg (this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, - "still alive! -> SIGTERM"); - ret = sleep (30); - - /* Need to kill the process only while brick mux has not enabled - */ - if (ret == 0) - kill (getpid(), SIGTERM); - - ret = sleep (30); - gf_msg (this->name, GF_LOG_EMERG, 0, P_MSG_HEALTHCHECK_FAILED, - "still alive! -> SIGKILL"); - if (ret == 0) - kill (getpid(), SIGKILL); - - } else { - LOCK (&ctx->volfile_lock); - for (trav_p = &top->children; *trav_p; - trav_p = &(*trav_p)->next) { - victim = (*trav_p)->xlator; - if (!victim->call_cleanup && - strcmp (victim->name, priv->base_path) == 0) { - victim_found = _gf_true; - break; - } - } - UNLOCK (&ctx->volfile_lock); - if (victim_found && !victim->cleanup_starting) { - gf_log (THIS->name, GF_LOG_INFO, "detaching not-only " - " child %s", priv->base_path); - victim->cleanup_starting = 1; - top->notify (top, GF_EVENT_CLEANUP, victim); - } + UNLOCK(&ctx->volfile_lock); + if (victim_found && !victim->cleanup_starting) { + gf_log(THIS->name, GF_LOG_INFO, + "detaching not-only " + " child %s", + priv->base_path); + victim->cleanup_starting = 1; + top->notify(top, GF_EVENT_CLEANUP, victim); } + } - return NULL; + return NULL; } void -posix_spawn_health_check_thread (xlator_t *xl) +posix_spawn_health_check_thread(xlator_t *xl) { - struct posix_private *priv = NULL; - int ret = -1; + struct posix_private *priv = NULL; + int ret = -1; - priv = xl->private; + priv = xl->private; - LOCK (&priv->lock); - { - /* cancel the running thread */ - if (priv->health_check_active == _gf_true) { - pthread_cancel (priv->health_check); - priv->health_check_active = _gf_false; - } + LOCK(&priv->lock); + { + /* cancel the running thread */ + if (priv->health_check_active == _gf_true) { + pthread_cancel(priv->health_check); + priv->health_check_active = _gf_false; + } - /* prevent scheduling a check in a tight loop */ - if (priv->health_check_interval == 0) - goto unlock; - - ret = gf_thread_create (&priv->health_check, NULL, - posix_health_check_thread_proc, - xl, "posixhc"); - if (ret < 0) { - priv->health_check_interval = 0; - priv->health_check_active = _gf_false; - gf_msg (xl->name, GF_LOG_ERROR, errno, - P_MSG_HEALTHCHECK_FAILED, - "unable to setup health-check thread"); - goto unlock; - } + /* prevent scheduling a check in a tight loop */ + if (priv->health_check_interval == 0) + goto unlock; - /* run the thread detached, resources will be freed on exit */ - pthread_detach (priv->health_check); - priv->health_check_active = _gf_true; + ret = gf_thread_create(&priv->health_check, NULL, + posix_health_check_thread_proc, xl, "posixhc"); + if (ret < 0) { + priv->health_check_interval = 0; + priv->health_check_active = _gf_false; + gf_msg(xl->name, GF_LOG_ERROR, errno, P_MSG_HEALTHCHECK_FAILED, + "unable to setup health-check thread"); + goto unlock; } + + /* run the thread detached, resources will be freed on exit */ + pthread_detach(priv->health_check); + priv->health_check_active = _gf_true; + } unlock: - UNLOCK (&priv->lock); + UNLOCK(&priv->lock); } void -posix_disk_space_check (xlator_t *this) -{ - struct posix_private *priv = NULL; - char *subvol_path = NULL; - int op_ret = 0; - int percent = 0; - struct statvfs buf = {0}; - uint64_t totsz = 0; - uint64_t freesz = 0; - - GF_VALIDATE_OR_GOTO (this->name, this, out); - priv = this->private; - GF_VALIDATE_OR_GOTO (this->name, priv, out); - - subvol_path = priv->base_path; - percent = priv->disk_reserve; - - op_ret = sys_statvfs (subvol_path, &buf); - - if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_STATVFS_FAILED, - "statvfs failed on %s", subvol_path); - goto out; - } - totsz = (buf.f_blocks * buf.f_bsize); - freesz = (buf.f_bfree * buf.f_bsize); - - if (freesz <= ((totsz * percent) / 100)) { - priv->disk_space_full = 1; - } else { - priv->disk_space_full = 0; - } +posix_disk_space_check(xlator_t *this) +{ + struct posix_private *priv = NULL; + char *subvol_path = NULL; + int op_ret = 0; + int percent = 0; + struct statvfs buf = {0}; + uint64_t totsz = 0; + uint64_t freesz = 0; + + GF_VALIDATE_OR_GOTO(this->name, this, out); + priv = this->private; + GF_VALIDATE_OR_GOTO(this->name, priv, out); + + subvol_path = priv->base_path; + percent = priv->disk_reserve; + + op_ret = sys_statvfs(subvol_path, &buf); + + if (op_ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_STATVFS_FAILED, + "statvfs failed on %s", subvol_path); + goto out; + } + totsz = (buf.f_blocks * buf.f_bsize); + freesz = (buf.f_bfree * buf.f_bsize); + + if (freesz <= ((totsz * percent) / 100)) { + priv->disk_space_full = 1; + } else { + priv->disk_space_full = 0; + } out: - return; + return; } - static void * -posix_disk_space_check_thread_proc (void *data) -{ - xlator_t *this = NULL; - struct posix_private *priv = NULL; - uint32_t interval = 0; - int ret = -1; - - this = data; - priv = this->private; - - interval = 5; - gf_msg_debug (this->name, 0, "disk-space thread started, " - "interval = %d seconds", interval); - while (1) { - /* aborting sleep() is a request to exit this thread, sleep() - * will normally not return when cancelled */ - ret = sleep (interval); - if (ret > 0) - break; - /* prevent thread errors while doing the health-check(s) */ - pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL); - - /* Do the disk-check.*/ - posix_disk_space_check (this); - if (!priv->disk_space_check_active) - goto out; - pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL); - } +posix_disk_space_check_thread_proc(void *data) +{ + xlator_t *this = NULL; + struct posix_private *priv = NULL; + uint32_t interval = 0; + int ret = -1; + + this = data; + priv = this->private; + + interval = 5; + gf_msg_debug(this->name, 0, + "disk-space thread started, " + "interval = %d seconds", + interval); + while (1) { + /* aborting sleep() is a request to exit this thread, sleep() + * will normally not return when cancelled */ + ret = sleep(interval); + if (ret > 0) + break; + /* prevent thread errors while doing the health-check(s) */ + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + + /* Do the disk-check.*/ + posix_disk_space_check(this); + if (!priv->disk_space_check_active) + goto out; + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + } out: - gf_msg_debug (this->name, 0, "disk space check thread exiting"); - LOCK (&priv->lock); - { - priv->disk_space_check_active = _gf_false; - } - UNLOCK (&priv->lock); + gf_msg_debug(this->name, 0, "disk space check thread exiting"); + LOCK(&priv->lock); + { + priv->disk_space_check_active = _gf_false; + } + UNLOCK(&priv->lock); - - return NULL; + return NULL; } void -posix_spawn_disk_space_check_thread (xlator_t *xl) +posix_spawn_disk_space_check_thread(xlator_t *xl) { - struct posix_private *priv = NULL; - int ret = -1; + struct posix_private *priv = NULL; + int ret = -1; - priv = xl->private; + priv = xl->private; - LOCK (&priv->lock); - { - /* cancel the running thread */ - if (priv->disk_space_check_active == _gf_true) { - pthread_cancel (priv->disk_space_check); - priv->disk_space_check_active = _gf_false; - } - - ret = gf_thread_create_detached (&priv->disk_space_check, - posix_disk_space_check_thread_proc, - xl, "posix_reserve"); - if (ret < 0) { - priv->disk_space_check_active = _gf_false; - gf_msg (xl->name, GF_LOG_ERROR, errno, - P_MSG_DISK_SPACE_CHECK_FAILED, - "unable to setup disk space check thread"); - goto unlock; - } + LOCK(&priv->lock); + { + /* cancel the running thread */ + if (priv->disk_space_check_active == _gf_true) { + pthread_cancel(priv->disk_space_check); + priv->disk_space_check_active = _gf_false; + } - priv->disk_space_check_active = _gf_true; + ret = gf_thread_create_detached(&priv->disk_space_check, + posix_disk_space_check_thread_proc, xl, + "posix_reserve"); + if (ret < 0) { + priv->disk_space_check_active = _gf_false; + gf_msg(xl->name, GF_LOG_ERROR, errno, P_MSG_DISK_SPACE_CHECK_FAILED, + "unable to setup disk space check thread"); + goto unlock; } + + priv->disk_space_check_active = _gf_true; + } unlock: - UNLOCK (&priv->lock); + UNLOCK(&priv->lock); } int -posix_fsyncer_pick (xlator_t *this, struct list_head *head) +posix_fsyncer_pick(xlator_t *this, struct list_head *head) { - struct posix_private *priv = NULL; - int count = 0; + struct posix_private *priv = NULL; + int count = 0; - priv = this->private; - pthread_mutex_lock (&priv->fsync_mutex); - { - while (list_empty (&priv->fsyncs)) - pthread_cond_wait (&priv->fsync_cond, - &priv->fsync_mutex); + priv = this->private; + pthread_mutex_lock(&priv->fsync_mutex); + { + while (list_empty(&priv->fsyncs)) + pthread_cond_wait(&priv->fsync_cond, &priv->fsync_mutex); - count = priv->fsync_queue_count; - priv->fsync_queue_count = 0; - list_splice_init (&priv->fsyncs, head); - } - pthread_mutex_unlock (&priv->fsync_mutex); + count = priv->fsync_queue_count; + priv->fsync_queue_count = 0; + list_splice_init(&priv->fsyncs, head); + } + pthread_mutex_unlock(&priv->fsync_mutex); - return count; + return count; } - void -posix_fsyncer_process (xlator_t *this, call_stub_t *stub, gf_boolean_t do_fsync) -{ - struct posix_fd *pfd = NULL; - int ret = -1; - int op_errno = 0; - - ret = posix_fd_ctx_get (stub->args.fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_GET_FDCTX_FAILED, - "could not get fdctx for fd(%s)", - uuid_utoa (stub->args.fd->inode->gfid)); - call_unwind_error (stub, -1, op_errno); - return; - } +posix_fsyncer_process(xlator_t *this, call_stub_t *stub, gf_boolean_t do_fsync) +{ + struct posix_fd *pfd = NULL; + int ret = -1; + int op_errno = 0; + + ret = posix_fd_ctx_get(stub->args.fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_GET_FDCTX_FAILED, + "could not get fdctx for fd(%s)", + uuid_utoa(stub->args.fd->inode->gfid)); + call_unwind_error(stub, -1, op_errno); + return; + } - if (do_fsync) { - if (stub->args.datasync) - ret = sys_fdatasync (pfd->fd); - else - ret = sys_fsync (pfd->fd); - } else { - ret = 0; - } + if (do_fsync) { + if (stub->args.datasync) + ret = sys_fdatasync(pfd->fd); + else + ret = sys_fsync(pfd->fd); + } else { + ret = 0; + } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "could not fstat fd(%s)", - uuid_utoa (stub->args.fd->inode->gfid)); - call_unwind_error (stub, -1, errno); - return; - } + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "could not fstat fd(%s)", uuid_utoa(stub->args.fd->inode->gfid)); + call_unwind_error(stub, -1, errno); + return; + } - call_unwind_error (stub, 0, 0); + call_unwind_error(stub, 0, 0); } - static void -posix_fsyncer_syncfs (xlator_t *this, struct list_head *head) +posix_fsyncer_syncfs(xlator_t *this, struct list_head *head) { - call_stub_t *stub = NULL; - struct posix_fd *pfd = NULL; - int ret = -1; + call_stub_t *stub = NULL; + struct posix_fd *pfd = NULL; + int ret = -1; - stub = list_entry (head->prev, call_stub_t, list); - ret = posix_fd_ctx_get (stub->args.fd, this, &pfd, NULL); - if (ret) - return; + stub = list_entry(head->prev, call_stub_t, list); + ret = posix_fd_ctx_get(stub->args.fd, this, &pfd, NULL); + if (ret) + return; #ifdef GF_LINUX_HOST_OS /* syncfs() is not "declared" in RHEL's glibc even though @@ -2280,152 +2235,152 @@ posix_fsyncer_syncfs (xlator_t *this, struct list_head *head) #include <sys/syscall.h> #include <unistd.h> #ifdef SYS_syncfs - syscall (SYS_syncfs, pfd->fd); + syscall(SYS_syncfs, pfd->fd); #else - sync(); + sync(); #endif #else - sync(); + sync(); #endif } - void * -posix_fsyncer (void *d) +posix_fsyncer(void *d) { - xlator_t *this = d; - struct posix_private *priv = NULL; - call_stub_t *stub = NULL; - call_stub_t *tmp = NULL; - struct list_head list; - int count = 0; - gf_boolean_t do_fsync = _gf_true; + xlator_t *this = d; + struct posix_private *priv = NULL; + call_stub_t *stub = NULL; + call_stub_t *tmp = NULL; + struct list_head list; + int count = 0; + gf_boolean_t do_fsync = _gf_true; - priv = this->private; + priv = this->private; - for (;;) { - INIT_LIST_HEAD (&list); + for (;;) { + INIT_LIST_HEAD(&list); - count = posix_fsyncer_pick (this, &list); + count = posix_fsyncer_pick(this, &list); - usleep (priv->batch_fsync_delay_usec); + usleep(priv->batch_fsync_delay_usec); - gf_msg_debug (this->name, 0, - "picked %d fsyncs", count); + gf_msg_debug(this->name, 0, "picked %d fsyncs", count); - switch (priv->batch_fsync_mode) { - case BATCH_NONE: - case BATCH_REVERSE_FSYNC: - break; - case BATCH_SYNCFS: - case BATCH_SYNCFS_SINGLE_FSYNC: - case BATCH_SYNCFS_REVERSE_FSYNC: - posix_fsyncer_syncfs (this, &list); - break; - } + switch (priv->batch_fsync_mode) { + case BATCH_NONE: + case BATCH_REVERSE_FSYNC: + break; + case BATCH_SYNCFS: + case BATCH_SYNCFS_SINGLE_FSYNC: + case BATCH_SYNCFS_REVERSE_FSYNC: + posix_fsyncer_syncfs(this, &list); + break; + } - if (priv->batch_fsync_mode == BATCH_SYNCFS) - do_fsync = _gf_false; - else - do_fsync = _gf_true; + if (priv->batch_fsync_mode == BATCH_SYNCFS) + do_fsync = _gf_false; + else + do_fsync = _gf_true; - list_for_each_entry_safe_reverse (stub, tmp, &list, list) { - list_del_init (&stub->list); + list_for_each_entry_safe_reverse(stub, tmp, &list, list) + { + list_del_init(&stub->list); - posix_fsyncer_process (this, stub, do_fsync); + posix_fsyncer_process(this, stub, do_fsync); - if (priv->batch_fsync_mode == BATCH_SYNCFS_SINGLE_FSYNC) - do_fsync = _gf_false; - } + if (priv->batch_fsync_mode == BATCH_SYNCFS_SINGLE_FSYNC) + do_fsync = _gf_false; } + } } /** * TODO: move fd/inode interfaces into a single routine.. */ static int32_t -posix_fetch_signature_xattr (char *real_path, - const char *key, dict_t *xattr, size_t *xsize) -{ - int32_t ret = 0; - char *memptr = NULL; - ssize_t xattrsize = 0; - char val_buf[2048] = {0,}; - gf_boolean_t have_val = _gf_false; - - xattrsize = sys_lgetxattr (real_path, key, val_buf, - sizeof(val_buf) - 1); - if (xattrsize >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) - xattrsize = sys_lgetxattr (real_path, key, NULL, 0); - if ((errno == ENOATTR) || (errno == ENODATA)) - return 0; - if (xattrsize == -1) - goto error_return; - } - memptr = GF_MALLOC (xattrsize + 1, gf_posix_mt_char); - if (!memptr) - goto error_return; - if (have_val) { - memcpy (memptr, val_buf, xattrsize); - memptr[xattrsize] = '\0'; - } else { - bzero (memptr, xattrsize + 1); - ret = sys_lgetxattr (real_path, key, memptr, xattrsize); - if (ret == -1) - goto freemem; - } - ret = dict_set_dynptr (xattr, (char *)key, memptr, xattrsize); - if (ret) - goto freemem; +posix_fetch_signature_xattr(char *real_path, const char *key, dict_t *xattr, + size_t *xsize) +{ + int32_t ret = 0; + char *memptr = NULL; + ssize_t xattrsize = 0; + char val_buf[2048] = { + 0, + }; + gf_boolean_t have_val = _gf_false; + + xattrsize = sys_lgetxattr(real_path, key, val_buf, sizeof(val_buf) - 1); + if (xattrsize >= 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) + xattrsize = sys_lgetxattr(real_path, key, NULL, 0); + if ((errno == ENOATTR) || (errno == ENODATA)) + return 0; + if (xattrsize == -1) + goto error_return; + } + memptr = GF_MALLOC(xattrsize + 1, gf_posix_mt_char); + if (!memptr) + goto error_return; + if (have_val) { + memcpy(memptr, val_buf, xattrsize); + memptr[xattrsize] = '\0'; + } else { + bzero(memptr, xattrsize + 1); + ret = sys_lgetxattr(real_path, key, memptr, xattrsize); + if (ret == -1) + goto freemem; + } + ret = dict_set_dynptr(xattr, (char *)key, memptr, xattrsize); + if (ret) + goto freemem; - if (xsize) - *xsize = xattrsize; + if (xsize) + *xsize = xattrsize; - return 0; + return 0; - freemem: - GF_FREE (memptr); - error_return: - return -1; +freemem: + GF_FREE(memptr); +error_return: + return -1; } static int32_t -posix_fd_fetch_signature_xattr (int fd, - const char *key, dict_t *xattr, size_t *xsize) +posix_fd_fetch_signature_xattr(int fd, const char *key, dict_t *xattr, + size_t *xsize) { - int32_t ret = 0; - char *memptr = NULL; - ssize_t xattrsize = 0; + int32_t ret = 0; + char *memptr = NULL; + ssize_t xattrsize = 0; - xattrsize = sys_fgetxattr (fd, key, NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) - return 0; - if (xattrsize == -1) - goto error_return; + xattrsize = sys_fgetxattr(fd, key, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) + return 0; + if (xattrsize == -1) + goto error_return; - memptr = GF_CALLOC (xattrsize + 1, sizeof (char), gf_posix_mt_char); - if (!memptr) - goto error_return; - ret = sys_fgetxattr (fd, key, memptr, xattrsize); - if (ret == -1) - goto freemem; + memptr = GF_CALLOC(xattrsize + 1, sizeof(char), gf_posix_mt_char); + if (!memptr) + goto error_return; + ret = sys_fgetxattr(fd, key, memptr, xattrsize); + if (ret == -1) + goto freemem; - ret = dict_set_dynptr (xattr, (char *)key, memptr, xattrsize); - if (ret) - goto freemem; + ret = dict_set_dynptr(xattr, (char *)key, memptr, xattrsize); + if (ret) + goto freemem; - if (xsize) - *xsize = xattrsize; + if (xsize) + *xsize = xattrsize; - return 0; + return 0; - freemem: - GF_FREE (memptr); - error_return: - return -1; +freemem: + GF_FREE(memptr); +error_return: + return -1; } /** @@ -2435,65 +2390,65 @@ posix_fd_fetch_signature_xattr (int fd, * interpreting the xattrs for anomalies. */ int32_t -posix_get_objectsignature (char *real_path, dict_t *xattr) +posix_get_objectsignature(char *real_path, dict_t *xattr) { - int32_t ret = 0; - size_t signsize = 0; + int32_t ret = 0; + size_t signsize = 0; - ret = posix_fetch_signature_xattr - (real_path, BITROT_CURRENT_VERSION_KEY, xattr, NULL); - if (ret) - goto error_return; + ret = posix_fetch_signature_xattr(real_path, BITROT_CURRENT_VERSION_KEY, + xattr, NULL); + if (ret) + goto error_return; - ret = posix_fetch_signature_xattr - (real_path, BITROT_SIGNING_VERSION_KEY, xattr, &signsize); - if (ret) - goto delkey1; + ret = posix_fetch_signature_xattr(real_path, BITROT_SIGNING_VERSION_KEY, + xattr, &signsize); + if (ret) + goto delkey1; - ret = dict_set_uint32 - (xattr, BITROT_SIGNING_XATTR_SIZE_KEY, (uint32_t) signsize); - if (ret) - goto delkey2; + ret = dict_set_uint32(xattr, BITROT_SIGNING_XATTR_SIZE_KEY, + (uint32_t)signsize); + if (ret) + goto delkey2; - return 0; + return 0; - delkey2: - dict_del (xattr, BITROT_SIGNING_VERSION_KEY); - delkey1: - dict_del (xattr, BITROT_CURRENT_VERSION_KEY); - error_return: - return -EINVAL; +delkey2: + dict_del(xattr, BITROT_SIGNING_VERSION_KEY); +delkey1: + dict_del(xattr, BITROT_CURRENT_VERSION_KEY); +error_return: + return -EINVAL; } int32_t -posix_fdget_objectsignature (int fd, dict_t *xattr) +posix_fdget_objectsignature(int fd, dict_t *xattr) { - int32_t ret = 0; - size_t signsize = 0; + int32_t ret = 0; + size_t signsize = 0; - ret = posix_fd_fetch_signature_xattr - (fd, BITROT_CURRENT_VERSION_KEY, xattr, NULL); - if (ret) - goto error_return; + ret = posix_fd_fetch_signature_xattr(fd, BITROT_CURRENT_VERSION_KEY, xattr, + NULL); + if (ret) + goto error_return; - ret = posix_fd_fetch_signature_xattr - (fd, BITROT_SIGNING_VERSION_KEY, xattr, &signsize); - if (ret) - goto delkey1; + ret = posix_fd_fetch_signature_xattr(fd, BITROT_SIGNING_VERSION_KEY, xattr, + &signsize); + if (ret) + goto delkey1; - ret = dict_set_uint32 - (xattr, BITROT_SIGNING_XATTR_SIZE_KEY, (uint32_t) signsize); - if (ret) - goto delkey2; + ret = dict_set_uint32(xattr, BITROT_SIGNING_XATTR_SIZE_KEY, + (uint32_t)signsize); + if (ret) + goto delkey2; - return 0; + return 0; - delkey2: - dict_del (xattr, BITROT_SIGNING_VERSION_KEY); - delkey1: - dict_del (xattr, BITROT_CURRENT_VERSION_KEY); - error_return: - return -EINVAL; +delkey2: + dict_del(xattr, BITROT_SIGNING_VERSION_KEY); +delkey1: + dict_del(xattr, BITROT_CURRENT_VERSION_KEY); +error_return: + return -EINVAL; } /* @@ -2506,793 +2461,782 @@ posix_fdget_objectsignature (int fd, dict_t *xattr) **/ int32_t -posix_resolve_dirgfid_to_path (const uuid_t dirgfid, const char *brick_path, - const char *bname, char **path) -{ - char *linkname = NULL; - char *dir_handle = NULL; - char *pgfidstr = NULL; - char *saveptr = NULL; - ssize_t len = 0; - int ret = 0; - uuid_t tmp_gfid = {0, }; - uuid_t pargfid = {0, }; - char gpath[PATH_MAX] = {0,}; - char result[PATH_MAX] = {0,}; - char result1[PATH_MAX] = {0,}; - char *dir_name = NULL; - char pre_dir_name[PATH_MAX] = {0,}; - xlator_t *this = NULL; - - this = THIS; - GF_ASSERT (this); - - gf_uuid_copy (pargfid, dirgfid); - if (!path || gf_uuid_is_null (pargfid)) { - ret = -1; - goto out; - } - - if (__is_root_gfid (pargfid)) { - if (bname) { - snprintf (result, PATH_MAX, "/%s", bname); - *path = gf_strdup (result); - } else { - *path = gf_strdup ("/"); - } - return ret; +posix_resolve_dirgfid_to_path(const uuid_t dirgfid, const char *brick_path, + const char *bname, char **path) +{ + char *linkname = NULL; + char *dir_handle = NULL; + char *pgfidstr = NULL; + char *saveptr = NULL; + ssize_t len = 0; + int ret = 0; + uuid_t tmp_gfid = { + 0, + }; + uuid_t pargfid = { + 0, + }; + char gpath[PATH_MAX] = { + 0, + }; + char result[PATH_MAX] = { + 0, + }; + char result1[PATH_MAX] = { + 0, + }; + char *dir_name = NULL; + char pre_dir_name[PATH_MAX] = { + 0, + }; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT(this); + + gf_uuid_copy(pargfid, dirgfid); + if (!path || gf_uuid_is_null(pargfid)) { + ret = -1; + goto out; + } + + if (__is_root_gfid(pargfid)) { + if (bname) { + snprintf(result, PATH_MAX, "/%s", bname); + *path = gf_strdup(result); + } else { + *path = gf_strdup("/"); } + return ret; + } - dir_handle = alloca (PATH_MAX); - linkname = alloca (PATH_MAX); - (void) snprintf (gpath, PATH_MAX, "%s/.glusterfs/", brick_path); - - while (!(__is_root_gfid (pargfid))) { - len = snprintf (dir_handle, PATH_MAX, "%s/%02x/%02x/%s", gpath, - pargfid[0], pargfid[1], uuid_utoa (pargfid)); - if ((len < 0) || (len >= PATH_MAX)) { - ret = -1; - goto out; - } - - len = sys_readlink (dir_handle, linkname, PATH_MAX); - if (len < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_READLINK_FAILED, - "could not read the " - "link from the gfid handle %s", dir_handle); - ret = -1; - goto out; - } - - linkname[len] = '\0'; + dir_handle = alloca(PATH_MAX); + linkname = alloca(PATH_MAX); + (void)snprintf(gpath, PATH_MAX, "%s/.glusterfs/", brick_path); - pgfidstr = strtok_r (linkname + strlen("../../00/00/"), "/", - &saveptr); - dir_name = strtok_r (NULL, "/", &saveptr); + while (!(__is_root_gfid(pargfid))) { + len = snprintf(dir_handle, PATH_MAX, "%s/%02x/%02x/%s", gpath, + pargfid[0], pargfid[1], uuid_utoa(pargfid)); + if ((len < 0) || (len >= PATH_MAX)) { + ret = -1; + goto out; + } - if (strlen(pre_dir_name) != 0) { /* Remove '/' at the end */ - len = snprintf (result, PATH_MAX, "%s/%s", dir_name, - pre_dir_name); - } else { - len = snprintf (result, PATH_MAX, "%s", dir_name); - } - if ((len < 0) || (len >= PATH_MAX)) { - ret = -1; - goto out; - } + len = sys_readlink(dir_handle, linkname, PATH_MAX); + if (len < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_READLINK_FAILED, + "could not read the " + "link from the gfid handle %s", + dir_handle); + ret = -1; + goto out; + } - snprintf (pre_dir_name, sizeof (pre_dir_name), "%s", result); + linkname[len] = '\0'; - gf_uuid_parse (pgfidstr, tmp_gfid); - gf_uuid_copy (pargfid, tmp_gfid); - } + pgfidstr = strtok_r(linkname + strlen("../../00/00/"), "/", &saveptr); + dir_name = strtok_r(NULL, "/", &saveptr); - if (bname) { - len = snprintf (result1, PATH_MAX, "/%s/%s", result, bname); + if (strlen(pre_dir_name) != 0) { /* Remove '/' at the end */ + len = snprintf(result, PATH_MAX, "%s/%s", dir_name, pre_dir_name); } else { - len = snprintf (result1, PATH_MAX, "/%s", result); + len = snprintf(result, PATH_MAX, "%s", dir_name); } if ((len < 0) || (len >= PATH_MAX)) { - ret = -1; - goto out; + ret = -1; + goto out; } - *path = gf_strdup (result1); - if (*path == NULL) { - ret = -1; - goto out; - } + snprintf(pre_dir_name, sizeof(pre_dir_name), "%s", result); + + gf_uuid_parse(pgfidstr, tmp_gfid); + gf_uuid_copy(pargfid, tmp_gfid); + } + + if (bname) { + len = snprintf(result1, PATH_MAX, "/%s/%s", result, bname); + } else { + len = snprintf(result1, PATH_MAX, "/%s", result); + } + if ((len < 0) || (len >= PATH_MAX)) { + ret = -1; + goto out; + } + + *path = gf_strdup(result1); + if (*path == NULL) { + ret = -1; + goto out; + } out: - return ret; + return ret; } posix_inode_ctx_t * -__posix_inode_ctx_get (inode_t *inode, xlator_t *this) +__posix_inode_ctx_get(inode_t *inode, xlator_t *this) { - int ret = -1; - uint64_t ctx_uint = 0; - posix_inode_ctx_t *ctx_p = NULL; + int ret = -1; + uint64_t ctx_uint = 0; + posix_inode_ctx_t *ctx_p = NULL; - ret = __inode_ctx_get (inode, this, &ctx_uint); - if (ret == 0) { - return (posix_inode_ctx_t *)ctx_uint; - } + ret = __inode_ctx_get(inode, this, &ctx_uint); + if (ret == 0) { + return (posix_inode_ctx_t *)ctx_uint; + } - ctx_p = GF_CALLOC (1, sizeof (*ctx_p), gf_posix_mt_inode_ctx_t); - if (!ctx_p) - return NULL; + ctx_p = GF_CALLOC(1, sizeof(*ctx_p), gf_posix_mt_inode_ctx_t); + if (!ctx_p) + return NULL; - pthread_mutex_init (&ctx_p->xattrop_lock, NULL); - pthread_mutex_init (&ctx_p->write_atomic_lock, NULL); - pthread_mutex_init (&ctx_p->pgfid_lock, NULL); + pthread_mutex_init(&ctx_p->xattrop_lock, NULL); + pthread_mutex_init(&ctx_p->write_atomic_lock, NULL); + pthread_mutex_init(&ctx_p->pgfid_lock, NULL); - ret = __inode_ctx_set (inode, this, (uint64_t *)&ctx_p); - if (ret < 0) { - pthread_mutex_destroy (&ctx_p->xattrop_lock); - pthread_mutex_destroy (&ctx_p->write_atomic_lock); - pthread_mutex_destroy (&ctx_p->pgfid_lock); - GF_FREE (ctx_p); - return NULL; - } + ret = __inode_ctx_set(inode, this, (uint64_t *)&ctx_p); + if (ret < 0) { + pthread_mutex_destroy(&ctx_p->xattrop_lock); + pthread_mutex_destroy(&ctx_p->write_atomic_lock); + pthread_mutex_destroy(&ctx_p->pgfid_lock); + GF_FREE(ctx_p); + return NULL; + } - return ctx_p; + return ctx_p; } int -__posix_inode_ctx_set_unlink_flag (inode_t *inode, xlator_t *this, uint64_t ctx) +__posix_inode_ctx_set_unlink_flag(inode_t *inode, xlator_t *this, uint64_t ctx) { - posix_inode_ctx_t *ctx_p = NULL; + posix_inode_ctx_t *ctx_p = NULL; - ctx_p = __posix_inode_ctx_get (inode, this); - if (ctx_p == NULL) - return -1; + ctx_p = __posix_inode_ctx_get(inode, this); + if (ctx_p == NULL) + return -1; - ctx_p->unlink_flag = ctx; + ctx_p->unlink_flag = ctx; - return 0; + return 0; } int -posix_inode_ctx_set_unlink_flag (inode_t *inode, xlator_t *this, uint64_t ctx) +posix_inode_ctx_set_unlink_flag(inode_t *inode, xlator_t *this, uint64_t ctx) { - int ret = -1; + int ret = -1; - LOCK(&inode->lock); - { - ret = __posix_inode_ctx_set_unlink_flag (inode, this, ctx); - } - UNLOCK(&inode->lock); + LOCK(&inode->lock); + { + ret = __posix_inode_ctx_set_unlink_flag(inode, this, ctx); + } + UNLOCK(&inode->lock); - return ret; + return ret; } int -__posix_inode_ctx_get_all (inode_t *inode, xlator_t *this, - posix_inode_ctx_t **ctx) +__posix_inode_ctx_get_all(inode_t *inode, xlator_t *this, + posix_inode_ctx_t **ctx) { - posix_inode_ctx_t *ctx_p = NULL; + posix_inode_ctx_t *ctx_p = NULL; - ctx_p = __posix_inode_ctx_get (inode, this); - if (ctx_p == NULL) - return -1; + ctx_p = __posix_inode_ctx_get(inode, this); + if (ctx_p == NULL) + return -1; - *ctx = ctx_p; + *ctx = ctx_p; - return 0; + return 0; } int -posix_inode_ctx_get_all (inode_t *inode, xlator_t *this, - posix_inode_ctx_t **ctx) +posix_inode_ctx_get_all(inode_t *inode, xlator_t *this, posix_inode_ctx_t **ctx) { - int ret = 0; + int ret = 0; - LOCK(&inode->lock); - { - ret = __posix_inode_ctx_get_all (inode, this, ctx); - } - UNLOCK(&inode->lock); + LOCK(&inode->lock); + { + ret = __posix_inode_ctx_get_all(inode, this, ctx); + } + UNLOCK(&inode->lock); - return ret; + return ret; } gf_boolean_t -posix_is_bulk_removexattr (char *name, dict_t *xdata) +posix_is_bulk_removexattr(char *name, dict_t *xdata) { - if (name && (strlen (name) == 0) && xdata) - return _gf_true; - return _gf_false; + if (name && (strlen(name) == 0) && xdata) + return _gf_true; + return _gf_false; } int32_t -posix_set_iatt_in_dict (dict_t *dict, struct iatt *preop, struct iatt *postop) -{ - int ret = -1; - struct iatt *stbuf = NULL; - int32_t len = sizeof(struct iatt); - struct iatt *prebuf = NULL; - struct iatt *postbuf = NULL; - - if (!dict) - return ret; - - if (postop) { - stbuf = GF_MALLOC (len, gf_common_mt_char); - if (!stbuf) - goto out; - memcpy (stbuf, postop, len); - ret = dict_set_iatt (dict, DHT_IATT_IN_XDATA_KEY, stbuf, - false); - if (ret < 0) { - GF_FREE (stbuf); - goto out; - } +posix_set_iatt_in_dict(dict_t *dict, struct iatt *preop, struct iatt *postop) +{ + int ret = -1; + struct iatt *stbuf = NULL; + int32_t len = sizeof(struct iatt); + struct iatt *prebuf = NULL; + struct iatt *postbuf = NULL; + + if (!dict) + return ret; + + if (postop) { + stbuf = GF_MALLOC(len, gf_common_mt_char); + if (!stbuf) + goto out; + memcpy(stbuf, postop, len); + ret = dict_set_iatt(dict, DHT_IATT_IN_XDATA_KEY, stbuf, false); + if (ret < 0) { + GF_FREE(stbuf); + goto out; } + } - if (preop) { - prebuf = GF_MALLOC (len, gf_common_mt_char); - if (!prebuf) - goto out; - memcpy (prebuf, preop, len); - ret = dict_set_iatt (dict, GF_PRESTAT, prebuf, false); - if (ret < 0) { - GF_FREE (prebuf); - goto out; - } + if (preop) { + prebuf = GF_MALLOC(len, gf_common_mt_char); + if (!prebuf) + goto out; + memcpy(prebuf, preop, len); + ret = dict_set_iatt(dict, GF_PRESTAT, prebuf, false); + if (ret < 0) { + GF_FREE(prebuf); + goto out; } + } - if (postop) { - postbuf = GF_MALLOC (len, gf_common_mt_char); - if (!postbuf) - goto out; - memcpy (postbuf, postop, len); - ret = dict_set_iatt (dict, GF_POSTSTAT, postbuf, false); - if (ret < 0) { - GF_FREE (postbuf); - goto out; - } + if (postop) { + postbuf = GF_MALLOC(len, gf_common_mt_char); + if (!postbuf) + goto out; + memcpy(postbuf, postop, len); + ret = dict_set_iatt(dict, GF_POSTSTAT, postbuf, false); + if (ret < 0) { + GF_FREE(postbuf); + goto out; } + } - ret = 0; + ret = 0; out: - return ret; + return ret; } mode_t -posix_override_umask (mode_t mode, mode_t mode_bit) +posix_override_umask(mode_t mode, mode_t mode_bit) { - gf_msg_debug ("posix", 0, "The value of mode is %u", mode); - mode = mode >> 9; /* 3x3 (bits for each octal digit)*/ - mode = (mode << 9) | mode_bit; - gf_msg_debug ("posix", 0, "The value of mode is %u", mode); - return mode; + gf_msg_debug("posix", 0, "The value of mode is %u", mode); + mode = mode >> 9; /* 3x3 (bits for each octal digit)*/ + mode = (mode << 9) | mode_bit; + gf_msg_debug("posix", 0, "The value of mode is %u", mode); + return mode; } int -posix_check_internal_writes (xlator_t *this, fd_t *fd, int sysfd, - dict_t *xdata) +posix_check_internal_writes(xlator_t *this, fd_t *fd, int sysfd, dict_t *xdata) { - int ret = 0; - size_t xattrsize = 0; - data_t *val = NULL; - - if (!xdata) - return 0; + int ret = 0; + size_t xattrsize = 0; + data_t *val = NULL; - LOCK (&fd->inode->lock); - { - val = dict_get (xdata, GF_PROTECT_FROM_EXTERNAL_WRITES); - if (val) { - ret = sys_fsetxattr (sysfd, - GF_PROTECT_FROM_EXTERNAL_WRITES, - val->data, val->len, 0); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, - P_MSG_XATTR_FAILED, - errno, "setxattr failed key %s", - GF_PROTECT_FROM_EXTERNAL_WRITES); - } - - goto out; - } + if (!xdata) + return 0; - if (dict_get (xdata, GF_AVOID_OVERWRITE)) { - xattrsize = sys_fgetxattr (sysfd, - GF_PROTECT_FROM_EXTERNAL_WRITES, - NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - ret = 0; - } else { - ret = -1; - } - } + LOCK(&fd->inode->lock); + { + val = dict_get(xdata, GF_PROTECT_FROM_EXTERNAL_WRITES); + if (val) { + ret = sys_fsetxattr(sysfd, GF_PROTECT_FROM_EXTERNAL_WRITES, + val->data, val->len, 0); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, P_MSG_XATTR_FAILED, errno, + "setxattr failed key %s", + GF_PROTECT_FROM_EXTERNAL_WRITES); + } + + goto out; + } + + if (dict_get(xdata, GF_AVOID_OVERWRITE)) { + xattrsize = sys_fgetxattr(sysfd, GF_PROTECT_FROM_EXTERNAL_WRITES, + NULL, 0); + if ((xattrsize == -1) && + ((errno == ENOATTR) || (errno == ENODATA))) { + ret = 0; + } else { + ret = -1; + } } + } out: - UNLOCK (&fd->inode->lock); - return ret; + UNLOCK(&fd->inode->lock); + return ret; } gf_cs_obj_state -posix_cs_heal_state (xlator_t *this, const char *realpath, int *fd, - struct iatt *buf) -{ - gf_boolean_t remote = _gf_false; - gf_boolean_t downloading = _gf_false; - int ret = 0; - gf_cs_obj_state state = GF_CS_ERROR; - size_t xattrsize = 0; - - if (!buf) { - ret = -1; - goto out; +posix_cs_heal_state(xlator_t *this, const char *realpath, int *fd, + struct iatt *buf) +{ + gf_boolean_t remote = _gf_false; + gf_boolean_t downloading = _gf_false; + int ret = 0; + gf_cs_obj_state state = GF_CS_ERROR; + size_t xattrsize = 0; + + if (!buf) { + ret = -1; + goto out; + } + + if (fd) { + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_REMOTE, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + remote = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "fgetxattr" + " failed"); + state = GF_CS_ERROR; + goto out; + } else { + remote = _gf_true; + } + + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_DOWNLOADING, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + downloading = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "fgetxattr" + " failed"); + state = GF_CS_ERROR; + goto out; + } else { + downloading = _gf_true; + } + } else { + xattrsize = sys_lgetxattr(realpath, GF_CS_OBJECT_REMOTE, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + remote = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "getxattr" + " failed"); + state = GF_CS_ERROR; + goto out; + } else { + remote = _gf_true; + } + + xattrsize = sys_lgetxattr(realpath, GF_CS_OBJECT_DOWNLOADING, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + downloading = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "getxattr" + " failed"); + state = GF_CS_ERROR; + goto out; + } else { + downloading = _gf_true; } + } + if (remote && downloading) { if (fd) { - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_REMOTE, NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - remote = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, errno, "fgetxattr" - " failed"); - state = GF_CS_ERROR; - goto out; - } else { - remote = _gf_true; - } - - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_DOWNLOADING, NULL, - 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - downloading = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, errno, "fgetxattr" - " failed"); - state = GF_CS_ERROR; - goto out; - } else { - downloading = _gf_true; - } + ret = sys_fremovexattr(*fd, GF_CS_OBJECT_DOWNLOADING); } else { - xattrsize = sys_lgetxattr (realpath, GF_CS_OBJECT_REMOTE, NULL, - 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - remote = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, errno, "getxattr" - " failed"); - state = GF_CS_ERROR; - goto out; - } else { - remote = _gf_true; - } - - xattrsize = sys_lgetxattr (realpath, GF_CS_OBJECT_DOWNLOADING, - NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - downloading = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, errno, "getxattr" - " failed"); - state = GF_CS_ERROR; - goto out; - } else { - downloading = _gf_true; - } + ret = sys_lremovexattr(realpath, GF_CS_OBJECT_DOWNLOADING); } - if (remote && downloading) { - if (fd) { - ret = sys_fremovexattr (*fd, GF_CS_OBJECT_DOWNLOADING); - } else { - ret = sys_lremovexattr (realpath, GF_CS_OBJECT_DOWNLOADING); - } + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "failed to remove xattr, repair failed"); + state = GF_CS_ERROR; + goto out; + } + + if (buf->ia_size) { + if (fd) { + ret = sys_ftruncate(*fd, 0); + } else { + ret = sys_truncate(realpath, 0); + } + + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "truncate failed. File is in inconsistent" + " state"); + state = GF_CS_ERROR; + goto out; + } + } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - "failed to remove xattr, repair failed"); - state = GF_CS_ERROR; - goto out; - } + state = GF_CS_REMOTE; + goto out; - if (buf->ia_size) { - if (fd) { - ret = sys_ftruncate (*fd, 0); - } else { - ret = sys_truncate (realpath, 0); - } - - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - "truncate failed. File is in inconsistent" - " state"); - state = GF_CS_ERROR; - goto out; - } - } - - state = GF_CS_REMOTE; + } else if (remote) { + if (buf->ia_size) { + if (fd) { + ret = sys_ftruncate(*fd, 0); + } else { + ret = sys_truncate(realpath, 0); + } + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "truncate failed. File is in inconsistent" + " state"); + state = GF_CS_ERROR; goto out; + } + } - } else if (remote) { - if (buf->ia_size) { - if (fd) { - ret = sys_ftruncate (*fd, 0); - } else { - ret = sys_truncate (realpath, 0); - } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - "truncate failed. File is in inconsistent" - " state"); - state = GF_CS_ERROR; - goto out; - } - } + state = GF_CS_REMOTE; + goto out; + } else if (downloading) { + if (buf->ia_size) { + if (fd) { + ret = sys_fremovexattr(*fd, GF_CS_OBJECT_DOWNLOADING); + } else { + ret = sys_lremovexattr(realpath, GF_CS_OBJECT_DOWNLOADING); + } - state = GF_CS_REMOTE; + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + "failed to remove xattr, repair failed"); + state = GF_CS_ERROR; goto out; - } else if (downloading) { - if (buf->ia_size) { - if (fd) { - ret = sys_fremovexattr (*fd, GF_CS_OBJECT_DOWNLOADING); - } else { - ret = sys_lremovexattr (realpath, GF_CS_OBJECT_DOWNLOADING); - } - - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - "failed to remove xattr, repair failed"); - state = GF_CS_ERROR; - goto out; - } - - state = GF_CS_LOCAL; - goto out; - } + } + + state = GF_CS_LOCAL; + goto out; } + } - state = GF_CS_LOCAL; + state = GF_CS_LOCAL; out: - gf_msg_debug (this->name, 0, "heal state returned %d", state); - return state; + gf_msg_debug(this->name, 0, "heal state returned %d", state); + return state; } gf_cs_obj_state -posix_cs_check_status (xlator_t *this, const char *realpath, int *fd, - struct iatt *buf) -{ - gf_boolean_t remote = _gf_false; - gf_boolean_t downloading = _gf_false; - int ret = 0; - gf_cs_obj_state state = GF_CS_LOCAL; - size_t xattrsize = 0; - int op_errno = 0; - - if (fd) { - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_REMOTE, NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - remote = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "getxattr " - "failed err %d", errno); - goto out; - } else { - remote = _gf_true; - } - - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_DOWNLOADING, NULL, - 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - downloading = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "getxattr " - "failed err : %d", errno); - - goto out; - } else { - downloading = _gf_true; - } - +posix_cs_check_status(xlator_t *this, const char *realpath, int *fd, + struct iatt *buf) +{ + gf_boolean_t remote = _gf_false; + gf_boolean_t downloading = _gf_false; + int ret = 0; + gf_cs_obj_state state = GF_CS_LOCAL; + size_t xattrsize = 0; + int op_errno = 0; + + if (fd) { + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_REMOTE, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + remote = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "getxattr " + "failed err %d", + errno); + goto out; + } else { + remote = _gf_true; } - if (realpath) { - xattrsize = sys_lgetxattr (realpath, GF_CS_OBJECT_REMOTE, NULL, - 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - remote = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "getxattr " - "failed err : %d", errno); - goto out; - } else { - remote = _gf_true; - } + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_DOWNLOADING, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + downloading = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "getxattr " + "failed err : %d", + errno); - xattrsize = sys_lgetxattr (realpath, GF_CS_OBJECT_DOWNLOADING, - NULL, 0); - if ((xattrsize == -1) && ((errno == ENOATTR) || - (errno == ENODATA))) { - downloading = _gf_false; - } else if (xattrsize == -1) { - ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "getxattr " - "failed err : %d", errno); - goto out; - } else { - downloading = _gf_true; - } + goto out; + } else { + downloading = _gf_true; + } + } + + if (realpath) { + xattrsize = sys_lgetxattr(realpath, GF_CS_OBJECT_REMOTE, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + remote = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "getxattr " + "failed err : %d", + errno); + goto out; + } else { + remote = _gf_true; + } + + xattrsize = sys_lgetxattr(realpath, GF_CS_OBJECT_DOWNLOADING, NULL, 0); + if ((xattrsize == -1) && ((errno == ENOATTR) || (errno == ENODATA))) { + downloading = _gf_false; + } else if (xattrsize == -1) { + ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "getxattr " + "failed err : %d", + errno); + goto out; + } else { + downloading = _gf_true; } + } out: - if (ret) { - gf_msg ("POSIX", GF_LOG_ERROR, 0, op_errno, "getxattr failed " - "with %d", op_errno); - state = GF_CS_ERROR; - return state; - } - - if ((remote && downloading) || (remote && buf && buf->ia_size)) { - state = GF_CS_REPAIR; - gf_msg_debug (this->name, 0, "status is REPAIR"); - return state; - } - - if (remote) - state = GF_CS_REMOTE; - else if (downloading) - state = GF_CS_DOWNLOADING; - else - state = GF_CS_LOCAL; + if (ret) { + gf_msg("POSIX", GF_LOG_ERROR, 0, op_errno, + "getxattr failed " + "with %d", + op_errno); + state = GF_CS_ERROR; + return state; + } - gf_msg_debug (this->name, 0, "state returned is %d", state); + if ((remote && downloading) || (remote && buf && buf->ia_size)) { + state = GF_CS_REPAIR; + gf_msg_debug(this->name, 0, "status is REPAIR"); return state; + } + if (remote) + state = GF_CS_REMOTE; + else if (downloading) + state = GF_CS_DOWNLOADING; + else + state = GF_CS_LOCAL; + + gf_msg_debug(this->name, 0, "state returned is %d", state); + return state; } int -posix_cs_set_state (xlator_t *this, dict_t **rsp, gf_cs_obj_state state, - char const *path, int *fd) +posix_cs_set_state(xlator_t *this, dict_t **rsp, gf_cs_obj_state state, + char const *path, int *fd) { - int ret = 0; - char *value = NULL; - size_t xattrsize = 0; + int ret = 0; + char *value = NULL; + size_t xattrsize = 0; + if (!(*rsp)) { + *rsp = dict_new(); if (!(*rsp)) { - *rsp = dict_new (); - if (!(*rsp)) { - gf_msg (this->name, GF_LOG_ERROR, 0, ENOMEM, "failed to" - " create dict"); - ret = -1; - goto out; - } - } - - ret = dict_set_uint64 (*rsp, GF_CS_OBJECT_STATUS, state); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, ENOMEM, "failed to set " - "dict"); + gf_msg(this->name, GF_LOG_ERROR, 0, ENOMEM, + "failed to" + " create dict"); + ret = -1; + goto out; + } + } + + ret = dict_set_uint64(*rsp, GF_CS_OBJECT_STATUS, state); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, ENOMEM, + "failed to set " + "dict"); + ret = -1; + goto out; + } + + if (fd) { + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_REMOTE, NULL, 0); + if (xattrsize != -1) { + value = GF_CALLOC(1, xattrsize + 1, gf_posix_mt_char); + if (!value) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, "no memory for value"); ret = -1; goto out; - } + } + /* TODO: Add check for ENODATA */ + xattrsize = sys_fgetxattr(*fd, GF_CS_OBJECT_REMOTE, value, + xattrsize + 1); + if (xattrsize == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + " getxattr failed for key %s", GF_CS_OBJECT_REMOTE); + goto out; + } else { + value[xattrsize] = '\0'; + } + } else { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + " getxattr failed for key %s", GF_CS_OBJECT_REMOTE); + goto out; + } + } else { + xattrsize = sys_lgetxattr(path, GF_CS_OBJECT_REMOTE, NULL, 0); + if (xattrsize != -1) { + value = GF_CALLOC(1, xattrsize + 1, gf_posix_mt_char); + if (!value) { + ret = -1; + goto out; + } - if (fd) { - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_REMOTE, NULL, 0); - if (xattrsize != -1) { - value = GF_CALLOC (1, xattrsize + 1, gf_posix_mt_char); - if (!value) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "no memory for value"); - ret = -1; - goto out; - } - /* TODO: Add check for ENODATA */ - xattrsize = sys_fgetxattr (*fd, GF_CS_OBJECT_REMOTE, - value, xattrsize + 1); - if (xattrsize == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - " getxattr failed for key %s", - GF_CS_OBJECT_REMOTE); - goto out; - } else { - value[xattrsize] = '\0'; - } - } else { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - " getxattr failed for key %s", - GF_CS_OBJECT_REMOTE); - goto out; - } + xattrsize = sys_lgetxattr(path, GF_CS_OBJECT_REMOTE, value, + xattrsize + 1); + if (xattrsize == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + " getxattr failed for key %s", GF_CS_OBJECT_REMOTE); + goto out; + } else { + value[xattrsize] = '\0'; + } } else { - xattrsize = sys_lgetxattr (path, GF_CS_OBJECT_REMOTE, NULL, 0); - if (xattrsize != -1) { - value = GF_CALLOC (1, xattrsize + 1, gf_posix_mt_char); - if (!value) { - ret = -1; - goto out; - } - - xattrsize = sys_lgetxattr (path, GF_CS_OBJECT_REMOTE, - value, xattrsize + 1); - if (xattrsize == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - " getxattr failed for key %s", - GF_CS_OBJECT_REMOTE); - goto out; - } else { - value[xattrsize] = '\0'; - } - } else { - gf_msg (this->name, GF_LOG_ERROR, 0, errno, - " getxattr failed for key %s", - GF_CS_OBJECT_REMOTE); - goto out; - } + gf_msg(this->name, GF_LOG_ERROR, 0, errno, + " getxattr failed for key %s", GF_CS_OBJECT_REMOTE); + goto out; } + } - if (ret == 0) { - ret = dict_set_str (*rsp, GF_CS_OBJECT_REMOTE, value); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "failed to set" - "value"); - } + if (ret == 0) { + ret = dict_set_str(*rsp, GF_CS_OBJECT_REMOTE, value); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "failed to set" + "value"); } + } out: - return ret; + return ret; } - /* This function checks the status of the file and updates the xattr response. * Also it repairs the state of the file which could have been resulted from a * crash or transient failures. */ int -posix_cs_maintenance (xlator_t *this, fd_t *fd, loc_t *loc, int *pfd, - struct iatt *buf, const char *realpath, dict_t *xattr_req, - dict_t **xattr_rsp, gf_boolean_t ignore_failure) +posix_cs_maintenance(xlator_t *this, fd_t *fd, loc_t *loc, int *pfd, + struct iatt *buf, const char *realpath, dict_t *xattr_req, + dict_t **xattr_rsp, gf_boolean_t ignore_failure) { - gf_cs_obj_state state = GF_CS_ERROR; - int ret = 0; - - if (!(dict_get (xattr_req, GF_CS_OBJECT_STATUS) || - dict_get (xattr_req, GF_CS_OBJECT_REPAIR))) - return 0; + gf_cs_obj_state state = GF_CS_ERROR; + int ret = 0; + if (!(dict_get(xattr_req, GF_CS_OBJECT_STATUS) || + dict_get(xattr_req, GF_CS_OBJECT_REPAIR))) + return 0; - if (fd) { - LOCK (&fd->inode->lock); - if (dict_get (xattr_req, GF_CS_OBJECT_STATUS)) { - state = posix_cs_check_status (this, NULL, pfd, buf); - gf_msg_debug (this->name, 0, "state : %d", state); - ret = posix_cs_set_state (this, xattr_rsp, - state, NULL, pfd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "posix_cs_set_state failed"); - } - - if (ignore_failure) { - ret = 0; - goto unlock; - } else { - if (state != GF_CS_LOCAL || ret != 0) { - ret = -1; - goto unlock; - } - } + if (fd) { + LOCK(&fd->inode->lock); + if (dict_get(xattr_req, GF_CS_OBJECT_STATUS)) { + state = posix_cs_check_status(this, NULL, pfd, buf); + gf_msg_debug(this->name, 0, "state : %d", state); + ret = posix_cs_set_state(this, xattr_rsp, state, NULL, pfd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "posix_cs_set_state failed"); + } + + if (ignore_failure) { + ret = 0; + goto unlock; + } else { + if (state != GF_CS_LOCAL || ret != 0) { + ret = -1; + goto unlock; } + } + } - if (dict_get (xattr_req, GF_CS_OBJECT_REPAIR)) { - state = posix_cs_check_status (this, NULL, pfd, - buf); - gf_msg_debug (this->name, 0, "state : %d", state); - - if (state == GF_CS_REPAIR) { - state = posix_cs_heal_state (this, NULL, - pfd, buf); - - if (state == GF_CS_ERROR) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "repair check failed"); - } - } - - ret = posix_cs_set_state (this, xattr_rsp, - state, NULL, pfd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "posix_cs_set_state failed"); - if (ignore_failure) - ret = 0; - else - ret = -1; - goto unlock; - } - } - } else { - if (!loc->inode) { - ret = 0; - goto out; + if (dict_get(xattr_req, GF_CS_OBJECT_REPAIR)) { + state = posix_cs_check_status(this, NULL, pfd, buf); + gf_msg_debug(this->name, 0, "state : %d", state); + + if (state == GF_CS_REPAIR) { + state = posix_cs_heal_state(this, NULL, pfd, buf); + + if (state == GF_CS_ERROR) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "repair check failed"); } + } - LOCK (&loc->inode->lock); - if (dict_get (xattr_req, GF_CS_OBJECT_STATUS)) { - state = posix_cs_check_status (this, realpath, NULL, - buf); - gf_msg_debug (this->name, 0, "state : %d", state); - ret = posix_cs_set_state (this, xattr_rsp, state, - realpath, NULL); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "posix_cs_set_state failed"); - } - - if (ignore_failure) { - ret = 0; - goto unlock; - } else { - if (state != GF_CS_LOCAL || ret != 0) { - ret = -1; - goto unlock; - } - } + ret = posix_cs_set_state(this, xattr_rsp, state, NULL, pfd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "posix_cs_set_state failed"); + if (ignore_failure) + ret = 0; + else + ret = -1; + goto unlock; + } + } + } else { + if (!loc->inode) { + ret = 0; + goto out; + } + + LOCK(&loc->inode->lock); + if (dict_get(xattr_req, GF_CS_OBJECT_STATUS)) { + state = posix_cs_check_status(this, realpath, NULL, buf); + gf_msg_debug(this->name, 0, "state : %d", state); + ret = posix_cs_set_state(this, xattr_rsp, state, realpath, NULL); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "posix_cs_set_state failed"); + } + + if (ignore_failure) { + ret = 0; + goto unlock; + } else { + if (state != GF_CS_LOCAL || ret != 0) { + ret = -1; + goto unlock; } + } + } + + if (dict_get(xattr_req, GF_CS_OBJECT_REPAIR)) { + state = posix_cs_check_status(this, realpath, NULL, buf); + gf_msg_debug(this->name, 0, "state : %d", state); - if (dict_get (xattr_req, GF_CS_OBJECT_REPAIR)) { - state = posix_cs_check_status (this, realpath, NULL, - buf); - gf_msg_debug (this->name, 0, "state : %d", state); - - if (state == GF_CS_REPAIR) { - state = posix_cs_heal_state (this, realpath, - NULL, buf); - - if (state == GF_CS_ERROR) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "repair check failed"); - } - } - - ret = posix_cs_set_state (this, xattr_rsp, - state, realpath, NULL); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "posix_cs_set_state failed"); - if (ignore_failure) - ret = 0; - else - ret = -1; - goto unlock; - } + if (state == GF_CS_REPAIR) { + state = posix_cs_heal_state(this, realpath, NULL, buf); + + if (state == GF_CS_ERROR) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "repair check failed"); } + } + + ret = posix_cs_set_state(this, xattr_rsp, state, realpath, NULL); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "posix_cs_set_state failed"); + if (ignore_failure) + ret = 0; + else + ret = -1; + goto unlock; + } } + } unlock: - if (fd) - UNLOCK (&fd->inode->lock); - else - UNLOCK (&loc->inode->lock); + if (fd) + UNLOCK(&fd->inode->lock); + else + UNLOCK(&loc->inode->lock); out: - return ret; + return ret; } diff --git a/xlators/storage/posix/src/posix-inode-fd-ops.c b/xlators/storage/posix/src/posix-inode-fd-ops.c index e467706db0c..2cb65d7fd0e 100644 --- a/xlators/storage/posix/src/posix-inode-fd-ops.c +++ b/xlators/storage/posix/src/posix-inode-fd-ops.c @@ -68,17 +68,21 @@ extern char *marker_xattrs[]; #undef HAVE_SET_FSID #ifdef HAVE_SET_FSID -#define DECLARE_OLD_FS_ID_VAR uid_t old_fsuid; gid_t old_fsgid; - -#define SET_FS_ID(uid, gid) do { \ - old_fsuid = setfsuid (uid); \ - old_fsgid = setfsgid (gid); \ - } while (0) - -#define SET_TO_OLD_FS_ID() do { \ - setfsuid (old_fsuid); \ - setfsgid (old_fsgid); \ - } while (0) +#define DECLARE_OLD_FS_ID_VAR \ + uid_t old_fsuid; \ + gid_t old_fsgid; + +#define SET_FS_ID(uid, gid) \ + do { \ + old_fsuid = setfsuid(uid); \ + old_fsgid = setfsgid(gid); \ + } while (0) + +#define SET_TO_OLD_FS_ID() \ + do { \ + setfsuid(old_fsuid); \ + setfsgid(old_fsgid); \ + } while (0) #else @@ -95,3756 +99,3789 @@ extern char *marker_xattrs[]; struct timeval otherwise. */ #if HAVE_UTIMENSAT -#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ - tv.tv_nsec = nanosecs +#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) tv.tv_nsec = nanosecs #else -#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ - tv.tv_usec = nanosecs / 1000 +#define SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, nanosecs) \ + tv.tv_usec = nanosecs / 1000 #endif -static char *disallow_removexattrs[] = { - GF_XATTR_VOL_ID_KEY, - GFID_XATTR_KEY, - NULL -}; +static char *disallow_removexattrs[] = {GF_XATTR_VOL_ID_KEY, GFID_XATTR_KEY, + NULL}; int32_t -posix_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +posix_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - struct iatt buf = {0,}; - int32_t op_ret = -1; - int32_t op_errno = 0; - struct posix_private *priv = NULL; - char *real_path = NULL; - dict_t *xattr_rsp = NULL; + struct iatt buf = { + 0, + }; + int32_t op_ret = -1; + int32_t op_errno = 0; + struct posix_private *priv = NULL; + char *real_path = NULL; + dict_t *xattr_rsp = NULL; - DECLARE_OLD_FS_ID_VAR; + DECLARE_OLD_FS_ID_VAR; - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); - priv = this->private; - VALIDATE_OR_GOTO (priv, out); + priv = this->private; + VALIDATE_OR_GOTO(priv, out); - SET_FS_ID (frame->root->uid, frame->root->gid); + SET_FS_ID(frame->root->uid, frame->root->gid); - MAKE_INODE_HANDLE (real_path, this, loc, &buf); + MAKE_INODE_HANDLE(real_path, this, loc, &buf); - if (op_ret == -1) { - op_errno = errno; - if (op_errno == ENOENT) { - gf_msg_debug(this->name, 0, "lstat on %s failed: %s", - real_path ? real_path : "<null>", - strerror (op_errno)); - } else { - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_LSTAT_FAILED, "lstat on %s failed", - real_path ? real_path : "<null>"); - } - goto out; + if (op_ret == -1) { + op_errno = errno; + if (op_errno == ENOENT) { + gf_msg_debug(this->name, 0, "lstat on %s failed: %s", + real_path ? real_path : "<null>", strerror(op_errno)); + } else { + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_path ? real_path : "<null>"); } - if (xdata) { - xattr_rsp = posix_xattr_fill (this, real_path, loc, NULL, -1, - xdata, &buf); + goto out; + } + if (xdata) { + xattr_rsp = posix_xattr_fill(this, real_path, loc, NULL, -1, xdata, + &buf); - posix_cs_maintenance (this, NULL, loc, NULL, &buf, real_path, - xdata, &xattr_rsp, _gf_true); - } + posix_cs_maintenance(this, NULL, loc, NULL, &buf, real_path, xdata, + &xattr_rsp, _gf_true); + } - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, &buf, xattr_rsp); - if (xattr_rsp) - dict_unref (xattr_rsp); + SET_TO_OLD_FS_ID(); + STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, &buf, xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); - return 0; + return 0; } static int -posix_do_chmod (xlator_t *this, const char *path, struct iatt *stbuf) +posix_do_chmod(xlator_t *this, const char *path, struct iatt *stbuf) { - int32_t ret = -1; - mode_t mode = 0; - mode_t mode_bit = 0; - struct posix_private *priv = NULL; - struct stat stat; - int is_symlink = 0; - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - ret = sys_lstat (path, &stat); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_LSTAT_FAILED, - "lstat failed: %s", path); - goto out; + int32_t ret = -1; + mode_t mode = 0; + mode_t mode_bit = 0; + struct posix_private *priv = NULL; + struct stat stat; + int is_symlink = 0; + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + ret = sys_lstat(path, &stat); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_LSTAT_FAILED, + "lstat failed: %s", path); + goto out; + } + + if (S_ISLNK(stat.st_mode)) + is_symlink = 1; + + if (S_ISDIR(stat.st_mode)) { + mode = st_mode_from_ia(stbuf->ia_prot, stbuf->ia_type); + mode_bit = (mode & priv->create_directory_mask) | + priv->force_directory_mode; + mode = posix_override_umask(mode, mode_bit); + } else { + mode = st_mode_from_ia(stbuf->ia_prot, stbuf->ia_type); + mode_bit = (mode & priv->create_mask) | priv->force_create_mode; + mode = posix_override_umask(mode, mode_bit); + } + ret = lchmod(path, mode); + if ((ret == -1) && (errno == ENOSYS)) { + /* in Linux symlinks are always in mode 0777 and no + such call as lchmod exists. + */ + gf_msg_debug(this->name, 0, "%s (%s)", path, strerror(errno)); + if (is_symlink) { + ret = 0; + goto out; } - if (S_ISLNK (stat.st_mode)) - is_symlink = 1; - - if (S_ISDIR (stat.st_mode)) { - mode = st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type); - mode_bit = (mode & priv->create_directory_mask) - | priv->force_directory_mode; - mode = posix_override_umask(mode, mode_bit); - } else { - mode = st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type); - mode_bit = (mode & priv->create_mask) - | priv->force_create_mode; - mode = posix_override_umask(mode, mode_bit); - } - ret = lchmod (path, mode); - if ((ret == -1) && (errno == ENOSYS)) { - /* in Linux symlinks are always in mode 0777 and no - such call as lchmod exists. - */ - gf_msg_debug (this->name, 0, "%s (%s)", path, strerror (errno)); - if (is_symlink) { - ret = 0; - goto out; - } - - ret = sys_chmod (path, mode); - } + ret = sys_chmod(path, mode); + } out: - return ret; + return ret; } static int -posix_do_chown (xlator_t *this, - const char *path, - struct iatt *stbuf, - int32_t valid) +posix_do_chown(xlator_t *this, const char *path, struct iatt *stbuf, + int32_t valid) { - int32_t ret = -1; - uid_t uid = -1; - gid_t gid = -1; + int32_t ret = -1; + uid_t uid = -1; + gid_t gid = -1; - if (valid & GF_SET_ATTR_UID) - uid = stbuf->ia_uid; + if (valid & GF_SET_ATTR_UID) + uid = stbuf->ia_uid; - if (valid & GF_SET_ATTR_GID) - gid = stbuf->ia_gid; + if (valid & GF_SET_ATTR_GID) + gid = stbuf->ia_gid; - ret = sys_lchown (path, uid, gid); + ret = sys_lchown(path, uid, gid); - return ret; + return ret; } static int -posix_do_utimes (xlator_t *this, - const char *path, - struct iatt *stbuf, - int valid) +posix_do_utimes(xlator_t *this, const char *path, struct iatt *stbuf, int valid) { - int32_t ret = -1; + int32_t ret = -1; #if defined(HAVE_UTIMENSAT) - struct timespec tv[2] = { {0,}, {0,} }; + struct timespec tv[2] = {{ + 0, + }, + { + 0, + }}; #else - struct timeval tv[2] = { {0,}, {0,} }; + struct timeval tv[2] = {{ + 0, + }, + { + 0, + }}; #endif - struct stat stat; - int is_symlink = 0; - - ret = sys_lstat (path, &stat); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_FILE_OP_FAILED, "%s", path); - goto out; - } + struct stat stat; + int is_symlink = 0; - if (S_ISLNK (stat.st_mode)) - is_symlink = 1; - - if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { - tv[0].tv_sec = stbuf->ia_atime; - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[0], stbuf->ia_atime_nsec); - } else { - /* atime is not given, use current values */ - tv[0].tv_sec = ST_ATIM_SEC (&stat); - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[0], ST_ATIM_NSEC (&stat)); - } - - if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { - tv[1].tv_sec = stbuf->ia_mtime; - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[1], stbuf->ia_mtime_nsec); - } else { - /* mtime is not given, use current values */ - tv[1].tv_sec = ST_MTIM_SEC (&stat); - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[1], ST_MTIM_NSEC (&stat)); + ret = sys_lstat(path, &stat); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_FILE_OP_FAILED, "%s", + path); + goto out; + } + + if (S_ISLNK(stat.st_mode)) + is_symlink = 1; + + if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { + tv[0].tv_sec = stbuf->ia_atime; + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[0], stbuf->ia_atime_nsec); + } else { + /* atime is not given, use current values */ + tv[0].tv_sec = ST_ATIM_SEC(&stat); + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[0], ST_ATIM_NSEC(&stat)); + } + + if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { + tv[1].tv_sec = stbuf->ia_mtime; + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[1], stbuf->ia_mtime_nsec); + } else { + /* mtime is not given, use current values */ + tv[1].tv_sec = ST_MTIM_SEC(&stat); + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv[1], ST_MTIM_NSEC(&stat)); + } + + ret = PATH_SET_TIMESPEC_OR_TIMEVAL(path, tv); + if ((ret == -1) && (errno == ENOSYS)) { + gf_msg_debug(this->name, 0, "%s (%s)", path, strerror(errno)); + if (is_symlink) { + ret = 0; + goto out; } ret = PATH_SET_TIMESPEC_OR_TIMEVAL(path, tv); - if ((ret == -1) && (errno == ENOSYS)) { - gf_msg_debug (this->name, 0, "%s (%s)", - path, strerror (errno)); - if (is_symlink) { - ret = 0; - goto out; - } - - ret = PATH_SET_TIMESPEC_OR_TIMEVAL(path, tv); - } + } out: - return ret; + return ret; } int -posix_setattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, struct iatt *stbuf, int32_t valid, dict_t *xdata) +posix_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char * real_path = 0; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; - dict_t *xattr_rsp = NULL; - struct posix_private *priv = NULL; - - priv = this->private; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_INODE_HANDLE (real_path, this, loc, &statpre); + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = 0; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; + dict_t *xattr_rsp = NULL; + struct posix_private *priv = NULL; + + priv = this->private; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_INODE_HANDLE(real_path, this, loc, &statpre); + + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "setattr (lstat) on %s failed", + real_path ? real_path : "<null>"); + goto out; + } + if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { + op_ret = posix_do_chown(this, real_path, stbuf, valid); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "setattr (lstat) on %s failed", - real_path ? real_path : "<null>"); - goto out; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CHOWN_FAILED, + "setattr (chown) on %s " + "failed", + real_path); + goto out; } + } - if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)){ - op_ret = posix_do_chown (this, real_path, stbuf, valid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_CHOWN_FAILED, "setattr (chown) on %s " - "failed", real_path); - goto out; - } - } - - if (valid & GF_SET_ATTR_MODE) { - op_ret = posix_do_chmod (this, real_path, stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_CHMOD_FAILED, "setattr (chmod) on %s " - "failed", real_path); - goto out; - } + if (valid & GF_SET_ATTR_MODE) { + op_ret = posix_do_chmod(this, real_path, stbuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_CHMOD_FAILED, + "setattr (chmod) on %s " + "failed", + real_path); + goto out; } + } - if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { - op_ret = posix_do_utimes (this, real_path, stbuf, valid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_UTIMES_FAILED, "setattr (utimes) on %s " - "failed", real_path); - goto out; - } - posix_update_utime_in_mdata (this, real_path, -1, loc->inode, - stbuf, valid); - } - - if (valid & GF_SET_ATTR_CTIME && !priv->ctime) { - /* - * If ctime is not enabled, we have no means to associate an - * arbitrary ctime with the file, so as a fallback, we ignore - * the ctime payload and update the file ctime to current time - * (which is possible directly with the POSIX API). - */ - op_ret = PATH_SET_TIMESPEC_OR_TIMEVAL (real_path, NULL); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_UTIMES_FAILED, "setattr (utimes) on %s " - "failed", real_path); - goto out; - } + if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { + op_ret = posix_do_utimes(this, real_path, stbuf, valid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_UTIMES_FAILED, + "setattr (utimes) on %s " + "failed", + real_path); + goto out; + } + posix_update_utime_in_mdata(this, real_path, -1, loc->inode, stbuf, + valid); + } + + if (valid & GF_SET_ATTR_CTIME && !priv->ctime) { + /* + * If ctime is not enabled, we have no means to associate an + * arbitrary ctime with the file, so as a fallback, we ignore + * the ctime payload and update the file ctime to current time + * (which is possible directly with the POSIX API). + */ + op_ret = PATH_SET_TIMESPEC_OR_TIMEVAL(real_path, NULL); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_UTIMES_FAILED, + "setattr (utimes) on %s " + "failed", + real_path); + goto out; } + } - if (!valid) { - op_ret = sys_lchown (real_path, -1, -1); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_LCHOWN_FAILED, "lchown (%s, -1, -1) " - "failed", real_path); + if (!valid) { + op_ret = sys_lchown(real_path, -1, -1); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LCHOWN_FAILED, + "lchown (%s, -1, -1) " + "failed", + real_path); - goto out; - } + goto out; } + } - op_ret = posix_pstat (this, loc->inode, loc->gfid, real_path, - &statpost, _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "setattr (lstat) on %s failed", real_path); - goto out; - } + op_ret = posix_pstat(this, loc->inode, loc->gfid, real_path, &statpost, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "setattr (lstat) on %s failed", real_path); + goto out; + } - if (valid & GF_SET_ATTR_CTIME && priv->ctime) { - /* - * If we got ctime payload, we override - * the ctime of statpost with that. - */ - statpost.ia_ctime = stbuf->ia_ctime; - statpost.ia_ctime_nsec = stbuf->ia_ctime_nsec; - } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &statpost); + if (valid & GF_SET_ATTR_CTIME && priv->ctime) { + /* + * If we got ctime payload, we override + * the ctime of statpost with that. + */ + statpost.ia_ctime = stbuf->ia_ctime; + statpost.ia_ctime_nsec = stbuf->ia_ctime_nsec; + } + posix_set_ctime(frame, this, real_path, -1, loc->inode, &statpost); - if (xdata) - xattr_rsp = posix_xattr_fill (this, real_path, loc, NULL, -1, - xdata, &statpost); - op_ret = 0; + if (xdata) + xattr_rsp = posix_xattr_fill(this, real_path, loc, NULL, -1, xdata, + &statpost); + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, - &statpre, &statpost, xattr_rsp); - if (xattr_rsp) - dict_unref (xattr_rsp); + STACK_UNWIND_STRICT(setattr, frame, op_ret, op_errno, &statpre, &statpost, + xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); - return 0; + return 0; } int32_t -posix_do_fchown (xlator_t *this, - int fd, - struct iatt *stbuf, - int32_t valid) +posix_do_fchown(xlator_t *this, int fd, struct iatt *stbuf, int32_t valid) { - int ret = -1; - uid_t uid = -1; - gid_t gid = -1; + int ret = -1; + uid_t uid = -1; + gid_t gid = -1; - if (valid & GF_SET_ATTR_UID) - uid = stbuf->ia_uid; + if (valid & GF_SET_ATTR_UID) + uid = stbuf->ia_uid; - if (valid & GF_SET_ATTR_GID) - gid = stbuf->ia_gid; + if (valid & GF_SET_ATTR_GID) + gid = stbuf->ia_gid; - ret = sys_fchown (fd, uid, gid); + ret = sys_fchown(fd, uid, gid); - return ret; + return ret; } - int32_t -posix_do_fchmod (xlator_t *this, - int fd, struct iatt *stbuf) +posix_do_fchmod(xlator_t *this, int fd, struct iatt *stbuf) { - int32_t ret = -1; - mode_t mode = 0; - mode_t mode_bit = 0; - struct posix_private *priv = NULL; - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - mode = st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type); - mode_bit = (mode & priv->create_mask) - | priv->force_create_mode; - mode = posix_override_umask (mode, mode_bit); - ret = sys_fchmod (fd, mode); + int32_t ret = -1; + mode_t mode = 0; + mode_t mode_bit = 0; + struct posix_private *priv = NULL; + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + mode = st_mode_from_ia(stbuf->ia_prot, stbuf->ia_type); + mode_bit = (mode & priv->create_mask) | priv->force_create_mode; + mode = posix_override_umask(mode, mode_bit); + ret = sys_fchmod(fd, mode); out: - return ret; + return ret; } static int -posix_do_futimes (xlator_t *this, int fd, struct iatt *stbuf, int valid) +posix_do_futimes(xlator_t *this, int fd, struct iatt *stbuf, int valid) { - int32_t ret = -1; - struct timeval tv[2] = { {0,}, {0,} }; - struct stat stat = {0,}; - - ret = sys_fstat (fd, &stat); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_FILE_OP_FAILED, "%d", fd); - goto out; - } - - if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { - tv[0].tv_sec = stbuf->ia_atime; - tv[0].tv_usec = stbuf->ia_atime_nsec / 1000; - } else { - /* atime is not given, use current values */ - tv[0].tv_sec = ST_ATIM_SEC (&stat); - tv[0].tv_usec = ST_ATIM_NSEC (&stat) / 1000; - } - - if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { - tv[1].tv_sec = stbuf->ia_mtime; - tv[1].tv_usec = stbuf->ia_mtime_nsec / 1000; - } else { - /* mtime is not given, use current values */ - tv[1].tv_sec = ST_MTIM_SEC (&stat); - tv[1].tv_usec = ST_MTIM_NSEC (&stat) / 1000; - } - - ret = sys_futimes (fd, tv); - if (ret == -1) - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FUTIMES_FAILED, - "%d", fd); + int32_t ret = -1; + struct timeval tv[2] = {{ + 0, + }, + { + 0, + }}; + struct stat stat = { + 0, + }; + + ret = sys_fstat(fd, &stat); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_FILE_OP_FAILED, "%d", + fd); + goto out; + } + + if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { + tv[0].tv_sec = stbuf->ia_atime; + tv[0].tv_usec = stbuf->ia_atime_nsec / 1000; + } else { + /* atime is not given, use current values */ + tv[0].tv_sec = ST_ATIM_SEC(&stat); + tv[0].tv_usec = ST_ATIM_NSEC(&stat) / 1000; + } + + if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { + tv[1].tv_sec = stbuf->ia_mtime; + tv[1].tv_usec = stbuf->ia_mtime_nsec / 1000; + } else { + /* mtime is not given, use current values */ + tv[1].tv_sec = ST_MTIM_SEC(&stat); + tv[1].tv_usec = ST_MTIM_NSEC(&stat) / 1000; + } + + ret = sys_futimes(fd, tv); + if (ret == -1) + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FUTIMES_FAILED, "%d", fd); out: - return ret; + return ret; } int -posix_fsetattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, struct iatt *stbuf, int32_t valid, dict_t *xdata) +posix_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; - struct posix_fd *pfd = NULL; - dict_t *xattr_rsp = NULL; - int32_t ret = -1; - - DECLARE_OLD_FS_ID_VAR; - - SET_FS_ID (frame->root->uid, frame->root->gid); - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + int32_t op_ret = -1; + int32_t op_errno = 0; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; + struct posix_fd *pfd = NULL; + dict_t *xattr_rsp = NULL; + int32_t ret = -1; + + DECLARE_OLD_FS_ID_VAR; + + SET_FS_ID(frame->root->uid, frame->root->gid); + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg_debug(this->name, 0, "pfd is NULL from fd=%p", fd); + goto out; + } - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg_debug (this->name, 0, "pfd is NULL from fd=%p", fd); - goto out; - } + op_ret = posix_fdstat(this, fd->inode, pfd->fd, &statpre); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fsetattr (fstat) failed on fd=%p", fd); + goto out; + } - op_ret = posix_fdstat (this, fd->inode, pfd->fd, &statpre); + if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { + op_ret = posix_do_fchown(this, pfd->fd, stbuf, valid); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fsetattr (fstat) failed on fd=%p", fd); - goto out; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FCHOWN_FAILED, + "fsetattr (fchown) failed" + " on fd=%p", + fd); + goto out; } + } - if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { - op_ret = posix_do_fchown (this, pfd->fd, stbuf, valid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FCHOWN_FAILED, "fsetattr (fchown) failed" - " on fd=%p", fd); - goto out; - } - + if (valid & GF_SET_ATTR_MODE) { + op_ret = posix_do_fchmod(this, pfd->fd, stbuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FCHMOD_FAILED, + "fsetattr (fchmod) failed" + " on fd=%p", + fd); + goto out; } + } - if (valid & GF_SET_ATTR_MODE) { - op_ret = posix_do_fchmod (this, pfd->fd, stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FCHMOD_FAILED, "fsetattr (fchmod) failed" - " on fd=%p", fd); - goto out; - } - } + if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { + op_ret = posix_do_futimes(this, pfd->fd, stbuf, valid); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FUTIMES_FAILED, + "fsetattr (futimes) on " + "failed fd=%p", + fd); + goto out; + } + posix_update_utime_in_mdata(this, NULL, pfd->fd, fd->inode, stbuf, + valid); + } + + if (!valid) { + op_ret = sys_fchown(pfd->fd, -1, -1); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FCHOWN_FAILED, + "fchown (%d, -1, -1) failed", pfd->fd); - if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { - op_ret = posix_do_futimes (this, pfd->fd, stbuf, valid); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FUTIMES_FAILED, "fsetattr (futimes) on " - "failed fd=%p", fd); - goto out; - } - posix_update_utime_in_mdata (this, NULL, pfd->fd, fd->inode, - stbuf, valid); + goto out; } + } - if (!valid) { - op_ret = sys_fchown (pfd->fd, -1, -1); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FCHOWN_FAILED, - "fchown (%d, -1, -1) failed", - pfd->fd); - - goto out; - } - } - - op_ret = posix_fdstat (this, fd->inode, pfd->fd, &statpost); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fsetattr (fstat) failed on fd=%p", fd); - goto out; - } + op_ret = posix_fdstat(this, fd->inode, pfd->fd, &statpost); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fsetattr (fstat) failed on fd=%p", fd); + goto out; + } - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, &statpost); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, &statpost); - if (xdata) - xattr_rsp = posix_xattr_fill (this, NULL, NULL, fd, pfd->fd, - xdata, &statpost); - op_ret = 0; + if (xdata) + xattr_rsp = posix_xattr_fill(this, NULL, NULL, fd, pfd->fd, xdata, + &statpost); + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, - &statpre, &statpost, xattr_rsp); - if (xattr_rsp) - dict_unref (xattr_rsp); + STACK_UNWIND_STRICT(fsetattr, frame, op_ret, op_errno, &statpre, &statpost, + xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); - return 0; + return 0; } static int32_t -posix_do_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags, off_t offset, size_t len, - struct iatt *statpre, struct iatt *statpost, dict_t *xdata, - dict_t **rsp_xdata) +posix_do_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + off_t offset, size_t len, struct iatt *statpre, + struct iatt *statpost, dict_t *xdata, dict_t **rsp_xdata) { - int32_t ret = -1; - int32_t op_errno = 0; - struct posix_fd *pfd = NULL; - gf_boolean_t locked = _gf_false; - posix_inode_ctx_t *ctx = NULL; - struct posix_private *priv = NULL; + int32_t ret = -1; + int32_t op_errno = 0; + struct posix_fd *pfd = NULL; + gf_boolean_t locked = _gf_false; + posix_inode_ctx_t *ctx = NULL; + struct posix_private *priv = NULL; - DECLARE_OLD_FS_ID_VAR; + DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); + SET_FS_ID(frame->root->uid, frame->root->gid); - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); - priv = this->private; + priv = this->private; - /* fallocate case is special so call posix_disk_space_check separately - for every fallocate fop instead of calling posix_disk_space with - thread after every 5 sec sleep to working correctly storage.reserve - option behaviour - */ - if (priv->disk_reserve) - posix_disk_space_check (this); + /* fallocate case is special so call posix_disk_space_check separately + for every fallocate fop instead of calling posix_disk_space with + thread after every 5 sec sleep to working correctly storage.reserve + option behaviour + */ + if (priv->disk_reserve) + posix_disk_space_check(this); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, ret, ret, out); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg_debug (this->name, 0, "pfd is NULL from fd=%p", fd); - goto out; - } - - ret = posix_inode_ctx_get_all (fd->inode, this, &ctx); - if (ret < 0) { - ret = -ENOMEM; - goto out; - } - - if (xdata && dict_get (xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) { - locked = _gf_true; - pthread_mutex_lock (&ctx->write_atomic_lock); - } + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, ret, ret, out); - ret = posix_fdstat (this, fd->inode, pfd->fd, statpre); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fallocate (fstat) failed on fd=%p", fd); - goto out; - } + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg_debug(this->name, 0, "pfd is NULL from fd=%p", fd); + goto out; + } - if (xdata) { - ret = posix_cs_maintenance (this, fd, NULL, &pfd->fd, statpre, - NULL, xdata, rsp_xdata, _gf_false); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - ret = -EIO; - goto out; - } - } + ret = posix_inode_ctx_get_all(fd->inode, this, &ctx); + if (ret < 0) { + ret = -ENOMEM; + goto out; + } + + if (xdata && dict_get(xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) { + locked = _gf_true; + pthread_mutex_lock(&ctx->write_atomic_lock); + } + + ret = posix_fdstat(this, fd->inode, pfd->fd, statpre); + if (ret == -1) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fallocate (fstat) failed on fd=%p", fd); + goto out; + } - ret = sys_fallocate (pfd->fd, flags, offset, len); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, -ret, P_MSG_FALLOCATE_FAILED, - "fallocate failed on %s offset: %jd, " - "len:%zu, flags: %d", uuid_utoa (fd->inode->gfid), - offset, len, flags); - goto out; - } + if (xdata) { + ret = posix_cs_maintenance(this, fd, NULL, &pfd->fd, statpre, NULL, + xdata, rsp_xdata, _gf_false); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + ret = -EIO; + goto out; + } + } + + ret = sys_fallocate(pfd->fd, flags, offset, len); + if (ret == -1) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, -ret, P_MSG_FALLOCATE_FAILED, + "fallocate failed on %s offset: %jd, " + "len:%zu, flags: %d", + uuid_utoa(fd->inode->gfid), offset, len, flags); + goto out; + } - ret = posix_fdstat (this, fd->inode, pfd->fd, statpost); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fallocate (fstat) failed on fd=%p", fd); - goto out; - } + ret = posix_fdstat(this, fd->inode, pfd->fd, statpost); + if (ret == -1) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fallocate (fstat) failed on fd=%p", fd); + goto out; + } - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, statpost); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, statpost); out: - if (locked) { - pthread_mutex_unlock (&ctx->write_atomic_lock); - locked = _gf_false; - } - SET_TO_OLD_FS_ID (); - if (ret == ENOSPC) - ret = -ENOSPC; - - return ret; + if (locked) { + pthread_mutex_unlock(&ctx->write_atomic_lock); + locked = _gf_false; + } + SET_TO_OLD_FS_ID(); + if (ret == ENOSPC) + ret = -ENOSPC; + + return ret; } -char* -_page_aligned_alloc (size_t size, char **aligned_buf) +char * +_page_aligned_alloc(size_t size, char **aligned_buf) { - char *alloc_buf = NULL; - char *buf = NULL; + char *alloc_buf = NULL; + char *buf = NULL; - alloc_buf = GF_CALLOC (1, (size + ALIGN_SIZE), gf_posix_mt_char); - if (!alloc_buf) - goto out; - /* page aligned buffer */ - buf = GF_ALIGN_BUF (alloc_buf, ALIGN_SIZE); - *aligned_buf = buf; + alloc_buf = GF_CALLOC(1, (size + ALIGN_SIZE), gf_posix_mt_char); + if (!alloc_buf) + goto out; + /* page aligned buffer */ + buf = GF_ALIGN_BUF(alloc_buf, ALIGN_SIZE); + *aligned_buf = buf; out: - return alloc_buf; + return alloc_buf; } static int32_t _posix_do_zerofill(int fd, off_t offset, off_t len, int o_direct) { - off_t num_vect = 0; - off_t num_loop = 1; - off_t idx = 0; - int32_t op_ret = -1; - int32_t vect_size = VECTOR_SIZE; - off_t remain = 0; - off_t extra = 0; - struct iovec *vector = NULL; - char *iov_base = NULL; - char *alloc_buf = NULL; - - if (len == 0) - return 0; - if (len < VECTOR_SIZE) - vect_size = len; - - num_vect = len / (vect_size); - remain = len % vect_size ; - if (num_vect > MAX_NO_VECT) { - extra = num_vect % MAX_NO_VECT; - num_loop = num_vect / MAX_NO_VECT; - num_vect = MAX_NO_VECT; - } - - vector = GF_CALLOC (num_vect, sizeof(struct iovec), - gf_common_mt_iovec); - if (!vector) - return -1; - if (o_direct) { - alloc_buf = _page_aligned_alloc(vect_size, &iov_base); - if (!alloc_buf) { - GF_FREE(vector); - return -1; - } - } else { - iov_base = GF_CALLOC (vect_size, sizeof(char), - gf_common_mt_char); - if (!iov_base) { - GF_FREE(vector); - return -1; - } - } - - for (idx = 0; idx < num_vect; idx++) { - vector[idx].iov_base = iov_base; - vector[idx].iov_len = vect_size; - } - if (sys_lseek (fd, offset, SEEK_SET) < 0) { - op_ret = -1; - goto err; - } + off_t num_vect = 0; + off_t num_loop = 1; + off_t idx = 0; + int32_t op_ret = -1; + int32_t vect_size = VECTOR_SIZE; + off_t remain = 0; + off_t extra = 0; + struct iovec *vector = NULL; + char *iov_base = NULL; + char *alloc_buf = NULL; + + if (len == 0) + return 0; + if (len < VECTOR_SIZE) + vect_size = len; + + num_vect = len / (vect_size); + remain = len % vect_size; + if (num_vect > MAX_NO_VECT) { + extra = num_vect % MAX_NO_VECT; + num_loop = num_vect / MAX_NO_VECT; + num_vect = MAX_NO_VECT; + } + + vector = GF_CALLOC(num_vect, sizeof(struct iovec), gf_common_mt_iovec); + if (!vector) + return -1; + if (o_direct) { + alloc_buf = _page_aligned_alloc(vect_size, &iov_base); + if (!alloc_buf) { + GF_FREE(vector); + return -1; + } + } else { + iov_base = GF_CALLOC(vect_size, sizeof(char), gf_common_mt_char); + if (!iov_base) { + GF_FREE(vector); + return -1; + } + } + + for (idx = 0; idx < num_vect; idx++) { + vector[idx].iov_base = iov_base; + vector[idx].iov_len = vect_size; + } + if (sys_lseek(fd, offset, SEEK_SET) < 0) { + op_ret = -1; + goto err; + } - for (idx = 0; idx < num_loop; idx++) { - op_ret = sys_writev (fd, vector, num_vect); - if (op_ret < 0) - goto err; - if (op_ret != (vect_size * num_vect)) { - op_ret = -1; - errno = ENOSPC; - goto err; - } - } - if (extra) { - op_ret = sys_writev (fd, vector, extra); - if (op_ret < 0) - goto err; - if (op_ret != (vect_size * extra)) { - op_ret = -1; - errno = ENOSPC; - goto err; - } - } - if (remain) { - vector[0].iov_len = remain; - op_ret = sys_writev (fd, vector , 1); - if (op_ret < 0) - goto err; - if (op_ret != remain) { - op_ret = -1; - errno = ENOSPC; - goto err; - } + for (idx = 0; idx < num_loop; idx++) { + op_ret = sys_writev(fd, vector, num_vect); + if (op_ret < 0) + goto err; + if (op_ret != (vect_size * num_vect)) { + op_ret = -1; + errno = ENOSPC; + goto err; + } + } + if (extra) { + op_ret = sys_writev(fd, vector, extra); + if (op_ret < 0) + goto err; + if (op_ret != (vect_size * extra)) { + op_ret = -1; + errno = ENOSPC; + goto err; + } + } + if (remain) { + vector[0].iov_len = remain; + op_ret = sys_writev(fd, vector, 1); + if (op_ret < 0) + goto err; + if (op_ret != remain) { + op_ret = -1; + errno = ENOSPC; + goto err; } + } err: - if (o_direct) - GF_FREE(alloc_buf); - else - GF_FREE(iov_base); - GF_FREE(vector); - return op_ret; + if (o_direct) + GF_FREE(alloc_buf); + else + GF_FREE(iov_base); + GF_FREE(vector); + return op_ret; } static int32_t -posix_do_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, struct iatt *statpre, struct iatt *statpost, - dict_t *xdata, dict_t **rsp_xdata) +posix_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + off_t len, struct iatt *statpre, struct iatt *statpost, + dict_t *xdata, dict_t **rsp_xdata) { - int32_t ret = -1; - int32_t op_errno = 0; - int32_t flags = 0; - struct posix_fd *pfd = NULL; - gf_boolean_t locked = _gf_false; - posix_inode_ctx_t *ctx = NULL; - - DECLARE_OLD_FS_ID_VAR; - - SET_FS_ID (frame->root->uid, frame->root->gid); + int32_t ret = -1; + int32_t op_errno = 0; + int32_t flags = 0; + struct posix_fd *pfd = NULL; + gf_boolean_t locked = _gf_false; + posix_inode_ctx_t *ctx = NULL; - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + DECLARE_OLD_FS_ID_VAR; - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg_debug (this->name, 0, "pfd is NULL from fd=%p", fd); - goto out; - } + SET_FS_ID(frame->root->uid, frame->root->gid); - ret = posix_inode_ctx_get_all (fd->inode, this, &ctx); - if (ret < 0) { - ret = -ENOMEM; - goto out; - } - - if (dict_get (xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) { - locked = _gf_true; - pthread_mutex_lock (&ctx->write_atomic_lock); - } - - ret = posix_fdstat (this, fd->inode, pfd->fd, statpre); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd = %p", fd); - goto out; - } + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); - if (xdata) { - ret = posix_cs_maintenance (this, fd, NULL, &pfd->fd, statpre, - NULL, xdata, rsp_xdata, _gf_false); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "file state " - "check failed, fd %p", fd); - ret = -EIO; - goto out; - } - } + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg_debug(this->name, 0, "pfd is NULL from fd=%p", fd); + goto out; + } - /* See if we can use FALLOC_FL_ZERO_RANGE to perform the zero fill. - * If it fails, fall back to _posix_do_zerofill() and an optional fsync. - */ - flags = FALLOC_FL_ZERO_RANGE; - ret = sys_fallocate (pfd->fd, flags, offset, len); - if (ret == 0) { - goto fsync; - } else { - ret = -errno; - if ((ret != -ENOSYS) && (ret != -EOPNOTSUPP)) { - goto out; - } - } + ret = posix_inode_ctx_get_all(fd->inode, this, &ctx); + if (ret < 0) { + ret = -ENOMEM; + goto out; + } + + if (dict_get(xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) { + locked = _gf_true; + pthread_mutex_lock(&ctx->write_atomic_lock); + } + + ret = posix_fdstat(this, fd->inode, pfd->fd, statpre); + if (ret == -1) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd = %p", fd); + goto out; + } - ret = _posix_do_zerofill (pfd->fd, offset, len, pfd->flags & O_DIRECT); + if (xdata) { + ret = posix_cs_maintenance(this, fd, NULL, &pfd->fd, statpre, NULL, + xdata, rsp_xdata, _gf_false); if (ret < 0) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_ZEROFILL_FAILED, - "zerofill failed on fd %d length %" PRId64 , - pfd->fd, len); - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state " + "check failed, fd %p", + fd); + ret = -EIO; + goto out; } + } -fsync: - if (pfd->flags & (O_SYNC|O_DSYNC)) { - ret = sys_fsync (pfd->fd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_WRITEV_FAILED, "fsync() in writev on fd" - "%d failed", pfd->fd); - ret = -errno; - goto out; - } - } + /* See if we can use FALLOC_FL_ZERO_RANGE to perform the zero fill. + * If it fails, fall back to _posix_do_zerofill() and an optional fsync. + */ + flags = FALLOC_FL_ZERO_RANGE; + ret = sys_fallocate(pfd->fd, flags, offset, len); + if (ret == 0) { + goto fsync; + } else { + ret = -errno; + if ((ret != -ENOSYS) && (ret != -EOPNOTSUPP)) { + goto out; + } + } + + ret = _posix_do_zerofill(pfd->fd, offset, len, pfd->flags & O_DIRECT); + if (ret < 0) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_ZEROFILL_FAILED, + "zerofill failed on fd %d length %" PRId64, pfd->fd, len); + goto out; + } - ret = posix_fdstat (this, fd->inode, pfd->fd, statpost); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "post operation fstat failed on fd=%p", fd); - goto out; - } +fsync: + if (pfd->flags & (O_SYNC | O_DSYNC)) { + ret = sys_fsync(pfd->fd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_WRITEV_FAILED, + "fsync() in writev on fd" + "%d failed", + pfd->fd); + ret = -errno; + goto out; + } + } + + ret = posix_fdstat(this, fd->inode, pfd->fd, statpost); + if (ret == -1) { + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "post operation fstat failed on fd=%p", fd); + goto out; + } - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, statpost); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, statpost); out: - if (locked) { - pthread_mutex_unlock (&ctx->write_atomic_lock); - locked = _gf_false; - } - SET_TO_OLD_FS_ID (); + if (locked) { + pthread_mutex_unlock(&ctx->write_atomic_lock); + locked = _gf_false; + } + SET_TO_OLD_FS_ID(); - return ret; + return ret; } int32_t -posix_glfallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size, - off_t offset, size_t len, dict_t *xdata) +posix_glfallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, + int32_t keep_size, off_t offset, size_t len, dict_t *xdata) { - int32_t ret; - int32_t flags = 0; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; + int32_t ret; + int32_t flags = 0; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; #ifdef FALLOC_FL_KEEP_SIZE - if (keep_size) - flags = FALLOC_FL_KEEP_SIZE; + if (keep_size) + flags = FALLOC_FL_KEEP_SIZE; #endif /* FALLOC_FL_KEEP_SIZE */ - ret = posix_do_fallocate (frame, this, fd, flags, offset, len, - &statpre, &statpost, xdata, NULL); - if (ret < 0) - goto err; + ret = posix_do_fallocate(frame, this, fd, flags, offset, len, &statpre, + &statpost, xdata, NULL); + if (ret < 0) + goto err; - STACK_UNWIND_STRICT(fallocate, frame, 0, 0, &statpre, &statpost, NULL); - return 0; + STACK_UNWIND_STRICT(fallocate, frame, 0, 0, &statpre, &statpost, NULL); + return 0; err: - STACK_UNWIND_STRICT(fallocate, frame, -1, -ret, NULL, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(fallocate, frame, -1, -ret, NULL, NULL, NULL); + return 0; } int32_t posix_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, size_t len, dict_t *xdata) { - int32_t ret; - dict_t *rsp_xdata = NULL; + int32_t ret; + dict_t *rsp_xdata = NULL; #ifndef FALLOC_FL_KEEP_SIZE - ret = EOPNOTSUPP; + ret = EOPNOTSUPP; -#else /* FALLOC_FL_KEEP_SIZE */ - int32_t flags = FALLOC_FL_KEEP_SIZE|FALLOC_FL_PUNCH_HOLE; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; +#else /* FALLOC_FL_KEEP_SIZE */ + int32_t flags = FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; - ret = posix_do_fallocate (frame, this, fd, flags, offset, len, - &statpre, &statpost, xdata, &rsp_xdata); - if (ret < 0) - goto err; + ret = posix_do_fallocate(frame, this, fd, flags, offset, len, &statpre, + &statpost, xdata, &rsp_xdata); + if (ret < 0) + goto err; - STACK_UNWIND_STRICT(discard, frame, 0, 0, &statpre, &statpost, - rsp_xdata); - return 0; + STACK_UNWIND_STRICT(discard, frame, 0, 0, &statpre, &statpost, rsp_xdata); + return 0; err: #endif /* FALLOC_FL_KEEP_SIZE */ - STACK_UNWIND_STRICT(discard, frame, -1, -ret, NULL, NULL, rsp_xdata); - return 0; + STACK_UNWIND_STRICT(discard, frame, -1, -ret, NULL, NULL, rsp_xdata); + return 0; } int32_t posix_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, dict_t *xdata) + off_t len, dict_t *xdata) { - int32_t ret = 0; - struct iatt statpre = {0,}; - struct iatt statpost = {0,}; - struct posix_private *priv = NULL; - int op_ret = -1; - int op_errno = -EINVAL; - dict_t *rsp_xdata = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - - priv = this->private; - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - ret = posix_do_zerofill (frame, this, fd, offset, len, - &statpre, &statpost, xdata, &rsp_xdata); - if (ret < 0) { - op_ret = -1; - op_errno = -ret; - goto out; - } + int32_t ret = 0; + struct iatt statpre = { + 0, + }; + struct iatt statpost = { + 0, + }; + struct posix_private *priv = NULL; + int op_ret = -1; + int op_errno = -EINVAL; + dict_t *rsp_xdata = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + + priv = this->private; + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + ret = posix_do_zerofill(frame, this, fd, offset, len, &statpre, &statpost, + xdata, &rsp_xdata); + if (ret < 0) { + op_ret = -1; + op_errno = -ret; + goto out; + } - STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, - rsp_xdata); - return 0; + STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, rsp_xdata); + return 0; out: - STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, NULL, NULL, - rsp_xdata); - return 0; + STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, NULL, NULL, + rsp_xdata); + return 0; } int32_t -posix_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) +posix_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) { - /* - * IPC is for inter-translator communication. If one gets here, it - * means somebody sent one that nobody else recognized, which is an - * error much like an uncaught exception. - */ - gf_msg (this->name, GF_LOG_ERROR, 0, P_MSG_IPC_NOT_HANDLE, - "GF_LOG_IPC(%d) not handled", op); - STACK_UNWIND_STRICT (ipc, frame, -1, -EOPNOTSUPP, NULL); - return 0; - + /* + * IPC is for inter-translator communication. If one gets here, it + * means somebody sent one that nobody else recognized, which is an + * error much like an uncaught exception. + */ + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_IPC_NOT_HANDLE, + "GF_LOG_IPC(%d) not handled", op); + STACK_UNWIND_STRICT(ipc, frame, -1, -EOPNOTSUPP, NULL); + return 0; } int32_t -posix_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - gf_seek_what_t what, dict_t *xdata) +posix_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + gf_seek_what_t what, dict_t *xdata) { #ifdef HAVE_SEEK_HOLE - struct posix_fd *pfd = NULL; - off_t ret = -1; - int err = 0; - int whence = 0; - struct iatt preop = {0,}; - dict_t *rsp_xdata = NULL; + struct posix_fd *pfd = NULL; + off_t ret = -1; + int err = 0; + int whence = 0; + struct iatt preop = { + 0, + }; + dict_t *rsp_xdata = NULL; - DECLARE_OLD_FS_ID_VAR; + DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); + SET_FS_ID(frame->root->uid, frame->root->gid); - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); - switch (what) { + switch (what) { case GF_SEEK_DATA: - whence = SEEK_DATA; - break; + whence = SEEK_DATA; + break; case GF_SEEK_HOLE: - whence = SEEK_HOLE; - break; + whence = SEEK_HOLE; + break; default: - err = ENOTSUP; - gf_msg (this->name, GF_LOG_ERROR, ENOTSUP, - P_MSG_SEEK_UNKOWN, "don't know what to seek"); - goto out; - } - - ret = posix_fd_ctx_get (fd, this, &pfd, &err); - if (ret < 0) { - gf_msg_debug (this->name, 0, "pfd is NULL from fd=%p", fd); - goto out; - } - - if (xdata) { - ret = posix_fdstat (this, fd->inode, pfd->fd, &preop); - if (ret == -1) { - ret = -errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } - - ret = posix_cs_maintenance (this, fd, NULL, &pfd->fd, &preop, NULL, - xdata, &rsp_xdata, _gf_false); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - ret = -EIO; - goto out; - } - } + err = ENOTSUP; + gf_msg(this->name, GF_LOG_ERROR, ENOTSUP, P_MSG_SEEK_UNKOWN, + "don't know what to seek"); + goto out; + } + + ret = posix_fd_ctx_get(fd, this, &pfd, &err); + if (ret < 0) { + gf_msg_debug(this->name, 0, "pfd is NULL from fd=%p", fd); + goto out; + } - ret = sys_lseek (pfd->fd, offset, whence); + if (xdata) { + ret = posix_fdstat(this, fd->inode, pfd->fd, &preop); if (ret == -1) { - err = errno; - gf_msg (this->name, fop_log_level(GF_FOP_SEEK, err), err, - P_MSG_SEEK_FAILED, - "seek failed on fd %d length %" PRId64, pfd->fd, - offset); - goto out; + ret = -errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; } + ret = posix_cs_maintenance(this, fd, NULL, &pfd->fd, &preop, NULL, + xdata, &rsp_xdata, _gf_false); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + ret = -EIO; + goto out; + } + } + + ret = sys_lseek(pfd->fd, offset, whence); + if (ret == -1) { + err = errno; + gf_msg(this->name, fop_log_level(GF_FOP_SEEK, err), err, + P_MSG_SEEK_FAILED, "seek failed on fd %d length %" PRId64, + pfd->fd, offset); + goto out; + } + out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (seek, frame, (ret == -1 ? -1 : 0), err, - (ret == -1 ? -1 : ret), rsp_xdata); + STACK_UNWIND_STRICT(seek, frame, (ret == -1 ? -1 : 0), err, + (ret == -1 ? -1 : ret), rsp_xdata); #else - STACK_UNWIND_STRICT (seek, frame, -1, EINVAL, 0, NULL); + STACK_UNWIND_STRICT(seek, frame, -1, EINVAL, 0, NULL); #endif - return 0; + return 0; } int32_t -posix_opendir (call_frame_t *frame, xlator_t *this, - loc_t *loc, fd_t *fd, dict_t *xdata) +posix_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - char * real_path = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - DIR * dir = NULL; - struct posix_fd * pfd = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (fd, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_errno = ESTALE; - goto out; - } + char *real_path = NULL; + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + DIR *dir = NULL; + struct posix_fd *pfd = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(fd, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + op_errno = ESTALE; + goto out; + } - op_ret = -1; - dir = sys_opendir (real_path); + op_ret = -1; + dir = sys_opendir(real_path); - if (dir == NULL) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_OPENDIR_FAILED, - "opendir failed on %s", real_path); - goto out; - } + if (dir == NULL) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_OPENDIR_FAILED, + "opendir failed on %s", real_path); + goto out; + } - op_ret = dirfd (dir); - if (op_ret < 0) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_DIRFD_FAILED, - "dirfd() failed on %s", real_path); - goto out; - } + op_ret = dirfd(dir); + if (op_ret < 0) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_DIRFD_FAILED, + "dirfd() failed on %s", real_path); + goto out; + } - pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); - if (!pfd) { - op_errno = errno; - goto out; - } + pfd = GF_CALLOC(1, sizeof(*pfd), gf_posix_mt_posix_fd); + if (!pfd) { + op_errno = errno; + goto out; + } - pfd->dir = dir; - pfd->dir_eof = -1; - pfd->fd = op_ret; + pfd->dir = dir; + pfd->dir_eof = -1; + pfd->fd = op_ret; - op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); - if (op_ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_FD_PATH_SETTING_FAILED, "failed to set the fd" - "context path=%s fd=%p", real_path, fd); + op_ret = fd_ctx_set(fd, this, (uint64_t)(long)pfd); + if (op_ret) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_FD_PATH_SETTING_FAILED, + "failed to set the fd" + "context path=%s fd=%p", + real_path, fd); - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, NULL); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, NULL); - op_ret = 0; + op_ret = 0; out: - if (op_ret == -1) { - if (dir) { - (void) sys_closedir (dir); - dir = NULL; - } - if (pfd) { - GF_FREE (pfd); - pfd = NULL; - } + if (op_ret == -1) { + if (dir) { + (void)sys_closedir(dir); + dir = NULL; } + if (pfd) { + GF_FREE(pfd); + pfd = NULL; + } + } - SET_TO_OLD_FS_ID (); - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, NULL); - return 0; + SET_TO_OLD_FS_ID(); + STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, NULL); + return 0; } int32_t -posix_releasedir (xlator_t *this, - fd_t *fd) +posix_releasedir(xlator_t *this, fd_t *fd) { - struct posix_fd * pfd = NULL; - uint64_t tmp_pfd = 0; - int ret = 0; + struct posix_fd *pfd = NULL; + uint64_t tmp_pfd = 0; + int ret = 0; - struct posix_private *priv = NULL; + struct posix_private *priv = NULL; - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); - ret = fd_ctx_del (fd, this, &tmp_pfd); - if (ret < 0) { - gf_msg_debug (this->name, 0, "pfd from fd=%p is NULL", fd); - goto out; - } + ret = fd_ctx_del(fd, this, &tmp_pfd); + if (ret < 0) { + gf_msg_debug(this->name, 0, "pfd from fd=%p is NULL", fd); + goto out; + } - pfd = (struct posix_fd *)(long)tmp_pfd; - if (!pfd->dir) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_PFD_NULL, - "pfd->dir is NULL for fd=%p", fd); - goto out; - } + pfd = (struct posix_fd *)(long)tmp_pfd; + if (!pfd->dir) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_PFD_NULL, + "pfd->dir is NULL for fd=%p", fd); + goto out; + } - priv = this->private; - if (!priv) - goto out; + priv = this->private; + if (!priv) + goto out; - pthread_mutex_lock (&priv->janitor_lock); - { - INIT_LIST_HEAD (&pfd->list); - list_add_tail (&pfd->list, &priv->janitor_fds); - pthread_cond_signal (&priv->janitor_cond); - } - pthread_mutex_unlock (&priv->janitor_lock); + pthread_mutex_lock(&priv->janitor_lock); + { + INIT_LIST_HEAD(&pfd->list); + list_add_tail(&pfd->list, &priv->janitor_fds); + pthread_cond_signal(&priv->janitor_cond); + } + pthread_mutex_unlock(&priv->janitor_lock); out: - return 0; + return 0; } - int32_t -posix_readlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, size_t size, dict_t *xdata) +posix_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - char * dest = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char * real_path = NULL; - struct iatt stbuf = {0,}; + char *dest = NULL; + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + char *real_path = NULL; + struct iatt stbuf = { + 0, + }; - DECLARE_OLD_FS_ID_VAR; + DECLARE_OLD_FS_ID_VAR; - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (loc, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(loc, out); - SET_FS_ID (frame->root->uid, frame->root->gid); + SET_FS_ID(frame->root->uid, frame->root->gid); - dest = alloca (size + 1); + dest = alloca(size + 1); - MAKE_INODE_HANDLE (real_path, this, loc, &stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat on %s failed", - loc->path ? loc->path : "<null>"); - goto out; - } + MAKE_INODE_HANDLE(real_path, this, loc, &stbuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", loc->path ? loc->path : "<null>"); + goto out; + } - op_ret = sys_readlink (real_path, dest, size); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_READYLINK_FAILED, - "readlink on %s failed", real_path); - goto out; - } + op_ret = sys_readlink(real_path, dest, size); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_READYLINK_FAILED, + "readlink on %s failed", real_path); + goto out; + } - dest[op_ret] = 0; + dest[op_ret] = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, dest, &stbuf, NULL); + STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, dest, &stbuf, NULL); - return 0; + return 0; } int32_t -posix_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) +posix_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = 0; - struct posix_private *priv = NULL; - struct iatt prebuf = {0,}; - struct iatt postbuf = {0,}; - dict_t *rsp_xdata = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = 0; + struct posix_private *priv = NULL; + struct iatt prebuf = { + 0, + }; + struct iatt postbuf = { + 0, + }; + dict_t *rsp_xdata = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + + MAKE_INODE_HANDLE(real_path, this, loc, &prebuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "pre-operation lstat on %s failed", + real_path ? real_path : "<null>"); + goto out; + } - MAKE_INODE_HANDLE (real_path, this, loc, &prebuf); + if (xdata) { + op_ret = posix_cs_maintenance(this, NULL, loc, NULL, &prebuf, real_path, + xdata, &rsp_xdata, _gf_false); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "pre-operation lstat on %s failed", - real_path ? real_path : "<null>"); - goto out; - } - - if (xdata) { - op_ret = posix_cs_maintenance (this, NULL, loc, NULL, &prebuf, - real_path, xdata, &rsp_xdata, - _gf_false); - if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, path %s", loc->path); - op_errno = EIO; - goto out; - } + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, path %s", loc->path); + op_errno = EIO; + goto out; } + } - op_ret = sys_truncate (real_path, offset); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_TRUNCATE_FAILED, - "truncate on %s failed", real_path); - goto out; - } + op_ret = sys_truncate(real_path, offset); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_TRUNCATE_FAILED, + "truncate on %s failed", real_path); + goto out; + } - op_ret = posix_pstat (this, loc->inode, loc->gfid, real_path, &postbuf, - _gf_false); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "lstat on %s failed", real_path); - goto out; - } + op_ret = posix_pstat(this, loc->inode, loc->gfid, real_path, &postbuf, + _gf_false); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "lstat on %s failed", real_path); + goto out; + } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &postbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &postbuf); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, - &prebuf, &postbuf, NULL); + STACK_UNWIND_STRICT(truncate, frame, op_ret, op_errno, &prebuf, &postbuf, + NULL); - return 0; + return 0; } int32_t -posix_open (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t flags, fd_t *fd, dict_t *xdata) +posix_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = NULL; - int32_t _fd = -1; - struct posix_fd *pfd = NULL; - struct posix_private *priv = NULL; - struct iatt stbuf = {0, }; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (fd, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - - if (loc->inode && - ((loc->inode->ia_type == IA_IFBLK) || - (loc->inode->ia_type == IA_IFCHR))) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_INVALID_ARGUMENT, - "open received on a block/char file (%s)", - uuid_utoa (loc->inode->gfid)); - op_errno = EINVAL; - goto out; - } - - if (flags & O_CREAT) - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL; + int32_t _fd = -1; + struct posix_fd *pfd = NULL; + struct posix_private *priv = NULL; + struct iatt stbuf = { + 0, + }; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(fd, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + + if (loc->inode && ((loc->inode->ia_type == IA_IFBLK) || + (loc->inode->ia_type == IA_IFCHR))) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_INVALID_ARGUMENT, + "open received on a block/char file (%s)", + uuid_utoa(loc->inode->gfid)); + op_errno = EINVAL; + goto out; + } - MAKE_INODE_HANDLE (real_path, this, loc, &stbuf); - if (!real_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } + if (flags & O_CREAT) + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); - if (IA_ISLNK (stbuf.ia_type)) { - op_ret = -1; - op_errno = ELOOP; - goto out; - } + MAKE_INODE_HANDLE(real_path, this, loc, &stbuf); + if (!real_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } + if (IA_ISLNK(stbuf.ia_type)) { op_ret = -1; - SET_FS_ID (frame->root->uid, frame->root->gid); + op_errno = ELOOP; + goto out; + } - if (priv->o_direct) - flags |= O_DIRECT; + op_ret = -1; + SET_FS_ID(frame->root->uid, frame->root->gid); - _fd = sys_open (real_path, flags, priv->force_create_mode); - if (_fd == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FILE_OP_FAILED, - "open on %s, flags: %d", real_path, flags); - goto out; - } + if (priv->o_direct) + flags |= O_DIRECT; + + _fd = sys_open(real_path, flags, priv->force_create_mode); + if (_fd == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FILE_OP_FAILED, + "open on %s, flags: %d", real_path, flags); + goto out; + } - posix_set_ctime (frame, this, real_path, -1, loc->inode, &stbuf); + posix_set_ctime(frame, this, real_path, -1, loc->inode, &stbuf); - pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); - if (!pfd) { - op_errno = errno; - goto out; - } + pfd = GF_CALLOC(1, sizeof(*pfd), gf_posix_mt_posix_fd); + if (!pfd) { + op_errno = errno; + goto out; + } - pfd->flags = flags; - pfd->fd = _fd; + pfd->flags = flags; + pfd->fd = _fd; - op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); - if (op_ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_FD_PATH_SETTING_FAILED, - "failed to set the fd context path=%s fd=%p", - real_path, fd); + op_ret = fd_ctx_set(fd, this, (uint64_t)(long)pfd); + if (op_ret) + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_FD_PATH_SETTING_FAILED, + "failed to set the fd context path=%s fd=%p", real_path, fd); - LOCK (&priv->lock); - { - priv->nr_files++; - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + priv->nr_files++; + } + UNLOCK(&priv->lock); - op_ret = 0; + op_ret = 0; out: - if (op_ret == -1) { - if (_fd != -1) { - sys_close (_fd); - } + if (op_ret == -1) { + if (_fd != -1) { + sys_close(_fd); } + } - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, NULL); + STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, NULL); - return 0; + return 0; } int -posix_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) +posix_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int _fd = -1; - struct posix_private * priv = NULL; - struct iobuf * iobuf = NULL; - struct iobref * iobref = NULL; - struct iovec vec = {0,}; - struct posix_fd * pfd = NULL; - struct iatt stbuf = {0,}; - struct iatt preop = {0,}; - int ret = -1; - dict_t *rsp_xdata = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (this->private, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - - if (fd->inode && - ((fd->inode->ia_type == IA_IFBLK) || - (fd->inode->ia_type == IA_IFCHR))) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_INVALID_ARGUMENT, - "readv received on a block/char file (%s)", - uuid_utoa (fd->inode->gfid)); - op_errno = EINVAL; - goto out; - } - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + int _fd = -1; + struct posix_private *priv = NULL; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + struct iovec vec = { + 0, + }; + struct posix_fd *pfd = NULL; + struct iatt stbuf = { + 0, + }; + struct iatt preop = { + 0, + }; + int ret = -1; + dict_t *rsp_xdata = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(this->private, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + + if (fd->inode && ((fd->inode->ia_type == IA_IFBLK) || + (fd->inode->ia_type == IA_IFCHR))) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_INVALID_ARGUMENT, + "readv received on a block/char file (%s)", + uuid_utoa(fd->inode->gfid)); + op_errno = EINVAL; + goto out; + } - if (!size) { - op_errno = EINVAL; - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - P_MSG_INVALID_ARGUMENT, "size=%"GF_PRI_SIZET, size); - goto out; - } + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; + } - iobuf = iobuf_get_page_aligned (this->ctx->iobuf_pool, size, - ALIGN_SIZE); - if (!iobuf) { - op_errno = ENOMEM; - goto out; - } + if (!size) { + op_errno = EINVAL; + gf_msg(this->name, GF_LOG_WARNING, EINVAL, P_MSG_INVALID_ARGUMENT, + "size=%" GF_PRI_SIZET, size); + goto out; + } - _fd = pfd->fd; + iobuf = iobuf_get_page_aligned(this->ctx->iobuf_pool, size, ALIGN_SIZE); + if (!iobuf) { + op_errno = ENOMEM; + goto out; + } - if (xdata) { - op_ret = posix_fdstat (this, fd->inode, _fd, &preop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } - op_ret = posix_cs_maintenance (this, fd, NULL, &_fd, &preop, NULL, - xdata, &rsp_xdata, _gf_false); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - op_errno = EIO; - goto out; - } - } + _fd = pfd->fd; - op_ret = sys_pread (_fd, iobuf->ptr, size, offset); + if (xdata) { + op_ret = posix_fdstat(this, fd->inode, _fd, &preop); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_READ_FAILED, "read failed on gfid=%s, " - "fd=%p, offset=%"PRIu64" size=%"GF_PRI_SIZET", " - "buf=%p", uuid_utoa (fd->inode->gfid), fd, - offset, size, iobuf->ptr); - goto out; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; } - - LOCK (&priv->lock); - { - priv->read_value += op_ret; + op_ret = posix_cs_maintenance(this, fd, NULL, &_fd, &preop, NULL, xdata, + &rsp_xdata, _gf_false); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + op_errno = EIO; + goto out; } - UNLOCK (&priv->lock); + } + + op_ret = sys_pread(_fd, iobuf->ptr, size, offset); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_READ_FAILED, + "read failed on gfid=%s, " + "fd=%p, offset=%" PRIu64 " size=%" GF_PRI_SIZET + ", " + "buf=%p", + uuid_utoa(fd->inode->gfid), fd, offset, size, iobuf->ptr); + goto out; + } - vec.iov_base = iobuf->ptr; - vec.iov_len = op_ret; + LOCK(&priv->lock); + { + priv->read_value += op_ret; + } + UNLOCK(&priv->lock); - iobref = iobref_new (); + vec.iov_base = iobuf->ptr; + vec.iov_len = op_ret; - iobref_add (iobref, iobuf); + iobref = iobref_new(); - /* - * readv successful, and we need to get the stat of the file - * we read from - */ + iobref_add(iobref, iobuf); - op_ret = posix_fdstat (this, fd->inode, _fd, &stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fstat failed on fd=%p", fd); - goto out; - } + /* + * readv successful, and we need to get the stat of the file + * we read from + */ + + op_ret = posix_fdstat(this, fd->inode, _fd, &stbuf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fstat failed on fd=%p", fd); + goto out; + } - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, &stbuf); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, &stbuf); - /* Hack to notify higher layers of EOF. */ - if (!stbuf.ia_size || (offset + vec.iov_len) >= stbuf.ia_size) - op_errno = ENOENT; + /* Hack to notify higher layers of EOF. */ + if (!stbuf.ia_size || (offset + vec.iov_len) >= stbuf.ia_size) + op_errno = ENOENT; - op_ret = vec.iov_len; + op_ret = vec.iov_len; out: - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, - &vec, 1, &stbuf, iobref, rsp_xdata); + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, &vec, 1, &stbuf, iobref, + rsp_xdata); - if (iobref) - iobref_unref (iobref); - if (iobuf) - iobuf_unref (iobuf); + if (iobref) + iobref_unref(iobref); + if (iobuf) + iobuf_unref(iobuf); - return 0; + return 0; } int32_t -__posix_pwritev (int fd, struct iovec *vector, int count, off_t offset) +__posix_pwritev(int fd, struct iovec *vector, int count, off_t offset) { - int32_t op_ret = 0; - int idx = 0; - int retval = 0; - off_t internal_off = 0; - - if (!vector) - return -EFAULT; - - internal_off = offset; - for (idx = 0; idx < count; idx++) { - retval = sys_pwrite (fd, vector[idx].iov_base, vector[idx].iov_len, - internal_off); - if (retval == -1) { - op_ret = -errno; - goto err; - } - op_ret += retval; - internal_off += retval; - } + int32_t op_ret = 0; + int idx = 0; + int retval = 0; + off_t internal_off = 0; + + if (!vector) + return -EFAULT; + + internal_off = offset; + for (idx = 0; idx < count; idx++) { + retval = sys_pwrite(fd, vector[idx].iov_base, vector[idx].iov_len, + internal_off); + if (retval == -1) { + op_ret = -errno; + goto err; + } + op_ret += retval; + internal_off += retval; + } err: - return op_ret; + return op_ret; } int32_t -__posix_writev (int fd, struct iovec *vector, int count, off_t startoff, - int odirect) +__posix_writev(int fd, struct iovec *vector, int count, off_t startoff, + int odirect) { - int32_t op_ret = 0; - int idx = 0; - int max_buf_size = 0; - int retval = 0; - char *buf = NULL; - char *alloc_buf = NULL; - off_t internal_off = 0; - - /* Check for the O_DIRECT flag during open() */ - if (!odirect) - return __posix_pwritev (fd, vector, count, startoff); - - for (idx = 0; idx < count; idx++) { - if (max_buf_size < vector[idx].iov_len) - max_buf_size = vector[idx].iov_len; - } - - alloc_buf = _page_aligned_alloc (max_buf_size, &buf); - if (!alloc_buf) { - op_ret = -errno; - goto err; - } - - internal_off = startoff; - for (idx = 0; idx < count; idx++) { - memcpy (buf, vector[idx].iov_base, vector[idx].iov_len); - - /* not sure whether writev works on O_DIRECT'd fd */ - retval = sys_pwrite (fd, buf, vector[idx].iov_len, internal_off); - if (retval == -1) { - op_ret = -errno; - goto err; - } - - op_ret += retval; - internal_off += retval; - } + int32_t op_ret = 0; + int idx = 0; + int max_buf_size = 0; + int retval = 0; + char *buf = NULL; + char *alloc_buf = NULL; + off_t internal_off = 0; + + /* Check for the O_DIRECT flag during open() */ + if (!odirect) + return __posix_pwritev(fd, vector, count, startoff); + + for (idx = 0; idx < count; idx++) { + if (max_buf_size < vector[idx].iov_len) + max_buf_size = vector[idx].iov_len; + } + + alloc_buf = _page_aligned_alloc(max_buf_size, &buf); + if (!alloc_buf) { + op_ret = -errno; + goto err; + } + + internal_off = startoff; + for (idx = 0; idx < count; idx++) { + memcpy(buf, vector[idx].iov_base, vector[idx].iov_len); + + /* not sure whether writev works on O_DIRECT'd fd */ + retval = sys_pwrite(fd, buf, vector[idx].iov_len, internal_off); + if (retval == -1) { + op_ret = -errno; + goto err; + } + + op_ret += retval; + internal_off += retval; + } err: - GF_FREE (alloc_buf); + GF_FREE(alloc_buf); - return op_ret; + return op_ret; } -dict_t* -_fill_writev_xdata (fd_t *fd, dict_t *xdata, xlator_t *this, int is_append) +dict_t * +_fill_writev_xdata(fd_t *fd, dict_t *xdata, xlator_t *this, int is_append) { - dict_t *rsp_xdata = NULL; - int32_t ret = 0; - inode_t *inode = NULL; - - if (fd) - inode = fd->inode; - - if (!fd || !fd->inode || gf_uuid_is_null (fd->inode->gfid)) { - gf_msg_callingfn (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_XATTR_FAILED, "fd: %p inode: %p" - "gfid:%s", fd, inode?inode:0, - inode?uuid_utoa(inode->gfid):"N/A"); - goto out; - } + dict_t *rsp_xdata = NULL; + int32_t ret = 0; + inode_t *inode = NULL; + + if (fd) + inode = fd->inode; + + if (!fd || !fd->inode || gf_uuid_is_null(fd->inode->gfid)) { + gf_msg_callingfn(this->name, GF_LOG_ERROR, EINVAL, P_MSG_XATTR_FAILED, + "fd: %p inode: %p" + "gfid:%s", + fd, inode ? inode : 0, + inode ? uuid_utoa(inode->gfid) : "N/A"); + goto out; + } - if (!xdata) - goto out; + if (!xdata) + goto out; - rsp_xdata = dict_new(); - if (!rsp_xdata) - goto out; + rsp_xdata = dict_new(); + if (!rsp_xdata) + goto out; - if (dict_get (xdata, GLUSTERFS_OPEN_FD_COUNT)) { - ret = dict_set_uint32 (rsp_xdata, GLUSTERFS_OPEN_FD_COUNT, - fd->inode->fd_count); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "%s: Failed to set " - "dictionary value for %s", - uuid_utoa (fd->inode->gfid), - GLUSTERFS_OPEN_FD_COUNT); - } + if (dict_get(xdata, GLUSTERFS_OPEN_FD_COUNT)) { + ret = dict_set_uint32(rsp_xdata, GLUSTERFS_OPEN_FD_COUNT, + fd->inode->fd_count); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "%s: Failed to set " + "dictionary value for %s", + uuid_utoa(fd->inode->gfid), GLUSTERFS_OPEN_FD_COUNT); } + } - if (dict_get (xdata, GLUSTERFS_ACTIVE_FD_COUNT)) { - ret = dict_set_uint32 (rsp_xdata, GLUSTERFS_ACTIVE_FD_COUNT, - fd->inode->active_fd_count); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "%s: Failed to set " - "dictionary value for %s", - uuid_utoa (fd->inode->gfid), - GLUSTERFS_ACTIVE_FD_COUNT); - } + if (dict_get(xdata, GLUSTERFS_ACTIVE_FD_COUNT)) { + ret = dict_set_uint32(rsp_xdata, GLUSTERFS_ACTIVE_FD_COUNT, + fd->inode->active_fd_count); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "%s: Failed to set " + "dictionary value for %s", + uuid_utoa(fd->inode->gfid), GLUSTERFS_ACTIVE_FD_COUNT); } + } - if (dict_get (xdata, GLUSTERFS_WRITE_IS_APPEND)) { - ret = dict_set_uint32 (rsp_xdata, GLUSTERFS_WRITE_IS_APPEND, - is_append); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "%s: Failed to set " - "dictionary value for %s", - uuid_utoa (fd->inode->gfid), - GLUSTERFS_WRITE_IS_APPEND); - } + if (dict_get(xdata, GLUSTERFS_WRITE_IS_APPEND)) { + ret = dict_set_uint32(rsp_xdata, GLUSTERFS_WRITE_IS_APPEND, is_append); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "%s: Failed to set " + "dictionary value for %s", + uuid_utoa(fd->inode->gfid), GLUSTERFS_WRITE_IS_APPEND); } + } out: - return rsp_xdata; + return rsp_xdata; } int32_t -posix_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) +posix_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) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int _fd = -1; - struct posix_private * priv = NULL; - struct posix_fd * pfd = NULL; - struct iatt preop = {0,}; - struct iatt postop = {0,}; - int ret = -1; - dict_t *rsp_xdata = NULL; - int is_append = 0; - gf_boolean_t locked = _gf_false; - gf_boolean_t write_append = _gf_false; - gf_boolean_t update_atomic = _gf_false; - posix_inode_ctx_t *ctx = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (vector, out); - VALIDATE_OR_GOTO (this->private, out); - - priv = this->private; - - VALIDATE_OR_GOTO (priv, out); - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - if (fd->inode && - ((fd->inode->ia_type == IA_IFBLK) || - (fd->inode->ia_type == IA_IFCHR))) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_INVALID_ARGUMENT, - "writev received on a block/char file (%s)", - uuid_utoa (fd->inode->gfid)); - op_errno = EINVAL; - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + int _fd = -1; + struct posix_private *priv = NULL; + struct posix_fd *pfd = NULL; + struct iatt preop = { + 0, + }; + struct iatt postop = { + 0, + }; + int ret = -1; + dict_t *rsp_xdata = NULL; + int is_append = 0; + gf_boolean_t locked = _gf_false; + gf_boolean_t write_append = _gf_false; + gf_boolean_t update_atomic = _gf_false; + posix_inode_ctx_t *ctx = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(vector, out); + VALIDATE_OR_GOTO(this->private, out); + + priv = this->private; + + VALIDATE_OR_GOTO(priv, out); + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + if (fd->inode && ((fd->inode->ia_type == IA_IFBLK) || + (fd->inode->ia_type == IA_IFCHR))) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_INVALID_ARGUMENT, + "writev received on a block/char file (%s)", + uuid_utoa(fd->inode->gfid)); + op_errno = EINVAL; + goto out; + } - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ret, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto out; - } + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ret, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; + } - _fd = pfd->fd; + _fd = pfd->fd; - ret = posix_check_internal_writes (this, fd, _fd, xdata); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "possible overwrite from internal client, fd=%p", fd); - op_ret = -1; - op_errno = EBUSY; - goto out; - } - - if (xdata) { - if (dict_get (xdata, GLUSTERFS_WRITE_IS_APPEND)) - write_append = _gf_true; - if (dict_get (xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) - update_atomic = _gf_true; - } + ret = posix_check_internal_writes(this, fd, _fd, xdata); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "possible overwrite from internal client, fd=%p", fd); + op_ret = -1; + op_errno = EBUSY; + goto out; + } + + if (xdata) { + if (dict_get(xdata, GLUSTERFS_WRITE_IS_APPEND)) + write_append = _gf_true; + if (dict_get(xdata, GLUSTERFS_WRITE_UPDATE_ATOMIC)) + update_atomic = _gf_true; + } + + /* The write_is_append check and write must happen + atomically. Else another write can overtake this + write after the check and get written earlier. + + So lock before preop-stat and unlock after write. + */ + + /* + * The update_atomic option is to instruct posix to do prestat, + * write and poststat atomically. This is to prevent any modification to + * ia_size and ia_blocks until poststat and the diff in their values + * between pre and poststat could be of use for some translators (shard + * as of today). + */ - /* The write_is_append check and write must happen - atomically. Else another write can overtake this - write after the check and get written earlier. + op_ret = posix_inode_ctx_get_all(fd->inode, this, &ctx); + if (op_ret < 0) { + op_errno = ENOMEM; + goto out; + } - So lock before preop-stat and unlock after write. - */ + if (write_append || update_atomic) { + locked = _gf_true; + pthread_mutex_lock(&ctx->write_atomic_lock); + } - /* - * The update_atomic option is to instruct posix to do prestat, - * write and poststat atomically. This is to prevent any modification to - * ia_size and ia_blocks until poststat and the diff in their values - * between pre and poststat could be of use for some translators (shard - * as of today). - */ + op_ret = posix_fdstat(this, fd->inode, _fd, &preop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; + } - op_ret = posix_inode_ctx_get_all (fd->inode, this, &ctx); + if (xdata) { + op_ret = posix_cs_maintenance(this, fd, NULL, &_fd, &preop, NULL, xdata, + &rsp_xdata, _gf_false); if (op_ret < 0) { - op_errno = ENOMEM; - goto out; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + op_errno = EIO; + goto out; } + } - if (write_append || update_atomic) { - locked = _gf_true; - pthread_mutex_lock (&ctx->write_atomic_lock); - } + if (locked && write_append) { + if (preop.ia_size == offset || (fd->flags & O_APPEND)) + is_append = 1; + } - op_ret = posix_fdstat (this, fd->inode, _fd, &preop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } + op_ret = __posix_writev(_fd, vector, count, offset, + (pfd->flags & O_DIRECT)); - if (xdata) { - op_ret = posix_cs_maintenance (this, fd, NULL, &_fd, &preop, NULL, - xdata, &rsp_xdata, _gf_false); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - op_errno = EIO; - goto out; - } - } - - if (locked && write_append) { - if (preop.ia_size == offset || (fd->flags & O_APPEND)) - is_append = 1; - } - - op_ret = __posix_writev (_fd, vector, count, offset, - (pfd->flags & O_DIRECT)); - - if (locked && (!update_atomic)) { - pthread_mutex_unlock (&ctx->write_atomic_lock); - locked = _gf_false; - } + if (locked && (!update_atomic)) { + pthread_mutex_unlock(&ctx->write_atomic_lock); + locked = _gf_false; + } - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - gf_msg (this->name, GF_LOG_ERROR, op_errno, P_MSG_WRITE_FAILED, - "write failed: offset %"PRIu64 - ",", offset); - goto out; - } + if (op_ret < 0) { + op_errno = -op_ret; + op_ret = -1; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_WRITE_FAILED, + "write failed: offset %" PRIu64 ",", offset); + goto out; + } - rsp_xdata = _fill_writev_xdata (fd, xdata, this, is_append); - /* writev successful, we also need to get the stat of - * the file we wrote to - */ + rsp_xdata = _fill_writev_xdata(fd, xdata, this, is_append); + /* writev successful, we also need to get the stat of + * the file we wrote to + */ - ret = posix_fdstat (this, fd->inode, _fd, &postop); - if (ret == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FSTAT_FAILED, - "post-operation fstat failed on fd=%p", - fd); - goto out; - } + ret = posix_fdstat(this, fd->inode, _fd, &postop); + if (ret == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "post-operation fstat failed on fd=%p", fd); + goto out; + } - posix_set_ctime (frame, this, NULL, pfd->fd, fd->inode, &postop); + posix_set_ctime(frame, this, NULL, pfd->fd, fd->inode, &postop); - if (locked) { - pthread_mutex_unlock (&ctx->write_atomic_lock); - locked = _gf_false; - } + if (locked) { + pthread_mutex_unlock(&ctx->write_atomic_lock); + locked = _gf_false; + } - if (flags & (O_SYNC|O_DSYNC)) { - ret = sys_fsync (_fd); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_WRITEV_FAILED, - "fsync() in writev on fd %d failed", - _fd); - op_ret = -1; - op_errno = errno; - goto out; - } + if (flags & (O_SYNC | O_DSYNC)) { + ret = sys_fsync(_fd); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_WRITEV_FAILED, + "fsync() in writev on fd %d failed", _fd); + op_ret = -1; + op_errno = errno; + goto out; } + } - LOCK (&priv->lock); - { - priv->write_value += op_ret; - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + priv->write_value += op_ret; + } + UNLOCK(&priv->lock); out: - if (locked) { - pthread_mutex_unlock (&ctx->write_atomic_lock); - locked = _gf_false; - } + if (locked) { + pthread_mutex_unlock(&ctx->write_atomic_lock); + locked = _gf_false; + } - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, &preop, &postop, - rsp_xdata); + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, &preop, &postop, + rsp_xdata); - if (rsp_xdata) - dict_unref (rsp_xdata); - return 0; + if (rsp_xdata) + dict_unref(rsp_xdata); + return 0; } - int32_t -posix_statfs (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xdata) +posix_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - char * real_path = NULL; - int32_t op_ret = -1; - int32_t op_errno = 0; - struct statvfs buf = {0, }; - struct posix_private * priv = NULL; - int shared_by = 1; - int percent = 0; - uint64_t reserved_blocks = 0; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (this->private, out); - - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - priv = this->private; - - op_ret = sys_statvfs (real_path, &buf); - - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_STATVFS_FAILED, - "statvfs failed on %s", real_path); - goto out; - } - - percent = priv->disk_reserve; - reserved_blocks = (buf.f_blocks * percent) / 100; - - if (buf.f_bfree > reserved_blocks) { - buf.f_bfree = (buf.f_bfree - reserved_blocks); - if (buf.f_bavail > buf.f_bfree) { - buf.f_bavail = buf.f_bfree; - } - } else { - buf.f_bfree = 0; - buf.f_bavail = 0; - } + char *real_path = NULL; + int32_t op_ret = -1; + int32_t op_errno = 0; + struct statvfs buf = { + 0, + }; + struct posix_private *priv = NULL; + int shared_by = 1; + int percent = 0; + uint64_t reserved_blocks = 0; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(this->private, out); + + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; + } - shared_by = priv->shared_brick_count; - if (shared_by > 1) { - buf.f_blocks /= shared_by; - buf.f_bfree /= shared_by; - buf.f_bavail /= shared_by; - buf.f_files /= shared_by; - buf.f_ffree /= shared_by; - buf.f_favail /= shared_by; - } + priv = this->private; - if (!priv->export_statfs) { - buf.f_blocks = 0; - buf.f_bfree = 0; - buf.f_bavail = 0; - buf.f_files = 0; - buf.f_ffree = 0; - buf.f_favail = 0; - } + op_ret = sys_statvfs(real_path, &buf); - op_ret = 0; + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_STATVFS_FAILED, + "statvfs failed on %s", real_path); + goto out; + } + + percent = priv->disk_reserve; + reserved_blocks = (buf.f_blocks * percent) / 100; + + if (buf.f_bfree > reserved_blocks) { + buf.f_bfree = (buf.f_bfree - reserved_blocks); + if (buf.f_bavail > buf.f_bfree) { + buf.f_bavail = buf.f_bfree; + } + } else { + buf.f_bfree = 0; + buf.f_bavail = 0; + } + + shared_by = priv->shared_brick_count; + if (shared_by > 1) { + buf.f_blocks /= shared_by; + buf.f_bfree /= shared_by; + buf.f_bavail /= shared_by; + buf.f_files /= shared_by; + buf.f_ffree /= shared_by; + buf.f_favail /= shared_by; + } + + if (!priv->export_statfs) { + buf.f_blocks = 0; + buf.f_bfree = 0; + buf.f_bavail = 0; + buf.f_files = 0; + buf.f_ffree = 0; + buf.f_favail = 0; + } + + op_ret = 0; out: - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, &buf, NULL); - return 0; + STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, &buf, NULL); + return 0; } - int32_t -posix_flush (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *xdata) +posix_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int ret = -1; - struct posix_fd *pfd = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL on fd=%p", fd); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + int ret = -1; + struct posix_fd *pfd = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL on fd=%p", fd); + goto out; + } - op_ret = 0; + op_ret = 0; out: - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, NULL); + STACK_UNWIND_STRICT(flush, frame, op_ret, op_errno, NULL); - return 0; + return 0; } - int32_t -posix_release (xlator_t *this, fd_t *fd) +posix_release(xlator_t *this, fd_t *fd) { - struct posix_private * priv = NULL; - struct posix_fd * pfd = NULL; - int ret = -1; - uint64_t tmp_pfd = 0; + struct posix_private *priv = NULL; + struct posix_fd *pfd = NULL; + int ret = -1; + uint64_t tmp_pfd = 0; - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); - priv = this->private; + priv = this->private; - ret = fd_ctx_del (fd, this, &tmp_pfd); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto out; - } - pfd = (struct posix_fd *)(long)tmp_pfd; + ret = fd_ctx_del(fd, this, &tmp_pfd); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; + } + pfd = (struct posix_fd *)(long)tmp_pfd; + + if (pfd->dir) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DIR_NOT_NULL, + "pfd->dir is %p (not NULL) for file fd=%p", pfd->dir, fd); + } + if (!priv) + goto out; - if (pfd->dir) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_DIR_NOT_NULL, - "pfd->dir is %p (not NULL) for file fd=%p", - pfd->dir, fd); - } - if (!priv) - goto out; + pthread_mutex_lock(&priv->janitor_lock); + { + INIT_LIST_HEAD(&pfd->list); + list_add_tail(&pfd->list, &priv->janitor_fds); + pthread_cond_signal(&priv->janitor_cond); + } + pthread_mutex_unlock(&priv->janitor_lock); - pthread_mutex_lock (&priv->janitor_lock); - { - INIT_LIST_HEAD (&pfd->list); - list_add_tail (&pfd->list, &priv->janitor_fds); - pthread_cond_signal (&priv->janitor_cond); - } - pthread_mutex_unlock (&priv->janitor_lock); - - LOCK (&priv->lock); - { - priv->nr_files--; - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + priv->nr_files--; + } + UNLOCK(&priv->lock); out: - return 0; + return 0; } - int -posix_batch_fsync (call_frame_t *frame, xlator_t *this, - fd_t *fd, int datasync, dict_t *xdata) +posix_batch_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, + dict_t *xdata) { - call_stub_t *stub = NULL; - struct posix_private *priv = NULL; + call_stub_t *stub = NULL; + struct posix_private *priv = NULL; - priv = this->private; + priv = this->private; - stub = fop_fsync_stub (frame, default_fsync, fd, datasync, xdata); - if (!stub) { - STACK_UNWIND_STRICT (fsync, frame, -1, ENOMEM, 0, 0, 0); - return 0; - } + stub = fop_fsync_stub(frame, default_fsync, fd, datasync, xdata); + if (!stub) { + STACK_UNWIND_STRICT(fsync, frame, -1, ENOMEM, 0, 0, 0); + return 0; + } - pthread_mutex_lock (&priv->fsync_mutex); - { - list_add_tail (&stub->list, &priv->fsyncs); - priv->fsync_queue_count++; - pthread_cond_signal (&priv->fsync_cond); - } - pthread_mutex_unlock (&priv->fsync_mutex); + pthread_mutex_lock(&priv->fsync_mutex); + { + list_add_tail(&stub->list, &priv->fsyncs); + priv->fsync_queue_count++; + pthread_cond_signal(&priv->fsync_cond); + } + pthread_mutex_unlock(&priv->fsync_mutex); - return 0; + return 0; } - int32_t -posix_fsync (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync, dict_t *xdata) +posix_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int _fd = -1; - struct posix_fd * pfd = NULL; - int ret = -1; - struct iatt preop = {0,}; - struct iatt postop = {0,}; - struct posix_private *priv = NULL; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); + int32_t op_ret = -1; + int32_t op_errno = 0; + int _fd = -1; + struct posix_fd *pfd = NULL; + int ret = -1; + struct iatt preop = { + 0, + }; + struct iatt postop = { + 0, + }; + struct posix_private *priv = NULL; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); #ifdef GF_DARWIN_HOST_OS - /* Always return success in case of fsync in MAC OS X */ - op_ret = 0; - goto out; + /* Always return success in case of fsync in MAC OS X */ + op_ret = 0; + goto out; #endif - priv = this->private; + priv = this->private; - if (priv->batch_fsync_mode && xdata && dict_get (xdata, "batch-fsync")) { - posix_batch_fsync (frame, this, fd, datasync, xdata); - return 0; - } - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd not found in fd's ctx"); - goto out; - } + if (priv->batch_fsync_mode && xdata && dict_get(xdata, "batch-fsync")) { + posix_batch_fsync(frame, this, fd, datasync, xdata); + return 0; + } - _fd = pfd->fd; + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd not found in fd's ctx"); + goto out; + } - op_ret = posix_fdstat (this, fd->inode, _fd, &preop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } + _fd = pfd->fd; - if (datasync) { - op_ret = sys_fdatasync (_fd); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FSYNC_FAILED, "fdatasync on fd=%p" - "failed:", fd); - goto out; - } - } else { - op_ret = sys_fsync (_fd); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_FSYNC_FAILED, "fsync on fd=%p " - "failed", fd); - goto out; - } - } + op_ret = posix_fdstat(this, fd->inode, _fd, &preop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; + } - op_ret = posix_fdstat (this, fd->inode, _fd, &postop); + if (datasync) { + op_ret = sys_fdatasync(_fd); if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_FSTAT_FAILED, - "post-operation fstat failed on fd=%p", fd); - goto out; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSYNC_FAILED, + "fdatasync on fd=%p" + "failed:", + fd); + goto out; + } + } else { + op_ret = sys_fsync(_fd); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSYNC_FAILED, + "fsync on fd=%p " + "failed", + fd); + goto out; } + } - op_ret = 0; + op_ret = posix_fdstat(this, fd->inode, _fd, &postop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_FSTAT_FAILED, + "post-operation fstat failed on fd=%p", fd); + goto out; + } + + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, &preop, &postop, - NULL); + STACK_UNWIND_STRICT(fsync, frame, op_ret, op_errno, &preop, &postop, NULL); - return 0; + return 0; } static int gf_posix_xattr_enotsup_log; static int -_handle_setxattr_keyvalue_pair (dict_t *d, char *k, data_t *v, - void *tmp) +_handle_setxattr_keyvalue_pair(dict_t *d, char *k, data_t *v, void *tmp) { - posix_xattr_filler_t *filler = NULL; + posix_xattr_filler_t *filler = NULL; - filler = tmp; + filler = tmp; - return posix_handle_pair (filler->this, filler->real_path, k, v, - filler->flags, filler->stbuf); + return posix_handle_pair(filler->this, filler->real_path, k, v, + filler->flags, filler->stbuf); } #ifdef GF_DARWIN_HOST_OS static int map_xattr_flags(int flags) { - /* DARWIN has different defines on XATTR_ flags. - There do not seem to be a POSIX standard - Parse any other flags over. - */ - int darwinflags = flags & ~(GF_XATTR_CREATE | GF_XATTR_REPLACE | XATTR_REPLACE); - if (GF_XATTR_CREATE & flags) - darwinflags |= XATTR_CREATE; - if (GF_XATTR_REPLACE & flags) - darwinflags |= XATTR_REPLACE; - return darwinflags; + /* DARWIN has different defines on XATTR_ flags. + There do not seem to be a POSIX standard + Parse any other flags over. + */ + int darwinflags = flags & + ~(GF_XATTR_CREATE | GF_XATTR_REPLACE | XATTR_REPLACE); + if (GF_XATTR_CREATE & flags) + darwinflags |= XATTR_CREATE; + if (GF_XATTR_REPLACE & flags) + darwinflags |= XATTR_REPLACE; + return darwinflags; } #endif int32_t -posix_setxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *dict, int flags, dict_t *xdata) +posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int flags, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char * real_path = NULL; - char *acl_xattr = NULL; - struct iatt preop = {0}; - struct iatt postop = {0}; - int32_t ret = 0; - ssize_t acl_size = 0; - dict_t *xattr = NULL; - posix_xattr_filler_t filler = {0,}; - struct posix_private *priv = NULL; - struct iatt tmp_stbuf = {0,}; - data_t *tdata = NULL; - char stime[4096]; - char sxattr[4096]; - gf_cs_obj_state state = -1; - char remotepath[4096] = {0}; - int i = 0; - int len; - - DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (this->private, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (dict, out); - - priv = this->private; - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - - posix_pstat(this, loc->inode, loc->gfid, real_path, &preop, _gf_false); - + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL; + char *acl_xattr = NULL; + struct iatt preop = {0}; + struct iatt postop = {0}; + int32_t ret = 0; + ssize_t acl_size = 0; + dict_t *xattr = NULL; + posix_xattr_filler_t filler = { + 0, + }; + struct posix_private *priv = NULL; + struct iatt tmp_stbuf = { + 0, + }; + data_t *tdata = NULL; + char stime[4096]; + char sxattr[4096]; + gf_cs_obj_state state = -1; + char remotepath[4096] = {0}; + int i = 0; + int len; + + DECLARE_OLD_FS_ID_VAR; + SET_FS_ID(frame->root->uid, frame->root->gid); + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(this->private, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(dict, out); + + priv = this->private; + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { op_ret = -1; + op_errno = ESTALE; + goto out; + } - dict_del (dict, GFID_XATTR_KEY); - dict_del (dict, GF_XATTR_VOL_ID_KEY); - /* the io-stats-dump key should not reach disk */ - dict_del (dict, GF_XATTR_IOSTATS_DUMP_KEY); - - tdata = dict_get (dict, GF_CS_OBJECT_UPLOAD_COMPLETE); - if (tdata) { - /*TODO: move the following to a different function */ - LOCK (&loc->inode->lock); - { - state = posix_cs_check_status (this, real_path, NULL, &preop); - if (state != GF_CS_LOCAL) { - op_errno = EINVAL; - ret = posix_cs_set_state (this, &xattr, state, real_path, - NULL); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "set state failed"); - } - goto unlock; - } - - ret = posix_pstat (this, loc->inode, loc->gfid, real_path, - &tmp_stbuf, _gf_true); - if (ret) { - op_errno = EINVAL; - goto unlock; - } - - sprintf (stime, "%lu", tmp_stbuf.ia_mtime); + posix_pstat(this, loc->inode, loc->gfid, real_path, &preop, _gf_false); - /*TODO: may be should consider nano-second also */ - if (strncmp (stime, tdata->data, tdata->len) != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, "mtime " - "passed is different from seen by file now." - " Will skip truncating the file"); - ret = -1; - op_errno = EINVAL; - goto unlock; - } + op_ret = -1; - len = sprintf (sxattr, "%lu", tmp_stbuf.ia_size); + dict_del(dict, GFID_XATTR_KEY); + dict_del(dict, GF_XATTR_VOL_ID_KEY); + /* the io-stats-dump key should not reach disk */ + dict_del(dict, GF_XATTR_IOSTATS_DUMP_KEY); - ret = sys_lsetxattr (real_path, GF_CS_OBJECT_SIZE, - sxattr, len, flags); + tdata = dict_get(dict, GF_CS_OBJECT_UPLOAD_COMPLETE); + if (tdata) { + /*TODO: move the following to a different function */ + LOCK(&loc->inode->lock); + { + state = posix_cs_check_status(this, real_path, NULL, &preop); + if (state != GF_CS_LOCAL) { + op_errno = EINVAL; + ret = posix_cs_set_state(this, &xattr, state, real_path, NULL); if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "setxattr failed. key %s err %d", - GF_CS_OBJECT_SIZE, ret); - op_errno = errno; - goto unlock; + gf_msg(this->name, GF_LOG_ERROR, 0, 0, "set state failed"); } + goto unlock; + } - if (loc->path[0] == '/') { - for (i = 1; i < strlen(loc->path); i++) { - remotepath[i-1] = loc->path[i]; - } - - remotepath[i] = '\0'; - gf_msg_debug (this->name, GF_LOG_ERROR, "remotepath %s", - remotepath); - } + ret = posix_pstat(this, loc->inode, loc->gfid, real_path, + &tmp_stbuf, _gf_true); + if (ret) { + op_errno = EINVAL; + goto unlock; + } + + sprintf(stime, "%lu", tmp_stbuf.ia_mtime); + + /*TODO: may be should consider nano-second also */ + if (strncmp(stime, tdata->data, tdata->len) != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "mtime " + "passed is different from seen by file now." + " Will skip truncating the file"); + ret = -1; + op_errno = EINVAL; + goto unlock; + } + len = sprintf(sxattr, "%lu", tmp_stbuf.ia_size); - ret = sys_lsetxattr (real_path, GF_CS_OBJECT_REMOTE, - remotepath, strlen (loc->path), flags); + ret = sys_lsetxattr(real_path, GF_CS_OBJECT_SIZE, sxattr, len, + flags); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "setxattr failed. key %s err %d", GF_CS_OBJECT_SIZE, + ret); + op_errno = errno; + goto unlock; + } + + if (loc->path[0] == '/') { + for (i = 1; i < strlen(loc->path); i++) { + remotepath[i - 1] = loc->path[i]; + } + + remotepath[i] = '\0'; + gf_msg_debug(this->name, GF_LOG_ERROR, "remotepath %s", + remotepath); + } + + ret = sys_lsetxattr(real_path, GF_CS_OBJECT_REMOTE, remotepath, + strlen(loc->path), flags); + if (ret) { + gf_log("POSIX", GF_LOG_ERROR, + "setxattr failed - %s" + " %d", + GF_CS_OBJECT_SIZE, ret); + goto unlock; + } + + ret = sys_truncate(real_path, 0); + if (ret) { + gf_log("POSIX", GF_LOG_ERROR, + "truncate failed - %s" + " %d", + GF_CS_OBJECT_SIZE, ret); + op_errno = errno; + ret = sys_lremovexattr(real_path, GF_CS_OBJECT_REMOTE); if (ret) { - gf_log ("POSIX", GF_LOG_ERROR, "setxattr failed - %s" - " %d", GF_CS_OBJECT_SIZE, ret); - goto unlock; - } - - ret = sys_truncate (real_path, 0); + gf_log("POSIX", GF_LOG_ERROR, + "removexattr " + "failed post processing- %s" + " %d", + GF_CS_OBJECT_SIZE, ret); + } + goto unlock; + } else { + state = GF_CS_REMOTE; + ret = posix_cs_set_state(this, &xattr, state, real_path, NULL); if (ret) { - gf_log ("POSIX", GF_LOG_ERROR, "truncate failed - %s" - " %d", GF_CS_OBJECT_SIZE, ret); - op_errno = errno; - ret = sys_lremovexattr (real_path, GF_CS_OBJECT_REMOTE); - if (ret) { - gf_log ("POSIX", GF_LOG_ERROR, "removexattr " - "failed post processing- %s" - " %d", GF_CS_OBJECT_SIZE, ret); - } - goto unlock; - } else { - state = GF_CS_REMOTE; - ret = posix_cs_set_state (this, &xattr, state, real_path, - NULL); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "set state failed"); - } - } + gf_msg(this->name, GF_LOG_ERROR, 0, 0, "set state failed"); } -unlock: - UNLOCK (&loc->inode->lock); - goto out; + } } + unlock: + UNLOCK(&loc->inode->lock); + goto out; + } - filler.real_path = real_path; - filler.this = this; - filler.stbuf = &preop; + filler.real_path = real_path; + filler.this = this; + filler.stbuf = &preop; #ifdef GF_DARWIN_HOST_OS - filler.flags = map_xattr_flags(flags); + filler.flags = map_xattr_flags(flags); #else - filler.flags = flags; + filler.flags = flags; #endif - op_ret = dict_foreach (dict, _handle_setxattr_keyvalue_pair, - &filler); - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - goto out; - } + op_ret = dict_foreach(dict, _handle_setxattr_keyvalue_pair, &filler); + if (op_ret < 0) { + op_errno = -op_ret; + op_ret = -1; + goto out; + } - xattr = dict_new(); - if (!xattr) - goto out; + xattr = dict_new(); + if (!xattr) + goto out; -/* - * FIXFIX: Send the stbuf info in the xdata for now - * This is used by DHT to redirect FOPs if the file is being migrated - * Ignore errors for now - */ - ret = posix_pstat(this, loc->inode, loc->gfid, real_path, &postop, - _gf_false); - if (ret) - goto out; + /* + * FIXFIX: Send the stbuf info in the xdata for now + * This is used by DHT to redirect FOPs if the file is being migrated + * Ignore errors for now + */ + ret = posix_pstat(this, loc->inode, loc->gfid, real_path, &postop, + _gf_false); + if (ret) + goto out; - ret = posix_set_iatt_in_dict (xattr, &preop, &postop); + ret = posix_set_iatt_in_dict(xattr, &preop, &postop); -/* - * ACL can be set on a file/folder using GF_POSIX_ACL_*_KEY xattrs which - * won't aware of access-control xlator. To update its context correctly, - * POSIX_ACL_*_XATTR stored in xdata which is send in the call_back path. - */ - if (dict_get (dict, GF_POSIX_ACL_ACCESS)) { - - /* - * The size of buffer will be know after calling sys_lgetxattr, - * so first we allocate buffer with large size(~4k), then we - * reduced into required size using GF_REALLO(). - */ - acl_xattr = GF_CALLOC (1, ACL_BUFFER_MAX, gf_posix_mt_char); - if (!acl_xattr) - goto out; - - acl_size = sys_lgetxattr (real_path, POSIX_ACL_ACCESS_XATTR, - acl_xattr, ACL_BUFFER_MAX); - - if (acl_size < 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_XATTR_FAILED, "Posix acl is not set " - "properly at the backend"); - goto out; - } + /* + * ACL can be set on a file/folder using GF_POSIX_ACL_*_KEY xattrs which + * won't aware of access-control xlator. To update its context correctly, + * POSIX_ACL_*_XATTR stored in xdata which is send in the call_back path. + */ + if (dict_get(dict, GF_POSIX_ACL_ACCESS)) { + /* + * The size of buffer will be know after calling sys_lgetxattr, + * so first we allocate buffer with large size(~4k), then we + * reduced into required size using GF_REALLO(). + */ + acl_xattr = GF_CALLOC(1, ACL_BUFFER_MAX, gf_posix_mt_char); + if (!acl_xattr) + goto out; - /* If acl_size is more than max buffer size, just ignore it */ - if (acl_size >= ACL_BUFFER_MAX) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - P_MSG_BUFFER_OVERFLOW, "size of acl is more" - "than the buffer"); - goto out; - } + acl_size = sys_lgetxattr(real_path, POSIX_ACL_ACCESS_XATTR, acl_xattr, + ACL_BUFFER_MAX); - acl_xattr = GF_REALLOC (acl_xattr, acl_size); - if (!acl_xattr) - goto out; + if (acl_size < 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_XATTR_FAILED, + "Posix acl is not set " + "properly at the backend"); + goto out; + } - ret = dict_set_bin (xattr, POSIX_ACL_ACCESS_XATTR, - acl_xattr, acl_size); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_SET_XDATA_FAIL, "failed to set" - "xdata for acl"); - GF_FREE (acl_xattr); - goto out; - } + /* If acl_size is more than max buffer size, just ignore it */ + if (acl_size >= ACL_BUFFER_MAX) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, P_MSG_BUFFER_OVERFLOW, + "size of acl is more" + "than the buffer"); + goto out; } - if (dict_get (dict, GF_POSIX_ACL_DEFAULT)) { + acl_xattr = GF_REALLOC(acl_xattr, acl_size); + if (!acl_xattr) + goto out; - acl_xattr = GF_CALLOC (1, ACL_BUFFER_MAX, gf_posix_mt_char); - if (!acl_xattr) - goto out; + ret = dict_set_bin(xattr, POSIX_ACL_ACCESS_XATTR, acl_xattr, acl_size); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, + "failed to set" + "xdata for acl"); + GF_FREE(acl_xattr); + goto out; + } + } - acl_size = sys_lgetxattr (real_path, POSIX_ACL_DEFAULT_XATTR, - acl_xattr, ACL_BUFFER_MAX); + if (dict_get(dict, GF_POSIX_ACL_DEFAULT)) { + acl_xattr = GF_CALLOC(1, ACL_BUFFER_MAX, gf_posix_mt_char); + if (!acl_xattr) + goto out; - if (acl_size < 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_XATTR_FAILED, "Posix acl is not set " - "properly at the backend"); - goto out; - } + acl_size = sys_lgetxattr(real_path, POSIX_ACL_DEFAULT_XATTR, acl_xattr, + ACL_BUFFER_MAX); - if (acl_size >= ACL_BUFFER_MAX) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - P_MSG_BUFFER_OVERFLOW, "size of acl is more" - "than the buffer"); - goto out; - } + if (acl_size < 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_XATTR_FAILED, + "Posix acl is not set " + "properly at the backend"); + goto out; + } - acl_xattr = GF_REALLOC (acl_xattr, acl_size); - if (!acl_xattr) - goto out; + if (acl_size >= ACL_BUFFER_MAX) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, P_MSG_BUFFER_OVERFLOW, + "size of acl is more" + "than the buffer"); + goto out; + } - ret = dict_set_bin (xattr, POSIX_ACL_DEFAULT_XATTR, - acl_xattr, acl_size); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_SET_XDATA_FAIL, "failed to set" - "xdata for acl"); - GF_FREE (acl_xattr); - goto out; - } + acl_xattr = GF_REALLOC(acl_xattr, acl_size); + if (!acl_xattr) + goto out; + + ret = dict_set_bin(xattr, POSIX_ACL_DEFAULT_XATTR, acl_xattr, acl_size); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_SET_XDATA_FAIL, + "failed to set" + "xdata for acl"); + GF_FREE(acl_xattr); + goto out; } + } out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xattr); + STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xattr); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - return 0; + return 0; } - int -posix_xattr_get_real_filename (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *key, dict_t *dict, dict_t *xdata) +posix_xattr_get_real_filename(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *key, dict_t *dict, dict_t *xdata) { - int ret = -1; - int op_ret = -1; - const char *fname = NULL; - char *real_path = NULL; - char *found = NULL; - DIR *fd = NULL; - struct dirent *entry = NULL; - struct dirent scratch[2] = {{0,},}; - - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - return -ESTALE; - } - if (op_ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, - "posix_xattr_get_real_filename (lstat) on %s failed", - real_path); - return -errno; - } - - fd = sys_opendir (real_path); - if (!fd) - return -errno; - - fname = key + SLEN (GF_XATTR_GET_REAL_FILENAME_KEY); - - for (;;) { - errno = 0; - entry = sys_readdir (fd, scratch); - if (!entry || errno != 0) - break; - - if (strcasecmp (entry->d_name, fname) == 0) { - found = gf_strdup (entry->d_name); - if (!found) { - (void) sys_closedir (fd); - return -ENOMEM; - } - break; - } + int ret = -1; + int op_ret = -1; + const char *fname = NULL; + char *real_path = NULL; + char *found = NULL; + DIR *fd = NULL; + struct dirent *entry = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + return -ESTALE; + } + if (op_ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_LSTAT_FAILED, + "posix_xattr_get_real_filename (lstat) on %s failed", real_path); + return -errno; + } + + fd = sys_opendir(real_path); + if (!fd) + return -errno; + + fname = key + SLEN(GF_XATTR_GET_REAL_FILENAME_KEY); + + for (;;) { + errno = 0; + entry = sys_readdir(fd, scratch); + if (!entry || errno != 0) + break; + + if (strcasecmp(entry->d_name, fname) == 0) { + found = gf_strdup(entry->d_name); + if (!found) { + (void)sys_closedir(fd); + return -ENOMEM; + } + break; } + } - (void) sys_closedir (fd); + (void)sys_closedir(fd); - if (!found) - return -ENOENT; + if (!found) + return -ENOENT; - ret = dict_set_dynstr (dict, (char *)key, found); - if (ret) { - GF_FREE (found); - return -ENOMEM; - } - ret = strlen (found) + 1; + ret = dict_set_dynstr(dict, (char *)key, found); + if (ret) { + GF_FREE(found); + return -ENOMEM; + } + ret = strlen(found) + 1; - return ret; + return ret; } int -posix_get_ancestry_directory (xlator_t *this, inode_t *leaf_inode, - gf_dirent_t *head, char **path, int type, - int32_t *op_errno, dict_t *xdata) +posix_get_ancestry_directory(xlator_t *this, inode_t *leaf_inode, + gf_dirent_t *head, char **path, int type, + int32_t *op_errno, dict_t *xdata) { - ssize_t handle_size = 0; - struct posix_private *priv = NULL; - inode_t *inode = NULL; - int ret = -1; - char dirpath[PATH_MAX] = {0,}; - - priv = this->private; - - handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); - - ret = posix_make_ancestryfromgfid (this, dirpath, PATH_MAX + 1, head, - type | POSIX_ANCESTRY_PATH, - leaf_inode->gfid, - handle_size, priv->base_path, - leaf_inode->table, &inode, xdata, - op_errno); - if (ret < 0) - goto out; - + ssize_t handle_size = 0; + struct posix_private *priv = NULL; + inode_t *inode = NULL; + int ret = -1; + char dirpath[PATH_MAX] = { + 0, + }; + + priv = this->private; + + handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); + + ret = posix_make_ancestryfromgfid( + this, dirpath, PATH_MAX + 1, head, type | POSIX_ANCESTRY_PATH, + leaf_inode->gfid, handle_size, priv->base_path, leaf_inode->table, + &inode, xdata, op_errno); + if (ret < 0) + goto out; - /* there is already a reference in loc->inode */ - inode_unref (inode); + /* there is already a reference in loc->inode */ + inode_unref(inode); - if ((type & POSIX_ANCESTRY_PATH) && (path != NULL)) { - if (strcmp (dirpath, "/")) - dirpath[strlen (dirpath) - 1] = '\0'; + if ((type & POSIX_ANCESTRY_PATH) && (path != NULL)) { + if (strcmp(dirpath, "/")) + dirpath[strlen(dirpath) - 1] = '\0'; - *path = gf_strdup (dirpath); - } + *path = gf_strdup(dirpath); + } out: - return ret; + return ret; } int32_t -posix_links_in_same_directory (char *dirpath, int count, inode_t *leaf_inode, - inode_t *parent, struct stat *stbuf, - gf_dirent_t *head, char **path, - int type, dict_t *xdata, int32_t *op_errno) +posix_links_in_same_directory(char *dirpath, int count, inode_t *leaf_inode, + inode_t *parent, struct stat *stbuf, + gf_dirent_t *head, char **path, int type, + dict_t *xdata, int32_t *op_errno) { - int op_ret = -1; - gf_dirent_t *gf_entry = NULL; - xlator_t *this = NULL; - struct posix_private *priv = NULL; - DIR *dirp = NULL; - struct dirent *entry = NULL; - struct dirent scratch[2] = {{0,},}; - char temppath[PATH_MAX] = {0,}; - char scr[PATH_MAX * 4] = {0,}; - - this = THIS; - - priv = this->private; - - dirp = sys_opendir (dirpath); - if (!dirp) { - *op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_OPEN_FAILED, - "could not opendir %s", dirpath); + int op_ret = -1; + gf_dirent_t *gf_entry = NULL; + xlator_t *this = NULL; + struct posix_private *priv = NULL; + DIR *dirp = NULL; + struct dirent *entry = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + char temppath[PATH_MAX] = { + 0, + }; + char scr[PATH_MAX * 4] = { + 0, + }; + + this = THIS; + + priv = this->private; + + dirp = sys_opendir(dirpath); + if (!dirp) { + *op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_OPEN_FAILED, + "could not opendir %s", dirpath); + goto out; + } + + while (count > 0) { + errno = 0; + entry = sys_readdir(dirp, scratch); + if (!entry || errno != 0) + break; + + if (entry->d_ino != stbuf->st_ino) + continue; + + /* Linking an inode here, can cause a race in posix_acl. + Parent inode gets linked here, but before + it reaches posix_acl_readdirp_cbk, create/lookup can + come on a leaf-inode, as parent-inode-ctx not yet updated + in posix_acl_readdirp_cbk, create and lookup can fail + with EACCESS. So do the inode linking in the quota xlator + + linked_inode = inode_link (leaf_inode, parent, + entry->d_name, NULL); + + GF_ASSERT (linked_inode == leaf_inode); + inode_unref (linked_inode);*/ + + if (type & POSIX_ANCESTRY_DENTRY) { + loc_t loc = { + 0, + }; + + loc.inode = inode_ref(leaf_inode); + gf_uuid_copy(loc.gfid, leaf_inode->gfid); + + (void)snprintf(temppath, sizeof(temppath), "%s/%s", dirpath, + entry->d_name); + + gf_entry = gf_dirent_for_name(entry->d_name); + gf_entry->inode = inode_ref(leaf_inode); + gf_entry->dict = posix_xattr_fill(this, temppath, &loc, NULL, -1, + xdata, NULL); + iatt_from_stat(&(gf_entry->d_stat), stbuf); + + list_add_tail(&gf_entry->list, &head->list); + loc_wipe(&loc); + } + + if (type & POSIX_ANCESTRY_PATH) { + (void)snprintf(temppath, sizeof(temppath), "%s/%s", + &dirpath[priv->base_path_length], entry->d_name); + if (!*path) { + *path = gf_strdup(temppath); + } else { + /* creating a colon separated */ + /* list of hard links */ + (void)snprintf(scr, sizeof(scr), "%s:%s", *path, temppath); + + GF_FREE(*path); + *path = gf_strdup(scr); + } + if (!*path) { + op_ret = -1; + *op_errno = ENOMEM; goto out; + } } - while (count > 0) { - errno = 0; - entry = sys_readdir (dirp, scratch); - if (!entry || errno != 0) - break; - - if (entry->d_ino != stbuf->st_ino) - continue; - - /* Linking an inode here, can cause a race in posix_acl. - Parent inode gets linked here, but before - it reaches posix_acl_readdirp_cbk, create/lookup can - come on a leaf-inode, as parent-inode-ctx not yet updated - in posix_acl_readdirp_cbk, create and lookup can fail - with EACCESS. So do the inode linking in the quota xlator - - linked_inode = inode_link (leaf_inode, parent, - entry->d_name, NULL); - - GF_ASSERT (linked_inode == leaf_inode); - inode_unref (linked_inode);*/ - - if (type & POSIX_ANCESTRY_DENTRY) { - loc_t loc = {0, }; + count--; + } - loc.inode = inode_ref (leaf_inode); - gf_uuid_copy (loc.gfid, leaf_inode->gfid); - - (void) snprintf (temppath, sizeof(temppath), "%s/%s", - dirpath, entry->d_name); - - gf_entry = gf_dirent_for_name (entry->d_name); - gf_entry->inode = inode_ref (leaf_inode); - gf_entry->dict - = posix_xattr_fill (this, temppath, &loc, NULL, - -1, xdata, NULL); - iatt_from_stat (&(gf_entry->d_stat), stbuf); - - list_add_tail (&gf_entry->list, &head->list); - loc_wipe (&loc); - } - - if (type & POSIX_ANCESTRY_PATH) { - (void) snprintf (temppath, sizeof(temppath), "%s/%s", - &dirpath[priv->base_path_length], - entry->d_name); - if (!*path) { - *path = gf_strdup (temppath); - } else { - /* creating a colon separated */ - /* list of hard links */ - (void) snprintf (scr, sizeof(scr), "%s:%s", - *path, temppath); - - GF_FREE (*path); - *path = gf_strdup (scr); - } - if (!*path) { - op_ret = -1; - *op_errno = ENOMEM; - goto out; - } - } - - count--; - } - - op_ret = 0; + op_ret = 0; out: - if (dirp) { - op_ret = sys_closedir (dirp); - if (op_ret == -1) { - *op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_CLOSE_FAILED, "closedir failed"); - } + if (dirp) { + op_ret = sys_closedir(dirp); + if (op_ret == -1) { + *op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_CLOSE_FAILED, + "closedir failed"); } + } - return op_ret; + return op_ret; } int -posix_get_ancestry_non_directory (xlator_t *this, inode_t *leaf_inode, - gf_dirent_t *head, char **path, int type, - int32_t *op_errno, dict_t *xdata) +posix_get_ancestry_non_directory(xlator_t *this, inode_t *leaf_inode, + gf_dirent_t *head, char **path, int type, + int32_t *op_errno, dict_t *xdata) { - size_t remaining_size = 0; - int op_ret = -1, pathlen = -1; - ssize_t handle_size = 0; - uuid_t pgfid = {0,}; - int nlink_samepgfid = 0; - struct stat stbuf = {0,}; - char *list = NULL; - int32_t list_offset = 0; - struct posix_private *priv = NULL; - ssize_t size = 0; - inode_t *parent = NULL; - loc_t *loc = NULL; - char *leaf_path = NULL; - char key[4096] = {0,}; - char dirpath[PATH_MAX] = {0,}; - char pgfidstr[UUID_CANONICAL_FORM_LEN+1] = {0,}; - int len; + size_t remaining_size = 0; + int op_ret = -1, pathlen = -1; + ssize_t handle_size = 0; + uuid_t pgfid = { + 0, + }; + int nlink_samepgfid = 0; + struct stat stbuf = { + 0, + }; + char *list = NULL; + int32_t list_offset = 0; + struct posix_private *priv = NULL; + ssize_t size = 0; + inode_t *parent = NULL; + loc_t *loc = NULL; + char *leaf_path = NULL; + char key[4096] = { + 0, + }; + char dirpath[PATH_MAX] = { + 0, + }; + char pgfidstr[UUID_CANONICAL_FORM_LEN + 1] = { + 0, + }; + int len; + + priv = this->private; + + loc = GF_CALLOC(1, sizeof(*loc), gf_posix_mt_char); + if (loc == NULL) { + op_ret = -1; + *op_errno = ENOMEM; + goto out; + } - priv = this->private; + gf_uuid_copy(loc->gfid, leaf_inode->gfid); - loc = GF_CALLOC (1, sizeof (*loc), gf_posix_mt_char); - if (loc == NULL) { - op_ret = -1; - *op_errno = ENOMEM; - goto out; - } - - gf_uuid_copy (loc->gfid, leaf_inode->gfid); + MAKE_INODE_HANDLE(leaf_path, this, loc, NULL); + if (!leaf_path) { + GF_FREE(loc); + *op_errno = ESTALE; + goto out; + } + GF_FREE(loc); + + size = sys_llistxattr(leaf_path, NULL, 0); + if (size == -1) { + *op_errno = errno; + if ((errno == ENOTSUP) || (errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting brick" + " with 'user_xattr' flag)"); - MAKE_INODE_HANDLE (leaf_path, this, loc, NULL); - if (!leaf_path) { - GF_FREE (loc); - *op_errno = ESTALE; - goto out; + } else { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_XATTR_FAILED, + "listxattr failed on" + "%s", + leaf_path); } - GF_FREE (loc); - size = sys_llistxattr (leaf_path, NULL, 0); - if (size == -1) { - *op_errno = errno; - if ((errno == ENOTSUP) || (errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting brick" - " with 'user_xattr' flag)"); + goto out; + } - } else { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_XATTR_FAILED, "listxattr failed on" - "%s", leaf_path); + if (size == 0) { + op_ret = 0; + goto out; + } - } + list = alloca(size); + if (!list) { + *op_errno = errno; + goto out; + } - goto out; - } + size = sys_llistxattr(leaf_path, list, size); + if (size < 0) { + op_ret = -1; + *op_errno = errno; + goto out; + } + remaining_size = size; + list_offset = 0; + + op_ret = sys_lstat(leaf_path, &stbuf); + if (op_ret == -1) { + *op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_LSTAT_FAILED, + "lstat failed on %s", leaf_path); + goto out; + } - if (size == 0) { - op_ret = 0; - goto out; - } + while (remaining_size > 0) { + snprintf(key, sizeof(key), "%s", list + list_offset); + if (strncmp(key, PGFID_XATTR_KEY_PREFIX, + SLEN(PGFID_XATTR_KEY_PREFIX)) != 0) + goto next; - list = alloca (size); - if (!list) { - *op_errno = errno; - goto out; + op_ret = sys_lgetxattr(leaf_path, key, &nlink_samepgfid, + sizeof(nlink_samepgfid)); + if (op_ret == -1) { + *op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on " + "%s: key = %s ", + leaf_path, key); + goto out; } - size = sys_llistxattr (leaf_path, list, size); - if (size < 0) { - op_ret = -1; - *op_errno = errno; - goto out; - } - remaining_size = size; - list_offset = 0; + nlink_samepgfid = ntoh32(nlink_samepgfid); - op_ret = sys_lstat (leaf_path, &stbuf); - if (op_ret == -1) { - *op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, P_MSG_LSTAT_FAILED, - "lstat failed on %s", leaf_path); - goto out; - } + snprintf(pgfidstr, sizeof(pgfidstr), "%s", + key + SLEN(PGFID_XATTR_KEY_PREFIX)); + gf_uuid_parse(pgfidstr, pgfid); - while (remaining_size > 0) { - snprintf(key, sizeof (key), "%s", list + list_offset); - if (strncmp (key, PGFID_XATTR_KEY_PREFIX, - SLEN (PGFID_XATTR_KEY_PREFIX)) != 0) - goto next; - - op_ret = sys_lgetxattr (leaf_path, key, - &nlink_samepgfid, - sizeof(nlink_samepgfid)); - if (op_ret == -1) { - *op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "getxattr failed on " - "%s: key = %s ", leaf_path, key); - goto out; - } + handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); - nlink_samepgfid = ntoh32 (nlink_samepgfid); - - snprintf (pgfidstr, sizeof (pgfidstr), "%s", - key + SLEN (PGFID_XATTR_KEY_PREFIX)); - gf_uuid_parse (pgfidstr, pgfid); - - handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); - - /* constructing the absolute real path of parent dir */ - snprintf (dirpath, sizeof (dirpath), "%s", priv->base_path); - pathlen = PATH_MAX + 1 - priv->base_path_length; - - op_ret = posix_make_ancestryfromgfid (this, - dirpath + priv->base_path_length, - pathlen, - head, - type | POSIX_ANCESTRY_PATH, - pgfid, - handle_size, - priv->base_path, - leaf_inode->table, - &parent, xdata, op_errno); - if (op_ret < 0) { - goto next; - } + /* constructing the absolute real path of parent dir */ + snprintf(dirpath, sizeof(dirpath), "%s", priv->base_path); + pathlen = PATH_MAX + 1 - priv->base_path_length; - dirpath[strlen (dirpath) - 1] = '\0'; + op_ret = posix_make_ancestryfromgfid( + this, dirpath + priv->base_path_length, pathlen, head, + type | POSIX_ANCESTRY_PATH, pgfid, handle_size, priv->base_path, + leaf_inode->table, &parent, xdata, op_errno); + if (op_ret < 0) { + goto next; + } - posix_links_in_same_directory (dirpath, nlink_samepgfid, - leaf_inode, parent, &stbuf, head, - path, type, xdata, op_errno); + dirpath[strlen(dirpath) - 1] = '\0'; - if (parent != NULL) { - inode_unref (parent); - parent = NULL; - } + posix_links_in_same_directory(dirpath, nlink_samepgfid, leaf_inode, + parent, &stbuf, head, path, type, xdata, + op_errno); - next: - len = strlen (key); - remaining_size -= (len + 1); - list_offset += (len + 1); - } /* while (remaining_size > 0) */ + if (parent != NULL) { + inode_unref(parent); + parent = NULL; + } - op_ret = 0; + next: + len = strlen(key); + remaining_size -= (len + 1); + list_offset += (len + 1); + } /* while (remaining_size > 0) */ + + op_ret = 0; out: - return op_ret; + return op_ret; } int -posix_get_ancestry (xlator_t *this, inode_t *leaf_inode, - gf_dirent_t *head, char **path, int type, int32_t *op_errno, - dict_t *xdata) +posix_get_ancestry(xlator_t *this, inode_t *leaf_inode, gf_dirent_t *head, + char **path, int type, int32_t *op_errno, dict_t *xdata) { - int ret = -1; - struct posix_private *priv = NULL; - - priv = this->private; + int ret = -1; + struct posix_private *priv = NULL; - if (IA_ISDIR (leaf_inode->ia_type)) { - ret = posix_get_ancestry_directory (this, leaf_inode, - head, path, type, op_errno, - xdata); - } else { + priv = this->private; - if (!priv->update_pgfid_nlinks) - goto out; - ret = posix_get_ancestry_non_directory (this, leaf_inode, - head, path, type, - op_errno, xdata); - } + if (IA_ISDIR(leaf_inode->ia_type)) { + ret = posix_get_ancestry_directory(this, leaf_inode, head, path, type, + op_errno, xdata); + } else { + if (!priv->update_pgfid_nlinks) + goto out; + ret = posix_get_ancestry_non_directory(this, leaf_inode, head, path, + type, op_errno, xdata); + } out: - if (ret && path && *path) { - GF_FREE (*path); - *path = NULL; - } + if (ret && path && *path) { + GF_FREE(*path); + *path = NULL; + } - return ret; + return ret; } - /** * posix_getxattr - this function returns a dictionary with all the * key:value pair present as xattr. used for * both 'listxattr' and 'getxattr'. */ int32_t -posix_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +posix_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - struct posix_private *priv = NULL; - int32_t op_ret = -1; - int32_t op_errno = 0; - char *value = NULL; - char *real_path = NULL; - dict_t *dict = NULL; - int ret = -1; - char *path = NULL; - char *rpath = NULL; - ssize_t size = 0; - char *list = NULL; - int32_t list_offset = 0; - size_t remaining_size = 0; - char *host_buf = NULL; - char *keybuffer = NULL; - int keybuff_len; - char *value_buf = NULL; - gf_boolean_t have_val = _gf_false; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); - VALIDATE_OR_GOTO (this->private, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - MAKE_INODE_HANDLE (real_path, this, loc, NULL); + struct posix_private *priv = NULL; + int32_t op_ret = -1; + int32_t op_errno = 0; + char *value = NULL; + char *real_path = NULL; + dict_t *dict = NULL; + int ret = -1; + char *path = NULL; + char *rpath = NULL; + ssize_t size = 0; + char *list = NULL; + int32_t list_offset = 0; + size_t remaining_size = 0; + char *host_buf = NULL; + char *keybuffer = NULL; + int keybuff_len; + char *value_buf = NULL; + gf_boolean_t have_val = _gf_false; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); + VALIDATE_OR_GOTO(this->private, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + + op_ret = -1; + priv = this->private; + + ret = posix_handle_georep_xattrs(frame, name, &op_errno, _gf_true); + if (ret == -1) { + op_ret = -1; + /* errno should be set from the above function*/ + goto out; + } + ret = posix_handle_mdata_xattr(frame, name, &op_errno); + if (ret == -1) { op_ret = -1; - priv = this->private; + /* errno should be set from the above function*/ + goto out; + } - ret = posix_handle_georep_xattrs (frame, name, &op_errno, _gf_true); - if (ret == -1) { - op_ret = -1; - /* errno should be set from the above function*/ - goto out; - } + if (name && posix_is_gfid2path_xattr(name)) { + op_ret = -1; + op_errno = ENOATTR; + goto out; + } - ret = posix_handle_mdata_xattr (frame, name, &op_errno); - if (ret == -1) { - op_ret = -1; - /* errno should be set from the above function*/ - goto out; - } + dict = dict_new(); + if (!dict) { + op_errno = ENOMEM; + goto out; + } - if (name && posix_is_gfid2path_xattr (name)) { - op_ret = -1; - op_errno = ENOATTR; - goto out; + if (loc->inode && name && GF_POSIX_ACL_REQUEST(name)) { + ret = posix_pacl_get(real_path, name, &value); + if (ret || !value) { + op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_ACL_FAILED, + "could not get acl (%s) for" + "%s", + name, real_path); + op_ret = -1; + goto out; } - dict = dict_new (); - if (!dict) { + ret = dict_set_dynstr(dict, (char *)name, value); + if (ret < 0) { + GF_FREE(value); + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_ACL_FAILED, + "could not set acl (%s) for" + "%s in dictionary", + name, real_path); + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + + size = ret; + goto done; + } + + if (loc->inode && name && + (strncmp(name, GF_XATTR_GET_REAL_FILENAME_KEY, + SLEN(GF_XATTR_GET_REAL_FILENAME_KEY)) == 0)) { + ret = posix_xattr_get_real_filename(frame, this, loc, name, dict, + xdata); + if (ret < 0) { + op_ret = -1; + op_errno = -ret; + if (op_errno == ENOENT) { + gf_msg_debug(this->name, 0, + "Failed to get " + "real filename (%s, %s)", + loc->path, name); + } else { + gf_msg(this->name, GF_LOG_WARNING, op_errno, + P_MSG_GETTING_FILENAME_FAILED, + "Failed to get real filename (%s, %s):", loc->path, + name); + } + goto out; + } + + size = ret; + goto done; + } + + if (loc->inode && name && !strcmp(name, GLUSTERFS_OPEN_FD_COUNT)) { + if (!fd_list_empty(loc->inode)) { + ret = dict_set_uint32(dict, (char *)name, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "Failed to set " + "dictionary value for %s", + name); op_errno = ENOMEM; goto out; + } + } else { + ret = dict_set_uint32(dict, (char *)name, 0); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "Failed to set " + "dictionary value for %s", + name); + op_errno = ENOMEM; + goto out; + } + } + goto done; + } + if (loc->inode && name && (XATTR_IS_PATHINFO(name))) { + VALIDATE_OR_GOTO(this->private, out); + if (LOC_HAS_ABSPATH(loc)) { + MAKE_REAL_PATH(rpath, this, loc->path); + } else { + rpath = real_path; + } + size = gf_asprintf( + &host_buf, "<POSIX(%s):%s:%s>", priv->base_path, + ((priv->node_uuid_pathinfo && !gf_uuid_is_null(priv->glusterd_uuid)) + ? uuid_utoa(priv->glusterd_uuid) + : priv->hostname), + rpath); + if (size < 0) { + op_errno = ENOMEM; + goto out; } - - if (loc->inode && name && GF_POSIX_ACL_REQUEST (name)) { - ret = posix_pacl_get (real_path, name, &value); - if (ret || !value) { - op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_ACL_FAILED, "could not get acl (%s) for" - "%s", name, real_path); - op_ret = -1; - goto out; - } - - ret = dict_set_dynstr (dict, (char *)name, value); - if (ret < 0) { - GF_FREE (value); - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_ACL_FAILED, "could not set acl (%s) for" - "%s in dictionary", name, real_path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - size = ret; - goto done; + ret = dict_set_dynstr(dict, (char *)name, host_buf); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "could not set value" + " (%s) in dictionary", + host_buf); + GF_FREE(host_buf); + op_errno = ENOMEM; + goto out; } - if (loc->inode && name && - (strncmp (name, GF_XATTR_GET_REAL_FILENAME_KEY, - SLEN (GF_XATTR_GET_REAL_FILENAME_KEY)) == 0)) { - ret = posix_xattr_get_real_filename (frame, this, loc, - name, dict, xdata); - if (ret < 0) { - op_ret = -1; - op_errno = -ret; - if (op_errno == ENOENT) { - gf_msg_debug (this->name, 0, "Failed to get " - "real filename (%s, %s)", - loc->path, name); - } else { - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_GETTING_FILENAME_FAILED, - "Failed to get real filename (%s, %s):" - , loc->path, name); - } - goto out; - } + goto done; + } - size = ret; - goto done; - } - - if (loc->inode && name && !strcmp (name, GLUSTERFS_OPEN_FD_COUNT)) { - if (!fd_list_empty (loc->inode)) { - ret = dict_set_uint32 (dict, (char *)name, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "Failed to set " - "dictionary value for %s", name); - op_errno = ENOMEM; - goto out; - } - } else { - ret = dict_set_uint32 (dict, (char *)name, 0); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "Failed to set " - "dictionary value for %s", name); - op_errno = ENOMEM; - goto out; - } - } - goto done; + if (loc->inode && name && (strcmp(name, GF_XATTR_NODE_UUID_KEY) == 0) && + !gf_uuid_is_null(priv->glusterd_uuid)) { + size = gf_asprintf(&host_buf, "%s", uuid_utoa(priv->glusterd_uuid)); + if (size == -1) { + op_errno = ENOMEM; + goto out; } - if (loc->inode && name && (XATTR_IS_PATHINFO (name))) { - VALIDATE_OR_GOTO (this->private, out); - if (LOC_HAS_ABSPATH (loc)) { - MAKE_REAL_PATH (rpath, this, loc->path); - } else { - rpath = real_path; - } - size = gf_asprintf (&host_buf, "<POSIX(%s):%s:%s>", - priv->base_path, - ((priv->node_uuid_pathinfo && - !gf_uuid_is_null(priv->glusterd_uuid)) - ? uuid_utoa (priv->glusterd_uuid) - : priv->hostname), rpath); - if (size < 0) { - op_errno = ENOMEM; - goto out; - } - ret = dict_set_dynstr (dict, (char *)name, host_buf); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "could not set value" - " (%s) in dictionary", host_buf); - GF_FREE (host_buf); - op_errno = ENOMEM; - goto out; - } - - goto done; + ret = dict_set_dynstr(dict, GF_XATTR_NODE_UUID_KEY, host_buf); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_DICT_SET_FAILED, + "could not set value" + "(%s) in dictionary", + host_buf); + GF_FREE(host_buf); + op_errno = -ret; + goto out; + } + goto done; + } + + if (loc->inode && name && (strcmp(name, GFID_TO_PATH_KEY) == 0)) { + ret = inode_path(loc->inode, NULL, &path); + if (ret < 0) { + op_errno = -ret; + gf_msg(this->name, GF_LOG_WARNING, op_errno, + P_MSG_INODE_PATH_GET_FAILED, + "%s: could not get " + "inode path", + uuid_utoa(loc->inode->gfid)); + goto out; } - if (loc->inode && name && - (strcmp (name, GF_XATTR_NODE_UUID_KEY) == 0) - && !gf_uuid_is_null (priv->glusterd_uuid)) { - size = gf_asprintf (&host_buf, "%s", - uuid_utoa (priv->glusterd_uuid)); - if (size == -1) { - op_errno = ENOMEM; - goto out; - } - ret = dict_set_dynstr (dict, GF_XATTR_NODE_UUID_KEY, - host_buf); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, -ret, - P_MSG_DICT_SET_FAILED, "could not set value" - "(%s) in dictionary", host_buf); - GF_FREE (host_buf); - op_errno = -ret; - goto out; - } - goto done; + size = ret; + ret = dict_set_dynstr(dict, GFID_TO_PATH_KEY, path); + if (ret < 0) { + op_errno = ENOMEM; + GF_FREE(path); + goto out; } + goto done; + } - if (loc->inode && name && - (strcmp (name, GFID_TO_PATH_KEY) == 0)) { - ret = inode_path (loc->inode, NULL, &path); - if (ret < 0) { - op_errno = -ret; - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_INODE_PATH_GET_FAILED, - "%s: could not get " - "inode path", uuid_utoa (loc->inode->gfid)); - goto out; - } - - size = ret; - ret = dict_set_dynstr (dict, GFID_TO_PATH_KEY, path); - if (ret < 0) { - op_errno = ENOMEM; - GF_FREE (path); - goto out; - } - goto done; + if (loc->inode && name && (strcmp(name, GFID2PATH_VIRT_XATTR_KEY) == 0)) { + if (!priv->gfid2path) { + op_errno = ENOATTR; + op_ret = -1; + goto out; } - - if (loc->inode && name && - (strcmp (name, GFID2PATH_VIRT_XATTR_KEY) == 0)) { - if (!priv->gfid2path) { - op_errno = ENOATTR; - op_ret = -1; - goto out; - } - ret = posix_get_gfid2path (this, loc->inode, real_path, - &op_errno, dict); - if (ret < 0) { - op_ret = -1; - goto out; - } - size = ret; - goto done; + ret = posix_get_gfid2path(this, loc->inode, real_path, &op_errno, dict); + if (ret < 0) { + op_ret = -1; + goto out; } + size = ret; + goto done; + } - if (loc->inode && name - && (strcmp (name, GET_ANCESTRY_PATH_KEY) == 0)) { - int type = POSIX_ANCESTRY_PATH; - - op_ret = posix_get_ancestry (this, loc->inode, NULL, - &path, type, &op_errno, - xdata); - if (op_ret < 0) { - op_ret = -1; - op_errno = ENODATA; - goto out; - } - size = op_ret; - op_ret = dict_set_dynstr (dict, GET_ANCESTRY_PATH_KEY, path); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, -op_ret, - P_MSG_GET_KEY_VALUE_FAILED, "could not get " - "value for key (%s)", GET_ANCESTRY_PATH_KEY); - GF_FREE (path); - op_errno = ENOMEM; - goto out; - } + if (loc->inode && name && (strcmp(name, GET_ANCESTRY_PATH_KEY) == 0)) { + int type = POSIX_ANCESTRY_PATH; - goto done; + op_ret = posix_get_ancestry(this, loc->inode, NULL, &path, type, + &op_errno, xdata); + if (op_ret < 0) { + op_ret = -1; + op_errno = ENODATA; + goto out; } - - if (loc->inode && name - && (strncmp (name, GLUSTERFS_GET_OBJECT_SIGNATURE, - SLEN (GLUSTERFS_GET_OBJECT_SIGNATURE)) == 0)) { - op_ret = posix_get_objectsignature (real_path, dict); - if (op_ret < 0) { - op_errno = -op_ret; - goto out; - } - - goto done; + size = op_ret; + op_ret = dict_set_dynstr(dict, GET_ANCESTRY_PATH_KEY, path); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, -op_ret, + P_MSG_GET_KEY_VALUE_FAILED, + "could not get " + "value for key (%s)", + GET_ANCESTRY_PATH_KEY); + GF_FREE(path); + op_errno = ENOMEM; + goto out; + } + + goto done; + } + + if (loc->inode && name && + (strncmp(name, GLUSTERFS_GET_OBJECT_SIGNATURE, + SLEN(GLUSTERFS_GET_OBJECT_SIGNATURE)) == 0)) { + op_ret = posix_get_objectsignature(real_path, dict); + if (op_ret < 0) { + op_errno = -op_ret; + goto out; } - /* here allocate value_buf of 8192 bytes to avoid one extra getxattr - call,If buffer size is small to hold the xattr result then it will - allocate a new buffer value of required size and call getxattr again - */ + goto done; + } + + /* here allocate value_buf of 8192 bytes to avoid one extra getxattr + call,If buffer size is small to hold the xattr result then it will + allocate a new buffer value of required size and call getxattr again + */ - value_buf = alloca (XATTR_VAL_BUF_SIZE); - if (name) { - char *key = (char *)name; + value_buf = alloca(XATTR_VAL_BUF_SIZE); + if (name) { + char *key = (char *)name; - keybuffer = key; + keybuffer = key; #if defined(GF_DARWIN_HOST_OS_DISABLED) - if (priv->xattr_user_namespace == XATTR_STRIP) { - if (strncmp(key, "user.",5) == 0) { - key += 5; - gf_msg_debug (this->name, 0, "getxattr for file %s" - " stripping user key: %s -> %s", - real_path, keybuffer, key); - } - } + if (priv->xattr_user_namespace == XATTR_STRIP) { + if (strncmp(key, "user.", 5) == 0) { + key += 5; + gf_msg_debug(this->name, 0, + "getxattr for file %s" + " stripping user key: %s -> %s", + real_path, keybuffer, key); + } + } #endif - size = sys_lgetxattr (real_path, key, value_buf, - XATTR_VAL_BUF_SIZE-1); - if (size >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_XATTR_FAILED, - "getxattr failed due to overflow of buffer" - " on %s: %s ", real_path, key); - size = sys_lgetxattr (real_path, key, NULL, 0); - } - if (size == -1) { - op_errno = errno; - if ((op_errno == ENOTSUP) || - (op_errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - this->name, - GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting" - " brick with 'user_xattr' " - "flag)"); - } - if ((op_errno == ENOATTR) || - (op_errno == ENODATA)) { - gf_msg_debug (this->name, 0, - "No such attribute:%s for file %s", - key, real_path); - } else { - gf_msg (this->name, GF_LOG_ERROR, - op_errno, P_MSG_XATTR_FAILED, - "getxattr failed on %s: %s ", - real_path, key); - } - goto out; - } - } - value = GF_MALLOC (size + 1, gf_posix_mt_char); - if (!value) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - if (have_val) { - memcpy (value, value_buf, size); + size = sys_lgetxattr(real_path, key, value_buf, XATTR_VAL_BUF_SIZE - 1); + if (size >= 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, P_MSG_XATTR_FAILED, + "getxattr failed due to overflow of buffer" + " on %s: %s ", + real_path, key); + size = sys_lgetxattr(real_path, key, NULL, 0); + } + if (size == -1) { + op_errno = errno; + if ((op_errno == ENOTSUP) || (op_errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting" + " brick with 'user_xattr' " + "flag)"); + } + if ((op_errno == ENOATTR) || (op_errno == ENODATA)) { + gf_msg_debug(this->name, 0, + "No such attribute:%s for file %s", key, + real_path); } else { - bzero (value, size + 1); - size = sys_lgetxattr (real_path, key, value, size); - if (size == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, - "getxattr failed on %s: key = %s", - real_path, key); - GF_FREE (value); - goto out; - } - } - value [size] = '\0'; - op_ret = dict_set_dynptr (dict, key, value, size); - if (op_ret < 0) { - op_errno = -op_ret; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_DICT_SET_FAILED, "dict set operation " - "on %s for the key %s failed.", real_path, key); - GF_FREE (value); - goto out; + gf_msg(this->name, GF_LOG_ERROR, op_errno, + P_MSG_XATTR_FAILED, "getxattr failed on %s: %s ", + real_path, key); } + goto out; + } + } + value = GF_MALLOC(size + 1, gf_posix_mt_char); + if (!value) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + if (have_val) { + memcpy(value, value_buf, size); + } else { + bzero(value, size + 1); + size = sys_lgetxattr(real_path, key, value, size); + if (size == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on %s: key = %s", real_path, key); + GF_FREE(value); + goto out; + } + } + value[size] = '\0'; + op_ret = dict_set_dynptr(dict, key, value, size); + if (op_ret < 0) { + op_errno = -op_ret; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_DICT_SET_FAILED, + "dict set operation " + "on %s for the key %s failed.", + real_path, key); + GF_FREE(value); + goto out; + } + + goto done; + } + + have_val = _gf_false; + size = sys_llistxattr(real_path, value_buf, XATTR_VAL_BUF_SIZE - 1); + if (size > 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, P_MSG_XATTR_FAILED, + "listxattr failed due to overflow of buffer" + " on %s ", + real_path); + size = sys_llistxattr(real_path, NULL, 0); + } + if (size == -1) { + op_errno = errno; + if ((errno == ENOTSUP) || (errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting" + " brick with 'user_xattr' " + "flag)"); + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "listxattr failed on %s", real_path); + } + goto out; + } + if (size == 0) + goto done; + } + list = alloca(size); + if (!list) { + op_errno = errno; + goto out; + } + if (have_val) { + memcpy(list, value_buf, size); + } else { + size = sys_llistxattr(real_path, list, size); + if (size < 0) { + op_ret = -1; + op_errno = errno; + goto out; + } + } + remaining_size = size; + list_offset = 0; + keybuffer = alloca(XATTR_KEY_BUF_SIZE); + while (remaining_size > 0) { + keybuff_len = snprintf(keybuffer, XATTR_KEY_BUF_SIZE, "%s", + list + list_offset); + + ret = posix_handle_georep_xattrs(frame, keybuffer, NULL, _gf_false); + if (ret == -1) + goto ignore; - goto done; + ret = posix_handle_mdata_xattr(frame, keybuffer, &op_errno); + if (ret == -1) { + goto ignore; + } + + if (posix_is_gfid2path_xattr(keybuffer)) { + goto ignore; } have_val = _gf_false; - size = sys_llistxattr (real_path, value_buf, XATTR_VAL_BUF_SIZE-1); - if (size > 0) { - have_val = _gf_true; + size = sys_lgetxattr(real_path, keybuffer, value_buf, + XATTR_VAL_BUF_SIZE - 1); + if (size >= 0) { + have_val = _gf_true; } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_XATTR_FAILED, - "listxattr failed due to overflow of buffer" - " on %s ", real_path); - size = sys_llistxattr (real_path, NULL, 0); - } - if (size == -1) { - op_errno = errno; - if ((errno == ENOTSUP) || (errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting" - " brick with 'user_xattr' " - "flag)"); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, - "listxattr failed on %s", real_path); - } - goto out; - } - if (size == 0) - goto done; - } - list = alloca (size); - if (!list) { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, op_errno, P_MSG_XATTR_FAILED, + "getxattr failed due to overflow of" + " buffer on %s: %s ", + real_path, keybuffer); + size = sys_lgetxattr(real_path, keybuffer, NULL, 0); + } + if (size == -1) { op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on" + " %s: key = %s ", + real_path, keybuffer); goto out; + } + } + value = GF_MALLOC(size + 1, gf_posix_mt_char); + if (!value) { + op_errno = errno; + goto out; } if (have_val) { - memcpy (list, value_buf, size); + memcpy(value, value_buf, size); } else { - size = sys_llistxattr (real_path, list, size); - if (size < 0) { - op_ret = -1; - op_errno = errno; - goto out; - } + bzero(value, size + 1); + size = sys_lgetxattr(real_path, keybuffer, value, size); + if (size == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on" + " %s: key = %s ", + real_path, keybuffer); + GF_FREE(value); + goto out; + } } - remaining_size = size; - list_offset = 0; - keybuffer = alloca (XATTR_KEY_BUF_SIZE); - while (remaining_size > 0) { - keybuff_len = snprintf (keybuffer, XATTR_KEY_BUF_SIZE, "%s", - list + list_offset); - - ret = posix_handle_georep_xattrs (frame, keybuffer, NULL, - _gf_false); - if (ret == -1) - goto ignore; - - ret = posix_handle_mdata_xattr (frame, keybuffer, &op_errno); - if (ret == -1) { - goto ignore; - } - - if (posix_is_gfid2path_xattr (keybuffer)) { - goto ignore; - } - - have_val = _gf_false; - size = sys_lgetxattr (real_path, keybuffer, value_buf, - XATTR_VAL_BUF_SIZE-1); - if (size >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, op_errno, - P_MSG_XATTR_FAILED, - "getxattr failed due to overflow of" - " buffer on %s: %s ", real_path, - keybuffer); - size = sys_lgetxattr (real_path, keybuffer, - NULL, 0); - } - if (size == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "getxattr failed on" - " %s: key = %s ", real_path, keybuffer); - goto out; - } - } - value = GF_MALLOC (size + 1, gf_posix_mt_char); - if (!value) { - op_errno = errno; - goto out; - } - if (have_val) { - memcpy (value, value_buf, size); - } else { - bzero(value, size + 1); - size = sys_lgetxattr (real_path, keybuffer, value, size); - if (size == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "getxattr failed on" - " %s: key = %s ", real_path, keybuffer); - GF_FREE (value); - goto out; - } - } - value [size] = '\0'; + value[size] = '\0'; #ifdef GF_DARWIN_HOST_OS - /* The protocol expect namespace for now */ - char *newkey = NULL; - gf_add_prefix (XATTR_USER_PREFIX, keybuffer, &newkey); - keybuff_len = snprintf (keybuffer, sizeof(keybuffer), "%s", newkey); - GF_FREE (newkey); + /* The protocol expect namespace for now */ + char *newkey = NULL; + gf_add_prefix(XATTR_USER_PREFIX, keybuffer, &newkey); + keybuff_len = snprintf(keybuffer, sizeof(keybuffer), "%s", newkey); + GF_FREE(newkey); #endif - op_ret = dict_set_dynptr (dict, keybuffer, value, size); - if (op_ret < 0) { - op_errno = -op_ret; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_DICT_SET_FAILED, "dict set operation " - "on %s for the key %s failed.", real_path, - keybuffer); - GF_FREE (value); - goto out; - } + op_ret = dict_set_dynptr(dict, keybuffer, value, size); + if (op_ret < 0) { + op_errno = -op_ret; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_DICT_SET_FAILED, + "dict set operation " + "on %s for the key %s failed.", + real_path, keybuffer); + GF_FREE(value); + goto out; + } -ignore: - remaining_size -= keybuff_len + 1; - list_offset += keybuff_len + 1; + ignore: + remaining_size -= keybuff_len + 1; + list_offset += keybuff_len + 1; - } /* while (remaining_size > 0) */ + } /* while (remaining_size > 0) */ done: - op_ret = size; + op_ret = size; - if (dict) { - dict_del (dict, GFID_XATTR_KEY); - dict_del (dict, GF_XATTR_VOL_ID_KEY); - } + if (dict) { + dict_del(dict, GFID_XATTR_KEY); + dict_del(dict, GF_XATTR_VOL_ID_KEY); + } out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, NULL); + STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, NULL); - if (dict) { - dict_unref (dict); - } + if (dict) { + dict_unref(dict); + } - return 0; + return 0; } - int32_t -posix_fgetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +posix_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct posix_fd * pfd = NULL; - int _fd = -1; - int32_t list_offset = 0; - ssize_t size = 0; - size_t remaining_size = 0; - char * value = NULL; - char * list = NULL; - dict_t * dict = NULL; - int ret = -1; - char key[4096] = {0,}; - int key_len; - char *value_buf = NULL; - gf_boolean_t have_val = _gf_false; - - DECLARE_OLD_FS_ID_VAR; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - SET_FS_ID (frame->root->uid, frame->root->gid); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - op_ret = -1; - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + struct posix_fd *pfd = NULL; + int _fd = -1; + int32_t list_offset = 0; + ssize_t size = 0; + size_t remaining_size = 0; + char *value = NULL; + char *list = NULL; + dict_t *dict = NULL; + int ret = -1; + char key[4096] = { + 0, + }; + int key_len; + char *value_buf = NULL; + gf_boolean_t have_val = _gf_false; + + DECLARE_OLD_FS_ID_VAR; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + SET_FS_ID(frame->root->uid, frame->root->gid); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + op_ret = -1; + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; + } - _fd = pfd->fd; + _fd = pfd->fd; - /* Get the total size */ - dict = dict_new (); - if (!dict) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } + /* Get the total size */ + dict = dict_new(); + if (!dict) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } - if (name && !strcmp (name, GLUSTERFS_OPEN_FD_COUNT)) { - ret = dict_set_uint32 (dict, (char *)name, 1); - if (ret < 0) { - op_ret = -1; - size = -1; - op_errno = ENOMEM; - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_DICT_SET_FAILED, "Failed to set " - "dictionary value for %s", name); - goto out; - } - goto done; + if (name && !strcmp(name, GLUSTERFS_OPEN_FD_COUNT)) { + ret = dict_set_uint32(dict, (char *)name, 1); + if (ret < 0) { + op_ret = -1; + size = -1; + op_errno = ENOMEM; + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED, + "Failed to set " + "dictionary value for %s", + name); + goto out; + } + goto done; + } + + if (name && strncmp(name, GLUSTERFS_GET_OBJECT_SIGNATURE, + SLEN(GLUSTERFS_GET_OBJECT_SIGNATURE)) == 0) { + op_ret = posix_fdget_objectsignature(_fd, dict); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "posix_fdget_objectsignature failed"); + op_errno = -op_ret; + op_ret = -1; + size = -1; + goto out; } - if (name && strncmp (name, GLUSTERFS_GET_OBJECT_SIGNATURE, - SLEN (GLUSTERFS_GET_OBJECT_SIGNATURE)) == 0) { - op_ret = posix_fdget_objectsignature (_fd, dict); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "posix_fdget_objectsignature failed"); - op_errno = -op_ret; - op_ret = -1; - size = -1; - goto out; - } + goto done; + } - goto done; - } + /* here allocate value_buf of 8192 bytes to avoid one extra getxattr + call,If buffer size is small to hold the xattr result then it will + allocate a new buffer value of required size and call getxattr again + */ + value_buf = alloca(XATTR_VAL_BUF_SIZE); - /* here allocate value_buf of 8192 bytes to avoid one extra getxattr - call,If buffer size is small to hold the xattr result then it will - allocate a new buffer value of required size and call getxattr again - */ - value_buf = alloca (XATTR_VAL_BUF_SIZE); - - if (name) { - key_len = snprintf (key, sizeof (key), "%s", name); + if (name) { + key_len = snprintf(key, sizeof(key), "%s", name); #ifdef GF_DARWIN_HOST_OS - struct posix_private *priv = NULL; - priv = this->private; - if (priv->xattr_user_namespace == XATTR_STRIP) { - char *newkey = NULL; - gf_add_prefix (XATTR_USER_PREFIX, key, &newkey); - key_len = snprintf (key, sizeof (key), "%s", newkey); - GF_FREE (newkey); - } + struct posix_private *priv = NULL; + priv = this->private; + if (priv->xattr_user_namespace == XATTR_STRIP) { + char *newkey = NULL; + gf_add_prefix(XATTR_USER_PREFIX, key, &newkey); + key_len = snprintf(key, sizeof(key), "%s", newkey); + GF_FREE(newkey); + } #endif - size = sys_fgetxattr (_fd, key, value_buf, - XATTR_VAL_BUF_SIZE-1); - if (size >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_XATTR_FAILED, - "fgetxattr failed due to overflow of" - "buffer on %s ", key); - size = sys_fgetxattr (_fd, key, NULL, 0); - } - if (size == -1) { - op_errno = errno; - if (errno == ENODATA || errno == ENOATTR) { - gf_msg_debug (this->name, 0, "fgetxattr" - " failed on key %s (%s)", - key, strerror (op_errno)); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fgetxattr" - " failed on key %s", key); - } - goto done; - } - } - value = GF_MALLOC (size + 1, gf_posix_mt_char); - if (!value) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - if (have_val) { - memcpy (value, value_buf, size); + size = sys_fgetxattr(_fd, key, value_buf, XATTR_VAL_BUF_SIZE - 1); + if (size >= 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, P_MSG_XATTR_FAILED, + "fgetxattr failed due to overflow of" + "buffer on %s ", + key); + size = sys_fgetxattr(_fd, key, NULL, 0); + } + if (size == -1) { + op_errno = errno; + if (errno == ENODATA || errno == ENOATTR) { + gf_msg_debug(this->name, 0, + "fgetxattr" + " failed on key %s (%s)", + key, strerror(op_errno)); } else { - bzero (value, size + 1); - size = sys_fgetxattr (_fd, key, value, size); - if (size == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fgetxattr" - " failed on fd %p for the key %s ", - fd, key); - GF_FREE (value); - goto out; - } - } - - value [size] = '\0'; - op_ret = dict_set_dynptr (dict, key, value, size); - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_DICT_SET_FAILED, "dict set operation " - "on key %s failed", key); - GF_FREE (value); - goto out; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fgetxattr" + " failed on key %s", + key); } - goto done; + } } - size = sys_flistxattr (_fd, value_buf, XATTR_VAL_BUF_SIZE-1); - if (size > 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_XATTR_FAILED, - "listxattr failed due to overflow of buffer" - " on %p ", fd); - size = sys_flistxattr (_fd, NULL, 0); - } - if (size == -1) { - op_ret = -1; - op_errno = errno; - if ((errno == ENOTSUP) || (errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting " - "brick with 'user_xattr' flag)"); - } else { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "listxattr failed " - "on %p:", fd); - } - goto out; - } - if (size == 0) - goto done; + value = GF_MALLOC(size + 1, gf_posix_mt_char); + if (!value) { + op_ret = -1; + op_errno = ENOMEM; + goto out; } - list = alloca (size + 1); - if (!list) { + if (have_val) { + memcpy(value, value_buf, size); + } else { + bzero(value, size + 1); + size = sys_fgetxattr(_fd, key, value, size); + if (size == -1) { op_ret = -1; - op_errno = ENOMEM; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fgetxattr" + " failed on fd %p for the key %s ", + fd, key); + GF_FREE(value); goto out; + } } - if (have_val) - memcpy (list, value_buf, size); - else - size = sys_flistxattr (_fd, list, size); - - remaining_size = size; - list_offset = 0; - while (remaining_size > 0) { - if(*(list + list_offset) == '\0') - break; - - key_len = snprintf (key, sizeof (key), "%s", list + list_offset); - have_val = _gf_false; - size = sys_fgetxattr (_fd, key, value_buf, - XATTR_VAL_BUF_SIZE-1); - if (size >= 0) { - have_val = _gf_true; - } else { - if (errno == ERANGE) { - gf_msg (this->name, GF_LOG_INFO, errno, - P_MSG_XATTR_FAILED, - "fgetxattr failed due to overflow of buffer" - " on fd %p: for the key %s ", fd, key); - size = sys_fgetxattr (_fd, key, NULL, 0); - } - if (size == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fgetxattr failed " - "on fd %p for the key %s ", fd, key); - break; - } - } - value = GF_MALLOC (size + 1, gf_posix_mt_char); - if (!value) { - op_ret = -1; - op_errno = errno; - goto out; - } - if (have_val) { - memcpy (value, value_buf, size); - } else { - bzero (value, size + 1); - size = sys_fgetxattr (_fd, key, value, size); - if (size == -1) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "fgetxattr failed o" - "n the fd %p for the key %s ", fd, key); - GF_FREE (value); - break; - } - } - value [size] = '\0'; - - op_ret = dict_set_dynptr (dict, key, value, size); - if (op_ret) { - op_errno = -op_ret; - op_ret = -1; - gf_msg (this->name, GF_LOG_ERROR, 0, - P_MSG_DICT_SET_FAILED, "dict set operation " - "failed on key %s", key); - GF_FREE (value); - goto out; - } - remaining_size -= key_len + 1; - list_offset += key_len + 1; - } /* while (remaining_size > 0) */ + value[size] = '\0'; + op_ret = dict_set_dynptr(dict, key, value, size); + if (op_ret < 0) { + op_errno = -op_ret; + op_ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_DICT_SET_FAILED, + "dict set operation " + "on key %s failed", + key); + GF_FREE(value); + goto out; + } + + goto done; + } + size = sys_flistxattr(_fd, value_buf, XATTR_VAL_BUF_SIZE - 1); + if (size > 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, P_MSG_XATTR_FAILED, + "listxattr failed due to overflow of buffer" + " on %p ", + fd); + size = sys_flistxattr(_fd, NULL, 0); + } + if (size == -1) { + op_ret = -1; + op_errno = errno; + if ((errno == ENOTSUP) || (errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting " + "brick with 'user_xattr' flag)"); + } else { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "listxattr failed " + "on %p:", + fd); + } + goto out; + } + if (size == 0) + goto done; + } + list = alloca(size + 1); + if (!list) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + if (have_val) + memcpy(list, value_buf, size); + else + size = sys_flistxattr(_fd, list, size); + + remaining_size = size; + list_offset = 0; + while (remaining_size > 0) { + if (*(list + list_offset) == '\0') + break; + + key_len = snprintf(key, sizeof(key), "%s", list + list_offset); + have_val = _gf_false; + size = sys_fgetxattr(_fd, key, value_buf, XATTR_VAL_BUF_SIZE - 1); + if (size >= 0) { + have_val = _gf_true; + } else { + if (errno == ERANGE) { + gf_msg(this->name, GF_LOG_INFO, errno, P_MSG_XATTR_FAILED, + "fgetxattr failed due to overflow of buffer" + " on fd %p: for the key %s ", + fd, key); + size = sys_fgetxattr(_fd, key, NULL, 0); + } + if (size == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fgetxattr failed " + "on fd %p for the key %s ", + fd, key); + break; + } + } + value = GF_MALLOC(size + 1, gf_posix_mt_char); + if (!value) { + op_ret = -1; + op_errno = errno; + goto out; + } + if (have_val) { + memcpy(value, value_buf, size); + } else { + bzero(value, size + 1); + size = sys_fgetxattr(_fd, key, value, size); + if (size == -1) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "fgetxattr failed o" + "n the fd %p for the key %s ", + fd, key); + GF_FREE(value); + break; + } + } + value[size] = '\0'; + + op_ret = dict_set_dynptr(dict, key, value, size); + if (op_ret) { + op_errno = -op_ret; + op_ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, P_MSG_DICT_SET_FAILED, + "dict set operation " + "failed on key %s", + key); + GF_FREE(value); + goto out; + } + remaining_size -= key_len + 1; + list_offset += key_len + 1; + + } /* while (remaining_size > 0) */ done: - op_ret = size; + op_ret = size; - if (dict) { - dict_del (dict, GFID_XATTR_KEY); - dict_del (dict, GF_XATTR_VOL_ID_KEY); - } + if (dict) { + dict_del(dict, GFID_XATTR_KEY); + dict_del(dict, GF_XATTR_VOL_ID_KEY); + } out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, NULL); + STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, NULL); - if (dict) - dict_unref (dict); + if (dict) + dict_unref(dict); - return 0; + return 0; } static int -_handle_fsetxattr_keyvalue_pair (dict_t *d, char *k, data_t *v, - void *tmp) +_handle_fsetxattr_keyvalue_pair(dict_t *d, char *k, data_t *v, void *tmp) { - posix_xattr_filler_t *filler = NULL; + posix_xattr_filler_t *filler = NULL; - filler = tmp; + filler = tmp; - return posix_fhandle_pair (filler->frame, filler->this, filler->fdnum, - k, v, filler->flags, filler->stbuf, - filler->fd); + return posix_fhandle_pair(filler->frame, filler->this, filler->fdnum, k, v, + filler->flags, filler->stbuf, filler->fd); } int32_t -posix_fsetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *dict, int flags, dict_t *xdata) +posix_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int flags, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - struct posix_fd *pfd = NULL; - int _fd = -1; - int ret = -1; - struct iatt preop = {0,}; - struct iatt postop = {0,}; - dict_t *xattr = NULL; - posix_xattr_filler_t filler = {0,}; - struct posix_private *priv = NULL; - - DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - VALIDATE_OR_GOTO (dict, out); - - priv = this->private; - DISK_SPACE_CHECK_AND_GOTO (frame, priv, xdata, op_ret, op_errno, out); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL from fd=%p", fd); - goto out; - } - _fd = pfd->fd; + int32_t op_ret = -1; + int32_t op_errno = 0; + struct posix_fd *pfd = NULL; + int _fd = -1; + int ret = -1; + struct iatt preop = { + 0, + }; + struct iatt postop = { + 0, + }; + dict_t *xattr = NULL; + posix_xattr_filler_t filler = { + 0, + }; + struct posix_private *priv = NULL; + + DECLARE_OLD_FS_ID_VAR; + SET_FS_ID(frame->root->uid, frame->root->gid); + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + VALIDATE_OR_GOTO(dict, out); + + priv = this->private; + DISK_SPACE_CHECK_AND_GOTO(frame, priv, xdata, op_ret, op_errno, out); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; + } + _fd = pfd->fd; - ret = posix_fdstat (this, fd->inode, pfd->fd, &preop); - if (ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_FSTAT_FAILED, "fsetxattr (fstat)" - "failed on fd=%p", fd); - goto out; - } + ret = posix_fdstat(this, fd->inode, pfd->fd, &preop); + if (ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_FSTAT_FAILED, + "fsetxattr (fstat)" + "failed on fd=%p", + fd); + goto out; + } - dict_del (dict, GFID_XATTR_KEY); - dict_del (dict, GF_XATTR_VOL_ID_KEY); + dict_del(dict, GFID_XATTR_KEY); + dict_del(dict, GF_XATTR_VOL_ID_KEY); - filler.fdnum = _fd; - filler.this = this; - filler.frame = frame; - filler.stbuf = &preop; - filler.fd = fd; + filler.fdnum = _fd; + filler.this = this; + filler.frame = frame; + filler.stbuf = &preop; + filler.fd = fd; #ifdef GF_DARWIN_HOST_OS - filler.flags = map_xattr_flags(flags); + filler.flags = map_xattr_flags(flags); #else - filler.flags = flags; + filler.flags = flags; #endif - op_ret = dict_foreach (dict, _handle_fsetxattr_keyvalue_pair, - &filler); - if (op_ret < 0) { - op_errno = -op_ret; - op_ret = -1; - } + op_ret = dict_foreach(dict, _handle_fsetxattr_keyvalue_pair, &filler); + if (op_ret < 0) { + op_errno = -op_ret; + op_ret = -1; + } - if (!ret && xdata && dict_get (xdata, GLUSTERFS_DURABLE_OP)) { - op_ret = sys_fsync (_fd); - if (op_ret < 0) { - op_ret = -1; - op_errno = errno; - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_DURABILITY_REQ_NOT_SATISFIED, - "could not satisfy durability request: " - "reason "); - } + if (!ret && xdata && dict_get(xdata, GLUSTERFS_DURABLE_OP)) { + op_ret = sys_fsync(_fd); + if (op_ret < 0) { + op_ret = -1; + op_errno = errno; + gf_msg(this->name, GF_LOG_WARNING, errno, + P_MSG_DURABILITY_REQ_NOT_SATISFIED, + "could not satisfy durability request: " + "reason "); } + } - ret = posix_fdstat (this, fd->inode, pfd->fd, &postop); - if (ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_XATTR_FAILED, "fsetxattr (fstat)" - "failed on fd=%p", fd); - goto out; - } - xattr = dict_new (); - if (!xattr) - goto out; + ret = posix_fdstat(this, fd->inode, pfd->fd, &postop); + if (ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_XATTR_FAILED, + "fsetxattr (fstat)" + "failed on fd=%p", + fd); + goto out; + } + xattr = dict_new(); + if (!xattr) + goto out; - ret = posix_set_iatt_in_dict (xattr, &preop, &postop); + ret = posix_set_iatt_in_dict(xattr, &preop, &postop); out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xattr); + STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xattr); - if (xattr) - dict_unref (xattr); + if (xattr) + dict_unref(xattr); - return 0; + return 0; } int -_posix_remove_xattr (dict_t *dict, char *key, data_t *value, void *data) +_posix_remove_xattr(dict_t *dict, char *key, data_t *value, void *data) { - int32_t op_ret = 0; - xlator_t *this = NULL; - posix_xattr_filler_t *filler = NULL; + int32_t op_ret = 0; + xlator_t *this = NULL; + posix_xattr_filler_t *filler = NULL; - filler = (posix_xattr_filler_t *) data; - this = filler->this; + filler = (posix_xattr_filler_t *)data; + this = filler->this; #ifdef GF_DARWIN_HOST_OS - struct posix_private *priv = NULL; - priv = (struct posix_private *) this->private; - char *newkey = NULL; - if (priv->xattr_user_namespace == XATTR_STRIP) { - gf_remove_prefix (XATTR_USER_PREFIX, key, &newkey); - gf_msg_debug ("remove_xattr", 0, "key %s => %s" , key, - newkey); - key = newkey; - } + struct posix_private *priv = NULL; + priv = (struct posix_private *)this->private; + char *newkey = NULL; + if (priv->xattr_user_namespace == XATTR_STRIP) { + gf_remove_prefix(XATTR_USER_PREFIX, key, &newkey); + gf_msg_debug("remove_xattr", 0, "key %s => %s", key, newkey); + key = newkey; + } #endif /* Bulk remove xattr is internal fop in gluster. Some of the xattrs may * have special behavior. Ex: removexattr("posix.system_acl_access"), @@ -3855,243 +3892,236 @@ _posix_remove_xattr (dict_t *dict, char *key, data_t *value, void *data) * treated as success. */ - if (filler->real_path) - op_ret = sys_lremovexattr (filler->real_path, key); - else - op_ret = sys_fremovexattr (filler->fdnum, key); - - if (op_ret == -1) { - if (errno == ENODATA || errno == ENOATTR) - op_ret = 0; - } - - if (op_ret == -1) { - filler->op_errno = errno; - if (errno != ENOATTR && errno != ENODATA && errno != EPERM) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "removexattr failed on " - "file/dir %s with gfid: %s (for %s)", - filler->real_path?filler->real_path:"", - uuid_utoa (filler->inode->gfid), key); - } - } + if (filler->real_path) + op_ret = sys_lremovexattr(filler->real_path, key); + else + op_ret = sys_fremovexattr(filler->fdnum, key); + + if (op_ret == -1) { + if (errno == ENODATA || errno == ENOATTR) + op_ret = 0; + } + + if (op_ret == -1) { + filler->op_errno = errno; + if (errno != ENOATTR && errno != ENODATA && errno != EPERM) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "removexattr failed on " + "file/dir %s with gfid: %s (for %s)", + filler->real_path ? filler->real_path : "", + uuid_utoa(filler->inode->gfid), key); + } + } #ifdef GF_DARWIN_HOST_OS - GF_FREE(newkey); + GF_FREE(newkey); #endif - return op_ret; + return op_ret; } int -posix_common_removexattr (call_frame_t *frame, loc_t *loc, fd_t *fd, - const char *name, dict_t *xdata, int *op_errno, - dict_t **xdata_rsp) +posix_common_removexattr(call_frame_t *frame, loc_t *loc, fd_t *fd, + const char *name, dict_t *xdata, int *op_errno, + dict_t **xdata_rsp) { - gf_boolean_t bulk_removexattr = _gf_false; - gf_boolean_t disallow = _gf_false; - char *real_path = NULL; - struct posix_fd *pfd = NULL; - int op_ret = 0; - struct iatt preop = {0,}; - struct iatt postop = {0,}; - int ret = 0; - int _fd = -1; - xlator_t *this = frame->this; - inode_t *inode = NULL; - posix_xattr_filler_t filler = {0}; - - DECLARE_OLD_FS_ID_VAR; - - SET_FS_ID (frame->root->uid, frame->root->gid); - - if (loc) { - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_ret = -1; - *op_errno = ESTALE; - goto out; - } - inode = loc->inode; - } else { - op_ret = posix_fd_ctx_get (fd, this, &pfd, op_errno); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, *op_errno, - P_MSG_PFD_NULL, "pfd is NULL from fd=%p", fd); - goto out; - } - _fd = pfd->fd; - inode = fd->inode; + gf_boolean_t bulk_removexattr = _gf_false; + gf_boolean_t disallow = _gf_false; + char *real_path = NULL; + struct posix_fd *pfd = NULL; + int op_ret = 0; + struct iatt preop = { + 0, + }; + struct iatt postop = { + 0, + }; + int ret = 0; + int _fd = -1; + xlator_t *this = frame->this; + inode_t *inode = NULL; + posix_xattr_filler_t filler = {0}; + + DECLARE_OLD_FS_ID_VAR; + + SET_FS_ID(frame->root->uid, frame->root->gid); + + if (loc) { + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + op_ret = -1; + *op_errno = ESTALE; + goto out; } - - if (posix_is_gfid2path_xattr (name)) { - op_ret = -1; - *op_errno = ENOATTR; - goto out; + inode = loc->inode; + } else { + op_ret = posix_fd_ctx_get(fd, this, &pfd, op_errno); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, *op_errno, P_MSG_PFD_NULL, + "pfd is NULL from fd=%p", fd); + goto out; } + _fd = pfd->fd; + inode = fd->inode; + } + if (posix_is_gfid2path_xattr(name)) { + op_ret = -1; + *op_errno = ENOATTR; + goto out; + } + + if (loc) + ret = posix_pstat(this, inode, loc->gfid, real_path, &preop, _gf_false); + else + ret = posix_fdstat(this, inode, _fd, &preop); + + if (gf_get_index_by_elem(disallow_removexattrs, (char *)name) >= 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_NOT_REMOVED, + "Remove xattr called on %s for file/dir %s with gfid: " + "%s", + name, real_path ? real_path : "", uuid_utoa(inode->gfid)); + op_ret = -1; + *op_errno = EPERM; + goto out; + } else if (posix_is_bulk_removexattr((char *)name, xdata)) { + bulk_removexattr = _gf_true; + (void)dict_has_key_from_array(xdata, disallow_removexattrs, &disallow); + if (disallow) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_NOT_REMOVED, + "Bulk removexattr has keys that shouldn't be " + "removed for file/dir %s with gfid: %s", + real_path ? real_path : "", uuid_utoa(inode->gfid)); + op_ret = -1; + *op_errno = EPERM; + goto out; + } + } + + if (bulk_removexattr) { + filler.real_path = real_path; + filler.this = this; + filler.fdnum = _fd; + filler.inode = inode; + op_ret = dict_foreach(xdata, _posix_remove_xattr, &filler); + if (op_ret) { + *op_errno = filler.op_errno; + goto out; + } + } else { if (loc) - ret = posix_pstat(this, inode, loc->gfid, real_path, - &preop, _gf_false); + op_ret = sys_lremovexattr(real_path, name); else - ret = posix_fdstat (this, inode, _fd, &preop); - - if (gf_get_index_by_elem (disallow_removexattrs, (char *)name) >= 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_NOT_REMOVED, - "Remove xattr called on %s for file/dir %s with gfid: " - "%s", name, real_path?real_path:"", - uuid_utoa(inode->gfid)); - op_ret = -1; - *op_errno = EPERM; - goto out; - } else if (posix_is_bulk_removexattr ((char *)name, xdata)) { - bulk_removexattr = _gf_true; - (void) dict_has_key_from_array (xdata, disallow_removexattrs, - &disallow); - if (disallow) { - gf_msg (this->name, GF_LOG_WARNING, 0, - P_MSG_XATTR_NOT_REMOVED, - "Bulk removexattr has keys that shouldn't be " - "removed for file/dir %s with gfid: %s", - real_path?real_path:"", uuid_utoa(inode->gfid)); - op_ret = -1; - *op_errno = EPERM; - goto out; - } - } - - if (bulk_removexattr) { - filler.real_path = real_path; - filler.this = this; - filler.fdnum = _fd; - filler.inode = inode; - op_ret = dict_foreach (xdata, _posix_remove_xattr, &filler); - if (op_ret) { - *op_errno = filler.op_errno; - goto out; - } - } else { - if (loc) - op_ret = sys_lremovexattr (real_path, name); - else - op_ret = sys_fremovexattr (_fd, name); - if (op_ret == -1) { - *op_errno = errno; - if (*op_errno != ENOATTR && *op_errno != ENODATA && - *op_errno != EPERM) { - gf_msg (this->name, GF_LOG_ERROR, *op_errno, - P_MSG_XATTR_FAILED, - "removexattr on %s with gfid %s " - "(for %s)", real_path, - uuid_utoa (inode->gfid), name); - } - goto out; - } - } - - if (loc) { - posix_set_ctime (frame, this, real_path, -1, inode, NULL); - ret = posix_pstat(this, inode, loc->gfid, real_path, &postop, - _gf_false); - } else { - posix_set_ctime (frame, this, NULL, _fd, inode, NULL); - ret = posix_fdstat (this, inode, _fd, &postop); - } - if (ret) - goto out; - *xdata_rsp = dict_new(); - if (!*xdata_rsp) - goto out; + op_ret = sys_fremovexattr(_fd, name); + if (op_ret == -1) { + *op_errno = errno; + if (*op_errno != ENOATTR && *op_errno != ENODATA && + *op_errno != EPERM) { + gf_msg(this->name, GF_LOG_ERROR, *op_errno, P_MSG_XATTR_FAILED, + "removexattr on %s with gfid %s " + "(for %s)", + real_path, uuid_utoa(inode->gfid), name); + } + goto out; + } + } + + if (loc) { + posix_set_ctime(frame, this, real_path, -1, inode, NULL); + ret = posix_pstat(this, inode, loc->gfid, real_path, &postop, + _gf_false); + } else { + posix_set_ctime(frame, this, NULL, _fd, inode, NULL); + ret = posix_fdstat(this, inode, _fd, &postop); + } + if (ret) + goto out; + *xdata_rsp = dict_new(); + if (!*xdata_rsp) + goto out; - ret = posix_set_iatt_in_dict (*xdata_rsp, &preop, &postop); + ret = posix_set_iatt_in_dict(*xdata_rsp, &preop, &postop); - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); - return op_ret; + SET_TO_OLD_FS_ID(); + return op_ret; } int32_t -posix_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +posix_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - int op_ret = -1; - int op_errno = EINVAL; - dict_t *xdata_rsp = NULL; + int op_ret = -1; + int op_errno = EINVAL; + dict_t *xdata_rsp = NULL; - VALIDATE_OR_GOTO (loc, out); + VALIDATE_OR_GOTO(loc, out); - op_ret = posix_common_removexattr (frame, loc, NULL, name, xdata, - &op_errno, &xdata_rsp); + op_ret = posix_common_removexattr(frame, loc, NULL, name, xdata, &op_errno, + &xdata_rsp); out: - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata_rsp); + STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata_rsp); - if (xdata_rsp) - dict_unref (xdata_rsp); + if (xdata_rsp) + dict_unref(xdata_rsp); - return 0; + return 0; } int32_t -posix_fremovexattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +posix_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - dict_t *xdata_rsp = NULL; + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + dict_t *xdata_rsp = NULL; - VALIDATE_OR_GOTO (fd, out); + VALIDATE_OR_GOTO(fd, out); - op_ret = posix_common_removexattr (frame, NULL, fd, name, xdata, - &op_errno, &xdata_rsp); + op_ret = posix_common_removexattr(frame, NULL, fd, name, xdata, &op_errno, + &xdata_rsp); out: - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata_rsp); + STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata_rsp); - if (xdata_rsp) - dict_unref (xdata_rsp); + if (xdata_rsp) + dict_unref(xdata_rsp); - return 0; + return 0; } - int32_t -posix_fsyncdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, int datasync, dict_t *xdata) +posix_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int ret = -1; - struct posix_fd *pfd = NULL; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + int ret = -1; + struct posix_fd *pfd = NULL; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + goto out; + } - op_ret = 0; + op_ret = 0; out: - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, NULL); + STACK_UNWIND_STRICT(fsyncdir, frame, op_ret, op_errno, NULL); - return 0; + return 0; } - void -posix_print_xattr (dict_t *this, - char *key, - data_t *value, - void *data) +posix_print_xattr(dict_t *this, char *key, data_t *value, void *data) { - gf_msg_debug ("posix", 0, - "(key/val) = (%s/%d)", key, data_to_int32 (value)); + gf_msg_debug("posix", 0, "(key/val) = (%s/%d)", key, data_to_int32(value)); } - /** * add_array - add two arrays of 32-bit numbers (stored in network byte order) * dest = dest + src @@ -4100,26 +4130,25 @@ posix_print_xattr (dict_t *this, */ static void -__add_array (int32_t *dest, int32_t *src, int count) +__add_array(int32_t *dest, int32_t *src, int count) { - int i = 0; - int32_t destval = 0; - for (i = 0; i < count; i++) { - destval = ntoh32 (dest[i]); - dest[i] = hton32 (destval + ntoh32 (src[i])); - } + int i = 0; + int32_t destval = 0; + for (i = 0; i < count; i++) { + destval = ntoh32(dest[i]); + dest[i] = hton32(destval + ntoh32(src[i])); + } } static void -__add_long_array (int64_t *dest, int64_t *src, int count) +__add_long_array(int64_t *dest, int64_t *src, int count) { - int i = 0; - for (i = 0; i < count; i++) { - dest[i] = hton64 (ntoh64 (dest[i]) + ntoh64 (src[i])); - } + int i = 0; + for (i = 0; i < count; i++) { + dest[i] = hton64(ntoh64(dest[i]) + ntoh64(src[i])); + } } - /* functions: __add_array_with_default __add_long_array_with_default @@ -4181,240 +4210,222 @@ __add_long_array (int64_t *dest, int64_t *src, int count) }; */ static void -__add_array_with_default (int32_t *dest, int32_t *src, int count) +__add_array_with_default(int32_t *dest, int32_t *src, int count) { - int i = 0; - int32_t destval = 0; - - for (i = 0; i < count; i++) { - destval = ntoh32 (dest[i]); - if (destval == 0) - dest[i] = hton32 (ntoh32 (src[i]) + - ntoh32 (src[count + i])); - else - dest[i] = hton32 (destval + ntoh32 (src[i])); - } + int i = 0; + int32_t destval = 0; + + for (i = 0; i < count; i++) { + destval = ntoh32(dest[i]); + if (destval == 0) + dest[i] = hton32(ntoh32(src[i]) + ntoh32(src[count + i])); + else + dest[i] = hton32(destval + ntoh32(src[i])); + } } static void -__add_long_array_with_default (int64_t *dest, int64_t *src, int count) +__add_long_array_with_default(int64_t *dest, int64_t *src, int count) { - int i = 0; - int64_t destval = 0; - - for (i = 0; i < count; i++) { - destval = ntoh64 (dest[i]); - if (destval == 0) - dest[i] = hton64 (ntoh64 (src[i]) + - ntoh64 (src[i + count])); - else - dest[i] = hton64 (destval + ntoh64 (src[i])); - } + int i = 0; + int64_t destval = 0; + + for (i = 0; i < count; i++) { + destval = ntoh64(dest[i]); + if (destval == 0) + dest[i] = hton64(ntoh64(src[i]) + ntoh64(src[i + count])); + else + dest[i] = hton64(destval + ntoh64(src[i])); + } } static int -_posix_handle_xattr_keyvalue_pair (dict_t *d, char *k, data_t *v, - void *tmp) +_posix_handle_xattr_keyvalue_pair(dict_t *d, char *k, data_t *v, void *tmp) { - int size = 0; - int count = 0; - int op_ret = 0; - int op_errno = 0; - gf_xattrop_flags_t optype = 0; - char *array = NULL; - char *dst_data = NULL; - inode_t *inode = NULL; - xlator_t *this = NULL; - posix_xattr_filler_t *filler = NULL; - posix_inode_ctx_t *ctx = NULL; - - filler = tmp; - - optype = (gf_xattrop_flags_t)(filler->flags); - this = filler->this; - inode = filler->inode; - count = v->len; - if (optype == GF_XATTROP_ADD_ARRAY_WITH_DEFAULT || - optype == GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT) - count = count / 2; - - array = GF_CALLOC (count, sizeof (char), gf_posix_mt_char); + int size = 0; + int count = 0; + int op_ret = 0; + int op_errno = 0; + gf_xattrop_flags_t optype = 0; + char *array = NULL; + char *dst_data = NULL; + inode_t *inode = NULL; + xlator_t *this = NULL; + posix_xattr_filler_t *filler = NULL; + posix_inode_ctx_t *ctx = NULL; + + filler = tmp; + + optype = (gf_xattrop_flags_t)(filler->flags); + this = filler->this; + inode = filler->inode; + count = v->len; + if (optype == GF_XATTROP_ADD_ARRAY_WITH_DEFAULT || + optype == GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT) + count = count / 2; + + array = GF_CALLOC(count, sizeof(char), gf_posix_mt_char); #ifdef GF_DARWIN_HOST_OS - struct posix_private *priv = NULL; - priv = this->private; - if (priv->xattr_user_namespace == XATTR_STRIP) { - if (strncmp(k, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) == 0) { - k += XATTR_USER_PREFIX_LEN; - } + struct posix_private *priv = NULL; + priv = this->private; + if (priv->xattr_user_namespace == XATTR_STRIP) { + if (strncmp(k, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) == 0) { + k += XATTR_USER_PREFIX_LEN; } + } #endif - op_ret = posix_inode_ctx_get_all (inode, this, &ctx); - if (op_ret < 0) { - op_errno = ENOMEM; - goto out; + op_ret = posix_inode_ctx_get_all(inode, this, &ctx); + if (op_ret < 0) { + op_errno = ENOMEM; + goto out; + } + + pthread_mutex_lock(&ctx->xattrop_lock); + { + if (filler->real_path) { + size = sys_lgetxattr(filler->real_path, k, (char *)array, count); + } else { + size = sys_fgetxattr(filler->fdnum, k, (char *)array, count); } - pthread_mutex_lock (&ctx->xattrop_lock); - { - if (filler->real_path) { - size = sys_lgetxattr (filler->real_path, k, - (char *)array, count); - } else { - size = sys_fgetxattr (filler->fdnum, k, (char *)array, - count); - } + op_errno = errno; + if ((size == -1) && (op_errno != ENODATA) && (op_errno != ENOATTR)) { + if (op_errno == ENOTSUP) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported by filesystem"); + } else if (op_errno != ENOENT || + !posix_special_xattr(marker_xattrs, k)) { + if (filler->real_path) + gf_msg(this->name, fop_log_level(GF_FOP_XATTROP, op_errno), + op_errno, P_MSG_XATTR_FAILED, + "getxattr failed on %s while " + "doing xattrop: Key:%s ", + filler->real_path, k); + else + gf_msg( + this->name, GF_LOG_ERROR, op_errno, P_MSG_XATTR_FAILED, + "fgetxattr failed on gfid=%s " + "while doing xattrop: " + "Key:%s (%s)", + uuid_utoa(filler->inode->gfid), k, strerror(op_errno)); + } + + op_ret = -1; + goto unlock; + } + + if (size == -1 && optype == GF_XATTROP_GET_AND_SET) { + GF_FREE(array); + array = NULL; + } + + /* We only write back the xattr if it has been really modified + * (i.e. v->data is not all 0's). Otherwise we return its value + * but we don't update anything. + * + * If the xattr does not exist, a value of all 0's is returned + * without creating it. */ + size = count; + if (optype != GF_XATTROP_GET_AND_SET && + mem_0filled(v->data, v->len) == 0) + goto unlock; + + dst_data = array; + switch (optype) { + case GF_XATTROP_ADD_ARRAY: + __add_array((int32_t *)array, (int32_t *)v->data, count / 4); + break; - op_errno = errno; - if ((size == -1) && (op_errno != ENODATA) && - (op_errno != ENOATTR)) { - if (op_errno == ENOTSUP) { - GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported by filesystem"); - } else if (op_errno != ENOENT || - !posix_special_xattr (marker_xattrs, - k)) { - if (filler->real_path) - gf_msg (this->name, fop_log_level (GF_FOP_XATTROP, - op_errno), op_errno, P_MSG_XATTR_FAILED, - "getxattr failed on %s while " - "doing xattrop: Key:%s ", - filler->real_path, k); - else - gf_msg (this->name, GF_LOG_ERROR, - op_errno, P_MSG_XATTR_FAILED, - "fgetxattr failed on gfid=%s " - "while doing xattrop: " - "Key:%s (%s)", - uuid_utoa (filler->inode->gfid), - k, strerror (op_errno)); - } - - op_ret = -1; - goto unlock; - } + case GF_XATTROP_ADD_ARRAY64: + __add_long_array((int64_t *)array, (int64_t *)v->data, + count / 8); + break; - if (size == -1 && optype == GF_XATTROP_GET_AND_SET) { - GF_FREE (array); - array = NULL; - } + case GF_XATTROP_ADD_ARRAY_WITH_DEFAULT: + __add_array_with_default((int32_t *)array, (int32_t *)v->data, + count / 4); + break; - /* We only write back the xattr if it has been really modified - * (i.e. v->data is not all 0's). Otherwise we return its value - * but we don't update anything. - * - * If the xattr does not exist, a value of all 0's is returned - * without creating it. */ - size = count; - if (optype != GF_XATTROP_GET_AND_SET && - mem_0filled(v->data, v->len) == 0) - goto unlock; - - dst_data = array; - switch (optype) { - - case GF_XATTROP_ADD_ARRAY: - __add_array ((int32_t *) array, - (int32_t *) v->data, count / 4); - break; - - case GF_XATTROP_ADD_ARRAY64: - __add_long_array ((int64_t *) array, - (int64_t *) v->data, - count / 8); - break; - - case GF_XATTROP_ADD_ARRAY_WITH_DEFAULT: - __add_array_with_default ((int32_t *) array, - (int32_t *) v->data, - count / 4); - break; - - case GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT: - __add_long_array_with_default ((int64_t *) array, - (int64_t *) v->data, - count / 8); - break; - - case GF_XATTROP_GET_AND_SET: - dst_data = v->data; - break; - - default: - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - P_MSG_UNKNOWN_OP, "Unknown xattrop type (%d)" - " on %s. Please send a bug report to " - "gluster-devel@gluster.org", optype, - filler->real_path); - op_ret = -1; - op_errno = EINVAL; - goto unlock; - } + case GF_XATTROP_ADD_ARRAY64_WITH_DEFAULT: + __add_long_array_with_default((int64_t *)array, + (int64_t *)v->data, count / 8); + break; - if (filler->real_path) { - size = sys_lsetxattr (filler->real_path, k, - dst_data, count, 0); - } else { - size = sys_fsetxattr (filler->fdnum, k, - (char *)dst_data, - count, 0); - } - op_errno = errno; + case GF_XATTROP_GET_AND_SET: + dst_data = v->data; + break; + + default: + gf_msg(this->name, GF_LOG_ERROR, EINVAL, P_MSG_UNKNOWN_OP, + "Unknown xattrop type (%d)" + " on %s. Please send a bug report to " + "gluster-devel@gluster.org", + optype, filler->real_path); + op_ret = -1; + op_errno = EINVAL; + goto unlock; } + + if (filler->real_path) { + size = sys_lsetxattr(filler->real_path, k, dst_data, count, 0); + } else { + size = sys_fsetxattr(filler->fdnum, k, (char *)dst_data, count, 0); + } + op_errno = errno; + } unlock: - pthread_mutex_unlock (&ctx->xattrop_lock); + pthread_mutex_unlock(&ctx->xattrop_lock); - if (op_ret == -1) - goto out; + if (op_ret == -1) + goto out; - if (size == -1) { - if (filler->real_path) - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_XATTR_FAILED, "setxattr failed on %s " - "while doing xattrop: key=%s", - filler->real_path, k); - else - gf_msg (this->name, GF_LOG_ERROR, op_errno, - P_MSG_XATTR_FAILED, - "fsetxattr failed on gfid=%s while doing " - "xattrop: key=%s (%s)", - uuid_utoa (filler->inode->gfid), - k, strerror (op_errno)); - op_ret = -1; - goto out; - } else if (array) { - op_ret = dict_set_bin (filler->xattr, k, array, count); - if (op_ret) { - if (filler->real_path) - gf_msg_debug (this->name, 0, - "dict_set_bin failed (path=%s): " - "key=%s (%s)", filler->real_path, - k, strerror (-size)); - else - gf_msg_debug (this->name, 0, - "dict_set_bin failed (gfid=%s): " - "key=%s (%s)", - uuid_utoa (filler->inode->gfid), - k, strerror (-size)); - - op_ret = -1; - op_errno = EINVAL; - GF_FREE (array); - goto out; - } - array = NULL; - } + if (size == -1) { + if (filler->real_path) + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_XATTR_FAILED, + "setxattr failed on %s " + "while doing xattrop: key=%s", + filler->real_path, k); + else + gf_msg(this->name, GF_LOG_ERROR, op_errno, P_MSG_XATTR_FAILED, + "fsetxattr failed on gfid=%s while doing " + "xattrop: key=%s (%s)", + uuid_utoa(filler->inode->gfid), k, strerror(op_errno)); + op_ret = -1; + goto out; + } else if (array) { + op_ret = dict_set_bin(filler->xattr, k, array, count); + if (op_ret) { + if (filler->real_path) + gf_msg_debug(this->name, 0, + "dict_set_bin failed (path=%s): " + "key=%s (%s)", + filler->real_path, k, strerror(-size)); + else + gf_msg_debug(this->name, 0, + "dict_set_bin failed (gfid=%s): " + "key=%s (%s)", + uuid_utoa(filler->inode->gfid), k, + strerror(-size)); + + op_ret = -1; + op_errno = EINVAL; + GF_FREE(array); + goto out; + } + array = NULL; + } out: - if (op_ret < 0) - filler->op_errno = op_errno; + if (op_ret < 0) + filler->op_errno = op_errno; - if (array) - GF_FREE (array); + if (array) + GF_FREE(array); - return op_ret; + return op_ret; } /** @@ -4425,997 +4436,987 @@ out: */ int -do_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, - gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) +do_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { - int op_ret = 0; - int op_errno = 0; - int _fd = -1; - char *real_path = NULL; - struct posix_fd *pfd = NULL; - inode_t *inode = NULL; - posix_xattr_filler_t filler = {0,}; - dict_t *xattr_rsp = NULL; - dict_t *xdata_rsp = NULL; - struct iatt stbuf = {0}; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (xattr, out); - VALIDATE_OR_GOTO (this, out); - - if (fd) { - op_ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, - fop_log_level(GF_FOP_FXATTROP, op_errno), - P_MSG_PFD_GET_FAILED, "failed to get pfd from" - " fd=%p", fd); - goto out; - } - _fd = pfd->fd; - } - - if (loc && !gf_uuid_is_null (loc->gfid)) { - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_ret = -1; - op_errno = ESTALE; - goto out; - } - } - - if (real_path) { - inode = loc->inode; - } else if (fd) { - inode = fd->inode; + int op_ret = 0; + int op_errno = 0; + int _fd = -1; + char *real_path = NULL; + struct posix_fd *pfd = NULL; + inode_t *inode = NULL; + posix_xattr_filler_t filler = { + 0, + }; + dict_t *xattr_rsp = NULL; + dict_t *xdata_rsp = NULL; + struct iatt stbuf = {0}; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(xattr, out); + VALIDATE_OR_GOTO(this, out); + + if (fd) { + op_ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, + fop_log_level(GF_FOP_FXATTROP, op_errno), + P_MSG_PFD_GET_FAILED, + "failed to get pfd from" + " fd=%p", + fd); + goto out; } + _fd = pfd->fd; + } - xattr_rsp = dict_new (); - if (xattr_rsp == NULL) { - op_ret = -1; - op_errno = ENOMEM; - goto out; + if (loc && !gf_uuid_is_null(loc->gfid)) { + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + op_ret = -1; + op_errno = ESTALE; + goto out; } + } - filler.this = this; - filler.fdnum = _fd; - filler.real_path = real_path; - filler.flags = (int)optype; - filler.inode = inode; - filler.xattr = xattr_rsp; + if (real_path) { + inode = loc->inode; + } else if (fd) { + inode = fd->inode; + } - op_ret = dict_foreach (xattr, _posix_handle_xattr_keyvalue_pair, - &filler); - op_errno = filler.op_errno; - if (op_ret < 0) - goto out; + xattr_rsp = dict_new(); + if (xattr_rsp == NULL) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } + + filler.this = this; + filler.fdnum = _fd; + filler.real_path = real_path; + filler.flags = (int)optype; + filler.inode = inode; + filler.xattr = xattr_rsp; + + op_ret = dict_foreach(xattr, _posix_handle_xattr_keyvalue_pair, &filler); + op_errno = filler.op_errno; + if (op_ret < 0) + goto out; - if (!xdata) - goto out; + if (!xdata) + goto out; - if (fd) { - op_ret = posix_fdstat (this, inode, _fd, &stbuf); - } else { - op_ret = posix_pstat (this, inode, inode->gfid, real_path, - &stbuf, _gf_false); - } - if (op_ret < 0) { - op_errno = errno; - goto out; - } - xdata_rsp = posix_xattr_fill (this, real_path, loc, fd, _fd, - xdata, &stbuf); - if (!xdata_rsp) { - op_ret = -1; - op_errno = ENOMEM; - } - posix_set_mode_in_dict (xdata, xdata_rsp, &stbuf); + if (fd) { + op_ret = posix_fdstat(this, inode, _fd, &stbuf); + } else { + op_ret = posix_pstat(this, inode, inode->gfid, real_path, &stbuf, + _gf_false); + } + if (op_ret < 0) { + op_errno = errno; + goto out; + } + xdata_rsp = posix_xattr_fill(this, real_path, loc, fd, _fd, xdata, &stbuf); + if (!xdata_rsp) { + op_ret = -1; + op_errno = ENOMEM; + } + posix_set_mode_in_dict(xdata, xdata_rsp, &stbuf); out: - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, xattr_rsp, - xdata_rsp); + STACK_UNWIND_STRICT(xattrop, frame, op_ret, op_errno, xattr_rsp, xdata_rsp); - if (xattr_rsp) - dict_unref (xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); - if (xdata_rsp) - dict_unref (xdata_rsp); - return 0; + if (xdata_rsp) + dict_unref(xdata_rsp); + return 0; } - int -posix_xattrop (call_frame_t *frame, xlator_t *this, - loc_t *loc, gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) +posix_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { - do_xattrop (frame, this, loc, NULL, optype, xattr, xdata); - return 0; + do_xattrop(frame, this, loc, NULL, optype, xattr, xdata); + return 0; } - int -posix_fxattrop (call_frame_t *frame, xlator_t *this, - fd_t *fd, gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) +posix_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { - do_xattrop (frame, this, NULL, fd, optype, xattr, xdata); - return 0; + do_xattrop(frame, this, NULL, fd, optype, xattr, xdata); + return 0; } int -posix_access (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t mask, dict_t *xdata) +posix_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - char *real_path = NULL; + int32_t op_ret = -1; + int32_t op_errno = 0; + char *real_path = NULL; - DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); + DECLARE_OLD_FS_ID_VAR; + SET_FS_ID(frame->root->uid, frame->root->gid); - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (loc, out); + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(loc, out); - MAKE_INODE_HANDLE (real_path, this, loc, NULL); - if (!real_path) { - op_ret = -1; - op_errno = errno; - goto out; - } + MAKE_INODE_HANDLE(real_path, this, loc, NULL); + if (!real_path) { + op_ret = -1; + op_errno = errno; + goto out; + } - op_ret = sys_access (real_path, mask & 07); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_ACCESS_FAILED, - "access failed on %s", real_path); - goto out; - } - op_ret = 0; + op_ret = sys_access(real_path, mask & 07); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_ACCESS_FAILED, + "access failed on %s", real_path); + goto out; + } + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT(access, frame, op_ret, op_errno, NULL); + return 0; } - int32_t -posix_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset, dict_t *xdata) +posix_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int _fd = -1; - struct iatt preop = {0,}; - struct iatt postop = {0,}; - struct posix_fd *pfd = NULL; - int ret = -1; - struct posix_private *priv = NULL; - dict_t *rsp_xdata = NULL; - - DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - goto out; - } + int32_t op_ret = -1; + int32_t op_errno = 0; + int _fd = -1; + struct iatt preop = { + 0, + }; + struct iatt postop = { + 0, + }; + struct posix_fd *pfd = NULL; + int ret = -1; + struct posix_private *priv = NULL; + dict_t *rsp_xdata = NULL; + + DECLARE_OLD_FS_ID_VAR; + SET_FS_ID(frame->root->uid, frame->root->gid); + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + goto out; + } - _fd = pfd->fd; + _fd = pfd->fd; - op_ret = posix_fdstat (this, fd->inode, _fd, &preop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } + op_ret = posix_fdstat(this, fd->inode, _fd, &preop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; + } - if (xdata) { - op_ret = posix_cs_maintenance (this, fd, NULL, &_fd, &preop, NULL, - xdata, &rsp_xdata, _gf_false); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - op_errno = EIO; - goto out; - } + if (xdata) { + op_ret = posix_cs_maintenance(this, fd, NULL, &_fd, &preop, NULL, xdata, + &rsp_xdata, _gf_false); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + op_errno = EIO; + goto out; } + } - op_ret = sys_ftruncate (_fd, offset); + op_ret = sys_ftruncate(_fd, offset); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_TRUNCATE_FAILED, - "ftruncate failed on fd=%p (%"PRId64"", fd, offset); - goto out; - } + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_TRUNCATE_FAILED, + "ftruncate failed on fd=%p (%" PRId64 "", fd, offset); + goto out; + } - op_ret = posix_fdstat (this, fd->inode, _fd, &postop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "post-operation fstat failed on fd=%p", fd); - goto out; - } + op_ret = posix_fdstat(this, fd->inode, _fd, &postop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "post-operation fstat failed on fd=%p", fd); + goto out; + } - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, &preop, - &postop, NULL); + STACK_UNWIND_STRICT(ftruncate, frame, op_ret, op_errno, &preop, &postop, + NULL); - return 0; + return 0; } - int32_t -posix_fstat (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *xdata) +posix_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int _fd = -1; - int32_t op_ret = -1; - int32_t op_errno = 0; - struct iatt buf = {0,}; - struct posix_fd *pfd = NULL; - dict_t *xattr_rsp = NULL; - int ret = -1; - struct posix_private *priv = NULL; - - DECLARE_OLD_FS_ID_VAR; - SET_FS_ID (frame->root->uid, frame->root->gid); - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - priv = this->private; - VALIDATE_OR_GOTO (priv, out); - - if (!xdata) - gf_msg_trace (this->name, 0, "null xdata passed, fd %p", fd); + int _fd = -1; + int32_t op_ret = -1; + int32_t op_errno = 0; + struct iatt buf = { + 0, + }; + struct posix_fd *pfd = NULL; + dict_t *xattr_rsp = NULL; + int ret = -1; + struct posix_private *priv = NULL; + + DECLARE_OLD_FS_ID_VAR; + SET_FS_ID(frame->root->uid, frame->root->gid); + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + priv = this->private; + VALIDATE_OR_GOTO(priv, out); + + if (!xdata) + gf_msg_trace(this->name, 0, "null xdata passed, fd %p", fd); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + goto out; + } - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - goto out; - } + _fd = pfd->fd; - _fd = pfd->fd; + op_ret = posix_fdstat(this, fd->inode, _fd, &buf); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "fstat failed on fd=%p", fd); + goto out; + } - op_ret = posix_fdstat (this, fd->inode, _fd, &buf); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "fstat failed on fd=%p", fd); - goto out; - } + if (xdata) { + xattr_rsp = posix_xattr_fill(this, NULL, NULL, fd, _fd, xdata, &buf); - if (xdata) { - xattr_rsp = posix_xattr_fill (this, NULL, NULL, fd, _fd, xdata, - &buf); + posix_cs_maintenance(this, fd, NULL, &_fd, &buf, NULL, xdata, + &xattr_rsp, _gf_false); + } - posix_cs_maintenance (this, fd, NULL, &_fd, &buf, NULL, xdata, - &xattr_rsp, _gf_false); - } - - op_ret = 0; + op_ret = 0; out: - SET_TO_OLD_FS_ID (); + SET_TO_OLD_FS_ID(); - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, &buf, xattr_rsp); - if (xattr_rsp) - dict_unref (xattr_rsp); - return 0; + STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, &buf, xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); + return 0; } int32_t -posix_lease (call_frame_t *frame, xlator_t *this, - loc_t *loc, struct gf_lease *lease, dict_t *xdata) +posix_lease(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct gf_lease *lease, dict_t *xdata) { - struct gf_lease nullease = {0, }; + struct gf_lease nullease = { + 0, + }; - gf_msg (this->name, GF_LOG_CRITICAL, EINVAL, P_MSG_LEASE_DISABLED, - "\"features/leases\" translator is not loaded. You need" - "to use it for proper functioning of your application"); + gf_msg(this->name, GF_LOG_CRITICAL, EINVAL, P_MSG_LEASE_DISABLED, + "\"features/leases\" translator is not loaded. You need" + "to use it for proper functioning of your application"); - STACK_UNWIND_STRICT (lease, frame, -1, ENOSYS, &nullease, NULL); - return 0; + STACK_UNWIND_STRICT(lease, frame, -1, ENOSYS, &nullease, NULL); + return 0; } static int gf_posix_lk_log; int32_t -posix_lk (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) +posix_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - struct gf_flock nullock = {0, }; + struct gf_flock nullock = { + 0, + }; - GF_LOG_OCCASIONALLY (gf_posix_lk_log, this->name, GF_LOG_CRITICAL, - "\"features/locks\" translator is " - "not loaded. You need to use it for proper " - "functioning of your application."); + GF_LOG_OCCASIONALLY(gf_posix_lk_log, this->name, GF_LOG_CRITICAL, + "\"features/locks\" translator is " + "not loaded. You need to use it for proper " + "functioning of your application."); - STACK_UNWIND_STRICT (lk, frame, -1, ENOSYS, &nullock, NULL); - return 0; + STACK_UNWIND_STRICT(lk, frame, -1, ENOSYS, &nullock, NULL); + return 0; } int32_t -posix_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +posix_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - GF_LOG_OCCASIONALLY (gf_posix_lk_log, this->name, GF_LOG_CRITICAL, - "\"features/locks\" translator is " - "not loaded. You need to use it for proper " - "functioning of your application."); + GF_LOG_OCCASIONALLY(gf_posix_lk_log, this->name, GF_LOG_CRITICAL, + "\"features/locks\" translator is " + "not loaded. You need to use it for proper " + "functioning of your application."); - STACK_UNWIND_STRICT (inodelk, frame, -1, ENOSYS, NULL); - return 0; + STACK_UNWIND_STRICT(inodelk, frame, -1, ENOSYS, NULL); + return 0; } int32_t -posix_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +posix_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - GF_LOG_OCCASIONALLY (gf_posix_lk_log, this->name, GF_LOG_CRITICAL, - "\"features/locks\" translator is " - "not loaded. You need to use it for proper " - "functioning of your application."); + GF_LOG_OCCASIONALLY(gf_posix_lk_log, this->name, GF_LOG_CRITICAL, + "\"features/locks\" translator is " + "not loaded. You need to use it for proper " + "functioning of your application."); - STACK_UNWIND_STRICT (finodelk, frame, -1, ENOSYS, NULL); - return 0; + STACK_UNWIND_STRICT(finodelk, frame, -1, ENOSYS, NULL); + return 0; } - int32_t -posix_entrylk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +posix_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - GF_LOG_OCCASIONALLY (gf_posix_lk_log, this->name, GF_LOG_CRITICAL, - "\"features/locks\" translator is " - "not loaded. You need to use it for proper " - "functioning of your application."); + GF_LOG_OCCASIONALLY(gf_posix_lk_log, this->name, GF_LOG_CRITICAL, + "\"features/locks\" translator is " + "not loaded. You need to use it for proper " + "functioning of your application."); - STACK_UNWIND_STRICT (entrylk, frame, -1, ENOSYS, NULL); - return 0; + STACK_UNWIND_STRICT(entrylk, frame, -1, ENOSYS, NULL); + return 0; } int32_t -posix_fentrylk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +posix_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - GF_LOG_OCCASIONALLY (gf_posix_lk_log, this->name, GF_LOG_CRITICAL, - "\"features/locks\" translator is " - "not loaded. You need to use it for proper " - "functioning of your application."); + GF_LOG_OCCASIONALLY(gf_posix_lk_log, this->name, GF_LOG_CRITICAL, + "\"features/locks\" translator is " + "not loaded. You need to use it for proper " + "functioning of your application."); - STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOSYS, NULL); - return 0; + STACK_UNWIND_STRICT(fentrylk, frame, -1, ENOSYS, NULL); + return 0; } - int -posix_fill_readdir (fd_t *fd, DIR *dir, off_t off, size_t size, - gf_dirent_t *entries, xlator_t *this, int32_t skip_dirs) +posix_fill_readdir(fd_t *fd, DIR *dir, off_t off, size_t size, + gf_dirent_t *entries, xlator_t *this, int32_t skip_dirs) { - off_t in_case = -1; - off_t last_off = 0; - size_t filled = 0; - int count = 0; - int32_t this_size = -1; - gf_dirent_t *this_entry = NULL; - struct posix_fd *pfd = NULL; - struct stat stbuf = {0,}; - char *hpath = NULL; - int len = 0; - int ret = 0; - int op_errno = 0; - struct dirent *entry = NULL; - struct dirent scratch[2] = {{0,},}; - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - count = -1; - errno = op_errno; - goto out; - } - - if (skip_dirs) { - len = posix_handle_path (this, fd->inode->gfid, NULL, NULL, 0); - if (len <= 0) { - errno = ESTALE; - count = -1; - goto out; - } - hpath = alloca (len + 256); /* NAME_MAX */ + off_t in_case = -1; + off_t last_off = 0; + size_t filled = 0; + int count = 0; + int32_t this_size = -1; + gf_dirent_t *this_entry = NULL; + struct posix_fd *pfd = NULL; + struct stat stbuf = { + 0, + }; + char *hpath = NULL; + int len = 0; + int ret = 0; + int op_errno = 0; + struct dirent *entry = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + count = -1; + errno = op_errno; + goto out; + } - if (posix_handle_path (this, fd->inode->gfid, NULL, hpath, - len) <= 0) { - errno = ESTALE; - count = -1; - goto out; - } + if (skip_dirs) { + len = posix_handle_path(this, fd->inode->gfid, NULL, NULL, 0); + if (len <= 0) { + errno = ESTALE; + count = -1; + goto out; + } + hpath = alloca(len + 256); /* NAME_MAX */ - len = strlen (hpath); - hpath[len] = '/'; + if (posix_handle_path(this, fd->inode->gfid, NULL, hpath, len) <= 0) { + errno = ESTALE; + count = -1; + goto out; } - if (!off) { - rewinddir (dir); - } else { - seekdir (dir, off); + len = strlen(hpath); + hpath[len] = '/'; + } + + if (!off) { + rewinddir(dir); + } else { + seekdir(dir, off); #ifndef GF_LINUX_HOST_OS - if ((u_long)telldir(dir) != off && off != pfd->dir_eof) { - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - P_MSG_DIR_OPERATION_FAILED, - "seekdir(0x%llx) failed on dir=%p: " - "Invalid argument (offset reused from " - "another DIR * structure?)", off, dir); - errno = EINVAL; - count = -1; - goto out; - } -#endif /* GF_LINUX_HOST_OS */ + if ((u_long)telldir(dir) != off && off != pfd->dir_eof) { + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, P_MSG_DIR_OPERATION_FAILED, + "seekdir(0x%llx) failed on dir=%p: " + "Invalid argument (offset reused from " + "another DIR * structure?)", + off, dir); + errno = EINVAL; + count = -1; + goto out; } +#endif /* GF_LINUX_HOST_OS */ + } - while (filled <= size) { - in_case = (u_long)telldir (dir); + while (filled <= size) { + in_case = (u_long)telldir(dir); - if (in_case == -1) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - P_MSG_DIR_OPERATION_FAILED, - "telldir failed on dir=%p", dir); - goto out; - } + if (in_case == -1) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, P_MSG_DIR_OPERATION_FAILED, + "telldir failed on dir=%p", dir); + goto out; + } - errno = 0; + errno = 0; - entry = sys_readdir (dir, scratch); + entry = sys_readdir(dir, scratch); - if (!entry || errno != 0) { - if (errno == EBADF) { - gf_msg (THIS->name, GF_LOG_WARNING, errno, - P_MSG_DIR_OPERATION_FAILED, - "readdir failed on dir=%p", - dir); - goto out; - } - break; - } + if (!entry || errno != 0) { + if (errno == EBADF) { + gf_msg(THIS->name, GF_LOG_WARNING, errno, + P_MSG_DIR_OPERATION_FAILED, "readdir failed on dir=%p", + dir); + goto out; + } + break; + } #ifdef __NetBSD__ - /* - * NetBSD with UFS1 backend uses backing files for - * extended attributes. They can be found in a - * .attribute file located at the root of the filesystem - * We hide it to glusterfs clients, since chaos will occur - * when the cluster/dht xlator decides to distribute - * exended attribute backing file across storage servers. - */ - if (__is_root_gfid (fd->inode->gfid) == 0 - && (!strcmp(entry->d_name, ".attribute"))) - continue; + /* + * NetBSD with UFS1 backend uses backing files for + * extended attributes. They can be found in a + * .attribute file located at the root of the filesystem + * We hide it to glusterfs clients, since chaos will occur + * when the cluster/dht xlator decides to distribute + * exended attribute backing file across storage servers. + */ + if (__is_root_gfid(fd->inode->gfid) == 0 && + (!strcmp(entry->d_name, ".attribute"))) + continue; #endif /* __NetBSD__ */ - if (__is_root_gfid (fd->inode->gfid) - && (!strcmp (GF_HIDDEN_PATH, entry->d_name))) { - continue; - } + if (__is_root_gfid(fd->inode->gfid) && + (!strcmp(GF_HIDDEN_PATH, entry->d_name))) { + continue; + } - if (skip_dirs) { - if (DT_ISDIR (entry->d_type)) { - continue; - } else if (hpath) { - strcpy (&hpath[len+1], entry->d_name); - ret = sys_lstat (hpath, &stbuf); - if (!ret && S_ISDIR (stbuf.st_mode)) - continue; - } - } + if (skip_dirs) { + if (DT_ISDIR(entry->d_type)) { + continue; + } else if (hpath) { + strcpy(&hpath[len + 1], entry->d_name); + ret = sys_lstat(hpath, &stbuf); + if (!ret && S_ISDIR(stbuf.st_mode)) + continue; + } + } - this_size = max (sizeof (gf_dirent_t), - sizeof (gfs3_dirplist)) - + strlen (entry->d_name) + 1; + this_size = max(sizeof(gf_dirent_t), sizeof(gfs3_dirplist)) + + strlen(entry->d_name) + 1; - if (this_size + filled > size) { - seekdir (dir, in_case); + if (this_size + filled > size) { + seekdir(dir, in_case); #ifndef GF_LINUX_HOST_OS - if ((u_long)telldir(dir) != in_case && - in_case != pfd->dir_eof) { - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - P_MSG_DIR_OPERATION_FAILED, - "seekdir(0x%llx) failed on dir=%p: " - "Invalid argument (offset reused from " - "another DIR * structure?)", - in_case, dir); - errno = EINVAL; - count = -1; - goto out; - } + if ((u_long)telldir(dir) != in_case && in_case != pfd->dir_eof) { + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, + P_MSG_DIR_OPERATION_FAILED, + "seekdir(0x%llx) failed on dir=%p: " + "Invalid argument (offset reused from " + "another DIR * structure?)", + in_case, dir); + errno = EINVAL; + count = -1; + goto out; + } #endif /* GF_LINUX_HOST_OS */ - break; - } - - this_entry = gf_dirent_for_name (entry->d_name); - - if (!this_entry) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - P_MSG_GF_DIRENT_CREATE_FAILED, - "could not create " - "gf_dirent for entry %s", entry->d_name); - goto out; - } - /* - * we store the offset of next entry here, which is - * probably not intended, but code using syncop_readdir() - * (glfs-heal.c, afr-self-heald.c, pump.c) rely on it - * for directory read resumption. - */ - last_off = (u_long)telldir(dir); - this_entry->d_off = last_off; - this_entry->d_ino = entry->d_ino; - this_entry->d_type = entry->d_type; - - list_add_tail (&this_entry->list, &entries->list); - - filled += this_size; - count ++; + break; } - if ((!sys_readdir (dir, scratch) && (errno == 0))) { - /* Indicate EOF */ - errno = ENOENT; - /* Remember EOF offset for later detection */ - pfd->dir_eof = (u_long)last_off; + this_entry = gf_dirent_for_name(entry->d_name); + + if (!this_entry) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, + P_MSG_GF_DIRENT_CREATE_FAILED, + "could not create " + "gf_dirent for entry %s", + entry->d_name); + goto out; } + /* + * we store the offset of next entry here, which is + * probably not intended, but code using syncop_readdir() + * (glfs-heal.c, afr-self-heald.c, pump.c) rely on it + * for directory read resumption. + */ + last_off = (u_long)telldir(dir); + this_entry->d_off = last_off; + this_entry->d_ino = entry->d_ino; + this_entry->d_type = entry->d_type; + + list_add_tail(&this_entry->list, &entries->list); + + filled += this_size; + count++; + } + + if ((!sys_readdir(dir, scratch) && (errno == 0))) { + /* Indicate EOF */ + errno = ENOENT; + /* Remember EOF offset for later detection */ + pfd->dir_eof = (u_long)last_off; + } out: - return count; + return count; } dict_t * -posix_entry_xattr_fill (xlator_t *this, inode_t *inode, - fd_t *fd, char *entry_path, dict_t *dict, - struct iatt *stbuf) +posix_entry_xattr_fill(xlator_t *this, inode_t *inode, fd_t *fd, + char *entry_path, dict_t *dict, struct iatt *stbuf) { - loc_t tmp_loc = {0,}; - - /* if we don't send the 'loc', open-fd-count be a problem. */ - tmp_loc.inode = inode; + loc_t tmp_loc = { + 0, + }; - return posix_xattr_fill (this, entry_path, &tmp_loc, NULL, -1, dict, - stbuf); + /* if we don't send the 'loc', open-fd-count be a problem. */ + tmp_loc.inode = inode; + return posix_xattr_fill(this, entry_path, &tmp_loc, NULL, -1, dict, stbuf); } - #ifdef _DIRENT_HAVE_D_TYPE static int -posix_d_type_from_ia_type (ia_type_t type) +posix_d_type_from_ia_type(ia_type_t type) { - switch (type) { - case IA_IFDIR: return DT_DIR; - case IA_IFCHR: return DT_CHR; - case IA_IFBLK: return DT_BLK; - case IA_IFIFO: return DT_FIFO; - case IA_IFLNK: return DT_LNK; - case IA_IFREG: return DT_REG; - case IA_IFSOCK: return DT_SOCK; - default: return DT_UNKNOWN; - } + switch (type) { + case IA_IFDIR: + return DT_DIR; + case IA_IFCHR: + return DT_CHR; + case IA_IFBLK: + return DT_BLK; + case IA_IFIFO: + return DT_FIFO; + case IA_IFLNK: + return DT_LNK; + case IA_IFREG: + return DT_REG; + case IA_IFSOCK: + return DT_SOCK; + default: + return DT_UNKNOWN; + } } #endif - int -posix_readdirp_fill (xlator_t *this, fd_t *fd, gf_dirent_t *entries, dict_t *dict) +posix_readdirp_fill(xlator_t *this, fd_t *fd, gf_dirent_t *entries, + dict_t *dict) { - gf_dirent_t *entry = NULL; - inode_table_t *itable = NULL; - inode_t *inode = NULL; - char *hpath = NULL; - int len = 0; - struct iatt stbuf = {0, }; - uuid_t gfid; - int ret = -1; + gf_dirent_t *entry = NULL; + inode_table_t *itable = NULL; + inode_t *inode = NULL; + char *hpath = NULL; + int len = 0; + struct iatt stbuf = { + 0, + }; + uuid_t gfid; + int ret = -1; + + if (list_empty(&entries->list)) + return 0; - if (list_empty(&entries->list)) - return 0; + itable = fd->inode->table; + + len = posix_handle_path(this, fd->inode->gfid, NULL, NULL, 0); + if (len <= 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLEPATH_FAILED, + "Failed to create handle path, fd=%p, gfid=%s", fd, + uuid_utoa(fd->inode->gfid)); + return -1; + } + + hpath = alloca(len + 256); /* NAME_MAX */ + if (posix_handle_path(this, fd->inode->gfid, NULL, hpath, len) <= 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_HANDLEPATH_FAILED, + "Failed to create handle path, fd=%p, gfid=%s", fd, + uuid_utoa(fd->inode->gfid)); + return -1; + } + + len = strlen(hpath); + hpath[len] = '/'; + + list_for_each_entry(entry, &entries->list, list) + { + inode = inode_grep(fd->inode->table, fd->inode, entry->d_name); + if (inode) + gf_uuid_copy(gfid, inode->gfid); + else + bzero(gfid, 16); - itable = fd->inode->table; + strcpy(&hpath[len + 1], entry->d_name); - len = posix_handle_path (this, fd->inode->gfid, NULL, NULL, 0); - if (len <= 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_HANDLEPATH_FAILED, - "Failed to create handle path, fd=%p, gfid=%s", - fd, uuid_utoa (fd->inode->gfid)); - return -1; - } + ret = posix_pstat(this, inode, gfid, hpath, &stbuf, _gf_false); - hpath = alloca (len + 256); /* NAME_MAX */ - if (posix_handle_path (this, fd->inode->gfid, NULL, hpath, len) <= 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_HANDLEPATH_FAILED, - "Failed to create handle path, fd=%p, gfid=%s", - fd, uuid_utoa (fd->inode->gfid)); - return -1; + if (ret == -1) { + if (inode) + inode_unref(inode); + continue; } - len = strlen (hpath); - hpath[len] = '/'; - - list_for_each_entry (entry, &entries->list, list) { - inode = inode_grep (fd->inode->table, fd->inode, - entry->d_name); - if (inode) - gf_uuid_copy (gfid, inode->gfid); - else - bzero(gfid, 16); - - strcpy (&hpath[len+1], entry->d_name); - - ret = posix_pstat (this, inode, gfid, hpath, &stbuf, _gf_false); - - if (ret == -1) { - if (inode) - inode_unref (inode); - continue; - } + if (!inode) + inode = inode_find(itable, stbuf.ia_gfid); - if (!inode) - inode = inode_find (itable, stbuf.ia_gfid); + if (!inode) + inode = inode_new(itable); - if (!inode) - inode = inode_new (itable); + entry->inode = inode; - entry->inode = inode; - - if (dict) { - entry->dict = - posix_entry_xattr_fill (this, entry->inode, - fd, hpath, - dict, &stbuf); - } + if (dict) { + entry->dict = posix_entry_xattr_fill(this, entry->inode, fd, hpath, + dict, &stbuf); + } - entry->d_stat = stbuf; - if (stbuf.ia_ino) - entry->d_ino = stbuf.ia_ino; + entry->d_stat = stbuf; + if (stbuf.ia_ino) + entry->d_ino = stbuf.ia_ino; #ifdef _DIRENT_HAVE_D_TYPE - if (entry->d_type == DT_UNKNOWN && !IA_ISINVAL(stbuf.ia_type)) { - /* The platform supports d_type but the underlying - filesystem doesn't. We set d_type to the correct - value from ia_type */ - entry->d_type = - posix_d_type_from_ia_type (stbuf.ia_type); - } + if (entry->d_type == DT_UNKNOWN && !IA_ISINVAL(stbuf.ia_type)) { + /* The platform supports d_type but the underlying + filesystem doesn't. We set d_type to the correct + value from ia_type */ + entry->d_type = posix_d_type_from_ia_type(stbuf.ia_type); + } #endif - inode = NULL; - } + inode = NULL; + } - return 0; + return 0; } - int32_t -posix_do_readdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t off, int whichop, dict_t *dict) +posix_do_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, int whichop, dict_t *dict) { - struct posix_fd *pfd = NULL; - DIR *dir = NULL; - int ret = -1; - int count = 0; - int32_t op_ret = -1; - int32_t op_errno = 0; - gf_dirent_t entries; - int32_t skip_dirs = 0; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); - - INIT_LIST_HEAD (&entries.list); - - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - goto out; - } + struct posix_fd *pfd = NULL; + DIR *dir = NULL; + int ret = -1; + int count = 0; + int32_t op_ret = -1; + int32_t op_errno = 0; + gf_dirent_t entries; + int32_t skip_dirs = 0; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + INIT_LIST_HEAD(&entries.list); + + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, op_errno, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + goto out; + } - dir = pfd->dir; + dir = pfd->dir; - if (!dir) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, P_MSG_PFD_NULL, - "dir is NULL for fd=%p", fd); - op_errno = EINVAL; - goto out; - } + if (!dir) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, P_MSG_PFD_NULL, + "dir is NULL for fd=%p", fd); + op_errno = EINVAL; + goto out; + } - /* When READDIR_FILTER option is set to on, we can filter out - * directory's entry from the entry->list. - */ - ret = dict_get_int32 (dict, GF_READDIR_SKIP_DIRS, &skip_dirs); + /* When READDIR_FILTER option is set to on, we can filter out + * directory's entry from the entry->list. + */ + ret = dict_get_int32(dict, GF_READDIR_SKIP_DIRS, &skip_dirs); - LOCK (&fd->lock); - { - /* posix_fill_readdir performs multiple separate individual - readdir() calls to fill up the buffer. + LOCK(&fd->lock); + { + /* posix_fill_readdir performs multiple separate individual + readdir() calls to fill up the buffer. - In case of NFS where the same anonymous FD is shared between - different applications, reading a common directory can - result in the anonymous fd getting re-used unsafely between - the two readdir requests (in two different io-threads). + In case of NFS where the same anonymous FD is shared between + different applications, reading a common directory can + result in the anonymous fd getting re-used unsafely between + the two readdir requests (in two different io-threads). - It would also help, in the future, to replace the loop - around readdir() with a single large getdents() call. - */ - count = posix_fill_readdir (fd, dir, off, size, &entries, this, - skip_dirs); - } - UNLOCK (&fd->lock); + It would also help, in the future, to replace the loop + around readdir() with a single large getdents() call. + */ + count = posix_fill_readdir(fd, dir, off, size, &entries, this, + skip_dirs); + } + UNLOCK(&fd->lock); - /* pick ENOENT to indicate EOF */ - op_errno = errno; - op_ret = count; + /* pick ENOENT to indicate EOF */ + op_errno = errno; + op_ret = count; - if (whichop != GF_FOP_READDIRP) - goto out; + if (whichop != GF_FOP_READDIRP) + goto out; - posix_readdirp_fill (this, fd, &entries, dict); + posix_readdirp_fill(this, fd, &entries, dict); out: - if (whichop == GF_FOP_READDIR) - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, &entries, - NULL); - else - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, - &entries, NULL); + if (whichop == GF_FOP_READDIR) + STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, &entries, NULL); + else + STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, &entries, NULL); - gf_dirent_free (&entries); + gf_dirent_free(&entries); - return 0; + return 0; } - int32_t -posix_readdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t off, dict_t *xdata) +posix_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *xdata) { - posix_do_readdir (frame, this, fd, size, off, GF_FOP_READDIR, xdata); - return 0; + posix_do_readdir(frame, this, fd, size, off, GF_FOP_READDIR, xdata); + return 0; } - int32_t -posix_readdirp (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t off, dict_t *dict) +posix_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *dict) { - gf_dirent_t entries; - int32_t op_ret = -1, op_errno = 0; - gf_dirent_t *entry = NULL; - - - if ((dict != NULL) && (dict_get (dict, GET_ANCESTRY_DENTRY_KEY))) { - INIT_LIST_HEAD (&entries.list); + gf_dirent_t entries; + int32_t op_ret = -1, op_errno = 0; + gf_dirent_t *entry = NULL; - op_ret = posix_get_ancestry (this, fd->inode, &entries, NULL, - POSIX_ANCESTRY_DENTRY, - &op_errno, dict); - if (op_ret >= 0) { - op_ret = 0; + if ((dict != NULL) && (dict_get(dict, GET_ANCESTRY_DENTRY_KEY))) { + INIT_LIST_HEAD(&entries.list); - list_for_each_entry (entry, &entries.list, list) { - op_ret++; - } - } - - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, - &entries, NULL); + op_ret = posix_get_ancestry(this, fd->inode, &entries, NULL, + POSIX_ANCESTRY_DENTRY, &op_errno, dict); + if (op_ret >= 0) { + op_ret = 0; - gf_dirent_free (&entries); - return 0; + list_for_each_entry(entry, &entries.list, list) { op_ret++; } } - posix_do_readdir (frame, this, fd, size, off, GF_FOP_READDIRP, dict); + STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, &entries, NULL); + + gf_dirent_free(&entries); return 0; + } + + posix_do_readdir(frame, this, fd, size, off, GF_FOP_READDIRP, dict); + return 0; } int32_t -posix_rchecksum (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset, int32_t len, dict_t *xdata) +posix_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + int32_t len, dict_t *xdata) { - char *alloc_buf = NULL; - char *buf = NULL; - int _fd = -1; - struct posix_fd *pfd = NULL; - int op_ret = -1; - int op_errno = 0; - int ret = 0; - ssize_t bytes_read = 0; - int32_t weak_checksum = 0; - int32_t zerofillcheck = 0; - unsigned char md5_checksum[MD5_DIGEST_LENGTH] = {0}; - unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0}; - unsigned char *checksum = NULL; - struct posix_private *priv = NULL; - dict_t *rsp_xdata = NULL; - gf_boolean_t buf_has_zeroes = _gf_false; - struct iatt preop = {0,}; - - VALIDATE_OR_GOTO (frame, out); - VALIDATE_OR_GOTO (this, out); - VALIDATE_OR_GOTO (fd, out); + char *alloc_buf = NULL; + char *buf = NULL; + int _fd = -1; + struct posix_fd *pfd = NULL; + int op_ret = -1; + int op_errno = 0; + int ret = 0; + ssize_t bytes_read = 0; + int32_t weak_checksum = 0; + int32_t zerofillcheck = 0; + unsigned char md5_checksum[MD5_DIGEST_LENGTH] = {0}; + unsigned char strong_checksum[SHA256_DIGEST_LENGTH] = {0}; + unsigned char *checksum = NULL; + struct posix_private *priv = NULL; + dict_t *rsp_xdata = NULL; + gf_boolean_t buf_has_zeroes = _gf_false; + struct iatt preop = { + 0, + }; + + VALIDATE_OR_GOTO(frame, out); + VALIDATE_OR_GOTO(this, out); + VALIDATE_OR_GOTO(fd, out); + + priv = this->private; + + alloc_buf = _page_aligned_alloc(len, &buf); + if (!alloc_buf) { + op_errno = ENOMEM; + goto out; + } - priv = this->private; + rsp_xdata = dict_new(); + if (!rsp_xdata) { + op_errno = ENOMEM; + goto out; + } - alloc_buf = _page_aligned_alloc (len, &buf); - if (!alloc_buf) { - op_errno = ENOMEM; - goto out; - } + ret = posix_fd_ctx_get(fd, this, &pfd, &op_errno); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_PFD_NULL, + "pfd is NULL, fd=%p", fd); + goto out; + } - rsp_xdata = dict_new(); - if (!rsp_xdata) { - op_errno = ENOMEM; - goto out; - } + _fd = pfd->fd; - ret = posix_fd_ctx_get (fd, this, &pfd, &op_errno); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, -ret, P_MSG_PFD_NULL, - "pfd is NULL, fd=%p", fd); - goto out; + if (xdata) { + op_ret = posix_fdstat(this, fd->inode, _fd, &preop); + if (op_ret == -1) { + op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, + "pre-operation fstat failed on fd=%p", fd); + goto out; } - _fd = pfd->fd; - - if (xdata) { - op_ret = posix_fdstat (this, fd->inode, _fd, &preop); - if (op_ret == -1) { - op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED, - "pre-operation fstat failed on fd=%p", fd); - goto out; - } - - op_ret = posix_cs_maintenance (this, fd, NULL, &_fd, &preop, NULL, - xdata, &rsp_xdata, _gf_false); - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, 0, - "file state check failed, fd %p", fd); - op_errno = EIO; - goto out; - } + op_ret = posix_cs_maintenance(this, fd, NULL, &_fd, &preop, NULL, xdata, + &rsp_xdata, _gf_false); + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, 0, + "file state check failed, fd %p", fd); + op_errno = EIO; + goto out; } + } - LOCK (&fd->lock); - { - if (priv->aio_capable && priv->aio_init_done) - __posix_fd_set_odirect (fd, pfd, 0, offset, len); - - bytes_read = sys_pread (_fd, buf, len, offset); - if (bytes_read < 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_PREAD_FAILED, - "pread of %d bytes returned %zd", len, - bytes_read); - - op_errno = errno; - } - - } - UNLOCK (&fd->lock); + LOCK(&fd->lock); + { + if (priv->aio_capable && priv->aio_init_done) + __posix_fd_set_odirect(fd, pfd, 0, offset, len); - if (bytes_read < 0) - goto out; + bytes_read = sys_pread(_fd, buf, len, offset); + if (bytes_read < 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_PREAD_FAILED, + "pread of %d bytes returned %zd", len, bytes_read); - if (xdata && dict_get_int32 (xdata, "check-zero-filled", - &zerofillcheck) == 0) { - buf_has_zeroes = (mem_0filled (buf, bytes_read)) ? _gf_false : - _gf_true; - ret = dict_set_uint32 (rsp_xdata, "buf-has-zeroes", - buf_has_zeroes); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, -ret, - P_MSG_DICT_SET_FAILED, "%s: Failed to set " - "dictionary value for key: %s", - uuid_utoa (fd->inode->gfid), "buf-has-zeroes"); - op_errno = -ret; - goto out; - } + op_errno = errno; } - weak_checksum = gf_rsync_weak_checksum ((unsigned char *) buf, (size_t) ret); + } + UNLOCK(&fd->lock); - if (priv->fips_mode_rchecksum) { - ret = dict_set_int32 (rsp_xdata, "fips-mode-rchecksum", 1); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, -ret, - P_MSG_DICT_SET_FAILED, "%s: Failed to set " - "dictionary value for key: %s", - uuid_utoa (fd->inode->gfid), - "fips-mode-rchecksum"); - goto out; - } - checksum = strong_checksum; - gf_rsync_strong_checksum ((unsigned char *)buf, - (size_t) bytes_read, - (unsigned char *)checksum); - } else { - checksum = md5_checksum; - gf_rsync_md5_checksum ((unsigned char *)buf, - (size_t) bytes_read, - (unsigned char *)checksum); - } - op_ret = 0; + if (bytes_read < 0) + goto out; - posix_set_ctime (frame, this, NULL, _fd, fd->inode, NULL); + if (xdata && + dict_get_int32(xdata, "check-zero-filled", &zerofillcheck) == 0) { + buf_has_zeroes = (mem_0filled(buf, bytes_read)) ? _gf_false : _gf_true; + ret = dict_set_uint32(rsp_xdata, "buf-has-zeroes", buf_has_zeroes); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_DICT_SET_FAILED, + "%s: Failed to set " + "dictionary value for key: %s", + uuid_utoa(fd->inode->gfid), "buf-has-zeroes"); + op_errno = -ret; + goto out; + } + } + weak_checksum = gf_rsync_weak_checksum((unsigned char *)buf, (size_t)ret); + + if (priv->fips_mode_rchecksum) { + ret = dict_set_int32(rsp_xdata, "fips-mode-rchecksum", 1); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, -ret, P_MSG_DICT_SET_FAILED, + "%s: Failed to set " + "dictionary value for key: %s", + uuid_utoa(fd->inode->gfid), "fips-mode-rchecksum"); + goto out; + } + checksum = strong_checksum; + gf_rsync_strong_checksum((unsigned char *)buf, (size_t)bytes_read, + (unsigned char *)checksum); + } else { + checksum = md5_checksum; + gf_rsync_md5_checksum((unsigned char *)buf, (size_t)bytes_read, + (unsigned char *)checksum); + } + op_ret = 0; + + posix_set_ctime(frame, this, NULL, _fd, fd->inode, NULL); out: - STACK_UNWIND_STRICT (rchecksum, frame, op_ret, op_errno, - weak_checksum, checksum, rsp_xdata); - if (rsp_xdata) - dict_unref (rsp_xdata); - GF_FREE (alloc_buf); + STACK_UNWIND_STRICT(rchecksum, frame, op_ret, op_errno, weak_checksum, + checksum, rsp_xdata); + if (rsp_xdata) + dict_unref(rsp_xdata); + GF_FREE(alloc_buf); - return 0; + return 0; } int -posix_forget (xlator_t *this, inode_t *inode) +posix_forget(xlator_t *this, inode_t *inode) { - int ret = 0; - char *unlink_path = NULL; - uint64_t ctx_uint = 0; - posix_inode_ctx_t *ctx = NULL; - struct posix_private *priv_posix = NULL; - - priv_posix = (struct posix_private *) this->private; - if (!priv_posix) - return 0; - - ret = inode_ctx_del (inode, this, &ctx_uint); - if (!ctx_uint) - return 0; - - ctx = (posix_inode_ctx_t *)ctx_uint; - - if (ctx->unlink_flag == GF_UNLINK_TRUE) { - POSIX_GET_FILE_UNLINK_PATH(priv_posix->base_path, - inode->gfid, unlink_path); - if (!unlink_path) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - P_MSG_UNLINK_FAILED, - "Failed to remove gfid :%s", - uuid_utoa (inode->gfid)); - ret = -1; - goto out; - } - ret = sys_unlink(unlink_path); + int ret = 0; + char *unlink_path = NULL; + uint64_t ctx_uint = 0; + posix_inode_ctx_t *ctx = NULL; + struct posix_private *priv_posix = NULL; + + priv_posix = (struct posix_private *)this->private; + if (!priv_posix) + return 0; + + ret = inode_ctx_del(inode, this, &ctx_uint); + if (!ctx_uint) + return 0; + + ctx = (posix_inode_ctx_t *)ctx_uint; + + if (ctx->unlink_flag == GF_UNLINK_TRUE) { + POSIX_GET_FILE_UNLINK_PATH(priv_posix->base_path, inode->gfid, + unlink_path); + if (!unlink_path) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, P_MSG_UNLINK_FAILED, + "Failed to remove gfid :%s", uuid_utoa(inode->gfid)); + ret = -1; + goto out; } + ret = sys_unlink(unlink_path); + } out: - pthread_mutex_destroy (&ctx->xattrop_lock); - pthread_mutex_destroy (&ctx->write_atomic_lock); - pthread_mutex_destroy (&ctx->pgfid_lock); - GF_FREE (ctx); - return ret; + pthread_mutex_destroy(&ctx->xattrop_lock); + pthread_mutex_destroy(&ctx->write_atomic_lock); + pthread_mutex_destroy(&ctx->pgfid_lock); + GF_FREE(ctx); + return ret; } diff --git a/xlators/storage/posix/src/posix-metadata.c b/xlators/storage/posix/src/posix-metadata.c index 7488e59ae70..82b05ebffc2 100644 --- a/xlators/storage/posix/src/posix-metadata.c +++ b/xlators/storage/posix/src/posix-metadata.c @@ -23,648 +23,631 @@ static int gf_posix_xattr_enotsup_log; * save it on disk in machine independent format */ static inline void -posix_mdata_to_disk (posix_mdata_disk_t *out, posix_mdata_t *in) +posix_mdata_to_disk(posix_mdata_disk_t *out, posix_mdata_t *in) { - out->version = in->version; - out->flags = htobe64(in->flags); + out->version = in->version; + out->flags = htobe64(in->flags); - out->ctime.tv_sec = htobe64(in->ctime.tv_sec); - out->ctime.tv_nsec = htobe64(in->ctime.tv_nsec); + out->ctime.tv_sec = htobe64(in->ctime.tv_sec); + out->ctime.tv_nsec = htobe64(in->ctime.tv_nsec); - out->mtime.tv_sec = htobe64(in->mtime.tv_sec); - out->mtime.tv_nsec = htobe64(in->mtime.tv_nsec); + out->mtime.tv_sec = htobe64(in->mtime.tv_sec); + out->mtime.tv_nsec = htobe64(in->mtime.tv_nsec); - out->atime.tv_sec = htobe64(in->atime.tv_sec); - out->atime.tv_nsec = htobe64(in->atime.tv_nsec); + out->atime.tv_sec = htobe64(in->atime.tv_sec); + out->atime.tv_nsec = htobe64(in->atime.tv_nsec); } /* posix_mdata_from_disk converts posix_mdata_disk_t into host byte order */ static inline void -posix_mdata_from_disk (posix_mdata_t *out, posix_mdata_disk_t *in) +posix_mdata_from_disk(posix_mdata_t *out, posix_mdata_disk_t *in) { - out->version = in->version; - out->flags = be64toh(in->flags); + out->version = in->version; + out->flags = be64toh(in->flags); - out->ctime.tv_sec = be64toh(in->ctime.tv_sec); - out->ctime.tv_nsec = be64toh(in->ctime.tv_nsec); + out->ctime.tv_sec = be64toh(in->ctime.tv_sec); + out->ctime.tv_nsec = be64toh(in->ctime.tv_nsec); - out->mtime.tv_sec = be64toh(in->mtime.tv_sec); - out->mtime.tv_nsec = be64toh(in->mtime.tv_nsec); + out->mtime.tv_sec = be64toh(in->mtime.tv_sec); + out->mtime.tv_nsec = be64toh(in->mtime.tv_nsec); - out->atime.tv_sec = be64toh(in->atime.tv_sec); - out->atime.tv_nsec = be64toh(in->atime.tv_nsec); + out->atime.tv_sec = be64toh(in->atime.tv_sec); + out->atime.tv_nsec = be64toh(in->atime.tv_nsec); } /* posix_fetch_mdata_xattr fetches the posix_mdata_t from disk */ static int -posix_fetch_mdata_xattr (xlator_t *this, const char *real_path_arg, int _fd, - inode_t *inode, posix_mdata_t *metadata, int *op_errno) +posix_fetch_mdata_xattr(xlator_t *this, const char *real_path_arg, int _fd, + inode_t *inode, posix_mdata_t *metadata, int *op_errno) { - size_t size = -1; - int op_ret = -1; - char *value = NULL; - gf_boolean_t fd_based_fop = _gf_false; - char gfid_str[64] = {0}; - char *real_path = NULL; - - char *key = GF_XATTR_MDATA_KEY; - - if (!metadata) { - op_ret = -1; - goto out; - } - - if (_fd != -1) { - fd_based_fop = _gf_true; - } - if (!(fd_based_fop || real_path_arg)) { - MAKE_HANDLE_PATH (real_path, this, inode->gfid, NULL); - if (!real_path) { - uuid_utoa_r (inode->gfid, gfid_str); - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_LSTAT_FAILED, "lstat on gfid %s failed", - gfid_str); - op_ret = -1; - *op_errno = errno; - goto out; - } - } - - if (fd_based_fop) { - size = sys_fgetxattr (_fd, key, NULL, 0); - } else if (real_path_arg) { - size = sys_lgetxattr (real_path_arg, key, NULL, 0); - } else if (real_path) { - size = sys_lgetxattr (real_path, key, NULL, 0); - } - - if (size == -1) { - *op_errno = errno; - if ((*op_errno == ENOTSUP) || (*op_errno == ENOSYS)) { - GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, - this->name, GF_LOG_WARNING, - "Extended attributes not " - "supported (try remounting" - " brick with 'user_xattr' " - "flag)"); - } else if (*op_errno == ENOATTR || - *op_errno == ENODATA) { - gf_msg_debug (this->name, 0, - "No such attribute:%s for file %s " - "gfid: %s", - key, real_path ? real_path : (real_path_arg ? real_path_arg : "null"), - uuid_utoa(inode->gfid)); - } else { - gf_msg (this->name, GF_LOG_DEBUG, *op_errno, - P_MSG_XATTR_FAILED, "getxattr failed" - " on %s gfid: %s key: %s ", - real_path ? real_path : (real_path_arg ? real_path_arg : "null"), - uuid_utoa(inode->gfid), key); - } - op_ret = -1; - goto out; - } - - value = GF_CALLOC (size + 1, sizeof(char), gf_posix_mt_char); - if (!value) { - op_ret = -1; - *op_errno = ENOMEM; - goto out; + size_t size = -1; + int op_ret = -1; + char *value = NULL; + gf_boolean_t fd_based_fop = _gf_false; + char gfid_str[64] = {0}; + char *real_path = NULL; + + char *key = GF_XATTR_MDATA_KEY; + + if (!metadata) { + op_ret = -1; + goto out; + } + + if (_fd != -1) { + fd_based_fop = _gf_true; + } + if (!(fd_based_fop || real_path_arg)) { + MAKE_HANDLE_PATH(real_path, this, inode->gfid, NULL); + if (!real_path) { + uuid_utoa_r(inode->gfid, gfid_str); + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_LSTAT_FAILED, + "lstat on gfid %s failed", gfid_str); + op_ret = -1; + *op_errno = errno; + goto out; } - - if (fd_based_fop) { - size = sys_fgetxattr (_fd, key, value, size); - } else if (real_path_arg) { - size = sys_lgetxattr (real_path_arg, key, value, size); - } else if (real_path) { - size = sys_lgetxattr (real_path, key, value, size); - } - if (size == -1) { - op_ret = -1; - *op_errno = errno; - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_XATTR_FAILED, "getxattr failed on " - " on %s gfid: %s key: %s ", - real_path ? real_path : (real_path_arg ? real_path_arg : "null"), - uuid_utoa(inode->gfid), key); - goto out; + } + + if (fd_based_fop) { + size = sys_fgetxattr(_fd, key, NULL, 0); + } else if (real_path_arg) { + size = sys_lgetxattr(real_path_arg, key, NULL, 0); + } else if (real_path) { + size = sys_lgetxattr(real_path, key, NULL, 0); + } + + if (size == -1) { + *op_errno = errno; + if ((*op_errno == ENOTSUP) || (*op_errno == ENOSYS)) { + GF_LOG_OCCASIONALLY(gf_posix_xattr_enotsup_log, this->name, + GF_LOG_WARNING, + "Extended attributes not " + "supported (try remounting" + " brick with 'user_xattr' " + "flag)"); + } else if (*op_errno == ENOATTR || *op_errno == ENODATA) { + gf_msg_debug(this->name, 0, + "No such attribute:%s for file %s " + "gfid: %s", + key, + real_path ? real_path + : (real_path_arg ? real_path_arg : "null"), + uuid_utoa(inode->gfid)); + } else { + gf_msg(this->name, GF_LOG_DEBUG, *op_errno, P_MSG_XATTR_FAILED, + "getxattr failed" + " on %s gfid: %s key: %s ", + real_path ? real_path + : (real_path_arg ? real_path_arg : "null"), + uuid_utoa(inode->gfid), key); } - - posix_mdata_from_disk (metadata, (posix_mdata_disk_t*)value); - - op_ret = 0; + op_ret = -1; + goto out; + } + + value = GF_CALLOC(size + 1, sizeof(char), gf_posix_mt_char); + if (!value) { + op_ret = -1; + *op_errno = ENOMEM; + goto out; + } + + if (fd_based_fop) { + size = sys_fgetxattr(_fd, key, value, size); + } else if (real_path_arg) { + size = sys_lgetxattr(real_path_arg, key, value, size); + } else if (real_path) { + size = sys_lgetxattr(real_path, key, value, size); + } + if (size == -1) { + op_ret = -1; + *op_errno = errno; + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "getxattr failed on " + " on %s gfid: %s key: %s ", + real_path ? real_path : (real_path_arg ? real_path_arg : "null"), + uuid_utoa(inode->gfid), key); + goto out; + } + + posix_mdata_from_disk(metadata, (posix_mdata_disk_t *)value); + + op_ret = 0; out: - GF_FREE (value); - return op_ret; + GF_FREE(value); + return op_ret; } /* posix_store_mdata_xattr stores the posix_mdata_t on disk */ static int -posix_store_mdata_xattr (xlator_t *this, const char *real_path_arg, int fd, - inode_t *inode, posix_mdata_t *metadata) +posix_store_mdata_xattr(xlator_t *this, const char *real_path_arg, int fd, + inode_t *inode, posix_mdata_t *metadata) { - char *real_path = NULL; - int op_ret = 0; - gf_boolean_t fd_based_fop = _gf_false; - char *key = GF_XATTR_MDATA_KEY; - char gfid_str[64] = {0}; - posix_mdata_disk_t disk_metadata; - - if (!metadata) { - op_ret = -1; - goto out; - } - - if (fd != -1) { - fd_based_fop = _gf_true; - } - if (!(fd_based_fop || real_path_arg)) { - MAKE_HANDLE_PATH (real_path, this, inode->gfid, NULL); - if (!real_path) { - uuid_utoa_r (inode->gfid, gfid_str); - gf_msg (this->name, GF_LOG_DEBUG, errno, - P_MSG_LSTAT_FAILED, "lstat on gfid %s failed", - gfid_str); - op_ret = -1; - goto out; - } - } - - /* Set default version as 1 */ - posix_mdata_to_disk (&disk_metadata, metadata); - - if (fd_based_fop) { - op_ret = sys_fsetxattr (fd, key, - (void *) &disk_metadata, - sizeof (posix_mdata_disk_t), 0); - } else if (real_path_arg) { - op_ret = sys_lsetxattr (real_path_arg, key, - (void *) &disk_metadata, - sizeof (posix_mdata_disk_t), 0); - } else if (real_path) { - op_ret = sys_lsetxattr (real_path, key, - (void *) &disk_metadata, - sizeof (posix_mdata_disk_t), 0); + char *real_path = NULL; + int op_ret = 0; + gf_boolean_t fd_based_fop = _gf_false; + char *key = GF_XATTR_MDATA_KEY; + char gfid_str[64] = {0}; + posix_mdata_disk_t disk_metadata; + + if (!metadata) { + op_ret = -1; + goto out; + } + + if (fd != -1) { + fd_based_fop = _gf_true; + } + if (!(fd_based_fop || real_path_arg)) { + MAKE_HANDLE_PATH(real_path, this, inode->gfid, NULL); + if (!real_path) { + uuid_utoa_r(inode->gfid, gfid_str); + gf_msg(this->name, GF_LOG_DEBUG, errno, P_MSG_LSTAT_FAILED, + "lstat on gfid %s failed", gfid_str); + op_ret = -1; + goto out; } + } + + /* Set default version as 1 */ + posix_mdata_to_disk(&disk_metadata, metadata); + + if (fd_based_fop) { + op_ret = sys_fsetxattr(fd, key, (void *)&disk_metadata, + sizeof(posix_mdata_disk_t), 0); + } else if (real_path_arg) { + op_ret = sys_lsetxattr(real_path_arg, key, (void *)&disk_metadata, + sizeof(posix_mdata_disk_t), 0); + } else if (real_path) { + op_ret = sys_lsetxattr(real_path, key, (void *)&disk_metadata, + sizeof(posix_mdata_disk_t), 0); + } #ifdef GF_DARWIN_HOST_OS - if (real_path_arg) { - posix_dump_buffer(this, real_path_arg, key, value, 0); - } else if (real_path) { - posix_dump_buffer(this, real_path, key, value, 0); - } + if (real_path_arg) { + posix_dump_buffer(this, real_path_arg, key, value, 0); + } else if (real_path) { + posix_dump_buffer(this, real_path, key, value, 0); + } #endif out: - if (op_ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, - "file: %s: gfid: %s key:%s ", - real_path ? real_path : (real_path_arg ? real_path_arg : "null"), - uuid_utoa(inode->gfid), key); - } - return op_ret; + if (op_ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_XATTR_FAILED, + "file: %s: gfid: %s key:%s ", + real_path ? real_path : (real_path_arg ? real_path_arg : "null"), + uuid_utoa(inode->gfid), key); + } + return op_ret; } /* _posix_get_mdata_xattr gets posix_mdata_t from inode context. If it fails * to get it from inode context, gets it from disk. This is with out inode lock. */ int -__posix_get_mdata_xattr (xlator_t *this, const char *real_path, int _fd, - inode_t *inode, struct iatt *stbuf) +__posix_get_mdata_xattr(xlator_t *this, const char *real_path, int _fd, + inode_t *inode, struct iatt *stbuf) { - posix_mdata_t *mdata = NULL; - int ret = -1; - int op_errno = 0; + posix_mdata_t *mdata = NULL; + int ret = -1; + int op_errno = 0; + + GF_VALIDATE_OR_GOTO(this->name, inode, out); + + ret = __inode_ctx_get1(inode, this, (uint64_t *)&mdata); + if (ret == -1 || !mdata) { + mdata = GF_CALLOC(1, sizeof(posix_mdata_t), gf_posix_mt_mdata_attr); + if (!mdata) { + ret = -1; + goto out; + } - GF_VALIDATE_OR_GOTO (this->name, inode, out); + ret = posix_fetch_mdata_xattr(this, real_path, _fd, inode, mdata, + &op_errno); - ret = __inode_ctx_get1 (inode, this, - (uint64_t *)&mdata); - if (ret == -1 || !mdata) { - mdata = GF_CALLOC (1, sizeof (posix_mdata_t), - gf_posix_mt_mdata_attr); - if (!mdata) { - ret = -1; - goto out; - } - - ret = posix_fetch_mdata_xattr (this, real_path, _fd, inode, - mdata, &op_errno); - - if (ret == 0) { - /* Got mdata from disk, set it in inode ctx. This case - * is hit when in-memory status is lost due to brick - * down scenario - */ - __inode_ctx_set1 (inode, this, (uint64_t *)&mdata); - } else { - /* Failed to get mdata from disk, xattr missing. - * This happens on two cases. - * 1. File is created before ctime is enabled. - * 2. On new file creation. - * - * Do nothing, just return success. It is as - * good as ctime feature is not enabled for this - * file. For files created before ctime is enabled, - * time attributes gets updated into ctime structure - * once the metadata modification fop happens and - * time attributes become consistent eventually. - * For new files, it would obviously get updated - * before the fop completion. - */ - if (stbuf && op_errno != ENOENT) { - ret = 0; - goto out; - } else { - /* This case should not be hit. If it hits, - * don't fail, log warning, free mdata and move - * on - */ - gf_msg (this->name, GF_LOG_WARNING, op_errno, - P_MSG_FETCHMDATA_FAILED, - "file: %s: gfid: %s key:%s ", - real_path ? real_path : "null", - uuid_utoa(inode->gfid), - GF_XATTR_MDATA_KEY); - GF_FREE (mdata); - ret = 0; - goto out; - } - } + if (ret == 0) { + /* Got mdata from disk, set it in inode ctx. This case + * is hit when in-memory status is lost due to brick + * down scenario + */ + __inode_ctx_set1(inode, this, (uint64_t *)&mdata); + } else { + /* Failed to get mdata from disk, xattr missing. + * This happens on two cases. + * 1. File is created before ctime is enabled. + * 2. On new file creation. + * + * Do nothing, just return success. It is as + * good as ctime feature is not enabled for this + * file. For files created before ctime is enabled, + * time attributes gets updated into ctime structure + * once the metadata modification fop happens and + * time attributes become consistent eventually. + * For new files, it would obviously get updated + * before the fop completion. + */ + if (stbuf && op_errno != ENOENT) { + ret = 0; + goto out; + } else { + /* This case should not be hit. If it hits, + * don't fail, log warning, free mdata and move + * on + */ + gf_msg(this->name, GF_LOG_WARNING, op_errno, + P_MSG_FETCHMDATA_FAILED, "file: %s: gfid: %s key:%s ", + real_path ? real_path : "null", uuid_utoa(inode->gfid), + GF_XATTR_MDATA_KEY); + GF_FREE(mdata); + ret = 0; + goto out; + } } + } - ret = 0; + ret = 0; - if (ret == 0 && stbuf) { - stbuf->ia_ctime = mdata->ctime.tv_sec; - stbuf->ia_ctime_nsec = mdata->ctime.tv_nsec; - stbuf->ia_mtime = mdata->mtime.tv_sec; - stbuf->ia_mtime_nsec = mdata->mtime.tv_nsec; - stbuf->ia_atime = mdata->atime.tv_sec; - stbuf->ia_atime_nsec = mdata->atime.tv_nsec; - } + if (ret == 0 && stbuf) { + stbuf->ia_ctime = mdata->ctime.tv_sec; + stbuf->ia_ctime_nsec = mdata->ctime.tv_nsec; + stbuf->ia_mtime = mdata->mtime.tv_sec; + stbuf->ia_mtime_nsec = mdata->mtime.tv_nsec; + stbuf->ia_atime = mdata->atime.tv_sec; + stbuf->ia_atime_nsec = mdata->atime.tv_nsec; + } out: - return ret; + return ret; } /* posix_get_mdata_xattr gets posix_mdata_t from inode context. If it fails * to get it from inode context, gets it from disk. This is with inode lock. */ int -posix_get_mdata_xattr (xlator_t *this, const char *real_path, int _fd, - inode_t *inode, struct iatt *stbuf) +posix_get_mdata_xattr(xlator_t *this, const char *real_path, int _fd, + inode_t *inode, struct iatt *stbuf) { - int ret = -1; + int ret = -1; - GF_VALIDATE_OR_GOTO (this->name, inode, out); + GF_VALIDATE_OR_GOTO(this->name, inode, out); - LOCK (&inode->lock); - { - ret = __posix_get_mdata_xattr (this, real_path, _fd, inode, stbuf); - } - UNLOCK (&inode->lock); + LOCK(&inode->lock); + { + ret = __posix_get_mdata_xattr(this, real_path, _fd, inode, stbuf); + } + UNLOCK(&inode->lock); out: - return ret; + return ret; } static int -posix_compare_timespec (struct timespec *first, struct timespec *second) +posix_compare_timespec(struct timespec *first, struct timespec *second) { - if (first->tv_sec == second->tv_sec) - return first->tv_nsec - second->tv_nsec; - else - return first->tv_sec - second->tv_sec; + if (first->tv_sec == second->tv_sec) + return first->tv_nsec - second->tv_nsec; + else + return first->tv_sec - second->tv_sec; } - /* posix_set_mdata_xattr updates the posix_mdata_t based on the flag * in inode context and stores it on disk */ static int -posix_set_mdata_xattr (xlator_t *this, const char *real_path, int fd, - inode_t *inode, struct timespec *time, - struct iatt *stbuf, posix_mdata_flag_t *flag, - gf_boolean_t update_utime) +posix_set_mdata_xattr(xlator_t *this, const char *real_path, int fd, + inode_t *inode, struct timespec *time, struct iatt *stbuf, + posix_mdata_flag_t *flag, gf_boolean_t update_utime) { - posix_mdata_t *mdata = NULL; - int ret = -1; - int op_errno = 0; - - GF_VALIDATE_OR_GOTO ("posix", this, out); - GF_VALIDATE_OR_GOTO (this->name, inode, out); - - LOCK (&inode->lock); - { - ret = __inode_ctx_get1 (inode, this, - (uint64_t *)&mdata); - if (ret == -1 || !mdata) { - /* - * Do we need to fetch the data from xattr - * If we does we can compare the value and store - * the largest data in inode ctx. - */ - mdata = GF_CALLOC (1, sizeof (posix_mdata_t), - gf_posix_mt_mdata_attr); - if (!mdata) { - ret = -1; - goto unlock; - } - - ret = posix_fetch_mdata_xattr (this, real_path, fd, - inode, - (void *)mdata, &op_errno); - if (ret == 0) { - /* Got mdata from disk, set it in inode ctx. This case - * is hit when in-memory status is lost due to brick - * down scenario - */ - __inode_ctx_set1 (inode, this, - (uint64_t *)&mdata); - } else if (ret && time) { - /* - * This is the first time creating the time - * attr. This happens when you activate this - * feature, and the legacy file will not have - * any xattr set. - * - * New files will create extended attributes. - */ - - /* - * TODO: This is wrong approach, because before - * creating fresh xattr, we should consult - * to all replica and/or distribution set. - * - * We should contact the time management - * xlators, and ask them to create an xattr. - */ - /* We should not be relying on backend file's - * time attributes to load the initial ctime - * time attribute structure. This is incorrect - * as each replica set would have witnessed the - * file creation at different times. - * - * For new file creation, ctime, atime and mtime - * should be same, hence initiate the ctime - * structure with the time from the frame. But - * for the files which were created before ctime - * feature is enabled, this is not accurate but - * still fine as the times would get eventually - * accurate. - */ - mdata->version = 1; - mdata->flags = 0; - mdata->ctime.tv_sec = time->tv_sec; - mdata->ctime.tv_nsec = time->tv_nsec; - mdata->atime.tv_sec = time->tv_sec; - mdata->atime.tv_nsec = time->tv_nsec; - mdata->mtime.tv_sec = time->tv_sec; - mdata->mtime.tv_nsec = time->tv_nsec; - - __inode_ctx_set1 (inode, this, - (uint64_t *)&mdata); - } - } - - /* Earlier, mdata was updated only if the existing time is less - * than the time to be updated. This would fail the scenarios - * where mtime can be set to any time using the syscall. Hence - * just updating without comparison. But the ctime is not - * allowed to changed to older date. - */ + posix_mdata_t *mdata = NULL; + int ret = -1; + int op_errno = 0; + + GF_VALIDATE_OR_GOTO("posix", this, out); + GF_VALIDATE_OR_GOTO(this->name, inode, out); - if (flag->ctime && - posix_compare_timespec (time, &mdata->ctime) > 0) { - mdata->ctime = *time; - } - - /* In distributed systems, there could be races with fops - * updating mtime/atime which could result in different - * mtime/atime for same file. So this makes sure, only the - * highest time is retained. If the mtime/atime update comes - * from the explicit utime syscall, it is allowed to set to - * previous time + LOCK(&inode->lock); + { + ret = __inode_ctx_get1(inode, this, (uint64_t *)&mdata); + if (ret == -1 || !mdata) { + /* + * Do we need to fetch the data from xattr + * If we does we can compare the value and store + * the largest data in inode ctx. + */ + mdata = GF_CALLOC(1, sizeof(posix_mdata_t), gf_posix_mt_mdata_attr); + if (!mdata) { + ret = -1; + goto unlock; + } + + ret = posix_fetch_mdata_xattr(this, real_path, fd, inode, + (void *)mdata, &op_errno); + if (ret == 0) { + /* Got mdata from disk, set it in inode ctx. This case + * is hit when in-memory status is lost due to brick + * down scenario */ - if (update_utime) { - if (flag->mtime) { - mdata->mtime = *time; - } - if (flag->atime) { - mdata->atime = *time; - } - } else { - if (flag->mtime && - posix_compare_timespec (time, &mdata->mtime) > 0) { - mdata->mtime = *time; - } - if (flag->atime && - posix_compare_timespec (time, &mdata->atime) > 0) { - mdata->atime = *time; - } - } - - if (inode->ia_type == IA_INVAL) { - /* - * TODO: This is non-linked inode. So we have to sync the - * data into backend. Because inode_link may return - * a different inode. - */ - /* ret = posix_store_mdata_xattr (this, loc, fd, - * mdata); */ - } + __inode_ctx_set1(inode, this, (uint64_t *)&mdata); + } else if (ret && time) { /* - * With this patch set, we are setting the xattr for each update - * We should evaluate the performance, and based on that we can - * decide on asynchronous updation. + * This is the first time creating the time + * attr. This happens when you activate this + * feature, and the legacy file will not have + * any xattr set. + * + * New files will create extended attributes. */ - ret = posix_store_mdata_xattr (this, real_path, fd, inode, - mdata); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - P_MSG_STOREMDATA_FAILED, - "file: %s: gfid: %s key:%s ", - real_path ? real_path : "null", - uuid_utoa(inode->gfid), GF_XATTR_MDATA_KEY); - goto unlock; - } + + /* + * TODO: This is wrong approach, because before + * creating fresh xattr, we should consult + * to all replica and/or distribution set. + * + * We should contact the time management + * xlators, and ask them to create an xattr. + */ + /* We should not be relying on backend file's + * time attributes to load the initial ctime + * time attribute structure. This is incorrect + * as each replica set would have witnessed the + * file creation at different times. + * + * For new file creation, ctime, atime and mtime + * should be same, hence initiate the ctime + * structure with the time from the frame. But + * for the files which were created before ctime + * feature is enabled, this is not accurate but + * still fine as the times would get eventually + * accurate. + */ + mdata->version = 1; + mdata->flags = 0; + mdata->ctime.tv_sec = time->tv_sec; + mdata->ctime.tv_nsec = time->tv_nsec; + mdata->atime.tv_sec = time->tv_sec; + mdata->atime.tv_nsec = time->tv_nsec; + mdata->mtime.tv_sec = time->tv_sec; + mdata->mtime.tv_nsec = time->tv_nsec; + + __inode_ctx_set1(inode, this, (uint64_t *)&mdata); + } } -unlock: - UNLOCK (&inode->lock); -out: - if (ret == 0 && stbuf) { - stbuf->ia_ctime = mdata->ctime.tv_sec; - stbuf->ia_ctime_nsec = mdata->ctime.tv_nsec; - stbuf->ia_mtime = mdata->mtime.tv_sec; - stbuf->ia_mtime_nsec = mdata->mtime.tv_nsec; - stbuf->ia_atime = mdata->atime.tv_sec; - stbuf->ia_atime_nsec = mdata->atime.tv_nsec; + + /* Earlier, mdata was updated only if the existing time is less + * than the time to be updated. This would fail the scenarios + * where mtime can be set to any time using the syscall. Hence + * just updating without comparison. But the ctime is not + * allowed to changed to older date. + */ + + if (flag->ctime && posix_compare_timespec(time, &mdata->ctime) > 0) { + mdata->ctime = *time; + } + + /* In distributed systems, there could be races with fops + * updating mtime/atime which could result in different + * mtime/atime for same file. So this makes sure, only the + * highest time is retained. If the mtime/atime update comes + * from the explicit utime syscall, it is allowed to set to + * previous time + */ + if (update_utime) { + if (flag->mtime) { + mdata->mtime = *time; + } + if (flag->atime) { + mdata->atime = *time; + } + } else { + if (flag->mtime && + posix_compare_timespec(time, &mdata->mtime) > 0) { + mdata->mtime = *time; + } + if (flag->atime && + posix_compare_timespec(time, &mdata->atime) > 0) { + mdata->atime = *time; + } } - return ret; + if (inode->ia_type == IA_INVAL) { + /* + * TODO: This is non-linked inode. So we have to sync the + * data into backend. Because inode_link may return + * a different inode. + */ + /* ret = posix_store_mdata_xattr (this, loc, fd, + * mdata); */ + } + /* + * With this patch set, we are setting the xattr for each update + * We should evaluate the performance, and based on that we can + * decide on asynchronous updation. + */ + ret = posix_store_mdata_xattr(this, real_path, fd, inode, mdata); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_STOREMDATA_FAILED, + "file: %s: gfid: %s key:%s ", real_path ? real_path : "null", + uuid_utoa(inode->gfid), GF_XATTR_MDATA_KEY); + goto unlock; + } + } +unlock: + UNLOCK(&inode->lock); +out: + if (ret == 0 && stbuf) { + stbuf->ia_ctime = mdata->ctime.tv_sec; + stbuf->ia_ctime_nsec = mdata->ctime.tv_nsec; + stbuf->ia_mtime = mdata->mtime.tv_sec; + stbuf->ia_mtime_nsec = mdata->mtime.tv_nsec; + stbuf->ia_atime = mdata->atime.tv_sec; + stbuf->ia_atime_nsec = mdata->atime.tv_nsec; + } + + return ret; } /* posix_update_utime_in_mdata updates the posix_mdata_t when mtime/atime * is modified using syscall */ void -posix_update_utime_in_mdata (xlator_t *this, const char *real_path, int fd, - inode_t *inode, - struct iatt *stbuf, int valid) +posix_update_utime_in_mdata(xlator_t *this, const char *real_path, int fd, + inode_t *inode, struct iatt *stbuf, int valid) { - int32_t ret = 0; + int32_t ret = 0; #if defined(HAVE_UTIMENSAT) - struct timespec tv = {0, }; + struct timespec tv = { + 0, + }; #else - struct timeval tv = {0, }; + struct timeval tv = { + 0, + }; #endif - posix_mdata_flag_t flag = {0, }; - - struct posix_private *priv = NULL; - - priv = this->private; - - if (inode && priv->ctime) { - if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { - tv.tv_sec = stbuf->ia_atime; - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, stbuf->ia_atime_nsec); - - flag.ctime = 0; - flag.mtime = 0; - flag.atime = 1; - ret = posix_set_mdata_xattr (this, real_path, -1, inode, &tv, NULL, - &flag, _gf_true); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix set mdata atime failed on file:" - " %s gfid:%s", - real_path, uuid_utoa (inode->gfid)); - } - } - - if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { - tv.tv_sec = stbuf->ia_mtime; - SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, stbuf->ia_mtime_nsec); - - flag.ctime = 1; - flag.mtime = 1; - flag.atime = 0; - - ret = posix_set_mdata_xattr (this, real_path, -1, inode, &tv, NULL, - &flag, _gf_true); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix set mdata mtime failed on file:" - " %s gfid:%s", - real_path, uuid_utoa (inode->gfid)); - } - } + posix_mdata_flag_t flag = { + 0, + }; + + struct posix_private *priv = NULL; + + priv = this->private; + + if (inode && priv->ctime) { + if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) { + tv.tv_sec = stbuf->ia_atime; + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, stbuf->ia_atime_nsec); + + flag.ctime = 0; + flag.mtime = 0; + flag.atime = 1; + ret = posix_set_mdata_xattr(this, real_path, -1, inode, &tv, NULL, + &flag, _gf_true); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix set mdata atime failed on file:" + " %s gfid:%s", + real_path, uuid_utoa(inode->gfid)); + } + } - } else { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix utime set mdata failed on file"); + if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) { + tv.tv_sec = stbuf->ia_mtime; + SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv, stbuf->ia_mtime_nsec); + + flag.ctime = 1; + flag.mtime = 1; + flag.atime = 0; + + ret = posix_set_mdata_xattr(this, real_path, -1, inode, &tv, NULL, + &flag, _gf_true); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix set mdata mtime failed on file:" + " %s gfid:%s", + real_path, uuid_utoa(inode->gfid)); + } } - return; + + } else { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix utime set mdata failed on file"); + } + return; } static void -posix_get_mdata_flag (uint64_t flags, posix_mdata_flag_t *flag) +posix_get_mdata_flag(uint64_t flags, posix_mdata_flag_t *flag) { - if (!flag) - return; - - flag->ctime = 0; - flag->atime = 0; - flag->mtime = 0; - - if (flags & MDATA_CTIME) - flag->ctime = 1; - if (flags & MDATA_MTIME) - flag->mtime = 1; - if (flags & MDATA_ATIME) - flag->atime = 1; + if (!flag) + return; + + flag->ctime = 0; + flag->atime = 0; + flag->mtime = 0; + + if (flags & MDATA_CTIME) + flag->ctime = 1; + if (flags & MDATA_MTIME) + flag->mtime = 1; + if (flags & MDATA_ATIME) + flag->atime = 1; } static void -posix_get_parent_mdata_flag (uint64_t flags, posix_mdata_flag_t *flag) +posix_get_parent_mdata_flag(uint64_t flags, posix_mdata_flag_t *flag) { - if (!flag) - return; - - flag->ctime = 0; - flag->atime = 0; - flag->mtime = 0; - - if (flags & MDATA_PAR_CTIME) - flag->ctime = 1; - if (flags & MDATA_PAR_MTIME) - flag->mtime = 1; - if (flags & MDATA_PAR_ATIME) - flag->atime = 1; + if (!flag) + return; + + flag->ctime = 0; + flag->atime = 0; + flag->mtime = 0; + + if (flags & MDATA_PAR_CTIME) + flag->ctime = 1; + if (flags & MDATA_PAR_MTIME) + flag->mtime = 1; + if (flags & MDATA_PAR_ATIME) + flag->atime = 1; } void -posix_set_ctime (call_frame_t *frame, xlator_t *this, const char* real_path, - int fd, inode_t *inode, struct iatt *stbuf) +posix_set_ctime(call_frame_t *frame, xlator_t *this, const char *real_path, + int fd, inode_t *inode, struct iatt *stbuf) { - posix_mdata_flag_t flag = {0,}; - int ret = 0; - struct posix_private *priv = NULL; - - priv = this->private; - - if (priv->ctime) { - (void) posix_get_mdata_flag (frame->root->flags, &flag); - if (frame->root->ctime.tv_sec == 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix set mdata failed, No ctime : %s gfid:%s", - real_path, - inode ? uuid_utoa (inode->gfid) : "No inode"); - goto out; - } - - ret = posix_set_mdata_xattr (this, real_path, fd, inode, - &frame->root->ctime, stbuf, &flag, - _gf_false); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix set mdata failed on file: %s gfid:%s", - real_path, - inode ? uuid_utoa (inode->gfid) : "No inode"); - } + posix_mdata_flag_t flag = { + 0, + }; + int ret = 0; + struct posix_private *priv = NULL; + + priv = this->private; + + if (priv->ctime) { + (void)posix_get_mdata_flag(frame->root->flags, &flag); + if (frame->root->ctime.tv_sec == 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix set mdata failed, No ctime : %s gfid:%s", real_path, + inode ? uuid_utoa(inode->gfid) : "No inode"); + goto out; } - out: - return; + + ret = posix_set_mdata_xattr(this, real_path, fd, inode, + &frame->root->ctime, stbuf, &flag, + _gf_false); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix set mdata failed on file: %s gfid:%s", real_path, + inode ? uuid_utoa(inode->gfid) : "No inode"); + } + } +out: + return; } void -posix_set_parent_ctime (call_frame_t *frame, xlator_t *this, - const char* real_path, int fd, inode_t *inode, - struct iatt *stbuf) +posix_set_parent_ctime(call_frame_t *frame, xlator_t *this, + const char *real_path, int fd, inode_t *inode, + struct iatt *stbuf) { - posix_mdata_flag_t flag = {0,}; - int ret = 0; - struct posix_private *priv = NULL; - - priv = this->private; - - if (inode && priv->ctime) { - (void) posix_get_parent_mdata_flag (frame->root->flags, &flag); - ret = posix_set_mdata_xattr (this, real_path, fd, inode, - &frame->root->ctime, stbuf, &flag, - _gf_false); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, errno, - P_MSG_SETMDATA_FAILED, - "posix set mdata failed on file: %s gfid:%s", - real_path, uuid_utoa (inode->gfid)); - } + posix_mdata_flag_t flag = { + 0, + }; + int ret = 0; + struct posix_private *priv = NULL; + + priv = this->private; + + if (inode && priv->ctime) { + (void)posix_get_parent_mdata_flag(frame->root->flags, &flag); + ret = posix_set_mdata_xattr(this, real_path, fd, inode, + &frame->root->ctime, stbuf, &flag, + _gf_false); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, errno, P_MSG_SETMDATA_FAILED, + "posix set mdata failed on file: %s gfid:%s", real_path, + uuid_utoa(inode->gfid)); } - return; + } + return; } diff --git a/xlators/storage/posix/src/posix.c b/xlators/storage/posix/src/posix.c index b8a71ce0fd8..61aa14d2827 100644 --- a/xlators/storage/posix/src/posix.c +++ b/xlators/storage/posix/src/posix.c @@ -17,71 +17,67 @@ #include "xlator.h" #include "posix.h" -class_methods_t class_methods = { - .init = posix_init, - .fini = posix_fini, - .reconfigure = posix_reconfigure, - .notify = posix_notify -}; +class_methods_t class_methods = {.init = posix_init, + .fini = posix_fini, + .reconfigure = posix_reconfigure, + .notify = posix_notify}; struct xlator_dumpops dumpops = { - .priv = posix_priv, - .inode = posix_inode, + .priv = posix_priv, + .inode = posix_inode, }; struct xlator_fops fops = { - .lookup = posix_lookup, - .stat = posix_stat, - .opendir = posix_opendir, - .readdir = posix_readdir, - .readdirp = posix_readdirp, - .readlink = posix_readlink, - .mknod = posix_mknod, - .mkdir = posix_mkdir, - .unlink = posix_unlink, - .rmdir = posix_rmdir, - .symlink = posix_symlink, - .rename = posix_rename, - .link = posix_link, - .truncate = posix_truncate, - .create = posix_create, - .open = posix_open, - .readv = posix_readv, - .writev = posix_writev, - .statfs = posix_statfs, - .flush = posix_flush, - .fsync = posix_fsync, - .setxattr = posix_setxattr, - .fsetxattr = posix_fsetxattr, - .getxattr = posix_getxattr, - .fgetxattr = posix_fgetxattr, - .removexattr = posix_removexattr, - .fremovexattr = posix_fremovexattr, - .fsyncdir = posix_fsyncdir, - .access = posix_access, - .ftruncate = posix_ftruncate, - .fstat = posix_fstat, - .lk = posix_lk, - .inodelk = posix_inodelk, - .finodelk = posix_finodelk, - .entrylk = posix_entrylk, - .fentrylk = posix_fentrylk, - .rchecksum = posix_rchecksum, - .xattrop = posix_xattrop, - .fxattrop = posix_fxattrop, - .setattr = posix_setattr, - .fsetattr = posix_fsetattr, - .fallocate = posix_glfallocate, - .discard = posix_discard, - .zerofill = posix_zerofill, - .ipc = posix_ipc, - .seek = posix_seek, - .lease = posix_lease, - .put = posix_put, + .lookup = posix_lookup, + .stat = posix_stat, + .opendir = posix_opendir, + .readdir = posix_readdir, + .readdirp = posix_readdirp, + .readlink = posix_readlink, + .mknod = posix_mknod, + .mkdir = posix_mkdir, + .unlink = posix_unlink, + .rmdir = posix_rmdir, + .symlink = posix_symlink, + .rename = posix_rename, + .link = posix_link, + .truncate = posix_truncate, + .create = posix_create, + .open = posix_open, + .readv = posix_readv, + .writev = posix_writev, + .statfs = posix_statfs, + .flush = posix_flush, + .fsync = posix_fsync, + .setxattr = posix_setxattr, + .fsetxattr = posix_fsetxattr, + .getxattr = posix_getxattr, + .fgetxattr = posix_fgetxattr, + .removexattr = posix_removexattr, + .fremovexattr = posix_fremovexattr, + .fsyncdir = posix_fsyncdir, + .access = posix_access, + .ftruncate = posix_ftruncate, + .fstat = posix_fstat, + .lk = posix_lk, + .inodelk = posix_inodelk, + .finodelk = posix_finodelk, + .entrylk = posix_entrylk, + .fentrylk = posix_fentrylk, + .rchecksum = posix_rchecksum, + .xattrop = posix_xattrop, + .fxattrop = posix_fxattrop, + .setattr = posix_setattr, + .fsetattr = posix_fsetattr, + .fallocate = posix_glfallocate, + .discard = posix_discard, + .zerofill = posix_zerofill, + .ipc = posix_ipc, + .seek = posix_seek, + .lease = posix_lease, + .put = posix_put, }; -struct xlator_cbks cbks = { - .release = posix_release, - .releasedir = posix_releasedir, - .forget = posix_forget -}; +struct xlator_cbks cbks = {.release = posix_release, + .releasedir = posix_releasedir, + .forget = posix_forget}; |