static int default_read_from_path(uint64_t oid, const char *path,
const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
ssize_t size;
/*
* Make sure oid is in the right place because oid might be misplaced
* in a wrong place, due to 'shutdown/restart with less disks' or any
* bugs. We need call err_to_sderr() to return EIO if disk is broken.
*
* For stale path, get_store_stale_path already does default_exist job.
*/
if (!is_stale_path(path) && !default_exist(oid, iocb->ec_index))
return err_to_sderr(path, oid, ENOENT);
fd = open(path, flags);
if (fd < 0)
return err_to_sderr(path, oid, errno);
size = xpread(fd, iocb->buf, iocb->length, iocb->offset);
if (unlikely(size != iocb->length)) {
sd_err("failed to read object %"PRIx64", path=%s, offset=%"
PRId32", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
}
close(fd);
return ret;
}
int default_write(uint64_t oid, const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
char path[PATH_MAX];
ssize_t size;
uint32_t len = iocb->length;
uint64_t offset = iocb->offset;
static bool trim_is_supported = true;
if (iocb->epoch < sys_epoch()) {
sd_debug("%"PRIu32" sys %"PRIu32, iocb->epoch, sys_epoch());
return SD_RES_OLD_NODE_VER;
}
if (uatomic_is_true(&sys->use_journal) &&
unlikely(journal_write_store(oid, iocb->buf, iocb->length,
iocb->offset, false))
!= SD_RES_SUCCESS) {
sd_err("turn off journaling");
uatomic_set_false(&sys->use_journal);
flags |= O_DSYNC;
sync();
}
get_store_path(oid, iocb->ec_index, path);
/*
* Make sure oid is in the right place because oid might be misplaced
* in a wrong place, due to 'shutdown/restart with less/more disks' or
* any bugs. We need call err_to_sderr() to return EIO if disk is broken
*/
if (!default_exist(oid, iocb->ec_index))
return err_to_sderr(path, oid, ENOENT);
fd = open(path, flags, sd_def_fmode);
if (unlikely(fd < 0))
return err_to_sderr(path, oid, errno);
if (trim_is_supported && is_sparse_object(oid)) {
if (default_trim(fd, oid, iocb, &offset, &len) < 0) {
trim_is_supported = false;
offset = iocb->offset;
len = iocb->length;
}
}
size = xpwrite(fd, iocb->buf, len, offset);
if (unlikely(size != len)) {
sd_err("failed to write object %"PRIx64", path=%s, offset=%"
PRId32", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
goto out;
}
out:
close(fd);
return ret;
}
int default_create_and_write(uint64_t oid, const struct siocb *iocb)
{
char path[PATH_MAX], tmp_path[PATH_MAX];
int flags = prepare_iocb(oid, iocb, true);
int ret, fd;
uint32_t len = iocb->length;
bool ec = is_erasure_obj(oid, iocb->copy_policy);
size_t obj_size;
sd_debug("%"PRIx64, oid);
get_obj_path(oid, path, sizeof(path));
get_tmp_obj_path(oid, tmp_path, sizeof(tmp_path));
if (uatomic_is_true(&sys->use_journal) &&
journal_write_store(oid, iocb->buf, iocb->length,
iocb->offset, true)
!= SD_RES_SUCCESS) {
sd_err("turn off journaling");
uatomic_set_false(&sys->use_journal);
flags |= O_DSYNC;
sync();
}
fd = open(tmp_path, flags, sd_def_fmode);
if (fd < 0) {
if (errno == EEXIST) {
/*
* This happens if node membership changes during object
* creation; while gateway retries a CREATE request,
* recovery process could also recover the object at the
* same time. They should try to write the same date,
* so it is okay to simply return success here.
*/
sd_debug("%s exists", tmp_path);
return SD_RES_SUCCESS;
}
sd_err("failed to open %s: %m", tmp_path);
return err_to_sderr(path, oid, errno);
}
if (ec) {
uint8_t policy = iocb->copy_policy ?:
get_vdi_copy_policy(oid_to_vid(oid));
int d;
ec_policy_to_dp(policy, &d, NULL);
obj_size = SD_DATA_OBJ_SIZE / d;
} else
int default_write(uint64_t oid, const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
char path[PATH_MAX];
ssize_t size;
if (iocb->epoch < sys_epoch()) {
sd_debug("%"PRIu32" sys %"PRIu32, iocb->epoch, sys_epoch());
return SD_RES_OLD_NODE_VER;
}
if (uatomic_is_true(&sys->use_journal) &&
unlikely(journal_write_store(oid, iocb->buf, iocb->length,
iocb->offset, false))
!= SD_RES_SUCCESS) {
sd_err("turn off journaling");
uatomic_set_false(&sys->use_journal);
flags |= O_DSYNC;
sync();
}
get_obj_path(oid, path);
fd = open(path, flags, sd_def_fmode);
if (unlikely(fd < 0))
return err_to_sderr(path, oid, errno);
size = xpwrite(fd, iocb->buf, iocb->length, iocb->offset);
if (unlikely(size != iocb->length)) {
sd_err("failed to write object %"PRIx64", path=%s, offset=%"
PRId64", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
goto out;
}
out:
close(fd);
return ret;
}
static int default_read_from_path(uint64_t oid, char *path,
const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
ssize_t size;
fd = open(path, flags);
if (fd < 0)
return err_to_sderr(path, oid, errno);
size = xpread(fd, iocb->buf, iocb->length, iocb->offset);
if (unlikely(size != iocb->length)) {
sd_err("failed to read object %"PRIx64", path=%s, offset=%"
PRId64", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
}
close(fd);
return ret;
}
int default_write(uint64_t oid, const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
char path[PATH_MAX];
ssize_t size;
if (iocb->epoch < sys_epoch()) {
sd_debug("%"PRIu32" sys %"PRIu32, iocb->epoch, sys_epoch());
return SD_RES_OLD_NODE_VER;
}
get_store_path(oid, iocb->ec_index, path);
/*
* Make sure oid is in the right place because oid might be misplaced
* in a wrong place, due to 'shutdown/restart with less/more disks' or
* any bugs. We need call err_to_sderr() to return EIO if disk is broken
*/
if (!default_exist(oid, iocb->ec_index))
return err_to_sderr(path, oid, errno);
fd = open(path, flags, sd_def_fmode);
if (unlikely(fd < 0))
return err_to_sderr(path, oid, errno);
size = xpwrite(fd, iocb->buf, iocb->length, iocb->offset);
if (unlikely(size != iocb->length)) {
sd_err("failed to write object %"PRIx64", path=%s, offset=%"
PRId32", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
goto out;
}
out:
close(fd);
return ret;
}
static int default_read_from_path(uint64_t oid, const char *path,
const struct siocb *iocb)
{
int flags = prepare_iocb(oid, iocb, false), fd,
ret = SD_RES_SUCCESS;
ssize_t size;
fd = open(path, flags);
if (fd < 0)
return err_to_sderr(path, oid, errno);
if (is_erasure_oid(oid) && iocb->ec_index <= SD_MAX_COPIES) {
uint8_t idx;
if (get_erasure_index(path, &idx) < 0) {
close(fd);
return err_to_sderr(path, oid, errno);
}
/* We pretend NO-OBJ to read old object in the stale dir */
if (idx != iocb->ec_index) {
sd_debug("ec_index %d != %d", iocb->ec_index, idx);
close(fd);
return SD_RES_NO_OBJ;
}
}
size = xpread(fd, iocb->buf, iocb->length, iocb->offset);
if (unlikely(size != iocb->length)) {
sd_err("failed to read object %"PRIx64", path=%s, offset=%"
PRId32", size=%"PRId32", result=%zd, %m", oid, path,
iocb->offset, iocb->length, size);
ret = err_to_sderr(path, oid, errno);
}
close(fd);
return ret;
}
int default_create_and_write(uint64_t oid, const struct siocb *iocb)
{
char path[PATH_MAX], tmp_path[PATH_MAX];
int flags = prepare_iocb(oid, iocb, true);
int ret, fd;
uint32_t len = iocb->length;
size_t obj_size;
uint64_t offset = iocb->offset;
sd_debug("%"PRIx64, oid);
get_store_path(oid, iocb->ec_index, path);
get_store_tmp_path(oid, iocb->ec_index, tmp_path);
if (uatomic_is_true(&sys->use_journal) &&
journal_write_store(oid, iocb->buf, iocb->length,
iocb->offset, true)
!= SD_RES_SUCCESS) {
sd_err("turn off journaling");
uatomic_set_false(&sys->use_journal);
flags |= O_DSYNC;
sync();
}
fd = open(tmp_path, flags, sd_def_fmode);
if (fd < 0) {
if (errno == EEXIST) {
/*
* This happens if node membership changes during object
* creation; while gateway retries a CREATE request,
* recovery process could also recover the object at the
* same time. They should try to write the same date,
* so it is okay to simply return success here.
*/
sd_debug("%s exists", tmp_path);
return SD_RES_SUCCESS;
}
sd_err("failed to open %s: %m", tmp_path);
return err_to_sderr(path, oid, errno);
}
obj_size = get_store_objsize(oid);
trim_zero_blocks(iocb->buf, &offset, &len);
if (offset != 0 || len != get_objsize(oid)) {
if (is_sparse_object(oid))
ret = xftruncate(fd, obj_size);
else
ret = prealloc(fd, obj_size);
if (ret < 0) {
ret = err_to_sderr(path, oid, errno);
goto out;
}
}
ret = xpwrite(fd, iocb->buf, len, offset);
if (ret != len) {
sd_err("failed to write object. %m");
ret = err_to_sderr(path, oid, errno);
goto out;
}
ret = rename(tmp_path, path);
if (ret < 0) {
sd_err("failed to rename %s to %s: %m", tmp_path, path);
ret = err_to_sderr(path, oid, errno);
goto out;
}
ret = SD_RES_SUCCESS;
objlist_cache_insert(oid);
out:
if (ret != SD_RES_SUCCESS)
unlink(tmp_path);
close(fd);
return ret;
}
int default_create_and_write(uint64_t oid, const struct siocb *iocb)
{
char path[PATH_MAX], tmp_path[PATH_MAX];
int flags = prepare_iocb(oid, iocb, true);
int ret, fd;
uint32_t len = iocb->length;
size_t obj_size;
sd_debug("%"PRIx64, oid);
get_store_path(oid, iocb->ec_index, path);
get_store_tmp_path(oid, iocb->ec_index, tmp_path);
fd = open(tmp_path, flags, sd_def_fmode);
if (fd < 0) {
if (errno == EEXIST) {
/*
* This happens if node membership changes during object
* creation; while gateway retries a CREATE request,
* recovery process could also recover the object at the
* same time. They should try to write the same date,
* so it is okay to simply return success here.
*/
sd_debug("%s exists", tmp_path);
return SD_RES_SUCCESS;
}
sd_err("failed to open %s: %m", tmp_path);
return err_to_sderr(path, oid, errno);
}
obj_size = get_store_objsize(oid);
ret = prealloc(fd, obj_size);
if (ret < 0) {
ret = err_to_sderr(path, oid, errno);
goto out;
}
ret = xpwrite(fd, iocb->buf, len, iocb->offset);
if (ret != len) {
sd_err("failed to write object. %m");
ret = err_to_sderr(path, oid, errno);
goto out;
}
/*
* Modern FS like ext4, xfs defaults to automatic syncing of files after
* replace-via-rename and replace-via-truncate operations. So rename
* without fsync() is actually safe.
*/
ret = rename(tmp_path, path);
if (ret < 0) {
sd_err("failed to rename %s to %s: %m", tmp_path, path);
ret = err_to_sderr(path, oid, errno);
goto out;
}
ret = SD_RES_SUCCESS;
objlist_cache_insert(oid);
out:
if (ret != SD_RES_SUCCESS && unlink(tmp_path) != 0)
sd_err("failed to unlink %s: %m", tmp_path);
close(fd);
return ret;
}
