path: root/hw/ufs/lu.c

/*
 * QEMU UFS Logical Unit
 *
 * Copyright (c) 2023 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Written by Jeuk Kim <jeuk20.kim@samsung.com>
 *
 * This code is licensed under the GNU GPL v2 or later.
 */

#include "qemu/osdep.h"
#include "qemu/units.h"
#include "qapi/error.h"
#include "qemu/memalign.h"
#include "hw/scsi/scsi.h"
#include "scsi/constants.h"
#include "sysemu/block-backend.h"
#include "qemu/cutils.h"
#include "trace.h"
#include "ufs.h"

/*
 * The code below handling SCSI commands is copied from hw/scsi/scsi-disk.c,
 * with minor adjustments to make it work for UFS.
 */

#define SCSI_DMA_BUF_SIZE (128 * KiB)
#define SCSI_MAX_INQUIRY_LEN 256
#define SCSI_INQUIRY_DATA_SIZE 36
#define SCSI_MAX_MODE_LEN 256

typedef struct UfsSCSIReq {
    SCSIRequest req;
    /* Both sector and sector_count are in terms of BDRV_SECTOR_SIZE bytes.  */
    uint64_t sector;
    uint32_t sector_count;
    uint32_t buflen;
    bool started;
    bool need_fua_emulation;
    struct iovec iov;
    QEMUIOVector qiov;
    BlockAcctCookie acct;
} UfsSCSIReq;

static void ufs_scsi_free_request(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);

    qemu_vfree(r->iov.iov_base);
}

static void scsi_check_condition(UfsSCSIReq *r, SCSISense sense)
{
    trace_ufs_scsi_check_condition(r->req.tag, sense.key, sense.asc,
                                   sense.ascq);
    scsi_req_build_sense(&r->req, sense);
    scsi_req_complete(&r->req, CHECK_CONDITION);
}

static int ufs_scsi_emulate_vpd_page(SCSIRequest *req, uint8_t *outbuf,
                                     uint32_t outbuf_len)
{
    UfsHc *u = UFS(req->bus->qbus.parent);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, req->dev);
    uint8_t page_code = req->cmd.buf[2];
    int start, buflen = 0;

    if (outbuf_len < SCSI_INQUIRY_DATA_SIZE) {
        return -1;
    }

    outbuf[buflen++] = lu->qdev.type & 0x1f;
    outbuf[buflen++] = page_code;
    outbuf[buflen++] = 0x00;
    outbuf[buflen++] = 0x00;
    start = buflen;

    switch (page_code) {
    case 0x00: /* Supported page codes, mandatory */
    {
        trace_ufs_scsi_emulate_vpd_page_00(req->cmd.xfer);
        outbuf[buflen++] = 0x00; /* list of supported pages (this page) */
        if (u->params.serial) {
            outbuf[buflen++] = 0x80; /* unit serial number */
        }
        outbuf[buflen++] = 0x87; /* mode page policy */
        break;
    }
    case 0x80: /* Device serial number, optional */
    {
        int l;

        if (!u->params.serial) {
            trace_ufs_scsi_emulate_vpd_page_80_not_supported();
            return -1;
        }

        l = strlen(u->params.serial);
        if (l > SCSI_INQUIRY_DATA_SIZE) {
            l = SCSI_INQUIRY_DATA_SIZE;
        }

        trace_ufs_scsi_emulate_vpd_page_80(req->cmd.xfer);
        memcpy(outbuf + buflen, u->params.serial, l);
        buflen += l;
        break;
    }
    case 0x87: /* Mode Page Policy, mandatory */
    {
        trace_ufs_scsi_emulate_vpd_page_87(req->cmd.xfer);
        outbuf[buflen++] = 0x3f; /* apply to all mode pages and subpages */
        outbuf[buflen++] = 0xff;
        outbuf[buflen++] = 0; /* shared */
        outbuf[buflen++] = 0;
        break;
    }
    default:
        return -1;
    }
    /* done with EVPD */
    assert(buflen - start <= 255);
    outbuf[start - 1] = buflen - start;
    return buflen;
}

static int ufs_scsi_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf,
                                    uint32_t outbuf_len)
{
    int buflen = 0;

    if (outbuf_len < SCSI_INQUIRY_DATA_SIZE) {
        return -1;
    }

    if (req->cmd.buf[1] & 0x1) {
        /* Vital product data */
        return ufs_scsi_emulate_vpd_page(req, outbuf, outbuf_len);
    }

    /* Standard INQUIRY data */
    if (req->cmd.buf[2] != 0) {
        return -1;
    }

    /* PAGE CODE == 0 */
    buflen = req->cmd.xfer;
    if (buflen > SCSI_MAX_INQUIRY_LEN) {
        buflen = SCSI_MAX_INQUIRY_LEN;
    }

    if (is_wlun(req->lun)) {
        outbuf[0] = TYPE_WLUN;
    } else {
        outbuf[0] = 0;
    }
    outbuf[1] = 0;

    strpadcpy((char *)&outbuf[16], 16, "QEMU UFS", ' ');
    strpadcpy((char *)&outbuf[8], 8, "QEMU", ' ');

    memset(&outbuf[32], 0, 4);

    outbuf[2] = 0x06; /* SPC-4 */
    outbuf[3] = 0x2;

    if (buflen > SCSI_INQUIRY_DATA_SIZE) {
        outbuf[4] = buflen - 5; /* Additional Length = (Len - 1) - 4 */
    } else {
        /*
         * If the allocation length of CDB is too small, the additional
         * length is not adjusted
         */
        outbuf[4] = SCSI_INQUIRY_DATA_SIZE - 5;
    }

    /* Support TCQ.  */
    outbuf[7] = req->bus->info->tcq ? 0x02 : 0;
    return buflen;
}

static int mode_sense_page(UfsLu *lu, int page, uint8_t **p_outbuf,
                           int page_control)
{
    static const int mode_sense_valid[0x3f] = {
        [MODE_PAGE_CACHING] = 1,
        [MODE_PAGE_R_W_ERROR] = 1,
        [MODE_PAGE_CONTROL] = 1,
    };

    uint8_t *p = *p_outbuf + 2;
    int length;

    assert(page < ARRAY_SIZE(mode_sense_valid));
    if ((mode_sense_valid[page]) == 0) {
        return -1;
    }

    /*
     * If Changeable Values are requested, a mask denoting those mode parameters
     * that are changeable shall be returned. As we currently don't support
     * parameter changes via MODE_SELECT all bits are returned set to zero.
     * The buffer was already memset to zero by the caller of this function.
     */
    switch (page) {
    case MODE_PAGE_CACHING:
        length = 0x12;
        if (page_control == 1 || /* Changeable Values */
            blk_enable_write_cache(lu->qdev.conf.blk)) {
            p[0] = 4; /* WCE */
        }
        break;

    case MODE_PAGE_R_W_ERROR:
        length = 10;
        if (page_control == 1) { /* Changeable Values */
            break;
        }
        p[0] = 0x80; /* Automatic Write Reallocation Enabled */
        break;

    case MODE_PAGE_CONTROL:
        length = 10;
        if (page_control == 1) { /* Changeable Values */
            break;
        }
        p[1] = 0x10; /* Queue Algorithm modifier */
        p[8] = 0xff; /* Busy Timeout Period */
        p[9] = 0xff;
        break;

    default:
        return -1;
    }

    assert(length < 256);
    (*p_outbuf)[0] = page;
    (*p_outbuf)[1] = length;
    *p_outbuf += length + 2;
    return length + 2;
}

static int ufs_scsi_emulate_mode_sense(UfsSCSIReq *r, uint8_t *outbuf)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    bool dbd;
    int page, buflen, ret, page_control;
    uint8_t *p;
    uint8_t dev_specific_param = 0;

    dbd = (r->req.cmd.buf[1] & 0x8) != 0;
    if (!dbd) {
        return -1;
    }

    page = r->req.cmd.buf[2] & 0x3f;
    page_control = (r->req.cmd.buf[2] & 0xc0) >> 6;

    trace_ufs_scsi_emulate_mode_sense((r->req.cmd.buf[0] == MODE_SENSE) ? 6 :
                                                                          10,
                                      page, r->req.cmd.xfer, page_control);
    memset(outbuf, 0, r->req.cmd.xfer);
    p = outbuf;

    if (!blk_is_writable(lu->qdev.conf.blk)) {
        dev_specific_param |= 0x80; /* Readonly.  */
    }

    p[2] = 0; /* Medium type.  */
    p[3] = dev_specific_param;
    p[6] = p[7] = 0; /* Block descriptor length.  */
    p += 8;

    if (page_control == 3) {
        /* Saved Values */
        scsi_check_condition(r, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED));
        return -1;
    }

    if (page == 0x3f) {
        for (page = 0; page <= 0x3e; page++) {
            mode_sense_page(lu, page, &p, page_control);
        }
    } else {
        ret = mode_sense_page(lu, page, &p, page_control);
        if (ret == -1) {
            return -1;
        }
    }

    buflen = p - outbuf;
    /*
     * The mode data length field specifies the length in bytes of the
     * following data that is available to be transferred. The mode data
     * length does not include itself.
     */
    outbuf[0] = ((buflen - 2) >> 8) & 0xff;
    outbuf[1] = (buflen - 2) & 0xff;
    return buflen;
}

/*
 * scsi_handle_rw_error has two return values.  False means that the error
 * must be ignored, true means that the error has been processed and the
 * caller should not do anything else for this request.  Note that
 * scsi_handle_rw_error always manages its reference counts, independent
 * of the return value.
 */
static bool scsi_handle_rw_error(UfsSCSIReq *r, int ret, bool acct_failed)
{
    bool is_read = (r->req.cmd.mode == SCSI_XFER_FROM_DEV);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    SCSISense sense = SENSE_CODE(NO_SENSE);
    int error = 0;
    bool req_has_sense = false;
    BlockErrorAction action;
    int status;

    if (ret < 0) {
        status = scsi_sense_from_errno(-ret, &sense);
        error = -ret;
    } else {
        /* A passthrough command has completed with nonzero status.  */
        status = ret;
        if (status == CHECK_CONDITION) {
            req_has_sense = true;
            error = scsi_sense_buf_to_errno(r->req.sense, sizeof(r->req.sense));
        } else {
            error = EINVAL;
        }
    }

    /*
     * Check whether the error has to be handled by the guest or should
     * rather follow the rerror=/werror= settings.  Guest-handled errors
     * are usually retried immediately, so do not post them to QMP and
     * do not account them as failed I/O.
     */
    if (req_has_sense && scsi_sense_buf_is_guest_recoverable(
                             r->req.sense, sizeof(r->req.sense))) {
        action = BLOCK_ERROR_ACTION_REPORT;
        acct_failed = false;
    } else {
        action = blk_get_error_action(lu->qdev.conf.blk, is_read, error);
        blk_error_action(lu->qdev.conf.blk, action, is_read, error);
    }

    switch (action) {
    case BLOCK_ERROR_ACTION_REPORT:
        if (acct_failed) {
            block_acct_failed(blk_get_stats(lu->qdev.conf.blk), &r->acct);
        }
        if (!req_has_sense && status == CHECK_CONDITION) {
            scsi_req_build_sense(&r->req, sense);
        }
        scsi_req_complete(&r->req, status);
        return true;

    case BLOCK_ERROR_ACTION_IGNORE:
        return false;

    case BLOCK_ERROR_ACTION_STOP:
        scsi_req_retry(&r->req);
        return true;

    default:
        g_assert_not_reached();
    }
}

static bool ufs_scsi_req_check_error(UfsSCSIReq *r, int ret, bool acct_failed)
{
    if (r->req.io_canceled) {
        scsi_req_cancel_complete(&r->req);
        return true;
    }

    if (ret < 0) {
        return scsi_handle_rw_error(r, ret, acct_failed);
    }

    return false;
}

static void scsi_aio_complete(void *opaque, int ret)
{
    UfsSCSIReq *r = (UfsSCSIReq *)opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb != NULL);
    r->req.aiocb = NULL;
    aio_context_acquire(blk_get_aio_context(lu->qdev.conf.blk));
    if (ufs_scsi_req_check_error(r, ret, true)) {
        goto done;
    }

    block_acct_done(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    scsi_req_complete(&r->req, GOOD);

done:
    aio_context_release(blk_get_aio_context(lu->qdev.conf.blk));
    scsi_req_unref(&r->req);
}

static int32_t ufs_scsi_emulate_command(SCSIRequest *req, uint8_t *buf)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, req->dev);
    uint32_t last_block = 0;
    uint8_t *outbuf;
    int buflen;

    switch (req->cmd.buf[0]) {
    case INQUIRY:
    case MODE_SENSE_10:
    case START_STOP:
    case REQUEST_SENSE:
        break;

    default:
        if (!blk_is_available(lu->qdev.conf.blk)) {
            scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
            return 0;
        }
        break;
    }

    /*
     * FIXME: we shouldn't return anything bigger than 4k, but the code
     * requires the buffer to be as big as req->cmd.xfer in several
     * places.  So, do not allow CDBs with a very large ALLOCATION
     * LENGTH.  The real fix would be to modify scsi_read_data and
     * dma_buf_read, so that they return data beyond the buflen
     * as all zeros.
     */
    if (req->cmd.xfer > 65536) {
        goto illegal_request;
    }
    r->buflen = MAX(4096, req->cmd.xfer);

    if (!r->iov.iov_base) {
        r->iov.iov_base = blk_blockalign(lu->qdev.conf.blk, r->buflen);
    }

    outbuf = r->iov.iov_base;
    memset(outbuf, 0, r->buflen);
    switch (req->cmd.buf[0]) {
    case TEST_UNIT_READY:
        assert(blk_is_available(lu->qdev.conf.blk));
        break;
    case INQUIRY:
        buflen = ufs_scsi_emulate_inquiry(req, outbuf, r->buflen);
        if (buflen < 0) {
            goto illegal_request;
        }
        break;
    case MODE_SENSE_10:
        buflen = ufs_scsi_emulate_mode_sense(r, outbuf);
        if (buflen < 0) {
            goto illegal_request;
        }
        break;
    case READ_CAPACITY_10:
        /* The normal LEN field for this command is zero.  */
        memset(outbuf, 0, 8);
        if (lu->qdev.max_lba > 0) {
            last_block = lu->qdev.max_lba - 1;
        };
        outbuf[0] = (last_block >> 24) & 0xff;
        outbuf[1] = (last_block >> 16) & 0xff;
        outbuf[2] = (last_block >> 8) & 0xff;
        outbuf[3] = last_block & 0xff;
        outbuf[4] = (lu->qdev.blocksize >> 24) & 0xff;
        outbuf[5] = (lu->qdev.blocksize >> 16) & 0xff;
        outbuf[6] = (lu->qdev.blocksize >> 8) & 0xff;
        outbuf[7] = lu->qdev.blocksize & 0xff;
        break;
    case REQUEST_SENSE:
        /* Just return "NO SENSE".  */
        buflen = scsi_convert_sense(NULL, 0, outbuf, r->buflen,
                                    (req->cmd.buf[1] & 1) == 0);
        if (buflen < 0) {
            goto illegal_request;
        }
        break;
    case SYNCHRONIZE_CACHE:
        /* The request is used as the AIO opaque value, so add a ref.  */
        scsi_req_ref(&r->req);
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct, 0,
                         BLOCK_ACCT_FLUSH);
        r->req.aiocb = blk_aio_flush(lu->qdev.conf.blk, scsi_aio_complete, r);
        return 0;
    case VERIFY_10:
        trace_ufs_scsi_emulate_command_VERIFY((req->cmd.buf[1] >> 1) & 3);
        if (req->cmd.buf[1] & 6) {
            goto illegal_request;
        }
        break;
    case SERVICE_ACTION_IN_16:
        /* Service Action In subcommands. */
        if ((req->cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) {
            trace_ufs_scsi_emulate_command_SAI_16();
            memset(outbuf, 0, req->cmd.xfer);

            if (lu->qdev.max_lba > 0) {
                last_block = lu->qdev.max_lba - 1;
            };
            outbuf[0] = 0;
            outbuf[1] = 0;
            outbuf[2] = 0;
            outbuf[3] = 0;
            outbuf[4] = (last_block >> 24) & 0xff;
            outbuf[5] = (last_block >> 16) & 0xff;
            outbuf[6] = (last_block >> 8) & 0xff;
            outbuf[7] = last_block & 0xff;
            outbuf[8] = (lu->qdev.blocksize >> 24) & 0xff;
            outbuf[9] = (lu->qdev.blocksize >> 16) & 0xff;
            outbuf[10] = (lu->qdev.blocksize >> 8) & 0xff;
            outbuf[11] = lu->qdev.blocksize & 0xff;
            outbuf[12] = 0;
            outbuf[13] = get_physical_block_exp(&lu->qdev.conf);

            if (lu->unit_desc.provisioning_type == 2 ||
                lu->unit_desc.provisioning_type == 3) {
                outbuf[14] = 0x80;
            }
            /* Protection, exponent and lowest lba field left blank. */
            break;
        }
        trace_ufs_scsi_emulate_command_SAI_unsupported();
        goto illegal_request;
    case MODE_SELECT_10:
        trace_ufs_scsi_emulate_command_MODE_SELECT_10(r->req.cmd.xfer);
        break;
    case START_STOP:
        /*
         * TODO: START_STOP is not yet implemented. It always returns success.
         * Revisit it when ufs power management is implemented.
         */
        trace_ufs_scsi_emulate_command_START_STOP();
        break;
    case FORMAT_UNIT:
        trace_ufs_scsi_emulate_command_FORMAT_UNIT();
        break;
    case SEND_DIAGNOSTIC:
        trace_ufs_scsi_emulate_command_SEND_DIAGNOSTIC();
        break;
    default:
        trace_ufs_scsi_emulate_command_UNKNOWN(buf[0],
                                               scsi_command_name(buf[0]));
        scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE));
        return 0;
    }
    assert(!r->req.aiocb);
    r->iov.iov_len = MIN(r->buflen, req->cmd.xfer);
    if (r->iov.iov_len == 0) {
        scsi_req_complete(&r->req, GOOD);
    }
    if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
        assert(r->iov.iov_len == req->cmd.xfer);
        return -r->iov.iov_len;
    } else {
        return r->iov.iov_len;
    }

illegal_request:
    if (r->req.status == -1) {
        scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
    }
    return 0;
}

static void ufs_scsi_emulate_read_data(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);
    int buflen = r->iov.iov_len;

    if (buflen) {
        trace_ufs_scsi_emulate_read_data(buflen);
        r->iov.iov_len = 0;
        r->started = true;
        scsi_req_data(&r->req, buflen);
        return;
    }

    /* This also clears the sense buffer for REQUEST SENSE.  */
    scsi_req_complete(&r->req, GOOD);
}

static int ufs_scsi_check_mode_select(UfsLu *lu, int page, uint8_t *inbuf,
                                      int inlen)
{
    uint8_t mode_current[SCSI_MAX_MODE_LEN];
    uint8_t mode_changeable[SCSI_MAX_MODE_LEN];
    uint8_t *p;
    int len, expected_len, changeable_len, i;

    /*
     * The input buffer does not include the page header, so it is
     * off by 2 bytes.
     */
    expected_len = inlen + 2;
    if (expected_len > SCSI_MAX_MODE_LEN) {
        return -1;
    }

    /* MODE_PAGE_ALLS is only valid for MODE SENSE commands */
    if (page == MODE_PAGE_ALLS) {
        return -1;
    }

    p = mode_current;
    memset(mode_current, 0, inlen + 2);
    len = mode_sense_page(lu, page, &p, 0);
    if (len < 0 || len != expected_len) {
        return -1;
    }

    p = mode_changeable;
    memset(mode_changeable, 0, inlen + 2);
    changeable_len = mode_sense_page(lu, page, &p, 1);
    assert(changeable_len == len);

    /*
     * Check that unchangeable bits are the same as what MODE SENSE
     * would return.
     */
    for (i = 2; i < len; i++) {
        if (((mode_current[i] ^ inbuf[i - 2]) & ~mode_changeable[i]) != 0) {
            return -1;
        }
    }
    return 0;
}

static void ufs_scsi_apply_mode_select(UfsLu *lu, int page, uint8_t *p)
{
    switch (page) {
    case MODE_PAGE_CACHING:
        blk_set_enable_write_cache(lu->qdev.conf.blk, (p[0] & 4) != 0);
        break;

    default:
        break;
    }
}

static int mode_select_pages(UfsSCSIReq *r, uint8_t *p, int len, bool change)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    while (len > 0) {
        int page, page_len;

        page = p[0] & 0x3f;
        if (p[0] & 0x40) {
            goto invalid_param;
        } else {
            if (len < 2) {
                goto invalid_param_len;
            }
            page_len = p[1];
            p += 2;
            len -= 2;
        }

        if (page_len > len) {
            goto invalid_param_len;
        }

        if (!change) {
            if (ufs_scsi_check_mode_select(lu, page, p, page_len) < 0) {
                goto invalid_param;
            }
        } else {
            ufs_scsi_apply_mode_select(lu, page, p);
        }

        p += page_len;
        len -= page_len;
    }
    return 0;

invalid_param:
    scsi_check_condition(r, SENSE_CODE(INVALID_PARAM));
    return -1;

invalid_param_len:
    scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN));
    return -1;
}

static void ufs_scsi_emulate_mode_select(UfsSCSIReq *r, uint8_t *inbuf)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    uint8_t *p = inbuf;
    int len = r->req.cmd.xfer;
    int hdr_len = 8;
    int bd_len;
    int pass;

    /* We only support PF=1, SP=0.  */
    if ((r->req.cmd.buf[1] & 0x11) != 0x10) {
        goto invalid_field;
    }

    if (len < hdr_len) {
        goto invalid_param_len;
    }

    bd_len = lduw_be_p(&p[6]);
    if (bd_len != 0) {
        goto invalid_param;
    }

    len -= hdr_len;
    p += hdr_len;

    /* Ensure no change is made if there is an error!  */
    for (pass = 0; pass < 2; pass++) {
        if (mode_select_pages(r, p, len, pass == 1) < 0) {
            assert(pass == 0);
            return;
        }
    }

    if (!blk_enable_write_cache(lu->qdev.conf.blk)) {
        /* The request is used as the AIO opaque value, so add a ref.  */
        scsi_req_ref(&r->req);
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct, 0,
                         BLOCK_ACCT_FLUSH);
        r->req.aiocb = blk_aio_flush(lu->qdev.conf.blk, scsi_aio_complete, r);
        return;
    }

    scsi_req_complete(&r->req, GOOD);
    return;

invalid_param:
    scsi_check_condition(r, SENSE_CODE(INVALID_PARAM));
    return;

invalid_param_len:
    scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN));
    return;

invalid_field:
    scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
}

/* block_num and nb_blocks expected to be in qdev blocksize */
static inline bool check_lba_range(UfsLu *lu, uint64_t block_num,
                                   uint32_t nb_blocks)
{
    /*
     * The first line tests that no overflow happens when computing the last
     * block.  The second line tests that the last accessed block is in
     * range.
     *
     * Careful, the computations should not underflow for nb_blocks == 0,
     * and a 0-block read to the first LBA beyond the end of device is
     * valid.
     */
    return (block_num <= block_num + nb_blocks &&
            block_num + nb_blocks <= lu->qdev.max_lba + 1);
}

static void ufs_scsi_emulate_write_data(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);

    if (r->iov.iov_len) {
        int buflen = r->iov.iov_len;
        trace_ufs_scsi_emulate_write_data(buflen);
        r->iov.iov_len = 0;
        scsi_req_data(&r->req, buflen);
        return;
    }

    switch (req->cmd.buf[0]) {
    case MODE_SELECT_10:
        /* This also clears the sense buffer for REQUEST SENSE.  */
        ufs_scsi_emulate_mode_select(r, r->iov.iov_base);
        break;
    default:
        abort();
    }
}

/* Return a pointer to the data buffer.  */
static uint8_t *ufs_scsi_get_buf(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);

    return (uint8_t *)r->iov.iov_base;
}

static int32_t ufs_scsi_dma_command(SCSIRequest *req, uint8_t *buf)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, req->dev);
    uint32_t len;
    uint8_t command;

    command = buf[0];

    if (!blk_is_available(lu->qdev.conf.blk)) {
        scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
        return 0;
    }

    len = scsi_data_cdb_xfer(r->req.cmd.buf);
    switch (command) {
    case READ_6:
    case READ_10:
        trace_ufs_scsi_dma_command_READ(r->req.cmd.lba, len);
        if (r->req.cmd.buf[1] & 0xe0) {
            goto illegal_request;
        }
        if (!check_lba_range(lu, r->req.cmd.lba, len)) {
            goto illegal_lba;
        }
        r->sector = r->req.cmd.lba * (lu->qdev.blocksize / BDRV_SECTOR_SIZE);
        r->sector_count = len * (lu->qdev.blocksize / BDRV_SECTOR_SIZE);
        break;
    case WRITE_6:
    case WRITE_10:
        trace_ufs_scsi_dma_command_WRITE(r->req.cmd.lba, len);
        if (!blk_is_writable(lu->qdev.conf.blk)) {
            scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));
            return 0;
        }
        if (r->req.cmd.buf[1] & 0xe0) {
            goto illegal_request;
        }
        if (!check_lba_range(lu, r->req.cmd.lba, len)) {
            goto illegal_lba;
        }
        r->sector = r->req.cmd.lba * (lu->qdev.blocksize / BDRV_SECTOR_SIZE);
        r->sector_count = len * (lu->qdev.blocksize / BDRV_SECTOR_SIZE);
        break;
    default:
        abort();
    illegal_request:
        scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
        return 0;
    illegal_lba:
        scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
        return 0;
    }
    r->need_fua_emulation = ((r->req.cmd.buf[1] & 8) != 0);
    if (r->sector_count == 0) {
        scsi_req_complete(&r->req, GOOD);
    }
    assert(r->iov.iov_len == 0);
    if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
        return -r->sector_count * BDRV_SECTOR_SIZE;
    } else {
        return r->sector_count * BDRV_SECTOR_SIZE;
    }
}

static void scsi_write_do_fua(UfsSCSIReq *r)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb == NULL);
    assert(!r->req.io_canceled);

    if (r->need_fua_emulation) {
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct, 0,
                         BLOCK_ACCT_FLUSH);
        r->req.aiocb = blk_aio_flush(lu->qdev.conf.blk, scsi_aio_complete, r);
        return;
    }

    scsi_req_complete(&r->req, GOOD);
    scsi_req_unref(&r->req);
}

static void scsi_dma_complete_noio(UfsSCSIReq *r, int ret)
{
    assert(r->req.aiocb == NULL);
    if (ufs_scsi_req_check_error(r, ret, false)) {
        goto done;
    }

    r->sector += r->sector_count;
    r->sector_count = 0;
    if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
        scsi_write_do_fua(r);
        return;
    } else {
        scsi_req_complete(&r->req, GOOD);
    }

done:
    scsi_req_unref(&r->req);
}

static void scsi_dma_complete(void *opaque, int ret)
{
    UfsSCSIReq *r = (UfsSCSIReq *)opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb != NULL);
    r->req.aiocb = NULL;

    aio_context_acquire(blk_get_aio_context(lu->qdev.conf.blk));
    if (ret < 0) {
        block_acct_failed(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    } else {
        block_acct_done(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    }
    scsi_dma_complete_noio(r, ret);
    aio_context_release(blk_get_aio_context(lu->qdev.conf.blk));
}

static BlockAIOCB *scsi_dma_readv(int64_t offset, QEMUIOVector *iov,
                                  BlockCompletionFunc *cb, void *cb_opaque,
                                  void *opaque)
{
    UfsSCSIReq *r = opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    return blk_aio_preadv(lu->qdev.conf.blk, offset, iov, 0, cb, cb_opaque);
}

static void scsi_init_iovec(UfsSCSIReq *r, size_t size)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    if (!r->iov.iov_base) {
        r->buflen = size;
        r->iov.iov_base = blk_blockalign(lu->qdev.conf.blk, r->buflen);
    }
    r->iov.iov_len = MIN(r->sector_count * BDRV_SECTOR_SIZE, r->buflen);
    qemu_iovec_init_external(&r->qiov, &r->iov, 1);
}

static void scsi_read_complete_noio(UfsSCSIReq *r, int ret)
{
    uint32_t n;

    assert(r->req.aiocb == NULL);
    if (ufs_scsi_req_check_error(r, ret, false)) {
        goto done;
    }

    n = r->qiov.size / BDRV_SECTOR_SIZE;
    r->sector += n;
    r->sector_count -= n;
    scsi_req_data(&r->req, r->qiov.size);

done:
    scsi_req_unref(&r->req);
}

static void scsi_read_complete(void *opaque, int ret)
{
    UfsSCSIReq *r = (UfsSCSIReq *)opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb != NULL);
    r->req.aiocb = NULL;
    trace_ufs_scsi_read_data_count(r->sector_count);
    aio_context_acquire(blk_get_aio_context(lu->qdev.conf.blk));
    if (ret < 0) {
        block_acct_failed(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    } else {
        block_acct_done(blk_get_stats(lu->qdev.conf.blk), &r->acct);
        trace_ufs_scsi_read_complete(r->req.tag, r->qiov.size);
    }
    scsi_read_complete_noio(r, ret);
    aio_context_release(blk_get_aio_context(lu->qdev.conf.blk));
}

/* Actually issue a read to the block device.  */
static void scsi_do_read(UfsSCSIReq *r, int ret)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb == NULL);
    if (ufs_scsi_req_check_error(r, ret, false)) {
        goto done;
    }

    /* The request is used as the AIO opaque value, so add a ref.  */
    scsi_req_ref(&r->req);

    if (r->req.sg) {
        dma_acct_start(lu->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_READ);
        r->req.residual -= r->req.sg->size;
        r->req.aiocb = dma_blk_io(
            blk_get_aio_context(lu->qdev.conf.blk), r->req.sg,
            r->sector << BDRV_SECTOR_BITS, BDRV_SECTOR_SIZE, scsi_dma_readv, r,
            scsi_dma_complete, r, DMA_DIRECTION_FROM_DEVICE);
    } else {
        scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct,
                         r->qiov.size, BLOCK_ACCT_READ);
        r->req.aiocb = scsi_dma_readv(r->sector << BDRV_SECTOR_BITS, &r->qiov,
                                      scsi_read_complete, r, r);
    }

done:
    scsi_req_unref(&r->req);
}

static void scsi_do_read_cb(void *opaque, int ret)
{
    UfsSCSIReq *r = (UfsSCSIReq *)opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb != NULL);
    r->req.aiocb = NULL;

    aio_context_acquire(blk_get_aio_context(lu->qdev.conf.blk));
    if (ret < 0) {
        block_acct_failed(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    } else {
        block_acct_done(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    }
    scsi_do_read(opaque, ret);
    aio_context_release(blk_get_aio_context(lu->qdev.conf.blk));
}

/* Read more data from scsi device into buffer.  */
static void scsi_read_data(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    bool first;

    trace_ufs_scsi_read_data_count(r->sector_count);
    if (r->sector_count == 0) {
        /* This also clears the sense buffer for REQUEST SENSE.  */
        scsi_req_complete(&r->req, GOOD);
        return;
    }

    /* No data transfer may already be in progress */
    assert(r->req.aiocb == NULL);

    /* The request is used as the AIO opaque value, so add a ref.  */
    scsi_req_ref(&r->req);
    if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
        trace_ufs_scsi_read_data_invalid();
        scsi_read_complete_noio(r, -EINVAL);
        return;
    }

    if (!blk_is_available(req->dev->conf.blk)) {
        scsi_read_complete_noio(r, -ENOMEDIUM);
        return;
    }

    first = !r->started;
    r->started = true;
    if (first && r->need_fua_emulation) {
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct, 0,
                         BLOCK_ACCT_FLUSH);
        r->req.aiocb = blk_aio_flush(lu->qdev.conf.blk, scsi_do_read_cb, r);
    } else {
        scsi_do_read(r, 0);
    }
}

static void scsi_write_complete_noio(UfsSCSIReq *r, int ret)
{
    uint32_t n;

    assert(r->req.aiocb == NULL);
    if (ufs_scsi_req_check_error(r, ret, false)) {
        goto done;
    }

    n = r->qiov.size / BDRV_SECTOR_SIZE;
    r->sector += n;
    r->sector_count -= n;
    if (r->sector_count == 0) {
        scsi_write_do_fua(r);
        return;
    } else {
        scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
        trace_ufs_scsi_write_complete_noio(r->req.tag, r->qiov.size);
        scsi_req_data(&r->req, r->qiov.size);
    }

done:
    scsi_req_unref(&r->req);
}

static void scsi_write_complete(void *opaque, int ret)
{
    UfsSCSIReq *r = (UfsSCSIReq *)opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    assert(r->req.aiocb != NULL);
    r->req.aiocb = NULL;

    aio_context_acquire(blk_get_aio_context(lu->qdev.conf.blk));
    if (ret < 0) {
        block_acct_failed(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    } else {
        block_acct_done(blk_get_stats(lu->qdev.conf.blk), &r->acct);
    }
    scsi_write_complete_noio(r, ret);
    aio_context_release(blk_get_aio_context(lu->qdev.conf.blk));
}

static BlockAIOCB *scsi_dma_writev(int64_t offset, QEMUIOVector *iov,
                                   BlockCompletionFunc *cb, void *cb_opaque,
                                   void *opaque)
{
    UfsSCSIReq *r = opaque;
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);
    return blk_aio_pwritev(lu->qdev.conf.blk, offset, iov, 0, cb, cb_opaque);
}

static void scsi_write_data(SCSIRequest *req)
{
    UfsSCSIReq *r = DO_UPCAST(UfsSCSIReq, req, req);
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, r->req.dev);

    /* No data transfer may already be in progress */
    assert(r->req.aiocb == NULL);

    /* The request is used as the AIO opaque value, so add a ref.  */
    scsi_req_ref(&r->req);
    if (r->req.cmd.mode != SCSI_XFER_TO_DEV) {
        trace_ufs_scsi_write_data_invalid();
        scsi_write_complete_noio(r, -EINVAL);
        return;
    }

    if (!r->req.sg && !r->qiov.size) {
        /* Called for the first time.  Ask the driver to send us more data.  */
        r->started = true;
        scsi_write_complete_noio(r, 0);
        return;
    }
    if (!blk_is_available(req->dev->conf.blk)) {
        scsi_write_complete_noio(r, -ENOMEDIUM);
        return;
    }

    if (r->req.sg) {
        dma_acct_start(lu->qdev.conf.blk, &r->acct, r->req.sg,
                       BLOCK_ACCT_WRITE);
        r->req.residual -= r->req.sg->size;
        r->req.aiocb = dma_blk_io(
            blk_get_aio_context(lu->qdev.conf.blk), r->req.sg,
            r->sector << BDRV_SECTOR_BITS, BDRV_SECTOR_SIZE, scsi_dma_writev, r,
            scsi_dma_complete, r, DMA_DIRECTION_TO_DEVICE);
    } else {
        block_acct_start(blk_get_stats(lu->qdev.conf.blk), &r->acct,
                         r->qiov.size, BLOCK_ACCT_WRITE);
        r->req.aiocb = scsi_dma_writev(r->sector << BDRV_SECTOR_BITS, &r->qiov,
                                       scsi_write_complete, r, r);
    }
}

static const SCSIReqOps ufs_scsi_emulate_reqops = {
    .size = sizeof(UfsSCSIReq),
    .free_req = ufs_scsi_free_request,
    .send_command = ufs_scsi_emulate_command,
    .read_data = ufs_scsi_emulate_read_data,
    .write_data = ufs_scsi_emulate_write_data,
    .get_buf = ufs_scsi_get_buf,
};

static const SCSIReqOps ufs_scsi_dma_reqops = {
    .size = sizeof(UfsSCSIReq),
    .free_req = ufs_scsi_free_request,
    .send_command = ufs_scsi_dma_command,
    .read_data = scsi_read_data,
    .write_data = scsi_write_data,
    .get_buf = ufs_scsi_get_buf,
};

/*
 * Following commands are not yet supported
 * PRE_FETCH(10),
 * UNMAP,
 * WRITE_BUFFER, READ_BUFFER,
 * SECURITY_PROTOCOL_IN, SECURITY_PROTOCOL_OUT
 */
static const SCSIReqOps *const ufs_scsi_reqops_dispatch[256] = {
    [TEST_UNIT_READY] = &ufs_scsi_emulate_reqops,
    [INQUIRY] = &ufs_scsi_emulate_reqops,
    [MODE_SENSE_10] = &ufs_scsi_emulate_reqops,
    [START_STOP] = &ufs_scsi_emulate_reqops,
    [READ_CAPACITY_10] = &ufs_scsi_emulate_reqops,
    [REQUEST_SENSE] = &ufs_scsi_emulate_reqops,
    [SYNCHRONIZE_CACHE] = &ufs_scsi_emulate_reqops,
    [MODE_SELECT_10] = &ufs_scsi_emulate_reqops,
    [VERIFY_10] = &ufs_scsi_emulate_reqops,
    [FORMAT_UNIT] = &ufs_scsi_emulate_reqops,
    [SERVICE_ACTION_IN_16] = &ufs_scsi_emulate_reqops,
    [SEND_DIAGNOSTIC] = &ufs_scsi_emulate_reqops,

    [READ_6] = &ufs_scsi_dma_reqops,
    [READ_10] = &ufs_scsi_dma_reqops,
    [WRITE_6] = &ufs_scsi_dma_reqops,
    [WRITE_10] = &ufs_scsi_dma_reqops,
};

static SCSIRequest *scsi_new_request(SCSIDevice *dev, uint32_t tag,
                                     uint32_t lun, uint8_t *buf,
                                     void *hba_private)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, dev);
    SCSIRequest *req;
    const SCSIReqOps *ops;
    uint8_t command;

    command = buf[0];
    ops = ufs_scsi_reqops_dispatch[command];
    if (!ops) {
        ops = &ufs_scsi_emulate_reqops;
    }
    req = scsi_req_alloc(ops, &lu->qdev, tag, lun, hba_private);

    return req;
}

static Property ufs_lu_props[] = {
    DEFINE_PROP_DRIVE("drive", UfsLu, qdev.conf.blk),
    DEFINE_PROP_END_OF_LIST(),
};

static bool ufs_lu_brdv_init(UfsLu *lu, Error **errp)
{
    SCSIDevice *dev = &lu->qdev;
    bool read_only;

    if (!lu->qdev.conf.blk) {
        error_setg(errp, "drive property not set");
        return false;
    }

    if (!blkconf_blocksizes(&lu->qdev.conf, errp)) {
        return false;
    }

    if (blk_get_aio_context(lu->qdev.conf.blk) != qemu_get_aio_context() &&
        !lu->qdev.hba_supports_iothread) {
        error_setg(errp, "HBA does not support iothreads");
        return false;
    }

    read_only = !blk_supports_write_perm(lu->qdev.conf.blk);

    if (!blkconf_apply_backend_options(&dev->conf, read_only,
                                       dev->type == TYPE_DISK, errp)) {
        return false;
    }

    if (blk_is_sg(lu->qdev.conf.blk)) {
        error_setg(errp, "unwanted /dev/sg*");
        return false;
    }

    blk_iostatus_enable(lu->qdev.conf.blk);
    return true;
}

static bool ufs_add_lu(UfsHc *u, UfsLu *lu, Error **errp)
{
    BlockBackend *blk = lu->qdev.conf.blk;
    int64_t brdv_len = blk_getlength(blk);
    uint64_t raw_dev_cap =
        be64_to_cpu(u->geometry_desc.total_raw_device_capacity);

    if (u->device_desc.number_lu >= UFS_MAX_LUS) {
        error_setg(errp, "ufs host controller has too many logical units.");
        return false;
    }

    if (u->lus[lu->lun] != NULL) {
        error_setg(errp, "ufs logical unit %d already exists.", lu->lun);
        return false;
    }

    u->lus[lu->lun] = lu;
    u->device_desc.number_lu++;
    raw_dev_cap += (brdv_len >> UFS_GEOMETRY_CAPACITY_SHIFT);
    u->geometry_desc.total_raw_device_capacity = cpu_to_be64(raw_dev_cap);
    return true;
}

static inline uint8_t ufs_log2(uint64_t input)
{
    int log = 0;
    while (input >>= 1) {
        log++;
    }
    return log;
}

static void ufs_init_lu(UfsLu *lu)
{
    BlockBackend *blk = lu->qdev.conf.blk;
    int64_t brdv_len = blk_getlength(blk);

    lu->lun = lu->qdev.lun;
    memset(&lu->unit_desc, 0, sizeof(lu->unit_desc));
    lu->unit_desc.length = sizeof(UnitDescriptor);
    lu->unit_desc.descriptor_idn = UFS_QUERY_DESC_IDN_UNIT;
    lu->unit_desc.lu_enable = 0x01;
    lu->unit_desc.logical_block_size = ufs_log2(lu->qdev.blocksize);
    lu->unit_desc.unit_index = lu->qdev.lun;
    lu->unit_desc.logical_block_count =
        cpu_to_be64(brdv_len / (1 << lu->unit_desc.logical_block_size));
}

static bool ufs_lu_check_constraints(UfsLu *lu, Error **errp)
{
    if (!lu->qdev.conf.blk) {
        error_setg(errp, "drive property not set");
        return false;
    }

    if (lu->qdev.channel != 0) {
        error_setg(errp, "ufs logical unit does not support channel");
        return false;
    }

    if (lu->qdev.lun >= UFS_MAX_LUS) {
        error_setg(errp, "lun must be between 1 and %d", UFS_MAX_LUS - 1);
        return false;
    }

    return true;
}

static void ufs_lu_realize(SCSIDevice *dev, Error **errp)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, dev);
    BusState *s = qdev_get_parent_bus(&dev->qdev);
    UfsHc *u = UFS(s->parent);
    AioContext *ctx = NULL;
    uint64_t nb_sectors, nb_blocks;

    if (!ufs_lu_check_constraints(lu, errp)) {
        return;
    }

    if (lu->qdev.conf.blk) {
        ctx = blk_get_aio_context(lu->qdev.conf.blk);
        aio_context_acquire(ctx);
        if (!blkconf_blocksizes(&lu->qdev.conf, errp)) {
            goto out;
        }
    }
    lu->qdev.blocksize = UFS_BLOCK_SIZE;
    blk_get_geometry(lu->qdev.conf.blk, &nb_sectors);
    nb_blocks = nb_sectors / (lu->qdev.blocksize / BDRV_SECTOR_SIZE);
    if (nb_blocks > UINT32_MAX) {
        nb_blocks = UINT32_MAX;
    }
    lu->qdev.max_lba = nb_blocks;
    lu->qdev.type = TYPE_DISK;

    ufs_init_lu(lu);
    if (!ufs_add_lu(u, lu, errp)) {
        goto out;
    }

    ufs_lu_brdv_init(lu, errp);
out:
    if (ctx) {
        aio_context_release(ctx);
    }
}

static void ufs_lu_unrealize(SCSIDevice *dev)
{
    UfsLu *lu = DO_UPCAST(UfsLu, qdev, dev);

    blk_drain(lu->qdev.conf.blk);
}

static void ufs_wlu_realize(DeviceState *qdev, Error **errp)
{
    UfsWLu *wlu = UFSWLU(qdev);
    SCSIDevice *dev = &wlu->qdev;

    if (!is_wlun(dev->lun)) {
        error_setg(errp, "not well-known logical unit number");
        return;
    }

    QTAILQ_INIT(&dev->requests);
}

static void ufs_lu_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);
    SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(oc);

    sc->realize = ufs_lu_realize;
    sc->unrealize = ufs_lu_unrealize;
    sc->alloc_req = scsi_new_request;
    dc->bus_type = TYPE_UFS_BUS;
    device_class_set_props(dc, ufs_lu_props);
    dc->desc = "Virtual UFS logical unit";
}

static void ufs_wlu_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);
    SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(oc);

    /*
     * The realize() function of TYPE_SCSI_DEVICE causes a segmentation fault
     * if a block drive does not exist. Define a new realize function for
     * well-known LUs that do not have a block drive.
     */
    dc->realize = ufs_wlu_realize;
    sc->alloc_req = scsi_new_request;
    dc->bus_type = TYPE_UFS_BUS;
    dc->desc = "Virtual UFS well-known logical unit";
}

static const TypeInfo ufs_lu_info = {
    .name = TYPE_UFS_LU,
    .parent = TYPE_SCSI_DEVICE,
    .class_init = ufs_lu_class_init,
    .instance_size = sizeof(UfsLu),
};

static const TypeInfo ufs_wlu_info = {
    .name = TYPE_UFS_WLU,
    .parent = TYPE_SCSI_DEVICE,
    .class_init = ufs_wlu_class_init,
    .instance_size = sizeof(UfsWLu),
};

static void ufs_lu_register_types(void)
{
    type_register_static(&ufs_lu_info);
    type_register_static(&ufs_wlu_info);
}

type_init(ufs_lu_register_types)