storage/lib/storage.c

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * 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.
 */

#define LOG_TAG "trusty_storage_client"

#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/uio.h>

#include <log/log.h>
#include <trusty/tipc.h>
#include <trusty/lib/storage.h>

#define MAX_CHUNK_SIZE 4040

static inline file_handle_t make_file_handle(storage_session_t s, uint32_t fid)
{
    return ((uint64_t)s << 32) | fid;
}

static inline storage_session_t _to_session(file_handle_t fh)
{
    return (storage_session_t)(fh >> 32);
}

static inline uint32_t _to_handle(file_handle_t fh)
{
    return (uint32_t) fh;
}

static inline uint32_t _to_msg_flags(uint32_t opflags)
{
    uint32_t msg_flags = 0;

    if (opflags & STORAGE_OP_COMPLETE)
        msg_flags |= STORAGE_MSG_FLAG_TRANSACT_COMPLETE;

    return msg_flags;
}

static ssize_t check_response(struct storage_msg *msg, ssize_t res)
{
    if (res < 0)
        return res;

    if ((size_t)res < sizeof(*msg)) {
        ALOGE("invalid msg length (%zd < %zd)\n", res, sizeof(*msg));
        return -EIO;
    }

    ALOGV("cmd 0x%x: server returned %u\n", msg->cmd, msg->result);

    switch(msg->result) {
        case STORAGE_NO_ERROR:
            return res - sizeof(*msg);

        case STORAGE_ERR_NOT_FOUND:
            return -ENOENT;

        case STORAGE_ERR_EXIST:
            return -EEXIST;

        case STORAGE_ERR_NOT_VALID:
            return -EINVAL;

        case STORAGE_ERR_UNIMPLEMENTED:
            ALOGE("cmd 0x%x: is unhandles command\n", msg->cmd);
            return -EINVAL;

        case STORAGE_ERR_ACCESS:
             return -EACCES;

        case STORAGE_ERR_TRANSACT:
             return -EBUSY;

        case STORAGE_ERR_GENERIC:
            ALOGE("cmd 0x%x: internal server error\n", msg->cmd);
            return -EIO;

        default:
            ALOGE("cmd 0x%x: unhandled server response %u\n",
                   msg->cmd, msg->result);
    }

    return -EIO;
}

static ssize_t send_reqv(storage_session_t session,
                         const struct iovec *tx_iovs, uint tx_iovcnt,
                         const struct iovec *rx_iovs, uint rx_iovcnt)
{
    ssize_t rc;

    rc = writev(session, tx_iovs, tx_iovcnt);
    if (rc < 0) {
        rc = -errno;
        ALOGE("failed to send request: %s\n", strerror(errno));
        return rc;
    }

    rc = readv(session, rx_iovs, rx_iovcnt);
    if (rc < 0) {
        rc = -errno;
        ALOGE("failed to recv response: %s\n", strerror(errno));
        return rc;
    }

    return rc;
}

int storage_open_session(const char *device, storage_session_t *session_p,
                         const char *port)
{
    int rc = tipc_connect(device, port);
    if (rc < 0)
        return rc;
    *session_p = (storage_session_t) rc;
    return 0;
}

void storage_close_session(storage_session_t session)
{
    tipc_close(session);
}


int storage_open_file(storage_session_t session, file_handle_t *handle_p, const char *name,
                      uint32_t flags, uint32_t opflags)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_OPEN, .flags = _to_msg_flags(opflags)};
    struct storage_file_open_req req = { .flags = flags };
    struct iovec tx[3] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}, {(void *)name, strlen(name)}};
    struct storage_file_open_resp rsp = { 0 };
    struct iovec rx[2] = {{&msg, sizeof(msg)}, {&rsp, sizeof(rsp)}};

    ssize_t rc = send_reqv(session, tx, 3, rx, 2);
    rc = check_response(&msg, rc);
    if (rc < 0)
        return rc;

    if ((size_t)rc != sizeof(rsp)) {
        ALOGE("%s: invalid response length (%zd != %zd)\n", __func__, rc, sizeof(rsp));
        return -EIO;
    }

    *handle_p = make_file_handle(session, rsp.handle);
    return 0;
}

void storage_close_file(file_handle_t fh)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_CLOSE };
    struct storage_file_close_req req = { .handle = _to_handle(fh)};
    struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
    struct iovec rx[1] = {{&msg, sizeof(msg)}};

    ssize_t rc = send_reqv(_to_session(fh), tx, 2, rx, 1);
    rc = check_response(&msg, rc);
    if (rc < 0) {
        ALOGE("close file failed (%d)\n", (int)rc);
    }
}

int storage_delete_file(storage_session_t session, const char *name, uint32_t opflags)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_DELETE, .flags = _to_msg_flags(opflags)};
    struct storage_file_delete_req req = { .flags = 0, };
    struct iovec tx[3] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}, {(void *)name, strlen(name)}};
    struct iovec rx[1] = {{&msg, sizeof(msg)}};

    ssize_t rc = send_reqv(session, tx, 3, rx, 1);
    return check_response(&msg, rc);
}

static int _read_chunk(file_handle_t fh, storage_off_t off, void *buf, size_t size)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_READ };
    struct storage_file_read_req req = { .handle = _to_handle(fh), .size = size, .offset = off };
    struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
    struct iovec rx[2] = {{&msg, sizeof(msg)}, {buf, size}};

    ssize_t rc = send_reqv(_to_session(fh), tx, 2, rx, 2);
    return check_response(&msg, rc);
}

ssize_t storage_read(file_handle_t fh, storage_off_t off, void *buf, size_t size)
{
    int rc;
    size_t bytes_read = 0;
    size_t chunk = MAX_CHUNK_SIZE;
    uint8_t *ptr = buf;

    while (size) {
        if (chunk > size)
            chunk = size;
        rc = _read_chunk(fh, off, ptr, chunk);
        if (rc < 0)
            return rc;
        if (rc == 0)
            break;
        off += rc;
        ptr += rc;
        bytes_read += rc;
        size -= rc;
    }
    return bytes_read;
}

static int _write_req(file_handle_t fh, storage_off_t off,
                      const void *buf, size_t size, uint32_t msg_flags)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_WRITE, .flags = msg_flags, };
    struct storage_file_write_req req = { .handle = _to_handle(fh), .offset = off, };
    struct iovec tx[3] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}, {(void *)buf, size}};
    struct iovec rx[1] = {{&msg, sizeof(msg)}};

    ssize_t rc = send_reqv(_to_session(fh), tx, 3, rx, 1);
    rc = check_response(&msg, rc);
    return rc < 0 ? rc : size;
}

ssize_t storage_write(file_handle_t fh, storage_off_t off,
                      const void *buf, size_t size, uint32_t opflags)
{
    int rc;
    size_t bytes_written = 0;
    size_t chunk = MAX_CHUNK_SIZE;
    const uint8_t *ptr = buf;
    uint32_t msg_flags = _to_msg_flags(opflags & ~STORAGE_OP_COMPLETE);

    while (size) {
        if (chunk >= size) {
            /* last chunk in sequence */
            chunk = size;
            msg_flags = _to_msg_flags(opflags);
        }
        rc = _write_req(fh, off, ptr, chunk, msg_flags);
        if (rc < 0)
            return rc;
        if ((size_t)rc != chunk) {
            ALOGE("got partial write (%d)\n", (int)rc);
            return -EIO;
        }
        off += chunk;
        ptr += chunk;
        bytes_written += chunk;
        size -= chunk;
    }
    return bytes_written;
}

int storage_set_file_size(file_handle_t fh, storage_off_t file_size, uint32_t opflags)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_SET_SIZE, .flags = _to_msg_flags(opflags)};
    struct storage_file_set_size_req req = { .handle = _to_handle(fh), .size = file_size, };
    struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
    struct iovec rx[1] = {{&msg, sizeof(msg)}};

    ssize_t rc = send_reqv(_to_session(fh), tx, 2, rx, 1);
    return check_response(&msg, rc);
}

int storage_get_file_size(file_handle_t fh, storage_off_t *size_p)
{
    struct storage_msg msg = { .cmd = STORAGE_FILE_GET_SIZE };
    struct storage_file_get_size_req  req = { .handle = _to_handle(fh), };
    struct iovec tx[2] = {{&msg, sizeof(msg)}, {&req, sizeof(req)}};
    struct storage_file_get_size_resp rsp;
    struct iovec rx[2] = {{&msg, sizeof(msg)}, {&rsp, sizeof(rsp)}};

    ssize_t rc = send_reqv(_to_session(fh), tx, 2, rx, 2);
    rc = check_response(&msg, rc);
    if (rc < 0)
        return rc;

    if ((size_t)rc != sizeof(rsp)) {
        ALOGE("%s: invalid response length (%zd != %zd)\n", __func__, rc, sizeof(rsp));
        return -EIO;
    }

    *size_p = rsp.size;
    return 0;
}

int storage_end_transaction(storage_session_t session, bool complete)
{
    struct storage_msg msg = {
        .cmd = STORAGE_END_TRANSACTION,
        .flags = complete ? STORAGE_MSG_FLAG_TRANSACT_COMPLETE : 0,
    };
    struct iovec iov = {&msg, sizeof(msg)};

    ssize_t rc = send_reqv(session, &iov, 1, &iov, 1);
    return check_response(&msg, rc);
}