static int adb_port_init(kbd_dev_t *kdev)
{
kbd_dev = kdev;
const char *dev = "adb/kbd";
service_id_t service_id;
int rc = loc_service_get_id(dev, &service_id, 0);
if (rc != EOK)
return rc;
dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
if (dev_sess == NULL) {
printf("%s: Failed to connect to device\n", NAME);
return ENOENT;
}
async_exch_t *exch = async_exchange_begin(dev_sess);
if (exch == NULL) {
printf("%s: Failed starting exchange with device\n", NAME);
async_hangup(dev_sess);
return ENOMEM;
}
rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
async_exchange_end(exch);
if (rc != EOK) {
printf("%s: Failed to create callback from device\n", NAME);
async_hangup(dev_sess);
return rc;
}
return EOK;
}
int vbd_create(vbd_t **rvbd)
{
vbd_t *vbd;
service_id_t vbd_svcid;
int rc;
vbd = calloc(1, sizeof(vbd_t));
if (vbd == NULL) {
rc = ENOMEM;
goto error;
}
rc = loc_service_get_id(SERVICE_NAME_VBD, &vbd_svcid,
IPC_FLAG_BLOCKING);
if (rc != EOK) {
rc = EIO;
goto error;
}
vbd->sess = loc_service_connect(vbd_svcid, INTERFACE_VBD,
IPC_FLAG_BLOCKING);
if (vbd->sess == NULL) {
rc = EIO;
goto error;
}
*rvbd = vbd;
return EOK;
error:
free(vbd);
return rc;
}
/**
* Start a new audio session.
* @param service Named service typically 'HOUND_SERVICE' constant.
* @return Valid session on success, NULL on failure.
*/
hound_sess_t *hound_service_connect(const char *service)
{
service_id_t id = 0;
const int ret =
loc_service_get_id(service, &id, IPC_FLAG_BLOCKING);
if (ret != EOK)
return NULL;
return loc_service_connect(id, INTERFACE_HOUND, IPC_FLAG_BLOCKING);
}
static int chardev_port_init(kbd_dev_t *kdev)
{
service_id_t service_id;
async_exch_t *exch;
unsigned int i;
int rc;
kbd_dev = kdev;
for (i = 0; i < num_devs; i++) {
rc = loc_service_get_id(in_devs[i], &service_id, 0);
if (rc == EOK)
break;
}
if (i >= num_devs) {
printf("%s: Could not find any suitable input device\n", NAME);
return -1;
}
dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
IPC_FLAG_BLOCKING);
if (dev_sess == NULL) {
printf("%s: Failed connecting to device\n", NAME);
return ENOENT;
}
exch = async_exchange_begin(dev_sess);
if (exch == NULL) {
printf("%s: Failed starting exchange with device\n", NAME);
async_hangup(dev_sess);
return ENOMEM;
}
/* NB: The callback connection is slotted for removal */
rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
async_exchange_end(exch);
if (rc != 0) {
printf("%s: Failed to create callback from device\n", NAME);
async_hangup(dev_sess);
return -1;
}
return 0;
}
/** Create UDP client instance.
*
* @param rudp Place to store pointer to new UDP client
* @return EOK on success, ENOMEM if out of memory, EIO if service
* cannot be contacted
*/
int udp_create(udp_t **rudp)
{
udp_t *udp;
service_id_t udp_svcid;
int rc;
udp = calloc(1, sizeof(udp_t));
if (udp == NULL) {
rc = ENOMEM;
goto error;
}
list_initialize(&udp->assoc);
fibril_mutex_initialize(&udp->lock);
fibril_condvar_initialize(&udp->cv);
rc = loc_service_get_id(SERVICE_NAME_UDP, &udp_svcid,
IPC_FLAG_BLOCKING);
if (rc != EOK) {
rc = EIO;
goto error;
}
udp->sess = loc_service_connect(udp_svcid, INTERFACE_UDP,
IPC_FLAG_BLOCKING);
if (udp->sess == NULL) {
rc = EIO;
goto error;
}
rc = udp_callback_create(udp);
if (rc != EOK) {
rc = EIO;
goto error;
}
*rudp = udp;
return EOK;
error:
free(udp);
return rc;
}
int inet_init(uint8_t protocol, inet_ev_ops_t *ev_ops)
{
service_id_t inet_svc;
int rc;
assert(inet_sess == NULL);
assert(inet_ev_ops == NULL);
assert(inet_protocol == 0);
rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
IPC_FLAG_BLOCKING);
if (rc != EOK)
return ENOENT;
inet_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
IPC_FLAG_BLOCKING);
if (inet_sess == NULL)
return ENOENT;
if (inet_set_proto(protocol) != EOK) {
async_hangup(inet_sess);
inet_sess = NULL;
return EIO;
}
if (inet_callback_create() != EOK) {
async_hangup(inet_sess);
inet_sess = NULL;
return EIO;
}
inet_protocol = protocol;
inet_ev_ops = ev_ops;
return EOK;
}
int main(int argc, char **argv)
{
int rc;
char *dev_path;
size_t block_size;
char *endptr;
aoff64_t block_offset = 0;
aoff64_t block_count = 1;
aoff64_t dev_nblocks;
bool toc = false;
if (argc < 2) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
--argc; ++argv;
if (str_cmp(*argv, "--toc") == 0) {
--argc; ++argv;
toc = true;
goto devname;
}
if (str_cmp(*argv, "--relative") == 0) {
--argc; ++argv;
relative = true;
}
if (str_cmp(*argv, "--offset") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing (offset).\n");
syntax_print();
return 1;
}
block_offset = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument (offset).\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
if (str_cmp(*argv, "--count") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing (count).\n");
syntax_print();
return 1;
}
block_count = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument (count).\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
devname:
if (argc != 1) {
printf(NAME ": Error, unexpected argument.\n");
syntax_print();
return 1;
}
dev_path = *argv;
rc = loc_service_get_id(dev_path, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", dev_path);
return 2;
}
rc = block_init(service_id, 2048);
if (rc != EOK) {
printf(NAME ": Error initializing libblock.\n");
return 2;
}
rc = block_get_bsize(service_id, &block_size);
if (rc != EOK) {
printf(NAME ": Error determining device block size.\n");
return 2;
}
rc = block_get_nblocks(service_id, &dev_nblocks);
if (rc != EOK) {
printf(NAME ": Warning, failed to obtain block device size.\n");
}
printf("Device %s has %" PRIuOFF64 " blocks, %" PRIuOFF64 " bytes each\n", dev_path, dev_nblocks, (aoff64_t) block_size);
if (toc)
rc = print_toc();
else
rc = print_blocks(block_offset, block_count, block_size);
block_fini(service_id);
return rc;
}
int main(int argc, char **argv)
{
sysarg_t baud = 38400;
service_id_t svc_id;
char *serial_port_name = NULL;
int arg = 1;
int rc;
isdv4_event_fn event_fn = emit_event;
if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
size_t arg_offset = str_lsize(argv[arg], 7);
char* arg_str = argv[arg] + arg_offset;
if (str_length(arg_str) == 0) {
fprintf(stderr, "--baud requires an argument\n");
syntax_print();
return 1;
}
char *endptr;
baud = strtol(arg_str, &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Invalid value for baud\n");
syntax_print();
return 1;
}
arg++;
}
if (argc > arg && str_cmp(argv[arg], "--print-events") == 0) {
event_fn = print_and_emit_event;
arg++;
}
if (argc > arg) {
serial_port_name = argv[arg];
rc = loc_service_get_id(serial_port_name, &svc_id, 0);
if (rc != EOK) {
fprintf(stderr, "Cannot find device service %s\n",
argv[arg]);
return 1;
}
arg++;
}
else {
category_id_t serial_cat_id;
rc = loc_category_get_id("serial", &serial_cat_id, 0);
if (rc != EOK) {
fprintf(stderr, "Failed getting id of category "
"'serial'\n");
return 1;
}
service_id_t *svc_ids;
size_t svc_count;
rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count); if (rc != EOK) {
fprintf(stderr, "Failed getting list of services\n");
return 1;
}
if (svc_count == 0) {
fprintf(stderr, "No service in category 'serial'\n");
free(svc_ids);
return 1;
}
svc_id = svc_ids[0];
rc = loc_service_get_name(svc_id, &serial_port_name);
if (rc != EOK) {
fprintf(stderr, "Failed getting name of serial service\n");
return 1;
}
free(svc_ids);
}
if (argc > arg) {
fprintf(stderr, "Too many arguments\n");
syntax_print();
return 1;
}
fibril_mutex_initialize(&client_mutex);
printf(NAME ": Using serial port %s\n", serial_port_name);
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
IPC_FLAG_BLOCKING);
if (!sess) {
fprintf(stderr, "Failed connecting to service\n");
}
async_exch_t *exch = async_exchange_begin(sess);
rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
SERIAL_NO_PARITY, 8, 1);
async_exchange_end(exch);
if (rc != EOK) {
fprintf(stderr, "Failed setting serial properties\n");
return 2;
}
rc = isdv4_init(&state, sess, event_fn);
if (rc != EOK) {
fprintf(stderr, "Failed initializing isdv4 state");
return 2;
}
rc = isdv4_init_tablet(&state);
if (rc != EOK) {
fprintf(stderr, "Failed initializing tablet");
return 2;
}
printf("Tablet information:\n");
printf(" Stylus: %ux%u pressure: %u tilt: ", state.stylus_max_x,
state.stylus_max_y, state.stylus_max_pressure);
if (state.stylus_tilt_supported) {
printf("%ux%u\n", state.stylus_max_xtilt, state.stylus_max_ytilt);
}
else {
printf("not supported\n");
}
printf(" Touch: %ux%u type: %s\n", state.touch_max_x, state.touch_max_y,
touch_type(state.touch_type));
fid_t fibril = fibril_create(read_fibril, NULL);
/* From this on, state is to be used only by read_fibril */
fibril_add_ready(fibril);
async_set_fallback_port_handler(mouse_connection, NULL);
rc = loc_server_register(NAME);
if (rc != EOK) {
printf("%s: Unable to register driver.\n", NAME);
return rc;
}
service_id_t service_id;
char *service_name;
rc = asprintf(&service_name, "mouse/isdv4-%" PRIun, svc_id);
if (rc < 0) {
printf(NAME ": Unable to create service name\n");
return rc;
}
rc = loc_service_register(service_name, &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register service %s.\n", service_name);
return rc;
}
category_id_t mouse_category;
rc = loc_category_get_id("mouse", &mouse_category, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf(NAME ": Unable to get mouse category id.\n");
}
else {
rc = loc_service_add_to_cat(service_id, mouse_category);
if (rc != EOK) {
printf(NAME ": Unable to add device to mouse category.\n");
}
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int main(int argc, char *argv[])
{
argv++;
argc--;
if (argc < 4) {
usage();
return 1;
}
char *term = *argv;
argv++;
argc--;
char *locfs = *argv;
argv++;
argc--;
bool print_msg = false;
bool wait = false;
while ((argc > 0) && (str_cmp(*argv, "--") != 0)) {
if (str_cmp(*argv, "--msg") == 0) {
print_msg = true;
} else if (str_cmp(*argv, "--wait") == 0) {
wait = true;
} else {
usage();
return 2;
}
argv++;
argc--;
}
if (argc < 1) {
usage();
return 3;
}
/* Skip "--" */
argv++;
argc--;
char *cmd = *argv;
char **args = argv;
if (wait) {
/* Wait for the terminal service to be ready */
service_id_t service_id;
int rc = loc_service_get_id(term, &service_id, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf("%s: Error waiting on %s (%s)\n", APP_NAME, term,
str_error(rc));
return rc;
}
}
char term_node[LOC_NAME_MAXLEN];
snprintf(term_node, LOC_NAME_MAXLEN, "%s/%s", locfs, term);
reopen(&stdin, 0, term_node, O_RDONLY, "r");
reopen(&stdout, 1, term_node, O_WRONLY, "w");
reopen(&stderr, 2, term_node, O_WRONLY, "w");
if (stdin == NULL)
return 4;
if (stdout == NULL)
return 5;
if (stderr == NULL)
return 6;
/*
* FIXME: fdopen() should actually detect that we are opening a console
* and it should set line-buffering mode automatically.
*/
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
version_print(term);
if (print_msg)
welcome_msg_print();
task_id_t id;
task_wait_t twait;
int rc = task_spawnv(&id, &twait, cmd, (const char * const *) args);
if (rc != EOK) {
printf("%s: Error spawning %s (%s)\n", APP_NAME, cmd,
str_error(rc));
return rc;
}
task_exit_t texit;
int retval;
rc = task_wait(&twait, &texit, &retval);
if (rc != EOK) {
printf("%s: Error waiting for %s (%s)\n", APP_NAME, cmd,
str_error(rc));
return rc;
}
return 0;
}
int
main(int argc, char **argv)
{
int rc, c;
category_id_t cat_id;
size_t svc_cnt;
service_id_t *svc_ids = NULL;
service_id_t svc_id;
char *svc_name = NULL;
bool read_only = true;
char *wdate = NULL;
char *wtime = NULL;
struct tm t;
int n_args = argc;
while ((c = getopt(argc, argv, "hd:t:")) != -1) {
switch (c) {
case 'h':
usage();
return 0;
case 'd':
if (wdate) {
usage();
return 1;
}
wdate = (char *)optarg;
read_only = false;
n_args -= 2;
break;
case 't':
if (wtime) {
usage();
return 1;
}
wtime = (char *)optarg;
read_only = false;
n_args -= 2;
break;
case '?':
usage();
return 1;
}
}
if (n_args != 1) {
printf(NAME ": Unrecognized parameter\n");
usage();
return 1;
}
/* Get the id of the clock category */
rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf(NAME ": Cannot get clock category id\n");
goto exit;
}
/* Get the list of available services in the clock category */
rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
if (rc != EOK) {
printf(NAME ": Cannot get the list of services in the clock "
"category\n");
goto exit;
}
/* Check if there are available services in the clock category */
if (svc_cnt == 0) {
printf(NAME ": No available service found in "
"the clock category\n");
goto exit;
}
/* Get the name of the clock service */
rc = loc_service_get_name(svc_ids[0], &svc_name);
if (rc != EOK) {
printf(NAME ": Cannot get the name of the service\n");
goto exit;
}
/* Get the service id for the device */
rc = loc_service_get_id(svc_name, &svc_id, 0);
if (rc != EOK) {
printf(NAME ": Cannot get the service id for device %s",
svc_name);
goto exit;
}
/* Connect to the device */
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
if (!sess) {
printf(NAME ": Cannot connect to the device\n");
goto exit;
}
/* Read the current date/time */
rc = clock_dev_time_get(sess, &t);
if (rc != EOK) {
printf(NAME ": Cannot read the current time\n");
goto exit;
}
if (read_only) {
/* Print the current time and exit */
printf("%02d/%02d/%d ", t.tm_mday,
t.tm_mon + 1, 1900 + t.tm_year);
printf("%02d:%02d:%02d\n", t.tm_hour, t.tm_min, t.tm_sec);
} else {
if (wdate) {
rc = read_date_from_arg(wdate, &t);
if (rc != EOK) {
printf(NAME ": error, date format not "
"recognized\n");
usage();
goto exit;
}
}
if (wtime) {
rc = read_time_from_arg(wtime, &t);
if (rc != EOK) {
printf(NAME ": error, time format not "
"recognized\n");
usage();
goto exit;
}
}
rc = tm_sanity_check(&t);
if (rc != EOK) {
printf(NAME ": error, invalid date/time\n");
goto exit;
}
rc = clock_dev_time_set(sess, &t);
if (rc != EOK) {
printf(NAME ": error, Unable to set date/time\n");
goto exit;
}
}
exit:
free(svc_name);
free(svc_ids);
return rc;
}
int main(int argc, char **argv)
{
int rc;
char *endptr;
char *dev_path;
service_id_t service_id;
ext2_filesystem_t filesystem;
int arg_flags;
uint32_t inode = 0;
uint32_t inode_data = 0;
arg_flags = 0;
if (argc < 2) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
/* Skip program name */
--argc; ++argv;
if (argc > 0 && str_cmp(*argv, "--no-check") == 0) {
--argc; ++argv;
arg_flags |= ARG_NO_CHECK;
}
if (argc > 0 && str_cmp(*argv, "--superblock") == 0) {
--argc; ++argv;
arg_flags |= ARG_SUPERBLOCK;
}
if (argc > 0 && str_cmp(*argv, "--block-groups") == 0) {
--argc; ++argv;
arg_flags |= ARG_BLOCK_GROUPS;
}
if (argc > 0 && str_cmp(*argv, "--inode") == 0) {
--argc; ++argv;
if (argc == 0) {
printf(NAME ": Argument expected for --inode\n");
return 2;
}
inode = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument for --inode.\n");
syntax_print();
return 1;
}
arg_flags |= ARG_INODE;
--argc; ++argv;
if (argc > 0 && str_cmp(*argv, "--blocks") == 0) {
--argc; ++argv;
arg_flags |= ARG_INODE_BLOCKS;
}
if (argc > 0 && str_cmp(*argv, "--data") == 0) {
--argc; ++argv;
if (argc == 0) {
printf(NAME ": Argument expected for --data\n");
return 2;
}
inode_data = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument for --data.\n");
syntax_print();
return 1;
}
arg_flags |= ARG_INODE_DATA;
--argc; ++argv;
}
if (argc > 0 && str_cmp(*argv, "--list") == 0) {
--argc; ++argv;
arg_flags |= ARG_INODE_LIST;
}
}
if (argc < 1) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
else if (argc > 1) {
printf(NAME ": Error, unexpected argument.\n");
syntax_print();
return 1;
}
assert(argc == 1);
/* Display common things by default */
if ((arg_flags & ARG_ALL) == 0) {
arg_flags = ARG_COMMON;
}
dev_path = *argv;
rc = loc_service_get_id(dev_path, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", dev_path);
return 2;
}
rc = ext2_filesystem_init(&filesystem, service_id);
if (rc != EOK) {
printf(NAME ": Error initializing libext2.\n");
return 3;
}
rc = ext2_filesystem_check_sanity(&filesystem);
if (rc != EOK) {
printf(NAME ": Filesystem did not pass sanity check.\n");
if (!(arg_flags & ARG_NO_CHECK)) {
return 3;
}
}
if (arg_flags & ARG_SUPERBLOCK) {
print_superblock(filesystem.superblock);
}
if (arg_flags & ARG_BLOCK_GROUPS) {
print_block_groups(&filesystem);
}
if (arg_flags & ARG_INODE) {
print_inode_by_number(&filesystem, inode, arg_flags & ARG_INODE_DATA,
inode_data, arg_flags & ARG_INODE_LIST,
arg_flags & ARG_INODE_BLOCKS);
}
ext2_filesystem_fini(&filesystem);
return 0;
}
int main(int argc, char **argv)
{
sysarg_t baud = 9600;
service_id_t svc_id;
int arg = 1;
int rc;
if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
size_t arg_offset = str_lsize(argv[arg], 7);
char* arg_str = argv[arg] + arg_offset;
if (str_length(arg_str) == 0) {
fprintf(stderr, "--baud requires an argument\n");
syntax_print();
return 1;
}
char *endptr;
baud = strtol(arg_str, &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Invalid value for baud\n");
syntax_print();
return 1;
}
arg++;
}
if (argc > arg) {
rc = loc_service_get_id(argv[arg], &svc_id, 0);
if (rc != EOK) {
fprintf(stderr, "Cannot find device service %s\n",
argv[arg]);
return 1;
}
arg++;
}
else {
category_id_t serial_cat_id;
rc = loc_category_get_id("serial", &serial_cat_id, 0);
if (rc != EOK) {
fprintf(stderr, "Failed getting id of category "
"'serial'\n");
return 1;
}
service_id_t *svc_ids;
size_t svc_count;
rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count);
if (rc != EOK) {
fprintf(stderr, "Failed getting list of services\n");
return 1;
}
if (svc_count == 0) {
fprintf(stderr, "No service in category 'serial'\n");
free(svc_ids);
return 1;
}
svc_id = svc_ids[0];
free(svc_ids);
}
if (argc > arg) {
fprintf(stderr, "Too many arguments\n");
syntax_print();
return 1;
}
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
IPC_FLAG_BLOCKING);
if (!sess) {
fprintf(stderr, "Failed connecting to service\n");
}
async_exch_t *exch = async_exchange_begin(sess);
rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
SERIAL_NO_PARITY, 8, 1);
async_exchange_end(exch);
if (rc != EOK) {
fprintf(stderr, "Failed setting serial properties\n");
return 2;
}
uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
if (buf == NULL) {
fprintf(stderr, "Failed allocating buffer\n");
return 3;
}
while (true) {
ssize_t read = char_dev_read(sess, buf, BUF_SIZE);
if (read < 0) {
fprintf(stderr, "Failed reading from serial device\n");
break;
}
ssize_t i;
for (i = 0; i < read; i++) {
printf("%02hhx ", buf[i]);
}
fflush(stdout);
}
free(buf);
return 0;
}
int main(int argc, char **argv)
{
struct fat_cfg cfg;
int rc;
char *dev_path;
service_id_t service_id;
char *endptr;
aoff64_t dev_nblocks;
cfg.sector_size = default_sector_size;
cfg.sectors_per_cluster = default_sectors_per_cluster;
cfg.fat_count = default_fat_count;
cfg.total_sectors = 0;
cfg.addt_res_sectors = 0;
cfg.root_ent_max = 128;
cfg.fat_type = FAT16;
if (argc < 2) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
--argc; ++argv;
if (str_cmp(*argv, "--size") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
cfg.total_sectors = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument.\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
if (str_cmp(*argv, "--type") == 0) {
--argc; ++argv;
if (*argv == NULL) {
printf(NAME ": Error, argument missing.\n");
syntax_print();
return 1;
}
cfg.fat_type = strtol(*argv, &endptr, 10);
if (*endptr != '\0') {
printf(NAME ": Error, invalid argument.\n");
syntax_print();
return 1;
}
--argc; ++argv;
}
if (argc != 1) {
printf(NAME ": Error, unexpected argument.\n");
syntax_print();
return 1;
}
dev_path = *argv;
printf("Device: %s\n", dev_path);
rc = loc_service_get_id(dev_path, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", dev_path);
return 2;
}
rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
if (rc != EOK) {
printf(NAME ": Error initializing libblock.\n");
return 2;
}
rc = block_get_bsize(service_id, &cfg.sector_size);
if (rc != EOK) {
printf(NAME ": Error determining device block size.\n");
return 2;
}
rc = block_get_nblocks(service_id, &dev_nblocks);
if (rc != EOK) {
printf(NAME ": Warning, failed to obtain block device size.\n");
} else {
printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
dev_nblocks);
if (!cfg.total_sectors || dev_nblocks < cfg.total_sectors)
cfg.total_sectors = dev_nblocks;
}
if (cfg.total_sectors == 0) {
printf(NAME ": Error. You must specify filesystem size.\n");
return 1;
}
if (cfg.fat_type != FAT12 && cfg.fat_type != FAT16 && cfg.fat_type != FAT32) {
printf(NAME ": Error. Unknown FAT type.\n");
return 2;
}
printf(NAME ": Creating FAT%d filesystem on device %s.\n", cfg.fat_type, dev_path);
rc = fat_params_compute(&cfg);
if (rc != EOK) {
printf(NAME ": Invalid file-system parameters.\n");
return 2;
}
rc = fat_blocks_write(&cfg, service_id);
if (rc != EOK) {
printf(NAME ": Error writing device.\n");
return 2;
}
block_fini(service_id);
printf("Success.\n");
return 0;
}
int main (int argc, char **argv)
{
int rc, c, opt_ind;
char *device_name;
size_t devblock_size;
struct mfs_sb_info sb;
/* Default is MinixFS V3 */
sb.magic = MFS_MAGIC_V3;
sb.fs_version = 3;
/* Default block size is 4Kb */
sb.block_size = MFS_MAX_BLOCKSIZE;
sb.dirsize = MFS3_DIRSIZE;
sb.n_inodes = 0;
sb.longnames = false;
sb.ino_per_block = V3_INODES_PER_BLOCK(MFS_MAX_BLOCKSIZE);
if (argc == 1) {
help_cmd_mkmfs(HELP_SHORT);
printf("Incorrect number of arguments, try `mkmfs --help'\n");
exit(0);
}
for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
c = getopt_long(argc, argv, "lh12b:i:",
long_options, &opt_ind);
switch (c) {
case 'h':
help_cmd_mkmfs(HELP_LONG);
exit(0);
case '1':
sb.magic = MFS_MAGIC_V1;
sb.block_size = MFS_BLOCKSIZE;
sb.fs_version = 1;
sb.ino_per_block = V1_INODES_PER_BLOCK;
sb.dirsize = MFS_DIRSIZE;
break;
case '2':
sb.magic = MFS_MAGIC_V2;
sb.block_size = MFS_BLOCKSIZE;
sb.fs_version = 2;
sb.ino_per_block = V2_INODES_PER_BLOCK;
sb.dirsize = MFS_DIRSIZE;
break;
case 'b':
sb.block_size = (uint32_t) strtol(optarg, NULL, 10);
break;
case 'i':
sb.n_inodes = (uint64_t) strtol(optarg, NULL, 10);
break;
case 'l':
sb.longnames = true;
sb.dirsize = MFSL_DIRSIZE;
break;
}
}
if (sb.block_size < MFS_MIN_BLOCKSIZE ||
sb.block_size > MFS_MAX_BLOCKSIZE) {
printf(NAME ":Error! Invalid block size.\n");
exit(0);
} else if (!is_power_of_two(sb.block_size)) {
/* Block size must be a power of 2. */
printf(NAME ":Error! Invalid block size.\n");
exit(0);
} else if (sb.block_size > MFS_BLOCKSIZE &&
sb.fs_version != 3) {
printf(NAME ":Error! Block size > 1024 is "
"supported by V3 filesystem only.\n");
exit(0);
} else if (sb.fs_version == 3 && sb.longnames) {
printf(NAME ":Error! Long filenames are supported "
"by V1/V2 filesystem only.\n");
exit(0);
}
if (sb.block_size == MFS_MIN_BLOCKSIZE)
shift = 1;
else if (sb.block_size == MFS_MAX_BLOCKSIZE)
shift = 3;
else
shift = 2;
argv += optind;
device_name = argv[0];
if (!device_name) {
help_cmd_mkmfs(HELP_LONG);
exit(0);
}
rc = loc_service_get_id(device_name, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", device_name);
return 2;
}
rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
if (rc != EOK) {
printf(NAME ": Error initializing libblock.\n");
return 2;
}
rc = block_get_bsize(service_id, &devblock_size);
if (rc != EOK) {
printf(NAME ": Error determining device block size.\n");
return 2;
}
rc = block_get_nblocks(service_id, &sb.dev_nblocks);
if (rc != EOK) {
printf(NAME ": Warning, failed to obtain "
"block device size.\n");
} else {
printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
sb.dev_nblocks);
}
if (devblock_size != 512) {
printf(NAME ": Error. Device block size is not 512 bytes.\n");
return 2;
}
/* Minimum block size is 1 Kb */
sb.dev_nblocks /= 2;
printf(NAME ": Creating Minix file system on device\n");
printf(NAME ": Writing superblock\n");
/* Initialize superblock */
if (init_superblock(&sb) != EOK) {
printf(NAME ": Error. Superblock initialization failed\n");
return 2;
}
printf(NAME ": Initializing bitmaps\n");
/* Initialize bitmaps */
if (init_bitmaps(&sb) != EOK) {
printf(NAME ": Error. Bitmaps initialization failed\n");
return 2;
}
printf(NAME ": Initializing the inode table\n");
/* Init inode table */
if (init_inode_table(&sb) != EOK) {
printf(NAME ": Error. Inode table initialization failed\n");
return 2;
}
printf(NAME ": Creating the root directory inode\n");
/* Make the root inode */
if (sb.fs_version == 1)
rc = make_root_ino(&sb);
else
rc = make_root_ino2(&sb);
if (rc != EOK) {
printf(NAME ": Error. Root inode initialization failed\n");
return 2;
}
/* Insert directory entries . and .. */
if (insert_dentries(&sb) != EOK) {
printf(NAME ": Error. Root directory initialization failed\n");
return 2;
}
block_fini(service_id);
return 0;
}
