block.cc revision 10390:28bc070b5a86
1/* 2 * Copyright (c) 2014 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions are 16 * met: redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer; 18 * redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution; 21 * neither the name of the copyright holders nor the names of its 22 * contributors may be used to endorse or promote products derived from 23 * this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 * 37 * Authors: Andreas Sandberg 38 */ 39 40#include "debug/VIOBlock.hh" 41#include "dev/virtio/block.hh" 42#include "params/VirtIOBlock.hh" 43#include "sim/system.hh" 44 45VirtIOBlock::VirtIOBlock(Params *params) 46 : VirtIODeviceBase(params, ID_BLOCK, sizeof(Config), 0), 47 qRequests(params->system->physProxy, params->queueSize, *this), 48 image(*params->image) 49{ 50 registerQueue(qRequests); 51 52 config.capacity = image.size(); 53} 54 55 56VirtIOBlock::~VirtIOBlock() 57{ 58} 59 60void 61VirtIOBlock::readConfig(PacketPtr pkt, Addr cfgOffset) 62{ 63 Config cfg_out; 64 cfg_out.capacity = htov_legacy(config.capacity); 65 66 readConfigBlob(pkt, cfgOffset, (uint8_t *)&cfg_out); 67} 68 69VirtIOBlock::Status 70VirtIOBlock::read(const BlkRequest &req, VirtDescriptor *desc_chain, 71 size_t off_data, size_t size) 72{ 73 uint8_t data[size]; 74 uint64_t sector(req.sector); 75 76 DPRINTF(VIOBlock, "Read request starting @ sector %i (size: %i)\n", 77 sector, size); 78 79 if (size % SectorSize != 0) 80 panic("Unexpected request/sector size relationship\n"); 81 82 for (Addr offset = 0; offset < size; offset += SectorSize) { 83 if (image.read(data + offset, sector) != SectorSize) { 84 warn("Failed to read sector %i\n", sector); 85 return S_IOERR; 86 } 87 ++sector; 88 } 89 90 desc_chain->chainWrite(off_data, data, size); 91 92 return S_OK; 93} 94 95VirtIOBlock::Status 96VirtIOBlock::write(const BlkRequest &req, VirtDescriptor *desc_chain, 97 size_t off_data, size_t size) 98{ 99 uint8_t data[size]; 100 uint64_t sector(req.sector); 101 102 DPRINTF(VIOBlock, "Write request starting @ sector %i (size: %i)\n", 103 sector, size); 104 105 if (size % SectorSize != 0) 106 panic("Unexpected request/sector size relationship\n"); 107 108 109 desc_chain->chainRead(off_data, data, size); 110 111 for (Addr offset = 0; offset < size; offset += SectorSize) { 112 if (image.write(data + offset, sector) != SectorSize) { 113 warn("Failed to write sector %i\n", sector); 114 return S_IOERR; 115 } 116 ++sector; 117 } 118 119 return S_OK; 120 121} 122 123void 124VirtIOBlock::RequestQueue::onNotifyDescriptor(VirtDescriptor *desc) 125{ 126 DPRINTF(VIOBlock, "Got input data descriptor (len: %i)\n", 127 desc->size()); 128 /* 129 * Read the request structure and do endian conversion if 130 * necessary. 131 */ 132 BlkRequest req; 133 desc->chainRead(0, (uint8_t *)&req, sizeof(req)); 134 req.type = htov_legacy(req.type); 135 req.sector = htov_legacy(req.sector); 136 137 Status status; 138 const size_t data_size(desc->chainSize() 139 - sizeof(BlkRequest) - sizeof(Status)); 140 141 switch (req.type) { 142 case T_IN: 143 status = parent.read(req, desc, sizeof(BlkRequest), data_size); 144 break; 145 146 case T_OUT: 147 status = parent.write(req, desc, sizeof(BlkRequest), data_size); 148 break; 149 150 case T_FLUSH: 151 status = S_OK; 152 break; 153 154 default: 155 warn("Unsupported IO request: %i\n", req.type); 156 status = S_UNSUPP; 157 break; 158 } 159 160 desc->chainWrite(sizeof(BlkRequest) + data_size, 161 &status, sizeof(status)); 162 163 // Tell the guest that we are done with this descriptor. 164 produceDescriptor(desc, sizeof(BlkRequest) + data_size + sizeof(Status)); 165 parent.kick(); 166} 167 168VirtIOBlock * 169VirtIOBlockParams::create() 170{ 171 return new VirtIOBlock(this); 172} 173