openmoko: kexecboot.c

/*
 *  kexecboot - A kexec based bootloader
 *
 *  Copyright (c) 2008-2009 Yuri Bushmelev <jay4mail@gmail.com>
 *  Copyright (c) 2008 Thomas Kunze <thommycheck@gmx.de>
 *
 *  small parts:
 *  Copyright (c) 2006 Matthew Allum <mallum@o-hand.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that 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.
 *
 */

#include "kexecboot.h"

/* Draw background with logo and text */
void draw_background(FB *fb, const char *text) {
        int margin = fb->width/64;

        /* Clear the background with #ecece1 */
        fb_draw_rect(fb, 0, 0, fb->width, fb->height,0xec, 0xec, 0xe1);

        /* logo */
        fb_draw_image(fb,
                      0,
                      0,
                      LOGO_IMG_WIDTH,
                      LOGO_IMG_HEIGHT,
                      LOGO_IMG_BYTES_PER_PIXEL, LOGO_IMG_RLE_PIXEL_DATA);

        fb_draw_text (fb, LOGO_IMG_WIDTH + margin, margin, 0, 0, 0,
                &radeon_font, text);
}

/* Draw one slot in menu */
void draw_slot(FB *fb, struct boot * boot,int slot, int height, int iscurrent)
{
        int margin = (height - CF_IMG_HEIGHT)/2;
        char text[100];
        if(!iscurrent)
                fb_draw_rect(fb, 0, slot*height, fb->width, height,
                        0xec, 0xec, 0xe1);
        else { //draw red border
                fb_draw_rect(fb, 0, slot*height, fb->width, height,
                        0xff, 0x00, 0x00);
                fb_draw_rect(fb, margin, slot*height+margin, fb->width-2*margin
                        , height-2*margin, 0xec, 0xec, 0xe1);
        }
        if(!strncmp(boot->device,"/dev/hd",strlen("/dev/hd")))
                fb_draw_image(fb, margin, slot*height+margin, CF_IMG_WIDTH,
                        CF_IMG_HEIGHT, CF_IMG_BYTES_PER_PIXEL, CF_IMG_RLE_PIXEL_DATA);
        else if(!strncmp(boot->device,"/dev/mmcblk",strlen("/dev/mmcblk")))
                fb_draw_image(fb, margin, slot*height + margin, MMC_IMG_WIDTH,
                        MMC_IMG_HEIGHT, MMC_IMG_BYTES_PER_PIXEL, MMC_IMG_RLE_PIXEL_DATA);
        else if(!strncmp(boot->device,"/dev/mtdblock",strlen("/dev/mtdblock")))
                fb_draw_image(fb, margin, slot*height + margin, MEMORY_IMG_WIDTH,
                        MEMORY_IMG_HEIGHT, MEMORY_IMG_BYTES_PER_PIXEL, MEMORY_IMG_RLE_PIXEL_DATA);
        sprintf(text,"%s (%s)",boot->device, boot->fstype);
        fb_draw_text (fb, CF_IMG_WIDTH+margin, slot*height+margin, 0, 0, 0,
                        &radeon_font, text);

}

/* Display bootlist menu with selection */
void display_menu(FB *fb, struct bootlist *bl, int current)
{
        int i,j;
        int slotheight = LOGO_IMG_HEIGHT;
        int slots = fb->height/slotheight -1;
        // struct boot that is in fist slot
        static int firstslot=0;

        if (0 == bl->size) {
                draw_background(fb, "No bootable devices found.\nInsert bootable device!\nR: Reboot  S: Rescan devices");
        } else {
                draw_background(fb, "Make your choice by selecting\nan item with the cursor keys.\nOK/Enter: Boot selected device\nR: Reboot  S: Rescan devices");
        }

        if(current < firstslot)
                firstslot=current;
        if(current > firstslot + slots -1)
                firstslot = current - (slots -1);
        for(i=1, j=firstslot; i <= slots && j< bl->size; i++, j++){
                draw_slot(fb, bl->list[j], i, slotheight, j == current);
        }
        fb_render(fb);
}

/* Display custom text near logo */
void display_text(FB *fb, const char *text) {
        draw_background(fb, text);
        fb_render(fb);
}

/*
 * Function: get_extra_cmdline()
 * It gets wanted tags from original cmdline.
 * Takes 2 args:
 * - extra_cmdline - buffer to store cmdline parameters;
 * - extra_cmdline_size - size of buffer
 *   (inc. terminating '\0').
 * Return values:
 * - length of extra_cmdline on success (w/o term. zero);
 * - -1 on error;
 * - (- length of extra_cmdline - 1)  on insufficient buffer space.
 * REFACTOR: do something with wanted_tags and this function (may be move to util)
 */

int get_extra_cmdline(char *const extra_cmdline, const size_t extra_cmdline_size)
{
        char *p, *t, *tag = NULL;
        char line[COMMAND_LINE_SIZE];
        int i, len, sp_size;
        int sum_len = 0;
        int wanted_tag_found = 0;
        int overflow = 0;

        const char proc_cmdline_path[] = "/proc/cmdline";

        /* Open /proc/cmdline and read cmdline */
        FILE *f = fopen(proc_cmdline_path, "r");
        if (NULL == f) {
                perror("Can't open /proc/cmdline");
                return -1;
        }

        if ( NULL == fgets(line, sizeof(line), f) ) {
                perror("Can't read /proc/cmdline");
                fclose(f);
                return -1;
        }

        fclose(f);

        /* clean up buffer before parsing */
        t = extra_cmdline;
        *t = '\0';

        p = line-1;             /* because of ++p below */

        sp_size = 0;    /* size of (first) space */

        do {
                ++p;

                if ( (NULL == tag) && (isalnum(*p)) ) {
                        /* new tag found */
                        tag = p;
                } else if (tag) {
                        /* we are working on some tag */

                        if (isspace(*p) || ('\0' == *p) || ('=' == *p) ) {
                                /* end of tag or '=' found */

                                if (!wanted_tag_found) {
                                        /* search in wanted_tags */
                                        for (i = 0; wanted_tags[i] != NULL; i++) {
                                                if ( 0 == strncmp(wanted_tags[i], tag, p-tag) ) {
                                                        /* match found */
                                                        wanted_tag_found = 1;
                                                        break;
                                                }
                                        }
                                }

                                if ( ('=' != *p) && wanted_tag_found ) {
                                        /* end of wanted tag found -> copy */

                                        len = p - tag;
                                        if ( (sum_len + len + sp_size) < extra_cmdline_size ) {
                                                if (sp_size) {
                                                        /* prepend space when have tags already */
                                                        *t = ' ';
                                                        ++t;
                                                        *t = '\0';
                                                        ++sum_len;
                                                } else {
                                                        sp_size = sizeof(char);
                                                }

                                                /* NOTE: tag is not null-terminated so copy only
                                                 * len chars and terminate it directly
                                                 */
                                                strncpy(t, tag, len);
                                                /* move pointer to position after copied tag */
                                                t += len ;
                                                /* null-terminate */
                                                *t = '\0';
                                                /* update summary length */
                                                sum_len += len;
                                        } else {
                                                /* we have no space - skip this tag */
                                                overflow = 1;
                                        }

                                        /* reset wanted_tag_found */
                                        wanted_tag_found = 0;
                                }

                                /* reset tag */
                                if (!wanted_tag_found) tag = NULL;

                        }
                }

        } while ('\0' != *p);

        if (overflow) return -sum_len-1;
        return sum_len;
}

void start_kernel(struct boot *boot)
{
        /* we use var[] instead of *var because sizeof(var) using */
        const char mount_point[] = "/mnt";
        const char kexec_path[] = "/usr/sbin/kexec";

        const char str_cmdline_start[] = "--command-line=";
        const char str_root[] = " root=";
        const char str_rootfstype[] = " rootfstype=";
        const char str_rootwait[] = " rootwait";

        /* empty environment */
        char *const envp[] = { NULL };

        const char *kexec_load_argv[] = { NULL, "-l", NULL, NULL, NULL };
        const char *kexec_exec_argv[] = { NULL, "-e", NULL, NULL};

        char extra_cmdline_buffer[COMMAND_LINE_SIZE];
        char *extra_cmdline, *cmdline_arg = NULL;
        int n, idx;
        struct stat *sinfo = malloc(sizeof(struct stat));

        kexec_exec_argv[0] = kexec_path;

        /* Check /proc/sys/net presence */
        if ( -1 == stat("/proc/sys/net", sinfo) ) {
                if (ENOENT == errno) {
                        /* We have no network, don't issue ifdown() while kexec'ing */
                        kexec_exec_argv[2] = "-x";
                        DPRINTF("No network is detected, disabling ifdown()\n");
                } else {
                        perror("Can't stat /proc/sys/net");
                }
        }
        free(sinfo);

        kexec_load_argv[0] = kexec_path;

        /* --command-line arg generation */
        idx = 2;        /* kexec_load_argv current option index */

        /* get some parts of cmdline from boot loader (e.g. mtdparts) */
        n = get_extra_cmdline( extra_cmdline_buffer,
                        sizeof(extra_cmdline_buffer) );
        if ( -1 == n ) {
                /* clean up extra_cmdline on error */
                extra_cmdline = NULL;
/*      } else if ( n < -1 ) { */
                /* Do something when we have no space to get all wanted tags */
                /* Now do nothing ;) */
        } else {
                extra_cmdline = extra_cmdline_buffer;
        }

        /* fill '--command-line' option */
        if (boot->cmdline || extra_cmdline || boot->device) {
                /* allocate space */
                n = strlenn(str_cmdline_start) + strlenn(boot->cmdline) +
                                sizeof(char) + strlenn(extra_cmdline) +
                                strlenn(str_root) + strlenn(boot->device) +
                                strlenn(str_rootfstype) + strlenn(boot->fstype) +
                                strlenn(str_rootwait) + sizeof(char);

                cmdline_arg = (char *)malloc(n);
                if (NULL == cmdline_arg) {
                        perror("Can't allocate memory for cmdline_arg");
                        /*  Should we exit?
                        exit(-1);
                        */
                } else {
                        strcpy(cmdline_arg, str_cmdline_start);
                        if (extra_cmdline)
                                strcat(cmdline_arg, extra_cmdline);
                        if (boot->cmdline && extra_cmdline)
                                strcat(cmdline_arg, " ");
                        if (boot->cmdline)
                                strcat(cmdline_arg, boot->cmdline);
                        if (boot->device) {
                                strcat(cmdline_arg, str_root);
                                strcat(cmdline_arg, boot->device);
                                if (boot->fstype) {
                                        strcat(cmdline_arg, str_rootfstype);
                                        strcat(cmdline_arg, boot->fstype);
                                }
                        }
                        strcat(cmdline_arg, str_rootwait);

                        kexec_load_argv[idx] = cmdline_arg;
                        ++idx;
                }
        }

        /* Append kernelpath as last arg of kexec */
        kexec_load_argv[idx] = boot->kernelpath;

        DPRINTF("kexec_load_argv: %s, %s, %s, %s\n", kexec_load_argv[0],
                        kexec_load_argv[1], kexec_load_argv[2],
                        kexec_load_argv[3]);

        DPRINTF("kexec_exec_argv: %s, %s, %s\n", kexec_exec_argv[0],
                        kexec_exec_argv[1], kexec_exec_argv[2]);

        /* Mount boot device */
        if ( -1 == mount(boot->device, mount_point, boot->fstype,
                        MS_RDONLY, NULL) ) {
                perror("Can't mount boot device");
                exit(-1);
        }

        /* Load kernel */
        n = fexecw(kexec_path, (char *const *)kexec_load_argv, envp);
        if (-1 == n) {
                perror("Kexec can't load kernel");
                exit(-1);
        }

        if (cmdline_arg)
                free(cmdline_arg);

        umount(mount_point);

        /* Boot new kernel */
        execve(kexec_path, (char *const *)kexec_exec_argv, envp);
}

int main(int argc, char **argv)
{
        int choice = 0;
        int initmode = 0;
        FB *fb;
        FILE *f;
        int angle = KXB_FBANGLE;
        struct bootlist * bl;
        struct input_event evt;
        struct termios old, new;
        struct hw_model_info *model;
        int ev0;
        int ev1;
        fd_set fds;
        /* hardcoded for openmoko gta02 with 2.6.24 kernel */
        char *eventif = "/dev/event0";
        char *eventif1 = "/dev/event1";

        struct input_event evt1;
        int maxfd;
        int nready;
        int nread;
        struct timeval tv;
        /* When our pid is 1 we are init-process */
        if ( 1 == getpid() ) {
                initmode = 1;

                DPRINTF("I'm the init-process!\n");

                /* extra delay for initializing slow SD/CF */
                sleep(1);

                /* Mount procfs */
                if ( -1 == mount("proc", "/proc", "proc",
                                0, NULL) ) {
                        perror("Can't mount procfs");
                        exit(-1);
                }

                DPRINTF("Procfs mounted\n");

                /* Set up console loglevel */
                f = fopen("/proc/sys/kernel/printk", "w");
                if (NULL == f) {
                        perror("/proc/sys/kernel/printk");
                        exit(-1);
                }
                fputs("0 4 1 7\n", f);
                fclose(f);

                DPRINTF("Console loglevel is set\n");

        }

        /* Get hardware model parameters (now FB angle only) */
        model = detect_hw_model(model_info);
        if (model->hw_model_id != HW_MODEL_UNKNOWN) {
                angle = model->angle;
                DPRINTF("Model is %s, fbangle is %d\n", model->name, model->angle);
        }

        /* Check command-line args when not an init-process */
        if (!initmode) {
                int i = 0;
                while (++i < argc) {
                        if (!strcmp(argv[i], "-a") || !strcmp(argv[i], "--angle")) {
                                if (++i > argc)
                                        goto fail;
                                angle = atoi(argv[i]);
                                continue;
                        }

                        if (!strcmp(argv[i], "-i") || !strcmp(argv[i], "--input")) {
                                if (++i > argc)
                                        goto fail;
                                eventif = argv[i];
                                continue;
                        }
                        if (!strcmp(argv[i], "-e") || !strcmp(argv[i], "--event")) {
                          if (++i > argc)
                            goto fail;
                          eventif1 = argv[i];
                          continue;
                        }

                        fail:
                 fprintf(stderr, "Usage: %s [-a|--angle <0|90|180|270>] \
                                [-i|--input </dev/input/eventX> [-e|--eventt </dev/input/eventX2>\n",
                         /* kxecboot -i /dev/input4 -e /dev/input0  for GTA02*/
                         /*                aux             tscreen on GTA running shr-unstable */
                        argv[0]);
                        exit(-1);
                }
        }

        DPRINTF("FB angle is %d, input device is %s\n", angle, eventif);
        DPRINTF("Going to fb mode\n");

        if ((fb = fb_new(angle)) == NULL)
                exit(-1);

        ev0 = open(eventif,O_RDONLY);
        ev1 = open(eventif1,O_RDONLY);
        if(!ev0 && !ev1 ){
            perror(eventif); /* maybe more sane output for for eventif1 */
            exit(3);
        }

        /* Switch cursor off. NOTE: works only when master-console is tty */
        printf("\033[?25l\n");

        // deactivate terminal input
        tcgetattr(fileno(stdin), &old);
        new = old;
        new.c_lflag &= ~ECHO;
//      new.c_cflag &=~CREAD;
        tcsetattr(fileno(stdin), TCSANOW, &new);

        bl = scan_devices(model);

        do {
                display_menu(fb, bl, choice);
                do{
                  /* Wait for some input. */
                  tv.tv_sec =1;
                  tv.tv_usec = 0;
                  FD_ZERO(&fds);
                  FD_SET( ev0,&fds);
                  FD_SET(ev1,&fds);
                  maxfd = 8;
                  nready = select(maxfd, &fds, NULL,NULL,&tv);
                  /* now GTA02 specific */
                  if( FD_ISSET(ev0, &fds))
                    {
                      read(ev0,&evt, sizeof(struct input_event));
                      DPRINTF("event: %i %i %i,\n",evt.type, evt.code,evt.value);
                    }
                  if( FD_ISSET(ev1, &fds))
                    {
                      read(ev1,&evt1 ,sizeof(struct input_event) );
                      DPRINTF("event1: %i %i %i,\n",evt1.type, evt1.code,evt1.value);
                      if ((evt1.code == 330) && (evt1.value == 1))
                        {
                          if ( choice < (bl->size - 1) ) 
                            {
                              choice++;
                              DPRINTF("Choice %i\n", choice);
                            }
                          else
                            {
                              choice=0;
                            }
                          DPRINTF("Selected: %i ,\n",choice );
                          break;
                        }
                    }
          } while( ( evt.type != EV_KEY || evt.value != 0) || ( evt.type != EV_KEY ||  evt1.value != 0) );
          // dev/event0 power 116
          }while( ( evt.code != 169 ) || (bl->size == 0)  );
        draw_background(fb, "DEBUG by EW: .\n Boot selected ");
        fb_render(fb);
                  
        fclose(f);
        // reset terminal
        tcsetattr(fileno(stdin), TCSANOW, &old);
        fb_destroy(fb);
        start_kernel(bl->list[choice]);
        /* When we reach this point then some error has occured */
        DPRINTF("We should not reach this point!");
        return -1;
}