src/virtio.js - emulators/v86 - Rivoreo Source Code Repositories

 "use strict";


 /** @constructor */
 function VirtIO(cpu, bus, filesystem)
 {
     // http://ozlabs.org/~rusty/virtio-spec/virtio-0.9.5.pdf

     this.pci_space = [
         0xf4, 0x1a, 0x09, 0x10, 0x07, 0x05, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x01, 0xa8, 0x00, 0x00, 0x00, 0x10, 0xbf, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x1a, 0x09, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00,
     ];
     this.pci_id = 0x06 << 3;
     this.pci_bars = [
         {
             size: 128 * 1024,
         },
     ];

     cpu.devices.pci.register_device(this);

     var io = cpu.io;

     io.register_read(0xA800, this, undefined, undefined, function()
     {
         // device features
         return 1;
     });

     io.register_write(0xA804, this, undefined, undefined, function(data)
     {
         // write guest features
         dbg_log("Guest feature selection: " + h(data, 8), LOG_VIRTIO);
     });

     io.register_write(0xA80E, this, undefined, function(data)
     {
         // rw queue select
         dbg_log("Queue select: " + h(data, 4), LOG_VIRTIO);
         this.queue_select = data;
     }, undefined);

     io.register_read(0xA80C, this, undefined, function()
     {
         // read queue size
         dbg_log("Read queue size", LOG_VIRTIO);
         return this.queue_size;
     }, undefined);

     io.register_read(0xA808, this, undefined, undefined, function()
     {
         // rw queue address
         dbg_log("Read queue address", LOG_VIRTIO);

         if(this.queue_select === 0)
         {
             return this.queue_address;
         }
         else
         {
             // queue does not exist
             return 0;
         }
     });

     io.register_write(0xA808, this, undefined, undefined, function(data)
     {
         // rw queue address
         dbg_log("Write queue address: " + h(data, 8), LOG_VIRTIO);
         this.queue_address = data;
     });

     io.register_write(0xA812, this, function(data)
     {
         dbg_log("Write device status: " + h(data, 2), LOG_VIRTIO);
         this.device_status = data;
     });

     io.register_read(0xA812, this, function()
     {
         dbg_log("Read device status", LOG_VIRTIO);
         return this.device_status;
     });

     io.register_read(0xA813, this, function()
     {
         dbg_log("Read isr", LOG_VIRTIO);

         // reading resets the isr
         var isr = this.isr;
         this.isr = 0;
         return isr;
     });

     io.register_write(0xA810, this, undefined, function(data)
     {
         dbg_log("Write queue notify: " + h(data, 4), LOG_VIRTIO);

         // only queue 0 supported
         dbg_assert(data === 0);

         var queue_start = this.queue_address << 12;
         var ring_start = queue_start + 16 * this.queue_size;
         var ring_desc_start = ring_start + 4;

         var flags = this.memory.read16(ring_start),
             // index of the next free ring
             idx = this.memory.read16(ring_start + 2);

         dbg_log("idx=" + h(idx, 4), LOG_VIRTIO);
         //dbg_assert(idx < this.queue_size);

         var mask = this.queue_size - 1;
         idx &= mask;

         while(this.last_idx !== idx)
         {
             var desc_idx = this.memory.read16(ring_desc_start + this.last_idx * 2);
             this.handle_descriptor(desc_idx);

             this.last_idx = this.last_idx + 1 & mask;
         }
     });

     this.irq = 0xC;

     /** @const */
     this.pic = cpu.devices.pic;

     /** @const */
     this.bus = bus;

     this.queue_select = 0;
     this.device_status = 0;
     this.isr = 0;

     // these should be stored per queue if there is more than one queue
     this.last_idx = 0;
     this.queue_size = 32;
     this.queue_address = 0;

     /** @const */
     this.memory = cpu.memory;

     for(var i = 0; i < 128; i++)
     {
         io.register_read(0xA814 + i, this, function(port)
         {
             dbg_log("Read device " + h(port), LOG_VIRTIO);
             //dbg_assert(typeof this.device.configspace[port] === "number");

             return this.device.configspace[port];
         }.bind(this, i), undefined, undefined);

         io.register_write(0xA814 + i, this, function(port, data)
         {
             dbg_log("Write device " + h(port) + ": " + h(data, 2), LOG_VIRTIO);
         }.bind(this, i), undefined, undefined);
     }

     // should be generalized to support more devices than just the filesystem
     /** @const */
     this.device = new Virtio9p(filesystem, bus);
     this.device.SendReply = this.device_reply.bind(this);

     this._state_skip = [
         this.memory,
         this.pic,
         this.bus,
     ];
     this._state_restore = function()
     {
         this.device.SendReply = this.device_reply.bind(this);
     };
 }

 VirtIO.prototype.handle_descriptor = function(idx)
 {
     var next = idx;
     var desc_start = this.queue_address << 12;

     var buffer_idx = 0;
     var buffers = [];

     do
     {
         var addr = desc_start + next * 16;
         var flags = this.memory.read16(addr + 12);

         if(flags & VRING_DESC_F_WRITE)
         {
             break;
         }

         if(flags & VRING_DESC_F_INDIRECT) {
             dbg_assert(false, "unsupported");
         }

         var addr_low = this.memory.read32s(addr);
         var addr_high = this.memory.read32s(addr + 4);
         var len = this.memory.read32s(addr + 8) >>> 0;

         buffers.push({
             addr_low: addr_low,
             addr_high: addr_high,
             len: len,
         });

         dbg_log("descriptor: addr=" + h(addr_high, 8) + ":" + h(addr_low, 8) +
                              " len=" + h(len, 8) + " flags=" + h(flags, 4) + " next=" + h(next, 4), LOG_VIRTIO);

         if(flags & VRING_DESC_F_NEXT)
         {
             next = this.memory.read16(addr + 14);
             dbg_assert(next < this.queue_size);
         }
         else
         {
             next = -1;
             break;
         }
     }
     while(true);

     var buffer_len = -1;
     var pointer = 0;

     var infos = {
         start: idx,
         next: next,
     };

     this.device.ReceiveRequest(infos, function()
     {
         // return one byte

         if(pointer >= buffer_len)
         {
             if(buffer_idx === buffers.length)
             {
                 dbg_log("Read more data than descriptor has", LOG_VIRTIO);
                 return 0;
             }

             var buf = buffers[buffer_idx++];

             addr_low = buf.addr_low;
             buffer_len = buf.len;
             pointer = 0;
         }

         return this.memory.read8(addr_low + pointer++);
     }.bind(this));
 };

 VirtIO.prototype.device_reply = function(infos)
 {
     if(infos.next === -1)
     {
         dbg_log("Reply to invalid index", LOG_VIRTIO);
         return;
     }

     var mask = this.queue_size - 1;
     var result_length = this.device.replybuffersize;

     var next = infos.next;
     var desc_start = this.queue_address << 12;

     var buffer_idx = 0;
     var buffers = [];

     do
     {
         var addr = desc_start + next * 16;
         var flags = this.memory.read16(addr + 12);

         if((flags & VRING_DESC_F_WRITE) === 0)
         {
             dbg_log("Bug: Readonly ring after writeonly ring", LOG_VIRTIO);
             break;
         }

         var addr_low = this.memory.read32s(addr);
         var addr_high = this.memory.read32s(addr + 4);
         var len = this.memory.read32s(addr + 8) >>> 0;

         buffers.push({
             addr_low: addr_low,
             addr_high: addr_high,
             len: len,
         });

         dbg_log("descriptor: addr=" + h(addr_high, 8) + ":" + h(addr_low, 8) +
                              " len=" + h(len, 8) + " flags=" + h(flags, 4) + " next=" + h(next, 4), LOG_VIRTIO);

         if(flags & VRING_DESC_F_NEXT)
         {
             next = this.memory.read16(addr + 14);
             dbg_assert(next < this.queue_size);
         }
         else
         {
             break;
         }
     }
     while(true);

     var buffer_len = -1;
     var pointer = 0;

     for(var i = 0; i < result_length; i++)
     {
         var data = this.device.replybuffer[i];

         if(pointer >= buffer_len)
         {
             if(buffer_idx === buffers.length)
             {
                 dbg_log("Write more data than descriptor has", LOG_VIRTIO);
                 return 0;
             }

             var buf = buffers[buffer_idx++];

             addr_low = buf.addr_low;
             buffer_len = buf.len;
             pointer = 0;
         }

         this.memory.write8(addr_low + pointer++, data);
     }

     var used_desc_start = (this.queue_address << 12) + 16 * this.queue_size + 4 + 2 * this.queue_size;
     used_desc_start = used_desc_start + 4095 & ~4095;

     var flags = this.memory.read16(used_desc_start);
     var used_idx = this.memory.read16(used_desc_start + 2);
     this.memory.write16(used_desc_start + 2, used_idx + 1);

     dbg_log("used descriptor: addr=" + h(used_desc_start, 8) + " flags=" + h(flags, 4) + " idx=" + h(used_idx, 4), LOG_VIRTIO);

     used_idx &= mask;
     var used_desc_offset = used_desc_start + 4 + used_idx * 8;
     this.memory.write32(used_desc_offset, infos.start);
     this.memory.write32(used_desc_offset + 4, result_length);

     this.isr |= 1;
     this.pic.push_irq(this.irq);
 };
	"use strict";


	/** @constructor */
	function VirtIO(cpu, bus, filesystem)
	{
	// http://ozlabs.org/~rusty/virtio-spec/virtio-0.9.5.pdf

	this.pci_space = [
	0xf4, 0x1a, 0x09, 0x10, 0x07, 0x05, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x01, 0xa8, 0x00, 0x00, 0x00, 0x10, 0xbf, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x1a, 0x09, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00,
	];
	this.pci_id = 0x06 << 3;
	this.pci_bars = [
	{
	size: 128 * 1024,
	},
	];

	cpu.devices.pci.register_device(this);

	var io = cpu.io;

	io.register_read(0xA800, this, undefined, undefined, function()
	{
	// device features
	return 1;
	});

	io.register_write(0xA804, this, undefined, undefined, function(data)
	{
	// write guest features
	dbg_log("Guest feature selection: " + h(data, 8), LOG_VIRTIO);
	});

	io.register_write(0xA80E, this, undefined, function(data)
	{
	// rw queue select
	dbg_log("Queue select: " + h(data, 4), LOG_VIRTIO);
	this.queue_select = data;
	}, undefined);

	io.register_read(0xA80C, this, undefined, function()
	{
	// read queue size
	dbg_log("Read queue size", LOG_VIRTIO);
	return this.queue_size;
	}, undefined);

	io.register_read(0xA808, this, undefined, undefined, function()
	{
	// rw queue address
	dbg_log("Read queue address", LOG_VIRTIO);

	if(this.queue_select === 0)
	{
	return this.queue_address;
	}
	else
	{
	// queue does not exist
	return 0;
	}
	});

	io.register_write(0xA808, this, undefined, undefined, function(data)
	{
	// rw queue address
	dbg_log("Write queue address: " + h(data, 8), LOG_VIRTIO);
	this.queue_address = data;
	});

	io.register_write(0xA812, this, function(data)
	{
	dbg_log("Write device status: " + h(data, 2), LOG_VIRTIO);
	this.device_status = data;
	});

	io.register_read(0xA812, this, function()
	{
	dbg_log("Read device status", LOG_VIRTIO);
	return this.device_status;
	});

	io.register_read(0xA813, this, function()
	{
	dbg_log("Read isr", LOG_VIRTIO);

	// reading resets the isr
	var isr = this.isr;
	this.isr = 0;
	return isr;
	});

	io.register_write(0xA810, this, undefined, function(data)
	{
	dbg_log("Write queue notify: " + h(data, 4), LOG_VIRTIO);

	// only queue 0 supported
	dbg_assert(data === 0);

	var queue_start = this.queue_address << 12;
	var ring_start = queue_start + 16 * this.queue_size;
	var ring_desc_start = ring_start + 4;

	var flags = this.memory.read16(ring_start),
	// index of the next free ring
	idx = this.memory.read16(ring_start + 2);

	dbg_log("idx=" + h(idx, 4), LOG_VIRTIO);
	//dbg_assert(idx < this.queue_size);

	var mask = this.queue_size - 1;
	idx &= mask;

	while(this.last_idx !== idx)
	{
	var desc_idx = this.memory.read16(ring_desc_start + this.last_idx * 2);
	this.handle_descriptor(desc_idx);

	this.last_idx = this.last_idx + 1 & mask;
	}
	});

	this.irq = 0xC;

	/** @const */
	this.pic = cpu.devices.pic;

	/** @const */
	this.bus = bus;

	this.queue_select = 0;
	this.device_status = 0;
	this.isr = 0;

	// these should be stored per queue if there is more than one queue
	this.last_idx = 0;
	this.queue_size = 32;
	this.queue_address = 0;

	/** @const */
	this.memory = cpu.memory;

	for(var i = 0; i < 128; i++)
	{
	io.register_read(0xA814 + i, this, function(port)
	{
	dbg_log("Read device " + h(port), LOG_VIRTIO);
	//dbg_assert(typeof this.device.configspace[port] === "number");

	return this.device.configspace[port];
	}.bind(this, i), undefined, undefined);

	io.register_write(0xA814 + i, this, function(port, data)
	{
	dbg_log("Write device " + h(port) + ": " + h(data, 2), LOG_VIRTIO);
	}.bind(this, i), undefined, undefined);
	}

	// should be generalized to support more devices than just the filesystem
	/** @const */
	this.device = new Virtio9p(filesystem, bus);
	this.device.SendReply = this.device_reply.bind(this);

	this._state_skip = [
	this.memory,
	this.pic,
	this.bus,
	];
	this._state_restore = function()
	{
	this.device.SendReply = this.device_reply.bind(this);
	};
	}

	VirtIO.prototype.handle_descriptor = function(idx)
	{
	var next = idx;
	var desc_start = this.queue_address << 12;

	var buffer_idx = 0;
	var buffers = [];

	do
	{
	var addr = desc_start + next * 16;
	var flags = this.memory.read16(addr + 12);

	if(flags & VRING_DESC_F_WRITE)
	{
	break;
	}

	if(flags & VRING_DESC_F_INDIRECT) {
	dbg_assert(false, "unsupported");
	}

	var addr_low = this.memory.read32s(addr);
	var addr_high = this.memory.read32s(addr + 4);
	var len = this.memory.read32s(addr + 8) >>> 0;

	buffers.push({
	addr_low: addr_low,
	addr_high: addr_high,
	len: len,
	});

	dbg_log("descriptor: addr=" + h(addr_high, 8) + ":" + h(addr_low, 8) +
	" len=" + h(len, 8) + " flags=" + h(flags, 4) + " next=" + h(next, 4), LOG_VIRTIO);

	if(flags & VRING_DESC_F_NEXT)
	{
	next = this.memory.read16(addr + 14);
	dbg_assert(next < this.queue_size);
	}
	else
	{
	next = -1;
	break;
	}
	}
	while(true);

	var buffer_len = -1;
	var pointer = 0;

	var infos = {
	start: idx,
	next: next,
	};

	this.device.ReceiveRequest(infos, function()
	{
	// return one byte

	if(pointer >= buffer_len)
	{
	if(buffer_idx === buffers.length)
	{
	dbg_log("Read more data than descriptor has", LOG_VIRTIO);
	return 0;
	}

	var buf = buffers[buffer_idx++];

	addr_low = buf.addr_low;
	buffer_len = buf.len;
	pointer = 0;
	}

	return this.memory.read8(addr_low + pointer++);
	}.bind(this));
	};

	VirtIO.prototype.device_reply = function(infos)
	{
	if(infos.next === -1)
	{
	dbg_log("Reply to invalid index", LOG_VIRTIO);
	return;
	}

	var mask = this.queue_size - 1;
	var result_length = this.device.replybuffersize;

	var next = infos.next;
	var desc_start = this.queue_address << 12;

	var buffer_idx = 0;
	var buffers = [];

	do
	{
	var addr = desc_start + next * 16;
	var flags = this.memory.read16(addr + 12);

	if((flags & VRING_DESC_F_WRITE) === 0)
	{
	dbg_log("Bug: Readonly ring after writeonly ring", LOG_VIRTIO);
	break;
	}

	var addr_low = this.memory.read32s(addr);
	var addr_high = this.memory.read32s(addr + 4);
	var len = this.memory.read32s(addr + 8) >>> 0;

	buffers.push({
	addr_low: addr_low,
	addr_high: addr_high,
	len: len,
	});

	dbg_log("descriptor: addr=" + h(addr_high, 8) + ":" + h(addr_low, 8) +
	" len=" + h(len, 8) + " flags=" + h(flags, 4) + " next=" + h(next, 4), LOG_VIRTIO);

	if(flags & VRING_DESC_F_NEXT)
	{
	next = this.memory.read16(addr + 14);
	dbg_assert(next < this.queue_size);
	}
	else
	{
	break;
	}
	}
	while(true);

	var buffer_len = -1;
	var pointer = 0;

	for(var i = 0; i < result_length; i++)
	{
	var data = this.device.replybuffer[i];

	if(pointer >= buffer_len)
	{
	if(buffer_idx === buffers.length)
	{
	dbg_log("Write more data than descriptor has", LOG_VIRTIO);
	return 0;
	}

	var buf = buffers[buffer_idx++];

	addr_low = buf.addr_low;
	buffer_len = buf.len;
	pointer = 0;
	}

	this.memory.write8(addr_low + pointer++, data);
	}

	var used_desc_start = (this.queue_address << 12) + 16 * this.queue_size + 4 + 2 * this.queue_size;
	used_desc_start = used_desc_start + 4095 & ~4095;

	var flags = this.memory.read16(used_desc_start);
	var used_idx = this.memory.read16(used_desc_start + 2);
	this.memory.write16(used_desc_start + 2, used_idx + 1);

	dbg_log("used descriptor: addr=" + h(used_desc_start, 8) + " flags=" + h(flags, 4) + " idx=" + h(used_idx, 4), LOG_VIRTIO);

	used_idx &= mask;
	var used_desc_offset = used_desc_start + 4 + used_idx * 8;
	this.memory.write32(used_desc_offset, infos.start);
	this.memory.write32(used_desc_offset + 4, result_length);

	this.isr \|= 1;
	this.pic.push_irq(this.irq);
	};