Changeset 4f351432 in mainline for uspace/app


Ignore:
Timestamp:
2012-08-16T22:17:52Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2568c94
Parents:
83298e8 (diff), 6d5e378 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Location:
uspace/app
Files:
7 added
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/cmds/modules/bdd/bdd.c

    r83298e8 r4f351432  
    3838#include "cmds.h"
    3939
    40 #include <libblock.h>
     40#include <block.h>
    4141#include <loc.h>
    4242#include <errno.h>

  • uspace/app/bdsh/input.c

    r83298e8 r4f351432  
    268268        if (rc != EOK) {
    269269                /* Error in communication with console */
     270                cli_quit = 1;
    270271                return;
    271272        }

  • uspace/app/blkdump/blkdump.c

    r83298e8 r4f351432  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/edit/edit.c

    r83298e8 r4f351432  
    9191typedef struct {
    9292        char *file_name;
    93         sheet_t sh;
     93        sheet_t *sh;
    9494} doc_t;
    9595
    … …  
    126126static int file_save_range(char const *fname, spt_t const *spos,
    127127    spt_t const *epos);
    128 static char *filename_prompt(char const *prompt, char const *init_value);
    129128static char *range_get_str(spt_t const *spos, spt_t const *epos);
     129
     130static char *prompt(char const *prompt, char const *init_value);
    130131
    131132static void pane_text_display(void);
    … …  
    142143static void caret_move_word_left(void);
    143144static void caret_move_word_right(void);
     145static void caret_move_to_line(int row);
     146static void caret_go_to_line_ask(void);
    144147
    145148static bool selection_active(void);
    … …  
    172175        coord_t coord;
    173176        bool new_file;
     177        int rc;
    174178
    175179        spt_t pt;
    … …  
    186190
    187191        /* Start with an empty sheet. */
    188         sheet_init(&doc.sh);
     192        rc = sheet_create(&doc.sh);
     193        if (rc != EOK) {
     194                printf("Out of memory.\n");
     195                return -1;
     196        }
    189197
    190198        /* Place caret at the beginning of file. */
    191199        coord.row = coord.column = 1;
    192         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &pt);
    193         sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
     200        sheet_get_cell_pt(doc.sh, &coord, dir_before, &pt);
     201        sheet_place_tag(doc.sh, &pt, &pane.caret_pos);
    194202        pane.ideal_column = coord.column;
    195203
    … …  
    213221        /* Place selection start tag. */
    214222        tag_get_pt(&pane.caret_pos, &pt);
    215         sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
     223        sheet_place_tag(doc.sh, &pt, &pane.sel_start);
    216224
    217225        /* Initial display */
    … …  
    404412                caret_move_word_left();
    405413                break;
     414        case KC_L:
     415                caret_go_to_line_ask();
     416                break;
    406417        default:
    407418                break;
    … …  
    423434}
    424435
    425 static void key_handle_movement(unsigned int key, bool select)
     436/** Move caret while preserving or resetting selection. */
     437static void caret_movement(int drow, int dcolumn, enum dir_spec align_dir,
     438    bool select)
    426439{
    427440        spt_t pt;
    … …  
    435448        had_sel = !spt_equal(&caret_pt, &pt);
    436449
    437         switch (key) {
    438         case KC_LEFT:
    439                 caret_move(0, -1, dir_before);
    440                 break;
    441         case KC_RIGHT:
    442                 caret_move(0, 0, dir_after);
    443                 break;
    444         case KC_UP:
    445                 caret_move(-1, 0, dir_before);
    446                 break;
    447         case KC_DOWN:
    448                 caret_move(+1, 0, dir_before);
    449                 break;
    450         case KC_HOME:
    451                 caret_move(0, -ED_INFTY, dir_before);
    452                 break;
    453         case KC_END:
    454                 caret_move(0, +ED_INFTY, dir_before);
    455                 break;
    456         case KC_PAGE_UP:
    457                 caret_move(-pane.rows, 0, dir_before);
    458                 break;
    459         case KC_PAGE_DOWN:
    460                 caret_move(+pane.rows, 0, dir_before);
    461                 break;
    462         default:
    463                 break;
    464         }
     450        caret_move(drow, dcolumn, align_dir);
    465451
    466452        if (select == false) {
    467453                /* Move sel_start to the same point as caret. */
    468                 sheet_remove_tag(&doc.sh, &pane.sel_start);
     454                sheet_remove_tag(doc.sh, &pane.sel_start);
    469455                tag_get_pt(&pane.caret_pos, &pt);
    470                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
     456                sheet_place_tag(doc.sh, &pt, &pane.sel_start);
    471457        }
    472458
    … …  
    487473}
    488474
     475static void key_handle_movement(unsigned int key, bool select)
     476{
     477        switch (key) {
     478        case KC_LEFT:
     479                caret_movement(0, -1, dir_before, select);
     480                break;
     481        case KC_RIGHT:
     482                caret_movement(0, 0, dir_after, select);
     483                break;
     484        case KC_UP:
     485                caret_movement(-1, 0, dir_before, select);
     486                break;
     487        case KC_DOWN:
     488                caret_movement(+1, 0, dir_before, select);
     489                break;
     490        case KC_HOME:
     491                caret_movement(0, -ED_INFTY, dir_before, select);
     492                break;
     493        case KC_END:
     494                caret_movement(0, +ED_INFTY, dir_before, select);
     495                break;
     496        case KC_PAGE_UP:
     497                caret_movement(-pane.rows, 0, dir_before, select);
     498                break;
     499        case KC_PAGE_DOWN:
     500                caret_movement(+pane.rows, 0, dir_before, select);
     501                break;
     502        default:
     503                break;
     504        }
     505}
     506
    489507/** Save the document. */
    490508static int file_save(char const *fname)
    … …  
    520538        char *fname;
    521539       
    522         fname = filename_prompt("Save As", old_fname);
     540        fname = prompt("Save As", old_fname);
    523541        if (fname == NULL) {
    524542                status_display("Save cancelled.");
    … …  
    535553}
    536554
    537 /** Ask for a file name. */
    538 static char *filename_prompt(char const *prompt, char const *init_value)
     555/** Ask for a string. */
     556static char *prompt(char const *prompt, char const *init_value)
    539557{
    540558        kbd_event_t ev;
    … …  
    657675
    658676        do {
    659                 sheet_copy_out(&doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
     677                sheet_copy_out(doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
    660678                bytes = str_size(buf);
    661679
    … …  
    692710
    693711        while (true) {
    694                 sheet_copy_out(&doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
     712                sheet_copy_out(doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
    695713                    &bep);
    696714                bytes = str_size(&buf[bpos]);
    … …  
    714732        int sh_rows, rows;
    715733
    716         sheet_get_num_rows(&doc.sh, &sh_rows);
     734        sheet_get_num_rows(doc.sh, &sh_rows);
    717735        rows = min(sh_rows - pane.sh_row + 1, pane.rows);
    718736
    … …  
    784802                rbc.row = pane.sh_row + i;
    785803                rbc.column = pane.sh_column;
    786                 sheet_get_cell_pt(&doc.sh, &rbc, dir_before, &rb);
     804                sheet_get_cell_pt(doc.sh, &rbc, dir_before, &rb);
    787805
    788806                /* Ending point for row display */
    789807                rec.row = pane.sh_row + i;
    790808                rec.column = pane.sh_column + pane.columns;
    791                 sheet_get_cell_pt(&doc.sh, &rec, dir_before, &re);
     809                sheet_get_cell_pt(doc.sh, &rec, dir_before, &re);
    792810
    793811                /* Copy the text of the row to the buffer. */
    794                 sheet_copy_out(&doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
     812                sheet_copy_out(doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
    795813
    796814                /* Display text from the buffer. */
    … …  
    861879        spt_t caret_pt;
    862880        coord_t coord;
     881        int last_row;
    863882
    864883        tag_get_pt(&pane.caret_pos, &caret_pt);
    865884        spt_get_coord(&caret_pt, &coord);
    866885
     886        sheet_get_num_rows(doc.sh, &last_row);
     887
    867888        const char *fname = (doc.file_name != NULL) ? doc.file_name : "<unnamed>";
    868889
    869890        console_set_pos(con, 0, scr_rows - 1);
    870891        console_set_style(con, STYLE_INVERTED);
    871         int n = printf(" %d, %d: File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
    872             "Ctrl-E Save As", coord.row, coord.column, fname);
     892        int n = printf(" %d, %d (%d): File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
     893            "Ctrl-E Save As", coord.row, coord.column, last_row, fname);
    873894       
    874895        int pos = scr_columns - 1 - n;
    … …  
    906927        cbuf[offs] = '\0';
    907928
    908         (void) sheet_insert(&doc.sh, &pt, dir_before, cbuf);
     929        (void) sheet_insert(doc.sh, &pt, dir_before, cbuf);
    909930
    910931        pane.rflags |= REDRAW_ROW;
    … …  
    923944
    924945        coord.column -= 1;
    925         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &sp);
    926 
    927         (void) sheet_delete(&doc.sh, &sp, &ep);
     946        sheet_get_cell_pt(doc.sh, &coord, dir_before, &sp);
     947
     948        (void) sheet_delete(doc.sh, &sp, &ep);
    928949
    929950        pane.rflags |= REDRAW_ROW;
    … …  
    941962        spt_get_coord(&sp, &sc);
    942963
    943         sheet_get_cell_pt(&doc.sh, &sc, dir_after, &ep);
     964        sheet_get_cell_pt(doc.sh, &sc, dir_after, &ep);
    944965        spt_get_coord(&ep, &ec);
    945966
    946         (void) sheet_delete(&doc.sh, &sp, &ep);
     967        (void) sheet_delete(doc.sh, &sp, &ep);
    947968
    948969        pane.rflags |= REDRAW_ROW;
    … …  
    10161037                else {
    10171038                        coord.row--;
    1018                         sheet_get_row_width(&doc.sh, coord.row, &coord.column);
     1039                        sheet_get_row_width(doc.sh, coord.row, &coord.column);
    10191040                }
    10201041        }
    10211042        if (drow > 0) {
    1022                 sheet_get_num_rows(&doc.sh, &num_rows);
     1043                sheet_get_num_rows(doc.sh, &num_rows);
    10231044                if (coord.row > num_rows) coord.row = num_rows;
    10241045        }
    … …  
    10331054         * coordinates. The character can be wider than one cell (e.g. tab).
    10341055         */
    1035         sheet_get_cell_pt(&doc.sh, &coord, align_dir, &pt);
    1036         sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1037         sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
     1056        sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
     1057        sheet_remove_tag(doc.sh, &pane.caret_pos);
     1058        sheet_place_tag(doc.sh, &pt, &pane.caret_pos);
    10381059
    10391060        /* For non-vertical movement set the new value for @c ideal_column. */
    … …  
    10551076                tag_get_pt(&pane.caret_pos, &pt);
    10561077
    1057                 sheet_remove_tag(&doc.sh, &pane.sel_start);
    1058                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
     1078                sheet_remove_tag(doc.sh, &pane.sel_start);
     1079                sheet_place_tag(doc.sh, &pt, &pane.sel_start);
    10591080        } while (!pt_is_word_beginning(&pt));
    10601081
    … …  
    10711092                tag_get_pt(&pane.caret_pos, &pt);
    10721093
    1073                 sheet_remove_tag(&doc.sh, &pane.sel_start);
    1074                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
     1094                sheet_remove_tag(doc.sh, &pane.sel_start);
     1095                sheet_place_tag(doc.sh, &pt, &pane.sel_start);
    10751096        } while (!pt_is_word_beginning(&pt));
    10761097
    10771098        pane.rflags |= REDRAW_TEXT;
    10781099}
     1100
     1101/** Change the caret position to a beginning of a given line
     1102 */
     1103static void caret_move_to_line(int row)
     1104{
     1105        spt_t pt;
     1106        coord_t coord;
     1107
     1108        tag_get_pt(&pane.caret_pos, &pt);
     1109        spt_get_coord(&pt, &coord);
     1110
     1111        caret_movement(row - coord.row, 0, dir_before, false);
     1112}
     1113
     1114/** Ask for line and go to it. */
     1115static void caret_go_to_line_ask(void)
     1116{
     1117        char *sline;
     1118       
     1119        sline = prompt("Go to line", "");
     1120        if (sline == NULL) {
     1121                status_display("Go to line cancelled.");
     1122                return;
     1123        }
     1124       
     1125        char *endptr;
     1126        int line = strtol(sline, &endptr, 10);
     1127        if (*endptr != '\0') {
     1128                status_display("Invalid number entered.");
     1129                return;
     1130        }
     1131       
     1132        caret_move_to_line(line);
     1133}
     1134
    10791135
    10801136/** Check for non-empty selection. */
    … …  
    11151171
    11161172        if (rel < 0)
    1117                 sheet_delete(&doc.sh, &pa, &pb);
     1173                sheet_delete(doc.sh, &pa, &pb);
    11181174        else
    1119                 sheet_delete(&doc.sh, &pb, &pa);
     1175                sheet_delete(doc.sh, &pb, &pa);
    11201176
    11211177        if (ca.row == cb.row)
    … …  
    11391195static void selection_sel_range(spt_t pa, spt_t pb)
    11401196{
    1141         sheet_remove_tag(&doc.sh, &pane.sel_start);
    1142         sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
    1143         sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1144         sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
     1197        sheet_remove_tag(doc.sh, &pane.sel_start);
     1198        sheet_place_tag(doc.sh, &pa, &pane.sel_start);
     1199        sheet_remove_tag(doc.sh, &pane.caret_pos);
     1200        sheet_place_tag(doc.sh, &pb, &pane.caret_pos);
    11451201
    11461202        pane.rflags |= REDRAW_TEXT;
    … …  
    12251281
    12261282        coord.row = coord.column = 1;
    1227         sheet_get_cell_pt(&doc.sh, &coord, dir_before, pt);
     1283        sheet_get_cell_pt(doc.sh, &coord, dir_before, pt);
    12281284}
    12291285
    … …  
    12341290        int num_rows;
    12351291
    1236         sheet_get_num_rows(&doc.sh, &num_rows);
     1292        sheet_get_num_rows(doc.sh, &num_rows);
    12371293        coord.row = num_rows + 1;
    12381294        coord.column = 1;
    12391295
    1240         sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
     1296        sheet_get_cell_pt(doc.sh, &coord, dir_after, pt);
    12411297}
    12421298
    … …  
    12491305        coord.column = 1;
    12501306
    1251         sheet_get_cell_pt(&doc.sh, &coord, dir_before, spt);
     1307        sheet_get_cell_pt(doc.sh, &coord, dir_before, spt);
    12521308}
    12531309
    … …  
    12591315
    12601316        spt_get_coord(cpt, &coord);
    1261         sheet_get_row_width(&doc.sh, coord.row, &row_width);
     1317        sheet_get_row_width(doc.sh, coord.row, &row_width);
    12621318        coord.column = row_width - 1;
    12631319
    1264         sheet_get_cell_pt(&doc.sh, &coord, dir_after, ept);
     1320        sheet_get_cell_pt(doc.sh, &coord, dir_after, ept);
    12651321}
    12661322
    … …  
    12881344
    12891345        coord.column -= 1;
    1290         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &lp);
     1346        sheet_get_cell_pt(doc.sh, &coord, dir_before, &lp);
    12911347
    12921348        return pt_is_delimiter(&lp)
    … …  
    13101366
    13111367        coord.column += 1;
    1312         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
     1368        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
    13131369
    13141370        ch = range_get_str(pt, &rp);
    … …  
    13361392
    13371393        coord.column += 1;
    1338         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
     1394        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
    13391395
    13401396        ch = range_get_str(pt, &rp);

  • uspace/app/edit/sheet.c

    r83298e8 r4f351432  
    5757
    5858#include "sheet.h"
     59#include "sheet_impl.h"
    5960
    6061enum {
    … …  
    6667
    6768/** Initialize an empty sheet. */
    68 int sheet_init(sheet_t *sh)
    69 {
     69int sheet_create(sheet_t **rsh)
     70{
     71        sheet_t *sh;
     72
     73        sh = calloc(1, sizeof(sheet_t));
     74        if (sh == NULL)
     75                return ENOMEM;
     76
    7077        sh->dbuf_size = INITIAL_SIZE;
    7178        sh->text_size = 0;
    … …  
    7784        list_initialize(&sh->tags);
    7885
     86        *rsh = sh;
    7987        return EOK;
    8088}

  • uspace/app/edit/sheet.h

    r83298e8 r4f351432  
    5050
    5151/** Sheet */
    52 typedef struct {
    53         /* Note: This structure is opaque for the user. */
    54 
    55         size_t text_size;
    56         size_t dbuf_size;
    57         char *data;
    58 
    59         list_t tags;
    60 } sheet_t;
     52struct sheet;
     53typedef struct sheet sheet_t;
    6154
    6255/** Character cell coordinates
    … …  
    9790} tag_t;
    9891
    99 extern int sheet_init(sheet_t *);
     92extern int sheet_create(sheet_t **);
    10093extern int sheet_insert(sheet_t *, spt_t *, enum dir_spec, char *);
    10194extern int sheet_delete(sheet_t *, spt_t *, spt_t *);

  • uspace/app/ext2info/ext2info.c

    r83298e8 r4f351432  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/init/init.c

    r83298e8 r4f351432  
    3737#include <stdio.h>
    3838#include <unistd.h>
     39#include <stdarg.h>
    3940#include <vfs/vfs.h>
    4041#include <bool.h>
    … …  
    6566#define SRV_CONSOLE  "/srv/console"
    6667#define APP_GETTERM  "/app/getterm"
     68
     69#define SRV_COMPOSITOR  "/srv/compositor"
     70
     71#define HID_INPUT              "hid/input"
     72#define HID_OUTPUT             "hid/output"
     73#define HID_COMPOSITOR_SERVER  ":0"
     74
     75#define srv_start(path, ...) \
     76        srv_startl(path, path, ##__VA_ARGS__, NULL)
    6777
    6878/** Print banner */
    … …  
    143153}
    144154
    145 static void spawn(const char *fname)
    146 {
    147         int rc;
     155static int srv_startl(const char *path, ...)
     156{
    148157        struct stat s;
    149        
    150         if (stat(fname, &s) == ENOENT)
    151                 return;
    152        
    153         printf("%s: Spawning %s\n", NAME, fname);
    154         rc = task_spawnl(NULL, fname, fname, NULL);
    155         if (rc != EOK) {
    156                 printf("%s: Error spawning %s (%s)\n", NAME, fname,
    157                     str_error(rc));
    158         }
    159 }
    160 
    161 static void srv_start(const char *fname)
    162 {
     158        if (stat(path, &s) == ENOENT) {
     159                printf("%s: Unable to stat %s\n", NAME, path);
     160                return ENOENT;
     161        }
     162       
     163        printf("%s: Starting %s\n", NAME, path);
     164       
     165        va_list ap;
     166        const char *arg;
     167        int cnt = 0;
     168       
     169        va_start(ap, path);
     170        do {
     171                arg = va_arg(ap, const char *);
     172                cnt++;
     173        } while (arg != NULL);
     174        va_end(ap);
     175       
     176        va_start(ap, path);
    163177        task_id_t id;
     178        int rc = task_spawn(&id, path, cnt, ap);
     179        va_end(ap);
     180       
     181        if (rc != EOK) {
     182                printf("%s: Error spawning %s (%s)\n", NAME, path,
     183                    str_error(rc));
     184                return rc;
     185        }
     186       
     187        if (!id) {
     188                printf("%s: Error spawning %s (invalid task id)\n", NAME,
     189                    path);
     190                return EINVAL;
     191        }
     192       
    164193        task_exit_t texit;
    165         int rc, retval;
    166         struct stat s;
    167        
    168         if (stat(fname, &s) == ENOENT)
    169                 return;
    170        
    171         printf("%s: Starting %s\n", NAME, fname);
    172         rc = task_spawnl(&id, fname, fname, NULL);
    173         if (!id) {
    174                 printf("%s: Error spawning %s (%s)\n", NAME, fname,
    175                     str_error(rc));
    176                 return;
    177         }
    178        
     194        int retval;
    179195        rc = task_wait(id, &texit, &retval);
    180196        if (rc != EOK) {
    181                 printf("%s: Error waiting for %s (%s)\n", NAME, fname,
    182                     str_error(rc));
    183                 return;
     197                printf("%s: Error waiting for %s (%s)\n", NAME, path,
     198                    str_error(rc));
     199                return rc;
    184200        }
    185201       
    186202        if (texit != TASK_EXIT_NORMAL) {
    187203                printf("%s: Server %s failed to start (unexpectedly "
    188                     "terminated)\n", NAME, fname);
    189                 return;
    190         }
    191 
    192         if (retval != 0) {
     204                    "terminated)\n", NAME, path);
     205                return EINVAL;
     206        }
     207       
     208        if (retval != 0)
    193209                printf("%s: Server %s failed to start (exit code %d)\n", NAME,
    194                         fname, retval);
    195         }
    196 }
    197 
    198 static void console(const char *isvc, const char *fbsvc)
    199 {
    200         printf("%s: Spawning %s %s %s\n", NAME, SRV_CONSOLE, isvc, fbsvc);
    201        
     210                    path, retval);
     211       
     212        return retval;
     213}
     214
     215static int console(const char *isvc, const char *osvc)
     216{
    202217        /* Wait for the input service to be ready */
    203218        service_id_t service_id;
    … …  
    206221                printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
    207222                    str_error(rc));
    208                 return;
    209         }
    210        
    211         /* Wait for the framebuffer service to be ready */
    212         rc = loc_service_get_id(fbsvc, &service_id, IPC_FLAG_BLOCKING);
    213         if (rc != EOK) {
    214                 printf("%s: Error waiting on %s (%s)\n", NAME, fbsvc,
    215                     str_error(rc));
    216                 return;
    217         }
    218        
    219         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, isvc, fbsvc, NULL);
    220         if (rc != EOK) {
    221                 printf("%s: Error spawning %s %s %s (%s)\n", NAME, SRV_CONSOLE,
    222                     isvc, fbsvc, str_error(rc));
    223         }
     223                return rc;
     224        }
     225       
     226        /* Wait for the output service to be ready */
     227        rc = loc_service_get_id(osvc, &service_id, IPC_FLAG_BLOCKING);
     228        if (rc != EOK) {
     229                printf("%s: Error waiting on %s (%s)\n", NAME, osvc,
     230                    str_error(rc));
     231                return rc;
     232        }
     233       
     234        return srv_start(SRV_CONSOLE, isvc, osvc);
     235}
     236
     237static int compositor(const char *isvc, const char *name)
     238{
     239        /* Wait for the input service to be ready */
     240        service_id_t service_id;
     241        int rc = loc_service_get_id(isvc, &service_id, IPC_FLAG_BLOCKING);
     242        if (rc != EOK) {
     243                printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
     244                    str_error(rc));
     245                return rc;
     246        }
     247       
     248        return srv_start(SRV_COMPOSITOR, isvc, name);
     249}
     250
     251static int gui_start(const char *app, const char *srv_name)
     252{
     253        char winreg[50];
     254        snprintf(winreg, sizeof(winreg), "%s%s%s", "comp", srv_name, "/winreg");
     255       
     256        printf("%s: Spawning %s %s\n", NAME, app, winreg);
     257       
     258        task_id_t id;
     259        int rc = task_spawnl(&id, app, app, winreg, NULL);
     260        if (rc != EOK) {
     261                printf("%s: Error spawning %s %s (%s)\n", NAME, app,
     262                    winreg, str_error(rc));
     263                return -1;
     264        }
     265       
     266        task_exit_t texit;
     267        int retval;
     268        rc = task_wait(id, &texit, &retval);
     269        if ((rc != EOK) || (texit != TASK_EXIT_NORMAL)) {
     270                printf("%s: Error retrieving retval from %s (%s)\n", NAME,
     271                    app, str_error(rc));
     272                return -1;
     273        }
     274       
     275        return retval;
    224276}
    225277
    … …  
    227279{
    228280        char term[LOC_NAME_MAXLEN];
    229         int rc;
    230        
    231281        snprintf(term, LOC_NAME_MAXLEN, "%s/%s", LOCFS_MOUNT_POINT, svc);
    232282       
    … …  
    235285        /* Wait for the terminal service to be ready */
    236286        service_id_t service_id;
    237         rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
     287        int rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
    238288        if (rc != EOK) {
    239289                printf("%s: Error waiting on %s (%s)\n", NAME, term,
    … …  
    279329        if (!mount_root(STRING(RDFMT))) {
    280330                printf("%s: Exiting\n", NAME);
    281                 return -1;
     331                return 1;
    282332        }
    283333       
    284334        /* Make sure tmpfs is running. */
    285         if (str_cmp(STRING(RDFMT), "tmpfs") != 0) {
    286                 spawn("/srv/tmpfs");
    287         }
    288        
    289         spawn("/srv/locfs");
    290         spawn("/srv/taskmon");
     335        if (str_cmp(STRING(RDFMT), "tmpfs") != 0)
     336                srv_start("/srv/tmpfs");
     337       
     338        srv_start("/srv/locfs");
     339        srv_start("/srv/taskmon");
    291340       
    292341        if (!mount_locfs()) {
    293342                printf("%s: Exiting\n", NAME);
    294                 return -2;
     343                return 2;
    295344        }
    296345       
    297346        mount_tmpfs();
    298347       
    299         spawn("/srv/devman");
    300         spawn("/srv/apic");
    301         spawn("/srv/i8259");
    302         spawn("/srv/obio");
     348        srv_start("/srv/devman");
     349        srv_start("/srv/apic");
     350        srv_start("/srv/i8259");
     351        srv_start("/srv/obio");
    303352        srv_start("/srv/cuda_adb");
    304353        srv_start("/srv/s3c24xx_uart");
    305354        srv_start("/srv/s3c24xx_ts");
    306355       
    307         spawn("/srv/loopip");
    308         spawn("/srv/ethip");
    309         spawn("/srv/inetsrv");
    310         spawn("/srv/tcp");
    311         spawn("/srv/udp");
    312        
    313         spawn("/srv/fb");
    314         spawn("/srv/input");
    315         console("hid/input", "hid/fb0");
    316        
    317         spawn("/srv/clipboard");
    318         spawn("/srv/remcons");
     356        srv_start("/srv/loopip");
     357        srv_start("/srv/ethip");
     358        srv_start("/srv/inetsrv");
     359        srv_start("/srv/tcp");
     360        srv_start("/srv/udp");
     361       
     362        srv_start("/srv/clipboard");
     363        srv_start("/srv/remcons");
    319364       
    320365        /*
    … …  
    325370        srv_start("/srv/ata_bd");
    326371        srv_start("/srv/gxe_bd");
    327 #else
    328         (void) srv_start;
    329372#endif
    330373       
    331374#ifdef CONFIG_MOUNT_DATA
    332375        /* Make sure fat is running. */
    333         if (str_cmp(STRING(RDFMT), "fat") != 0) {
     376        if (str_cmp(STRING(RDFMT), "fat") != 0)
    334377                srv_start("/srv/fat");
    335         }
     378       
    336379        mount_data();
    337380#else
    … …  
    339382#endif
    340383       
    341         getterm("term/vc0", "/app/bdsh", true);
    342         getterm("term/vc1", "/app/bdsh", false);
    343         getterm("term/vc2", "/app/bdsh", false);
    344         getterm("term/vc3", "/app/bdsh", false);
    345         getterm("term/vc4", "/app/bdsh", false);
    346         getterm("term/vc5", "/app/bdsh", false);
    347         getterm("term/vc6", "/app/klog", false);
     384        srv_start("/srv/input", HID_INPUT);
     385        srv_start("/srv/output", HID_OUTPUT);
     386       
     387        int rc = compositor(HID_INPUT, HID_COMPOSITOR_SERVER);
     388        if (rc == EOK) {
     389                gui_start("/app/vlaunch", HID_COMPOSITOR_SERVER);
     390                gui_start("/app/vterm", HID_COMPOSITOR_SERVER);
     391        } else {
     392                rc = console(HID_INPUT, HID_OUTPUT);
     393                if (rc == EOK) {
     394                        getterm("term/vc0", "/app/bdsh", true);
     395                        getterm("term/vc1", "/app/bdsh", false);
     396                        getterm("term/vc2", "/app/bdsh", false);
     397                        getterm("term/vc3", "/app/bdsh", false);
     398                        getterm("term/vc4", "/app/bdsh", false);
     399                        getterm("term/vc5", "/app/bdsh", false);
     400                        getterm("term/vc6", "/app/klog", false);
     401                }
     402        }
    348403       
    349404        return 0;

  • uspace/app/mkexfat/mkexfat.c

    r83298e8 r4f351432  
    3838
    3939#include <stdio.h>
    40 #include <libblock.h>
     40#include <block.h>
    4141#include <assert.h>
    4242#include <errno.h>

  • uspace/app/mkfat/mkfat.c

    r83298e8 r4f351432  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/mkmfs/mkmfs.c

    r83298e8 r4f351432  
    3939#include <stdio.h>
    4040#include <stdlib.h>
    41 #include <libblock.h>
     41#include <block.h>
    4242#include <unistd.h>
    4343#include <errno.h>
Note: See TracChangeset for help on using the changeset viewer.