WIP disk driver

facekapow · facekapow · commit 433d9c4134d6 · 2016-08-21T10:04:03.000-04:00
diff --git a/js/core/disk/disk-driver.js b/js/core/disk/disk-driver.js
@@ -0,0 +1,49 @@
+// Copyright 2016-present runtime.js project authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+const nameHandle = Symbol('name');
+
+class DiskDriver {
+  constructor(name = '') {
+    this[nameHandle] = name;
+    this.onread = null;
+    this.onwrite = null;
+    this.ongetformatinfo = null;
+  }
+  get name() {
+    return this[nameHandle];
+  }
+  read(sector, u8) {
+    if (!this.onread) {
+      throw new Error('driver was not initialized');
+    }
+    return this.onread(sector, u8);
+  }
+  write(sector, u8) {
+    if (!this.onwrite) {
+      throw new Error('driver was not initialized');
+    }
+    return this.onwrite(sector, u8);
+  }
+  get formatInfo() {
+    if (!this.ongetformatinfo) {
+      throw new Error('driver was not initialized');
+    }
+    return this.ongetformatinfo();
+  }
+}
+
+module.exports = DiskDriver;
diff --git a/js/core/disk/drivers.js b/js/core/disk/drivers.js
@@ -0,0 +1,42 @@
+// Copyright 2016-present runtime.js project authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+let defaultDriver = null;
+const availableDrivers = Object.create(null);
+
+function deepFreeze(obj) {
+  const keys = Object.getOwnPropertyNames(obj);
+  for (const key of keys) {
+    const prop = obj[key];
+    if (typeof prop === 'object' && prop !== null) deepFreeze(prop);
+  }
+  return Object.freeze(obj);
+}
+
+exports.addDriver = (driver) => {
+  availableDrivers[driver.name] = driver;
+
+  console.log(`[disk] using driver ${driver.name}`);
+
+  // Set this driver as the default one
+  defaultDriver = driver;
+};
+
+exports.getDefaultDriver = () => defaultDriver;
+exports.getCopyOfDrivers = () => {
+  const copy = Object.create(null);
+  Object.assign(copy, availableDrivers);
+  return deepFreeze(copy);
+};
diff --git a/js/core/disk/index.js b/js/core/disk/index.js
@@ -0,0 +1,36 @@
+// Copyright 2016-present runtime.js project authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+const DiskDriver = require('./disk-driver');
+const { addDriver, getDefaultDriver, getCopyOfDrivers } = require('./drivers');
+
+module.exports = {
+  DiskDriver,
+  addDriver,
+  read(sector, data) {
+    return getDefaultDriver().read(sector, data);
+  },
+  write(sector, data) {
+    return getDefaultDriver().write(sector, data);
+  },
+  get formatInfo() {
+    return getDefaultDriver().formatInfo;
+  },
+  // we expose drivers because the user may want
+  // to access different drives with different drivers
+  get drivers() {
+    return getCopyOfDrivers();
+  }
+};
diff --git a/js/core/index.js b/js/core/index.js
@@ -18,6 +18,7 @@ const { allocator } = require('./resources');
 require('./polyfill');
 
 const random = require('./random');
+const disk = require('./disk');
 const keyboard = require('./keyboard');
 const ps2 = require('./ps2');
 const pci = require('./pci');
@@ -28,6 +29,7 @@ class Runtime {
   constructor() {
     Object.assign(this, {
       random,
+      disk,
       keyboard,
       pci,
       ps2,
diff --git a/js/driver/virtio/blk.js b/js/driver/virtio/blk.js
@@ -0,0 +1,149 @@
+// Copyright 2016-present runtime.js project authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+const VirtioDevice = require('./device');
+const runtime = require('../../core');
+
+const VIRTIO_BLK_T_IN = 0;
+const VIRTIO_BLK_T_OUT = 1;
+
+// not sure how to set uint64
+function setUint64LE(u8, offset, value) {
+  u8[offset] = (value >>> 0);
+  u8[offset + 1] = (value >>> 8);
+  u8[offset + 2] = (value >>> 16);
+  u8[offset + 3] = (value >>> 24);
+  u8[offset + 4] = (value >>> 32);
+  u8[offset + 5] = (value >>> 40);
+  u8[offset + 6] = (value >>> 48);
+  u8[offset + 7] = (value >>> 56);
+}
+
+function initializeBlockDevice(pciDevice) {
+  const ioSpace = pciDevice.getBAR(0).resource;
+  const irq = pciDevice.getIRQ();
+
+  const features = {
+    VIRTIO_BLK_F_SIZE_MAX: 1,
+    VIRTIO_BLK_F_SEG_MAX: 2,
+    VIRTIO_BLK_F_GEOMETRY: 4,
+    VIRTIO_BLK_F_RO: 5,
+    VIRTIO_BLK_F_BLK_SIZE: 6,
+    VIRTIO_BLK_F_FLUSH: 9,
+    VIRTIO_BLK_F_TOPOLOGY: 10,
+    VIRTIO_BLK_F_CONFIG_WCE: 11,
+  };
+
+  const dev = new VirtioDevice('blk', ioSpace);
+  dev.setDriverAck();
+
+  const driverFeatures = {
+    // VIRTIO_BLK_F_SIZE_MAX: true,
+    VIRTIO_BLK_F_SEG_MAX: true,
+    VIRTIO_BLK_F_GEOMETRY: true,
+    VIRTIO_BLK_F_BLK_SIZE: true,
+    VIRTIO_BLK_F_TOPOLOGY: true,
+  };
+
+  const deviceFeatures = dev.readDeviceFeatures(features);
+  debug(JSON.stringify(deviceFeatures));
+
+  if (!dev.writeGuestFeatures(features, driverFeatures, deviceFeatures)) {
+    debug('[virtio] blk driver is unable to start');
+    return;
+  }
+
+  const QUEUE_ID_REQ = 0;
+
+  const reqQueue = dev.queueSetup(QUEUE_ID_REQ);
+  const promiseQueue = [];
+
+  const sectorSize = 512;
+  const sectorCount = dev.blkReadSectorCount();
+  const totalSectorCount = dev.blkReadTotalSectorCount();
+
+  function buildHeader(type, sector) {
+    const u8 = new Uint8Array(16);
+    const view = new DataView(u8.buffer);
+    view.setUint32(0, type, true);
+    view.setUint32(4, 0, true); // priority: low
+    //setUint64LE(u8, 8, sector); // doesn't work as expected
+    view.setFloat64(8, sector, true); // DataView doesn't have setUint64!
+    return u8;
+  }
+
+  const diskDriver = new runtime.disk.DiskDriver('blk');
+  diskDriver.onread = (sector, data) => {
+    return new Promise((resolve, reject) => {
+      if (sector > totalSectorCount) {
+        setImmediate(() => {
+          reject(new RangeError(`sector out of bounds (max: ${totalSectorCount})`));
+        });
+        return;
+      }
+      const status = new Uint8Array(1);
+      promiseQueue.push([resolve, reject, VIRTIO_BLK_T_IN, data, status]);
+      reqQueue.placeBuffers([buildHeader(VIRTIO_BLK_T_IN, sector), data, status], [false, true, true]);
+
+      if (reqQueue.isNotificationNeeded()) {
+        dev.queueNotify(QUEUE_ID_REQ);
+      }
+    });
+  };
+  diskDriver.onwrite = (sector, data) => {
+    return new Promise((resolve, reject) => {
+      const status = new Uint8Array(1);
+      promiseQueue.push([resolve, reject, VIRTIO_BLK_T_OUT, data, status]);
+      reqQueue.placeBuffers([buildHeader(VIRTIO_BLK_T_OUT, sector), data, status], [false, false, true]);
+
+      if (reqQueue.isNotificationNeeded()) {
+        dev.queueNotify(QUEUE_ID_REQ);
+      }
+    });
+  };
+  diskDriver.ongetformatinfo = () => ({
+    sectorSize,
+    sectorCount,
+    totalSectorCount,
+  });
+
+  runtime.disk.addDriver(diskDriver);
+
+  function recvBuffer() {
+    if (promiseQueue.length === 0) {
+      return;
+    }
+    const [resolve, reject, type, data, status] = promiseQueue.shift();
+    setImmediate(() => {
+      if (status[0] !== 0) return reject(new Error('IO error'));
+      if (type === VIRTIO_BLK_T_IN) {
+        resolve(data);
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  irq.on(() => {
+    if (!dev.hasPendingIRQ()) {
+      return;
+    }
+    reqQueue.fetchBuffers(recvBuffer);
+  });
+
+  dev.setDriverReady();
+}
+
+module.exports = initializeBlockDevice;
diff --git a/js/driver/virtio/device.js b/js/driver/virtio/device.js
@@ -47,6 +47,17 @@ class VirtioDevice {
         ioPorts.NETWORK_DEVICE_STATUS = 0x1A; // 16 bit r
       }
 
+      if (deviceType === 'blk') {
+        // Block device
+        ioPorts.BLOCK_TOTAL_SECTOR_COUNT = 0x14; // 64 bit r
+        ioPorts.BLOCK_MAX_SEGMENT_SIZE = 0x1c; // 32 bit r
+        ioPorts.BLOCK_MAX_SEGMENT_COUNT = 0x20; // 32 bit r
+        ioPorts.BLOCK_CYLINDER_COUNT = 0x24; // 16 bit r
+        ioPorts.BLOCK_HEAD_COUNT = 0x26; // 8 bit r
+        ioPorts.BLOCK_SECTOR_COUNT = 0x27; // 8 bit r
+        ioPorts.BLOCK_BLOCK_LENGTH = 0x28; // 32 bit r
+      }
+
       const ports = {};
       for (const portName of Object.keys(ioPorts)) {
         const portOffset = ioPorts[portName];
@@ -128,6 +139,16 @@ class VirtioDevice {
   netReadStatus() {
     return !!(1 & this.io.NETWORK_DEVICE_STATUS.read16());
   }
+
+    // [block device]
+  blkReadSectorCount() {
+    return this.io.BLOCK_SECTOR_COUNT.read8();
+  }
+
+    // [block device]
+  blkReadTotalSectorCount() {
+    return this.io.BLOCK_TOTAL_SECTOR_COUNT.read32();
+  }
 }
 
 module.exports = VirtioDevice;
diff --git a/js/driver/virtio/index.js b/js/driver/virtio/index.js
@@ -14,8 +14,10 @@
 
 'use strict';
 const virtioNet = require('./net');
+const virtioBlk = require('./blk');
 const virtioRNG = require('./rng');
 const VIRTIO_SUBSYSTEM_NETWORK = 1;
+const VIRTIO_SUBSYSTEM_BLOCK = 2;
 const VIRTIO_SUBSYSTEM_RNG = 4;
 const runtime = require('../../core');
 
@@ -26,6 +28,9 @@ const driver = {
     if (subsystemId === VIRTIO_SUBSYSTEM_NETWORK) {
       return virtioNet(pciDevice);
     }
+    if (subsystemId === VIRTIO_SUBSYSTEM_BLOCK) {
+      return virtioBlk(pciDevice);
+    }
     if (subsystemId === VIRTIO_SUBSYSTEM_RNG) {
       return virtioRNG(pciDevice);
     }
diff --git a/js/driver/virtio/vring/descriptor-table.js b/js/driver/virtio/vring/descriptor-table.js
@@ -95,11 +95,17 @@ class DescriptorTable {
     const first = head;
     for (let i = 0; i < count; ++i) {
       const d = buffers[i];
+      let bufWriteOnly = false;
+      if (typeof isWriteOnly === 'boolean') {
+        bufWriteOnly = isWriteOnly;
+      } else {
+        bufWriteOnly = isWriteOnly[i];
+      }
       let flags = 0;
       if (count !== i + 1) {
         flags |= VRING_DESC_F_NEXT;
       }
-      if (isWriteOnly) {
+      if (bufWriteOnly) {
         flags |= VRING_DESC_F_WRITE;
       }
 
