Merge remote branch 'kwolf/for-anthony' into staging (f124a410) · Commits · SUMMER2020 / students / proj-2021291

Makefile.objs

+2 −2

Original line number	Diff line number	Diff line
		@@ -14,7 +14,7 @@ oslib-obj-$(CONFIG_POSIX) += oslib-posix.o
		# block-obj-y is code used by both qemu system emulation and qemu-img

		block-obj-y = cutils.o cache-utils.o qemu-malloc.o qemu-option.o module.o async.o
		block-obj-y += nbd.o block.o aio.o aes.o qemu-config.o
		block-obj-y += nbd.o block.o aio.o aes.o qemu-config.o qemu-progress.o qemu-sockets.o
		block-obj-$(CONFIG_POSIX) += posix-aio-compat.o
		block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o

		@@ -94,7 +94,7 @@ common-obj-$(CONFIG_SSI_SD) += ssi-sd.o
		common-obj-$(CONFIG_SD) += sd.o
		common-obj-y += bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o
		common-obj-y += bt-hci-csr.o
		common-obj-y += buffered_file.o migration.o migration-tcp.o qemu-sockets.o
		common-obj-y += buffered_file.o migration.o migration-tcp.o
		common-obj-y += qemu-char.o savevm.o #aio.o
		common-obj-y += msmouse.o ps2.o
		common-obj-y += qdev.o qdev-properties.o

block-migration.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -140,7 +140,7 @@ static inline void add_avg_read_time(int64_t time)
		static inline long double compute_read_bwidth(void)
		{
		assert(block_mig_state.total_time != 0);
		return (block_mig_state.reads * BLOCK_SIZE)/ block_mig_state.total_time;
		return (block_mig_state.reads / block_mig_state.total_time) * BLOCK_SIZE;
		}

		static int bmds_aio_inflight(BlkMigDevState *bmds, int64_t sector)

block.c

+18 −10

Original line number	Diff line number	Diff line
		@@ -697,14 +697,22 @@ void bdrv_close_all(void)
		}
		}

		/* make a BlockDriverState anonymous by removing from bdrv_state list.
		Also, NULL terminate the device_name to prevent double remove */
		void bdrv_make_anon(BlockDriverState *bs)
		{
		if (bs->device_name[0] != '\0') {
		QTAILQ_REMOVE(&bdrv_states, bs, list);
		}
		bs->device_name[0] = '\0';
		}

		void bdrv_delete(BlockDriverState *bs)
		{
		assert(!bs->peer);

		/* remove from list, if necessary */
		if (bs->device_name[0] != '\0') {
		QTAILQ_REMOVE(&bdrv_states, bs, list);
		}
		bdrv_make_anon(bs);

		bdrv_close(bs);
		if (bs->file != NULL) {
		@@ -1153,15 +1161,13 @@ int64_t bdrv_getlength(BlockDriverState *bs)
		if (!drv)
		return -ENOMEDIUM;

		/* Fixed size devices use the total_sectors value for speed instead of
		issuing a length query (like lseek) on each call. Also, legacy block
		drivers don't provide a bdrv_getlength function and must use
		total_sectors. */
		if (!bs->growable \|\| !drv->bdrv_getlength) {
		return bs->total_sectors * BDRV_SECTOR_SIZE;
		}
		if (bs->growable \|\| bs->removable) {
		if (drv->bdrv_getlength) {
		return drv->bdrv_getlength(bs);
		}
		}
		return bs->total_sectors * BDRV_SECTOR_SIZE;
		}

		/* return 0 as number of sectors if no device present or error */
		void bdrv_get_geometry(BlockDriverState bs, uint64_t nb_sectors_ptr)
		@@ -2809,6 +2815,8 @@ void bdrv_set_locked(BlockDriverState *bs, int locked)
		{
		BlockDriver *drv = bs->drv;

		trace_bdrv_set_locked(bs, locked);

		bs->locked = locked;
		if (drv && drv->bdrv_set_locked) {
		drv->bdrv_set_locked(bs, locked);

block.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ int bdrv_create(BlockDriver drv, const char filename,
		QEMUOptionParameter *options);
		int bdrv_create_file(const char* filename, QEMUOptionParameter *options);
		BlockDriverState bdrv_new(const char device_name);
		void bdrv_make_anon(BlockDriverState *bs);
		void bdrv_delete(BlockDriverState *bs);
		int bdrv_file_open(BlockDriverState *pbs, const char filename, int flags);
		int bdrv_open(BlockDriverState bs, const char filename, int flags,

block/nbd.c

+102 −55

Original line number	Diff line number	Diff line
		@@ -29,96 +29,152 @@
		#include "qemu-common.h"
		#include "nbd.h"
		#include "module.h"
		#include "qemu_socket.h"

		#include <sys/types.h>
		#include <unistd.h>

		#define EN_OPTSTR ":exportname="

		/* #define DEBUG_NBD */

		#if defined(DEBUG_NBD)
		#define logout(fmt, ...) \
		fprintf(stderr, "nbd\t%-24s" fmt, __func__, ##__VA_ARGS__)
		#else
		#define logout(fmt, ...) ((void)0)
		#endif

		typedef struct BDRVNBDState {
		int sock;
		off_t size;
		size_t blocksize;
		char export_name; / An NBD server may export several devices */

		/* If it begins with '/', this is a UNIX domain socket. Otherwise,
		* it's a string of the form <hostname\|ip4\|\[ip6\]>:port
		*/
		char *host_spec;
		} BDRVNBDState;

		static int nbd_open(BlockDriverState bs, const char filename, int flags)
		static int nbd_config(BDRVNBDState s, const char filename, int flags)
		{
		BDRVNBDState *s = bs->opaque;
		uint32_t nbdflags;

		char *file;
		char *name;
		const char *host;
		char *export_name;
		const char *host_spec;
		const char *unixpath;
		int sock;
		off_t size;
		size_t blocksize;
		int ret;
		int err = -EINVAL;

		file = qemu_strdup(filename);

		name = strstr(file, EN_OPTSTR);
		if (name) {
		if (name[strlen(EN_OPTSTR)] == 0) {
		export_name = strstr(file, EN_OPTSTR);
		if (export_name) {
		if (export_name[strlen(EN_OPTSTR)] == 0) {
		goto out;
		}
		name[0] = 0;
		name += strlen(EN_OPTSTR);
		export_name[0] = 0; /* truncate 'file' */
		export_name += strlen(EN_OPTSTR);
		s->export_name = qemu_strdup(export_name);
		}

		if (!strstart(file, "nbd:", &host)) {
		/* extract the host_spec - fail if it's not nbd:... */
		if (!strstart(file, "nbd:", &host_spec)) {
		goto out;
		}

		if (strstart(host, "unix:", &unixpath)) {

		if (unixpath[0] != '/') {
		/* are we a UNIX or TCP socket? */
		if (strstart(host_spec, "unix:", &unixpath)) {
		if (unixpath[0] != '/') { /* We demand an absolute path*/
		goto out;
		}

		sock = unix_socket_outgoing(unixpath);

		s->host_spec = qemu_strdup(unixpath);
		} else {
		uint16_t port = NBD_DEFAULT_PORT;
		char p, r;
		char hostname[128];

		pstrcpy(hostname, 128, host);
		s->host_spec = qemu_strdup(host_spec);
		}

		p = strchr(hostname, ':');
		if (p != NULL) {
		*p = '\0';
		p++;
		err = 0;

		port = strtol(p, &r, 0);
		if (r == p) {
		goto out;
		out:
		qemu_free(file);
		if (err != 0) {
		qemu_free(s->export_name);
		qemu_free(s->host_spec);
		}
		return err;
		}

		sock = tcp_socket_outgoing(hostname, port);
		static int nbd_establish_connection(BlockDriverState *bs)
		{
		BDRVNBDState *s = bs->opaque;
		int sock;
		int ret;
		off_t size;
		size_t blocksize;
		uint32_t nbdflags;

		if (s->host_spec[0] == '/') {
		sock = unix_socket_outgoing(s->host_spec);
		} else {
		sock = tcp_socket_outgoing_spec(s->host_spec);
		}

		/* Failed to establish connection */
		if (sock == -1) {
		err = -errno;
		goto out;
		logout("Failed to establish connection to NBD server\n");
		return -errno;
		}

		ret = nbd_receive_negotiate(sock, name, &nbdflags, &size, &blocksize);
		/* NBD handshake */
		ret = nbd_receive_negotiate(sock, s->export_name, &nbdflags, &size,
		&blocksize);
		if (ret == -1) {
		err = -errno;
		goto out;
		logout("Failed to negotiate with the NBD server\n");
		closesocket(sock);
		return -errno;
		}

		/* Now that we're connected, set the socket to be non-blocking */
		socket_set_nonblock(sock);

		s->sock = sock;
		s->size = size;
		s->blocksize = blocksize;
		err = 0;

		out:
		qemu_free(file);
		return err;
		logout("Established connection with NBD server\n");
		return 0;
		}

		static void nbd_teardown_connection(BlockDriverState *bs)
		{
		BDRVNBDState *s = bs->opaque;
		struct nbd_request request;

		request.type = NBD_CMD_DISC;
		request.handle = (uint64_t)(intptr_t)bs;
		request.from = 0;
		request.len = 0;
		nbd_send_request(s->sock, &request);

		closesocket(s->sock);
		}

		static int nbd_open(BlockDriverState bs, const char filename, int flags)
		{
		BDRVNBDState *s = bs->opaque;
		int result;

		/* Pop the config into our state object. Exit if invalid. */
		result = nbd_config(s, filename, flags);
		if (result != 0) {
		return result;
		}

		/* establish TCP connection, return error if it fails
		* TODO: Configurable retry-until-timeout behaviour.
		*/
		result = nbd_establish_connection(bs);

		return result;
		}

		static int nbd_read(BlockDriverState *bs, int64_t sector_num,
		@@ -183,16 +239,7 @@ static int nbd_write(BlockDriverState *bs, int64_t sector_num,

		static void nbd_close(BlockDriverState *bs)
		{
		BDRVNBDState *s = bs->opaque;
		struct nbd_request request;

		request.type = NBD_CMD_DISC;
		request.handle = (uint64_t)(intptr_t)bs;
		request.from = 0;
		request.len = 0;
		nbd_send_request(s->sock, &request);

		close(s->sock);
		nbd_teardown_connection(bs);
		}

		static int64_t nbd_getlength(BlockDriverState *bs)