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; }