From 3f7a9348dd365edcfe58b8ecdf293b17a7d779ce Mon Sep 17 00:00:00 2001 From: Andreas Sandberg Date: Sat, 20 Sep 2014 17:17:54 -0400 Subject: dev: Add support for 9p proxying over VirtIO This patch adds support for 9p filesystem proxying over VirtIO. It can currently operate by connecting to a 9p server over a socket (VirtIO9PSocket) or by starting the diod 9p server and connecting over pipe (VirtIO9PDiod). *WARNING*: Checkpoints are currently not supported for systems with 9p proxies! --- src/dev/virtio/fs9p.hh | 371 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 371 insertions(+) create mode 100644 src/dev/virtio/fs9p.hh (limited to 'src/dev/virtio/fs9p.hh') diff --git a/src/dev/virtio/fs9p.hh b/src/dev/virtio/fs9p.hh new file mode 100644 index 000000000..2cbdbc9eb --- /dev/null +++ b/src/dev/virtio/fs9p.hh @@ -0,0 +1,371 @@ +/* + * Copyright (c) 2014 ARM Limited + * All rights reserved + * + * The license below extends only to copyright in the software and shall + * not be construed as granting a license to any other intellectual + * property including but not limited to intellectual property relating + * to a hardware implementation of the functionality of the software + * licensed hereunder. You may use the software subject to the license + * terms below provided that you ensure that this notice is replicated + * unmodified and in its entirety in all distributions of the software, + * modified or unmodified, in source code or in binary form. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Andreas Sandberg + */ + +#ifndef __DEV_VIRTIO_FS9P_HH__ +#define __DEV_VIRTIO_FS9P_HH__ + +#include +#include +#include + +#include "base/pollevent.hh" +#include "dev/virtio/base.hh" + +struct VirtIO9PBaseParams; + +typedef uint8_t P9MsgType; +typedef uint16_t P9Tag; + +struct P9MsgHeader { + /** Length including header */ + uint32_t len; + /** Message type */ + P9MsgType type; + /** Message tag */ + P9Tag tag; +} M5_ATTR_PACKED; + +/** Convert p9 byte order (LE) to host byte order */ +template inline T +p9toh(T v) { return letoh(v); } + +/** Convert host byte order to p9 byte order (LE) */ +template inline T +htop9(T v) { return htole(v); } + +template <> inline P9MsgHeader +p9toh(P9MsgHeader v) +{ + v.len = p9toh(v.len); + v.type = p9toh(v.type); + v.tag = p9toh(v.tag); + return v; +} + +template <> inline P9MsgHeader +htop9(P9MsgHeader v) +{ + v.len = htop9(v.len); + v.type = htop9(v.type); + v.tag = htop9(v.tag); + return v; +} + +/** + * This class implements a VirtIO transport layer for the 9p network + * file system. + * + * The 9p VirtIO transport uses the following queues: + * -# 9p requests and replies + * + * Each 9p request and response is sent in its own descriptor + * chain. The guest initiates a transaction by packing a T message + * (see the 9p spec) into the first part of a descriptor chain. After + * the T message, the guest reserves space for the reply (R message) + * by including one or more writable descriptors. The server replies + * by writing an R message into the writable descriptors and putting + * the chain in the used ring (VirtQueue::produceDescriptor()). + * + * @see https://github.com/rustyrussell/virtio-spec + * @see https://github.com/ericvh/9p-rfc + * @see https://code.google.com/p/diod/wiki/protocol + */ +class VirtIO9PBase : public VirtIODeviceBase +{ + public: + typedef VirtIO9PBaseParams Params; + VirtIO9PBase(Params *params); + virtual ~VirtIO9PBase(); + + void readConfig(PacketPtr pkt, Addr cfgOffset); + + protected: + /** + * VirtIO 9p configuration structure + * + * @note The fields in this structure depend on the features + * exposed to the guest. + */ + struct Config { + uint16_t len; + char tag[]; + } M5_ATTR_PACKED; + + /** Currently active configuration (host byte order) */ + std::unique_ptr config; + + /** VirtIO device ID */ + static const DeviceId ID_9P = 0x09; + + /** @{ + * @name Feature bits + */ + /** Device provides a name of the resource in its configuration */ + static const FeatureBits F_MOUNT_TAG = 0x01; + /** @} */ + + protected: + /** + * Virtqueue for 9p requests + */ + class FSQueue : public VirtQueue + { + public: + FSQueue(PortProxy &proxy, uint16_t size, VirtIO9PBase &_parent) + : VirtQueue(proxy, size), parent(_parent) {} + virtual ~FSQueue() {} + + void onNotifyDescriptor(VirtDescriptor *desc); + + std::string name() const { return parent.name() + ".queue"; } + + protected: + VirtIO9PBase &parent; + }; + + FSQueue queue; + + protected: + /** + * Handle incoming 9p RPC message. + * + * @param header 9p message header. + * @param data Pointer to data in message. + * @param size Size of data (excluding header) + */ + virtual void recvTMsg(const P9MsgHeader &header, const uint8_t *data, size_t size) = 0; + /** + * Send a 9p RPC message reply. + * + * @param header 9p message header. + * @param data Pointer to data in message. + * @param size Size of data (excluding header) + */ + void sendRMsg(const P9MsgHeader &header, const uint8_t *data, size_t size); + + /** + * Dump a 9p RPC message on the debug output + * + * @param header 9p message header. + * @param data Pointer to data in message. + * @param size Size of data (excluding header) + */ + void dumpMsg(const P9MsgHeader &header, const uint8_t *data, size_t size); + + private: + /** + * Map between 9p transaction tags and descriptors where they + * appeared. + * + * When handling asynchronous requests, we need to ensure that + * replies are posted in the same descriptor as queries. The 9p + * RPC protocol uses the tag field in the header to match requests + * and replies, which we use here to find the relevant descriptor. + */ + std::map pendingTransactions; +}; + +struct VirtIO9PProxyParams; + +/** + * VirtIO 9p proxy base class. + * + * This base class provides basic functionality shared by different 9p + * proxy implementations. + */ +class VirtIO9PProxy : public VirtIO9PBase +{ + public: + typedef VirtIO9PProxyParams Params; + VirtIO9PProxy(Params *params); + virtual ~VirtIO9PProxy(); + + void serialize(std::ostream &os); + void unserialize(Checkpoint *cp, const std::string §ion); + + protected: + void recvTMsg(const P9MsgHeader &header, const uint8_t *data, size_t size); + + /** Notification of pending data from server */ + void serverDataReady(); + + /** + * Read data from the server behind the proxy. + * + * @note This method may return read fewer than len bytes. + * + * @param data Memory location to store results in. + * @param len Maximum length to read. + * @return Number of bytes read, -errno on failure. + */ + virtual ssize_t read(uint8_t *data, size_t len) = 0; + /** + * Write data to the server behind the proxy. + * + * @note This method may return write fewer than len bytes. + * + * @param data Pointer to data to write. + * @param len Maximum length to write. + * @return Number of bytes written, -errno on failure. + */ + virtual ssize_t write(const uint8_t *data, size_t len) = 0; + + /** + * Convenience function that reads exactly len bytes. + * + * This method calls read until exactly len number of bytes has + * been read. A read() call is retried if the underlying syscall + * was interrupted. + * + * @param data Memory location to store results in. + * @param len Number of bytes to read. + */ + void readAll(uint8_t *data, size_t len); + /** + * Convenience function that writes exactly len bytes. + * + * This method calls write until exactly len number of bytes has + * been written. A write() call is retried if the underlying + * syscall was interrupted. + * + * @param data Data to write. + * @param len Number of bytes to write. + */ + void writeAll(const uint8_t *data, size_t len); +}; + +struct VirtIO9PDiodParams; + +/** + * VirtIO 9p proxy that communicates with the diod 9p server using + * pipes. + */ +class VirtIO9PDiod : public VirtIO9PProxy +{ + public: + typedef VirtIO9PDiodParams Params; + VirtIO9PDiod(Params *params); + virtual ~VirtIO9PDiod(); + + void startup(); + + protected: + /** + * Start diod and setup the communication pipes. + */ + void startDiod(); + + ssize_t read(uint8_t *data, size_t len); + ssize_t write(const uint8_t *data, size_t len); + + private: + class DiodDataEvent : public PollEvent + { + public: + DiodDataEvent(VirtIO9PDiod &_parent, int fd, int event) + : PollEvent(fd, event), parent(_parent) {} + + virtual ~DiodDataEvent() {}; + + void process(int revent); + + private: + VirtIO9PDiod &parent; + }; + + /** fd for data pipe going to diod (write end) */ + int fd_to_diod; + /** fd for data pipe coming from diod (read end) */ + int fd_from_diod; + + std::unique_ptr dataEvent; + + /** PID of diod process */ + int diod_pid; +}; + +struct VirtIO9PSocketParams; + +/** + * VirtIO 9p proxy that communicates with a 9p server over tcp + * sockets. + */ +class VirtIO9PSocket : public VirtIO9PProxy +{ + public: + typedef VirtIO9PSocketParams Params; + VirtIO9PSocket(Params *params); + virtual ~VirtIO9PSocket(); + + void startup(); + + protected: + /** + * Try to resolve the server name and connect to the 9p server. + */ + void connectSocket(); + + /** 9p server disconnect notification */ + void socketDisconnect(); + + ssize_t read(uint8_t *data, size_t len); + ssize_t write(const uint8_t *data, size_t len); + + private: + class SocketDataEvent : public PollEvent + { + public: + SocketDataEvent(VirtIO9PSocket &_parent, int fd, int event) + : PollEvent(fd, event), parent(_parent) {} + + virtual ~SocketDataEvent() {}; + + void process(int revent); + + private: + VirtIO9PSocket &parent; + }; + + /** Socket connected to the 9p server */ + int fdSocket; + + std::unique_ptr dataEvent; +}; + +#endif // __DEV_VIRTIO_FS9P_HH__ -- cgit v1.2.3