src/bsp/lk/app/lkboot/lkboot.c - T103 - Gitiles

 /*
  * Copyright (c) 2014 Brian Swetland
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
  * (the "Software"), to deal in the Software without restriction,
  * including without limitation the rights to use, copy, modify, merge,
  * publish, distribute, sublicense, and/or sell copies of the Software,
  * and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 #include "lkboot.h"

 #include <app.h>

 #include <platform.h>
 #include <stdio.h>
 #include <debug.h>
 #include <string.h>
 #include <pow2.h>
 #include <err.h>
 #include <assert.h>
 #include <trace.h>

 #include <lib/sysparam.h>

 #include <kernel/thread.h>
 #include <kernel/mutex.h>

 #include <kernel/vm.h>
 #include <app/lkboot.h>

 #if WITH_LIB_MINIP
 #include <lib/minip.h>
 #endif

 #ifndef LKBOOT_WITH_SERVER
 #define LKBOOT_WITH_SERVER 1
 #endif
 #ifndef LKBOOT_AUTOBOOT
 #define LKBOOT_AUTOBOOT 1
 #endif
 #ifndef LKBOOT_AUTOBOOT_TIMEOUT
 #define LKBOOT_AUTOBOOT_TIMEOUT 5000
 #endif

 #define LOCAL_TRACE 0

 #define STATE_OPEN 0
 #define STATE_DATA 1
 #define STATE_RESP 2
 #define STATE_DONE 3
 #define STATE_ERROR 4

 typedef struct LKB {
     lkb_read_hook *read;
     lkb_write_hook *write;

     void *cookie;

     int state;
     size_t avail;
 } lkb_t;

 lkb_t *lkboot_create_lkb(void *cookie, lkb_read_hook *read, lkb_write_hook *write) {
     lkb_t *lkb = malloc(sizeof(lkb_t));
     if (!lkb)
         return NULL;

     lkb->cookie = cookie;
     lkb->state = STATE_OPEN;
     lkb->avail = 0;
     lkb->read = read;
     lkb->write = write;

     return lkb;
 }

 static int lkb_send(lkb_t *lkb, u8 opcode, const void *data, size_t len) {
     msg_hdr_t hdr;

     // once we sent our OKAY or FAIL or errored out, no more writes
     if (lkb->state >= STATE_DONE) return -1;

     switch (opcode) {
     case MSG_OKAY:
     case MSG_FAIL:
         lkb->state = STATE_DONE;
         if (len > 0xFFFF) return -1;
         break;
     case MSG_LOG:
         if (len > 0xFFFF) return -1;
         break;
     case MSG_SEND_DATA:
         if (len > 0x10000) return -1;
         break;
     case MSG_GO_AHEAD:
         if (lkb->state == STATE_OPEN) {
             lkb->state = STATE_DATA;
             break;
         }
         len = 0;
     default:
         lkb->state = STATE_ERROR;
         opcode = MSG_FAIL;
         data = "internal error";
         len = 14;
         break;
     }

     hdr.opcode = opcode;
     hdr.extra = 0;
     hdr.length = (opcode == MSG_SEND_DATA) ? (len - 1) : len;
     if (lkb->write(lkb->cookie, &hdr, sizeof(hdr)) != sizeof(&hdr)) {
         printf("xmit hdr fail\n");
         lkb->state = STATE_ERROR;
         return -1;
     }
     if (len && (lkb->write(lkb->cookie, data, len) != (ssize_t)len)) {
         printf("xmit data fail\n");
         lkb->state = STATE_ERROR;
         return -1;
     }
     return 0;
 }

 #define lkb_okay(lkb) lkb_send(lkb, MSG_OKAY, NULL, 0)
 #define lkb_fail(lkb, msg) lkb_send(lkb, MSG_FAIL, msg, strlen(msg))

 int lkb_write(lkb_t *lkb, const void *_data, size_t len) {
     const char *data = _data;
     while (len > 0) {
         size_t xfer = (len > 65536) ? 65536 : len;
         if (lkb_send(lkb, MSG_SEND_DATA, data, xfer)) return -1;
         len -= xfer;
         data += xfer;
     }
     return 0;
 }

 int lkb_read(lkb_t *lkb, void *_data, size_t len) {
     char *data = _data;

     if (lkb->state == STATE_RESP) {
         return 0;
     }
     if (lkb->state == STATE_OPEN) {
         if (lkb_send(lkb, MSG_GO_AHEAD, NULL, 0)) return -1;
     }
     while (len > 0) {
         if (lkb->avail == 0) {
             msg_hdr_t hdr;
             if (lkb->read(lkb->cookie, &hdr, sizeof(hdr))) goto fail;
             if (hdr.opcode == MSG_END_DATA) {
                 lkb->state = STATE_RESP;
                 return -1;
             }
             if (hdr.opcode != MSG_SEND_DATA) goto fail;
             lkb->avail = ((size_t) hdr.length) + 1;
         }
         if (lkb->avail >= len) {
             if (lkb->read(lkb->cookie, data, len)) goto fail;
             lkb->avail -= len;
             return 0;
         }
         if (lkb->read(lkb->cookie, data, lkb->avail)) {
             lkb->state = STATE_ERROR;
             return -1;
         }
         data += lkb->avail;
         len -= lkb->avail;
         lkb->avail = 0;
     }
     return 0;

 fail:
     lkb->state = STATE_ERROR;
     return -1;
 }

 status_t lkboot_process_command(lkb_t *lkb)
 {
     msg_hdr_t hdr;
     char cmd[128];
     char *arg;
     int err;
     const char *result;
     unsigned len;

     if (lkb->read(lkb->cookie, &hdr, sizeof(hdr))) goto fail;
     if (hdr.opcode != MSG_CMD) goto fail;
     if (hdr.length > 127) goto fail;
     if (lkb->read(lkb->cookie, cmd, hdr.length)) goto fail;
     cmd[hdr.length] = 0;

     TRACEF("recv '%s'\n", cmd);

     if (!(arg = strchr(cmd, ':'))) goto fail;
     *arg++ = 0;
     len = atoul(arg);
     if (!(arg = strchr(arg, ':'))) goto fail;
     arg++;

     err = lkb_handle_command(lkb, cmd, arg, len, &result);
     if (err >= 0) {
         lkb_okay(lkb);
     } else {
         lkb_fail(lkb, result);
     }

     TRACEF("command handled with success\n");
     return NO_ERROR;

 fail:
     TRACEF("command failed\n");
     return ERR_IO;
 }

 static status_t lkboot_server(lk_time_t timeout)
 {
     lkboot_dcc_init();

 #if WITH_LIB_MINIP
     /* open the server's socket */
     tcp_socket_t *listen_socket = NULL;
     if (tcp_open_listen(&listen_socket, 1023) < 0) {
         printf("lkboot: error opening listen socket\n");
         return ERR_NO_MEMORY;
     }
 #endif

     /* run the main lkserver loop */
     printf("lkboot: starting server\n");
     lk_time_t t = current_time(); /* remember when we started */
     for (;;) {
         bool handled_command = false;

         lkb_t *lkb;

 #if WITH_LIB_MINIP
         /* wait for a new connection */
         lk_time_t sock_timeout = 100;
         tcp_socket_t *s;
         if (tcp_accept_timeout(listen_socket, &s, sock_timeout) >= 0) {
             DEBUG_ASSERT(s);

             /* handle the command and close it */
             lkb = lkboot_tcp_opened(s);
             lkboot_process_command(lkb);
             free(lkb);
             tcp_close(s);
             handled_command = true;
         }
 #endif

         /* check if anything is coming in on dcc */
         lkb = lkboot_check_dcc_open();
         if (lkb) {
             lkboot_process_command(lkb);
             free(lkb);
             handled_command = true;
         }

         /* after the first command, stay in the server loop forever */
         if (handled_command && timeout != INFINITE_TIME) {
             timeout = INFINITE_TIME;
             printf("lkboot: handled command, staying in server loop\n");
         }

         /* see if we need to drop out and try to direct boot */
         if (timeout != INFINITE_TIME && (current_time() - t >= timeout)) {
             break;
         }
     }

 #if WITH_LIB_MINIP
     tcp_close(listen_socket);
 #endif

     printf("lkboot: server timed out\n");

     return ERR_TIMED_OUT;
 }

 /* platform code can override this to conditionally abort autobooting from flash */
 __WEAK bool platform_abort_autoboot(void)
 {
     return false;
 }

 static void lkboot_task(const struct app_descriptor *app, void *args)
 {
     /* read a few sysparams to decide if we're going to autoboot */
     uint8_t autoboot = 1;
     sysparam_read("lkboot.autoboot", &autoboot, sizeof(autoboot));

     /* let platform code have a shot at disabling the autoboot behavior */
     if (platform_abort_autoboot())
         autoboot = 0;

 #if !LKBOOT_AUTOBOOT
     autoboot = 0;
 #endif

     /* if we're going to autoobot, read the timeout value */
     lk_time_t autoboot_timeout;
     if (!autoboot) {
         autoboot_timeout = INFINITE_TIME;
     } else {
         autoboot_timeout = LKBOOT_AUTOBOOT_TIMEOUT;
         sysparam_read("lkboot.autoboot_timeout", &autoboot_timeout, sizeof(autoboot_timeout));
     }

     TRACEF("autoboot %u autoboot_timeout %u\n", autoboot, (uint)autoboot_timeout);

 #if LKBOOT_WITH_SERVER
     lkboot_server(autoboot_timeout);
 #else
     if (autoboot_timeout != INFINITE_TIME) {
         TRACEF("waiting for %u milliseconds before autobooting\n", (uint)autoboot_timeout);
         thread_sleep(autoboot_timeout);
     }
 #endif

     if (autoboot_timeout != INFINITE_TIME) {
         TRACEF("trying to boot from flash...\n");
         status_t err = do_flash_boot();
         TRACEF("do_flash_boot returns %d\n", err);
     }

 #if LKBOOT_WITH_SERVER
     TRACEF("restarting server\n");
     lkboot_server(INFINITE_TIME);
 #endif

     TRACEF("nothing to do, exiting\n");
 }

 APP_START(lkboot)
     .entry = lkboot_task,
     .flags = 0,
 APP_END
	/*
	* Copyright (c) 2014 Brian Swetland
	*
	* Permission is hereby granted, free of charge, to any person obtaining
	* a copy of this software and associated documentation files
	* (the "Software"), to deal in the Software without restriction,
	* including without limitation the rights to use, copy, modify, merge,
	* publish, distribute, sublicense, and/or sell copies of the Software,
	* and to permit persons to whom the Software is furnished to do so,
	* subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be
	* included in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#include "lkboot.h"

	#include <app.h>

	#include <platform.h>
	#include <stdio.h>
	#include <debug.h>
	#include <string.h>
	#include <pow2.h>
	#include <err.h>
	#include <assert.h>
	#include <trace.h>

	#include <lib/sysparam.h>

	#include <kernel/thread.h>
	#include <kernel/mutex.h>

	#include <kernel/vm.h>
	#include <app/lkboot.h>

	#if WITH_LIB_MINIP
	#include <lib/minip.h>
	#endif

	#ifndef LKBOOT_WITH_SERVER
	#define LKBOOT_WITH_SERVER 1
	#endif
	#ifndef LKBOOT_AUTOBOOT
	#define LKBOOT_AUTOBOOT 1
	#endif
	#ifndef LKBOOT_AUTOBOOT_TIMEOUT
	#define LKBOOT_AUTOBOOT_TIMEOUT 5000
	#endif

	#define LOCAL_TRACE 0

	#define STATE_OPEN 0
	#define STATE_DATA 1
	#define STATE_RESP 2
	#define STATE_DONE 3
	#define STATE_ERROR 4

	typedef struct LKB {
	lkb_read_hook *read;
	lkb_write_hook *write;

	void *cookie;

	int state;
	size_t avail;
	} lkb_t;

	lkb_t lkboot_create_lkb(void cookie, lkb_read_hook read, lkb_write_hook write) {
	lkb_t *lkb = malloc(sizeof(lkb_t));
	if (!lkb)
	return NULL;

	lkb->cookie = cookie;
	lkb->state = STATE_OPEN;
	lkb->avail = 0;
	lkb->read = read;
	lkb->write = write;

	return lkb;
	}

	static int lkb_send(lkb_t lkb, u8 opcode, const void data, size_t len) {
	msg_hdr_t hdr;

	// once we sent our OKAY or FAIL or errored out, no more writes
	if (lkb->state >= STATE_DONE) return -1;

	switch (opcode) {
	case MSG_OKAY:
	case MSG_FAIL:
	lkb->state = STATE_DONE;
	if (len > 0xFFFF) return -1;
	break;
	case MSG_LOG:
	if (len > 0xFFFF) return -1;
	break;
	case MSG_SEND_DATA:
	if (len > 0x10000) return -1;
	break;
	case MSG_GO_AHEAD:
	if (lkb->state == STATE_OPEN) {
	lkb->state = STATE_DATA;
	break;
	}
	len = 0;
	default:
	lkb->state = STATE_ERROR;
	opcode = MSG_FAIL;
	data = "internal error";
	len = 14;
	break;
	}

	hdr.opcode = opcode;
	hdr.extra = 0;
	hdr.length = (opcode == MSG_SEND_DATA) ? (len - 1) : len;
	if (lkb->write(lkb->cookie, &hdr, sizeof(hdr)) != sizeof(&hdr)) {
	printf("xmit hdr fail\n");
	lkb->state = STATE_ERROR;
	return -1;
	}
	if (len && (lkb->write(lkb->cookie, data, len) != (ssize_t)len)) {
	printf("xmit data fail\n");
	lkb->state = STATE_ERROR;
	return -1;
	}
	return 0;
	}

	#define lkb_okay(lkb) lkb_send(lkb, MSG_OKAY, NULL, 0)
	#define lkb_fail(lkb, msg) lkb_send(lkb, MSG_FAIL, msg, strlen(msg))

	int lkb_write(lkb_t lkb, const void _data, size_t len) {
	const char *data = _data;
	while (len > 0) {
	size_t xfer = (len > 65536) ? 65536 : len;
	if (lkb_send(lkb, MSG_SEND_DATA, data, xfer)) return -1;
	len -= xfer;
	data += xfer;
	}
	return 0;
	}

	int lkb_read(lkb_t lkb, void _data, size_t len) {
	char *data = _data;

	if (lkb->state == STATE_RESP) {
	return 0;
	}
	if (lkb->state == STATE_OPEN) {
	if (lkb_send(lkb, MSG_GO_AHEAD, NULL, 0)) return -1;
	}
	while (len > 0) {
	if (lkb->avail == 0) {
	msg_hdr_t hdr;
	if (lkb->read(lkb->cookie, &hdr, sizeof(hdr))) goto fail;
	if (hdr.opcode == MSG_END_DATA) {
	lkb->state = STATE_RESP;
	return -1;
	}
	if (hdr.opcode != MSG_SEND_DATA) goto fail;
	lkb->avail = ((size_t) hdr.length) + 1;
	}
	if (lkb->avail >= len) {
	if (lkb->read(lkb->cookie, data, len)) goto fail;
	lkb->avail -= len;
	return 0;
	}
	if (lkb->read(lkb->cookie, data, lkb->avail)) {
	lkb->state = STATE_ERROR;
	return -1;
	}
	data += lkb->avail;
	len -= lkb->avail;
	lkb->avail = 0;
	}
	return 0;

	fail:
	lkb->state = STATE_ERROR;
	return -1;
	}

	status_t lkboot_process_command(lkb_t *lkb)
	{
	msg_hdr_t hdr;
	char cmd[128];
	char *arg;
	int err;
	const char *result;
	unsigned len;

	if (lkb->read(lkb->cookie, &hdr, sizeof(hdr))) goto fail;
	if (hdr.opcode != MSG_CMD) goto fail;
	if (hdr.length > 127) goto fail;
	if (lkb->read(lkb->cookie, cmd, hdr.length)) goto fail;
	cmd[hdr.length] = 0;

	TRACEF("recv '%s'\n", cmd);

	if (!(arg = strchr(cmd, ':'))) goto fail;
	*arg++ = 0;
	len = atoul(arg);
	if (!(arg = strchr(arg, ':'))) goto fail;
	arg++;

	err = lkb_handle_command(lkb, cmd, arg, len, &result);
	if (err >= 0) {
	lkb_okay(lkb);
	} else {
	lkb_fail(lkb, result);
	}

	TRACEF("command handled with success\n");
	return NO_ERROR;

	fail:
	TRACEF("command failed\n");
	return ERR_IO;
	}

	static status_t lkboot_server(lk_time_t timeout)
	{
	lkboot_dcc_init();

	#if WITH_LIB_MINIP
	/* open the server's socket */
	tcp_socket_t *listen_socket = NULL;
	if (tcp_open_listen(&listen_socket, 1023) < 0) {
	printf("lkboot: error opening listen socket\n");
	return ERR_NO_MEMORY;
	}
	#endif

	/* run the main lkserver loop */
	printf("lkboot: starting server\n");
	lk_time_t t = current_time(); /* remember when we started */
	for (;;) {
	bool handled_command = false;

	lkb_t *lkb;

	#if WITH_LIB_MINIP
	/* wait for a new connection */
	lk_time_t sock_timeout = 100;
	tcp_socket_t *s;
	if (tcp_accept_timeout(listen_socket, &s, sock_timeout) >= 0) {
	DEBUG_ASSERT(s);

	/* handle the command and close it */
	lkb = lkboot_tcp_opened(s);
	lkboot_process_command(lkb);
	free(lkb);
	tcp_close(s);
	handled_command = true;
	}
	#endif

	/* check if anything is coming in on dcc */
	lkb = lkboot_check_dcc_open();
	if (lkb) {
	lkboot_process_command(lkb);
	free(lkb);
	handled_command = true;
	}

	/* after the first command, stay in the server loop forever */
	if (handled_command && timeout != INFINITE_TIME) {
	timeout = INFINITE_TIME;
	printf("lkboot: handled command, staying in server loop\n");
	}

	/* see if we need to drop out and try to direct boot */
	if (timeout != INFINITE_TIME && (current_time() - t >= timeout)) {
	break;
	}
	}

	#if WITH_LIB_MINIP
	tcp_close(listen_socket);
	#endif

	printf("lkboot: server timed out\n");

	return ERR_TIMED_OUT;
	}

	/* platform code can override this to conditionally abort autobooting from flash */
	__WEAK bool platform_abort_autoboot(void)
	{
	return false;
	}

	static void lkboot_task(const struct app_descriptor app, void args)
	{
	/* read a few sysparams to decide if we're going to autoboot */
	uint8_t autoboot = 1;
	sysparam_read("lkboot.autoboot", &autoboot, sizeof(autoboot));

	/* let platform code have a shot at disabling the autoboot behavior */
	if (platform_abort_autoboot())
	autoboot = 0;

	#if !LKBOOT_AUTOBOOT
	autoboot = 0;
	#endif

	/* if we're going to autoobot, read the timeout value */
	lk_time_t autoboot_timeout;
	if (!autoboot) {
	autoboot_timeout = INFINITE_TIME;
	} else {
	autoboot_timeout = LKBOOT_AUTOBOOT_TIMEOUT;
	sysparam_read("lkboot.autoboot_timeout", &autoboot_timeout, sizeof(autoboot_timeout));
	}

	TRACEF("autoboot %u autoboot_timeout %u\n", autoboot, (uint)autoboot_timeout);

	#if LKBOOT_WITH_SERVER
	lkboot_server(autoboot_timeout);
	#else
	if (autoboot_timeout != INFINITE_TIME) {
	TRACEF("waiting for %u milliseconds before autobooting\n", (uint)autoboot_timeout);
	thread_sleep(autoboot_timeout);
	}
	#endif

	if (autoboot_timeout != INFINITE_TIME) {
	TRACEF("trying to boot from flash...\n");
	status_t err = do_flash_boot();
	TRACEF("do_flash_boot returns %d\n", err);
	}

	#if LKBOOT_WITH_SERVER
	TRACEF("restarting server\n");
	lkboot_server(INFINITE_TIME);
	#endif

	TRACEF("nothing to do, exiting\n");
	}

	APP_START(lkboot)
	.entry = lkboot_task,
	.flags = 0,
	APP_END