Linux-NBD/NBD.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include <inttypes.h>
#include <unistd.h>
#include <endian.h>

#include <sys/ioctl.h>
#include <netinet/in.h>
#include <byteswap.h>

typedef uint32_t u32;
typedef uint64_t u64;
#include "nbd.h"

#if __BYTE_ORDER == __BIG_ENDIAN
#define ntohll(netlong) (netlong)
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define ntohll(netlong) __bswap_64(netlong)
#else
error, you should not exist
#endif

struct rstate {
  struct nbd_request req;
  u32 req_read; /* how many octets of req are valid */
  u32 data_read; /* how many octets of the data sv are valid */
};

MODULE = Linux::NBD             PACKAGE = Linux::NBD::Client

PROTOTYPES: DISABLE

void
_set_sock (int dev, int fd)
        CODE:
        ioctl (dev, NBD_SET_SOCK, (unsigned long)fd);

void
_doit (int dev, int server = 0)
        CODE:
        if (server)
          for (server = 0; server < 4095; server++)
            if (server != dev)
              close (server);

        ioctl (dev, NBD_DO_IT);

        if (server)
          _exit (0);

void
_disconnect (int dev)
        CODE:
        ioctl (dev, NBD_DISCONNECT);

void
_clear_sock (int dev)
        ALIAS:
        _clear_sock = NBD_CLEAR_SOCK
        _clear_que  = NBD_CLEAR_QUE
        CODE:
        ioctl (dev, ix);

void
_set_blksize (int dev, unsigned long arg)
        ALIAS:
        _set_blksize     = NBD_SET_BLKSIZE
        _set_size        = NBD_SET_SIZE
        _set_size_blocks = NBD_SET_SIZE_BLOCKS
        _set_timeout     = NBD_SET_TIMEOUT
        _set_flags       = NBD_SET_FLAGS
        CODE:
        ioctl (dev, ix, arg);

void
_print_debug (int dev)
        CODE:
        ioctl (dev, NBD_PRINT_DEBUG, 0);

MODULE = Linux::NBD             PACKAGE = Linux::NBD::Server

void
_one_request (SV *obj, int fd)
        CODE:
{
        struct rstate *s;
        u64 from;
        u32 len;
        char *method;
        MAGIC *mg = mg_find (SvRV (obj), PERL_MAGIC_ext);

        if (!mg)
          {
            mg = sv_magicext (SvRV (obj), 0, PERL_MAGIC_ext, 0, 0, 0);
            mg->mg_len = sizeof (struct rstate);
            New (0, mg->mg_ptr, mg->mg_len, char);

            ((struct rstate *)mg->mg_ptr)->req_read = 0; /* initialise the state machine */
          }

        s = (struct rstate *)mg->mg_ptr;

        if (s->req_read < sizeof (struct nbd_request))
          {
            int res = read (fd, s->req_read + (char *)&s->req, sizeof (struct nbd_request) - s->req_read);

            if (res > 0)
              s->req_read += res;
            else if (res == 0)
              XSRETURN_UNDEF; /* should req->eof */
            else if (errno != EAGAIN && errno != EWOULDBLOCK)
              XSRETURN_UNDEF; /* should req->error */

            s->data_read = 0;

            if (s->req_read < sizeof (struct nbd_request))
              XSRETURN_NO;
          }

        /* now we have a full request, so check for data */
        if (s->req.magic != htonl (NBD_REQUEST_MAGIC))
          croak ("Linux::NBD::Server received illegal request magic %08lx - protocol error.\n", ntohl (s->req.magic));

        from = ntohll (s->req.from);
        len  = ntohl  (s->req.len);

        switch (ntohl (s->req.type))
          {
            case NBD_CMD_WRITE:
              if (!mg->mg_obj)
                {
                  mg->mg_flags |= MGf_REFCOUNTED;
                  mg->mg_obj = NEWSV (0, len);
                  SvPOK_only (mg->mg_obj);
                  SvCUR_set (mg->mg_obj, len);
                }

              if (s->data_read < len)
                {
                  int res = read (fd, s->data_read + SvPVX (mg->mg_obj), len - s->data_read);

                  if (res > 0)
                    s->data_read += res;
                  else if (res == 0)
                    XSRETURN_UNDEF; /* should req->eof */
                  else if (errno != EAGAIN && errno != EWOULDBLOCK)
                    XSRETURN_UNDEF; /* should req->error */

                  if (s->data_read < len)
                    XSRETURN_NO;
                }

              /* fallthrough */
            case NBD_CMD_READ:
            case NBD_CMD_FLUSH:
            case NBD_CMD_TRIM:
            case NBD_CMD_WRITE_ZEROES:
              s->req_read = 0;

              PUSHMARK (SP);
              EXTEND (SP, 4);
              PUSHs (obj);
              PUSHs (sv_2mortal (newSVpvn (s->req.handle, sizeof (s->req.handle))));
              PUSHs (sv_2mortal (sizeof (UV) < 8 && from > 0xffffffffUL
                                 ? newSVnv (from)
                                 : newSVuv (from)));

              if (mg->mg_obj)
                {
                  PUSHs (sv_2mortal (mg->mg_obj));
                  mg->mg_obj = 0;
                  method = "req_write";
                }
              else
                {
                  PUSHs (sv_2mortal (newSVuv (len)));
                  method = s->req.type == NBD_CMD_READ         ? "req_read"
                         : s->req.type == NBD_CMD_FLUSH        ? "req_flush"
                         : s->req.type == NBD_CMD_TRIM         ? "req_trim"
                         : s->req.type == NBD_CMD_WRITE_ZEROES ? "req_write_zeroes"
                         : (abort (), "");
                }

              break;

            case NBD_CMD_DISC:
              s->req_read = 0;

              method = "req_disc";

              PUSHMARK (SP);
              XPUSHs (obj);

              break;

            default:
              croak ("Linux::NBD::Server received unsupported request type %d.\n", ntohl (s->req.type));
          }

        PUTBACK;
        call_method (method, G_DISCARD);
        SPAGAIN;

        XSRETURN_YES;
}

SV *
format_reply (SV *unused, SV *handle, unsigned int error = 0, SV *data = 0)
        CODE:
{
        struct nbd_reply rep;
        STRLEN len;
        char *h = SvPV (handle, len);

        if (len != sizeof (rep.handle))
          croak ("format_reply: illegal handle (length %d, should be %d)", len, sizeof (rep.handle));

        rep.magic = htonl (NBD_REPLY_MAGIC);
        rep.error = htonl (error);
        memcpy (rep.handle, h, sizeof (rep.handle));

        RETVAL = newSVpvn ((char *)&rep, sizeof (rep));

        if (data && !error)
          sv_catsv (RETVAL, data);
}
        OUTPUT:
        RETVAL

Revision:	1.8
Committed:	Tue May 30 01:07:29 2017 UTC (6 years, 11 months ago) by root
Branch:	MAIN
Changes since 1.7:	+25 -29 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "EXTERN.h"
2			#include "perl.h"
3			#include "XSUB.h"
4
5			#include <inttypes.h>
6			#include <unistd.h>
7			#include <endian.h>
8
9			#include <sys/ioctl.h>
10			#include <netinet/in.h>
11			#include <byteswap.h>
12
13			typedef uint32_t u32;
14			typedef uint64_t u64;
15	root	1.8	#include "nbd.h"
16	root	1.1
17			#if __BYTE_ORDER == __BIG_ENDIAN
18			#define ntohll(netlong) (netlong)
19			#elif __BYTE_ORDER == __LITTLE_ENDIAN
20			#define ntohll(netlong) __bswap_64(netlong)
21			#else
22			error, you should not exist
23			#endif
24
25	root	1.6	struct rstate {
26			struct nbd_request req;
27			u32 req_read; /* how many octets of req are valid */
28			u32 data_read; /* how many octets of the data sv are valid */
29			};
30
31	root	1.1	MODULE = Linux::NBD PACKAGE = Linux::NBD::Client
32
33	root	1.6	PROTOTYPES: DISABLE
34
35	root	1.1	void
36			_set_sock (int dev, int fd)
37			CODE:
38			ioctl (dev, NBD_SET_SOCK, (unsigned long)fd);
39
40			void
41	root	1.2	_doit (int dev, int server = 0)
42	root	1.1	CODE:
43	root	1.2	if (server)
44			for (server = 0; server < 4095; server++)
45			if (server != dev)
46			close (server);
47
48	root	1.1	ioctl (dev, NBD_DO_IT);
49	root	1.2
50			if (server)
51	root	1.1	_exit (0);
52
53			void
54			_disconnect (int dev)
55			CODE:
56			ioctl (dev, NBD_DISCONNECT);
57
58			void
59			_clear_sock (int dev)
60	root	1.8	ALIAS:
61			_clear_sock = NBD_CLEAR_SOCK
62			_clear_que = NBD_CLEAR_QUE
63			CODE:
64			ioctl (dev, ix);
65
66			void
67			_set_blksize (int dev, unsigned long arg)
68			ALIAS:
69			_set_blksize = NBD_SET_BLKSIZE
70			_set_size = NBD_SET_SIZE
71			_set_size_blocks = NBD_SET_SIZE_BLOCKS
72			_set_timeout = NBD_SET_TIMEOUT
73			_set_flags = NBD_SET_FLAGS
74	root	1.1	CODE:
75	root	1.8	ioctl (dev, ix, arg);
76	root	1.5
77			void
78			_print_debug (int dev)
79			CODE:
80			ioctl (dev, NBD_PRINT_DEBUG, 0);
81
82	root	1.1	MODULE = Linux::NBD PACKAGE = Linux::NBD::Server
83
84			void
85			_one_request (SV *obj, int fd)
86			CODE:
87	root	1.3	{
88	root	1.6	struct rstate *s;
89			u64 from;
90			u32 len;
91			char *method;
92			MAGIC *mg = mg_find (SvRV (obj), PERL_MAGIC_ext);
93
94			if (!mg)
95			{
96			mg = sv_magicext (SvRV (obj), 0, PERL_MAGIC_ext, 0, 0, 0);
97			mg->mg_len = sizeof (struct rstate);
98			New (0, mg->mg_ptr, mg->mg_len, char);
99
100			((struct rstate )mg->mg_ptr)->req_read = 0; / initialise the state machine */
101			}
102
103			s = (struct rstate *)mg->mg_ptr;
104	root	1.1
105	root	1.6	if (s->req_read < sizeof (struct nbd_request))
106	root	1.1	{
107	root	1.6	int res = read (fd, s->req_read + (char *)&s->req, sizeof (struct nbd_request) - s->req_read);
108
109			if (res > 0)
110			s->req_read += res;
111			else if (res == 0)
112			XSRETURN_UNDEF; /* should req->eof */
113			else if (errno != EAGAIN && errno != EWOULDBLOCK)
114			XSRETURN_UNDEF; /* should req->error */
115
116			s->data_read = 0;
117	root	1.7
118			if (s->req_read < sizeof (struct nbd_request))
119			XSRETURN_NO;
120	root	1.1	}
121
122	root	1.6	/* now we have a full request, so check for data */
123			if (s->req.magic != htonl (NBD_REQUEST_MAGIC))
124			croak ("Linux::NBD::Server received illegal request magic %08lx - protocol error.\n", ntohl (s->req.magic));
125
126			from = ntohll (s->req.from);
127			len = ntohl (s->req.len);
128
129			switch (ntohl (s->req.type))
130			{
131			case NBD_CMD_WRITE:
132			if (!mg->mg_obj)
133			{
134			mg->mg_flags \|= MGf_REFCOUNTED;
135			mg->mg_obj = NEWSV (0, len);
136			SvPOK_only (mg->mg_obj);
137			SvCUR_set (mg->mg_obj, len);
138			}
139
140			if (s->data_read < len)
141			{
142			int res = read (fd, s->data_read + SvPVX (mg->mg_obj), len - s->data_read);
143
144			if (res > 0)
145			s->data_read += res;
146			else if (res == 0)
147			XSRETURN_UNDEF; /* should req->eof */
148			else if (errno != EAGAIN && errno != EWOULDBLOCK)
149			XSRETURN_UNDEF; /* should req->error */
150	root	1.7
151			if (s->data_read < len)
152			XSRETURN_NO;
153	root	1.6	}
154
155			/* fallthrough */
156			case NBD_CMD_READ:
157	root	1.8	case NBD_CMD_FLUSH:
158			case NBD_CMD_TRIM:
159			case NBD_CMD_WRITE_ZEROES:
160	root	1.6	s->req_read = 0;
161
162			PUSHMARK (SP);
163			EXTEND (SP, 4);
164			PUSHs (obj);
165			PUSHs (sv_2mortal (newSVpvn (s->req.handle, sizeof (s->req.handle))));
166			PUSHs (sv_2mortal (sizeof (UV) < 8 && from > 0xffffffffUL
167			? newSVnv (from)
168			: newSVuv (from)));
169
170			if (mg->mg_obj)
171			{
172			PUSHs (sv_2mortal (mg->mg_obj));
173			mg->mg_obj = 0;
174			method = "req_write";
175			}
176			else
177			{
178			PUSHs (sv_2mortal (newSVuv (len)));
179	root	1.8	method = s->req.type == NBD_CMD_READ ? "req_read"
180			: s->req.type == NBD_CMD_FLUSH ? "req_flush"
181			: s->req.type == NBD_CMD_TRIM ? "req_trim"
182			: s->req.type == NBD_CMD_WRITE_ZEROES ? "req_write_zeroes"
183			: (abort (), "");
184	root	1.6	}
185
186			break;
187
188			case NBD_CMD_DISC:
189			s->req_read = 0;
190
191			method = "req_disc";
192
193			PUSHMARK (SP);
194			XPUSHs (obj);
195
196			break;
197
198			default:
199			croak ("Linux::NBD::Server received unsupported request type %d.\n", ntohl (s->req.type));
200			}
201
202			PUTBACK;
203			call_method (method, G_DISCARD);
204			SPAGAIN;
205
206	root	1.1	XSRETURN_YES;
207	root	1.3	}
208	root	1.1
209			SV *
210	root	1.6	format_reply (SV unused, SV handle, unsigned int error = 0, SV *data = 0)
211	root	1.1	CODE:
212	root	1.3	{
213	root	1.1	struct nbd_reply rep;
214			STRLEN len;
215			char *h = SvPV (handle, len);
216
217			if (len != sizeof (rep.handle))
218			croak ("format_reply: illegal handle (length %d, should be %d)", len, sizeof (rep.handle));
219
220			rep.magic = htonl (NBD_REPLY_MAGIC);
221			rep.error = htonl (error);
222			memcpy (rep.handle, h, sizeof (rep.handle));
223
224			RETVAL = newSVpvn ((char *)&rep, sizeof (rep));
225
226			if (data && !error)
227			sv_catsv (RETVAL, data);
228	root	1.8	}
229	root	1.1	OUTPUT:
230			RETVAL
231