/*

  Copyright (c) 2008-2015 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"

#endif

#include "glusterfs/xlator.h"

#include "glusterfs/defaults.h"

int

args_lookup_store(default_args_t *args, loc_t *loc, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_lookup_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, inode_t *inode, struct iatt *buf,

                      dict_t *xdata, struct iatt *postparent)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_stat_store(default_args_t *args, loc_t *loc, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_stat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                    struct iatt *buf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (op_ret == 0)

        args->stat = *buf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fstat_store(default_args_t *args, fd_t *fd, dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fstat_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     struct iatt *buf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (buf)

        args->stat = *buf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_truncate_store(default_args_t *args, loc_t *loc, off_t off, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->offset = off;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_truncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                        int32_t op_errno, struct iatt *prebuf,

                        struct iatt *postbuf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (prebuf)

        args->prestat = *prebuf;

    if (postbuf)

        args->poststat = *postbuf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_ftruncate_store(default_args_t *args, fd_t *fd, off_t off, dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    args->offset = off;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_ftruncate_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                         int32_t op_errno, struct iatt *prebuf,

                         struct iatt *postbuf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (prebuf)

        args->prestat = *prebuf;

    if (postbuf)

        args->poststat = *postbuf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_access_store(default_args_t *args, loc_t *loc, int32_t mask, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->mask = mask;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_access_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_readlink_store(default_args_t *args, loc_t *loc, size_t size,

                    dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->size = size;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_readlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                        int32_t op_errno, const char *path, struct iatt *stbuf,

                        dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (path)

        args->buf = gf_strdup(path);

    if (stbuf)

        args->stat = *stbuf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_mknod_store(default_args_t *args, loc_t *loc, mode_t mode, dev_t rdev,

                 mode_t umask, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->mode = mode;

    args->rdev = rdev;

    args->umask = umask;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_mknod_cbk_store(default_args_cbk_t *args, int op_ret, int32_t op_errno,

                     inode_t *inode, struct iatt *buf, struct iatt *preparent,

                     struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_mkdir_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,

                 dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->mode = mode;

    args->umask = umask;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_mkdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     inode_t *inode, struct iatt *buf, struct iatt *preparent,

                     struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_unlink_store(default_args_t *args, loc_t *loc, int xflag, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->xflag = xflag;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_unlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, struct iatt *preparent,

                      struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_rmdir_store(default_args_t *args, loc_t *loc, int flags, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->flags = flags;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_rmdir_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     struct iatt *preparent, struct iatt *postparent,

                     dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_symlink_store(default_args_t *args, const char *linkname, loc_t *loc,

                   mode_t umask, dict_t *xdata)

{

    args->linkname = gf_strdup(linkname);

    args->umask = umask;

    loc_copy(&args->loc, loc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_symlink_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                       int32_t op_errno, inode_t *inode, struct iatt *buf,

                       struct iatt *preparent, struct iatt *postparent,

                       dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_rename_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,

                  dict_t *xdata)

{

    loc_copy(&args->loc, oldloc);

    loc_copy(&args->loc2, newloc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_rename_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, struct iatt *buf,

                      struct iatt *preoldparent, struct iatt *postoldparent,

                      struct iatt *prenewparent, struct iatt *postnewparent,

                      dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (buf)

        args->stat = *buf;

    if (preoldparent)

        args->preparent = *preoldparent;

    if (postoldparent)

        args->postparent = *postoldparent;

    if (prenewparent)

        args->preparent2 = *prenewparent;

    if (postnewparent)

        args->postparent2 = *postnewparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_link_store(default_args_t *args, loc_t *oldloc, loc_t *newloc,

                dict_t *xdata)

{

    loc_copy(&args->loc, oldloc);

    loc_copy(&args->loc2, newloc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_link_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                    inode_t *inode, struct iatt *buf, struct iatt *preparent,

                    struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_create_store(default_args_t *args, loc_t *loc, int32_t flags, mode_t mode,

                  mode_t umask, fd_t *fd, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->flags = flags;

    args->mode = mode;

    args->umask = umask;

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_create_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, fd_t *fd, inode_t *inode,

                      struct iatt *buf, struct iatt *preparent,

                      struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (fd)

        args->fd = fd_ref(fd);

    if (inode)

        args->inode = inode_ref(inode);

    if (buf)

        args->stat = *buf;

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_open_store(default_args_t *args, loc_t *loc, int32_t flags, fd_t *fd,

                dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->flags = flags;

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_open_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                    fd_t *fd, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_readv_store(default_args_t *args, fd_t *fd, size_t size, off_t off,

                 uint32_t flags, dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    args->size = size;

    args->offset = off;

    args->flags = flags;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_readv_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     struct iovec *vector, int32_t count, struct iatt *stbuf,

                     struct iobref *iobref, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (op_ret >= 0) {

        args->vector = iov_dup(vector, count);

        args->count = count;

        args->stat = *stbuf;

        args->iobref = iobref_ref(iobref);

    }

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_writev_store(default_args_t *args, fd_t *fd, struct iovec *vector,

                  int32_t count, off_t off, uint32_t flags,

                  struct iobref *iobref, dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    args->vector = iov_dup(vector, count);

    args->count = count;

    args->offset = off;

    args->flags = flags;

    args->iobref = iobref_ref(iobref);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_writev_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, struct iatt *prebuf,

                      struct iatt *postbuf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (op_ret >= 0)

        args->poststat = *postbuf;

    if (prebuf)

        args->prestat = *prebuf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_put_store(default_args_t *args, loc_t *loc, mode_t mode, mode_t umask,

               uint32_t flags, struct iovec *vector, int32_t count, off_t off,

               struct iobref *iobref, dict_t *xattr, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->mode = mode;

    args->umask = umask;

    args->flags = flags;

    args->vector = iov_dup(vector, count);

    args->count = count;

    args->offset = off;

    args->iobref = iobref_ref(iobref);

    if (xattr)

        args->xattr = dict_ref(xattr);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_put_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                   inode_t *inode, struct iatt *buf, struct iatt *preparent,

                   struct iatt *postparent, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (op_ret >= 0)

        args->stat = *buf;

    if (inode)

        args->inode = inode_ref(inode);

    if (preparent)

        args->preparent = *preparent;

    if (postparent)

        args->postparent = *postparent;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_flush_store(default_args_t *args, fd_t *fd, dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_flush_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsync_store(default_args_t *args, fd_t *fd, int32_t datasync,

                 dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    args->datasync = datasync;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsync_cbk_store(default_args_cbk_t *args, int32_t op_ret, int32_t op_errno,

                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (prebuf)

        args->prestat = *prebuf;

    if (postbuf)

        args->poststat = *postbuf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_opendir_store(default_args_t *args, loc_t *loc, fd_t *fd, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_opendir_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                       int32_t op_errno, fd_t *fd, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (fd)

        args->fd = fd_ref(fd);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsyncdir_store(default_args_t *args, fd_t *fd, int32_t datasync,

                    dict_t *xdata)

{

    if (fd)

        args->fd = fd_ref(fd);

    args->datasync = datasync;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsyncdir_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                        int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_statfs_store(default_args_t *args, loc_t *loc, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_statfs_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                      int32_t op_errno, struct statvfs *buf, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (op_ret == 0)

        args->statvfs = *buf;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_setxattr_store(default_args_t *args, loc_t *loc, dict_t *dict,

                    int32_t flags, dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    /* TODO */

    if (dict)

        args->xattr = dict_ref(dict);

    args->flags = flags;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_setxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                        int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_getxattr_store(default_args_t *args, loc_t *loc, const char *name,

                    dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    if (name)

        args->name = gf_strdup(name);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_getxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                        int32_t op_errno, dict_t *dict, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (dict)

        args->xattr = dict_ref(dict);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsetxattr_store(default_args_t *args, fd_t *fd, dict_t *dict,

                     int32_t flags, dict_t *xdata)

{

    args->fd = fd_ref(fd);

    if (dict)

        args->xattr = dict_ref(dict);

    args->flags = flags;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fsetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                         int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fgetxattr_store(default_args_t *args, fd_t *fd, const char *name,

                     dict_t *xdata)

{

    args->fd = fd_ref(fd);

    if (name)

        args->name = gf_strdup(name);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fgetxattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                         int32_t op_errno, dict_t *dict, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (dict)

        args->xattr = dict_ref(dict);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_removexattr_store(default_args_t *args, loc_t *loc, const char *name,

                       dict_t *xdata)

{

    loc_copy(&args->loc, loc);

    args->name = gf_strdup(name);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_removexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                           int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;

    args->op_errno = op_errno;

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fremovexattr_store(default_args_t *args, fd_t *fd, const char *name,

                        dict_t *xdata)

{

    args->fd = fd_ref(fd);

    args->name = gf_strdup(name);

    if (xdata)

        args->xdata = dict_ref(xdata);

    return 0;

}

int

args_fremovexattr_cbk_store(default_args_cbk_t *args, int32_t op_ret,

                            int32_t op_errno, dict_t *xdata)

{

    args->op_ret = op_ret;