Ignore:
Timestamp:
Jul 10, 2020, 9:09:25 PM (4 years ago)
Author:
coas-nagasima
Message:

NTShellタスクを更新

File:
1 edited

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/ntshell/src/main.c

    r434 r441  
    4848#include "syssvc/serial.h"
    4949#include "syssvc/syslog.h"
     50#include "target_syssvc.h"
    5051#include "kernel_cfg.h"
    5152#include "main.h"
    52 #include "rza1.h"
     53#include "fdtable.h"
     54#ifndef NTSHELL_NO_SOCKET
    5355#include <tinet_config.h>
    5456#include <netinet/in.h>
    … …  
    7072#include "usrcmd.h"
    7173#include "util/ntopt.h"
    72 #include "fdtable.h"
    73 #include "target_syssvc.h"
     74#include "netapp/dhcp4_cli.h"
     75#include "ntp_cli.h"
     76#include "netcmd.h"
     77#endif
    7478
    7579ID ws_api_mailboxid = MAIN_DATAQUEUE;
    7680ID ws_mempoolid = MPF_NET_BUF_256;
     81extern ntstdio_t *ntstdio;
    7782
    7883char command[NTOPT_TEXT_MAXLEN];
    79 ntstdio_t ntstdio;
    80 
    81 unsigned char ntstdio_xi(struct ntstdio_t *handle)
    82 {
    83         char buf[1];
    84         if(serial_rea_dat(SIO_PORTID, buf, 1) != 1)
    85                 return -EIO;
    86         return buf[0];
    87 }
    88 
    89 void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
    90 {
    91         char buf[1];
    92         buf[0] = c;
    93         serial_wri_dat(SIO_PORTID, buf, 1);
    94 }
    9584
    9685const uint8_t mac_addr[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
    … …  
    10190        "3.5.0",
    10291        TARGET_NAME,
    103     "toppers.jp"
     92        "toppers.jp"
    10493};
    10594
    … …  
    113102        main_state_start,
    114103        main_state_idle,
     104#ifndef NTSHELL_NO_SOCKET
     105        main_state_start_dhcp,
     106#endif
     107        main_state_servey_cmd,
    115108};
    116109
    117110struct main_obj_t {
    118111        ntshell_t ntshell;
    119         TMO timer;
     112        int timer;
    120113        enum main_state_t state;
    121114        SYSTIM prev, now;
    122         WS_FBS_ID rcvmsg;
    123         T_WS_FBS_QUEUE wbs_queue;
    124         WS_FBS_ID sndmsg;
     115        task_base_t **tasks;
     116        int task_count;
     117#ifndef NTSHELL_NO_SOCKET
     118        uint8_t link;
     119        uint8_t link_up;
     120        uint8_t up;
     121        uint8_t dhcp;
     122        uint8_t ntp;
     123        ntp_cli_state_t ntp_state;
     124#endif
     125        bool_t exec;
     126        int event_req, event_res;
    125127};
    126128struct main_obj_t main_obj;
    127129
    128 static void main_change_netif_link(T_IFNET *ether);
     130#ifndef NTSHELL_NO_SOCKET
     131static void netif_link_callback(T_IFNET *ether);
     132static void main_change_netif_link(uint8_t link_up, uint8_t up);
     133#endif
    129134static void main_initialize(struct main_obj_t *obj);
    130 static TMO main_get_timer(struct main_obj_t *obj);
    131 static void main_progress(struct main_obj_t *obj, TMO elapse);
    132 static void main_timeout(struct main_obj_t *obj);
    133 extern int execute_command(int wait);
     135static void main_finalize(struct main_obj_t *obj);
     136static int main_get_timer(struct main_obj_t *obj);
     137static void main_progress(struct main_obj_t *obj, int elapse);
     138static void main_timeout(struct main_obj_t *obj, bool_t wakeup);
     139static int execute_command(struct main_obj_t *obj, int wait);
    134140static int usrcmd_ntopt_callback(long *args, void *extobj);
    135 
     141#ifndef NTSHELL_NO_SOCKET
     142static void ntp_cli_state_changed(ntp_cli_state_t state);
     143#endif
     144
     145void stdio_open(ID portid);
     146void stdio_input(unsigned char c);
     147
     148bool_t dhcp_enable;
     149int ntshell_exit;
    136150int shellcmd_exit_code;
    137151volatile int shellcmd_state;
    … …  
    139153jmp_buf shellcmd_exit;
    140154
     155void main_task_init(task_base_t **tasks, int task_count)
     156{
     157        main_obj.tasks = tasks;
     158        main_obj.task_count = task_count;
     159}
     160
    141161int uart_read(char *buf, int cnt, void *extobj)
    142162{
    143         return serial_rea_dat(SIO_PORTID, (char *)buf, cnt);
     163        struct main_obj_t *obj = (struct main_obj_t *)extobj;
     164        int result;
     165        ER ret;
     166        int timer;
     167        bool_t wakeup = false;
     168
     169        obj->prev = obj->now;
     170
     171        if (obj->event_req != obj->event_res) {
     172                obj->event_res = obj->event_req;
     173                wakeup = true;
     174#ifndef NTSHELL_NO_SOCKET
     175                if (obj->dhcp) {
     176                        obj->dhcp = 0;
     177                        obj->state = main_state_start_dhcp;
     178                }
     179#endif
     180                obj->timer = 0;
     181        }
     182
     183        /* タイマー取得 */
     184        timer = main_get_timer(obj);
     185
     186        /* 待ち */
     187        ret = serial_trea_dat(SIO_PORTID, buf, cnt, timer);
     188        if ((ret < 0) && (ret != E_OK) && (ret != E_TMOUT) && (ret != E_RLWAI)) {
     189                syslog(LOG_NOTICE, "tslp_tsk ret: %s %d", itron_strerror(ret), timer);
     190                ntshell_exit = 1;
     191                return -1;
     192        }
     193        if (ret != E_TMOUT)
     194                wakeup = true;
     195        result = (int)ret;
     196
     197        ret = get_tim(&obj->now);
     198        if (ret != E_OK) {
     199                syslog(LOG_NOTICE, "get_tim ret: %s", itron_strerror(ret));
     200                ntshell_exit = 1;
     201                return -1;
     202        }
     203
     204        /* 時間経過 */
     205        int elapse = obj->now - obj->prev;
     206        main_progress(obj, elapse);
     207
     208        /* タイムアウト処理 */
     209        main_timeout(obj, wakeup);
     210
     211        return result;
    144212}
    145213
    … …  
    162230        }
    163231
    164         return execute_command(tskid == MAIN_TASK);
    165 }
     232        return execute_command(&main_obj, tskid == MAIN_TASK);
     233}
     234
     235gpio_t led_blue, led_green, led_red, sw;
    166236
    167237/*
    168  * メインタスク
     238 *  メインタスク
    169239 */
    170240void main_task(intptr_t exinf)
    171241{
    172242        struct main_obj_t *obj = (struct main_obj_t *)&main_obj;
     243
     244        gpio_init_out(&led_blue, LED_BLUE);
     245        gpio_init_out(&led_green, LED_GREEN);
     246        gpio_init_out(&led_red, LED_RED);
     247        gpio_init_in(&sw, USER_BUTTON0);
     248
     249        obj->exec = gpio_read(&sw) == 1;
     250
     251        gpio_write(&led_blue, 1);
     252        gpio_write(&led_green, obj->exec ? 1 : 0);
     253        gpio_write(&led_red, 0);
     254
     255        ether_set_link_callback(main_change_netif_link);
     256
     257        /* 初期化 */
     258        ffarch_init();
     259
     260        stdio_open(SIO_PORTID);
     261
     262#ifndef NTSHELL_NO_SOCKET
     263        ntp_cli_set_state_changed_cb(ntp_cli_state_changed);
     264#endif
    173265
    174266        main_initialize(obj);
    … …  
    177269        ntshell_set_prompt(&obj->ntshell, "NTShell>");
    178270        ntshell_execute(&obj->ntshell);
     271
     272        main_finalize(obj);
    179273}
    180274
    … …  
    184278static void main_initialize(struct main_obj_t *obj)
    185279{
    186         FILINFO fno;
    187 #if FF_USE_LFN
    188         char lfn[FF_MAX_LFN + 1];
    189         fno.lfname = lfn;
    190         fno.lfsize = FF_MAX_LFN + 1;
    191 #endif
    192280        ER ret;
    193 
    194         ntstdio_init(&ntstdio, NTSTDIO_OPTION_LINE_ECHO | NTSTDIO_OPTION_CANON | NTSTDIO_OPTION_LF_CRLF | NTSTDIO_OPTION_LF_CR, ntstdio_xi, ntstdio_xo);
    195 
    196         obj->timer = TMO_FEVR;
     281        ID tskid = 0;
     282
     283        ret = get_tid(&tskid);
     284        if (ret != E_OK) {
     285                syslog(LOG_ERROR, "get_tid %d", ret);
     286                return;
     287        }
     288
     289        obj->timer = 100000;
    197290        obj->state = main_state_start;
    198291
    199         gpio_t led_blue, led_green, led_red, sw;
    200         gpio_init_out(&led_blue, LED_BLUE);
    201         gpio_init_out(&led_green, LED_GREEN);
    202         gpio_init_out(&led_red, LED_RED);
    203         gpio_init_in(&sw, USER_BUTTON0);
    204 
    205         bool_t exec = gpio_read(&sw) == 1;
    206 
    207         gpio_write(&led_blue, 1);
    208         gpio_write(&led_green, exec ? 1 : 0);
    209         gpio_write(&led_red, 0);
    210 
    211         ether_set_link_callback(main_change_netif_link);
    212 
    213         /* 初期化 */
    214         if (mruby_arduino_init() == 0) {
    215                 gpio_write(&led_blue, 0);
    216         }
    217         else {
    218                 gpio_write(&led_blue, 0);
    219                 gpio_write(&led_red, 1);
    220         }
    221 
     292        for (int i = 0; i < obj->task_count; i++) {
     293                task_base_t *task = obj->tasks[i];
     294                task->on_start(task, tskid);
     295        }
     296
     297        gpio_write(&led_blue, 0);
    222298        gpio_write(&led_green, 0);
    223299
    224300        act_tsk(HTTPD1_TASK);
    225301        act_tsk(HTTPD2_TASK);
    226 
    227         if (f_stat("1:/upload/main.mrb", &fno) != FR_OK) {
    228                 exec = false;
    229         }
    230 
    231         if (exec) {
    232                 ntlibc_strlcpy(command, "mruby -b 1:/upload/main.mrb", sizeof(command));
    233 
    234                 execute_command(1);
    235         }
    236302
    237303        ret = get_tim(&obj->now);
    … …  
    243309}
    244310
     311static void main_finalize(struct main_obj_t *obj)
     312{
     313        for (int i = 0; i < obj->task_count; i++) {
     314                task_base_t *task = obj->tasks[i];
     315                task->on_end(task);
     316        }
     317}
     318
    245319/*
    246320 * タイマー取得
    247321 */
    248 static TMO main_get_timer(struct main_obj_t *obj)
    249 {
    250         TMO timer = obj->timer;
     322static int main_get_timer(struct main_obj_t *obj)
     323{
     324        int timer = obj->timer;
     325
     326        for (int i = 0; i < obj->task_count; i++) {
     327                task_base_t *task = obj->tasks[i];
     328                int timer2 = task->get_timer(task);
     329                if ((timer == -1) || ((timer2 != -1) && (timer > timer2)))
     330                        timer = timer2;
     331        }
    251332
    252333        return timer;
    … …  
    256337 * 時間経過
    257338 */
    258 static void main_progress(struct main_obj_t *obj, TMO elapse)
     339static void main_progress(struct main_obj_t *obj, int elapse)
    259340{
    260341        if (obj->timer != TMO_FEVR) {
    … …  
    264345                }
    265346        }
     347
     348        for (int i = 0; i < obj->task_count; i++) {
     349                task_base_t *task = obj->tasks[i];
     350                task->progress(task, elapse);
     351        }
    266352}
    267353
    … …  
    269355 * タイムアウト処理
    270356 */
    271 static void main_timeout(struct main_obj_t *obj)
    272 {
    273         //if (obj->timer == 0) {
    274         //}
    275 }
    276 
     357static void main_timeout(struct main_obj_t *obj, bool_t wakeup)
     358{
     359        ER ret;
     360        uint32_t event = wakeup ? MAIN_EVENT_WAKEUP : 0;
     361
     362        if (!wakeup && (obj->timer != 0))
     363                return;
     364
     365        switch (obj->state) {
     366        case main_state_start:
     367#ifndef NTSHELL_NO_SOCKET
     368                ether_set_link_callback(netif_link_callback);
     369#endif
     370                {
     371                        FILINFO fno;
     372#if FF_USE_LFN
     373                        char lfn[FF_MAX_LFN + 1];
     374                        fno.lfname = lfn;
     375                        fno.lfsize = FF_MAX_LFN + 1;
     376#endif
     377                        if (f_stat("1:/upload/main.mrb", &fno) != FR_OK) {
     378                                obj->exec = false;
     379                        }
     380
     381                        if (obj->exec) {
     382                                cmd_execute("mruby -b 1:/upload/main.mrb", obj);
     383                        }
     384                }
     385                obj->state = main_state_idle;
     386                obj->timer = TMO_FEVR;
     387                break;
     388#ifndef NTSHELL_NO_SOCKET
     389        case main_state_start_dhcp:
     390                ret = dhcp4c_renew_info();
     391                if (ret == E_OK) {
     392                        obj->state = main_state_idle;
     393                        obj->timer = TMO_FEVR;
     394                }
     395                else {
     396                        obj->state = main_state_start_dhcp;
     397                        obj->timer = 1000000;
     398                }
     399                break;
     400#endif
     401        default:
     402                obj->state = main_state_idle;
     403                obj->timer = TMO_FEVR;
     404                break;
     405        }
     406#ifndef NTSHELL_NO_SOCKET
     407        if (obj->link) {
     408                obj->link = 0;
     409                event |= MAIN_EVENT_NETIF_CHANGED;
     410                if (obj->link_up)
     411                        event |= MAIN_EVENT_LINK_UP;
     412                if (obj->up)
     413                        event |= MAIN_EVENT_UP;
     414
     415                if (obj->link_up && obj->up)
     416                        ntp_cli_execute();
     417
     418                main_change_netif_link(obj->link_up, obj->up);
     419        }
     420        if (obj->ntp) {
     421                obj->ntp = 0;
     422                if (obj->ntp_state != NTP_CLI_STATE_SYNC)
     423                        event |= MAIN_EVENT_NTP_ASYNC;
     424                else
     425                        event |= MAIN_EVENT_NTP_SYNC;
     426        }
     427#endif
     428        for (int i = 0; i < obj->task_count; i++) {
     429                task_base_t *task = obj->tasks[i];
     430                task->process(task, event);
     431        }
     432}
     433
     434#ifndef NTSHELL_NO_SOCKET
    277435/* MACアドレスの設定時に呼ばれる */
    278436void mbed_mac_address(char *mac)
    … …  
    281439}
    282440
    283 static void main_change_netif_link(T_IFNET *ether)
     441void main_change_netif_link(uint8_t link_up, uint8_t up)
    284442{
    285443        FLGPTN flgptn;
    … …  
    295453        set_flg(FLG_SELECT_WAIT, flgptn);
    296454}
     455
     456void netif_link_callback(T_IFNET *ether)
     457{
     458        struct main_obj_t *obj = (struct main_obj_t *)&main_obj;
     459        uint8_t link_up = (ether->flags & IF_FLAG_LINK_UP) != 0;
     460        uint8_t up = (ether->flags & IF_FLAG_UP) != 0;
     461        bool_t wake = false;
     462
     463        if (dhcp_enable) {
     464                if (!link_up)
     465                        dhcp4c_rel_info();
     466                else if (!up) {
     467                        wake = dhcp4c_renew_info() != E_OK;
     468                        if (wake) {
     469                                obj->dhcp = 1;
     470                        }
     471                }
     472        }
     473        else {
     474                up = link_up;
     475        }
     476
     477        if ((obj->link_up != link_up) || (obj->up != up)) {
     478                obj->link = 1;
     479                wake = true;
     480        }
     481
     482        obj->link_up = link_up;
     483        obj->up = up;
     484
     485        if (wake && (obj->event_req == obj->event_res)) {
     486                obj->event_req++;
     487                rel_wai(MAIN_TASK);
     488        }
     489}
     490
     491void ntp_cli_state_changed(ntp_cli_state_t state)
     492{
     493        struct main_obj_t *obj = (struct main_obj_t *)&main_obj;
     494        bool_t wake = obj->ntp_state != state;
     495
     496        if (wake) {
     497                obj->ntp_state = state;
     498                obj->ntp = 1;
     499
     500                if (obj->event_req == obj->event_res) {
     501                        obj->event_req++;
     502                        rel_wai(MAIN_TASK);
     503                }
     504        }
     505}
     506#endif
    297507
    298508/*
    … …  
    302512{
    303513        shellcmd_state = 1;
    304         shellcmd_exit_code = ntopt_parse(command, usrcmd_ntopt_callback, NULL);
     514
     515        if (setjmp(shellcmd_exit) == 0) {
     516                shellcmd_exit_code = ntopt_parse(command, usrcmd_ntopt_callback, NULL);
     517        }
     518
     519        //fflush(stdout);
     520        clean_fd();
     521
    305522        shellcmd_state = 2;
    306523}
    … …  
    315532        {"hexdump", "Hex dump", usrcmd_hexdump},
    316533        {"date", "print date and time", usrcmd_date},
     534#ifndef NTSHELL_NO_SOCKET
     535        {"ping", "ping", usrcmd_ping},
     536        {"dhcpc", "DHCP Client rel/renew/info", usrcmd_dhcp4c},
     537        {"dnsc", "DNS client", usrcmd_dnsc },
     538        {"ntpc", "NTP client", usrcmd_ntpc },
     539#endif
    317540        {"info", "This is a description text string for info command.", usrcmd_info},
    318541        {"exit", "Exit Natural Tiny Shell", usrcmd_exit},
    … …  
    330553
    331554        if (ntlibc_strcmp((const char *)args[1], "help") == 0) {
    332                 usrcmd_help(args[0], (char **)&args[1]);
     555                found = 1;
     556                result = usrcmd_help(args[0], (char **)&args[1]);
    333557        }
    334558        else for (int i = 0; i < cmd_table_info.count; i++) {
    335559                if (ntlibc_strcmp((const char *)args[1], p->cmd) == 0) {
    336                         return p->func(args[0], (char **)&args[1]);
     560                        found = 1;
     561                        result = p->func(args[0], (char **)&args[1]);
     562                        break;
    337563                }
    338564                p++;
    339565        }
    340         if (setjmp(shellcmd_exit) == 0) {
    341                 (*((PowerOn_Reset_t *)0x18220000))(args);
    342         }
    343         clean_fd();
    344         return 0;
     566
     567        if ((found == 0) && setjmp(shellcmd_exit) == 0) {
     568                found = 1;
     569                (*((PowerOn_Reset_t *)0x18200000))(args);
     570        }
     571
     572        if ((found == 0) && (((const char *)args[1])[0] != '\0'))
     573                ntstdio_printf(ntstdio, "Unknown command found. %s \n", (const char *)args[1]);
     574
     575        return result;
    345576}
    346577
    … …  
    349580        const cmd_table_t *p = cmd_table_info.table;
    350581        for (int i = 0; i < cmd_table_info.count; i++) {
    351                 ntstdio_puts(&ntstdio, p->cmd);
    352                 ntstdio_puts(&ntstdio, "\t:");
    353                 ntstdio_puts(&ntstdio, p->desc);
    354                 ntstdio_puts(&ntstdio, "\n");
     582                ntstdio_puts(ntstdio, p->cmd);
     583                ntstdio_puts(ntstdio, "\t:");
     584                ntstdio_puts(ntstdio, p->desc);
     585                ntstdio_puts(ntstdio, "\n");
    355586                p++;
    356587        }
    … …  
    372603void shell_abort()
    373604{
    374         asm("bkpt #0");
    375 
    376605        shellcmd_exit_code = -1;
    377606        longjmp(shellcmd_exit, 1);
    … …  
    390619}
    391620
    392 int execute_command(int wait)
    393 {
     621int execute_command(struct main_obj_t *obj, int wait)
     622{
     623        T_RTSK rtsk;
    394624        ER ret;
    395625
    … …  
    399629        }
    400630
    401         tslp_tsk(100000);
     631        if (ret == E_OK)
     632                tslp_tsk(100000);
    402633
    403634        clean_fd();
    … …  
    413644
    414645        do {
    415                 tslp_tsk(100000);
     646                obj->state = main_state_servey_cmd;
     647                obj->timer = 100000;
     648
     649                char c;
     650                if (obj->ntshell.func_read(&c, sizeof(c), obj->ntshell.extobj) == 1) {
     651                        // Ctrl+Cが押された場合
     652                        if (c == 0x03) {
     653                                // コマンドタスクを終了
     654                                ret = ter_tsk(SHELLCMD_TASK);
     655                                if (ret != E_OK) {
     656                                        syslog(LOG_ERROR, "ter_tsk => %d", ret);
     657                                }
     658                                shellcmd_exit_code = -1;
     659                                shellcmd_state = 4;
     660                                if (ret == E_OK)
     661                                        tslp_tsk(100000);
     662                                break;
     663                        }
     664
     665                        stdio_input(c);
     666                }
     667
     668                ret = ref_tsk(SHELLCMD_TASK, &rtsk);
     669                if ((ret != E_OK) || (rtsk.tskstat == TTS_DMT))
     670                        shellcmd_state = 3;
    416671        } while(shellcmd_state == 1);
    417672
     673        obj->state = main_state_idle;
     674        obj->timer = TMO_FEVR;
     675
     676        clean_fd();
     677
    418678        return shellcmd_exit_code;
    419679}
    … …  
    421681int shell_clock_getres(clockid_t clk_id, struct timespec *res)
    422682{
    423         if (clk_id != CLOCK_REALTIME)
     683        if ((clk_id != CLOCK_REALTIME) && (clk_id != CLOCK_MONOTONIC))
    424684                return -EINVAL;
    425685
    … …  
    434694        SYSTIM now = 0;
    435695
    436         if (clk_id != CLOCK_REALTIME)
     696        if ((clk_id != CLOCK_REALTIME) && (clk_id != CLOCK_MONOTONIC))
    437697                return -EINVAL;
    438698
    … …  
    446706int shell_clock_settime(clockid_t clk_id, const struct timespec *tp)
    447707{
    448         if (clk_id != CLOCK_REALTIME)
     708        if ((clk_id != CLOCK_REALTIME) && (clk_id != CLOCK_MONOTONIC))
    449709                return -EINVAL;
    450710
    451         rtc_write(tp->tv_sec);
     711        SYSTIM time;
     712        ER ret;
     713
     714        time = (tp->tv_sec * 1000000ll) + (tp->tv_nsec / 1000ll);
     715
     716        ret = set_tim(time);
     717        if (ret != E_OK) {
     718                return -EPERM;
     719        }
    452720
    453721        return 0;
    … …  
    482750}
    483751
    484 struct sigaction sigtable[6];
    485 
    486 int shell_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
    487 {
    488         struct sigaction *sat;
     752// musl-1.1.18\src\internal\ksigaction.h
     753struct k_sigaction {
     754        void(*handler)(int);
     755        unsigned long flags;
     756        void(*restorer)(void);
     757        unsigned mask[2];
     758};
     759
     760struct k_sigaction sigtable[7];
     761
     762int shell_sigaction(int sig, const struct k_sigaction *restrict sa,
     763        struct k_sigaction *restrict old, size_t size)
     764{
     765        struct k_sigaction *sat;
    489766
    490767        switch(sig){
    … …  
    507784                sat = &sigtable[5];
    508785                break;
     786        case SIGPIPE:
     787                sat = &sigtable[6];
     788                break;
    509789        default:
    510790                return -EINVAL;
    … …  
    512792
    513793        if (old != NULL)
    514                 memcpy(old, sat, sizeof(struct sigaction));
    515 
    516         memcpy(sat, sa, sizeof(struct sigaction));
     794                memcpy(old, sat, offsetof(struct k_sigaction, mask) + size);
     795
     796        memcpy(sat, sa, offsetof(struct k_sigaction, mask) + size);
    517797
    518798        return 0;
    … …  
    524804}
    525805
    526 int stdio_close(struct _IO_FILE *fp)
    527 {
    528         return -EPERM;
    529 }
    530 
    531 size_t stdio_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
    532 {
    533         return -EPERM;
    534 }
    535 
    536 size_t stdio_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
    537 {
    538         return -EPERM;
    539 }
    540 
    541 size_t stdin_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
    542 {
    543         int i = 0;
    544         while (i < len) {
    545                 int c = ntstdio_getc(&ntstdio);
    546                 data[i++] = c;
    547                 if ((c == EOF) || (c == '\n'))
    548                         break;
    549         }
    550         return i;
    551 }
    552 
    553 size_t stdout_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
    554 {
    555         for (int i = 0; i < len; i++) {
    556                 ntstdio_putc(&ntstdio, data[i]);
    557         }
    558         return len;
    559 }
    560 
    561 size_t stderr_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
    562 {
    563         for (int i = 0; i < len; i++) {
    564                 ntstdio_putc(&ntstdio, data[i]);
    565         }
    566         return len;
    567 }
    568 
    569 int sio_close(struct _IO_FILE *fp)
    570 {
    571         return -EPERM;
    572 }
    573 
    574 size_t sio_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
    575 {
    576         return -EPERM;
    577 }
    578 
    579 size_t sio_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
    580 {
    581         return -EPERM;
    582 }
    583 
    584 off_t sio_seek(struct _IO_FILE *fp, off_t ofs, int org)
    585 {
    586         return -EPERM;
    587 }
    588 
    589 int sio_ioctl(struct _IO_FILE *fp, int request, void *arg)
    590 {
    591         switch (request) {
    592         case TIOCGWINSZ:
     806int shell_gettid()
     807{
     808        ID tskid;
     809        ER ret;
     810
     811        ret = get_tid(&tskid);
     812        if (ret != E_OK)
     813                return -1;
     814
     815        return tskid;
     816}
     817
     818int shell_tkill(int tid, int sig)
     819{
     820        if ((tid == SHELLCMD_TASK) && (sig == SIGABRT)) {
     821                shell_abort();
     822        }
     823
     824        no_implement("tkill");
     825        return -1;
     826}
     827
     828int shell_kill(int pid, int sig)
     829{
     830        DebugBreak();
     831        return -1;
     832}
     833
     834int shell_gettimeofday(struct timeval *tv, void *tzvp)
     835{
     836        SYSTIM time;
     837        if (!tv) return 0;
     838        get_tim(&time);
     839        tv->tv_sec = time / 1000000;
     840        tv->tv_usec = time - (tv->tv_sec * 1000000);
     841        return 0;
     842}
     843
     844int shell_nanosleep(const struct timespec *req, struct timespec *rem)
     845{
     846        ER ret;
     847        TMO tmo;
     848        SYSTIM prev, now, diff;
     849
     850        if ((req == NULL) || (req->tv_nsec < 0) || (req->tv_nsec >= 1000000000))
     851                return -EINVAL;
     852
     853        get_tim(&prev);
     854
     855        tmo = req->tv_sec * 1000000 + req->tv_nsec / 1000;
     856        ret = tslp_tsk(tmo);
     857        if (ret == E_OK) {
     858                if (rem != NULL) {
     859                        get_tim(&now);
     860                        diff = now - prev;
     861                        rem->tv_sec = diff / 1000000ll;
     862                        rem->tv_nsec = (diff - (rem->tv_sec * 1000000ll)) * 1000ll;
     863                }
    593864                return 0;
    594         case TCGETS:
    595                 return sio_tcgetattr(fp->fd, (struct termios *)arg);
    596         case TCSETS + TCSANOW:
    597         case TCSETS + TCSADRAIN:
    598         case TCSETS + TCSAFLUSH:
    599                 return sio_tcsetattr(fp->fd, request - TCSETS, (const struct termios *)arg);
    600         }
    601 
    602         return -EINVAL;
    603 }
    604 
     865        }
     866        else if (ret == E_TMOUT) {
     867                if (rem != NULL) {
     868                        rem->tv_sec = 0;
     869                        rem->tv_nsec = 0;
     870                }
     871                return 0;
     872        }
     873
     874        return -EFAULT;
     875}
     876
     877ssize_t shell_getrandom(void *buf, size_t buflen, unsigned int flags)
     878{
     879        SYSTIM now;
     880        int32_t i;
     881        int *output = (int *)buf;
     882        size_t sz = buflen / 4;
     883
     884        get_tim(&now);
     885        srand(now);
     886
     887        for (i = 0; i < sz; i++)
     888                output[i] = rand();
     889
     890        for (i = 4 * sz; i < buflen; i++)
     891                ((char *)buf)[i] = rand();
     892
     893        return buflen;
     894}
     895
     896extern uint32_t  __CmdBase;
     897extern uint32_t  __CmdLimit;
     898
     899void *shell_brk(void *addr)
     900{
     901        if (addr == 0) {
     902                return (void *)((intptr_t)&__CmdBase + 0x40000);
     903        }
     904        if ((addr >= (intptr_t)&__CmdBase + 0x40000) && (addr < &__CmdLimit)) {
     905                return addr;
     906        }
     907        return (void *)-1;
     908}
     909
     910void *shell_mmap2(void *start, size_t length, int prot, int flags, int fd, off_t pgoffset)
     911{
     912        if (fd != -1)
     913                return -EINVAL;
     914
     915        if ((length >= 0) && (length <= (intptr_t)&__CmdLimit - ((intptr_t)&__CmdBase + 0x40000))) {
     916                return &__CmdBase + 0x40000;
     917        }
     918        return (void *)-1;
     919}
     920
     921int shell_mprotect(void *addr, size_t len, int prot)
     922{
     923        //if ((addr >= (intptr_t)&__CmdBase + 0x40000) && ((intptr_t)addr + len < &__CmdLimit)) {
     924                return 0;
     925        //}
     926        //return -1;
     927}
Note: See TracChangeset for help on using the changeset viewer.