Atmosphere/exosphere/program/source/smc/secmon_smc_result.cpp

/*
 * Copyright (c) Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <exosphere.hpp>
#include "../secmon_error.hpp"
#include "../secmon_page_mapper.hpp"
#include "secmon_smc_result.hpp"

namespace ams::secmon::smc {

    namespace {

        constinit u64              g_async_key     = InvalidAsyncKey;
        constinit GetResultHandler g_async_handler = nullptr;

        u64 GenerateRandomU64() {
            /* NOTE: This is one of the only places where Nintendo does not do data flushing. */
            /*       to ensure coherency when doing random byte generation. */
            /*       It is not clear why it is necessary elsewhere but not here. */
            /* TODO: Figure out why. */
            u64 v;
            se::GenerateRandomBytes(std::addressof(v), sizeof(v));
            return v;
        }

    }

    u64 BeginAsyncOperation(GetResultHandler handler) {
        /* Only allow one async operation at a time. */
        if (g_async_key != InvalidAsyncKey) {
            return InvalidAsyncKey;
        }

        /* Generate a random async key. */
        g_async_key     = GenerateRandomU64();
        g_async_handler = handler;

        return g_async_key;
    }

    void CancelAsyncOperation(u64 async_key) {
        if (async_key == g_async_key) {
            g_async_key = InvalidAsyncKey;
        }
    }

    void EndAsyncOperation() {
        gic::SetPending(SecurityEngineUserInterruptId);
    }

    SmcResult SmcGetResult(SmcArguments &args) {
        /* Decode arguments. */
        const u64 async_key = args.r[1];

        /* Validate arguments. */
        SMC_R_UNLESS(g_async_key != InvalidAsyncKey,      NoAsyncOperation);
        SMC_R_UNLESS(g_async_key == async_key,       InvalidAsyncOperation);

        /* Call the handler. */
        args.r[1] = static_cast<u64>(g_async_handler(nullptr, 0));
        g_async_key = InvalidAsyncKey;

        return SmcResult::Success;
    }

    SmcResult SmcGetResultData(SmcArguments &args) {
        /* Decode arguments. */
        const u64 async_key            = args.r[1];
        const uintptr_t user_phys_addr = args.r[2];
        const size_t    user_size      = args.r[3];

        /* Allocate a work buffer on the stack. */
        alignas(8) u8 work_buffer[1_KB];

        /* Validate arguments. */
        SMC_R_UNLESS(g_async_key != InvalidAsyncKey,        NoAsyncOperation);
        SMC_R_UNLESS(g_async_key == async_key,         InvalidAsyncOperation);
        SMC_R_UNLESS(user_size <= sizeof(work_buffer),       InvalidArgument);

        /* Call the handler. */
        args.r[1] = static_cast<u64>(g_async_handler(work_buffer, user_size));
        g_async_key = InvalidAsyncKey;

        /* Map the user buffer. */
        {
            UserPageMapper mapper(user_phys_addr);
            SMC_R_UNLESS(mapper.Map(),                                              InvalidArgument);
            SMC_R_UNLESS(mapper.CopyToUser(user_phys_addr, work_buffer, user_size), InvalidArgument);
        }

        return SmcResult::Success;
    }

}