/*
* 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.
*/
#include <inttypes.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <plat/eeData.h>
#include <plat/plat.h>
#include <plat/wdt.h>
#include <apInt.h>
#include <atomic.h>
#include <bl.h>
#include <cpu.h>
#include <crc.h>
#include <eventQ.h>
#include <heap.h>
#include <hostIntf.h>
#include <mpu.h>
#include <nanohubPacket.h>
#include <osApi.h>
#include <platform.h>
#include <printf.h>
#include <sensors.h>
#include <seos.h>
#include <seos_priv.h>
#include <slab.h>
#include <syscall.h>
#include <timer.h>
#include <util.h>
#include <nanohub/nanohub.h>
#include <chreApi.h>
struct TaskPool {
struct Task data[MAX_TASKS];
};
static struct TaskPool mTaskPool;
static struct EvtQueue *mEvtsInternal;
static struct SlabAllocator* mMiscInternalThingsSlab;
static struct TaskList mFreeTasks;
static struct TaskList mTasks;
static struct Task *mCurrentTask;
static struct Task *mSystemTask;
static TaggedPtr *mCurEvtEventFreeingInfo = NULL; //used as flag for retaining. NULL when none or already retained
static inline void list_init(struct TaskList *l)
{
l->prev = l->next = NO_NODE;
}
struct Task *osGetCurrentTask()
{
return mCurrentTask;
}
struct Task *osSetCurrentTask(struct Task *task)
{
struct Task *old = mCurrentTask;
while (true) {
old = mCurrentTask;
if (atomicCmpXchgPtr((uintptr_t*)&mCurrentTask, (uintptr_t)old, (uintptr_t)task)) {
break;
}
}
return old;
}
// beyond this point, noone shall access mCurrentTask directly
static inline bool osTaskTestFlags(struct Task *task, uint32_t mask)
{
return (atomicReadByte(&task->flags) & mask) != 0;
}
bool osAppIsChre(uint16_t tid)
{
struct Task *task = osTaskFindByTid(tid);
return task && osTaskIsChre(task);
}
uint32_t osAppChreVersion(uint16_t tid)
{
struct Task *task = osTaskFindByTid(tid);
if (task)
return osTaskChreVersion(task);
else
return 0;
}
static inline uint32_t osTaskClrSetFlags(struct Task *task, uint32_t clrMask, uint32_t setMask)
{
while (true) {
uint8_t flags = atomicReadByte(&task->flags);
uint8_t newFlags = (flags & ~clrMask) | setMask;
if (atomicCmpXchgByte(&task->flags, flags, newFlags))
return newFlags;
}
}
static inline uint32_t osTaskAddIoCount(struct Task *task, int32_t delta)
{
uint8_t count = atomicAddByte(&task->ioCount, delta);
count += delta; // old value is returned, so we add it again
return count;
}
static inline uint32_t osTaskGetIoCount(struct Task *task)
{
return atomicReadByte(&task->ioCount);
}
uint8_t osTaskIndex(struct Task *task)
{
// we don't need signed diff here: this way we simplify boundary check
size_t idx = task - &mTaskPool.data[0];
return idx >= MAX_TASKS || &mTaskPool.data[idx] != task ? NO_NODE : idx;
}
static inline struct Task *osTaskByIdx(size_t idx)
{
return idx >= MAX_TASKS ? NULL : &mTaskPool.data[idx];
}
uint32_t osGetCurrentTid()
{
struct Task *task = osGetCurrentTask();
if (task == NULL) {
return UINT32_MAX;
}
return task->tid;
}
uint32_t osSetCurrentTid(uint32_t tid)
{
struct Task *task = osTaskByIdx(TID_TO_TASK_IDX(tid));
if (task && task->tid == tid) {
struct Task *preempted = osSetCurrentTask(task);
return preempted->tid;
}
return osGetCurrentTid();
}
static inline struct Task *osTaskListPeekHead(struct TaskList *listHead)
{
TaskIndex idx = listHead->next;
return idx == NO_NODE ? NULL : &mTaskPool.data[idx];
}
#ifdef DEBUG
static void dumpListItems(const char *p, struct TaskList *listHead)
{
int i = 0;
struct Task *task;
osLog(LOG_ERROR, "List: %s (%p) [%u;%u]\n",
p,
listHead,
listHead ? listHead->prev : NO_NODE,
listHead ? listHead->next : NO_NODE
);
if (!listHead)
return;
for_each_task(listHead, task) {
osLog(LOG_ERROR, " item %d: task=%p TID=%04X [%u;%u;%u]\n",
i,
task,
task->tid,
task->list.prev,
osTaskIndex(task),
task->list.next
);
++i;
}
}
static void dumpTaskList(const char *f, struct Task *task, struct TaskList *listHead)
{
osLog(LOG_ERROR, "%s: pool: %p; task=%p [%u;%u;%u]; listHead=%p [%u;%u]\n",
f,
&mTaskPool,
task,
task ? task->list.prev : NO_NODE,
osTaskIndex(task),
task ? task->list.next : NO_NODE,
listHead,
listHead ? listHead->prev : NO_NODE,
listHead ? listHead->next : NO_NODE
);
dumpListItems("Tasks", &mTasks);
dumpListItems("Free Tasks", &mFreeTasks);
}
#else
#define dumpTaskList(a,b,c)
#endif
static inline void osTaskListRemoveTask(struct TaskList *listHead, struct Task *task)
{
if (task && listHead) {
struct TaskList *cur = &task->list;
TaskIndex left_idx = cur->prev;
TaskIndex right_idx = cur->next;
struct TaskList *left = left_idx == NO_NODE ? listHead : &mTaskPool.data[left_idx].list;
struct TaskList *right = right_idx == NO_NODE ? listHead : &mTaskPool.data[right_idx].list;
cur->prev = cur->next = NO_NODE;
left->next = right_idx;
right->prev = left_idx;
} else {
dumpTaskList(__func__, task, listHead);
}
}
static inline void osTaskListAddTail(struct TaskList *listHead, struct Task *task)
{
if (task && listHead) {
struct TaskList *cur = &task->list;
TaskIndex last_idx = listHead->prev;
TaskIndex new_idx = osTaskIndex(task);
struct TaskList *last = last_idx == NO_NODE ? listHead : &mTaskPool.data[last_idx].list;
cur->prev = last_idx;
cur->next = NO_NODE;
last->next = new_idx;
listHead->prev = new_idx;
} else {
dumpTaskList(__func__, task, listHead);
}
}
static struct Task *osAllocTask()
{
struct Task *task = osTaskListPeekHead(&mFreeTasks);
if (task) {
osTaskListRemoveTask(&mFreeTasks, task);
uint16_t tid = task->tid;
memset(task, 0, sizeof(*task));
task->tid = tid;
}
return task;
}
static void osFreeTask(struct Task *task)
{
if (task) {
task->flags = 0;
task->ioCount = 0;
osTaskListAddTail(&mFreeTasks, task);
}
}
static void osRemoveTask(struct Task *task)
{
osTaskListRemoveTask(&mTasks, task);
}
static void osAddTask(struct Task *task)
{
osTaskListAddTail(&mTasks, task);
}
struct Task* osTaskFindByTid(uint32_t tid)
{
TaskIndex idx = TID_TO_TASK_IDX(tid);
return idx < MAX_TASKS ? &mTaskPool.data[idx] : NULL;
}
static inline bool osTaskInit(struct Task *task)
{
struct Task *preempted = osSetCurrentTask(task);
bool done = cpuAppInit(task->app, &task->platInfo, task->tid);
osSetCurrentTask(preempted);
return done;
}
static void osTaskRelease(struct Task *task)
{
uint32_t taskTid = task->tid;
uint32_t platErr, sensorErr;
int timErr, heapErr;
uint64_t appId;
if (task->app)
appId = task->app->hdr.appId;
else
appId = 0;
platErr = platFreeResources(taskTid); // HW resources cleanup (IRQ, DMA etc)
sensorErr = sensorFreeAll(taskTid);
timErr = timTimerCancelAll(taskTid);
heapErr = heapFreeAll(taskTid);
if (platErr || sensorErr || timErr || heapErr)
osLog(LOG_WARN, "released app ID 0x%" PRIx64 "; plat:%08" PRIx32 " sensor:%08" PRIx32 " tim:%d heap:%d; TID %04" PRIX32 "\n", appId, platErr, sensorErr, timErr, heapErr, taskTid);
else
osLog(LOG_INFO, "released app ID 0x%" PRIx64 "; TID %04" PRIX32 "\n", appId, taskTid);
}
static inline void osTaskEnd(struct Task *task)
{
if (!osTaskTestFlags(task, FL_TASK_ABORTED)) {
struct Task *preempted = osSetCurrentTask(task);
cpuAppEnd(task->app, &task->platInfo);
osSetCurrentTask(preempted);
}
// task was supposed to release it's resources,
// but we do our cleanup anyway
// NOTE: we don't need to unsubscribe from events
osTaskRelease(task);
}
static inline void osTaskHandle(struct Task *task, uint16_t evtType, uint16_t fromTid, const void* evtData)
{
struct Task *preempted = osSetCurrentTask(task);
cpuAppHandle(task->app, &task->platInfo,
EVENT_WITH_ORIGIN(evtType, osTaskIsChre(task) ? fromTid : 0),
evtData);
osSetCurrentTask(preempted);
}
void osTaskInvokeMessageFreeCallback(struct Task *task, void (*freeCallback)(void *, size_t), void *message, uint32_t messageSize)
{
if (!task || !freeCallback)
return;
cpuAppInvoke(task->app, &task->platInfo, (void (*)(uintptr_t,uintptr_t))freeCallback, (uintptr_t)message, (uintptr_t)messageSize);
}
void osTaskInvokeEventFreeCallback(struct Task *task, void (*freeCallback)(uint16_t, void *), uint16_t event, void *data)
{
if (!task || !freeCallback)
return;
cpuAppInvoke(task->app, &task->platInfo,
(void (*)(uintptr_t,uintptr_t))freeCallback,
(uintptr_t)event, (uintptr_t)data);
}
static void osPrivateEvtFreeF(void *event)
{
union SeosInternalSlabData *act = event;
uint16_t fromTid = act->privateEvt.fromTid;
struct Task *srcTask = osTaskFindByTid(fromTid);
TaggedPtr evtFreeInfo = act->privateEvt.evtFreeInfo;
uint32_t evtType = act->privateEvt.evtType;
void *evtData = act->privateEvt.evtData;
slabAllocatorFree(mMiscInternalThingsSlab, event);
if (!srcTask) {
osLog(LOG_ERROR, "ERROR: Failed to find task to free event: evtType=%08" PRIX32 "\n", evtType);
return;
}
if (taggedPtrIsPtr(evtFreeInfo) && taggedPtrToPtr(evtFreeInfo)) {
if (osTaskIsChre(srcTask) && (evtType >> 16) == EVT_PRIVATE_CLASS_CHRE) {
osChreFreeEvent(fromTid,
(void (*)(uint16_t, void *))taggedPtrToPtr(evtFreeInfo),
evtType & EVT_MASK, evtData);
} else {
// this is for internal non-CHRE tasks, and CHRE tasks
// System may schedule non-CHRE events on behalf of CHRE app;
// this is the place we release them
struct Task *preempted = osSetCurrentTask(srcTask);
((EventFreeF)taggedPtrToPtr(evtFreeInfo))(evtData);
osSetCurrentTask(preempted);
}
} else if (taggedPtrIsUint(evtFreeInfo)) {
// this is for external non-CHRE tasks
struct AppEventFreeData fd = {.evtType = evtType, .evtData = evtData};
osTaskHandle(srcTask, EVT_APP_FREE_EVT_DATA, OS_SYSTEM_TID, &fd);
}
osTaskAddIoCount(srcTask, -1);
}
static void handleEventFreeing(uint32_t evtType, void *evtData, TaggedPtr evtFreeData) // watch out, this is synchronous
{
struct Task *srcTask = osTaskFindByTid(EVENT_GET_ORIGIN(evtType));
if (!srcTask) {
osLog(LOG_ERROR, "ERROR: Failed to find task to free event: evtType=%08" PRIX32 "\n", evtType);
return;
}
// release non-CHRE event; we can't determine if this is CHRE or non-CHRE event, but
// this method is only called to release non-CHRE events, so we make use of that fact
if (taggedPtrIsPtr(evtFreeData) && taggedPtrToPtr(evtFreeData)) {
// this is for internal non-CHRE tasks, and CHRE tasks
// System may schedule non-CHRE events on behalf of CHRE app;
// this is the place we release them
struct Task *preempted = osSetCurrentTask(srcTask);
((EventFreeF)taggedPtrToPtr(evtFreeData))(evtData);
osSetCurrentTask(preempted);
} else if (taggedPtrIsUint(evtFreeData)) {
// this is for external non-CHRE tasks
struct AppEventFreeData fd = {.evtType = EVENT_GET_EVENT(evtType), .evtData = evtData};
osTaskHandle(srcTask, EVT_APP_FREE_EVT_DATA, OS_SYSTEM_TID, &fd);
}
osTaskAddIoCount(srcTask, -1);
}
static void osInit(void)
{
heapInit();
platInitialize();
osLog(LOG_INFO, "SEOS Initializing\n");
cpuInitLate();
/* create the queues */
if (!(mEvtsInternal = evtQueueAlloc(512, handleEventFreeing))) {
osLog(LOG_INFO, "events failed to init\n");
return;
}
mMiscInternalThingsSlab = slabAllocatorNew(sizeof(union SeosInternalSlabData), alignof(union SeosInternalSlabData), 64 /* for now? */);
if (!mMiscInternalThingsSlab) {
osLog(LOG_INFO, "deferred actions list failed to init\n");
return;
}
}
static struct Task* osTaskFindByAppID(uint64_t appID)
{
struct Task *task;
for_each_task(&mTasks, task) {
if (task->app && task->app->hdr.appId == appID)
return task;
}
return NULL;
}
void osSegmentIteratorInit(struct SegmentIterator *it)
{
uint32_t sz;
uint8_t *start = platGetSharedAreaInfo(&sz);
it->shared = (const struct Segment *)(start);
it->sharedEnd = (const struct Segment *)(start + sz);
it->seg = NULL;
}
bool osAppSegmentSetState(const struct AppHdr *app, uint32_t segState)
{
bool done;
struct Segment *seg = osGetSegment(app);
uint8_t state = segState;
if (!seg)
return false;
mpuAllowRamExecution(true);
mpuAllowRomWrite(true);
done = BL.blProgramShared(&seg->state, &state, sizeof(state), BL_FLASH_KEY1, BL_FLASH_KEY2);
mpuAllowRomWrite(false);
mpuAllowRamExecution(false);
return done;
}
bool osSegmentSetSize(struct Segment *seg, uint32_t size)
{
bool ret = true;
if (!seg)
return false;
if (size > SEG_SIZE_MAX) {
seg->state = SEG_ST_ERASED;
size = SEG_SIZE_MAX;
ret = false;
}
seg->size[0] = size;
seg->size[1] = size >> 8;
seg->size[2] = size >> 16;
return ret;
}
struct Segment *osSegmentGetEnd()
{
uint32_t size;
uint8_t *start = platGetSharedAreaInfo(&size);
return (struct Segment *)(start + size);
}
uint32_t osSegmentGetFree()
{
struct SegmentIterator it;
const struct Segment *storageSeg = NULL;
osSegmentIteratorInit(&it);
while (osSegmentIteratorNext(&it)) {
if (osSegmentGetState(it.seg) == SEG_ST_EMPTY) {
storageSeg = it.seg;
break;
}
}
if (!storageSeg || storageSeg > it.sharedEnd)
return 0;
return (uint8_t *)it.sharedEnd - (uint8_t *)storageSeg;
}
struct Segment *osGetSegment(const struct AppHdr *app)
{
uint32_t size;
uint8_t *start = platGetSharedAreaInfo(&size);
return (struct Segment *)((uint8_t*)app &&
(uint8_t*)app >= start &&
(uint8_t*)app < (start + size) ?
(uint8_t*)app - sizeof(struct Segment) : NULL);
}
bool osEraseShared()
{
wdtDisableClk();
mpuAllowRamExecution(true);
mpuAllowRomWrite(true);
(void)BL.blEraseShared(BL_FLASH_KEY1, BL_FLASH_KEY2);
mpuAllowRomWrite(false);
mpuAllowRamExecution(false);
wdtEnableClk();
return true;
}
bool osWriteShared(void *dest, const void *src, uint32_t len)
{
bool ret;
mpuAllowRamExecution(true);
mpuAllowRomWrite(true);
ret = BL.blProgramShared(dest, src, len, BL_FLASH_KEY1, BL_FLASH_KEY2);
mpuAllowRomWrite(false);
mpuAllowRamExecution(false);
if (!ret)
osLog(LOG_ERROR, "osWriteShared: blProgramShared return false\n");
return ret;
}
struct AppHdr *osAppSegmentCreate(uint32_t size)
{
struct SegmentIterator it;
const struct Segment *storageSeg = NULL;
struct AppHdr *app;
osSegmentIteratorInit(&it);
while (osSegmentIteratorNext(&it)) {
if (osSegmentGetState(it.seg) == SEG_ST_EMPTY) {
storageSeg = it.seg;
break;
}
}
if (!storageSeg || osSegmentSizeGetNext(storageSeg, size) > it.sharedEnd)
return NULL;
app = osSegmentGetData(storageSeg);
osAppSegmentSetState(app, SEG_ST_RESERVED);
return app;
}
bool osAppSegmentClose(struct AppHdr *app, uint32_t segDataSize, uint32_t segState)
{
struct Segment seg;
// this is enough for holding padding to uint32_t and the footer
uint8_t footer[sizeof(uint32_t) + FOOTER_SIZE];
int footerLen;
bool ret;
uint32_t totalSize;
uint8_t *start = platGetSharedAreaInfo(&totalSize);
uint8_t *end = start + totalSize;
int32_t fullSize = segDataSize + sizeof(seg); // without footer or padding
struct Segment *storageSeg = osGetSegment(app);
// sanity check
if (segDataSize >= SEG_SIZE_MAX)
return false;
// physical limits check
if (osSegmentSizeAlignedWithFooter(segDataSize) + sizeof(struct Segment) > totalSize)
return false;
// available space check: we could truncate size, instead of disallowing it,
// but we know that we performed validation on the size before, in *Create call,
// and it was fine, so this must be a programming error, and so we fail.
// on a side note: size may grow or shrink compared to original estimate.
// typically it shrinks, since we skip some header info and padding, as well
// as signature blocks, but it is possible that at some point we may produce
// more data for some reason. At that time the logic here may need to change
if (osSegmentSizeGetNext(storageSeg, segDataSize) > (struct Segment*)end)
return false;
seg.state = segState;
osSegmentSetSize(&seg, segDataSize);
ret = osWriteShared((uint8_t*)storageSeg, (uint8_t*)&seg, sizeof(seg));
footerLen = (-fullSize) & 3;
memset(footer, 0x00, footerLen);
wdtDisableClk();
struct SegmentFooter segFooter = {
.crc = ~soft_crc32(storageSeg, fullSize, ~0),
};
wdtEnableClk();
memcpy(&footer[footerLen], &segFooter, sizeof(segFooter));
footerLen += sizeof(segFooter);
if (ret && footerLen)
ret = osWriteShared((uint8_t*)storageSeg + fullSize, footer, footerLen);
return ret;
}
bool osAppWipeData(struct AppHdr *app)
{
struct Segment *seg = osGetSegment(app);
int32_t size = osSegmentGetSize(seg);
uint8_t *p = (uint8_t*)app;
uint32_t state = osSegmentGetState(seg);
uint8_t buf[256];
bool done = true;
if (!seg || size == SEG_SIZE_INVALID || state == SEG_ST_EMPTY) {
osLog(LOG_ERROR, "%s: can't erase segment: app=%p; seg=%p"
"; size=%" PRIu32
"; state=%" PRIu32
"\n",
__func__, app, seg, size, state);
return false;
}
size = osSegmentSizeAlignedWithFooter(size);
memset(buf, 0, sizeof(buf));
while (size > 0) {
uint32_t flashSz = size > sizeof(buf) ? sizeof(buf) : size;
// keep trying to zero-out stuff even in case of intermittent failures.
// flash write may occasionally fail on some byte, but it is not good enough
// reason to not rewrite other bytes
bool res = osWriteShared(p, buf, flashSz);
done = done && res;
size -= flashSz;
p += flashSz;
}
return done;
}
static inline bool osAppIsValid(const struct AppHdr *app)
{
return app->hdr.magic == APP_HDR_MAGIC &&
app->hdr.fwVer == APP_HDR_VER_CUR &&
(app->hdr.fwFlags & FL_APP_HDR_APPLICATION) != 0 &&
app->hdr.payInfoType == LAYOUT_APP;
}
static bool osExtAppIsValid(const struct AppHdr *app, uint32_t len)
{
return osAppIsValid(app) &&
len >= sizeof(*app) &&
osAppSegmentGetState(app) == SEG_ST_VALID &&
osAppSegmentCalcCrcResidue(app) == CRC_RESIDUE &&
!(app->hdr.fwFlags & FL_APP_HDR_INTERNAL);
}
static bool osIntAppIsValid(const struct AppHdr *app)
{
return osAppIsValid(app) &&
osAppSegmentGetState(app) == SEG_STATE_INVALID &&
(app->hdr.fwFlags & FL_APP_HDR_INTERNAL) != 0;
}
static inline bool osExtAppErase(const struct AppHdr *app)
{
return osAppSegmentSetState(app, SEG_ST_ERASED);
}
static struct Task *osLoadApp(const struct AppHdr *app) {
struct Task *task;
task = osAllocTask();
if (!task) {
osLog(LOG_WARN, "External app id %016" PRIX64 " @ %p cannot be used as too many apps already exist.\n", app->hdr.appId, app);
return NULL;
}
task->app = app;
bool done = (app->hdr.fwFlags & FL_APP_HDR_INTERNAL) ?
cpuInternalAppLoad(task->app, &task->platInfo) :
cpuAppLoad(task->app, &task->platInfo);
if (!done) {
osLog(LOG_WARN, "App @ %p ID %016" PRIX64 " failed to load\n", app, app->hdr.appId);
osFreeTask(task);
task = NULL;
}
return task;
}
static void osUnloadApp(struct Task *task)
{
// this is called on task that has stopped running, or had never run
cpuAppUnload(task->app, &task->platInfo);
osFreeTask(task);
}
static bool osStartApp(const struct AppHdr *app)
{
bool done = false;
struct Task *task;
if ((task = osLoadApp(app)) != NULL) {
task->subbedEvtListSz = MAX_EMBEDDED_EVT_SUBS;
task->subbedEvents = task->subbedEventsInt;
osTaskMakeNewTid(task);
// print external NanoApp info to facilitate NanoApp debugging
if (!(task->app->hdr.fwFlags & FL_APP_HDR_INTERNAL))
osLog(LOG_INFO,
"loaded app ID 0x%" PRIx64 " at flash base 0x%" PRIxPTR " ram base 0x%" PRIxPTR "; TID %04" PRIX16 "\n",
task->app->hdr.appId, (uintptr_t) task->app, (uintptr_t) task->platInfo.data, task->tid);
done = osTaskInit(task);
if (!done) {
osLog(LOG_WARN, "App @ %p ID %016" PRIX64 " failed to init\n", task->app, task->app->hdr.appId);
osUnloadApp(task);
} else {
osAddTask(task);
(void)osEnqueueEvt(EVT_APP_BEGIN, task, NULL);
}
}
return done;
}
static bool osStopTask(struct Task *task, bool abort)
{
struct Task *preempted;
if (!task)
return false;
if (osTaskTestFlags(task, FL_TASK_STOPPED))
return true;
preempted = osSetCurrentTask(mSystemTask);
osRemoveTask(task);
osTaskClrSetFlags(task, 0, FL_TASK_STOPPED);
if (abort)
osTaskClrSetFlags(task, 0, FL_TASK_ABORTED);
else if (osTaskGetIoCount(task))
osTaskHandle(task, EVT_APP_STOP, OS_SYSTEM_TID, NULL);
osEnqueueEvt(EVT_APP_END, task, NULL);
osSetCurrentTask(preempted);
return true;
}
void osTaskAbort(struct Task *task)
{
osStopTask(task, true);
}
static bool matchAutoStart(const void *cookie, const struct AppHdr *app)
{
bool match = (bool)cookie;
if (app->hdr.fwFlags & FL_APP_HDR_CHRE) {
if (app->hdr.chreApiMajor == 0xFF && app->hdr.chreApiMinor == 0xFF)
return match;
else if ((app->hdr.chreApiMajor < 0x01) ||
(app->hdr.chreApiMajor == 0x01 && app->hdr.chreApiMinor < 0x01))
return match;
else
return !match;
} else {
return match;
}
}
static bool matchAppId(const void *data, const struct AppHdr *app)
{
uint64_t appId, vendor, seqId, curAppId;
memcpy(&appId, data, sizeof(appId));
vendor = APP_ID_GET_VENDOR(appId);
seqId = APP_ID_GET_SEQ_ID(appId);
curAppId = app->hdr.appId;
if ((vendor == APP_VENDOR_ANY || vendor == APP_ID_GET_VENDOR(curAppId)) &&
(seqId == APP_SEQ_ID_ANY || seqId == APP_ID_GET_SEQ_ID(curAppId))) {
return true;
} else {
return false;
}
}
static bool osExtAppFind(struct SegmentIterator *it, appMatchFunc func, const void *data)
{
const struct AppHdr *app;
const struct Segment *seg;
while (osSegmentIteratorNext(it)) {
seg = it->seg;
if (!seg)
break;
if (seg->state == SEG_ST_EMPTY)
break;
if (seg->state != SEG_ST_VALID)
continue;
app = osSegmentGetData(seg);
if (func(data, app))
return true;
}
return false;
}
static uint32_t osExtAppStopEraseApps(appMatchFunc func, const void *data, bool doErase)
{
const struct AppHdr *app;
int32_t len;
struct SegmentIterator it;
uint32_t stopCount = 0;
uint32_t eraseCount = 0;
uint32_t appCount = 0;
uint32_t taskCount = 0;
struct MgmtStatus stat = { .value = 0 };
struct Task *task;
osSegmentIteratorInit(&it);
while (osExtAppFind(&it, func, data)) {
app = osSegmentGetData(it.seg);
len = osSegmentGetSize(it.seg);
if (!osExtAppIsValid(app, len))
continue;
appCount++;
/* it is safe to erase a running app;
* erase merely sets a flag in the header,
* and app keeps running until it is stopped */
if (doErase && osExtAppErase(app))
eraseCount++;
task = osTaskFindByAppID(app->hdr.appId);
if (task) {
taskCount++;
if (osStopTask(task, false))
stopCount++;
}
}
SET_COUNTER(stat.app, appCount);
SET_COUNTER(stat.task, taskCount);
SET_COUNTER(stat.op, stopCount);
SET_COUNTER(stat.erase, eraseCount);
return stat.value;
}
uint32_t osExtAppStopAppsByAppId(uint64_t appId)
{
return osExtAppStopEraseApps(matchAppId, &appId, false);
}
uint32_t osExtAppEraseAppsByAppId(uint64_t appId)
{
return osExtAppStopEraseApps(matchAppId, &appId, true);
}
static void osScanExternal()
{
struct SegmentIterator it;
osSegmentIteratorInit(&it);
while (osSegmentIteratorNext(&it)) {
switch (osSegmentGetState(it.seg)) {
case SEG_ST_EMPTY:
// everything looks good
osLog(LOG_INFO, "External area is good\n");
return;
case SEG_ST_ERASED:
case SEG_ST_VALID:
// this is valid stuff, ignore
break;
case SEG_ST_RESERVED:
default:
// something is wrong: erase everything
osLog(LOG_ERROR, "External area is damaged. Erasing\n");
osEraseShared();
return;
}
}
}
static uint32_t osExtAppStartApps(appMatchFunc func, void *data)
{
const struct AppHdr *app;
int32_t len;
struct SegmentIterator it;
struct SegmentIterator checkIt;
uint32_t startCount = 0;
uint32_t eraseCount = 0;
uint32_t appCount = 0;
uint32_t taskCount = 0;
struct MgmtStatus stat = { .value = 0 };
osScanExternal();
osSegmentIteratorInit(&it);
while (osExtAppFind(&it, func, data)) {
app = osSegmentGetData(it.seg);
len = osSegmentGetSize(it.seg);
// skip erased or malformed apps
if (!osExtAppIsValid(app, len))
continue;
appCount++;
checkIt = it;
// find the most recent copy
while (osExtAppFind(&checkIt, matchAppId, &app->hdr.appId)) {
if (osExtAppErase(app)) // erase the old one, so we skip it next time
eraseCount++;
app = osSegmentGetData(checkIt.seg);
}
if (osTaskFindByAppID(app->hdr.appId)) {
// this either the most recent external app with the same ID,
// or internal app with the same id; in both cases we do nothing
taskCount++;
continue;
}
if (osStartApp(app))
startCount++;
}
SET_COUNTER(stat.app, appCount);
SET_COUNTER(stat.task, taskCount);
SET_COUNTER(stat.op, startCount);
SET_COUNTER(stat.erase, eraseCount);
return stat.value;
}
uint32_t osExtAppStartAppsByAppId(uint64_t appId)
{
return osExtAppStartApps(matchAppId, &appId);
}
static void osStartTasks(void)
{
const struct AppHdr *app;
uint32_t i, nApps;
struct Task* task;
uint32_t status = 0;
uint32_t taskCnt = 0;
osLog(LOG_DEBUG, "Initializing task pool...\n");
list_init(&mTasks);
list_init(&mFreeTasks);
for (i = 0; i < MAX_TASKS; ++i) {
task = &mTaskPool.data[i];
list_init(&task->list);
osFreeTask(task);
}
mSystemTask = osAllocTask(); // this is a dummy task; holder of TID 0; all system code will run with TID 0
osSetCurrentTask(mSystemTask);
osLog(LOG_DEBUG, "System task is: %p\n", mSystemTask);
/* first enum all internal apps, making sure to check for dupes */
osLog(LOG_DEBUG, "Starting internal apps...\n");
for (i = 0, app = platGetInternalAppList(&nApps); i < nApps; i++, app++) {
if (!osIntAppIsValid(app)) {
osLog(LOG_WARN, "Invalid internal app @ %p ID %016" PRIX64
"header version: %" PRIu16
"\n",
app, app->hdr.appId, app->hdr.fwVer);
continue;
}
if (!(app->hdr.fwFlags & FL_APP_HDR_INTERNAL)) {
osLog(LOG_WARN, "Internal app is not marked: [%p]: flags: 0x%04" PRIX16
"; ID: %016" PRIX64
"; ignored\n",
app, app->hdr.fwFlags, app->hdr.appId);
continue;
}
if ((task = osTaskFindByAppID(app->hdr.appId))) {
osLog(LOG_WARN, "Internal app ID %016" PRIX64
"@ %p attempting to update internal app @ %p; app @%p ignored.\n",
app->hdr.appId, app, task->app, app);
continue;
}
if (osStartApp(app))
taskCnt++;
}
osLog(LOG_DEBUG, "Starting external apps...\n");
status = osExtAppStartApps(matchAutoStart, (void *)true);
osLog(LOG_DEBUG, "Started %" PRIu32 " internal apps; EXT status: %08" PRIX32 "\n", taskCnt, status);
}
static void osInternalEvtHandle(uint32_t evtType, void *evtData)
{
union SeosInternalSlabData *da = (union SeosInternalSlabData*)evtData;
struct Task *task, *ssTask;
uint32_t i, j;
uint16_t tid = EVENT_GET_ORIGIN(evtType);
uint16_t evt = EVENT_GET_EVENT(evtType), newEvt;
struct Task *srcTask = osTaskFindByTid(tid);
struct Task *preempted = osSetCurrentTask(srcTask);
struct AppEventStartStop ssMsg;
switch (evt) {
case EVT_SUBSCRIBE_TO_EVT:
case EVT_UNSUBSCRIBE_TO_EVT:
/* get task */
task = osTaskFindByTid(da->evtSub.tid);
if (!task)
break;
for (j = 0; j < da->evtSub.numEvts; j++) {
/* find if subscribed to this evt */
for (i = 0; i < task->subbedEvtCount && task->subbedEvents[i] != da->evtSub.evts[j]; i++);
/* if unsub & found -> unsub */
if (evt == EVT_UNSUBSCRIBE_TO_EVT && i != task->subbedEvtCount)
task->subbedEvents[i] = task->subbedEvents[--task->subbedEvtCount];
/* if sub & not found -> sub */
else if (evt == EVT_SUBSCRIBE_TO_EVT && i == task->subbedEvtCount) {
if (task->subbedEvtListSz == task->subbedEvtCount) { /* enlarge the list */
uint32_t newSz = (task->subbedEvtListSz * 3 + 1) / 2;
uint32_t *newList = heapAlloc(sizeof(uint32_t[newSz])); /* grow by 50% */
if (newList) {
memcpy(newList, task->subbedEvents, sizeof(uint32_t[task->subbedEvtListSz]));
if (task->subbedEvents != task->subbedEventsInt)
heapFree(task->subbedEvents);
task->subbedEvents = newList;
task->subbedEvtListSz = newSz;
}
}
if (task->subbedEvtListSz > task->subbedEvtCount) { /* have space ? */
task->subbedEvents[task->subbedEvtCount++] = da->evtSub.evts[j];
}
}
}
break;
case EVT_APP_BEGIN:
case EVT_APP_END:
ssTask = evtData;
ssMsg.appId = ssTask->app->hdr.appId;
ssMsg.version = ssTask->app->hdr.appVer;
ssMsg.tid = ssTask->tid;
if (evt == EVT_APP_BEGIN) {
newEvt = EVT_APP_STARTED;
} else {
newEvt = EVT_APP_STOPPED;
osTaskEnd(ssTask);
osUnloadApp(ssTask);
}
/* send this event to all tasks who want it */
for_each_task(&mTasks, task) {
if (task != ssTask) {
for (i = 0; i < task->subbedEvtCount; i++) {
if (task->subbedEvents[i] == newEvt) {
osTaskHandle(task, newEvt, OS_SYSTEM_TID, &ssMsg);
break;
}
}
}
}
break;
case EVT_DEFERRED_CALLBACK:
da->deferred.callback(da->deferred.cookie);
break;
case EVT_PRIVATE_EVT:
task = osTaskFindByTid(da->privateEvt.toTid);
evtType = da->privateEvt.evtType & EVT_MASK;
evtData = da->privateEvt.evtData;
if (task) {
//private events cannot be retained
TaggedPtr *tmp = mCurEvtEventFreeingInfo;
mCurEvtEventFreeingInfo = NULL;
osTaskHandle(task, evtType, da->privateEvt.fromTid, da->privateEvt.evtData);
mCurEvtEventFreeingInfo = tmp;
}
break;
}
osSetCurrentTask(preempted);
}
void abort(void)
{
/* this is necessary for va_* funcs... */
osLog(LOG_ERROR, "Abort called");
while(1);
}
bool osRetainCurrentEvent(TaggedPtr *evtFreeingInfoP)
{
if (!mCurEvtEventFreeingInfo)
return false;
*evtFreeingInfoP = *mCurEvtEventFreeingInfo;
mCurEvtEventFreeingInfo = NULL;
return true;
}
void osFreeRetainedEvent(uint32_t evtType, void *evtData, TaggedPtr *evtFreeingInfoP)
{
//TODO: figure the way to calculate src tid here to pass to handleEventFreeing
handleEventFreeing(evtType, evtData, *evtFreeingInfoP);
}
void osMainInit(void)
{
cpuInit();
cpuIntsOff();
osInit();
timInit();
sensorsInit();
syscallInit();
osApiExport(mMiscInternalThingsSlab);
osChreApiExport();
apIntInit();
cpuIntsOn();
wdtInit();
osStartTasks();
//broadcast app start to all already-loaded apps
(void)osEnqueueEvt(EVT_APP_START, NULL, NULL);
}
void osMainDequeueLoop(void)
{
TaggedPtr evtFreeingInfo;
uint32_t evtType, j;
void *evtData;
struct Task *task;
uint16_t tid, evt;
/* get an event */
if (!evtQueueDequeue(mEvtsInternal, &evtType, &evtData, &evtFreeingInfo, true))
return;
/* by default we free them when we're done with them */
mCurEvtEventFreeingInfo = &evtFreeingInfo;
tid = EVENT_GET_ORIGIN(evtType);
evt = EVENT_GET_EVENT(evtType);
if (evt < EVT_NO_FIRST_USER_EVENT) {
/* handle deferred actions and other reserved events here */
osInternalEvtHandle(evtType, evtData);
} else {
/* send this event to all tasks who want it */
for_each_task(&mTasks, task) {
for (j = 0; j < task->subbedEvtCount; j++) {
if (task->subbedEvents[j] == evt) {
osTaskHandle(task, evt, tid, evtData);
break;
}
}
}
}
/* free it */
if (mCurEvtEventFreeingInfo)
handleEventFreeing(evtType, evtData, evtFreeingInfo);
/* avoid some possible errors */
mCurEvtEventFreeingInfo = NULL;
}
void __attribute__((noreturn)) osMain(void)
{
osMainInit();
while (true)
{
osMainDequeueLoop();
platPeriodic();
}
}
static void osDeferredActionFreeF(void* event)
{
slabAllocatorFree(mMiscInternalThingsSlab, event);
}
static bool osEventsSubscribeUnsubscribeV(bool sub, uint32_t numEvts, va_list ap)
{
struct Task *task = osGetCurrentTask();
union SeosInternalSlabData *act;
int i;
if (!sub && osTaskTestFlags(task, FL_TASK_STOPPED)) // stopping, so this is a no-op
return true;
if (numEvts > MAX_EVT_SUB_CNT)
return false;
act = slabAllocatorAlloc(mMiscInternalThingsSlab);
if (!act)
return false;
act->evtSub.tid = task->tid;
act->evtSub.numEvts = numEvts;
for (i = 0; i < numEvts; i++)
act->evtSub.evts[i] = va_arg(ap, uint32_t);
return osEnqueueEvtOrFree(sub ? EVT_SUBSCRIBE_TO_EVT : EVT_UNSUBSCRIBE_TO_EVT, act, osDeferredActionFreeF);
}
static bool osEventsSubscribeUnsubscribe(bool sub, uint32_t numEvts, ...)
{
bool ret;
va_list ap;
va_start(ap, numEvts);
ret = osEventsSubscribeUnsubscribeV(sub, numEvts, ap);
va_end(ap);
return ret;
}
bool osEventSubscribe(uint32_t tid, uint32_t evtType)
{
(void)tid;
return osEventsSubscribeUnsubscribe(true, 1, evtType);
}
bool osEventUnsubscribe(uint32_t tid, uint32_t evtType)
{
(void)tid;
return osEventsSubscribeUnsubscribe(false, 1, evtType);
}
bool osEventsSubscribe(uint32_t numEvts, ...)
{
bool ret;
va_list ap;
va_start(ap, numEvts);
ret = osEventsSubscribeUnsubscribeV(true, numEvts, ap);
va_end(ap);
return ret;
}
bool osEventsUnsubscribe(uint32_t numEvts, ...)
{
bool ret;
va_list ap;
va_start(ap, numEvts);
ret = osEventsSubscribeUnsubscribeV(false, numEvts, ap);
va_end(ap);
return ret;
}
static bool osEnqueueEvtCommon(uint32_t evt, void *evtData, TaggedPtr evtFreeInfo, bool urgent)
{
struct Task *task = osGetCurrentTask();
uint32_t evtType = EVENT_WITH_ORIGIN(evt, osGetCurrentTid());
osTaskAddIoCount(task, 1);
if (osTaskTestFlags(task, FL_TASK_STOPPED) ||
!evtQueueEnqueue(mEvtsInternal, evtType, evtData, evtFreeInfo, urgent)) {
osTaskAddIoCount(task, -1);
return false;
}
return true;
}
void osRemovePendingEvents(bool (*match)(uint32_t evtType, const void *evtData, void *context), void *context)
{
evtQueueRemoveAllMatching(mEvtsInternal, match, context);
}
bool osEnqueueEvt(uint32_t evtType, void *evtData, EventFreeF evtFreeF)
{
return osEnqueueEvtCommon(evtType, evtData, taggedPtrMakeFromPtr(evtFreeF), false);
}
bool osEnqueueEvtOrFree(uint32_t evtType, void *evtData, EventFreeF evtFreeF)
{
bool success = osEnqueueEvt(evtType, evtData, evtFreeF);
if (!success && evtFreeF)
evtFreeF(evtData);
return success;
}
bool osEnqueueEvtAsApp(uint32_t evtType, void *evtData, bool freeData)
{
// compatibility with existing external apps
if (evtType & EVENT_TYPE_BIT_DISCARDABLE_COMPAT)
evtType |= EVENT_TYPE_BIT_DISCARDABLE;
return osEnqueueEvtCommon(evtType, evtData, freeData ? taggedPtrMakeFromUint(osGetCurrentTid()) : taggedPtrMakeFromPtr(NULL), false);
}
bool osDefer(OsDeferCbkF callback, void *cookie, bool urgent)
{
union SeosInternalSlabData *act = slabAllocatorAlloc(mMiscInternalThingsSlab);
if (!act)
return false;
act->deferred.callback = callback;
act->deferred.cookie = cookie;
if (osEnqueueEvtCommon(EVT_DEFERRED_CALLBACK, act, taggedPtrMakeFromPtr(osDeferredActionFreeF), urgent))
return true;
slabAllocatorFree(mMiscInternalThingsSlab, act);
return false;
}
static bool osEnqueuePrivateEvtEx(uint32_t evtType, void *evtData, TaggedPtr evtFreeInfo, uint32_t toTid)
{
union SeosInternalSlabData *act = slabAllocatorAlloc(mMiscInternalThingsSlab);
bool result;
if (!act) {
osLog(LOG_ERROR, "[seos] ERROR: osEnqueuePrivateEvtEx: call to slabAllocatorAlloc() failed\n");
return false;
}
struct Task *task = osGetCurrentTask();
osTaskAddIoCount(task, 1);
act->privateEvt.evtType = evtType;
act->privateEvt.evtData = evtData;
act->privateEvt.evtFreeInfo = evtFreeInfo;
act->privateEvt.fromTid = task->tid;
act->privateEvt.toTid = toTid;
osSetCurrentTask(mSystemTask);
result = osEnqueueEvtOrFree(EVT_PRIVATE_EVT, act, osPrivateEvtFreeF);
osSetCurrentTask(task);
return result;
}
// only called to send events for CHRE apps
bool osEnqueuePrivateEvtNew(uint16_t evtType, void *evtData,
void (*evtFreeCallback)(uint16_t evtType, void *evtData),
uint32_t toTid)
{
if (!osEnqueuePrivateEvtEx(evtType | (EVT_PRIVATE_CLASS_CHRE << 16), evtData,
taggedPtrMakeFromPtr(evtFreeCallback), toTid)) {
osChreFreeEvent(osGetCurrentTid(), evtFreeCallback, evtType, evtData);
return false;
}
return true;
}
bool osEnqueuePrivateEvt(uint32_t evtType, void *evtData, EventFreeF evtFreeF, uint32_t toTid)
{
return osEnqueuePrivateEvtEx(evtType & EVT_MASK, evtData, taggedPtrMakeFromPtr(evtFreeF), toTid);
}
bool osEnqueuePrivateEvtAsApp(uint32_t evtType, void *evtData, uint32_t toTid)
{
return osEnqueuePrivateEvtEx(evtType & EVT_MASK, evtData, taggedPtrMakeFromUint(osGetCurrentTid()), toTid);
}
bool osTidById(const uint64_t *appId, uint32_t *tid)
{
struct Task *task;
for_each_task(&mTasks, task) {
if (task->app && !memcmp(&task->app->hdr.appId, appId, sizeof(*appId))) {
*tid = task->tid;
return true;
}
}
return false;
}
bool osAppInfoById(uint64_t appId, uint32_t *appIdx, uint32_t *appVer, uint32_t *appSize)
{
uint32_t i = 0;
struct Task *task;
for_each_task(&mTasks, task) {
const struct AppHdr *app = task->app;
if (app && app->hdr.appId == appId) {
*appIdx = i;
*appVer = app->hdr.appVer;
*appSize = app->sect.rel_end;
return true;
}
i++;
}
return false;
}
bool osAppInfoByIndex(uint32_t appIdx, uint64_t *appId, uint32_t *appVer, uint32_t *appSize)
{
struct Task *task;
int i = 0;
for_each_task(&mTasks, task) {
if (i != appIdx) {
++i;
} else {
const struct AppHdr *app = task->app;
*appId = app->hdr.appId;
*appVer = app->hdr.appVer;
*appSize = app->sect.rel_end;
return true;
}
}
return false;
}
bool osExtAppInfoByIndex(uint32_t appIdx, uint64_t *appId, uint32_t *appVer, uint32_t *appSize)
{
struct Task *task;
int i = 0;
for_each_task(&mTasks, task) {
const struct AppHdr *app = task->app;
if (!(app->hdr.fwFlags & FL_APP_HDR_INTERNAL)) {
if (i != appIdx) {
++i;
} else {
*appId = app->hdr.appId;
*appVer = app->hdr.appVer;
*appSize = app->sect.rel_end;
return true;
}
}
}
return false;
}
void osLogv(char clevel, uint32_t flags, const char *str, va_list vl)
{
void *userData = platLogAllocUserData();
platLogPutcharF(userData, clevel);
cvprintf(platLogPutcharF, flags, userData, str, vl);
platLogFlush(userData);
}
void osLog(enum LogLevel level, const char *str, ...)
{
va_list vl;
va_start(vl, str);
osLogv((char)level, 0, str, vl);
va_end(vl);
}
//Google's public key for Google's apps' signing
const uint8_t __attribute__ ((section (".pubkeys"))) _RSA_KEY_GOOGLE[] = {
0xd9, 0xcd, 0x83, 0xae, 0xb5, 0x9e, 0xe4, 0x63, 0xf1, 0x4c, 0x26, 0x6a, 0x1c, 0xeb, 0x4c, 0x12,
0x5b, 0xa6, 0x71, 0x7f, 0xa2, 0x4e, 0x7b, 0xa2, 0xee, 0x02, 0x86, 0xfc, 0x0d, 0x31, 0x26, 0x74,
0x1e, 0x9c, 0x41, 0x43, 0xba, 0x16, 0xe9, 0x23, 0x4d, 0xfc, 0xc4, 0xca, 0xcc, 0xd5, 0x27, 0x2f,
0x16, 0x4c, 0xe2, 0x85, 0x39, 0xb3, 0x0b, 0xcb, 0x73, 0xb6, 0x56, 0xc2, 0x98, 0x83, 0xf6, 0xfa,
0x7a, 0x6e, 0xa0, 0x9a, 0xcc, 0x83, 0x97, 0x9d, 0xde, 0x89, 0xb2, 0xa3, 0x05, 0x46, 0x0c, 0x12,
0xae, 0x01, 0xf8, 0x0c, 0xf5, 0x39, 0x32, 0xe5, 0x94, 0xb9, 0xa0, 0x8f, 0x19, 0xe4, 0x39, 0x54,
0xad, 0xdb, 0x81, 0x60, 0x74, 0x63, 0xd5, 0x80, 0x3b, 0xd2, 0x88, 0xf4, 0xcb, 0x6b, 0x47, 0x28,
0x80, 0xb0, 0xd1, 0x89, 0x6d, 0xd9, 0x62, 0x88, 0x81, 0xd6, 0xc0, 0x13, 0x88, 0x91, 0xfb, 0x7d,
0xa3, 0x7f, 0xa5, 0x40, 0x12, 0xfb, 0x77, 0x77, 0x4c, 0x98, 0xe4, 0xd3, 0x62, 0x39, 0xcc, 0x63,
0x34, 0x76, 0xb9, 0x12, 0x67, 0xfe, 0x83, 0x23, 0x5d, 0x40, 0x6b, 0x77, 0x93, 0xd6, 0xc0, 0x86,
0x6c, 0x03, 0x14, 0xdf, 0x78, 0x2d, 0xe0, 0x9b, 0x5e, 0x05, 0xf0, 0x93, 0xbd, 0x03, 0x1d, 0x17,
0x56, 0x88, 0x58, 0x25, 0xa6, 0xae, 0x63, 0xd2, 0x01, 0x43, 0xbb, 0x7e, 0x7a, 0xa5, 0x62, 0xdf,
0x8a, 0x31, 0xbd, 0x24, 0x1b, 0x1b, 0xeb, 0xfe, 0xdf, 0xd1, 0x31, 0x61, 0x4a, 0xfa, 0xdd, 0x6e,
0x62, 0x0c, 0xa9, 0xcd, 0x08, 0x0c, 0xa1, 0x1b, 0xe7, 0xf2, 0xed, 0x36, 0x22, 0xd0, 0x5d, 0x80,
0x78, 0xeb, 0x6f, 0x5a, 0x58, 0x18, 0xb5, 0xaf, 0x82, 0x77, 0x4c, 0x95, 0xce, 0xc6, 0x4d, 0xda,
0xca, 0xef, 0x68, 0xa6, 0x6d, 0x71, 0x4d, 0xf1, 0x14, 0xaf, 0x68, 0x25, 0xb8, 0xf3, 0xff, 0xbe,
};
#ifdef DEBUG
//debug key whose privatekey is checked in as misc/debug.privkey
const uint8_t __attribute__ ((section (".pubkeys"))) _RSA_KEY_GOOGLE_DEBUG[] = {
0x2d, 0xff, 0xa6, 0xb5, 0x65, 0x87, 0xbe, 0x61, 0xd1, 0xe1, 0x67, 0x10, 0xa1, 0x9b, 0xc6, 0xca,
0xc8, 0xb1, 0xf0, 0xaa, 0x88, 0x60, 0x9f, 0xa1, 0x00, 0xa1, 0x41, 0x9a, 0xd8, 0xb4, 0xd1, 0x74,
0x9f, 0x23, 0x28, 0x0d, 0xc2, 0xc4, 0x37, 0x15, 0xb1, 0x4a, 0x80, 0xca, 0xab, 0xb9, 0xba, 0x09,
0x7d, 0xf8, 0x44, 0xd6, 0xa2, 0x72, 0x28, 0x12, 0x91, 0xf6, 0xa5, 0xea, 0xbd, 0xf8, 0x81, 0x6b,
0xd2, 0x3c, 0x50, 0xa2, 0xc6, 0x19, 0x54, 0x48, 0x45, 0x8d, 0x92, 0xac, 0x01, 0xda, 0x14, 0x32,
0xdb, 0x05, 0x82, 0x06, 0x30, 0x25, 0x09, 0x7f, 0x5a, 0xbb, 0x86, 0x64, 0x70, 0x98, 0x64, 0x1e,
0xe6, 0xca, 0x1d, 0xc1, 0xcb, 0xb6, 0x23, 0xd2, 0x62, 0x00, 0x46, 0x97, 0xd5, 0xcc, 0xe6, 0x36,
0x72, 0xec, 0x2e, 0x43, 0x1f, 0x0a, 0xaf, 0xf2, 0x51, 0xe1, 0xcd, 0xd2, 0x98, 0x5d, 0x7b, 0x64,
0xeb, 0xd1, 0x35, 0x4d, 0x59, 0x13, 0x82, 0x6c, 0xbd, 0xc4, 0xa2, 0xfc, 0xad, 0x64, 0x73, 0xe2,
0x71, 0xb5, 0xf4, 0x45, 0x53, 0x6b, 0xc3, 0x56, 0xb9, 0x8b, 0x3d, 0xeb, 0x00, 0x48, 0x6e, 0x29,
0xb1, 0xb4, 0x8e, 0x2e, 0x43, 0x39, 0xef, 0x45, 0xa0, 0xb8, 0x8b, 0x5f, 0x80, 0xb5, 0x0c, 0xc3,
0x03, 0xe3, 0xda, 0x51, 0xdc, 0xec, 0x80, 0x2c, 0x0c, 0xdc, 0xe2, 0x71, 0x0a, 0x14, 0x4f, 0x2c,
0x22, 0x2b, 0x0e, 0xd1, 0x8b, 0x8f, 0x93, 0xd2, 0xf3, 0xec, 0x3a, 0x5a, 0x1c, 0xba, 0x80, 0x54,
0x23, 0x7f, 0xb0, 0x54, 0x8b, 0xe3, 0x98, 0x22, 0xbb, 0x4b, 0xd0, 0x29, 0x5f, 0xce, 0xf2, 0xaa,
0x99, 0x89, 0xf2, 0xb7, 0x5d, 0x8d, 0xb2, 0x72, 0x0b, 0x52, 0x02, 0xb8, 0xa4, 0x37, 0xa0, 0x3b,
0xfe, 0x0a, 0xbc, 0xb3, 0xb3, 0xed, 0x8f, 0x8c, 0x42, 0x59, 0xbe, 0x4e, 0x31, 0xed, 0x11, 0x9b,
};
#endif