everything.x

typedef hyper quad_t;
typedef unsigned int uint32_t;
typedef unsigned int u_int32_t;
typedef unsigned hyper u_int64_t;
typedef hyper int64_t;
typedef int int32_t;

struct aclentry {
	int acl_type;
	int uid;
	int perm;
};

/*
struct getaclargs {
	netobj fh;
	int	mask;
};

*/
/*
struct getaclreply {
	int status;
	int attr_follows;
	fattr3 attr;
	int	mask;
	int aclcount;
	aclentry aclentry<>;
	int daclcount;
	aclentry daclentry<>;
};
*/

/*
struct setaclargs {
	netobj fh;
	int mask;
	int aclcount;
	aclentry aclentry<>;
	int daclcount;
	aclentry daclentry<>;
};
*/

/*
struct setaclreply {
	int status;
	int attr_follows;
	fattr3 attr;
};
*/
/* XDR: libgfchangelog -> changelog */

/*
struct changelog_probe_req {
       unsigned int filter;
       char sock[UNIX_PATH_MAX];
};
*/

struct changelog_probe_rsp {
       int op_ret;
};

/* XDR: changelog -> libgfchangelog */
/*
struct changelog_event_req {
       unsigned long seq;

       unsigned long tv_sec;
       unsigned long tv_usec;
};

struct changelog_event_rsp {
       int op_ret;

       unsigned long seq;
};
*/
 enum gf_cli_defrag_type {
        GF_DEFRAG_CMD_START = 1,
        GF_DEFRAG_CMD_STOP,
        GF_DEFRAG_CMD_STATUS,
        GF_DEFRAG_CMD_START_LAYOUT_FIX,
        GF_DEFRAG_CMD_START_FORCE, /* used by remove-brick data migration */
        GF_DEFRAG_CMD_START_TIER,
        GF_DEFRAG_CMD_STATUS_TIER,
        GF_DEFRAG_CMD_START_DETACH_TIER,
        GF_DEFRAG_CMD_STOP_DETACH_TIER
};

 enum gf_defrag_status_t {
        GF_DEFRAG_STATUS_NOT_STARTED,
        GF_DEFRAG_STATUS_STARTED,
        GF_DEFRAG_STATUS_STOPPED,
        GF_DEFRAG_STATUS_COMPLETE,
        GF_DEFRAG_STATUS_FAILED,
        GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED,
        GF_DEFRAG_STATUS_LAYOUT_FIX_STOPPED,
        GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE,
        GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED,
        GF_DEFRAG_STATUS_MAX
};

 enum gf1_cluster_type {
        GF_CLUSTER_TYPE_NONE = 0,
        GF_CLUSTER_TYPE_STRIPE,
        GF_CLUSTER_TYPE_REPLICATE,
        GF_CLUSTER_TYPE_STRIPE_REPLICATE,
        GF_CLUSTER_TYPE_DISPERSE,
        GF_CLUSTER_TYPE_TIER,
        GF_CLUSTER_TYPE_MAX
};

enum gf_bitrot_type {
        GF_BITROT_OPTION_TYPE_NONE = 0,
        GF_BITROT_OPTION_TYPE_ENABLE,
        GF_BITROT_OPTION_TYPE_DISABLE,
        GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE,
        GF_BITROT_OPTION_TYPE_SCRUB_FREQ,
        GF_BITROT_OPTION_TYPE_SCRUB,
        GF_BITROT_OPTION_TYPE_EXPIRY_TIME,
        GF_BITROT_OPTION_TYPE_MAX
};

 enum gf1_op_commands {
        GF_OP_CMD_NONE = 0,
        GF_OP_CMD_START,
        GF_OP_CMD_COMMIT,
        GF_OP_CMD_STOP,
        GF_OP_CMD_STATUS,
        GF_OP_CMD_COMMIT_FORCE,
        GF_OP_CMD_DETACH_START,
        GF_OP_CMD_DETACH_COMMIT,
        GF_OP_CMD_DETACH_COMMIT_FORCE,
        GF_OP_CMD_STOP_DETACH_TIER
};

enum gf_quota_type {
        GF_QUOTA_OPTION_TYPE_NONE = 0,
        GF_QUOTA_OPTION_TYPE_ENABLE,
        GF_QUOTA_OPTION_TYPE_DISABLE,
        GF_QUOTA_OPTION_TYPE_LIMIT_USAGE,
        GF_QUOTA_OPTION_TYPE_REMOVE,
        GF_QUOTA_OPTION_TYPE_LIST,
        GF_QUOTA_OPTION_TYPE_VERSION,
        GF_QUOTA_OPTION_TYPE_ALERT_TIME,
        GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT,
        GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT,
        GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT,
        GF_QUOTA_OPTION_TYPE_VERSION_OBJECTS,
        GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS,
        GF_QUOTA_OPTION_TYPE_LIST_OBJECTS,
        GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS,
        GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS,
        GF_QUOTA_OPTION_TYPE_MAX
};

enum gf1_cli_friends_list {
        GF_CLI_LIST_PEERS = 1,
        GF_CLI_LIST_POOL_NODES = 2
};

enum gf1_cli_get_volume {
        GF_CLI_GET_VOLUME_ALL = 1,
        GF_CLI_GET_VOLUME,
        GF_CLI_GET_NEXT_VOLUME
};

enum gf1_cli_sync_volume {
        GF_CLI_SYNC_ALL = 1
};

enum gf1_cli_op_flags {
        GF_CLI_FLAG_OP_FORCE = 1
};

enum gf1_cli_gsync_set {
        GF_GSYNC_OPTION_TYPE_NONE,
        GF_GSYNC_OPTION_TYPE_START,
        GF_GSYNC_OPTION_TYPE_STOP,
        GF_GSYNC_OPTION_TYPE_CONFIG,
        GF_GSYNC_OPTION_TYPE_STATUS,
        GF_GSYNC_OPTION_TYPE_ROTATE,
        GF_GSYNC_OPTION_TYPE_CREATE,
        GF_GSYNC_OPTION_TYPE_DELETE,
        GF_GSYNC_OPTION_TYPE_PAUSE,
        GF_GSYNC_OPTION_TYPE_RESUME
};

enum gf1_cli_stats_op {
        GF_CLI_STATS_NONE  = 0,
        GF_CLI_STATS_START = 1,
        GF_CLI_STATS_STOP  = 2,
        GF_CLI_STATS_INFO  = 3,
        GF_CLI_STATS_TOP = 4
};

enum gf1_cli_info_op {
        GF_CLI_INFO_NONE = 0,
        GF_CLI_INFO_ALL = 1,
        GF_CLI_INFO_INCREMENTAL = 2,
        GF_CLI_INFO_CUMULATIVE = 3,
        GF_CLI_INFO_CLEAR = 4
};

enum gf1_cli_top_op {
        GF_CLI_TOP_NONE = 0,
        GF_CLI_TOP_OPEN,
        GF_CLI_TOP_READ,
        GF_CLI_TOP_WRITE,
        GF_CLI_TOP_OPENDIR,
        GF_CLI_TOP_READDIR,
        GF_CLI_TOP_READ_PERF,
        GF_CLI_TOP_WRITE_PERF
};

/* The unconventional hex numbers help us perform
   bit-wise operations which reduces complexity */
enum gf_cli_status_type {
        GF_CLI_STATUS_NONE         = 0x000000,
        GF_CLI_STATUS_MEM          = 0x000001,    /*000000000000001*/
        GF_CLI_STATUS_CLIENTS      = 0x000002,    /*000000000000010*/
        GF_CLI_STATUS_INODE        = 0x000004,    /*000000000000100*/
        GF_CLI_STATUS_FD           = 0x000008,    /*000000000001000*/
        GF_CLI_STATUS_CALLPOOL     = 0x000010,    /*000000000010000*/
        GF_CLI_STATUS_DETAIL       = 0x000020,    /*000000000100000*/
        GF_CLI_STATUS_TASKS        = 0x000040,    /*00000001000000*/
        GF_CLI_STATUS_MASK         = 0x0000FF,    /*000000011111111 Used to get the op*/
        GF_CLI_STATUS_VOL          = 0x000100,    /*00000000100000000*/
        GF_CLI_STATUS_ALL          = 0x000200,    /*00000001000000000*/
        GF_CLI_STATUS_BRICK        = 0x000400,    /*00000010000000000*/
        GF_CLI_STATUS_NFS          = 0x000800,    /*00000100000000000*/
        GF_CLI_STATUS_SHD          = 0x001000,    /*00001000000000000*/
        GF_CLI_STATUS_QUOTAD       = 0x002000,    /*00010000000000000*/
        GF_CLI_STATUS_SNAPD        = 0x004000,    /*00100000000000000*/
        GF_CLI_STATUS_BITD         = 0x008000,    /*01000000000000000*/
        GF_CLI_STATUS_SCRUB        = 0x010000     /*10000000000000000*/
};

/* Identifiers for snapshot clis */
enum gf1_cli_snapshot {
        GF_SNAP_OPTION_TYPE_NONE = 0,
        GF_SNAP_OPTION_TYPE_CREATE,
        GF_SNAP_OPTION_TYPE_DELETE,
        GF_SNAP_OPTION_TYPE_RESTORE,
        GF_SNAP_OPTION_TYPE_ACTIVATE,
        GF_SNAP_OPTION_TYPE_DEACTIVATE,
        GF_SNAP_OPTION_TYPE_LIST,
        GF_SNAP_OPTION_TYPE_STATUS,
        GF_SNAP_OPTION_TYPE_CONFIG,
        GF_SNAP_OPTION_TYPE_CLONE,
        GF_SNAP_OPTION_TYPE_INFO
};

enum gf1_cli_snapshot_info {
        GF_SNAP_INFO_TYPE_ALL = 0,
        GF_SNAP_INFO_TYPE_SNAP,
        GF_SNAP_INFO_TYPE_VOL
};

enum gf1_cli_snapshot_config {
        GF_SNAP_CONFIG_TYPE_NONE = 0,
        GF_SNAP_CONFIG_TYPE_SET,
        GF_SNAP_CONFIG_DISPLAY
};

enum  gf1_cli_snapshot_status {
        GF_SNAP_STATUS_TYPE_ALL = 0,
        GF_SNAP_STATUS_TYPE_SNAP,
        GF_SNAP_STATUS_TYPE_VOL
};

enum gf1_cli_snapshot_delete {
        GF_SNAP_DELETE_TYPE_ALL  = 0,
        GF_SNAP_DELETE_TYPE_SNAP = 1,
        GF_SNAP_DELETE_TYPE_VOL  = 2
};

struct gf_cli_req {
        opaque  dict<>;
};

 struct gf_cli_rsp {
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
};

struct gf1_cli_peer_list_req {
        int     flags;
        opaque  dict<>;
};

struct gf1_cli_peer_list_rsp {
        int     op_ret;
        int     op_errno;
        opaque  friends<>;
};

struct gf1_cli_fsm_log_req {
        string name<>;
};

struct gf1_cli_fsm_log_rsp {
        int op_ret;
        int op_errno;
        string op_errstr<>;
        opaque fsm_log<>;
};

struct gf1_cli_getwd_req {
        int     unused;
};

struct gf1_cli_getwd_rsp {
        int     op_ret;
        int     op_errno;
        string  wd<>;
};

struct gf1_cli_mount_req {
        string label<>;
        opaque dict<>;
};

struct gf1_cli_mount_rsp {
       int op_ret;
       int op_errno;
       string path<>;
};

struct gf1_cli_umount_req {
        int lazy;
        string path<>;
};

struct gf1_cli_umount_rsp {
       int op_ret;
       int op_errno;
};
 enum gf_cli_defrag_type {
        GF_DEFRAG_CMD_START = 1,
        GF_DEFRAG_CMD_STOP = 2,
        GF_DEFRAG_CMD_STATUS = 3,
        GF_DEFRAG_CMD_START_LAYOUT_FIX = 4,
        GF_DEFRAG_CMD_START_FORCE = 5, /* used by remove-brick data migration */
        GF_DEFRAG_CMD_START_TIER = 6,
        GF_DEFRAG_CMD_STATUS_TIER = 7,
        GF_DEFRAG_CMD_START_DETACH_TIER = 8,
        GF_DEFRAG_CMD_STOP_DETACH_TIE = 9
};

 enum gf_defrag_status_t {
        GF_DEFRAG_STATUS_NOT_STARTED = 0,
        GF_DEFRAG_STATUS_STARTED = 1,
        GF_DEFRAG_STATUS_STOPPED = 2,
        GF_DEFRAG_STATUS_COMPLETE = 3,
        GF_DEFRAG_STATUS_FAILED = 4,
        GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED = 5,
        GF_DEFRAG_STATUS_LAYOUT_FIX_STOPPED = 6,
        GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE = 7,
        GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED = 8,
        GF_DEFRAG_STATUS_MAX = 9 
};

 enum gf1_cluster_type {
        GF_CLUSTER_TYPE_NONE = 0,
        GF_CLUSTER_TYPE_STRIPE = 1,
        GF_CLUSTER_TYPE_REPLICATE = 2,
        GF_CLUSTER_TYPE_STRIPE_REPLICATE = 3,
        GF_CLUSTER_TYPE_DISPERSE = 4,
        GF_CLUSTER_TYPE_TIER = 5,
        GF_CLUSTER_TYPE_MAX = 6
};

enum gf_bitrot_type {
        GF_BITROT_OPTION_TYPE_NONE = 0,
        GF_BITROT_OPTION_TYPE_ENABLE = 1,
        GF_BITROT_OPTION_TYPE_DISABLE = 2,
        GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE = 3,
        GF_BITROT_OPTION_TYPE_SCRUB_FREQ = 4,
        GF_BITROT_OPTION_TYPE_SCRUB = 5,
        GF_BITROT_OPTION_TYPE_EXPIRY_TIME = 6,
        GF_BITROT_OPTION_TYPE_MAX = 7
};

 enum gf1_op_commands {
        GF_OP_CMD_NONE = 0,
        GF_OP_CMD_START = 1,
        GF_OP_CMD_COMMIT = 2,
        GF_OP_CMD_STOP = 3,
        GF_OP_CMD_STATUS = 4,
        GF_OP_CMD_COMMIT_FORCE = 5,
        GF_OP_CMD_DETACH_START = 6,
        GF_OP_CMD_DETACH_COMMIT = 7,
        GF_OP_CMD_DETACH_COMMIT_FORCE = 8,
        GF_OP_CMD_STOP_DETACH_TIER = 9
};

enum gf_quota_type {
        GF_QUOTA_OPTION_TYPE_NONE = 0,
        GF_QUOTA_OPTION_TYPE_ENABLE = 1,
        GF_QUOTA_OPTION_TYPE_DISABLE = 2,
        GF_QUOTA_OPTION_TYPE_LIMIT_USAGE = 3,
        GF_QUOTA_OPTION_TYPE_REMOVE = 4,
        GF_QUOTA_OPTION_TYPE_LIST = 5,
        GF_QUOTA_OPTION_TYPE_VERSION = 6,
        GF_QUOTA_OPTION_TYPE_ALERT_TIME = 7,
        GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT = 8,
        GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT = 9,
        GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT = 10,
        GF_QUOTA_OPTION_TYPE_VERSION_OBJECTS = 11,
        GF_QUOTA_OPTION_TYPE_LIMIT_OBJECTS = 12,
        GF_QUOTA_OPTION_TYPE_LIST_OBJECTS = 13,
        GF_QUOTA_OPTION_TYPE_REMOVE_OBJECTS = 14,
        GF_QUOTA_OPTION_TYPE_ENABLE_OBJECTS = 15,
        GF_QUOTA_OPTION_TYPE_MAX = 16
};

enum gf1_cli_friends_list {
        GF_CLI_LIST_PEERS = 1,
        GF_CLI_LIST_POOL_NODES = 2
};

enum gf1_cli_get_volume {
        GF_CLI_GET_VOLUME_ALL = 1,
        GF_CLI_GET_VOLUME = 2,
        GF_CLI_GET_NEXT_VOLUME = 3
};

enum gf1_cli_sync_volume {
        GF_CLI_SYNC_ALL = 1
};

enum gf1_cli_op_flags {
        GF_CLI_FLAG_OP_FORCE = 1
};

enum gf1_cli_gsync_set {
        GF_GSYNC_OPTION_TYPE_NONE = 0,
        GF_GSYNC_OPTION_TYPE_START = 1,
        GF_GSYNC_OPTION_TYPE_STOP = 2,
        GF_GSYNC_OPTION_TYPE_CONFIG = 3,
        GF_GSYNC_OPTION_TYPE_STATUS = 4,
        GF_GSYNC_OPTION_TYPE_ROTATE = 5,
        GF_GSYNC_OPTION_TYPE_CREATE = 6,
        GF_GSYNC_OPTION_TYPE_DELETE = 7,
        GF_GSYNC_OPTION_TYPE_PAUSE = 8,
        GF_GSYNC_OPTION_TYPE_RESUME = 9
};

enum gf1_cli_stats_op {
        GF_CLI_STATS_NONE  = 0,
        GF_CLI_STATS_START = 1,
        GF_CLI_STATS_STOP  = 2,
        GF_CLI_STATS_INFO  = 3,
        GF_CLI_STATS_TOP = 4
};

enum gf1_cli_info_op {
        GF_CLI_INFO_NONE = 0,
        GF_CLI_INFO_ALL = 1,
        GF_CLI_INFO_INCREMENTAL = 2,
        GF_CLI_INFO_CUMULATIVE = 3,
        GF_CLI_INFO_CLEAR = 4
};

enum gf1_cli_top_op {
        GF_CLI_TOP_NONE = 0,
        GF_CLI_TOP_OPEN = 1,
        GF_CLI_TOP_READ = 2,
        GF_CLI_TOP_WRITE = 3,
        GF_CLI_TOP_OPENDIR = 4,
        GF_CLI_TOP_READDIR = 5,
        GF_CLI_TOP_READ_PERF = 6,
        GF_CLI_TOP_WRITE_PERF = 7
};

/* The unconventional hex numbers help us perform
   bit-wise operations which reduces complexity */
enum gf_cli_status_type {
        GF_CLI_STATUS_NONE         = 0x000000,
        GF_CLI_STATUS_MEM          = 0x000001,    /*000000000000001*/
        GF_CLI_STATUS_CLIENTS      = 0x000002,    /*000000000000010*/
        GF_CLI_STATUS_INODE        = 0x000004,    /*000000000000100*/
        GF_CLI_STATUS_FD           = 0x000008,    /*000000000001000*/
        GF_CLI_STATUS_CALLPOOL     = 0x000010,    /*000000000010000*/
        GF_CLI_STATUS_DETAIL       = 0x000020,    /*000000000100000*/
        GF_CLI_STATUS_TASKS        = 0x000040,    /*00000001000000*/
        GF_CLI_STATUS_MASK         = 0x0000FF,    /*000000011111111 Used to get the op*/
        GF_CLI_STATUS_VOL          = 0x000100,    /*00000000100000000*/
        GF_CLI_STATUS_ALL          = 0x000200,    /*00000001000000000*/
        GF_CLI_STATUS_BRICK        = 0x000400,    /*00000010000000000*/
        GF_CLI_STATUS_NFS          = 0x000800,    /*00000100000000000*/
        GF_CLI_STATUS_SHD          = 0x001000,    /*00001000000000000*/
        GF_CLI_STATUS_QUOTAD       = 0x002000,    /*00010000000000000*/
        GF_CLI_STATUS_SNAPD        = 0x004000,    /*00100000000000000*/
        GF_CLI_STATUS_BITD         = 0x008000,    /*01000000000000000*/
        GF_CLI_STATUS_SCRUB        = 0x010000     /*10000000000000000*/
};

/* Identifiers for snapshot clis */
enum gf1_cli_snapshot {
        GF_SNAP_OPTION_TYPE_NONE = 0,
        GF_SNAP_OPTION_TYPE_CREATE = 1,
        GF_SNAP_OPTION_TYPE_DELETE = 2,
        GF_SNAP_OPTION_TYPE_RESTORE = 3,
        GF_SNAP_OPTION_TYPE_ACTIVATE = 4,
        GF_SNAP_OPTION_TYPE_DEACTIVATE = 5,
        GF_SNAP_OPTION_TYPE_LIST = 6,
        GF_SNAP_OPTION_TYPE_STATUS = 7,
        GF_SNAP_OPTION_TYPE_CONFIG = 8,
        GF_SNAP_OPTION_TYPE_CLONE = 9,
        GF_SNAP_OPTION_TYPE_INFO = 10
};

enum gf1_cli_snapshot_info {
        GF_SNAP_INFO_TYPE_ALL = 0,
        GF_SNAP_INFO_TYPE_SNAP = 1,
        GF_SNAP_INFO_TYPE_VOL = 2
};

enum gf1_cli_snapshot_config {
        GF_SNAP_CONFIG_TYPE_NONE = 0,
        GF_SNAP_CONFIG_TYPE_SET = 1,
        GF_SNAP_CONFIG_DISPLAY = 2
};

enum  gf1_cli_snapshot_status {
        GF_SNAP_STATUS_TYPE_ALL = 0,
        GF_SNAP_STATUS_TYPE_SNAP = 1,
        GF_SNAP_STATUS_TYPE_VOL = 2
};

enum gf1_cli_snapshot_delete {
        GF_SNAP_DELETE_TYPE_ALL  = 0,
        GF_SNAP_DELETE_TYPE_SNAP = 1,
        GF_SNAP_DELETE_TYPE_VOL  = 2
};

struct gf_cli_req {
        opaque  dict<>;
};

 struct gf_cli_rsp {
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
};

struct gf1_cli_peer_list_req {
        int     flags;
        opaque  dict<>;
};

struct gf1_cli_peer_list_rsp {
        int     op_ret;
        int     op_errno;
        opaque  friends<>;
};

struct gf1_cli_fsm_log_req {
        string name<>;
};

struct gf1_cli_fsm_log_rsp {
        int op_ret;
        int op_errno;
        string op_errstr<>;
        opaque fsm_log<>;
};

struct gf1_cli_getwd_req {
        int     unused;
};

struct gf1_cli_getwd_rsp {
        int     op_ret;
        int     op_errno;
        string  wd<>;
};

struct gf1_cli_mount_req {
        string label<>;
        opaque dict<>;
};

struct gf1_cli_mount_rsp {
       int op_ret;
       int op_errno;
       string path<>;
};

struct gf1_cli_umount_req {
        int lazy;
        string path<>;
};

struct gf1_cli_umount_rsp {
       int op_ret;
       int op_errno;
};
 enum glusterd_volume_status {
        GLUSTERD_STATUS_NONE = 0,
        GLUSTERD_STATUS_STARTED,
        GLUSTERD_STATUS_STOPPED
} ;

/*
 struct gd1_mgmt_probe_req {
        opaque  uuid[16];
        string  hostname<>;
        int     port;
}  ;
*/

 struct gd1_mgmt_probe_rsp {
        opaque  uuid[16];
        string  hostname<>;
        int     port;
        int     op_ret;
        int     op_errno;
        string op_errstr<>;
}  ;

struct gd1_mgmt_friend_req {
        opaque  uuid[16];
        string  hostname<>;
        int     port;
        opaque  vols<>;
}  ;

struct gd1_mgmt_friend_rsp {
        opaque  uuid[16];
        string  hostname<>;
        int     op_ret;
        int     op_errno;
        int     port;
}  ;

struct gd1_mgmt_unfriend_req {
        opaque  uuid[16];
        string  hostname<>;
        int     port;
}  ;

struct gd1_mgmt_unfriend_rsp {
        opaque  uuid[16];
        string  hostname<>;
        int     op_ret;
        int     op_errno;
        int     port;
}  ;

struct gd1_mgmt_cluster_lock_req {
        opaque  uuid[16];
}  ;

struct gd1_mgmt_cluster_lock_rsp {
        opaque  uuid[16];
        int     op_ret;
        int     op_errno;
}  ;

struct gd1_mgmt_cluster_unlock_req {
        opaque  uuid[16];
}  ;

struct gd1_mgmt_cluster_unlock_rsp {
        opaque  uuid[16];
        int     op_ret;
        int     op_errno;
}  ;

struct gd1_mgmt_stage_op_req {
        opaque  uuid[16];
        int     op;
        opaque  buf<>;
}  ;


struct gd1_mgmt_stage_op_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
}  ;

struct gd1_mgmt_commit_op_req {
        opaque  uuid[16];
        int     op;
        opaque  buf<>;
}  ;


struct gd1_mgmt_commit_op_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        opaque  dict<>;
        string  op_errstr<>;
}  ;

struct gd1_mgmt_friend_update {
        opaque uuid[16];
        opaque  friends<>;
        int     port;
} ;

struct gd1_mgmt_friend_update_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
}  ;

struct gd1_mgmt_brick_op_req {
        string  name<>;
        int     op;
        opaque  input<>;
} ;

struct gd1_mgmt_brick_op_rsp {
        int     op_ret;
        int     op_errno;
        opaque  output<>;
        string  op_errstr<>;
} ;

struct gd1_mgmt_v3_lock_req {
        opaque  uuid[16];
        opaque  txn_id[16];
        int            op;
        opaque         dict<>;
}  ;

struct gd1_mgmt_v3_lock_rsp {
        opaque  uuid[16];
        opaque  txn_id[16];
        opaque         dict<>;
        int            op_ret;
        int            op_errno;
}  ;

struct gd1_mgmt_v3_pre_val_req {
        opaque  uuid[16];
        int     op;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_pre_val_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_brick_op_req {
        opaque  uuid[16];
        int     op;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_brick_op_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_commit_req {
        opaque  uuid[16];
        int     op;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_commit_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        opaque  dict<>;
        string  op_errstr<>;
}  ;

struct gd1_mgmt_v3_post_val_req {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_post_val_rsp {
        opaque  uuid[16];
        int     op;
        int     op_ret;
        int     op_errno;
        string  op_errstr<>;
        opaque  dict<>;
}  ;

struct gd1_mgmt_v3_unlock_req {
        opaque  uuid[16];
        opaque  txn_id[16];
        int            op;
        opaque         dict<>;
}  ;

struct gd1_mgmt_v3_unlock_rsp {
        opaque  uuid[16];
        opaque  txn_id[16];
        opaque         dict<>;
        int            op_ret;
        int            op_errno;
}  ;
#define GF_REQUEST_MAXGROUPS    16
struct gf_statfs {
	u_quad_t bsize;
	u_quad_t frsize;
	u_quad_t blocks;
	u_quad_t bfree;
	u_quad_t bavail;
	u_quad_t files;
	u_quad_t ffree;
	u_quad_t favail;
	u_quad_t fsid;
	u_quad_t flag;
	u_quad_t namemax;
};

struct gf_proto_flock {
	unsigned int   flock_type;
	unsigned int   whence;
	u_quad_t start;
	u_quad_t len;
        unsigned int   pid;
        opaque         lk_owner<>;
} ;


struct gf_iatt {
        opaque             ia_gfid[16];
        u_quad_t     ia_ino;        /* inode number */
        u_quad_t     ia_dev;        /* backing device ID */
        unsigned int       mode;          /* mode (type + protection )*/
        unsigned int       ia_nlink;      /* Link count */
        unsigned int       ia_uid;        /* user ID of owner */
        unsigned int       ia_gid;        /* group ID of owner */
        u_quad_t     ia_rdev;       /* device ID (if special file) */
        u_quad_t     ia_size;       /* file size in bytes */
        unsigned int       ia_blksize;    /* blocksize for filesystem I/O */
        u_quad_t     ia_blocks;     /* number of 512B blocks allocated */
        unsigned int       ia_atime;      /* last access time */
        unsigned int       ia_atime_nsec;
        unsigned int       ia_mtime;      /* last modification time */
        unsigned int       ia_mtime_nsec;
        unsigned int       ia_ctime;      /* last status change time */
        unsigned int       ia_ctime_nsec;
};


struct gfs3_cbk_cache_invalidation_req {
        string         gfid<>;
        unsigned int   event_type; /* Upcall event type */
        unsigned int   flags;  /* or mask of events incase of inotify */
        unsigned int   expire_time_attr; /* the amount of time which client
                                          * can cache this entry */
        gf_iatt stat;  /* Updated/current stat of the file/dir */
        gf_iatt parent_stat;  /* Updated stat of the parent dir
                                      * needed in case of create, mkdir,
                                      * unlink, rmdir, rename fops */
        gf_iatt oldparent_stat;  /* Updated stat of the oldparent dir
                                           needed in case of rename fop */
        opaque   xdata<>; /* Extra data */
};

struct gfs3_stat_req {
        opaque gfid[16];
        opaque   xdata<>; /* Extra data */
};
struct gfs3_stat_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        opaque   xdata<>; /* Extra data */
} ;


struct gfs3_readlink_req {
        opaque gfid[16];
	unsigned int   size;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_readlink_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt buf;
        string      path<>; /* NULL terminated */
        opaque   xdata<>; /* Extra data */
} ;


 struct gfs3_mknod_req {
        opaque  pargfid[16];
	u_quad_t dev;
	unsigned int mode;
        unsigned int umask;
	string     bname<>; /* NULL terminated */
        opaque   xdata<>; /* Extra data */
} ;
 struct gfs3_mknod_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
};


 struct  gfs3_mkdir_req {
        opaque  pargfid[16];
	unsigned int mode;
        unsigned int umask;
	string     bname<>; /* NULL terminated */
        opaque     xdata<>; /* Extra data */
} ;
 struct  gfs3_mkdir_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
} ;


 struct   gfs3_unlink_req {
        opaque  pargfid[16];
	string     bname<>; /* NULL terminated */
        unsigned int xflags;
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_unlink_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
};


 struct   gfs3_rmdir_req {
        opaque  pargfid[16];
        int        xflags;
	string     bname<>; /* NULL terminated */
        opaque     xdata<>; /* Extra data */
};
 struct   gfs3_rmdir_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
};


 struct   gfs3_symlink_req {
        opaque  pargfid[16];
	string     bname<>;
        unsigned int umask;
	string     linkname<>;
        opaque   xdata<>; /* Extra data */
};
 struct  gfs3_symlink_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
};


 struct   gfs3_rename_req {
        opaque  oldgfid[16];
        opaque  newgfid[16];
	string       oldbname<>; /* NULL terminated */
	string       newbname<>; /* NULL terminated */
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_rename_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt preoldparent;
        gf_iatt postoldparent;
        gf_iatt prenewparent;
        gf_iatt postnewparent;
        opaque   xdata<>; /* Extra data */
};


 struct  gfs3_link_req {
        opaque  oldgfid[16];
        opaque  newgfid[16];
	string       newbname<>;
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_link_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
};

 struct   gfs3_truncate_req {
        opaque gfid[16];
	u_quad_t offset;
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_truncate_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt prestat;
        gf_iatt poststat;
        opaque   xdata<>; /* Extra data */
};


 struct   gfs3_open_req {
        opaque gfid[16];
	unsigned int flags;
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_open_rsp {
        int    op_ret;
        int    op_errno;
	quad_t fd;
        opaque   xdata<>; /* Extra data */
};


 struct   gfs3_read_req {
        opaque gfid[16];
	quad_t  fd;
	u_quad_t offset;
	unsigned int size;
        unsigned int flag;
        opaque   xdata<>; /* Extra data */
};
 struct  gfs3_read_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        unsigned int size;
        opaque   xdata<>; /* Extra data */
} ;

struct   gfs3_lookup_req {
        opaque gfid[16];
        opaque  pargfid[16];
	unsigned int flags;
	string     bname<>;
        opaque   xdata<>; /* Extra data */
};
 struct   gfs3_lookup_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
} ;



 struct   gfs3_write_req {
        opaque gfid[16];
	quad_t  fd;
	u_quad_t offset;
	unsigned int size;
        unsigned int flag;
        opaque   xdata<>; /* Extra data */
};
 struct gfs3_write_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt prestat;
        gf_iatt poststat;
        opaque   xdata<>; /* Extra data */
} ;


 struct gfs3_statfs_req  {
        opaque gfid[16];
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_statfs_rsp {
        int    op_ret;
        int    op_errno;
	gf_statfs statfs;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_lk_req {
        opaque gfid[16];
	int64_t         fd;
	unsigned int        cmd;
	unsigned int        lk_type;
	gf_proto_flock flock;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_lk_rsp {
        int    op_ret;
        int    op_errno;
	gf_proto_flock flock;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_inodelk_req {
        opaque gfid[16];
	unsigned int cmd;
	unsigned int inodelk_type;
	gf_proto_flock flock;
        string     volume<>;
        opaque   xdata<>; /* Extra data */
}  ;

struct   gfs3_finodelk_req {
        opaque gfid[16];
	quad_t  fd;
	unsigned int cmd;
	unsigned int finodelk_type;
	gf_proto_flock flock;
        string volume<>;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_fsync_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt prestat;
        gf_iatt poststat;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_setxattr_req {
        opaque gfid[16];
	unsigned int flags;
        opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;



 struct gfs3_fsetxattr_req {
        opaque gfid[16];
	int64_t  fd;
	unsigned int flags;
        opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;



 struct gfs3_xattrop_req {
        opaque gfid[16];
	unsigned int flags;
        opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_xattrop_rsp  {
        int    op_ret;
        int    op_errno;
	opaque  dict<>;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_fxattrop_req {
        opaque gfid[16];
	quad_t  fd;
	unsigned int flags;
	opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_fxattrop_rsp  {
        int    op_ret;
        int    op_errno;
	opaque  dict<>;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_getxattr_req  {
        opaque gfid[16];
	unsigned int namelen;
	string     name<>;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_getxattr_rsp {
        int    op_ret;
        int    op_errno;
	opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_fgetxattr_req  {
        opaque gfid[16];
	quad_t  fd;
        unsigned int namelen;
	string     name<>;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_fgetxattr_rsp {
        int    op_ret;
        int    op_errno;
        opaque     dict<>;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_removexattr_req {
        opaque gfid[16];
	string     name<>;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_fremovexattr_req {
        opaque gfid[16];
        quad_t  fd;
	string     name<>;
        opaque   xdata<>; /* Extra data */
}  ;



 struct gfs3_opendir_req {
        opaque gfid[16];
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_opendir_rsp {
        int    op_ret;
        int    op_errno;
	quad_t fd;
        opaque   xdata<>; /* Extra data */
}  ;


 struct gfs3_fsyncdir_req {
        opaque gfid[16];
	quad_t  fd;
	int  data;
        opaque   xdata<>; /* Extra data */
}  ;

 struct   gfs3_readdir_req  {
        opaque gfid[16];
	quad_t  fd;
	u_quad_t offset;
	unsigned int size;
        opaque   xdata<>; /* Extra data */
};

 struct gfs3_readdirp_req {
        opaque gfid[16];
	quad_t  fd;
	u_quad_t offset;
	unsigned int size;
        opaque dict<>;
}  ;


struct gfs3_access_req  {
        opaque gfid[16];
	unsigned int mask;
        opaque   xdata<>; /* Extra data */
} ;


struct gfs3_create_req {
        opaque  pargfid[16];
	unsigned int flags;
	unsigned int mode;
	unsigned int umask;
	string     bname<>;
        opaque   xdata<>; /* Extra data */
}  ;
struct  gfs3_create_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
	u_quad_t       fd;
        gf_iatt preparent;
        gf_iatt postparent;
        opaque   xdata<>; /* Extra data */
} ;



struct   gfs3_ftruncate_req  {
        opaque gfid[16];
	quad_t  fd;
	u_quad_t offset;
        opaque   xdata<>; /* Extra data */
} ;
struct   gfs3_ftruncate_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt prestat;
        gf_iatt poststat;
        opaque   xdata<>; /* Extra data */
} ;


struct gfs3_fstat_req {
        opaque gfid[16];
	quad_t  fd;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_fstat_rsp {
        int    op_ret;
        int    op_errno;
	gf_iatt stat;
        opaque   xdata<>; /* Extra data */
}  ;



 struct   gfs3_entrylk_req {
        opaque gfid[16];
	unsigned int  cmd;
	unsigned int  entrylk_type;
	u_quad_t  namelen;
	string      name<>;
        string      volume<>;
        opaque   xdata<>; /* Extra data */
};

 struct   gfs3_fentrylk_req {
        opaque gfid[16];
	quad_t   fd;
	unsigned int  cmd;
	unsigned int  fentrylk_type;
	u_quad_t  namelen;
	string      name<>;
        string      volume<>;
        opaque   xdata<>; /* Extra data */
};


 struct gfs3_setattr_req {
        opaque gfid[16];
        gf_iatt stbuf;
        int        valid;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_setattr_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt statpre;
        gf_iatt statpost;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_fsetattr_req {
        quad_t        fd;
        gf_iatt stbuf;
        int        valid;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_fsetattr_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt statpre;
        gf_iatt statpost;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_fallocate_req {
	opaque		gfid[16];
        quad_t		fd;
	unsigned int	flags;
	u_quad_t	offset;
	u_quad_t	size;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_fallocate_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt statpre;
        gf_iatt statpost;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_discard_req {
	opaque		gfid[16];
        quad_t		fd;
	u_quad_t	offset;
	u_quad_t	size;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_discard_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt statpre;
        gf_iatt statpost;
        opaque   xdata<>; /* Extra data */
}  ;

 struct gfs3_zerofill_req {
        opaque          gfid[16];
        quad_t           fd;
        u_quad_t  offset;
        u_quad_t  size;
        opaque   xdata<>;
}  ;

 struct gfs3_zerofill_rsp {
        int    op_ret;
        int    op_errno;
        gf_iatt statpre;
        gf_iatt statpost;
        opaque   xdata<>;
}  ;


 struct gfs3_rchecksum_req {
        quad_t   fd;
        u_quad_t  offset;
        unsigned int  len;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gfs3_rchecksum_rsp {
        int    op_ret;
        int    op_errno;
        unsigned int weak_checksum;
        opaque   strong_checksum<>;
        opaque   xdata<>; /* Extra data */
}  ;


struct gfs3_ipc_req {
	int     op;
	opaque  xdata<>;
};

struct gfs3_ipc_rsp {
	int     op_ret;
	int     op_errno;
	opaque  xdata<>;
};


 struct gf_setvolume_req {
        opaque dict<>;
}  ;
 struct  gf_setvolume_rsp {
        int    op_ret;
        int    op_errno;
        opaque dict<>;
} ;


 struct gf_getspec_req {
	unsigned int flags;
	string     key<>;
        opaque   xdata<>; /* Extra data */
}  ;
 struct  gf_getspec_rsp {
        int    op_ret;
        int    op_errno;
	string spec<>;
        opaque   xdata<>; /* Extra data */
} ;

 struct gf_get_volume_info_req {
        opaque   dict<>; /* Extra data */
}  ;
 struct  gf_get_volume_info_rsp {
        int    op_ret;
        int    op_errno;
        string op_errstr<>;
        opaque   dict<>; /* Extra data */
} ;

 struct gf_mgmt_hndsk_req {
        opaque   hndsk<>;
}  ;

 struct  gf_mgmt_hndsk_rsp {
        int    op_ret;
        int    op_errno;
        opaque   hndsk<>;
} ;

 struct   gf_log_req {
        opaque    msg<>;
} ;

 struct gf_notify_req {
	unsigned int  flags;
        string buf<>;
        opaque   xdata<>; /* Extra data */
}  ;
 struct gf_notify_rsp {
        int    op_ret;
        int    op_errno;
	unsigned int  flags;
        string buf<>;
        opaque   xdata<>; /* Extra data */
}  ;

struct gfs3_releasedir_req {
        opaque gfid[16];
	quad_t  fd;
        opaque   xdata<>; /* Extra data */
}  ;

struct gfs3_release_req {
        opaque gfid[16];
	quad_t  fd;
        opaque   xdata<>; /* Extra data */
}  ;

struct gfs3_dirlist {
       u_quad_t d_ino;
       u_quad_t d_off;
       unsigned int d_len;
       unsigned int d_type;
       string name<>;
       gfs3_dirlist *nextentry;
};


struct gfs3_readdir_rsp {
       int op_ret;
       int op_errno;
       gfs3_dirlist *reply;
        opaque   xdata<>; /* Extra data */
};

struct gfs3_dirplist {
       u_quad_t d_ino;
       u_quad_t d_off;
       unsigned int d_len;
       unsigned int d_type;
       string name<>;
       gf_iatt stat;
       opaque dict<>;
       gfs3_dirplist *nextentry;
};

struct gfs3_readdirp_rsp {
       int op_ret;
       int op_errno;
       gfs3_dirplist *reply;
        opaque   xdata<>; /* Extra data */
};

struct gf_set_lk_ver_rsp {
       int op_ret;
       int op_errno;
       int lk_ver;
};

struct gf_set_lk_ver_req {
       string uid<>;
       int lk_ver;
};

struct gf_event_notify_req {
	int op;
	opaque dict<>;
};

struct gf_event_notify_rsp {
	int op_ret;
	int op_errno;
	opaque dict<>;
};


struct gf_getsnap_name_uuid_req {
        opaque dict<>;
};

struct gf_getsnap_name_uuid_rsp {
        int op_ret;
        int op_errno;
        string op_errstr<>;
        opaque dict<>;
};
/*
  Copyright (c) 2007-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.
*/

/* This is used by rpcgen to auto generate the rpc stubs.
 * mount3udp_svc.c is heavily modified though
 */

const MNTUDPPATHLEN = 1024;

typedef string mntudpdirpath<MNTPATHLEN>;

/*
program MOUNTUDP_PROGRAM {
        version MOUNTUDP_V3 {
                void MOUNTUDPPROC3_NULL(void) = 0;
                mountres3 MOUNTUDPPROC3_MNT (mntudpdirpath) = 1;
                mountstat3 MOUNTUDPPROC3_UMNT (mntudpdirpath) = 3;
        } = 3;
} = 100005;
*/
/*
  Copyright (c) 2007-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.
*/

/* .x file defined as according to the RFC */

const MAXNETOBJ_SZ = 1024;
const LM_MAXSTRLEN = 1024;
const MAXNAMELEN = 1025;

typedef opaque nlm4_netobj<MAXNETOBJ_SZ>;

/*
 * The following enums are actually bit encoded for efficient
 * boolean algebra.... DON'T change them.....
 */
enum	fsh_mode {
	fsm_DN  = 0,	/* deny none */
	fsm_DR  = 1,	/* deny read */
	fsm_DW  = 2,	/* deny write */
	fsm_DRW = 3	/* deny read/write */
};

enum	fsh_access {
	fsa_NONE = 0,	/* for completeness */
	fsa_R    = 1,	/* read only */
	fsa_W    = 2,	/* write only */
	fsa_RW   = 3	/* read/write */
};

/* definitions for NLM version 4 */
enum nlm4_stats {
	nlm4_granted			= 0,
	nlm4_denied			= 1,
	nlm4_denied_nolock		= 2,
	nlm4_blocked			= 3,
	nlm4_denied_grace_period	= 4,
	nlm4_deadlck			= 5,
	nlm4_rofs			= 6,
	nlm4_stale_fh			= 7,
	nlm4_fbig			= 8,
	nlm4_failed			= 9
};

struct nlm4_stat {
	nlm4_stats stat;
};

struct nlm4_holder {
	bool exclusive;
	u_int32_t svid;
	nlm4_netobj oh;
	u_int64_t l_offset;
	u_int64_t l_len;
};

struct nlm4_lock {
	string caller_name<LM_MAXSTRLEN>;
	nlm4_netobj fh;
	nlm4_netobj oh;
	u_int32_t svid;
	u_int64_t l_offset;
	u_int64_t l_len;
};

struct nlm4_share {
	string caller_name<LM_MAXSTRLEN>;
	nlm4_netobj fh;
	nlm4_netobj oh;
	fsh_mode mode;
	fsh_access access;
};

union nlm4_testrply switch (nlm4_stats stat) {
	case nlm4_denied:
		nlm4_holder holder;
	default:
		void;
};

struct nlm4_testres {
	nlm4_netobj cookie;
	nlm4_testrply stat;
};

struct nlm4_testargs {
	nlm4_netobj cookie;
	bool exclusive;
	nlm4_lock alock;
};

struct nlm4_res {
	nlm4_netobj cookie;
	nlm4_stat stat;
};

struct nlm4_lockargs {
	nlm4_netobj cookie;
	bool block;
	bool exclusive;
	nlm4_lock alock;
	bool reclaim;		/* used for recovering locks */
	int32_t state;		/* specify local status monitor state */
};

struct nlm4_cancargs {
	nlm4_netobj cookie;
	bool block;
	bool exclusive;
	nlm4_lock alock;
};

struct nlm4_unlockargs {
	nlm4_netobj cookie;
	nlm4_lock alock;
};

struct	nlm4_shareargs {
	nlm4_netobj	cookie;
	nlm4_share	share;
	bool	reclaim;
};

struct	nlm4_shareres {
	nlm4_netobj	cookie;
	nlm4_stats	stat;
	int32_t	sequence;
};

struct  nlm4_freeallargs {
        string       name<LM_MAXSTRLEN>;   /* client hostname */
        uint32_t     state;                /* unused */
};

/*
 * argument for the procedure called by rpc.statd when a monitored host
 * status change.
 * XXX assumes LM_MAXSTRLEN == SM_MAXSTRLEN
 */
struct nlm_sm_status {
	string mon_name<LM_MAXSTRLEN>; /* name of host */
	int state;			/* new state */
	opaque nlm_priv[16];		/* private data */
};

/*
program NLMCBK_PROGRAM {
        version NLMCBK_V1 {
                void NLMCBK_SM_NOTIFY(struct nlm_sm_status) = 16;
        } = 1;
} = 100021;
*/
/*
 * This defines the maximum length of the string
 * identifying the caller.
 */
const SM_MAXSTRLEN = 1024;

struct sm_name {
    string mon_name<SM_MAXSTRLEN>;
};

enum res {
    STAT_SUCC = 0,   /*  NSM agrees to monitor.  */
    STAT_FAIL = 1    /*  NSM cannot monitor.  */
};

struct sm_stat_res {
    res    res_stat;
    int    state;
};

struct sm_stat {
    int    state;    /*  state number of NSM  */
};

struct my_id {
    string my_name<SM_MAXSTRLEN>;  /*  hostname  */
    int    my_prog;                /*  RPC program number  */
    int    my_vers;                /*  program version number  */
    int    my_proc;                /*  procedure number  */
};

struct mon_id {
    string mon_name<SM_MAXSTRLEN>; /* name of the host to be monitored */
    my_id my_id;
};

struct mon {
    mon_id mon_id;
    opaque    mon_priv[16];        /*  private information  */
};

struct nsm_callback_status {
    string mon_name<SM_MAXSTRLEN>;
    int    state;
    opaque nsm_priv[16];        /*  for private information  */
};


struct pmap_port_by_brick_req {
       string   brick<>;
};

struct pmap_port_by_brick_rsp {
       int      op_ret;
       int      op_errno;
       int      status;
       int      port;
};


struct pmap_brick_by_port_req {
       int      port;
};

struct pmap_brick_by_port_rsp {
       int      op_ret;
       int      op_errno;
       int      status;
       string   brick<>;
};


struct pmap_signup_req {
       string brick<>;
       int port;
};

struct pmap_signup_rsp {
       int      op_ret;
       int      op_errno;
};


struct pmap_signin_req {
       string brick<>;
       int port;
};

struct pmap_signin_rsp {
       int      op_ret;
       int      op_errno;
};

struct pmap_signout_req {
       string brick<>;
       int port;
       int rdma_port;
};

struct pmap_signout_rsp {
       int      op_ret;
       int      op_errno;
};
/* This file has definition of few XDR structures which are
 * not captured in any section specific file */
typedef unsigned hyper u_quad_t;

struct auth_glusterfs_parms_v2 {
	int pid;
	unsigned int uid;
	unsigned int gid;
	unsigned int groups<>;
	opaque lk_owner<>;
};

struct auth_glusterfs_parms {
	hyper lk_owner;
	unsigned int pid;
	unsigned int uid;
	unsigned int gid;
	unsigned int ngrps;
	unsigned int groups[16];
};

struct gf_dump_req {
	hyper gfs_id;
};


struct gf_prog_detail {
	string progname<>;
	hyper prognum;
	hyper progver;
	gf_prog_detail *next;
};


struct gf_dump_rsp {
	hyper gfs_id;
	int op_ret;
	int op_errno;
	gf_prog_detail *prog;
};


struct gf_common_rsp {
   int    op_ret;
   int    op_errno;
   opaque   xdata<>; /* Extra data */
} ;