BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → / @ 9336

  → / @ 9337

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Regard whitespace Rev 9336 → Rev 9337

/kernel/trunk/runtests.py
15,7 → 15,7
sys.path.append('test')
import common
enable_umka = False
enable_umka = True
def log(s, end = "\n"):
print(s, end = end, flush = True)
171,7 → 171,7
return thread
def gcc(fin, fout):
flags = "-m32 -std=c11 -g -O0 -masm=intel -fno-pie"
flags = "-m32 -std=c11 -g -O0 -masm=intel -fno-pie -w"
defines = "-D_FILE_OFFSET_BITS=64 -DNDEBUG -D_POSIX_C_SOURCE=200809L"
include = "-Iumka -Iumka/linux"
command = f"gcc {flags} {defines} {include} -c {fin} -o {fout}"
183,7 → 183,9
flags = "-dUEFI=1 -dextended_primary_loader=1 -dUMKA=1"
files = "umka/umka.asm umka/build/umka.o -s umka/build/umka.fas"
memory = "-m 2000000"
os.system(f"{include} fasm {flags} {files} {memory}")
command = f"{include} fasm {flags} {files} {memory}"
print(command)
os.system(command)
def build_umka():
if not enable_umka:
196,11 → 198,9
"trace.c",
"trace_lbr.c",
"vdisk.c",
"vnet.c",
"lodepng.c",
"linux/pci.c",
"linux/thread.c",
"util.c" ]
"linux/thread.c" ]
sources = [f"umka/{f}" for f in sources]
objects = []
for source in sources:
211,7 → 211,9
build_umka_asm()
objects.append("umka/build/umka.o")
objects = " ".join(objects)
os.system(f"gcc -m32 -no-pie -o umka_shell -static -T umka/umka.ld {objects}")
command = f"gcc -m32 -no-pie -o umka_shell -static -T umka/umka.ld {objects}"
print(command)
os.system(command)
def create_relocated(root_dir, fname):
with open(fname, "rb") as f:
226,7 → 228,7
def run_umka_test(root_dir, test_file_path):
test = create_relocated(root_dir, test_file_path)
ref_log = create_relocated(root_dir, f"{test_file_path[:-2]}.ref.log")
out_log = create_relocated(root_dir, f"{test_file_path[:-2]}.out.log")
out_log = f"{test_file_path[:-2]}.out.log.o"
os.system(f"./umka_shell < {test} > {out_log}")
if os.system(f"cmp {ref_log} {out_log}") != 0:
print(f"FAILURE: {test_file_path}\n", end = "")

/kernel/trunk/umka/getopt.c
0,0 → 1,218
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include "getopt.h"
char *optarg;
int optind=1, opterr=1, optopt, __optpos, optreset=0;
#define optpos __optpos
static void __getopt_msg(const char *a, const char *b, const char *c, size_t l)
{
FILE *f = stderr;
#if !defined(WIN32) && !defined(_WIN32)
flockfile(f);
#endif
fputs(a, f);
fwrite(b, strlen(b), 1, f);
fwrite(c, 1, l, f);
fputc('\n', f);
#if !defined(WIN32) && !defined(_WIN32)
funlockfile(f);
#endif
}
int getopt(int argc, char * const argv[], const char *optstring)
{
int i, c, d;
int k, l;
char *optchar;
if (!optind || optreset) {
optreset = 0;
__optpos = 0;
optind = 1;
}
if (optind >= argc || !argv[optind])
return -1;
if (argv[optind][0] != '-') {
if (optstring[0] == '-') {
optarg = argv[optind++];
return 1;
}
return -1;
}
if (!argv[optind][1])
return -1;
if (argv[optind][1] == '-' && !argv[optind][2])
return optind++, -1;
if (!optpos) optpos++;
c = argv[optind][optpos], k = 1;
optchar = argv[optind]+optpos;
optopt = c;
optpos += k;
if (!argv[optind][optpos]) {
optind++;
optpos = 0;
}
if (optstring[0] == '-' || optstring[0] == '+')
optstring++;
i = 0;
d = 0;
do {
d = optstring[i], l = 1;
if (l>0) i+=l; else i++;
} while (l && d != c);
if (d != c) {
if (optstring[0] != ':' && opterr)
__getopt_msg(argv[0], ": unrecognized option: ", optchar, k);
return '?';
}
if (optstring[i] == ':') {
if (optstring[i+1] == ':') optarg = 0;
else if (optind >= argc) {
if (optstring[0] == ':') return ':';
if (opterr) __getopt_msg(argv[0],
": option requires an argument: ",
optchar, k);
return '?';
}
if (optstring[i+1] != ':' || optpos) {
optarg = argv[optind++] + optpos;
optpos = 0;
}
}
return c;
}
static void permute(char *const *argv, int dest, int src)
{
char **av = (char **)argv;
char *tmp = av[src];
int i;
for (i=src; i>dest; i--)
av[i] = av[i-1];
av[dest] = tmp;
}
static int __getopt_long_core(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx, int longonly)
{
optarg = 0;
if (longopts && argv[optind][0] == '-' &&
((longonly && argv[optind][1] && argv[optind][1] != '-') ||
(argv[optind][1] == '-' && argv[optind][2])))
{
int colon = optstring[optstring[0]=='+'||optstring[0]=='-']==':';
int i, cnt, match = -1;
char *opt;
for (cnt=i=0; longopts[i].name; i++) {
const char *name = longopts[i].name;
opt = argv[optind]+1;
if (*opt == '-') opt++;
for (; *name && *name == *opt; name++, opt++);
if (*opt && *opt != '=') continue;
match = i;
if (!*name) {
cnt = 1;
break;
}
cnt++;
}
if (cnt==1) {
i = match;
optind++;
optopt = longopts[i].val;
if (*opt == '=') {
if (!longopts[i].has_arg) {
if (colon || !opterr)
return '?';
__getopt_msg(argv[0],
": option does not take an argument: ",
longopts[i].name,
strlen(longopts[i].name));
return '?';
}
optarg = opt+1;
} else if (longopts[i].has_arg == required_argument) {
if (!(optarg = argv[optind])) {
if (colon) return ':';
if (!opterr) return '?';
__getopt_msg(argv[0],
": option requires an argument: ",
longopts[i].name,
strlen(longopts[i].name));
return '?';
}
optind++;
}
if (idx) *idx = i;
if (longopts[i].flag) {
*longopts[i].flag = longopts[i].val;
return 0;
}
return longopts[i].val;
}
if (argv[optind][1] == '-') {
if (!colon && opterr)
__getopt_msg(argv[0], cnt ?
": option is ambiguous: " :
": unrecognized option: ",
argv[optind]+2,
strlen(argv[optind]+2));
optind++;
return '?';
}
}
return getopt(argc, argv, optstring);
}
static int __getopt_long(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx, int longonly)
{
int ret, skipped, resumed;
if (!optind || optreset) {
optreset = 0;
__optpos = 0;
optind = 1;
}
if (optind >= argc || !argv[optind]) return -1;
skipped = optind;
if (optstring[0] != '+' && optstring[0] != '-') {
int i;
for (i=optind; ; i++) {
if (i >= argc || !argv[i]) return -1;
if (argv[i][0] == '-' && argv[i][1]) break;
}
optind = i;
}
resumed = optind;
ret = __getopt_long_core(argc, argv, optstring, longopts, idx, longonly);
if (resumed > skipped) {
int i, cnt = optind-resumed;
for (i=0; i<cnt; i++)
permute(argv, skipped, optind-1);
optind = skipped + cnt;
}
return ret;
}
int getopt_long(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx)
{
return __getopt_long(argc, argv, optstring, longopts, idx, 0);
}
int getopt_long_only(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx)
{
return __getopt_long(argc, argv, optstring, longopts, idx, 1);
}

/kernel/trunk/umka/getopt.h
0,0 → 1,54
/*
Copyright 2005-2014 Rich Felker, et al.
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.
*/
#ifndef _GETOPT_H
#define _GETOPT_H
#ifdef __cplusplus
extern "C" {
#endif
int getopt(int, char * const [], const char *);
extern char *optarg;
extern int optind, opterr, optopt, optreset;
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
int getopt_long(int, char *const *, const char *, const struct option *, int *);
int getopt_long_only(int, char *const *, const char *, const struct option *, int *);
#define no_argument 0
#define required_argument 1
#define optional_argument 2
#ifdef __cplusplus
}
#endif
#endif

/kernel/trunk/umka/shell.c
20,30 → 20,17
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
#include <limits.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <time.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include "getopt.h"
#include "vdisk.h"
#include "vnet.h"
#include "umka.h"
#include "trace.h"
#include "pci.h"
#include "util.h"
#include "lodepng.h"
#define PATH_MAX 4096
207,30 → 194,12
}
static int
next_line(int is_tty, int block) {
next_line(int is_tty) {
if (is_tty) {
prompt();
}
if (block) {
return fgets(cmd_buf, FGETS_BUF_LEN, fin) != NULL;
} else {
fd_set readfds;
// FD_ZERO(&readfds);
memset(&readfds, 0, sizeof(readfds));
FD_SET(fileno(fin), &readfds);
struct timeval timeout = {.tv_sec = 0, .tv_usec = 0};
int sr = select(fileno(fin)+1, &readfds, NULL, NULL, &timeout);
if (sr > 0) {
fgets(cmd_buf, FGETS_BUF_LEN, fin);
if (cmd_buf[0] == EOF) {
cmd_buf[0] = '\0';
}
} else {
cmd_buf[0] = '\0';
}
return 1;
}
}
static int
split_args(char *s, char **argv) {
1836,661 → 1805,6
}
static void
shell_stack_init(int argc, char **argv) {
const char *usage = \
"usage: stack_init";
if (argc != 1) {
fputs(usage, fout);
return;
}
(void)argv;
umka_stack_init();
}
static void
shell_net_add_device(int argc, char **argv) {
const char *usage = \
"usage: net_add_device";
if (argc != 1) {
fputs(usage, fout);
return;
}
(void)argv;
net_device_t *vnet = vnet_init(42); // FIXME: tap & list like block devices
int32_t dev_num = kos_net_add_device(vnet);
fprintf(fout, "device number: %" PRIi32 "\n", dev_num);
}
static void
shell_net_get_dev_count(int argc, char **argv) {
const char *usage = \
"usage: net_get_dev_count";
if (argc != 1) {
fputs(usage, fout);
return;
}
(void)argv;
uint32_t count = umka_sys_net_get_dev_count();
fprintf(fout, "active network devices: %u\n", count);
}
static void
shell_net_get_dev_type(int argc, char **argv) {
const char *usage = \
"usage: net_get_dev_type <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
int32_t dev_type = umka_sys_net_get_dev_type(dev_num);
fprintf(fout, "status: %s\n", dev_type == -1 ? "fail" : "ok");
if (dev_type != -1) {
fprintf(fout, "type of network device #%" PRIu8 ": %i\n",
dev_num, dev_type);
}
}
static void
shell_net_get_dev_name(int argc, char **argv) {
const char *usage = \
"usage: net_get_dev_name <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
char dev_name[64];
uint8_t dev_num = strtoul(argv[1], NULL, 0);
int32_t status = umka_sys_net_get_dev_name(dev_num, dev_name);
fprintf(fout, "status: %s\n", status == -1 ? "fail" : "ok");
if (status != -1) {
fprintf(fout, "name of network device #%" PRIu8 ": %s\n",
dev_num, dev_name);
}
}
static void
shell_net_dev_reset(int argc, char **argv) {
const char *usage = \
"usage: net_dev_reset <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
int32_t status = umka_sys_net_dev_reset(dev_num);
fprintf(fout, "status: %s\n", status == -1 ? "fail" : "ok");
}
static void
shell_net_dev_stop(int argc, char **argv) {
const char *usage = \
"usage: net_dev_stop <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
int32_t status = umka_sys_net_dev_stop(dev_num);
fprintf(fout, "status: %s\n", status == -1 ? "fail" : "ok");
}
static void
shell_net_get_dev(int argc, char **argv) {
const char *usage = \
"usage: net_get_dev <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
intptr_t dev = umka_sys_net_get_dev(dev_num);
fprintf(fout, "status: %s\n", dev == -1 ? "fail" : "ok");
if (dev != -1) {
fprintf(fout, "address of net dev #%" PRIu8 ": 0x%x\n", dev_num, dev);
}
}
static void
shell_net_get_packet_tx_count(int argc, char **argv) {
const char *usage = \
"usage: net_get_packet_tx_count <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t count = umka_sys_net_get_packet_tx_count(dev_num);
fprintf(fout, "status: %s\n", count == UINT32_MAX ? "fail" : "ok");
if (count != UINT32_MAX) {
fprintf(fout, "packet tx count of net dev #%" PRIu8 ": %" PRIu32 "\n",
dev_num, count);
}
}
static void
shell_net_get_packet_rx_count(int argc, char **argv) {
const char *usage = \
"usage: net_get_packet_rx_count <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t count = umka_sys_net_get_packet_rx_count(dev_num);
fprintf(fout, "status: %s\n", count == UINT32_MAX ? "fail" : "ok");
if (count != UINT32_MAX) {
fprintf(fout, "packet rx count of net dev #%" PRIu8 ": %" PRIu32 "\n",
dev_num, count);
}
}
static void
shell_net_get_byte_tx_count(int argc, char **argv) {
const char *usage = \
"usage: net_get_byte_tx_count <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t count = umka_sys_net_get_byte_tx_count(dev_num);
fprintf(fout, "status: %s\n", count == UINT32_MAX ? "fail" : "ok");
if (count != UINT32_MAX) {
fprintf(fout, "byte tx count of net dev #%" PRIu8 ": %" PRIu32 "\n",
dev_num, count);
}
}
static void
shell_net_get_byte_rx_count(int argc, char **argv) {
const char *usage = \
"usage: net_get_byte_rx_count <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t count = umka_sys_net_get_byte_rx_count(dev_num);
fprintf(fout, "status: %s\n", count == UINT32_MAX ? "fail" : "ok");
if (count != UINT32_MAX) {
fprintf(fout, "byte rx count of net dev #%" PRIu8 ": %" PRIu32 "\n",
dev_num, count);
}
}
static void
print_link_status_names(uint32_t status) {
switch (status & 0x3) {
case ETH_LINK_DOWN:
fprintf(fout, "ETH_LINK_DOWN");
break;
case ETH_LINK_UNKNOWN:
fprintf(fout, "ETH_LINK_UNKNOWN");
break;
case ETH_LINK_FD:
fprintf(fout, "ETH_LINK_FD");
break;
default:
fprintf(fout, "ERROR");
break;
}
switch(status & ~3u) {
case ETH_LINK_1G:
fprintf(fout, " + ETH_LINK_1G");
break;
case ETH_LINK_100M:
fprintf(fout, " + ETH_LINK_100M");
break;
case ETH_LINK_10M:
fprintf(fout, " + ETH_LINK_10M");
break;
default:
fprintf(fout, " + UNKNOWN");
break;
}
}
static void
shell_net_get_link_status(int argc, char **argv) {
const char *usage = \
"usage: net_get_link_status <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint8_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t status = umka_sys_net_get_link_status(dev_num);
fprintf(fout, "status: %s\n", status == UINT32_MAX ? "fail" : "ok");
if (status != UINT32_MAX) {
fprintf(fout, "link status of net dev #%" PRIu8 ": %" PRIu32 " ",
dev_num, status);
print_link_status_names(status);
putchar('\n');
}
}
static void
shell_net_open_socket(int argc, char **argv) {
const char *usage = \
"usage: net_open_socket <domain> <type> <protocol>\n"
" domain domain\n"
" type type\n"
" protocol protocol";
if (argc != 4) {
fputs(usage, fout);
return;
}
uint32_t domain = strtoul(argv[1], NULL, 0);
uint32_t type = strtoul(argv[2], NULL, 0);
uint32_t protocol = strtoul(argv[3], NULL, 0);
f75ret_t r = umka_sys_net_open_socket(domain, type, protocol);
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
// UINT32_MAX
}
static void
shell_net_close_socket(int argc, char **argv) {
const char *usage = \
"usage: net_close_socket <socket number>\n"
" socket number socket number";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t fd = strtoul(argv[1], NULL, 0);
f75ret_t r = umka_sys_net_close_socket(fd);
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
}
static void
shell_net_bind(int argc, char **argv) {
const char *usage = \
"usage: net_bind <fd> <port> <ip>\n"
" fd socket number\n"
" port port\n"
" addr addr";
if (argc != 4) {
fputs(usage, fout);
return;
}
uint32_t fd = strtoul(argv[1], NULL, 0);
uint16_t port = strtoul(argv[2], NULL, 0);
char *addr_str = argv[3];
uint32_t addr = inet_addr(addr_str);
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET4;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = addr;
fprintf(fout, "sockaddr at %p\n", (void*)&sa);
f75ret_t r = umka_sys_net_bind(fd, &sa, sizeof(struct sockaddr_in));
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
}
static void
shell_net_listen(int argc, char **argv) {
const char *usage = \
"usage: net_listen <fd> <backlog>\n"
" fd socket number\n"
" backlog max queue length";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t fd = strtoul(argv[1], NULL, 0);
uint32_t backlog = strtoul(argv[2], NULL, 0);
f75ret_t r = umka_sys_net_listen(fd, backlog);
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
}
static void
shell_net_connect(int argc, char **argv) {
const char *usage = \
"usage: net_connect <fd> <port> <ip>\n"
" fd socket number\n"
" port port\n"
" addr addr";
if (argc != 4) {
fputs(usage, fout);
return;
}
uint32_t fd = strtoul(argv[1], NULL, 0);
uint16_t port = strtoul(argv[2], NULL, 0);
char *addr_str = argv[3];
uint32_t addr = inet_addr(addr_str);
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET4;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = addr;
fprintf(fout, "sockaddr at %p\n", (void*)&sa);
f75ret_t r = umka_sys_net_connect(fd, &sa, sizeof(struct sockaddr_in));
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
}
static void
shell_net_accept(int argc, char **argv) {
const char *usage = \
"usage: net_accept <fd> <port> <ip>\n"
" fd socket number\n"
" port port\n"
" addr addr";
if (argc != 4) {
fputs(usage, fout);
return;
}
uint32_t fd = strtoul(argv[1], NULL, 0);
uint16_t port = strtoul(argv[2], NULL, 0);
char *addr_str = argv[3];
uint32_t addr = inet_addr(addr_str);
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET4;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = addr;
fprintf(fout, "sockaddr at %p\n", (void*)&sa);
f75ret_t r = umka_sys_net_accept(fd, &sa, sizeof(struct sockaddr_in));
fprintf(fout, "value: 0x%" PRIx32 "\n", r.value);
fprintf(fout, "errorcode: 0x%" PRIx32 "\n", r.errorcode);
}
static void
shell_net_eth_read_mac(int argc, char **argv) {
const char *usage = \
"usage: net_eth_read_mac <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_eth_read_mac(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
(uint8_t)(r.ebx >> 0), (uint8_t)(r.ebx >> 8),
(uint8_t)(r.eax >> 0), (uint8_t)(r.eax >> 8),
(uint8_t)(r.eax >> 16), (uint8_t)(r.eax >> 24));
}
}
static void
shell_net_ipv4_get_addr(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_get_addr <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_ipv4_get_addr(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%d.%d.%d.%d\n",
(uint8_t)(r.eax >> 0), (uint8_t)(r.eax >> 8),
(uint8_t)(r.eax >> 16), (uint8_t)(r.eax >> 24));
}
}
static void
shell_net_ipv4_set_addr(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_set_addr <dev_num> <addr>\n"
" dev_num device number as returned by net_add_device\n"
" addr a.b.c.d";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
char *addr_str = argv[2];
uint32_t addr = inet_addr(addr_str);
f76ret_t r = umka_sys_net_ipv4_set_addr(dev_num, addr);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "status: ok\n");
}
}
static void
shell_net_ipv4_get_dns(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_get_dns <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_ipv4_get_dns(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%d.%d.%d.%d\n",
(uint8_t)(r.eax >> 0), (uint8_t)(r.eax >> 8),
(uint8_t)(r.eax >> 16), (uint8_t)(r.eax >> 24));
}
}
static void
shell_net_ipv4_set_dns(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_set_dns <dev_num> <dns>\n"
" dev_num device number as returned by net_add_device\n"
" dns a.b.c.d";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t dns = inet_addr(argv[2]);
f76ret_t r = umka_sys_net_ipv4_set_dns(dev_num, dns);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "status: ok\n");
}
}
static void
shell_net_ipv4_get_subnet(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_get_subnet <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_ipv4_get_subnet(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%d.%d.%d.%d\n",
(uint8_t)(r.eax >> 0), (uint8_t)(r.eax >> 8),
(uint8_t)(r.eax >> 16), (uint8_t)(r.eax >> 24));
}
}
static void
shell_net_ipv4_set_subnet(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_set_subnet <dev_num> <subnet>\n"
" dev_num device number as returned by net_add_device\n"
" subnet a.b.c.d";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
char *subnet_str = argv[2];
uint32_t subnet = inet_addr(subnet_str);
f76ret_t r = umka_sys_net_ipv4_set_subnet(dev_num, subnet);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "status: ok\n");
}
}
static void
shell_net_ipv4_get_gw(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_get_gw <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_ipv4_get_gw(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%d.%d.%d.%d\n",
(uint8_t)(r.eax >> 0), (uint8_t)(r.eax >> 8),
(uint8_t)(r.eax >> 16), (uint8_t)(r.eax >> 24));
}
}
static void
shell_net_ipv4_set_gw(int argc, char **argv) {
const char *usage = \
"usage: net_ipv4_set_gw <dev_num> <gw>\n"
" dev_num device number as returned by net_add_device\n"
" gw a.b.c.d";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
char *gw_str = argv[2];
uint32_t gw = inet_addr(gw_str);
f76ret_t r = umka_sys_net_ipv4_set_gw(dev_num, gw);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "status: ok\n");
}
}
static void
shell_net_arp_get_count(int argc, char **argv) {
const char *usage = \
"usage: net_arp_get_count <dev_num>\n"
" dev_num device number as returned by net_add_device";
if (argc != 2) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
f76ret_t r = umka_sys_net_arp_get_count(dev_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "%" PRIi32 "\n", r.eax);
}
}
static void
shell_net_arp_get_entry(int argc, char **argv) {
const char *usage = \
"usage: net_arp_get_entry <dev_num> <arp_num>\n"
" dev_num device number as returned by net_add_device\n"
" arp_num arp number as returned by net_add_device";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
uint32_t arp_num = strtoul(argv[2], NULL, 0);
arp_entry_t arp;
f76ret_t r = umka_sys_net_arp_get_entry(dev_num, arp_num, &arp);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
} else {
fprintf(fout, "arp #%u: IP %d.%d.%d.%d, "
"mac %2.2" SCNu8 ":%2.2" SCNu8 ":%2.2" SCNu8
":%2.2" SCNu8 ":%2.2" SCNu8 ":%2.2" SCNu8 ", "
"status %" PRIu16 ", "
"ttl %" PRIu16 "\n",
arp_num,
(uint8_t)(arp.ip >> 0), (uint8_t)(arp.ip >> 8),
(uint8_t)(arp.ip >> 16), (uint8_t)(arp.ip >> 24),
arp.mac[0], arp.mac[1], arp.mac[2],
arp.mac[3], arp.mac[4], arp.mac[5],
arp.status, arp.ttl);
}
}
static void
shell_net_arp_add_entry(int argc, char **argv) {
const char *usage = \
"usage: net_arp_add_entry <dev_num> <addr> <mac> <status> <ttl>\n"
" dev_num device number as returned by net_add_device\n"
" addr IP addr\n"
" mac ethernet addr\n"
" status see ARP.inc\n"
" ttl Time to live";
if (argc != 6) {
fputs(usage, fout);
return;
}
arp_entry_t arp;
uint32_t dev_num = strtoul(argv[1], NULL, 0);
arp.ip = inet_addr(argv[2]);
sscanf(argv[3], "%" SCNu8 ":%" SCNu8 ":%" SCNu8
":%" SCNu8 ":%" SCNu8 ":%" SCNu8,
arp.mac+0, arp.mac+1, arp.mac+2,
arp.mac+3, arp.mac+4, arp.mac+5);
arp.status = strtoul(argv[4], NULL, 0);
arp.ttl = strtoul(argv[5], NULL, 0);
f76ret_t r = umka_sys_net_arp_add_entry(dev_num, &arp);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
}
}
static void
shell_net_arp_del_entry(int argc, char **argv) {
const char *usage = \
"usage: net_arp_del_entry <dev_num> <arp_num>\n"
" dev_num device number as returned by net_add_device\n"
" arp_num arp number as returned by net_add_device";
if (argc != 3) {
fputs(usage, fout);
return;
}
uint32_t dev_num = strtoul(argv[1], NULL, 0);
int32_t arp_num = strtoul(argv[2], NULL, 0);
f76ret_t r = umka_sys_net_arp_del_entry(dev_num, arp_num);
if (r.eax == UINT32_MAX) {
fprintf(fout, "status: fail\n");
}
}
static void
shell_bg_set_size(int argc, char **argv) {
const char *usage = \
"usage: bg_set_size <xsize> <ysize>\n"
2635,37 → 1949,6
{ "ls80", shell_ls80 },
{ "move_window", shell_move_window },
{ "mouse_move", shell_mouse_move },
{ "net_accept", shell_net_accept },
{ "net_add_device", shell_net_add_device },
{ "net_arp_add_entry", shell_net_arp_add_entry },
{ "net_arp_del_entry", shell_net_arp_del_entry },
{ "net_arp_get_count", shell_net_arp_get_count },
{ "net_arp_get_entry", shell_net_arp_get_entry },
{ "net_bind", shell_net_bind },
{ "net_close_socket", shell_net_close_socket },
{ "net_connect", shell_net_connect },
{ "net_dev_reset", shell_net_dev_reset },
{ "net_dev_stop", shell_net_dev_stop },
{ "net_eth_read_mac", shell_net_eth_read_mac },
{ "net_get_byte_rx_count", shell_net_get_byte_rx_count },
{ "net_get_byte_tx_count", shell_net_get_byte_tx_count },
{ "net_get_dev", shell_net_get_dev },
{ "net_get_dev_count", shell_net_get_dev_count },
{ "net_get_dev_name", shell_net_get_dev_name },
{ "net_get_dev_type", shell_net_get_dev_type },
{ "net_get_link_status", shell_net_get_link_status },
{ "net_get_packet_rx_count", shell_net_get_packet_rx_count },
{ "net_get_packet_tx_count", shell_net_get_packet_tx_count },
{ "net_ipv4_get_addr", shell_net_ipv4_get_addr },
{ "net_ipv4_get_dns", shell_net_ipv4_get_dns },
{ "net_ipv4_get_gw", shell_net_ipv4_get_gw },
{ "net_ipv4_get_subnet", shell_net_ipv4_get_subnet },
{ "net_ipv4_set_addr", shell_net_ipv4_set_addr },
{ "net_ipv4_set_dns", shell_net_ipv4_set_dns },
{ "net_ipv4_set_gw", shell_net_ipv4_set_gw },
{ "net_ipv4_set_subnet", shell_net_ipv4_set_subnet },
{ "net_listen", shell_net_listen },
{ "net_open_socket", shell_net_open_socket },
{ "pci_get_path", shell_pci_get_path },
{ "pci_set_path", shell_pci_set_path },
{ "process_info", shell_process_info },
2685,7 → 1968,6
{ "set_skin", shell_set_skin },
{ "set_window_caption", shell_set_window_caption },
{ "set_window_colors", shell_set_window_colors },
{ "stack_init", shell_stack_init },
{ "stat70", shell_stat70 },
{ "stat80", shell_stat80 },
{ "window_redraw", shell_window_redraw },
2728,12 → 2010,12
}
void *
run_test(FILE *in, FILE *out, int block) {
run_test(FILE *in, FILE *out) {
fin = in;
fout = out;
int is_tty = isatty(fileno(fin));
int is_tty = 0; // isatty(fileno(fin));
char **argv = (char**)malloc(sizeof(char*) * (MAX_COMMAND_ARGS + 1));
while(next_line(is_tty, block)) {
while(next_line(is_tty)) {
if (cmd_buf[0] == '#' || cmd_buf[0] == '\n' || cmd_buf[0] == '\0' ||
cmd_buf[0] == '\r') {
fprintf(fout, "%s", cmd_buf);

/kernel/trunk/umka/shell.h
3,6 → 3,6
#include <stdio.h>
void *run_test(FILE *in, FILE *out, int block);
void *run_test(FILE *in, FILE *out);
#endif // SHELL_H_INCLUDED

/kernel/trunk/umka/test/012_#f70_#f70s1_#xfs_#v5_#s05k_ls_all_dir_types_ftype1.t
File deleted

/kernel/trunk/umka/test/006_#f70_#f70s0_#xfs_#s05k_read_with_holes.ref.log
File deleted

/kernel/trunk/umka/test/008_#f70_#f70s1_#xfs_#s4k_ls_all_dir_types_ftype0.ref.log
File deleted

/kernel/trunk/umka/test/004_#f70_#f70s5_#xfs_stat.ref.log
File deleted

/kernel/trunk/umka/test/008_#f70_#f70s1_#xfs_#s4k_ls_all_dir_types_ftype0.t
File deleted

/kernel/trunk/umka/test/004_#f70_#f70s5_#xfs_stat.t
File deleted

/kernel/trunk/umka/test/011_#f70_#f70s1_#xfs_#lookup_#unicode_all.ref.log
File deleted

/kernel/trunk/umka/test/009_#f70_#f70s0_#f70s1_#xfs_#s05k_#xattr.ref.log
File deleted

/kernel/trunk/umka/test/006_#f70_#f70s0_#xfs_#s05k_read_with_holes.t
File deleted

/kernel/trunk/umka/test/011_#f70_#f70s1_#xfs_#lookup_#unicode_all.t
File deleted

/kernel/trunk/umka/test/015_#f70_#f70s0_#xfs_#v5_#s05k_read_without_holes.t
File deleted

/kernel/trunk/umka/test/022_#net_#f74_all.d
File deleted

/kernel/trunk/umka/test/017_#f70_#f70s0_#xfs_#s05k_read_above_4GiB.ref.log
File deleted

/kernel/trunk/umka/test/003_#f70_#f70s0_#xfs_#s05k_read_without_holes.t
File deleted

/kernel/trunk/umka/test/005_#f30_#xfs_cur_dir.ref.log
File deleted

/kernel/trunk/umka/test/025_#net_#arp_#f76_all.d
File deleted

/kernel/trunk/umka/test/002_#f70_#f70s1_#xfs_#s05k_ls_all_dir_types_ftype0.ref.log
File deleted

/kernel/trunk/umka/test/014_#f70_#f70s0_#xfs_#v5_#s05k_read_with_holes.ref.log
File deleted

/kernel/trunk/umka/test/010_#f70_#xfs_#lookup_#xattr_all.t
File deleted

/kernel/trunk/umka/test/005_#f30_#xfs_cur_dir.t
File deleted

/kernel/trunk/umka/test/019_#xfs_deep_btree.ref.log
File deleted

/kernel/trunk/umka/test/017_#f70_#f70s0_#xfs_#s05k_read_above_4GiB.t
File deleted

/kernel/trunk/umka/test/002_#f70_#f70s1_#xfs_#s05k_ls_all_dir_types_ftype0.t
File deleted

/kernel/trunk/umka/test/014_#f70_#f70s0_#xfs_#v5_#s05k_read_with_holes.t
File deleted

/kernel/trunk/umka/test/009_#f70_#f70s0_#f70s1_#xfs_#s05k_#xattr.t
File deleted

/kernel/trunk/umka/test/015_#f70_#f70s0_#xfs_#v5_#s05k_read_without_holes.ref.log
File deleted

/kernel/trunk/umka/test/018_#xfs_#coverage_all.ref.log
File deleted

/kernel/trunk/umka/test/019_#xfs_deep_btree.t
File deleted

/kernel/trunk/umka/test/003_#f70_#f70s0_#xfs_#s05k_read_without_holes.ref.log
File deleted

/kernel/trunk/umka/test/012_#f70_#f70s1_#xfs_#v5_#s05k_ls_all_dir_types_ftype1.ref.log
File deleted

/kernel/trunk/umka/test/023_#net_#f75_all.d
File deleted

/kernel/trunk/umka/test/007_#f70_#xfs_#lookup_all.ref.log
File deleted

/kernel/trunk/umka/test/024_#net_#f76_all.d
File deleted

/kernel/trunk/umka/test/013_#f70_#xfs_#v5_#lookup_all.ref.log
File deleted

/kernel/trunk/umka/test/007_#f70_#xfs_#lookup_all.t
File deleted

/kernel/trunk/umka/test/018_#xfs_#coverage_all.t
File deleted

/kernel/trunk/umka/test/013_#f70_#xfs_#v5_#lookup_all.t
File deleted

/kernel/trunk/umka/test/010_#f70_#xfs_#lookup_#xattr_all.ref.log
File deleted

/kernel/trunk/umka/trace.h
5,9 → 5,9
extern uint32_t coverage;
#define COVERAGE_ON() do { trace_resume(coverage); } while (0)
#define COVERAGE_ON()
#define COVERAGE_OFF() do { coverage = trace_pause(); } while (0)
#define COVERAGE_OFF()
void trace_begin(void);
void trace_end(void);

/kernel/trunk/umka/umka.h
1,9 → 1,8
#ifndef UMKA_H_INCLUDED
#define UMKA_H_INCLUDED
#include <inttypes.h>
#include <stdint.h>
#include <stddef.h>
#include <signal.h> // for irq0: siginfo_t
#define STDCALL __attribute__((__stdcall__))
397,7 → 396,7
kos_osloop(void);
void
irq0(int signo, siginfo_t *info, void *context);
irq0(int signo, void *info_unused, void *context);
void
umka_init(void);

/kernel/trunk/umka/umka_shell.c
16,15 → 16,11
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "shell.h"
#include "umka.h"
#include "trace.h"
53,7 → 49,6
while (argc) {
if (!strcmp(argv[0], "-c")) {
coverage = 1;
argc -= 1;
argv += 1;
continue;
86,13 → 81,7
}
}
if (coverage)
trace_begin();
run_test(fin, fout);
run_test(fin, fout, 1);
if (coverage)
trace_end();
return 0;
}

/kernel/trunk/umka/vdisk.c
1,8 → 1,8
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <errno.h>
#include "umka.h"
#include "trace.h"
#include "vdisk.h"

/kernel/trunk/umka/vdisk.h
2,7 → 2,7
#define VDISK_H_INCLUDED
#include <stdio.h>
#include <inttypes.h>
#include "umka.h"
void *vdisk_init(const char *fname, int adjust_cache_size, size_t cache_size);