From 683b6ba3f17a9bbf876c66f5d4b7a9d573d8853f Mon Sep 17 00:00:00 2001 From: Prasanna Kumar Kalever Date: Fri, 20 Jan 2017 12:13:37 +0530 Subject: gluster-block: listen on unix and inet from now We basically have 2 RPC connections, 1. Between gluster block CLI and local gluster-blockd This connection is basically UNIX/local netid ,listening on /var/run/gluster-blockd.socket file. The CLI always Send/Receive the commands to/from the local gluster-blockd via local rpc. 2. Between gluster-blockd's, i.e local (to cli) gluster-blockd and the gluster-blockd's running on remote(blockhost) This is the tcp connection. The rpc requests are listening on 24006 Also from now gluster-blockd is multi threaded (As of now 2 threads) Lets consider the Create Request to understand what each thread solves Thread1 (THE CLI THREAD) * Listening on local RPC * Generate the GBID (UUID) and create the entry with name GBID in the given volume with a requested size. * And Send the Configuration requests to remote hosts, waits for the replies (HINt: after this point Read Thread2 and come back) * Return to CLI. Thread 2 (THE SERVER THREAD) * Listens on 24006 * On Receiving an event, read the structure. * Executes the required "targetcli bla bla bla" command locally * Fills the command exitcode and the output in the RPC reply structure and send reply Signed-off-by: Prasanna Kumar Kalever --- Makefile | 6 +-- glfs-operations.c | 12 ++--- glfs-operations.h | 6 ++- gluster-block.c | 104 +++++++++++++++++++++++------------ gluster-blockd.c | 133 ++++++++++++++++++++++++++++++++++++++++++--- rpc/block.h | 64 ++++++++++++++++++---- rpc/block.x | 31 +++++++++-- rpc/block_clnt.c | 27 +++++++--- rpc/block_svc.c | 159 +++++++++++++++++++++++++++++++++++++++++++----------- rpc/block_xdr.c | 45 +++++++++++++++- 10 files changed, 485 insertions(+), 102 deletions(-) diff --git a/Makefile b/Makefile index 5bce7b2..e713ee7 100644 --- a/Makefile +++ b/Makefile @@ -16,9 +16,9 @@ CLIENT = gluster-block CDEP = glfs-operations.o utils.o rpc/block_clnt.c rpc/block_xdr.c gluster-block.o SERVER = gluster-blockd -SDEP = rpc/block_svc.o rpc/block_xdr.o gluster-blockd.o utils.o +SDEP = rpc/block_svc.o rpc/block_clnt.c rpc/block_xdr.o gluster-blockd.o utils.o glfs-operations.o -CFLAGS = -g -ggdb -Wall +CFLAGS = -g -ggdb -Wall -lpthread LIBS := $(shell pkg-config --libs uuid glusterfs-api) DEPS_LIST = gcc tcmu-runner targetcli @@ -38,7 +38,7 @@ $(CLIENT): $(CDEP) $(CC) $(CFLAGS) $(LIBS) $^ -o $@ $(SERVER): $(SDEP) - $(CC) $(CFLAGS) $^ -o $@ + $(CC) $(CFLAGS) $(LIBS) $^ -o $@ glfs-operations.o: glfs-operations.c glfs-operations.h $(foreach x, $(DEPS_LIST),\ diff --git a/glfs-operations.c b/glfs-operations.c index 3a6bd32..fecc315 100644 --- a/glfs-operations.c +++ b/glfs-operations.c @@ -18,7 +18,7 @@ int -glusterBlockCreateEntry(glusterBlockDefPtr blk) +glusterBlockCreateEntry(blockCreateCli *blk, char *gbid) { struct glfs *glfs; struct glfs_fd *fd; @@ -30,7 +30,7 @@ glusterBlockCreateEntry(glusterBlockDefPtr blk) return -1; } - ret = glfs_set_volfile_server(glfs, "tcp", blk->host, 24007); + ret = glfs_set_volfile_server(glfs, "tcp", blk->volfileserver, 24007); if (ret) { ERROR("%s", "glfs_set_volfile_server: failed"); goto out; @@ -48,7 +48,7 @@ glusterBlockCreateEntry(glusterBlockDefPtr blk) goto out; } - fd = glfs_creat(glfs, blk->filename, + fd = glfs_creat(glfs, gbid, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); if (!fd) { @@ -74,7 +74,7 @@ glusterBlockCreateEntry(glusterBlockDefPtr blk) int -glusterBlockDeleteEntry(glusterBlockDefPtr blk) +glusterBlockDeleteEntry(blockCreateCli *blk, char *gbid) { struct glfs *glfs; int ret = 0; @@ -85,7 +85,7 @@ glusterBlockDeleteEntry(glusterBlockDefPtr blk) return -1; } - ret = glfs_set_volfile_server(glfs, "tcp", blk->host, 24007); + ret = glfs_set_volfile_server(glfs, "tcp", blk->volfileserver, 24007); if (ret) { ERROR("%s", "glfs_set_volfile_server: failed"); goto out; @@ -103,7 +103,7 @@ glusterBlockDeleteEntry(glusterBlockDefPtr blk) goto out; } - ret = glfs_unlink(glfs, blk->filename); + ret = glfs_unlink(glfs, gbid); if (ret) { ERROR("%s", "glfs_unlink: failed"); goto out; diff --git a/glfs-operations.h b/glfs-operations.h index dd3992b..1a1208d 100644 --- a/glfs-operations.h +++ b/glfs-operations.h @@ -19,6 +19,8 @@ # include +# include "rpc/block.h" + typedef struct glusterBlockDef { @@ -31,8 +33,8 @@ typedef struct glusterBlockDef { typedef glusterBlockDef *glusterBlockDefPtr; -int glusterBlockCreateEntry(glusterBlockDefPtr blk); +int glusterBlockCreateEntry(blockCreateCli *blk, char *gbid); -int glusterBlockDeleteEntry(glusterBlockDefPtr blk); +int glusterBlockDeleteEntry(blockCreateCli *blk, char *gbid); #endif /* _GLFS_OPERATIONS_H */ diff --git a/gluster-block.c b/gluster-block.c index 9a2564e..e6dc0fc 100644 --- a/gluster-block.c +++ b/gluster-block.c @@ -12,6 +12,7 @@ # define _GNU_SOURCE /* See feature_test_macros(7) */ # include +# include # include # include @@ -53,21 +54,40 @@ typedef blockServerDef *blockServerDefPtr; static void -gluster_block_1(char *host, char *cmd, blockTrans **reply) +gluster_block_cli_1(blockCreateCli cobj, blockResponse **reply) { CLIENT *clnt; + int sockfd, len; + struct sockaddr_un saun; - clnt = clnt_create (host, GLUSTER_BLOCK, GLUSTER_BLOCK_VERS, "tcp"); + if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + perror("client: socket"); + exit(1); + } + + saun.sun_family = AF_UNIX; + strcpy(saun.sun_path, ADDRESS); + + len = sizeof(saun.sun_family) + strlen(saun.sun_path); + + if (connect(sockfd, (struct sockaddr *) &saun, len) < 0) { + perror("client: connect"); + exit(1); + } + + clnt = clntunix_create ((struct sockaddr_un *) &saun, GLUSTER_BLOCK_CLI, GLUSTER_BLOCK_CLI_VERS, &sockfd, 0, 0); if (clnt == NULL) { - clnt_pcreateerror (host); + clnt_pcreateerror ("localhost"); exit (1); } - *reply = block_exec_1(&cmd, clnt); + *reply = block_create_cli_1(&cobj, clnt); if (*reply == NULL) { - clnt_perror (clnt, "call failed"); + clnt_perror (clnt, "call failed gluster-block"); } + printf("%s\n", (*reply)->out); + clnt_destroy (clnt); } @@ -249,16 +269,20 @@ glusterBlockCreate(int count, char **options, char *name) { int c; int ret = 0; - char *cmd = NULL; - char *exec = NULL; - char *iqn = NULL; - char *blkServers = NULL; - blockServerDefPtr list; - uuid_t out; - glusterBlockDefPtr blk; - blockTrans *reply; - size_t i; +// char *cmd = NULL; +// char *exec = NULL; +// char *iqn = NULL; +// char *blkServers = NULL; +// blockServerDefPtr list; +// uuid_t out; +// glusterBlockDefPtr blk; + blockResponse *reply; + static blockCreateCli cobj; +// size_t i; +/* + if (GB_ALLOC(&cobj) < 0) + return -1; if (GB_ALLOC(blk) < 0) return -1; @@ -266,6 +290,7 @@ glusterBlockCreate(int count, char **options, char *name) uuid_generate(out); uuid_unparse(out, blk->filename); +*/ if (!name) { ERROR("%s", "Insufficient arguments supplied for" @@ -274,6 +299,8 @@ glusterBlockCreate(int count, char **options, char *name) goto out; } + strcpy(cobj.block_name, name); + while (1) { static const struct option long_options[] = { {"volume", required_argument, 0, 'v'}, @@ -294,22 +321,23 @@ glusterBlockCreate(int count, char **options, char *name) switch (c) { case 'b': - blkServers = optarg; + //blkServers = optarg; + GB_STRDUP(cobj.block_hosts, optarg); break; case 'v': - GB_STRDUP(blk->volume, optarg); + strcpy(cobj.volume, optarg); ret++; break; case 'h': - GB_STRDUP(blk->host, optarg); + strcpy(cobj.volfileserver, optarg); ret++; break; case 's': - blk->size = glusterBlockCreateParseSize(optarg); - if (blk->size < 0) { + cobj.size = glusterBlockCreateParseSize(optarg); + if (cobj.size < 0) { ERROR("%s", "failed while parsing size"); ret = -1; goto out; @@ -326,13 +354,13 @@ glusterBlockCreate(int count, char **options, char *name) break; } } - +/* if (blkServers) { list = blockServerParse(blkServers); } else { list = blockServerParse("localhost"); } - +*/ /* Print any remaining command line arguments (not options). */ if (optind < count) { ERROR("%s", "non-option ARGV-elements: "); @@ -351,6 +379,13 @@ glusterBlockCreate(int count, char **options, char *name) goto out; } + gluster_block_cli_1(cobj, &reply); + + + + + +/* ret = glusterBlockCreateEntry(blk); if (ret) { ERROR("%s volume: %s host: %s", @@ -363,7 +398,6 @@ glusterBlockCreate(int count, char **options, char *name) blk->filename, blk->filename) < 0) goto out; - /* Created user-backed storage object LUN size 2147483648. */ for (i = 0; i < list->nhosts; i++) { MSG("[OnHost: %s]", list->hosts[i]); gluster_block_1(list->hosts[i], cmd, &reply); @@ -429,8 +463,10 @@ glusterBlockCreate(int count, char **options, char *name) GB_FREE(iqn); glusterBlockDefFree(blk); blockServerDefFree(list); +*/ - return ret; + out: + return 0; } @@ -527,12 +563,12 @@ getCfgstring(char* name, char *blkServer) char *cmd; char *exec; char *buf = NULL; - blockTrans *reply; + blockResponse *reply = NULL; asprintf(&cmd, "%s %s", TARGETCLI_GLFS, BACKEND_CFGSTR); asprintf(&exec, cmd, name); - gluster_block_1(blkServer, exec, &reply); + //gluster_block_1(blkServer, exec, &reply); if (!reply || reply->exit) { ERROR("%s on host: %s", FAILED_GATHERING_CFGSTR, blkServer); @@ -559,7 +595,7 @@ glusterBlockList(blockServerDefPtr blkServers) char *size; char *cfgstring = NULL; glusterBlockDefPtr blk = NULL; - blockTrans *reply; + blockResponse *reply = NULL; MSG("%s", "BlockName Volname Host Size Status"); @@ -567,7 +603,7 @@ glusterBlockList(blockServerDefPtr blkServers) for (i = 0; i < blkServers->nhosts; i++) { MSG("[OnHost: %s]", blkServers->hosts[i]); - gluster_block_1(blkServers->hosts[i], cmd, &reply); + //gluster_block_1(blkServers->hosts[i], cmd, &reply); if (!reply || reply->exit) { ERROR("%s on host: %s", FAILED_LIST_BACKEND, blkServers->hosts[i]); @@ -632,7 +668,7 @@ glusterBlockDelete(char* name, blockServerDefPtr blkServers) char *cfgstring = NULL; char *iqn = NULL; glusterBlockDefPtr blk = NULL; - blockTrans *reply; + blockResponse *reply = NULL; asprintf(&cmd, "%s %s %s", TARGETCLI_GLFS, DELETE, name); @@ -647,7 +683,7 @@ glusterBlockDelete(char* name, blockServerDefPtr blkServers) goto fail; } - gluster_block_1(blkServers->hosts[i], cmd, &reply); + //gluster_block_1(blkServers->hosts[i], cmd, &reply); if (!reply || reply->exit) { ERROR("%s on host: %s", FAILED_DELETING_BACKEND, blkServers->hosts[i]); @@ -669,7 +705,7 @@ glusterBlockDelete(char* name, blockServerDefPtr blkServers) asprintf(&iqn, "%s%s", IQN_PREFIX, blk->filename); asprintf(&exec, "%s %s %s", TARGETCLI_ISCSI, DELETE, iqn); - gluster_block_1(blkServers->hosts[i], exec, &reply); + //gluster_block_1(blkServers->hosts[i], exec, &reply); if (!reply || reply->exit) { ERROR("%s on host: %s", FAILED_DELETING_IQN, blkServers->hosts[i]); @@ -680,7 +716,7 @@ glusterBlockDelete(char* name, blockServerDefPtr blkServers) GB_FREE(exec); GB_FREE(iqn); - gluster_block_1(blkServers->hosts[i], TARGETCLI_SAVE, &reply); + //gluster_block_1(blkServers->hosts[i], TARGETCLI_SAVE, &reply); if (!reply || reply->exit) { ERROR("%s on host: %s", FAILED_SAVEING_CONFIG, blkServers->hosts[i]); @@ -691,7 +727,7 @@ glusterBlockDelete(char* name, blockServerDefPtr blkServers) putchar('\n'); } - ret = glusterBlockDeleteEntry(blk); + //ret = glusterBlockDeleteEntry(blk); if (ret) { ERROR("%s volume: %s host: %s", FAILED_DELETING_FILE, blk->volume, blk->host); @@ -713,13 +749,13 @@ glusterBlockInfo(char* name, blockServerDefPtr blkServers) size_t i; int ret = 0; char *cmd; - blockTrans *reply; + blockResponse *reply = NULL; asprintf(&cmd, "%s/%s %s", TARGETCLI_GLFS, name, INFO); for (i = 0; i < blkServers->nhosts; i++) { MSG("[OnHost: %s]", blkServers->hosts[i]); - gluster_block_1(blkServers->hosts[i], cmd, &reply); + //gluster_block_1(blkServers->hosts[i], cmd, &reply); if (!reply || reply->exit) { ret = -1; ERROR("%s on host: %s", diff --git a/gluster-blockd.c b/gluster-blockd.c index 18506ac..6b73c8b 100644 --- a/gluster-blockd.c +++ b/gluster-blockd.c @@ -1,15 +1,135 @@ #define _GNU_SOURCE /* See feature_test_macros(7) */ -#include +#include +#include +#include +# include #include "rpc/block.h" #include "utils.h" +#include "glfs-operations.h" +# define UUID_BUF_SIZE 256 +# define CFG_STRING_SIZE 256 -blockTrans * -block_exec_1_svc(char **cmd, struct svc_req *rqstp) +# define LIST "list" +# define CREATE "create" +# define DELETE "delete" +# define INFO "info" +# define MODIFY "modify" +# define BLOCKHOST "block-host" +# define HELP "help" + +# define GLFS_PATH "/backstores/user:glfs" +# define TARGETCLI_GLFS "targetcli "GLFS_PATH +# define TARGETCLI_ISCSI "targetcli /iscsi" +# define TARGETCLI_SAVE "targetcli / saveconfig" +# define ATTRIBUTES "generate_node_acls=1 demo_mode_write_protect=0" +# define BACKEND_CFGSTR "ls | grep ' %s ' | cut -d'[' -f2 | cut -d']' -f1" +# define LUNS_LIST "ls | grep -v user:glfs | cut -d'-' -f2 | cut -d' ' -f2" + +# define IQN_PREFIX "iqn.2016-12.org.gluster-block:" + +# define MSERVER_DELIMITER "," + +blockResponse * +block_create_cli_1_svc(blockCreateCli *blk, struct svc_req *rqstp) +{ + //FILE *fp; + CLIENT *clnt; + int sockfd; + struct hostent *server; + struct sockaddr_in sain; + int ret; + uuid_t out; + static blockCreate *cobj; + static blockResponse *reply; + char *gbid = CALLOC(UUID_BUF_SIZE); + + uuid_generate(out); + uuid_unparse(out,gbid); + + ret = glusterBlockCreateEntry(blk, gbid); + if (ret) { + ERROR("%s volume: %s host: %s", + FAILED_CREATING_FILE, blk->volume, blk->volfileserver); + goto out; + } + + if(GB_ALLOC(cobj) < 0) + goto out; + + strcpy(cobj->volume, blk->volume); + strcpy(cobj->volfileserver, blk->volfileserver); + strcpy(cobj->block_name, blk->block_name); + cobj->size = blk->size; + strcpy(cobj->gbid, gbid); + + //for + + if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { + perror("gluster-blockd: socket"); + exit(1); + } + server = gethostbyname(blk->block_hosts); + if (server == NULL) { + fprintf(stderr,"ERROR, no such host\n"); + exit(0); + } + + bzero((char *) &sain, sizeof(sain)); + sain.sin_family = AF_INET; + bcopy((char *)server->h_addr, (char *)&sain.sin_addr.s_addr, server->h_length); + sain.sin_port = htons(24006); + + if (connect(sockfd, (struct sockaddr *) &sain, sizeof(sain)) < 0) { + perror("gluster-blockd: connect"); + exit(1); + } + + clnt = clnttcp_create ((struct sockaddr_in *) &sain, GLUSTER_BLOCK, GLUSTER_BLOCK_VERS, &sockfd, 0, 0); + if (clnt == NULL) { + clnt_pcreateerror ("localhost"); + exit (1); + } + + reply = block_create_1(cobj, clnt); + if (reply == NULL) { + clnt_perror (clnt, "call failed gluster-blockd"); + } + + clnt_destroy (clnt); + +out: + return reply; +} + + +blockResponse * +block_create_1_svc(blockCreate *blk, struct svc_req *rqstp) { FILE *fp; - static blockTrans *obj; + char *backstore = NULL; + char *iqn = NULL; + char *lun = NULL; + char *attr = NULL; + char *exec = NULL; + blockResponse *obj = NULL; + + asprintf(&backstore, "%s %s %s %zu %s@%s/%s %s", TARGETCLI_GLFS, + CREATE, blk->block_name, blk->size, blk->volume, blk->volfileserver, + blk->gbid, blk->gbid); + + asprintf(&iqn, "%s %s %s%s", TARGETCLI_ISCSI, CREATE, IQN_PREFIX, blk->gbid); + + + asprintf(&lun, "%s/%s%s/tpg1/luns %s %s/%s", + TARGETCLI_ISCSI, IQN_PREFIX, blk->gbid, CREATE, GLFS_PATH, blk->block_name); + + asprintf(&attr, "%s/%s%s/tpg1 set attribute %s", + TARGETCLI_ISCSI, IQN_PREFIX, blk->gbid, ATTRIBUTES); + + + asprintf(&exec, "%s && %s && %s && %s && %s", backstore, iqn, lun, attr, TARGETCLI_SAVE); if(GB_ALLOC(obj) < 0) return NULL; @@ -19,9 +139,9 @@ block_exec_1_svc(char **cmd, struct svc_req *rqstp) return NULL; } - fp = popen(*cmd, "r"); + fp = popen(exec, "r"); if (fp != NULL) { - size_t newLen = fread(obj->out, sizeof(char), 4996, fp); + size_t newLen = fread(obj->out, sizeof(char), 4096, fp); if (ferror( fp ) != 0) { ERROR("%s", "Error reading command output\n"); } else { @@ -32,3 +152,4 @@ block_exec_1_svc(char **cmd, struct svc_req *rqstp) return obj; } + diff --git a/rpc/block.h b/rpc/block.h index 54315b7..d939057 100644 --- a/rpc/block.h +++ b/rpc/block.h @@ -8,41 +8,85 @@ #include +#define ADDRESS "/var/run/gluster-block.socket" #ifdef __cplusplus extern "C" { #endif -struct blockTrans { +struct blockCreate { + char volume[255]; + char volfileserver[255]; + char gbid[127]; + u_quad_t size; + char block_name[255]; +}; +typedef struct blockCreate blockCreate; + +struct blockCreateCli { + char volume[255]; + char volfileserver[255]; + u_quad_t size; + char block_name[255]; + char *block_hosts; +}; +typedef struct blockCreateCli blockCreateCli; + +struct blockResponse { int exit; char *out; + u_quad_t offset; + struct { + u_int xdata_len; + char *xdata_val; + } xdata; }; -typedef struct blockTrans blockTrans; +typedef struct blockResponse blockResponse; + +#define GLUSTER_BLOCK_CLI 212153113 +#define GLUSTER_BLOCK_CLI_VERS 1 + +#if defined(__STDC__) || defined(__cplusplus) +#define BLOCK_CREATE_CLI 1 +extern blockResponse * block_create_cli_1(blockCreateCli *, CLIENT *); +extern blockResponse * block_create_cli_1_svc(blockCreateCli *, struct svc_req *); +extern int gluster_block_cli_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t); + +#else /* K&R C */ +#define BLOCK_CREATE_CLI 1 +extern blockResponse * block_create_cli_1(); +extern blockResponse * block_create_cli_1_svc(); +extern int gluster_block_cli_1_freeresult (); +#endif /* K&R C */ #define GLUSTER_BLOCK 21215311 #define GLUSTER_BLOCK_VERS 1 #if defined(__STDC__) || defined(__cplusplus) -#define BLOCK_EXEC 1 -extern blockTrans * block_exec_1(char **, CLIENT *); -extern blockTrans * block_exec_1_svc(char **, struct svc_req *); +#define BLOCK_CREATE 1 +extern blockResponse * block_create_1(blockCreate *, CLIENT *); +extern blockResponse * block_create_1_svc(blockCreate *, struct svc_req *); extern int gluster_block_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t); #else /* K&R C */ -#define BLOCK_EXEC 1 -extern blockTrans * block_exec_1(); -extern blockTrans * block_exec_1_svc(); +#define BLOCK_CREATE 1 +extern blockResponse * block_create_1(); +extern blockResponse * block_create_1_svc(); extern int gluster_block_1_freeresult (); #endif /* K&R C */ /* the xdr functions */ #if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_blockTrans (XDR *, blockTrans*); +extern bool_t xdr_blockCreate (XDR *, blockCreate*); +extern bool_t xdr_blockCreateCli (XDR *, blockCreateCli*); +extern bool_t xdr_blockResponse (XDR *, blockResponse*); #else /* K&R C */ -extern bool_t xdr_blockTrans (); +extern bool_t xdr_blockCreate (); +extern bool_t xdr_blockCreateCli (); +extern bool_t xdr_blockResponse (); #endif /* K&R C */ diff --git a/rpc/block.x b/rpc/block.x index c88fdf2..b563c9e 100644 --- a/rpc/block.x +++ b/rpc/block.x @@ -1,12 +1,35 @@ +struct blockCreate { + char volume[255]; + char volfileserver[255]; + char gbid[127]; /* uuid */ + u_quad_t size; + char block_name[255]; +}; + +struct blockCreateCli { + char volume[255]; + char volfileserver[255]; + u_quad_t size; + char block_name[255]; + string block_hosts<>; +}; -struct blockTrans { - int exit; /* exit code of the command */ - string out<>; /* stdout of the command */ +struct blockResponse { + int exit; /* exit code of the command */ + string out<>; /* json output */ + u_quad_t offset; /* dentry d_name offset */ + opaque xdata<>; /* future reserve */ }; +program GLUSTER_BLOCK_CLI { + version GLUSTER_BLOCK_CLI_VERS { + blockResponse BLOCK_CREATE_CLI(blockCreateCli) = 1; + } = 1; +} = 212153113; /* B2 L12 O15 C3 K11 C3 */ + program GLUSTER_BLOCK { version GLUSTER_BLOCK_VERS { - blockTrans BLOCK_EXEC(string) = 1; + blockResponse BLOCK_CREATE(blockCreate) = 1; } = 1; } = 21215311; /* B2 L12 O15 C3 K11 */ diff --git a/rpc/block_clnt.c b/rpc/block_clnt.c index 9e5b585..ae95d9a 100644 --- a/rpc/block_clnt.c +++ b/rpc/block_clnt.c @@ -9,15 +9,30 @@ /* Default timeout can be changed using clnt_control() */ static struct timeval TIMEOUT = { 25, 0 }; -blockTrans * -block_exec_1(char **argp, CLIENT *clnt) +blockResponse * +block_create_cli_1(blockCreateCli *argp, CLIENT *clnt) { - static blockTrans clnt_res; + static blockResponse clnt_res; memset((char *)&clnt_res, 0, sizeof(clnt_res)); - if (clnt_call (clnt, BLOCK_EXEC, - (xdrproc_t) xdr_wrapstring, (caddr_t) argp, - (xdrproc_t) xdr_blockTrans, (caddr_t) &clnt_res, + if (clnt_call (clnt, BLOCK_CREATE_CLI, + (xdrproc_t) xdr_blockCreateCli, (caddr_t) argp, + (xdrproc_t) xdr_blockResponse, (caddr_t) &clnt_res, + TIMEOUT) != RPC_SUCCESS) { + return (NULL); + } + return (&clnt_res); +} + +blockResponse * +block_create_1(blockCreate *argp, CLIENT *clnt) +{ + static blockResponse clnt_res; + + memset((char *)&clnt_res, 0, sizeof(clnt_res)); + if (clnt_call (clnt, BLOCK_CREATE, + (xdrproc_t) xdr_blockCreate, (caddr_t) argp, + (xdrproc_t) xdr_blockResponse, (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) { return (NULL); } diff --git a/rpc/block_svc.c b/rpc/block_svc.c index 144b7e1..4c054f5 100644 --- a/rpc/block_svc.c +++ b/rpc/block_svc.c @@ -6,6 +6,8 @@ #include "block.h" #include #include +#include +#include #include #include #include @@ -16,11 +18,16 @@ #define SIG_PF void(*)(int) #endif + + +pthread_t p_thread1, p_thread2; + + static void -gluster_block_1(struct svc_req *rqstp, register SVCXPRT *transp) +gluster_block_cli_1(struct svc_req *rqstp, register SVCXPRT *transp) { union { - char *block_exec_1_arg; + blockCreateCli block_create_cli_1_arg; } argument; char *result; xdrproc_t _xdr_argument, _xdr_result; @@ -31,10 +38,10 @@ gluster_block_1(struct svc_req *rqstp, register SVCXPRT *transp) (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL); return; - case BLOCK_EXEC: - _xdr_argument = (xdrproc_t) xdr_wrapstring; - _xdr_result = (xdrproc_t) xdr_blockTrans; - local = (char *(*)(char *, struct svc_req *)) block_exec_1_svc; + case BLOCK_CREATE_CLI: + _xdr_argument = (xdrproc_t) xdr_blockCreateCli; + _xdr_result = (xdrproc_t) xdr_blockResponse; + local = (char *(*)(char *, struct svc_req *)) block_create_cli_1_svc; break; default: @@ -57,46 +64,138 @@ gluster_block_1(struct svc_req *rqstp, register SVCXPRT *transp) return; } -int -main (int argc, char **argv) +static void +gluster_block_1(struct svc_req *rqstp, register SVCXPRT *transp) { - register SVCXPRT *transp; - struct sockaddr_in addr; - int sockfd; + union { + blockCreate block_create_1_arg; + } argument; + char *result; + xdrproc_t _xdr_argument, _xdr_result; + char *(*local)(char *, struct svc_req *); - pmap_unset (GLUSTER_BLOCK, GLUSTER_BLOCK_VERS); + switch (rqstp->rq_proc) { + case NULLPROC: + (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL); + return; - if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { - fprintf (stderr, "%s", "socket failed"); - } + case BLOCK_CREATE: + _xdr_argument = (xdrproc_t) xdr_blockCreate; + _xdr_result = (xdrproc_t) xdr_blockResponse; + local = (char *(*)(char *, struct svc_req *)) block_create_1_svc; + break; - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = INADDR_ANY; - addr.sin_port = htons(24009); + default: + svcerr_noproc (transp); + return; + } + memset ((char *)&argument, 0, sizeof (argument)); + if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { + svcerr_decode (transp); + return; + } + result = (*local)((char *)&argument, rqstp); + if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { + svcerr_systemerr (transp); + } + if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { + fprintf (stderr, "%s", "unable to free arguments"); + exit (1); + } + return; +} + +void * +cli_thread(void *vargp) +{ + register SVCXPRT *transp; + struct sockaddr_un saun; + int sockfd, len; - if (bind(sockfd, (struct sockaddr *)&addr, sizeof (addr)) < 0) { - fprintf (stderr, "%s", "bind failed"); + if ((sockfd = socket(AF_UNIX, SOCK_STREAM, IPPROTO_IP)) < 0) { + perror("server: socket"); + exit(1); } - if (listen(sockfd, 10) < 0) { - fprintf (stderr, "%s", "server: listen failed"); + saun.sun_family = AF_UNIX; + strcpy(saun.sun_path, ADDRESS); + + unlink(ADDRESS); + len = sizeof(saun.sun_family) + strlen(saun.sun_path); + + if (bind(sockfd, (struct sockaddr *) &saun, len) < 0) { + perror("server: bind"); exit(1); } - transp = svctcp_create(sockfd, 0, 0); - if (transp == NULL) { - fprintf (stderr, "%s", "cannot create tcp service"); + transp = svcunix_create(sockfd, 0, 0, ADDRESS); + if (transp == NULL) { + fprintf (stderr, "%s", "cannot create tcp service"); + exit(1); + } + + if (!svc_register(transp, GLUSTER_BLOCK_CLI, GLUSTER_BLOCK_CLI_VERS, gluster_block_cli_1, IPPROTO_IP)) { + fprintf (stderr, "%s", "unable to register (GLUSTER_BLOCK_CLI, GLUSTER_BLOCK_CLI_VERS, unix|local)."); exit(1); } + svc_run (); + + return NULL; +} + +void * +server_thread(void *vargp) +{ + register SVCXPRT *transp; + struct sockaddr_in sain; + int sockfd; + + if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { + perror("server: socket"); + exit(1); + } + + sain.sin_family = AF_INET; + sain.sin_addr.s_addr = INADDR_ANY; + sain.sin_port = htons(24006); + + if (bind(sockfd, (struct sockaddr *) &sain, sizeof (sain)) < 0) { + perror("server: bind"); + exit(1); + } + + transp = svctcp_create(sockfd, 0, 0); + if (transp == NULL) { + fprintf (stderr, "%s", "cannot create tcp service"); + exit(1); + } + if (!svc_register(transp, GLUSTER_BLOCK, GLUSTER_BLOCK_VERS, gluster_block_1, IPPROTO_TCP)) { - fprintf (stderr, "%s", "unable to register (BLOCK_PROG, GLUSTER_BLOCK_VERS, tcp)."); + fprintf (stderr, "%s", "unable to register (GLUSTER_BLOCK, GLUSTER_BLOCK_VERS, tcp)."); exit(1); } - svc_run (); + svc_run (); + + return NULL; +} + + +int +main (int argc, char **argv) +{ + pmap_unset (GLUSTER_BLOCK_CLI, GLUSTER_BLOCK_CLI_VERS); + pmap_unset (GLUSTER_BLOCK, GLUSTER_BLOCK_VERS); + + pthread_create(&p_thread1, NULL, cli_thread, NULL); + pthread_create(&p_thread2, NULL, server_thread, NULL); + + pthread_join(p_thread1, NULL); + pthread_join(p_thread2, NULL); + - fprintf (stderr, "%s", "svc_run returned"); - exit (1); - /* NOTREACHED */ + fprintf (stderr, "%s", "svc_run returned"); + exit (0); + /* NOTREACHED */ } diff --git a/rpc/block_xdr.c b/rpc/block_xdr.c index cd8400e..91775fa 100644 --- a/rpc/block_xdr.c +++ b/rpc/block_xdr.c @@ -6,11 +6,54 @@ #include "block.h" bool_t -xdr_blockTrans (XDR *xdrs, blockTrans *objp) +xdr_blockCreate (XDR *xdrs, blockCreate *objp) +{ + if (!xdr_vector (xdrs, (char *)objp->volume, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->volfileserver, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->gbid, 127, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_u_quad_t (xdrs, &objp->size)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->block_name, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + return TRUE; +} + +bool_t +xdr_blockCreateCli (XDR *xdrs, blockCreateCli *objp) +{ + if (!xdr_vector (xdrs, (char *)objp->volume, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->volfileserver, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_u_quad_t (xdrs, &objp->size)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->block_name, 255, + sizeof (char), (xdrproc_t) xdr_char)) + return FALSE; + if (!xdr_string (xdrs, &objp->block_hosts, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_blockResponse (XDR *xdrs, blockResponse *objp) { if (!xdr_int (xdrs, &objp->exit)) return FALSE; if (!xdr_string (xdrs, &objp->out, ~0)) return FALSE; + if (!xdr_u_quad_t (xdrs, &objp->offset)) + return FALSE; + if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) + return FALSE; return TRUE; } -- cgit