diff options
Diffstat (limited to 'xlators/cluster/map/src/map.c')
| -rw-r--r-- | xlators/cluster/map/src/map.c | 1911 |
1 files changed, 1142 insertions, 769 deletions
diff --git a/xlators/cluster/map/src/map.c b/xlators/cluster/map/src/map.c index 8c4b7c83c..6150a33ce 100644 --- a/xlators/cluster/map/src/map.c +++ b/xlators/cluster/map/src/map.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2009 Z RESEARCH, Inc. <http://www.zresearch.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2010-2012 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. +*/ #ifndef _CONFIG_H #define _CONFIG_H #include "config.h" @@ -25,104 +15,910 @@ #include "xlator.h" #include "map.h" -/* For <op>_cbk functions */ -#include "defaults.c" +/* TODO : + * -> support for 'get' 'put' API in through xattrs. + * -> define the behavior of notify() + */ + +static int32_t +map_stat_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *buf) + +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +static int32_t +map_setattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *statpre, + struct iatt *statpost) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, statpre->ia_ino, &statpre->ia_ino); + map_itransform (this, prev->this, statpost->ia_ino, &statpost->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, statpre, statpost); + return 0; +} + +static int32_t +map_fsetattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *statpre, + struct iatt *statpost) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, statpre->ia_ino, &statpre->ia_ino); + map_itransform (this, prev->this, statpost->ia_ino, &statpost->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, statpre, statpost); + return 0; +} + +static int32_t +map_truncate_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *prebuf, + struct iatt *postbuf) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, postbuf->ia_ino, &postbuf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, prebuf, postbuf); + return 0; +} + +static int32_t +map_ftruncate_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *prebuf, + struct iatt *postbuf) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, postbuf->ia_ino, &postbuf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, prebuf, postbuf); + return 0; +} + + +static int32_t +map_access_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +static int32_t +map_readlink_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + const char *path, + struct iatt *sbuf) +{ + STACK_UNWIND (frame, op_ret, op_errno, path, sbuf); + return 0; +} + +static int32_t +map_unlink_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *preparent, + struct iatt *postparent) +{ + STACK_UNWIND (frame, op_ret, op_errno, preparent, postparent); + return 0; +} + +static int32_t +map_rmdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *preparent, + struct iatt *postparent) +{ + STACK_UNWIND (frame, op_ret, op_errno, preparent, postparent); + return 0; +} + + +static int32_t +map_rename_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *buf, + struct iatt *preoldparent, + struct iatt *postoldparent, + struct iatt *prenewparent, + struct iatt *postnewparent) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +static int32_t +map_link_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct iatt *buf, + struct iatt *preparent, + struct iatt *postparent) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; +} + +static int32_t +map_open_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) +{ + STACK_UNWIND (frame, op_ret, op_errno, fd); + return 0; +} + +static int32_t +map_readv_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iovec *vector, + int32_t count, + struct iatt *stbuf, + struct iobref *iobref) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, stbuf->ia_ino, &stbuf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, vector, count, stbuf, iobref); + return 0; +} + +static int32_t +map_writev_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *prebuf, + struct iatt *postbuf) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, postbuf->ia_ino, &postbuf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, prebuf, postbuf); + return 0; +} + +static int32_t +map_flush_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_fsync_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *prebuf, + struct iatt *postbuf) +{ + STACK_UNWIND (frame, op_ret, op_errno, prebuf, postbuf); + return 0; +} + + +static int32_t +map_fstat_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct iatt *buf) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + + +static int32_t +map_getdents_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dir_entry_t *entries, + int32_t count) +{ + STACK_UNWIND (frame, op_ret, op_errno, entries, count); + return 0; +} +static int32_t +map_setdents_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +static int32_t +map_fsyncdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_setxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_fsetxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_fgetxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} + + + +static int32_t +map_getxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} + int32_t -map_stat (call_frame_t *frame, - xlator_t *this, - loc_t *loc) +map_xattrop_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) { - int32_t op_errno = 1; - xlator_t *subvol = NULL; + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (loc, err); - VALIDATE_OR_GOTO (loc->inode, err); - VALIDATE_OR_GOTO (loc->path, err); +int32_t +map_fxattrop_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} - subvol = get_mapping_subvol_from_ctx (this, loc->inode); - if (!subvol) { - op_errno = EINVAL; - goto err; +static int32_t +map_removexattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_lk_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct gf_flock *lock) +{ + STACK_UNWIND (frame, op_ret, op_errno, lock); + return 0; +} + + +static int32_t +map_inodelk_cbk (call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, int32_t op_errno) + +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + + +static int32_t +map_finodelk_cbk (call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, int32_t op_errno) + +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_entrylk_cbk (call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, int32_t op_errno) + +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +static int32_t +map_fentrylk_cbk (call_frame_t *frame, void *cookie, + xlator_t *this, int32_t op_ret, int32_t op_errno) + +{ + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +static int32_t +map_newentry_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct iatt *buf, + struct iatt *preparent, + struct iatt *postparent) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; + +} + + +static int32_t +map_create_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + fd_t *fd, + inode_t *inode, + struct iatt *buf, + struct iatt *preparent, + struct iatt *postparent) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, fd, inode, buf); + return 0; +} + + +/* + * map_normalize_stats - + */ +void +map_normalize_stats (struct statvfs *buf, + unsigned long bsize, + unsigned long frsize) +{ + double factor; + + if (buf->f_bsize != bsize) { + factor = ((double) buf->f_bsize) / bsize; + buf->f_bsize = bsize; + buf->f_bfree = (fsblkcnt_t) (factor * buf->f_bfree); + buf->f_bavail = (fsblkcnt_t) (factor * buf->f_bavail); + } + + if (buf->f_frsize != frsize) { + factor = ((double) buf->f_frsize) / frsize; + buf->f_frsize = frsize; + buf->f_blocks = (fsblkcnt_t) (factor * buf->f_blocks); + } +} + + +int32_t +map_statfs_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct statvfs *stbuf) +{ + struct statvfs *dict_buf = NULL; + map_local_t *local = NULL; + int this_call_cnt = 0; + unsigned long bsize; + unsigned long frsize; + + local = frame->local; + + LOCK (&frame->lock); + { + this_call_cnt = --local->call_count; + + if (op_ret == -1) { + local->op_errno = op_errno; + goto unlock; + } + local->op_ret = 0; + + /* when a call is successfull, add it to local->dict */ + dict_buf = &local->statvfs; + + if (dict_buf->f_bsize != 0) { + bsize = max (dict_buf->f_bsize, + stbuf->f_bsize); + + frsize = max (dict_buf->f_frsize, + stbuf->f_frsize); + map_normalize_stats(dict_buf, bsize, frsize); + map_normalize_stats(stbuf, bsize, frsize); + } else { + dict_buf->f_bsize = stbuf->f_bsize; + dict_buf->f_frsize = stbuf->f_frsize; + } + + dict_buf->f_blocks += stbuf->f_blocks; + dict_buf->f_bfree += stbuf->f_bfree; + dict_buf->f_bavail += stbuf->f_bavail; + dict_buf->f_files += stbuf->f_files; + dict_buf->f_ffree += stbuf->f_ffree; + dict_buf->f_favail += stbuf->f_favail; + dict_buf->f_fsid = stbuf->f_fsid; + dict_buf->f_flag = stbuf->f_flag; + dict_buf->f_namemax = stbuf->f_namemax; } +unlock: + UNLOCK (&frame->lock); - STACK_WIND (frame, - default_stat_cbk, - subvol, - subvol->fops->stat, - loc); + if (!this_call_cnt) { + STACK_UNWIND (frame, local->op_ret, local->op_errno, + &local->statvfs); + } return 0; - err: - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); +} + +int32_t +map_single_lookup_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct iatt *buf, + dict_t *dict, + struct iatt *postparent) +{ + call_frame_t *prev = NULL; + prev = cookie; + + map_itransform (this, prev->this, buf->ia_ino, &buf->ia_ino); + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf, dict); + + return 0; +} + +int32_t +map_root_lookup_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct iatt *buf, + dict_t *dict, + struct iatt *postparent) +{ + int callcnt = 0; + map_local_t *local = NULL; + inode_t *tmp_inode = NULL; + dict_t *tmp_dict = NULL; + + local = frame->local; + LOCK (&frame->lock); + { + callcnt = --local->call_count; + if ((op_ret == 0) && (local->op_ret == -1)) { + local->op_ret = 0; + local->stbuf = *buf; + if (dict) + local->dict = dict_ref (dict); + local->inode = inode_ref (inode); + } + if (op_ret == -1) + local->op_errno = op_errno; + + } + UNLOCK (&frame->lock); + + if (!callcnt) { + tmp_dict = local->dict; + tmp_inode = local->inode; + + STACK_UNWIND (frame, local->op_ret, + local->op_errno, local->inode, + &local->stbuf, local->dict); + + inode_unref (local->inode); + if (tmp_dict) + dict_unref (tmp_dict); + } return 0; } int32_t -map_chmod (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode) +map_opendir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) { - int32_t op_errno = 1; - xlator_t *subvol = NULL; + int callcnt = 0; + map_local_t *local = NULL; + fd_t *local_fd = NULL; - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (loc, err); - VALIDATE_OR_GOTO (loc->inode, err); - VALIDATE_OR_GOTO (loc->path, err); + local = frame->local; + LOCK (&frame->lock); + { + callcnt = --local->call_count; - subvol = get_mapping_subvol_from_ctx (this, loc->inode); - if (!subvol) { - op_errno = EINVAL; - goto err; + if (op_ret == -1) { + local->op_errno = op_errno; + goto unlock; + } + + local->op_ret = 0; } + unlock: + UNLOCK (&frame->lock); - STACK_WIND (frame, - default_chmod_cbk, - subvol, - subvol->fops->chmod, - loc, - mode); + if (!callcnt) { + local_fd = local->fd; + local->fd = NULL; + + STACK_UNWIND (frame, local->op_ret, + local->op_errno, local_fd); + + fd_unref (local_fd); + } return 0; - err: - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); +} + +int32_t +map_single_readdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + gf_dirent_t *entries) +{ + call_frame_t *prev = NULL; + gf_dirent_t *orig_entry = NULL; + + prev = cookie; + list_for_each_entry (orig_entry, &entries->list, list) { + map_itransform (this, prev->this, orig_entry->d_ino, + &orig_entry->d_ino); + } + STACK_UNWIND (frame, op_ret, op_errno, entries); + return 0; } + int32_t -map_fchmod (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - mode_t mode) +map_single_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) +{ + call_frame_t *prev = NULL; + gf_dirent_t *orig_entry = NULL; + + prev = cookie; + + list_for_each_entry (orig_entry, &entries->list, list) { + map_itransform (this, prev->this, orig_entry->d_ino, + &orig_entry->d_ino); + orig_entry->d_stat.ia_ino = orig_entry->d_ino; + } + STACK_UNWIND (frame, op_ret, op_errno, entries); + return 0; +} + +int +map_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *orig_entries); + +int +map_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *orig_entries); + +int +map_generic_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *orig_entries, + int whichop) +{ + map_local_t *local = NULL; + gf_dirent_t entries; + gf_dirent_t *orig_entry = NULL; + gf_dirent_t *entry = NULL; + call_frame_t *prev = NULL; + xlator_t *subvol = NULL; + xlator_t *next_subvol = NULL; + off_t next_offset = 0; + int count = 0; + fd_t *local_fd = NULL; + + INIT_LIST_HEAD (&entries.list); + prev = cookie; + local = frame->local; + + if (op_ret < 0) + goto done; + + list_for_each_entry (orig_entry, &orig_entries->list, list) { + subvol = prev->this; + + entry = gf_dirent_for_name (orig_entry->d_name); + if (!entry) { + gf_log (this->name, GF_LOG_ERROR, + "memory allocation failed :("); + goto unwind; + } + + map_itransform (this, subvol, orig_entry->d_ino, + &entry->d_ino); + map_itransform (this, subvol, orig_entry->d_off, + &entry->d_off); + + if (whichop == GF_FOP_READDIRP) + entry->d_stat.ia_ino = entry->d_ino; + entry->d_type = orig_entry->d_type; + entry->d_len = orig_entry->d_len; + + list_add_tail (&entry->list, &entries.list); + count++; + next_offset = orig_entry->d_off; + } + + op_ret = count; + +done: + if (count == 0) { + /* non-zero next_offset means that + EOF is not yet hit on the current subvol + */ + if (next_offset == 0) { + next_subvol = map_subvol_next (this, prev->this); + } else { + next_subvol = prev->this; + } + + if (!next_subvol) { + goto unwind; + } + + if (whichop == GF_FOP_READDIR) + STACK_WIND (frame, map_readdir_cbk, next_subvol, + next_subvol->fops->readdir, local->fd, + local->size, 0); + else + STACK_WIND (frame, map_readdirp_cbk, next_subvol, + next_subvol->fops->readdirp, local->fd, + local->size, 0); + return 0; + } + +unwind: + if (op_ret < 0) + op_ret = 0; + + local_fd = local->fd; + local->fd = NULL; + + STACK_UNWIND (frame, op_ret, op_errno, &entries); + + fd_unref (local_fd); + + gf_dirent_free (&entries); + + return 0; +} + + +int +map_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *orig_entries) +{ + map_generic_readdir_cbk (frame, cookie, this, op_ret, op_errno, + orig_entries, GF_FOP_READDIR); + return 0; +} + + +int +map_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *orig_entries) +{ + map_generic_readdir_cbk (frame, cookie, this, op_ret, op_errno, + orig_entries, GF_FOP_READDIRP); + return 0; +} + + +/* Management operations */ + +static int32_t +map_checksum_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + uint8_t *file_checksum, + uint8_t *dir_checksum) +{ + STACK_UNWIND (frame, op_ret, op_errno, file_checksum, dir_checksum); + return 0; +} + + +/* Fops starts here */ + +int32_t +map_stat (call_frame_t *frame, + xlator_t *this, + loc_t *loc) { int32_t op_errno = 1; xlator_t *subvol = NULL; VALIDATE_OR_GOTO (frame, err); VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - VALIDATE_OR_GOTO (fd->inode, err); + VALIDATE_OR_GOTO (loc, err); + VALIDATE_OR_GOTO (loc->inode, err); + VALIDATE_OR_GOTO (loc->path, err); - subvol = get_mapping_subvol_from_ctx (this, fd->inode); + subvol = get_mapping_subvol_from_ctx (this, loc->inode); if (!subvol) { op_errno = EINVAL; goto err; } - STACK_WIND (frame, - default_fchmod_cbk, - subvol, - subvol->fops->fchmod, - fd, - mode); + STACK_WIND (frame, map_stat_cbk, subvol, subvol->fops->stat, loc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -131,20 +927,21 @@ map_fchmod (call_frame_t *frame, } int32_t -map_chown (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - uid_t uid, - gid_t gid) +map_setattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + struct iatt *stbuf, + int32_t valid) { int32_t op_errno = 1; xlator_t *subvol = NULL; - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (loc, err); - VALIDATE_OR_GOTO (loc->inode, err); - VALIDATE_OR_GOTO (loc->path, err); + GF_VALIDATE_OR_GOTO ("map", this, err); + GF_VALIDATE_OR_GOTO (this->name, frame, err); + GF_VALIDATE_OR_GOTO (this->name, loc, err); + GF_VALIDATE_OR_GOTO (this->name, loc->inode, err); + GF_VALIDATE_OR_GOTO (this->name, loc->path, err); + GF_VALIDATE_OR_GOTO (this->name, stbuf, err); subvol = get_mapping_subvol_from_ctx (this, loc->inode); if (!subvol) { @@ -152,13 +949,8 @@ map_chown (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_chown_cbk, - subvol, - subvol->fops->chown, - loc, - uid, - gid); + STACK_WIND (frame, map_setattr_cbk, subvol, + subvol->fops->setattr, loc, stbuf, valid); return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -167,19 +959,19 @@ map_chown (call_frame_t *frame, } int32_t -map_fchown (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - uid_t uid, - gid_t gid) +map_fsetattr (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + struct iatt *stbuf, + int32_t valid) { int32_t op_errno = 1; xlator_t *subvol = NULL; - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - VALIDATE_OR_GOTO (fd->inode, err); + GF_VALIDATE_OR_GOTO ("map", this, err); + GF_VALIDATE_OR_GOTO (this->name, frame, err); + GF_VALIDATE_OR_GOTO (this->name, fd, err); + GF_VALIDATE_OR_GOTO (this->name, stbuf, err); subvol = get_mapping_subvol_from_ctx (this, fd->inode); if (!subvol) { @@ -187,13 +979,8 @@ map_fchown (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_fchown_cbk, - subvol, - subvol->fops->fchown, - fd, - uid, - gid); + STACK_WIND (frame, map_fsetattr_cbk, subvol, + subvol->fops->fsetattr, fd, stbuf, valid); return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -222,12 +1009,9 @@ map_truncate (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_truncate_cbk, - subvol, - subvol->fops->truncate, - loc, - offset); + STACK_WIND (frame, map_truncate_cbk, subvol, + subvol->fops->truncate, loc, offset); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -255,47 +1039,10 @@ map_ftruncate (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_ftruncate_cbk, - subvol, - subvol->fops->ftruncate, - fd, - offset); - return 0; - err: - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); + STACK_WIND (frame, map_ftruncate_cbk, subvol, + subvol->fops->ftruncate, fd, offset); return 0; -} - -int32_t -map_utimens (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - struct timespec tv[2]) -{ - int32_t op_errno = 1; - xlator_t *subvol = NULL; - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (loc, err); - VALIDATE_OR_GOTO (loc->inode, err); - VALIDATE_OR_GOTO (loc->path, err); - - subvol = get_mapping_subvol_from_ctx (this, loc->inode); - if (!subvol) { - op_errno = EINVAL; - goto err; - } - - STACK_WIND (frame, - default_utimens_cbk, - subvol, - subvol->fops->utimens, - loc, - tv); - return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -323,12 +1070,9 @@ map_access (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_access_cbk, - subvol, - subvol->fops->access, - loc, - mask); + STACK_WIND (frame, map_access_cbk, subvol, + subvol->fops->access, loc, mask); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -358,12 +1102,9 @@ map_readlink (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_readlink_cbk, - subvol, - subvol->fops->readlink, - loc, - size); + STACK_WIND (frame, map_readlink_cbk, subvol, + subvol->fops->readlink, loc, size); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -391,11 +1132,8 @@ map_unlink (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_unlink_cbk, - subvol, - subvol->fops->unlink, - loc); + STACK_WIND (frame, map_unlink_cbk, subvol, subvol->fops->unlink, loc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -423,11 +1161,8 @@ map_rmdir (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_rmdir_cbk, - subvol, - subvol->fops->rmdir, - loc); + STACK_WIND (frame, map_rmdir_cbk, subvol, subvol->fops->rmdir, loc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -460,19 +1195,16 @@ map_rename (call_frame_t *frame, } if (newloc->path) { - new_subvol = get_mapping_subvol_from_path (this, - newloc->path); + new_subvol = get_mapping_subvol_from_path (this, newloc->path); if (new_subvol && (new_subvol != old_subvol)) { op_errno = EXDEV; goto err; } } - STACK_WIND (frame, - default_rename_cbk, - old_subvol, - old_subvol->fops->rename, - oldloc, newloc); + STACK_WIND (frame, map_rename_cbk, old_subvol, + old_subvol->fops->rename, oldloc, newloc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -505,19 +1237,16 @@ map_link (call_frame_t *frame, } if (newloc->path) { - new_subvol = get_mapping_subvol_from_path (this, - newloc->path); + new_subvol = get_mapping_subvol_from_path (this, newloc->path); if (new_subvol && (new_subvol != old_subvol)) { op_errno = EXDEV; goto err; } } - STACK_WIND (frame, - default_link_cbk, - old_subvol, - old_subvol->fops->link, - oldloc, newloc); + STACK_WIND (frame, map_link_cbk, old_subvol, + old_subvol->fops->link, oldloc, newloc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -530,7 +1259,7 @@ int32_t map_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd) + int32_t flags, fd_t *fd, int wbflags) { int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -547,11 +1276,9 @@ map_open (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_open_cbk, - subvol, - subvol->fops->open, - loc, flags, fd); + STACK_WIND (frame, map_open_cbk, subvol, + subvol->fops->open, loc, flags, fd, wbflags); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -580,16 +1307,12 @@ map_readv (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_readv_cbk, - subvol, - subvol->fops->readv, - fd, - size, - offset); + STACK_WIND (frame, map_readv_cbk, subvol, + subvol->fops->readv, fd, size, offset); + return 0; err: - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); + STACK_UNWIND (frame, -1, op_errno, NULL, 0, NULL, NULL); return 0; } @@ -600,7 +1323,8 @@ map_writev (call_frame_t *frame, fd_t *fd, struct iovec *vector, int32_t count, - off_t off) + off_t off, + struct iobref *iobref) { int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -616,14 +1340,9 @@ map_writev (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_writev_cbk, - subvol, - subvol->fops->writev, - fd, - vector, - count, - off); + STACK_WIND (frame, map_writev_cbk, subvol, + subvol->fops->writev, fd, vector, count, off, iobref); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -650,11 +1369,8 @@ map_flush (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_flush_cbk, - subvol, - subvol->fops->flush, - fd); + STACK_WIND (frame, map_flush_cbk, subvol, subvol->fops->flush, fd); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -683,12 +1399,9 @@ map_fsync (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_fsync_cbk, - subvol, - subvol->fops->fsync, - fd, - flags); + STACK_WIND (frame, map_fsync_cbk, subvol, + subvol->fops->fsync, fd, flags); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -715,11 +1428,8 @@ map_fstat (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_fstat_cbk, - subvol, - subvol->fops->fstat, - fd); + STACK_WIND (frame, map_fstat_cbk, subvol, subvol->fops->fstat, fd); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -749,14 +1459,9 @@ map_getdents (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_getdents_cbk, - subvol, - subvol->fops->getdents, - fd, - size, - offset, - flag); + STACK_WIND (frame, map_getdents_cbk, subvol, + subvol->fops->getdents, fd, size, offset, flag); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -786,14 +1491,9 @@ map_setdents (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_setdents_cbk, - subvol, - subvol->fops->setdents, - fd, - flags, - entries, - count); + STACK_WIND (frame, map_setdents_cbk, subvol, + subvol->fops->setdents, fd, flags, entries, count); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -822,12 +1522,9 @@ map_fsyncdir (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_fsyncdir_cbk, - subvol, - subvol->fops->fsyncdir, - fd, - flags); + STACK_WIND (frame, map_fsyncdir_cbk, subvol, + subvol->fops->fsyncdir, fd, flags); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -845,7 +1542,6 @@ map_setxattr (call_frame_t *frame, dict_t *dict, int32_t flags) { - /* TODO: support for 'get' 'put' API */ int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -861,13 +1557,9 @@ map_setxattr (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_setxattr_cbk, - subvol, - subvol->fops->setxattr, - loc, - dict, - flags); + STACK_WIND (frame, map_setxattr_cbk, subvol, + subvol->fops->setxattr, loc, dict, flags); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -881,7 +1573,6 @@ map_getxattr (call_frame_t *frame, loc_t *loc, const char *name) { - /* TODO: support for 'get' 'put' API */ int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -897,12 +1588,41 @@ map_getxattr (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_getxattr_cbk, - subvol, - subvol->fops->getxattr, - loc, - name); + STACK_WIND (frame, map_getxattr_cbk, subvol, + subvol->fops->getxattr, loc, name); + + return 0; + err: + STACK_UNWIND (frame, -1, op_errno, NULL, NULL); + + return 0; +} + + +int32_t +map_fsetxattr (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + dict_t *dict, + int32_t flags) +{ + int32_t op_errno = 1; + xlator_t *subvol = NULL; + + VALIDATE_OR_GOTO (frame, err); + VALIDATE_OR_GOTO (this, err); + VALIDATE_OR_GOTO (fd, err); + VALIDATE_OR_GOTO (fd->inode, err); + + subvol = get_mapping_subvol_from_ctx (this, fd->inode); + if (!subvol) { + op_errno = EINVAL; + goto err; + } + + STACK_WIND (frame, map_fsetxattr_cbk, subvol, + subvol->fops->fsetxattr, fd, dict, flags); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -911,6 +1631,37 @@ map_getxattr (call_frame_t *frame, } int32_t +map_fgetxattr (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + const char *name) +{ + int32_t op_errno = 1; + xlator_t *subvol = NULL; + + VALIDATE_OR_GOTO (frame, err); + VALIDATE_OR_GOTO (this, err); + VALIDATE_OR_GOTO (fd, err); + VALIDATE_OR_GOTO (fd->inode, err); + + subvol = get_mapping_subvol_from_ctx (this, fd->inode); + if (!subvol) { + op_errno = EINVAL; + goto err; + } + + STACK_WIND (frame, map_fgetxattr_cbk, subvol, + subvol->fops->fgetxattr, fd, name); + + return 0; + err: + STACK_UNWIND (frame, -1, op_errno, NULL, NULL); + + return 0; +} + + +int32_t map_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, @@ -932,13 +1683,9 @@ map_xattrop (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_xattrop_cbk, - subvol, - subvol->fops->xattrop, - loc, - flags, - dict); + STACK_WIND (frame, map_xattrop_cbk, subvol, + subvol->fops->xattrop, loc, flags, dict); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -967,14 +1714,10 @@ map_fxattrop (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_fxattrop_cbk, - subvol, - subvol->fops->fxattrop, - fd, - flags, - dict); - return 0; + STACK_WIND (frame, map_fxattrop_cbk, subvol, + subvol->fops->fxattrop, fd, flags, dict); + + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1002,12 +1745,9 @@ map_removexattr (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_removexattr_cbk, - subvol, - subvol->fops->removexattr, - loc, - name); + STACK_WIND (frame, map_removexattr_cbk, subvol, + subvol->fops->removexattr, loc, name); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1020,7 +1760,7 @@ map_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct flock *lock) + struct gf_flock *lock) { int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -1036,13 +1776,9 @@ map_lk (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_lk_cbk, - subvol, - subvol->fops->lk, - fd, - cmd, - lock); + STACK_WIND (frame, map_lk_cbk, subvol, + subvol->fops->lk, fd, cmd, lock); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1053,7 +1789,7 @@ map_lk (call_frame_t *frame, int32_t map_inodelk (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t cmd, struct flock *lock) + const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *lock) { int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -1070,11 +1806,9 @@ map_inodelk (call_frame_t *frame, xlator_t *this, goto err; } - STACK_WIND (frame, - default_inodelk_cbk, - subvol, - subvol->fops->inodelk, - loc, cmd, lock); + STACK_WIND (frame, map_inodelk_cbk, subvol, + subvol->fops->inodelk, volume, loc, cmd, lock); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1085,7 +1819,7 @@ map_inodelk (call_frame_t *frame, xlator_t *this, int32_t map_finodelk (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t cmd, struct flock *lock) + const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock) { int32_t op_errno = 1; xlator_t *subvol = NULL; @@ -1101,11 +1835,9 @@ map_finodelk (call_frame_t *frame, xlator_t *this, goto err; } - STACK_WIND (frame, - default_finodelk_cbk, - subvol, - subvol->fops->finodelk, - fd, cmd, lock); + STACK_WIND (frame, map_finodelk_cbk, subvol, + subvol->fops->finodelk, volume, fd, cmd, lock); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1115,7 +1847,7 @@ map_finodelk (call_frame_t *frame, xlator_t *this, int32_t map_entrylk (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *basename, + const char *volume, loc_t *loc, const char *basename, entrylk_cmd cmd, entrylk_type type) { int32_t op_errno = 1; @@ -1133,10 +1865,9 @@ map_entrylk (call_frame_t *frame, xlator_t *this, goto err; } - STACK_WIND (frame, default_entrylk_cbk, - subvol, - subvol->fops->entrylk, - loc, basename, cmd, type); + STACK_WIND (frame, map_entrylk_cbk, subvol, + subvol->fops->entrylk, volume, loc, basename, cmd, type); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1146,7 +1877,7 @@ map_entrylk (call_frame_t *frame, xlator_t *this, int32_t map_fentrylk (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *basename, + const char *volume, fd_t *fd, const char *basename, entrylk_cmd cmd, entrylk_type type) { int32_t op_errno = 1; @@ -1163,10 +1894,9 @@ map_fentrylk (call_frame_t *frame, xlator_t *this, goto err; } - STACK_WIND (frame, default_fentrylk_cbk, - subvol, - subvol->fops->fentrylk, - fd, basename, cmd, type); + STACK_WIND (frame, map_fentrylk_cbk, subvol, + subvol->fops->fentrylk, volume, fd, basename, cmd, type); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1195,12 +1925,9 @@ map_checksum (call_frame_t *frame, goto err; } - STACK_WIND (frame, - default_checksum_cbk, - subvol, - subvol->fops->checksum, - loc, - flag); + STACK_WIND (frame, map_checksum_cbk, subvol, + subvol->fops->checksum, loc, flag); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1208,25 +1935,6 @@ map_checksum (call_frame_t *frame, return 0; } -static int32_t -map_newentry_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - inode_t *inode, - struct stat *buf) -{ - call_frame_t *prev = NULL; - prev = cookie; - - map_itransform (this, prev->this, buf->st_ino, &buf->st_ino); - - STACK_UNWIND (frame, op_ret, op_errno, inode, buf); - return 0; - -} - int32_t map_mknod (call_frame_t *frame, @@ -1257,11 +1965,9 @@ map_mknod (call_frame_t *frame, loc->path); } - STACK_WIND (frame, - map_newentry_cbk, - subvol, - subvol->fops->mknod, - loc, mode, rdev); + STACK_WIND (frame, map_newentry_cbk, subvol, + subvol->fops->mknod, loc, mode, rdev); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1297,11 +2003,8 @@ map_mkdir (call_frame_t *frame, loc->path); } - STACK_WIND (frame, - map_newentry_cbk, - subvol, - subvol->fops->mkdir, - loc, mode); + STACK_WIND (frame, map_newentry_cbk, subvol, + subvol->fops->mkdir, loc, mode); return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1338,11 +2041,9 @@ map_symlink (call_frame_t *frame, loc->path); } - STACK_WIND (frame, - map_newentry_cbk, - subvol, - subvol->fops->symlink, - linkpath, loc); + STACK_WIND (frame, map_newentry_cbk, subvol, + subvol->fops->symlink, linkpath, loc); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1350,25 +2051,6 @@ map_symlink (call_frame_t *frame, return 0; } - -static int32_t -map_create_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - fd_t *fd, - inode_t *inode, - struct stat *buf) -{ - call_frame_t *prev = NULL; - prev = cookie; - - map_itransform (this, prev->this, buf->st_ino, &buf->st_ino); - STACK_UNWIND (frame, op_ret, op_errno, fd, inode, buf); - return 0; -} - int32_t map_create (call_frame_t *frame, xlator_t *this, @@ -1398,10 +2080,9 @@ map_create (call_frame_t *frame, loc->path); } - STACK_WIND (frame, map_create_cbk, - subvol, - subvol->fops->create, - loc, flags, mode, fd); + STACK_WIND (frame, map_create_cbk, subvol, + subvol->fops->create, loc, flags, mode, fd); + return 0; err: STACK_UNWIND (frame, -1, op_errno, NULL, NULL); @@ -1409,73 +2090,6 @@ map_create (call_frame_t *frame, return 0; } -int32_t -map_single_lookup_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - inode_t *inode, - struct stat *buf, - dict_t *dict) -{ - call_frame_t *prev = NULL; - prev = cookie; - - map_itransform (this, prev->this, buf->st_ino, &buf->st_ino); - - STACK_UNWIND (frame, op_ret, op_errno, inode, buf, dict); - - return 0; -} - -int32_t -map_lookup_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - inode_t *inode, - struct stat *buf, - dict_t *dict) -{ - int callcnt = 0; - map_local_t *local = NULL; - inode_t *tmp_inode = NULL; - dict_t *tmp_dict = NULL; - - local = frame->local; - LOCK (&frame->lock); - { - callcnt = --local->call_count; - if ((op_ret == 0) && (local->op_ret == -1)) { - local->op_ret = 0; - local->stbuf = *buf; - if (dict) - local->dict = dict_ref (dict); - local->inode = inode_ref (inode); - } - if (op_ret == -1) - local->op_errno = op_errno; - - } - UNLOCK (&frame->lock); - - if (!callcnt) { - tmp_dict = local->dict; - tmp_inode = local->inode; - - STACK_UNWIND (frame, local->op_ret, - local->op_errno, local->inode, - &local->stbuf, local->dict); - - inode_unref (local->inode); - if (tmp_dict) - dict_unref (tmp_dict); - } - - return 0; -} int32_t map_lookup (call_frame_t *frame, @@ -1517,17 +2131,14 @@ map_lookup (call_frame_t *frame, } /* Just one callback */ - STACK_WIND (frame, - map_single_lookup_cbk, - subvol, - subvol->fops->lookup, - loc, - xattr_req); + STACK_WIND (frame, map_single_lookup_cbk, subvol, + subvol->fops->lookup, loc, xattr_req); return 0; root_inode: - local = CALLOC (1, sizeof (map_local_t)); + local = GF_CALLOC (1, sizeof (map_local_t), + gf_map_mt_map_local_t); frame->local = local; local->call_count = priv->child_count; @@ -1535,12 +2146,8 @@ map_lookup (call_frame_t *frame, trav = this->children; while (trav) { - STACK_WIND (frame, - map_lookup_cbk, - trav->xlator, - trav->xlator->fops->lookup, - loc, - xattr_req); + STACK_WIND (frame, map_root_lookup_cbk, trav->xlator, + trav->xlator->fops->lookup, loc, xattr_req); trav = trav->next; } @@ -1551,93 +2158,7 @@ map_lookup (call_frame_t *frame, return 0; } -/* - * unify_normalize_stats - - */ -void -map_normalize_stats (struct statvfs *buf, - unsigned long bsize, - unsigned long frsize) -{ - double factor; - - if (buf->f_bsize != bsize) { - factor = ((double) buf->f_bsize) / bsize; - buf->f_bsize = bsize; - buf->f_bfree = (fsblkcnt_t) (factor * buf->f_bfree); - buf->f_bavail = (fsblkcnt_t) (factor * buf->f_bavail); - } - - if (buf->f_frsize != frsize) { - factor = ((double) buf->f_frsize) / frsize; - buf->f_frsize = frsize; - buf->f_blocks = (fsblkcnt_t) (factor * buf->f_blocks); - } -} - - -int32_t -map_statfs_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct statvfs *stbuf) -{ - struct statvfs *dict_buf = NULL; - map_local_t *local = NULL; - int this_call_cnt = 0; - unsigned long bsize; - unsigned long frsize; - - local = frame->local; - - LOCK (&frame->lock); - { - this_call_cnt = --local->call_count; - - if (op_ret == -1) { - local->op_errno = op_errno; - goto unlock; - } - local->op_ret = 0; - - /* when a call is successfull, add it to local->dict */ - dict_buf = &local->statvfs; - - if (dict_buf->f_bsize != 0) { - bsize = max (dict_buf->f_bsize, - stbuf->f_bsize); - - frsize = max (dict_buf->f_frsize, - stbuf->f_frsize); - map_normalize_stats(dict_buf, bsize, frsize); - map_normalize_stats(stbuf, bsize, frsize); - } else { - dict_buf->f_bsize = stbuf->f_bsize; - dict_buf->f_frsize = stbuf->f_frsize; - } - - dict_buf->f_blocks += stbuf->f_blocks; - dict_buf->f_bfree += stbuf->f_bfree; - dict_buf->f_bavail += stbuf->f_bavail; - dict_buf->f_files += stbuf->f_files; - dict_buf->f_ffree += stbuf->f_ffree; - dict_buf->f_favail += stbuf->f_favail; - dict_buf->f_fsid = stbuf->f_fsid; - dict_buf->f_flag = stbuf->f_flag; - dict_buf->f_namemax = stbuf->f_namemax; - } -unlock: - UNLOCK (&frame->lock); - if (!this_call_cnt) { - STACK_UNWIND (frame, local->op_ret, local->op_errno, - &local->statvfs); - } - - return 0; -} int32_t map_statfs (call_frame_t *frame, @@ -1664,16 +2185,13 @@ map_statfs (call_frame_t *frame, } /* Just one callback */ - STACK_WIND (frame, - default_statfs_cbk, - subvol, - subvol->fops->statfs, - loc); + STACK_WIND (frame, map_statfs_cbk, subvol, subvol->fops->statfs, loc); return 0; root_inode: - local = CALLOC (1, sizeof (map_local_t)); + local = GF_CALLOC (1, sizeof (map_local_t), + gf_map_mt_map_local_t); priv = this->private; frame->local = local; @@ -1682,11 +2200,8 @@ map_statfs (call_frame_t *frame, trav = this->children; while (trav) { - STACK_WIND (frame, - map_statfs_cbk, - trav->xlator, - trav->xlator->fops->statfs, - loc); + STACK_WIND (frame, map_statfs_cbk, trav->xlator, + trav->xlator->fops->statfs, loc); trav = trav->next; } @@ -1698,46 +2213,6 @@ map_statfs (call_frame_t *frame, } int32_t -map_opendir_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - fd_t *fd) -{ - int callcnt = 0; - map_local_t *local = NULL; - fd_t *local_fd = NULL; - - local = frame->local; - LOCK (&frame->lock); - { - callcnt = --local->call_count; - - if (op_ret == -1) { - local->op_errno = op_errno; - goto unlock; - } - - local->op_ret = 0; - } - unlock: - UNLOCK (&frame->lock); - - if (!callcnt) { - local_fd = local->fd; - local->fd = NULL; - - STACK_UNWIND (frame, local->op_ret, - local->op_errno, local_fd); - - fd_unref (local_fd); - } - return 0; -} - - -int32_t map_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) @@ -1762,15 +2237,14 @@ map_opendir (call_frame_t *frame, } /* Just one callback */ - STACK_WIND (frame, - default_opendir_cbk, - subvol, - subvol->fops->opendir, - loc, fd); + STACK_WIND (frame, map_opendir_cbk, subvol, + subvol->fops->opendir, loc, fd); + return 0; root_inode: - local = CALLOC (1, sizeof (map_local_t)); + local = GF_CALLOC (1, sizeof (map_local_t), + gf_map_mt_map_local_t); priv = this->private; frame->local = local; @@ -1780,11 +2254,8 @@ map_opendir (call_frame_t *frame, trav = this->children; while (trav) { - STACK_WIND (frame, - map_opendir_cbk, - trav->xlator, - trav->xlator->fops->opendir, - loc, fd); + STACK_WIND (frame, map_opendir_cbk, trav->xlator, + trav->xlator->fops->opendir, loc, fd); trav = trav->next; } @@ -1797,109 +2268,8 @@ map_opendir (call_frame_t *frame, int32_t -map_single_readdir_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - gf_dirent_t *entries) -{ - call_frame_t *prev = NULL; - gf_dirent_t *orig_entry = NULL; - - prev = cookie; - - list_for_each_entry (orig_entry, &entries->list, list) { - map_itransform (this, prev->this, orig_entry->d_ino, - &orig_entry->d_ino); - } - STACK_UNWIND (frame, op_ret, op_errno, entries); - - return 0; -} - - -int -map_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, gf_dirent_t *orig_entries) -{ - map_local_t *local = NULL; - gf_dirent_t entries; - gf_dirent_t *orig_entry = NULL; - gf_dirent_t *entry = NULL; - call_frame_t *prev = NULL; - xlator_t *subvol = NULL; - xlator_t *next = NULL; - int count = 0; - fd_t *local_fd = NULL; - - INIT_LIST_HEAD (&entries.list); - prev = cookie; - local = frame->local; - - if (op_ret < 0) - goto done; - - list_for_each_entry (orig_entry, &orig_entries->list, list) { - subvol = prev->this; - - entry = gf_dirent_for_name (orig_entry->d_name); - if (!entry) { - gf_log (this->name, GF_LOG_ERROR, - "memory allocation failed :("); - goto unwind; - } - - map_itransform (this, subvol, orig_entry->d_ino, - &entry->d_ino); - map_itransform (this, subvol, orig_entry->d_off, - &entry->d_off); - - entry->d_type = orig_entry->d_type; - entry->d_len = orig_entry->d_len; - - list_add_tail (&entry->list, &entries.list); - count++; - } - - op_ret = count; - -done: - if (count == 0) { - next = map_subvol_next (this, prev->this); - if (!next) { - goto unwind; - } - - STACK_WIND (frame, map_readdir_cbk, - next, next->fops->readdir, - local->fd, local->size, 0); - return 0; - } - -unwind: - if (op_ret < 0) - op_ret = 0; - - local_fd = local->fd; - local->fd = NULL; - - STACK_UNWIND (frame, op_ret, op_errno, &entries); - - fd_unref (local_fd); - - gf_dirent_free (&entries); - - return 0; -} - - -int32_t -map_readdir (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t yoff) +map_do_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t yoff, int whichop) { int32_t op_errno = EINVAL; xlator_t *subvol = NULL; @@ -1922,17 +2292,19 @@ map_readdir (call_frame_t *frame, } /* Just one callback */ - - STACK_WIND (frame, - map_single_readdir_cbk, - subvol, - subvol->fops->readdir, - fd, size, yoff); + if (whichop == GF_FOP_READDIR) + STACK_WIND (frame, map_single_readdir_cbk, subvol, + subvol->fops->readdir, fd, size, yoff); + else + STACK_WIND (frame, map_single_readdirp_cbk, subvol, + subvol->fops->readdirp, fd, size, yoff); + return 0; root_inode: /* readdir on '/' */ - local = CALLOC (1, sizeof (map_local_t)); + local = GF_CALLOC (1, sizeof (map_local_t), + gf_map_mt_map_local_t); if (!local) { gf_log (this->name, GF_LOG_ERROR, "memory allocation failed :("); @@ -1950,9 +2322,12 @@ map_readdir (call_frame_t *frame, map_deitransform (this, yoff, &xvol, (uint64_t *)&xoff); - STACK_WIND (frame, map_readdir_cbk, - xvol, xvol->fops->readdir, - fd, size, xoff); + if (whichop == GF_FOP_READDIR) + STACK_WIND (frame, map_readdir_cbk, xvol, xvol->fops->readdir, + fd, size, xoff); + else + STACK_WIND (frame, map_readdirp_cbk, xvol, xvol->fops->readdirp, + fd, size, xoff); return 0; err: @@ -1962,42 +2337,22 @@ map_readdir (call_frame_t *frame, } -#if 0 -/* TODO : do it later as currently only unify uses this mop and mostly - unify will be used below map */ + int32_t -map_stats_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct xlator_stats *stats) +map_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t yoff) { - STACK_UNWIND (frame, op_ret, op_errno, stats); - return 0; + map_do_readdir (frame, this, fd, size, yoff, GF_FOP_READDIR); + return 0; } - int32_t -map_stats (call_frame_t *frame, - xlator_t *this, - int32_t flags) +map_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t yoff) { - STACK_WIND (frame, - map_stats_cbk, - subvol, - subvol->mops->stats, - flags); - return 0; - err: - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); - - return 0; + map_do_readdir (frame, this, fd, size, yoff, GF_FOP_READDIRP); + return 0; } -#endif /* if 0 */ - - -/* TODO: define the behavior of notify */ void @@ -2010,22 +2365,40 @@ fini (xlator_t *this) priv = this->private; if (priv) { - if (priv->xlarray) - FREE (priv->xlarray); + GF_FREE (priv->xlarray); trav_map = priv->map; while (trav_map) { tmp_map = trav_map; trav_map = trav_map->next; - FREE (tmp_map); + GF_FREE (tmp_map); } - FREE(priv); + GF_FREE(priv); } return; } +int32_t +mem_acct_init (xlator_t *this) +{ + int ret = -1; + + if (!this) + return ret; + + ret = xlator_mem_acct_init (this, gf_map_mt_end + 1); + + if (ret != 0) { + gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" + "failed"); + return ret; + } + + return ret; +} + int init (xlator_t *this) { @@ -2040,7 +2413,8 @@ init (xlator_t *this) char *dup_map_pair = NULL; char *dir_str = NULL; char *subvol_str = NULL; - char *default_xl = NULL; + char *map_xl = NULL; + if (!this->children) { gf_log (this->name,GF_LOG_ERROR, @@ -2053,7 +2427,8 @@ init (xlator_t *this) "dangling volume. check volfile "); } - priv = CALLOC (1, sizeof (map_private_t)); + priv = GF_CALLOC (1, sizeof (map_private_t), + gf_map_mt_map_private_t); this->private = priv; /* allocate xlator array */ @@ -2062,7 +2437,8 @@ init (xlator_t *this) count++; trav = trav->next; } - priv->xlarray = CALLOC (1, sizeof (struct map_xlator_array) * count); + priv->xlarray = GF_CALLOC (1, sizeof (struct map_xlator_array) * count, + gf_map_mt_map_xlator_array); priv->child_count = count; /* build xlator array */ @@ -2082,7 +2458,7 @@ init (xlator_t *this) } map_pair_str = strtok_r (pattern_string, ";", &tmp_str); while (map_pair_str) { - dup_map_pair = strdup (map_pair_str); + dup_map_pair = gf_strdup (map_pair_str); dir_str = strtok_r (dup_map_pair, ":", &tmp_str1); if (!dir_str) { gf_log (this->name, GF_LOG_ERROR, @@ -2104,15 +2480,15 @@ init (xlator_t *this) goto err; } - FREE (dup_map_pair); + GF_FREE (dup_map_pair); map_pair_str = strtok_r (NULL, ";", &tmp_str); } /* default-volume brick4 */ - ret = dict_get_str (this->options, "default-volume", &default_xl); + ret = dict_get_str (this->options, "default-volume", &map_xl); if (ret == 0) { - ret = assign_default_subvol (this, default_xl); + ret = assign_default_subvol (this, map_xl); if (ret != 0) { gf_log (this->name, GF_LOG_ERROR, "assigning default failed"); @@ -2135,18 +2511,15 @@ struct xlator_fops fops = { .create = map_create, .stat = map_stat, - .chmod = map_chmod, - .chown = map_chown, - .fchown = map_fchown, - .fchmod = map_fchmod, .fstat = map_fstat, - .utimens = map_utimens, .truncate = map_truncate, .ftruncate = map_ftruncate, .access = map_access, .readlink = map_readlink, .setxattr = map_setxattr, .getxattr = map_getxattr, + .fsetxattr = map_fsetxattr, + .fgetxattr = map_fgetxattr, .removexattr = map_removexattr, .open = map_open, .readv = map_readv, @@ -2157,6 +2530,7 @@ struct xlator_fops fops = { .lk = map_lk, .opendir = map_opendir, .readdir = map_readdir, + .readdirp = map_readdirp, .fsyncdir = map_fsyncdir, .symlink = map_symlink, .unlink = map_unlink, @@ -2173,9 +2547,8 @@ struct xlator_fops fops = { .setdents = map_setdents, .getdents = map_getdents, .checksum = map_checksum, -}; - -struct xlator_mops mops = { + .setattr = map_setattr, + .fsetattr = map_fsetattr, }; struct xlator_cbks cbks = { |