fix bug in mt-mapperd

[archipelago] / xseg / peers / user / xseg-tool.c

diff --git a/xseg/peers/user/xseg-tool.c b/xseg/peers/user/xseg-tool.c
index 21e85cf..74ce401 100644 (file)
--- a/xseg/peers/user/xseg-tool.c
+++ b/xseg/peers/user/xseg-tool.c
@@ -10,7 +10,7 @@
 #include <unistd.h>
 
 #include <xseg/xseg.h>
 #include <unistd.h>
 
 #include <xseg/xseg.h>

-
+#include <xseg/protocol.h>

 int help(void)
 {
        printf("xseg <spec> [[[<src_port>]:[<dst_port>]] [<command> <arg>*] ]*\n"
 int help(void)
 {
        printf("xseg <spec> [[[<src_port>]:[<dst_port>]] [<command> <arg>*] ]*\n"

@@ -189,11 +189,11 @@ out:
 
 void report_request(struct xseg_request *req)
 {
 
 void report_request(struct xseg_request *req)
 {

-       uint32_t max = req->datalen;
-       char *data = xseg_get_data(xseg, req);
-       if (max > 128)
-               max = 128;
-       data[max-1] = 0;
+       //uint32_t max = req->datalen;
+       //char *data = xseg_get_data(xseg, req);
+       //if (max > 128)
+       //      max = 128;
+       //data[max-1] = 0;

        fprintf(stderr, "request %llu state %u\n", (unsigned long long)req->serial, req->state);
 }
 
        fprintf(stderr, "request %llu state %u\n", (unsigned long long)req->serial, req->state);
 }
 

@@ -314,6 +314,7 @@ int cmd_write(char *target, uint64_t offset)
                fprintf(stderr, "Cannot submit\n");
                return -1;
        }
                fprintf(stderr, "Cannot submit\n");
                return -1;
        }

+       xseg_signal(xseg, p);

 
        return 0;
 }
 
        return 0;
 }

@@ -325,6 +326,39 @@ int cmd_truncate(char *target, uint64_t offset)
 
 int cmd_delete(char *target)
 {
 
 int cmd_delete(char *target)
 {

+        uint32_t targetlen = strlen(target);
+        int r;
+        struct xseg_request *req;
+       init_local_signal();
+        xseg_bind_port(xseg, srcport, NULL);
+
+        req = xseg_get_request(xseg, srcport, dstport, X_ALLOC);
+        if (!req) {
+                fprintf(stderr, "No request!\n");
+                return -1;
+        }
+
+        r = xseg_prep_request(xseg, req, targetlen, 0);
+        if (r < 0) {
+                fprintf(stderr, "Cannot prepare request! (%lu, %lu)\n",
+                        (unsigned long) targetlen, (unsigned long) req->bufferlen - targetlen);
+                xseg_put_request(xseg, req, srcport);
+                return -1;
+        }
+
+       char *reqtarget = xseg_get_target(xseg, req);
+        strncpy(reqtarget, target, targetlen);
+        req->op = X_DELETE;
+
+        xport p = xseg_submit(xseg, req, srcport, X_ALLOC);
+        if (p == NoPort){
+               fprintf(stderr, "Couldn't submit request\n");
+                xseg_put_request(xseg, req, srcport);
+                return -1;
+       }
+
+        xseg_signal(xseg, p);
+

        return 0;
 }
 
        return 0;
 }
 

@@ -345,6 +379,44 @@ int cmd_copy(char *src, char *dst)
 
 int cmd_clone(char *src, char *dst)
 {
 
 int cmd_clone(char *src, char *dst)
 {

+
+        uint32_t targetlen = strlen(dst);
+       uint32_t parentlen = strlen(src);
+        struct xseg_request *req;
+        struct xseg_request_clone *xclone;
+       xseg_bind_port(xseg, srcport, NULL);
+       req = xseg_get_request(xseg, srcport, dstport, X_ALLOC);
+        if (!req) {
+                fprintf(stderr, "No request\n");
+                return -1;
+        }
+
+       int r = xseg_prep_request(xseg, req, targetlen, sizeof(struct xseg_request_clone));
+        if (r < 0) {
+                fprintf(stderr, "Cannot prepare request!\n");
+                xseg_put_request(xseg, req, srcport);
+                return -1;
+        }
+
+       char *target = xseg_get_target(xseg, req);
+       char *data = xseg_get_data(xseg, req);
+
+       strncpy(target, dst, targetlen);
+        xclone = (struct xseg_request_clone *) data;
+        strncpy(xclone->target, src, parentlen);
+       xclone->targetlen = parentlen;
+        xclone->size = -1;
+        req->offset = 0;
+        req->size = sizeof(struct xseg_request_clone);
+        req->op = X_CLONE;
+
+       xport p = xseg_submit(xseg, req, srcport, X_ALLOC);
+       if (p == NoPort){
+               fprintf(stderr, "Cannot submit request\n");
+               return -1;
+       }
+       xseg_signal(xseg, p);
+

        return 0;
 }
 
        return 0;
 }
 

@@ -438,28 +510,28 @@ int cmd_bridge(uint32_t portno1, uint32_t portno2, char *logfile, char *how)
                        active = 0;
 
                        //FIXME
                        active = 0;
 
                        //FIXME

-                       req = xseg_accept(xseg, portno1);
+                       req = xseg_accept(xseg, portno1, 0);

                        if (req) {
                                xseg_submit(xseg, req, portno2, X_ALLOC);
                                log_req(logfd, portno1, portno2, LOG_ACCEPT, method, req);
                                active += 1;
                        }
 
                        if (req) {
                                xseg_submit(xseg, req, portno2, X_ALLOC);
                                log_req(logfd, portno1, portno2, LOG_ACCEPT, method, req);
                                active += 1;
                        }
 

-                       req = xseg_accept(xseg, portno2);
+                       req = xseg_accept(xseg, portno2, 0);

                        if (req) {
                                xseg_submit(xseg, req, portno1, X_ALLOC);
                                log_req(logfd, portno2, portno1, LOG_ACCEPT, method, req);
                                active += 1;
                        }
 
                        if (req) {
                                xseg_submit(xseg, req, portno1, X_ALLOC);
                                log_req(logfd, portno2, portno1, LOG_ACCEPT, method, req);
                                active += 1;
                        }
 

-                       req = xseg_receive(xseg, portno1);
+                       req = xseg_receive(xseg, portno1, 0);

                        if (req) {
                                xseg_respond(xseg, req, portno2, X_ALLOC);
                                log_req(logfd, portno1, portno2, LOG_RECEIVE, method, req);
                                active += 1;
                        }
 
                        if (req) {
                                xseg_respond(xseg, req, portno2, X_ALLOC);
                                log_req(logfd, portno1, portno2, LOG_RECEIVE, method, req);
                                active += 1;
                        }
 

-                       req = xseg_receive(xseg, portno2);
+                       req = xseg_receive(xseg, portno2, 0);

                        if (req) {
                                xseg_respond(xseg, req, portno1, X_ALLOC);
                                log_req(logfd, portno2, portno1, LOG_RECEIVE, method, req);
                        if (req) {
                                xseg_respond(xseg, req, portno1, X_ALLOC);
                                log_req(logfd, portno2, portno1, LOG_RECEIVE, method, req);

@@ -560,7 +632,7 @@ int cmd_rndwrite(long loops, int32_t seed, uint32_t targetlen, uint32_t chunksiz
                        }
                }
 
                        }
                }
 

-               received = xseg_receive(xseg, srcport);
+               received = xseg_receive(xseg, srcport, 0);

                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        nr_received += 1;
                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        nr_received += 1;

@@ -666,7 +738,7 @@ int cmd_rndread(long loops, int32_t seed, uint32_t targetlen, uint32_t chunksize
                        }
                }
 
                        }
                }
 

-               received = xseg_receive(xseg, srcport);
+               received = xseg_receive(xseg, srcport, 0);

                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        nr_received += 1;
                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        nr_received += 1;

@@ -717,7 +789,7 @@ int cmd_submit_reqs(long loops, long concurrent_reqs, int op)
        xport p;
        char *req_data, *req_target;
 
        xport p;
        char *req_data, *req_target;
 

-       xseg_bind_port(xseg, srcport);
+       xseg_bind_port(xseg, srcport, NULL);

 
        gettimeofday(&tv1, NULL);
        for (;;) {
 
        gettimeofday(&tv1, NULL);
        for (;;) {

@@ -760,7 +832,7 @@ int cmd_submit_reqs(long loops, long concurrent_reqs, int op)
                                        perror("Cannot signal peer");
                        }
                }
                                        perror("Cannot signal peer");
                        }
                }

-               received = xseg_receive(xseg, srcport);
+               received = xseg_receive(xseg, srcport, 0);

                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        --nr_flying;
                if (received) {
                        xseg_cancel_wait(xseg, srcport);
                        --nr_flying;

@@ -883,7 +955,7 @@ int cmd_put_requests(void)
        struct xseg_request *req;
 
        for (;;) {
        struct xseg_request *req;
 
        for (;;) {

-               req = xseg_accept(xseg, dstport);
+               req = xseg_accept(xseg, dstport, 0);

                if (!req)
                        break;
                if (xseg_put_request(xseg, req, srcport))
                if (!req)
                        break;
                if (xseg_put_request(xseg, req, srcport))

@@ -898,12 +970,12 @@ int cmd_finish(unsigned long nr, int fail)
        struct xseg_request *req;
        char *buf = malloc(sizeof(char) * 8128);
        char *req_target, *req_data;
        struct xseg_request *req;
        char *buf = malloc(sizeof(char) * 8128);
        char *req_target, *req_data;

-       xseg_bind_port(xseg, srcport);
+       xseg_bind_port(xseg, srcport, NULL);

        xport p;
 
        for (; nr--;) {
                xseg_prepare_wait(xseg, srcport);
        xport p;
 
        for (; nr--;) {
                xseg_prepare_wait(xseg, srcport);

-               req = xseg_accept(xseg, srcport);
+               req = xseg_accept(xseg, srcport, 0);

                if (req) {
                        req_target = xseg_get_target(xseg, req);
                        req_data = xseg_get_data(xseg, req);
                if (req) {
                        req_target = xseg_get_target(xseg, req);
                        req_data = xseg_get_data(xseg, req);

@@ -938,6 +1010,7 @@ int cmd_finish(unsigned long nr, int fail)
 void handle_reply(struct xseg_request *req)
 {
        char *req_data = xseg_get_data(xseg, req);
 void handle_reply(struct xseg_request *req)
 {
        char *req_data = xseg_get_data(xseg, req);

+       char *req_target = xseg_get_target(xseg, req);

        if (!(req->state & XS_SERVED)) {
                report_request(req);
                goto put;
        if (!(req->state & XS_SERVED)) {
                report_request(req);
                goto put;

@@ -949,11 +1022,18 @@ void handle_reply(struct xseg_request *req)
                break;
 
        case X_WRITE:
                break;
 
        case X_WRITE:

+               fprintf(stdout, "wrote: ");
+               fwrite(req_data, 1, req->datalen, stdout);
+               break;

        case X_SYNC:
        case X_DELETE:
        case X_SYNC:
        case X_DELETE:

+               fprintf(stderr, "deleted %s\n", req_target);
+               break;

        case X_TRUNCATE:
        case X_COMMIT:
        case X_CLONE:
        case X_TRUNCATE:
        case X_COMMIT:
        case X_CLONE:

+               fprintf(stderr, "cloned %s\n", ((struct xseg_request_clone *)req_data)->target);
+               break;

        case X_INFO:
                fprintf(stderr, "size: %llu\n", (unsigned long long)*((uint64_t *)req_data));
                break;
        case X_INFO:
                fprintf(stderr, "size: %llu\n", (unsigned long long)*((uint64_t *)req_data));
                break;

@@ -971,9 +1051,10 @@ int cmd_wait(uint32_t nr)
 {
        struct xseg_request *req;
        long ret;
 {
        struct xseg_request *req;
        long ret;

+       init_local_signal(); 

 
        for (;;) {
 
        for (;;) {

-               req = xseg_receive(xseg, srcport);
+               req = xseg_receive(xseg, srcport, 0);

                if (req) {
                        handle_reply(req);
                        nr--;
                if (req) {
                        handle_reply(req);
                        nr--;

@@ -1000,7 +1081,7 @@ int cmd_put_replies(void)
        struct xseg_request *req;
 
        for (;;) {
        struct xseg_request *req;
 
        for (;;) {

-               req = xseg_receive(xseg, dstport);
+               req = xseg_receive(xseg, dstport, 0);

                if (!req)
                        break;
                fprintf(stderr, "request: %08llx%08llx\n"
                if (!req)
                        break;
                fprintf(stderr, "request: %08llx%08llx\n"

@@ -1022,7 +1103,7 @@ int cmd_put_replies(void)
 
 int cmd_bind(long portno)
 {
 
 int cmd_bind(long portno)
 {

-       struct xseg_port *port = xseg_bind_port(xseg, portno);
+       struct xseg_port *port = xseg_bind_port(xseg, portno, NULL);

        if (!port) {
                fprintf(stderr, "failed to bind port %ld\n", portno);
                return 1;
        if (!port) {
                fprintf(stderr, "failed to bind port %ld\n", portno);
                return 1;