path: root/xlators/protocol/lib/src/protocol.h

/*
  Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.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/>.
*/

#ifndef _PROTOCOL_H
#define _PROTOCOL_H

#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif

#include <inttypes.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <unistd.h>
#include <fcntl.h>

#include "byte-order.h"
#include "iatt.h"

/* Any changes in the protocol structure or adding new '[f,m]ops' needs to 
 * bump the protocol version by "0.1" 
 */

#define GF_PROTOCOL_VERSION "3.0"

extern char *gf_mop_list[];
extern char *gf_cbk_list[];

/* NOTE: add members ONLY at the end (just before _MAXVALUE) */
typedef enum {
        GF_PROTO_FOP_STAT,       /* 0 */
        GF_PROTO_FOP_READLINK,   /* 1 */
        GF_PROTO_FOP_MKNOD,      /* 2 */
        GF_PROTO_FOP_MKDIR,
        GF_PROTO_FOP_UNLINK,
        GF_PROTO_FOP_RMDIR,      /* 5 */
        GF_PROTO_FOP_SYMLINK,
        GF_PROTO_FOP_RENAME,
        GF_PROTO_FOP_LINK,
        GF_PROTO_FOP_TRUNCATE,
        GF_PROTO_FOP_OPEN,       /* 10 */
        GF_PROTO_FOP_READ,
        GF_PROTO_FOP_WRITE,
        GF_PROTO_FOP_STATFS,     /* 15 */
        GF_PROTO_FOP_FLUSH,
        GF_PROTO_FOP_FSYNC,
        GF_PROTO_FOP_SETXATTR,
        GF_PROTO_FOP_GETXATTR,
        GF_PROTO_FOP_REMOVEXATTR,/* 20 */
        GF_PROTO_FOP_OPENDIR,
        GF_PROTO_FOP_GETDENTS,
        GF_PROTO_FOP_FSYNCDIR,
        GF_PROTO_FOP_ACCESS,
        GF_PROTO_FOP_CREATE,     /* 25 */
        GF_PROTO_FOP_FTRUNCATE,
        GF_PROTO_FOP_FSTAT,
        GF_PROTO_FOP_LK,
        GF_PROTO_FOP_LOOKUP,
        GF_PROTO_FOP_SETDENTS,
        GF_PROTO_FOP_READDIR,
        GF_PROTO_FOP_INODELK,   /* 35 */
        GF_PROTO_FOP_FINODELK,
	GF_PROTO_FOP_ENTRYLK,
	GF_PROTO_FOP_FENTRYLK,
        GF_PROTO_FOP_CHECKSUM,
        GF_PROTO_FOP_XATTROP,  /* 40 */
        GF_PROTO_FOP_FXATTROP,
        GF_PROTO_FOP_LOCK_NOTIFY,
        GF_PROTO_FOP_LOCK_FNOTIFY,
        GF_PROTO_FOP_FGETXATTR,
        GF_PROTO_FOP_FSETXATTR, /* 45 */
        GF_PROTO_FOP_RCHECKSUM,
        GF_PROTO_FOP_SETATTR,
        GF_PROTO_FOP_FSETATTR,
        GF_PROTO_FOP_READDIRP,
        GF_PROTO_FOP_MAXVALUE,
} glusterfs_proto_fop_t;

/* NOTE: add members ONLY at the end (just before _MAXVALUE) */
typedef enum {
        GF_MOP_SETVOLUME, /* 0 */
        GF_MOP_GETVOLUME, /* 1 */
        GF_MOP_STATS,
        GF_MOP_SETSPEC,
        GF_MOP_GETSPEC,
	GF_MOP_PING,      /* 5 */
        GF_MOP_LOG,
        GF_MOP_NOTIFY,
        GF_MOP_MAXVALUE,   /* 8 */
} glusterfs_mop_t;

typedef enum {
	GF_CBK_FORGET,      /* 0 */
	GF_CBK_RELEASE,     /* 1 */
	GF_CBK_RELEASEDIR,  /* 2 */
	GF_CBK_MAXVALUE     /* 3 */
} glusterfs_cbk_t;

typedef enum {
        GF_OP_TYPE_FOP_REQUEST = 1,
        GF_OP_TYPE_MOP_REQUEST,
	GF_OP_TYPE_CBK_REQUEST,
        GF_OP_TYPE_FOP_REPLY,
        GF_OP_TYPE_MOP_REPLY,
	GF_OP_TYPE_CBK_REPLY
} glusterfs_op_type_t;


struct gf_stat {
	uint64_t ino;
	uint64_t size;
	uint64_t blocks;
	uint64_t dev;
	uint32_t rdev;
	uint32_t mode;
	uint32_t nlink;
	uint32_t uid;
	uint32_t gid;
	uint32_t blksize;
	uint32_t atime;
	uint32_t atime_nsec;
	uint32_t mtime ;
	uint32_t mtime_nsec;
	uint32_t ctime;
	uint32_t ctime_nsec;
} __attribute__((packed));


static inline void
gf_stat_to_stat (struct gf_stat *gf_stat, struct stat *stat)
{
	stat->st_dev          = ntoh64 (gf_stat->dev);
	stat->st_ino          = ntoh64 (gf_stat->ino);
	stat->st_mode         = ntoh32 (gf_stat->mode);
	stat->st_nlink        = ntoh32 (gf_stat->nlink);
	stat->st_uid          = ntoh32 (gf_stat->uid);
	stat->st_gid          = ntoh32 (gf_stat->gid);
	stat->st_rdev         = ntoh32 (gf_stat->rdev);
	stat->st_size         = ntoh64 (gf_stat->size);
	stat->st_blksize      = ntoh32 (gf_stat->blksize);
	stat->st_blocks       = ntoh64 (gf_stat->blocks);
	stat->st_atime        = ntoh32 (gf_stat->atime);
	stat->st_mtime        = ntoh32 (gf_stat->mtime);
	stat->st_ctime        = ntoh32 (gf_stat->ctime);
        ST_ATIM_NSEC_SET(stat, ntoh32 (gf_stat->atime_nsec));
        ST_MTIM_NSEC_SET(stat, ntoh32 (gf_stat->mtime_nsec));
        ST_CTIM_NSEC_SET(stat, ntoh32 (gf_stat->ctime_nsec));
}


static inline void
gf_stat_from_stat (struct gf_stat *gf_stat, struct stat *stat)
{
	gf_stat->dev         = hton64 (stat->st_dev);
	gf_stat->ino         = hton64 (stat->st_ino);
	gf_stat->mode        = hton32 (stat->st_mode);
	gf_stat->nlink       = hton32 (stat->st_nlink);
	gf_stat->uid         = hton32 (stat->st_uid);
	gf_stat->gid         = hton32 (stat->st_gid);
	gf_stat->rdev        = hton32 (stat->st_rdev);
	gf_stat->size        = hton64 (stat->st_size);
	gf_stat->blksize     = hton32 (stat->st_blksize);
	gf_stat->blocks      = hton64 (stat->st_blocks);
	gf_stat->atime       = hton32 (stat->st_atime);
	gf_stat->mtime       = hton32 (stat->st_mtime);
	gf_stat->ctime       = hton32 (stat->st_ctime);
        gf_stat->atime_nsec  = hton32 (ST_ATIM_NSEC(stat));
        gf_stat->mtime_nsec  = hton32 (ST_MTIM_NSEC(stat));
        gf_stat->ctime_nsec  = hton32 (ST_CTIM_NSEC(stat));
}


static inline void
gf_stat_to_iatt (struct gf_stat *gf_stat, struct iatt *iatt)
{
        iatt->ia_ino        = ntoh64 (gf_stat->ino);
        iatt->ia_dev        = ntoh64 (gf_stat->dev);
        iatt->ia_type       = ia_type_from_st_mode (ntoh32 (gf_stat->mode));
        iatt->ia_prot       = ia_prot_from_st_mode (ntoh32 (gf_stat->mode));
        iatt->ia_nlink      = ntoh32 (gf_stat->nlink);
        iatt->ia_uid        = ntoh32 (gf_stat->uid);
        iatt->ia_gid        = ntoh32 (gf_stat->gid);
        iatt->ia_rdev       = ntoh64 (gf_stat->rdev);
        iatt->ia_size       = ntoh64 (gf_stat->size);
        iatt->ia_blksize    = ntoh32 (gf_stat->blksize);
        iatt->ia_blocks     = ntoh64 (gf_stat->blocks);
        iatt->ia_atime      = ntoh32 (gf_stat->atime);
        iatt->ia_atime_nsec = ntoh32 (gf_stat->atime_nsec);
        iatt->ia_mtime      = ntoh32 (gf_stat->mtime);
        iatt->ia_mtime_nsec = ntoh32 (gf_stat->mtime_nsec);
        iatt->ia_ctime      = ntoh32 (gf_stat->ctime);
        iatt->ia_ctime_nsec = ntoh32 (gf_stat->ctime_nsec);

        iatt->ia_gen        = ntoh64 (gf_stat->dev);
}


static inline void
gf_stat_from_iatt (struct gf_stat *gf_stat, struct iatt *iatt)
{
        gf_stat->ino        = hton64 (iatt->ia_ino);
        gf_stat->dev        = hton64 (iatt->ia_dev);
        gf_stat->mode       = hton32 (st_mode_from_ia (iatt->ia_prot,
                                                       iatt->ia_type));
        gf_stat->nlink      = hton32 (iatt->ia_nlink);
        gf_stat->uid        = hton32 (iatt->ia_uid);
        gf_stat->gid        = hton32 (iatt->ia_gid);
        gf_stat->rdev       = hton32 (iatt->ia_rdev);
        gf_stat->size       = hton64 (iatt->ia_size);
        gf_stat->blksize    = hton32 (iatt->ia_blksize);
        gf_stat->blocks     = hton64 (iatt->ia_blocks);
        gf_stat->atime      = hton32 (iatt->ia_atime);
        gf_stat->atime_nsec = hton32 (iatt->ia_atime_nsec);
        gf_stat->mtime      = hton32 (iatt->ia_mtime);
        gf_stat->mtime_nsec = hton32 (iatt->ia_mtime_nsec);
        gf_stat->ctime      = hton32 (iatt->ia_ctime);
        gf_stat->ctime_nsec = hton32 (iatt->ia_ctime_nsec);

        gf_stat->dev        = hton64 (iatt->ia_gen);

}


struct gf_statfs {
	uint64_t bsize;
	uint64_t frsize;
	uint64_t blocks;
	uint64_t bfree;
	uint64_t bavail;
	uint64_t files;
	uint64_t ffree;
	uint64_t favail;
	uint64_t fsid;
	uint64_t flag;
	uint64_t namemax;
} __attribute__((packed));


static inline void
gf_statfs_to_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
{
	stat->f_bsize   = ntoh64 (gf_stat->bsize);
	stat->f_frsize  = ntoh64 (gf_stat->frsize);
	stat->f_blocks  = ntoh64 (gf_stat->blocks);
	stat->f_bfree   = ntoh64 (gf_stat->bfree);
	stat->f_bavail  = ntoh64 (gf_stat->bavail);
	stat->f_files   = ntoh64 (gf_stat->files);
	stat->f_ffree   = ntoh64 (gf_stat->ffree);
	stat->f_favail  = ntoh64 (gf_stat->favail);
	stat->f_fsid    = ntoh64 (gf_stat->fsid);
	stat->f_flag    = ntoh64 (gf_stat->flag);
	stat->f_namemax = ntoh64 (gf_stat->namemax);
}


static inline void
gf_statfs_from_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
{
	gf_stat->bsize   = hton64 (stat->f_bsize);
	gf_stat->frsize  = hton64 (stat->f_frsize);
	gf_stat->blocks  = hton64 (stat->f_blocks);
	gf_stat->bfree   = hton64 (stat->f_bfree);
	gf_stat->bavail  = hton64 (stat->f_bavail);
	gf_stat->files   = hton64 (stat->f_files);
	gf_stat->ffree   = hton64 (stat->f_ffree);
	gf_stat->favail  = hton64 (stat->f_favail);
	gf_stat->fsid    = hton64 (stat->f_fsid);
	gf_stat->flag    = hton64 (stat->f_flag);
	gf_stat->namemax = hton64 (stat->f_namemax);
}


struct gf_flock {
	uint16_t type;
	uint16_t whence;
	uint64_t start;
	uint64_t len;
	uint32_t pid;
} __attribute__((packed));


static inline void
gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock)
{
	flock->l_type   = ntoh16 (gf_flock->type);
	flock->l_whence = ntoh16 (gf_flock->whence);
	flock->l_start  = ntoh64 (gf_flock->start);
	flock->l_len    = ntoh64 (gf_flock->len);
	flock->l_pid    = ntoh32 (gf_flock->pid);
}


static inline void
gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock)
{
	gf_flock->type   = hton16 (flock->l_type);
	gf_flock->whence = hton16 (flock->l_whence);
	gf_flock->start  = hton64 (flock->l_start);
	gf_flock->len    = hton64 (flock->l_len);
	gf_flock->pid    = hton32 (flock->l_pid);
}


struct gf_timespec {
	uint32_t tv_sec;
	uint32_t tv_nsec;
} __attribute__((packed));


static inline void
gf_timespec_to_timespec (struct gf_timespec *gf_ts, struct timespec *ts)
{

	ts[0].tv_sec  = ntoh32 (gf_ts[0].tv_sec);
	ts[0].tv_nsec = ntoh32 (gf_ts[0].tv_nsec);
	ts[1].tv_sec  = ntoh32 (gf_ts[1].tv_sec);
	ts[1].tv_nsec = ntoh32 (gf_ts[1].tv_nsec);
}


static inline void
gf_timespec_from_timespec (struct gf_timespec *gf_ts, struct timespec *ts)
{
	gf_ts[0].tv_sec  = hton32 (ts[0].tv_sec);
	gf_ts[0].tv_nsec = hton32 (ts[0].tv_nsec);
	gf_ts[1].tv_sec  = hton32 (ts[1].tv_sec);
	gf_ts[1].tv_nsec = hton32 (ts[1].tv_nsec);
}


#define GF_O_ACCMODE           003
#define GF_O_RDONLY             00
#define GF_O_WRONLY             01
#define GF_O_RDWR               02
#define GF_O_CREAT            0100
#define GF_O_EXCL             0200
#define GF_O_NOCTTY           0400
#define GF_O_TRUNC           01000
#define GF_O_APPEND          02000
#define GF_O_NONBLOCK        04000
#define GF_O_SYNC           010000
#define GF_O_ASYNC          020000

#define GF_O_DIRECT         040000
#define GF_O_DIRECTORY     0200000
#define GF_O_NOFOLLOW      0400000
#define GF_O_NOATIME      01000000
#define GF_O_CLOEXEC      02000000

#define GF_O_LARGEFILE     0100000

#define XLATE_BIT(from, to, bit)    do {                \
                if (from & bit)                         \
                        to = to | GF_##bit;             \
        } while (0)

#define UNXLATE_BIT(from, to, bit)  do {                \
                if (from & GF_##bit)                    \
                        to = to | bit;                  \
        } while (0)

#define XLATE_ACCESSMODE(from, to) do {                 \
                switch (from & O_ACCMODE) {             \
                case O_RDONLY: to |= GF_O_RDONLY;       \
                        break;                          \
                case O_WRONLY: to |= GF_O_WRONLY;       \
                        break;                          \
                case O_RDWR: to |= GF_O_RDWR;           \
                        break;                          \
                }                                       \
        } while (0)

#define UNXLATE_ACCESSMODE(from, to) do {               \
                switch (from & GF_O_ACCMODE) {          \
                case GF_O_RDONLY: to |= O_RDONLY;       \
                        break;                          \
                case GF_O_WRONLY: to |= O_WRONLY;       \
                        break;                          \
                case GF_O_RDWR: to |= O_RDWR;           \
                        break;                          \
                }                                       \
        } while (0)

static inline uint32_t
gf_flags_from_flags (uint32_t flags)
{
        uint32_t gf_flags = 0;

        XLATE_ACCESSMODE (flags, gf_flags);

        XLATE_BIT (flags, gf_flags, O_CREAT);
        XLATE_BIT (flags, gf_flags, O_EXCL);
        XLATE_BIT (flags, gf_flags, O_NOCTTY);
        XLATE_BIT (flags, gf_flags, O_TRUNC);
        XLATE_BIT (flags, gf_flags, O_APPEND);
        XLATE_BIT (flags, gf_flags, O_NONBLOCK);
        XLATE_BIT (flags, gf_flags, O_SYNC);
        XLATE_BIT (flags, gf_flags, O_ASYNC);

        XLATE_BIT (flags, gf_flags, O_DIRECT);
        XLATE_BIT (flags, gf_flags, O_DIRECTORY);
        XLATE_BIT (flags, gf_flags, O_NOFOLLOW);
#ifdef O_NOATIME
        XLATE_BIT (flags, gf_flags, O_NOATIME);
#endif
#ifdef O_CLOEXEC
        XLATE_BIT (flags, gf_flags, O_CLOEXEC);
#endif
        XLATE_BIT (flags, gf_flags, O_LARGEFILE);

        return gf_flags;
}

static inline uint32_t
gf_flags_to_flags (uint32_t gf_flags)
{
        uint32_t flags = 0;

        UNXLATE_ACCESSMODE (gf_flags, flags);

        UNXLATE_BIT (gf_flags, flags, O_CREAT);
        UNXLATE_BIT (gf_flags, flags, O_EXCL);
        UNXLATE_BIT (gf_flags, flags, O_NOCTTY);
        UNXLATE_BIT (gf_flags, flags, O_TRUNC);
        UNXLATE_BIT (gf_flags, flags, O_APPEND);
        UNXLATE_BIT (gf_flags, flags, O_NONBLOCK);
        UNXLATE_BIT (gf_flags, flags, O_SYNC);
        UNXLATE_BIT (gf_flags, flags, O_ASYNC);

        UNXLATE_BIT (gf_flags, flags, O_DIRECT);
        UNXLATE_BIT (gf_flags, flags, O_DIRECTORY);
        UNXLATE_BIT (gf_flags, flags, O_NOFOLLOW);
#ifdef O_NOATIME
        UNXLATE_BIT (gf_flags, flags, O_NOATIME);
#endif
#ifdef O_CLOEXEC
        UNXLATE_BIT (gf_flags, flags, O_CLOEXEC);
#endif
        UNXLATE_BIT (gf_flags, flags, O_LARGEFILE);

        return flags;
}


typedef struct {
	uint64_t ino;
        uint64_t gen;
	char     path[0];     /* NULL terminated */
} __attribute__((packed)) gf_fop_stat_req_t;;
typedef struct {
	struct gf_stat stat;
} __attribute__((packed)) gf_fop_stat_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t size;
	char     path[0];     /* NULL terminated */
} __attribute__((packed)) gf_fop_readlink_req_t;
typedef struct {
        struct gf_stat buf;
	char     path[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_readlink_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	uint64_t dev;
	uint32_t mode;
	char     path[0];     /* NULL terminated */
	char     bname[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_mknod_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_mknod_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	uint32_t mode;
	char     path[0];     /* NULL terminated */
	char     bname[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_mkdir_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_mkdir_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	char     path[0];     /* NULL terminated */
	char     bname[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_unlink_req_t;
typedef struct {
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_unlink_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	char     path[0];
	char     bname[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_rmdir_req_t;
typedef struct {
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_rmdir_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	char     path[0];
	char     bname[0];
	char     linkname[0];
} __attribute__((packed)) gf_fop_symlink_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat preparent;
        struct gf_stat postparent;
}__attribute__((packed)) gf_fop_symlink_rsp_t;


typedef struct {
	uint64_t   oldpar;
        uint64_t   oldgen;
	uint64_t   newpar;
        uint64_t   newgen;
	char       oldpath[0];
	char       oldbname[0]; /* NULL terminated */
	char       newpath[0];
	char       newbname[0]; /* NULL terminated */
} __attribute__((packed)) gf_fop_rename_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat preoldparent;
        struct gf_stat postoldparent;
        struct gf_stat prenewparent;
        struct gf_stat postnewparent;
} __attribute__((packed)) gf_fop_rename_rsp_t;


typedef struct {
	uint64_t   oldino;
        uint64_t   oldgen;
	uint64_t   newpar;
        uint64_t   newgen;
	char       oldpath[0];
	char       newpath[0];
	char       newbname[0];
}__attribute__((packed)) gf_fop_link_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_link_rsp_t;

typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint64_t offset;
	char     path[0];
} __attribute__((packed)) gf_fop_truncate_req_t;
typedef struct {
	struct gf_stat prestat;
        struct gf_stat poststat;
} __attribute__((packed)) gf_fop_truncate_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t flags;
        uint32_t wbflags;
	char     path[0];
} __attribute__((packed)) gf_fop_open_req_t;
typedef struct {
	int64_t fd;
} __attribute__((packed)) gf_fop_open_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint64_t offset;
	uint32_t size;
} __attribute__((packed)) gf_fop_read_req_t;
typedef struct {
	struct gf_stat stat;
	char buf[0];
} __attribute__((packed)) gf_fop_read_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint64_t offset;
	uint32_t size;
} __attribute__((packed)) gf_fop_write_req_t;
typedef struct {
	struct gf_stat prestat;
        struct gf_stat poststat;
} __attribute__((packed)) gf_fop_write_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	char     path[0];
} __attribute__((packed)) gf_fop_statfs_req_t;
typedef struct {
	struct gf_statfs statfs;
} __attribute__((packed)) gf_fop_statfs_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
} __attribute__((packed)) gf_fop_flush_req_t;
typedef struct { } __attribute__((packed)) gf_fop_flush_rsp_t;


typedef struct fsync_req {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint32_t data;
} __attribute__((packed)) gf_fop_fsync_req_t;
typedef struct {
        struct gf_stat prestat;
        struct gf_stat poststat;
} __attribute__((packed)) gf_fop_fsync_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t flags;
	uint32_t dict_len;
	char     dict[0];
	char     path[0];
} __attribute__((packed)) gf_fop_setxattr_req_t;
typedef struct { } __attribute__((packed)) gf_fop_setxattr_rsp_t;


typedef struct {
        uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint32_t flags;
	uint32_t dict_len;
	char     dict[0];
} __attribute__((packed)) gf_fop_fsetxattr_req_t;
typedef struct { } __attribute__((packed)) gf_fop_fsetxattr_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t flags;
	uint32_t dict_len;
	char     dict[0];
	char     path[0];
} __attribute__((packed)) gf_fop_xattrop_req_t;

typedef struct {
	uint32_t dict_len;
	char  dict[0];
} __attribute__((packed)) gf_fop_xattrop_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint32_t flags;
	uint32_t dict_len;
	char     dict[0];
} __attribute__((packed)) gf_fop_fxattrop_req_t;

typedef struct {
	uint32_t dict_len;
	char  dict[0];
} __attribute__((packed)) gf_fop_fxattrop_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t namelen;
	char     path[0];
	char     name[0];
} __attribute__((packed)) gf_fop_getxattr_req_t;
typedef struct {
	uint32_t dict_len;
	char     dict[0];
} __attribute__((packed)) gf_fop_getxattr_rsp_t;


typedef struct {
        uint64_t ino;
        uint64_t gen;
	int64_t  fd;
        uint32_t namelen;
	char     name[0];
} __attribute__((packed)) gf_fop_fgetxattr_req_t;
typedef struct {
	uint32_t dict_len;
	char     dict[0];
} __attribute__((packed)) gf_fop_fgetxattr_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	char     path[0];
	char     name[0];
} __attribute__((packed)) gf_fop_removexattr_req_t;
typedef struct { } __attribute__((packed)) gf_fop_removexattr_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	char     path[0];
} __attribute__((packed)) gf_fop_opendir_req_t;
typedef struct {
	int64_t fd;
} __attribute__((packed)) gf_fop_opendir_rsp_t;


typedef struct fsyncdir_req {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	int32_t  data;
} __attribute__((packed)) gf_fop_fsyncdir_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_fsyncdir_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint64_t offset;
	uint32_t size;
} __attribute__((packed)) gf_fop_readdir_req_t;
typedef struct {
	uint32_t size;
	char     buf[0];
} __attribute__((packed)) gf_fop_readdir_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint64_t offset;
	uint32_t size;
} __attribute__((packed)) gf_fop_readdirp_req_t;
typedef struct {
	uint32_t size;
	char     buf[0];
} __attribute__((packed)) gf_fop_readdirp_rsp_t;


typedef struct  {
	uint64_t ino;
        uint64_t gen;
	uint32_t mask;
	char     path[0];
} __attribute__((packed)) gf_fop_access_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_access_rsp_t;


typedef struct {
	uint64_t par;
        uint64_t gen;
	uint32_t flags;
	uint32_t mode;
	char     path[0];
	char     bname[0];
} __attribute__((packed)) gf_fop_create_req_t;
typedef struct {
	struct gf_stat stat;
	uint64_t       fd;
        struct gf_stat preparent;
        struct gf_stat postparent;
} __attribute__((packed)) gf_fop_create_rsp_t;



typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint64_t offset;
} __attribute__((packed)) gf_fop_ftruncate_req_t;
typedef struct {
	struct gf_stat prestat;
        struct gf_stat poststat;
} __attribute__((packed)) gf_fop_ftruncate_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
} __attribute__((packed)) gf_fop_fstat_req_t;
typedef struct {
	struct gf_stat stat;
} __attribute__((packed)) gf_fop_fstat_rsp_t;


typedef struct {
	uint64_t        ino;
        uint64_t        gen;
	int64_t         fd;
	uint32_t        cmd;
	uint32_t        type;
	struct gf_flock flock;
} __attribute__((packed)) gf_fop_lk_req_t;
typedef struct {
	struct gf_flock flock;
} __attribute__((packed)) gf_fop_lk_rsp_t;

typedef struct {
	uint64_t ino;
        uint64_t gen;
	uint32_t cmd;
	uint32_t type;
	struct gf_flock flock;
	char     path[0];
        char     volume[0];
} __attribute__((packed)) gf_fop_inodelk_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_inodelk_rsp_t;

typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
	uint32_t cmd;
	uint32_t type;
	struct gf_flock flock;
        char volume[0];
} __attribute__((packed)) gf_fop_finodelk_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_finodelk_rsp_t;

typedef struct {
	uint64_t  ino;
        uint64_t  gen;
	uint32_t  cmd;
	uint32_t  type;
	uint64_t  namelen;
	char      path[0];
	char      name[0];
        char      volume[0];
} __attribute__((packed)) gf_fop_entrylk_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_entrylk_rsp_t;

typedef struct {
	uint64_t  ino;
        uint64_t  gen;
	int64_t   fd;
	uint32_t  cmd;
	uint32_t  type;
	uint64_t  namelen;
	char      name[0];
        char      volume[0];
} __attribute__((packed)) gf_fop_fentrylk_req_t;
typedef struct {
} __attribute__((packed)) gf_fop_fentrylk_rsp_t;

typedef struct {
	uint64_t ino; /* NOTE: used only in case of 'root' lookup */
	uint64_t par;
        uint64_t gen;
	uint32_t flags;
	uint32_t dictlen;
	char     path[0];
	char     bname[0];
	char     dict[0];
} __attribute__((packed)) gf_fop_lookup_req_t;
typedef struct {
	struct gf_stat stat;
        struct gf_stat postparent;
	uint32_t       dict_len;
	char           dict[0];
} __attribute__((packed)) gf_fop_lookup_rsp_t;

typedef struct {
	uint64_t  ino;
        uint64_t  gen;
	uint32_t  flag;
	char      path[0];
} __attribute__((packed)) gf_fop_checksum_req_t;
typedef struct {
	unsigned char fchecksum[0];
	unsigned char dchecksum[0];
} __attribute__((packed)) gf_fop_checksum_rsp_t;

typedef struct {
        uint64_t       ino;
        uint64_t       gen;
        struct gf_stat stbuf;
        int32_t        valid;
        char           path[0];
} __attribute__((packed)) gf_fop_setattr_req_t;
typedef struct {
        struct gf_stat statpre;
        struct gf_stat statpost;
} __attribute__((packed)) gf_fop_setattr_rsp_t;

typedef struct {
        int64_t        fd;
        struct gf_stat stbuf;
        int32_t        valid;
} __attribute__((packed)) gf_fop_fsetattr_req_t;
typedef struct {
        struct gf_stat statpre;
        struct gf_stat statpost;
} __attribute__((packed)) gf_fop_fsetattr_rsp_t;

typedef struct {
        int64_t   fd;
        uint64_t  offset;
        uint32_t  len;
} __attribute__((packed)) gf_fop_rchecksum_req_t;
typedef struct {
        uint32_t weak_checksum;
        unsigned char strong_checksum[0];
} __attribute__((packed)) gf_fop_rchecksum_rsp_t;

typedef struct {
	uint32_t flags;
	uint32_t keylen;
	char     key[0];
} __attribute__((packed)) gf_mop_getspec_req_t;
typedef struct {
	char spec[0];
} __attribute__((packed)) gf_mop_getspec_rsp_t;


typedef struct {
        uint32_t msglen;
	char     msg[0];
} __attribute__((packed)) gf_mop_log_req_t;
typedef struct {
} __attribute__((packed)) gf_mop_log_rsp_t;


typedef struct {
	uint32_t dict_len;
	char buf[0];
} __attribute__((packed)) gf_mop_setvolume_req_t;
typedef struct {
	uint32_t dict_len;
	char buf[0];
} __attribute__((packed)) gf_mop_setvolume_rsp_t;


typedef struct {
} __attribute__((packed)) gf_mop_ping_req_t;
typedef struct {
} __attribute__((packed)) gf_mop_ping_rsp_t;

typedef struct {
	uint32_t  flags;
        char buf[0];
} __attribute__((packed)) gf_mop_notify_req_t;
typedef struct {
	uint32_t  flags;
        char buf[0];
} __attribute__((packed)) gf_mop_notify_rsp_t;

typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
} __attribute__((packed)) gf_cbk_releasedir_req_t;
typedef struct {
} __attribute__((packed)) gf_cbk_releasedir_rsp_t;


typedef struct {
	uint64_t ino;
        uint64_t gen;
	int64_t  fd;
} __attribute__((packed)) gf_cbk_release_req_t;
typedef struct {
} __attribute__((packed)) gf_cbk_release_rsp_t;


typedef struct {
	uint32_t count;
	uint64_t ino_array[0];
} __attribute__((packed)) gf_cbk_forget_req_t;
typedef struct { } __attribute__((packed)) gf_cbk_forget_rsp_t;


typedef struct {
	uint32_t pid;
	uint32_t uid;
	uint32_t gid;

        /* Number of groups being sent through the array above. */
        uint32_t ngrps;

        /* Array of groups to which the uid belongs apart from the primary group
         * in gid.
         */
        uint32_t groups[GF_REQUEST_MAXGROUPS];

        uint64_t lk_owner;
} __attribute__ ((packed)) gf_hdr_req_t;


typedef struct {
	uint32_t op_ret;
	uint32_t op_errno;
} __attribute__ ((packed)) gf_hdr_rsp_t;


typedef struct {
	uint64_t callid;
	uint32_t type;
	uint32_t op;
	uint32_t size;
	union {
		gf_hdr_req_t req;
		gf_hdr_rsp_t rsp;
	} __attribute__ ((packed));
} __attribute__ ((packed)) gf_hdr_common_t;


static inline gf_hdr_common_t *
__gf_hdr_new (int size)
{
	gf_hdr_common_t *hdr = NULL;

	/* TODO: use mem-pool */
	hdr = GF_CALLOC (sizeof (gf_hdr_common_t) + size, 1,
                         gf_common_mt_gf_hdr_common_t);

	if (!hdr) {
		return NULL;
	}

	hdr->size = hton32 (size);

	return hdr;
}


#define gf_hdr_len(type, x) (sizeof (gf_hdr_common_t) + sizeof (*type) + x)
#define gf_hdr_new(type, x) __gf_hdr_new (sizeof (*type) + x)


static inline void *
gf_param (gf_hdr_common_t *hdr)
{
	return ((void *)hdr) + sizeof (*hdr);
}


struct gf_dirent_nb {
	uint64_t       d_ino;
	uint64_t       d_off;
	uint32_t       d_len;
	uint32_t       d_type;
        struct gf_stat d_stat;
	char           d_name[0];
} __attribute__((packed));

int
gf_dirent_unserialize (gf_dirent_t *entries, const char *buf, size_t buf_size);
int
gf_dirent_serialize (gf_dirent_t *entries, char *buf, size_t buf_size);

int protocol_common_init (void);

#endif