/*
Copyright (c) 2018 Red Hat, Inc. <http://www.redhat.com>
This file is part of GlusterFS.
This file is licensed to you under your choice of the GNU Lesser
General Public License, version 3 or any later version (LGPLv3 or
later), or the GNU General Public License, version 2 (GPLv2), in all
cases as published by the Free Software Foundation.
*/
#include <glusterfs/xlator.h>
#include "posix-metadata.h"
#include "posix-metadata-disk.h"
#include "posix-handle.h"
#include "posix-messages.h"
#include <glusterfs/syscall.h>
#include <glusterfs/compat-errno.h>
#include <glusterfs/compat.h>
static int gf_posix_xattr_enotsup_log;
/* posix_mdata_to_disk converts posix_mdata_t into network byte order to
* save it on disk in machine independent format
*/
static inline void
posix_mdata_to_disk(posix_mdata_disk_t *out, posix_mdata_t *in)
{
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->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);
}
/* 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)
{
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->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);
}
void
posix_mdata_iatt_from_disk(struct mdata_iatt *out, posix_mdata_disk_t *in)
{
out->ia_ctime = be64toh(in->ctime.tv_sec);
out->ia_ctime_nsec = be64toh(in->ctime.tv_nsec);
out->ia_mtime = be64toh(in->mtime.tv_sec);
out->ia_mtime_nsec = be64toh(in->mtime.tv_nsec);
out->ia_atime = be64toh(in->atime.tv_sec);
out->ia_atime_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)
{
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)) {
GF_VALIDATE_OR_GOTO(this->name, inode, out);
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"),
inode ? uuid_utoa(inode->gfid) : "null");
} 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"),
inode ? uuid_utoa(inode->gfid) : "null", 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;
}
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"),
inode ? uuid_utoa(inode->gfid) : "null", key);
goto out;
}
posix_mdata_from_disk(metadata, (posix_mdata_disk_t *)value);
op_ret = 0;
out:
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)
{
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);
}
#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;
}
/* _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_mdata_t *mdata = NULL;
int ret = -1;
int op_errno = 0;
/* Handle readdirp: inode might be null, time attributes should be served
* from xattr not from backend's file attributes */
if (inode) {
ret = __inode_ctx_get1(inode, this, (uint64_t *)&mdata);
} else {
ret = -1;
}
if (ret == -1 || !mdata) {
mdata = GF_CALLOC(1, sizeof(posix_mdata_t), gf_posix_mt_mdata_attr);
if (!mdata) {
gf_msg(this->name, GF_LOG_ERROR, ENOMEM, P_MSG_NOMEM,
"Could not allocate mdata. file: %s: gfid: %s",
real_path ? real_path : "null",
inode ? uuid_utoa(inode->gfid) : "null");
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
*/
if (inode) {
__inode_ctx_set1(inode, this, (uint64_t *)&mdata);
}
} else {
/* Failed to get mdata from disk, xattr missing.
* This happens when the file is created before
* ctime is enabled.
*/
if (stbuf && op_errno != ENOENT) {
ret = 0;
GF_FREE(mdata);
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",
inode ? uuid_utoa(inode->gfid) : "null",
GF_XATTR_MDATA_KEY);
GF_FREE(mdata);
ret = 0;
goto out;
}
}
}
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;
}
/* Not set in inode context, hence free mdata */
if (!inode) {
GF_FREE(mdata);
}
out:
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)
{
int ret = -1;
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);
out:
return ret;
}
static int
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;
}
int
posix_set_mdata_xattr_legacy_files(xlator_t *this, inode_t *inode,
const char *realpath,
struct mdata_iatt *mdata_iatt, int *op_errno)
{
posix_mdata_t *mdata = NULL;
posix_mdata_t imdata = {
0,
};
int ret = 0;
gf_boolean_t mdata_already_set = _gf_false;
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 == 0 && mdata) {
mdata_already_set = _gf_true;
} else if (ret == -1 || !mdata) {
mdata = GF_CALLOC(1, sizeof(posix_mdata_t), gf_posix_mt_mdata_attr);
if (!mdata) {
gf_msg(this->name, GF_LOG_ERROR, ENOMEM, P_MSG_NOMEM,
"Could not allocate mdata. gfid: %s",
uuid_utoa(inode->gfid));
ret = -1;
*op_errno = ENOMEM;
goto unlock;
}
ret = posix_fetch_mdata_xattr(this, realpath, -1, inode,
(void *)mdata, op_errno);
if (ret == 0) {
/* Got mdata from disk. This is a race, another client
* has healed the xattr during lookup. So set it in inode
* ctx */
__inode_ctx_set1(inode, this, (uint64_t *)&mdata);
mdata_already_set = _gf_true;
} else {
*op_errno = 0;
mdata->version = 1;
mdata->flags = 0;
mdata->ctime.tv_sec = mdata_iatt->ia_ctime;
mdata->ctime.tv_nsec = mdata_iatt->ia_ctime_nsec;
mdata->atime.tv_sec = mdata_iatt->ia_atime;
mdata->atime.tv_nsec = mdata_iatt->ia_atime_nsec;
mdata->mtime.tv_sec = mdata_iatt->ia_mtime;
mdata->mtime.tv_nsec = mdata_iatt->ia_mtime_nsec;
__inode_ctx_set1(inode, this, (uint64_t *)&mdata);
}
}
if (mdata_already_set) {
/* Compare and update the larger time */
imdata.ctime.tv_sec = mdata_iatt->ia_ctime;
imdata.ctime.tv_nsec = mdata_iatt->ia_ctime_nsec;
imdata.atime.tv_sec = mdata_iatt->ia_atime;
imdata.atime.tv_nsec = mdata_iatt->ia_atime_nsec;
imdata.mtime.tv_sec = mdata_iatt->ia_mtime;
imdata.mtime.tv_nsec = mdata_iatt->ia_mtime_nsec;
if (posix_compare_timespec(&imdata.ctime, &mdata->ctime) > 0) {
mdata->ctime = imdata.ctime;
}
if (posix_compare_timespec(&imdata.mtime, &mdata->mtime) > 0) {
mdata->mtime = imdata.mtime;
}
if (posix_compare_timespec(&imdata.atime, &mdata->atime) > 0) {
mdata->atime = imdata.atime;
}
}
ret = posix_store_mdata_xattr(this, realpath, -1, inode, mdata);
if (ret) {
gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_STOREMDATA_FAILED,
"gfid: %s key:%s ", uuid_utoa(inode->gfid),
GF_XATTR_MDATA_KEY);
*op_errno = errno;
goto unlock;
}
}
unlock:
UNLOCK(&inode->lock);
out:
return ret;
}
/* 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 timespec *u_atime, struct timespec *u_mtime,
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);
GF_VALIDATE_OR_GOTO(this->name, time, out);
if (update_utime && (flag->ctime && !time) && (flag->atime && !u_atime) &&
(flag->mtime && !u_mtime)) {
goto 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) {
gf_msg(this->name, GF_LOG_ERROR, ENOMEM, P_MSG_NOMEM,
"Could not allocate mdata. file: %s: gfid: %s",
real_path ? real_path : "null", uuid_utoa(inode->gfid));
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 {
/*
* This is the first time creating the time attr. This happens
* when you activate this feature. On this code path, only new
* files will create mdata xattr. The legacy files (files
* created before ctime enabled) will not have any xattr set.
* The xattr on legacy file will be set via lookup.
*/
/* Don't create xattr with utimes/utimensat, only update if
* present. This otherwise causes issues during inservice
* upgrade. It causes inconsistent xattr values with in replica
* set. The scenario happens during upgrade where clients are
* older versions (without the ctime feature) and the server is
* upgraded to the new version (with the ctime feature which
* is enabled by default).
*/
if (update_utime) {
UNLOCK(&inode->lock);
GF_FREE(mdata);
return 0;
}
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);
}
}
/* 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 or future time but the ctime is always set to
* current time.
*/
if (update_utime) {
if (flag->ctime &&
posix_compare_timespec(time, &mdata->ctime) > 0) {
mdata->ctime = *time;
}
if (flag->mtime) {
mdata->mtime = *u_mtime;
}
if (flag->atime) {
mdata->atime = *u_atime;
}
} else {
if (flag->ctime &&
posix_compare_timespec(time, &mdata->ctime) > 0) {
mdata->ctime = *time;
}
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); */
}
/*
* 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 timespec *ctime,
struct iatt *stbuf, int valid)
{
int32_t ret = 0;
#if defined(HAVE_UTIMENSAT)
struct timespec tv_atime = {
0,
};
struct timespec tv_mtime = {
0,
};
#else
struct timeval tv_atime = {
0,
};
struct timeval tv_mtime = {
0,
};
#endif
posix_mdata_flag_t flag = {
0,
};
struct posix_private *priv = NULL;
priv = this->private;
/* NOTE:
* This routine (utimes) is intentionally allowed for all internal and
* external clients even if ctime is not set. This is because AFR and
* WORM uses time attributes for it's internal operations
*/
if (inode && priv->ctime) {
if ((valid & GF_SET_ATTR_ATIME) == GF_SET_ATTR_ATIME) {
tv_atime.tv_sec = stbuf->ia_atime;
SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv_atime, stbuf->ia_atime_nsec);
flag.ctime = 1;
flag.atime = 1;
}
if ((valid & GF_SET_ATTR_MTIME) == GF_SET_ATTR_MTIME) {
tv_mtime.tv_sec = stbuf->ia_mtime;
SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv_mtime, stbuf->ia_mtime_nsec);
flag.ctime = 1;
flag.mtime = 1;
}
if (flag.mtime || flag.atime) {
ret = posix_set_mdata_xattr(this, real_path, -1, inode, ctime,
&tv_atime, &tv_mtime, 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));
}
}
}
return;
}
/* posix_update_ctime_in_mdata updates the posix_mdata_t when ctime needs
* to be modified
*/
void
posix_update_ctime_in_mdata(xlator_t *this, const char *real_path, int fd,
inode_t *inode, struct timespec *ctime,
struct iatt *stbuf, int valid)
{
int32_t ret = 0;
#if defined(HAVE_UTIMENSAT)
struct timespec tv_ctime = {
0,
};
#else
struct timeval tv_ctime = {
0,
};
#endif
posix_mdata_flag_t flag = {
0,
};
struct posix_private *priv = NULL;
priv = this->private;
if (inode && priv->ctime) {
tv_ctime.tv_sec = stbuf->ia_ctime;
SET_TIMESPEC_NSEC_OR_TIMEVAL_USEC(tv_ctime, stbuf->ia_ctime_nsec);
flag.ctime = 1;
ret = posix_set_mdata_xattr(this, real_path, -1, inode, &tv_ctime, NULL,
NULL, 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));
}
}
return;
}
static void
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;
}
static void
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;
}
void
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 ((flag.ctime == 0) && (flag.mtime == 0) && (flag.atime == 0)) {
goto out;
}
ret = posix_set_mdata_xattr(this, real_path, fd, inode,
&frame->root->ctime, NULL, NULL, 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_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);
if ((flag.ctime == 0) && (flag.mtime == 0) && (flag.atime == 0)) {
goto out;
}
ret = posix_set_mdata_xattr(this, real_path, fd, inode,
&frame->root->ctime, NULL, NULL, 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));
}
}
out:
return;
}
void
posix_set_ctime_cfr(call_frame_t *frame, xlator_t *this,
const char *real_path_in, int fd_in, inode_t *inode_in,
struct iatt *stbuf_in, const char *real_path_out,
int fd_out, inode_t *inode_out, struct iatt *stbuf_out)
{
posix_mdata_flag_t flag = {
0,
};
posix_mdata_flag_t flag_dup = {
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 ((flag.ctime == 0) && (flag.mtime == 0) && (flag.atime == 0)) {
goto out;
}
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 : in: %s gfid_in:%s "
"out: %s gfid_out:%s",
real_path_in,
inode_in ? uuid_utoa(inode_in->gfid) : "No inode",
real_path_out,
inode_out ? uuid_utoa(inode_out->gfid) : "No inode");
goto out;
}
flag_dup = flag;
/*
* For the destination file, no need to update atime.
* It got modified. Hence the things that need to be
* changed are mtime and ctime (provided the utime
* xlator from the client has set those flags, which
* are just copied to flag_dup).
*/
if (flag.atime)
flag_dup.atime = 0;
ret = posix_set_mdata_xattr(this, real_path_out, fd_out, inode_out,
&frame->root->ctime, NULL, NULL, stbuf_out,
&flag_dup, _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_out,
inode_out ? uuid_utoa(inode_out->gfid) : "No inode");
}
/*
* For the source file, no need to change the mtime and ctime.
* For source file, it is only read operation. So, if at all
* anything needs to be updated, it is only the atime.
*/
if (flag.atime)
flag_dup.atime = flag.atime;
flag_dup.mtime = 0;
flag_dup.ctime = 0;
ret = posix_set_mdata_xattr(this, real_path_in, fd_out, inode_out,
&frame->root->ctime, NULL, NULL, stbuf_out,
&flag_dup, _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_in,
inode_in ? uuid_utoa(inode_in->gfid) : "No inode");
}
}
out:
return;
}