static int display_meminfo(void) { ulong mstart = mem_malloc_start(); ulong mend = mem_malloc_end(); ulong msize = mend - mstart + 1; pr_debug("barebox code: 0x%p -> 0x%p\n", _stext, _etext - 1); pr_debug("bss segment: 0x%p -> 0x%p\n", __bss_start, __bss_stop - 1); pr_info("malloc space: 0x%08lx -> 0x%08lx (size %s)\n", mstart, mend, size_human_readable(msize)); return 0; }
static int pcaal1_mem_init(void) { #ifdef CONFIG_OMAP_GPMC /* * WP is made high and WAIT1 active Low */ gpmc_generic_init(0x10); #endif omap3_add_sram0(); omap_add_ram0(get_sdr_cs_size(SDRC_CS0_OSET)); printf("found %s at SDCS0\n", size_human_readable(get_sdr_cs_size(SDRC_CS0_OSET))); if ((get_sdr_cs_size(SDRC_CS1_OSET) != 0) && (get_sdr_cs1_base() != OMAP_SDRC_CS0)) { arm_add_mem_device("ram1", get_sdr_cs1_base(), get_sdr_cs_size(SDRC_CS1_OSET)); printf("found %s at SDCS1\n", size_human_readable(get_sdr_cs_size(SDRC_CS1_OSET))); } return 0; }
void uimage_print_contents(struct uimage_handle *handle) { struct image_header *hdr = &handle->header; #if defined(CONFIG_TIMESTAMP) struct rtc_time tm; #endif printf(" Image Name: %.*s\n", IH_NMLEN, hdr->ih_name); #if defined(CONFIG_TIMESTAMP) printf(" Created: "); to_tm(hdr->ih_time, &tm); printf("%4d-%02d-%02d %2d:%02d:%02d UTC\n", tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); #endif #if defined(CONFIG_CMD_BOOTM_SHOW_TYPE) printf(" OS: %s\n", image_get_os_name(hdr->ih_os)); printf(" Architecture: %s\n", image_get_arch_name(hdr->ih_arch)); printf(" Type: %s\n", image_get_type_name(hdr->ih_type)); printf(" Compression: %s\n", image_get_comp_name(hdr->ih_comp)); #endif printf(" Data Size: %d Bytes = %s\n", hdr->ih_size, size_human_readable(hdr->ih_size)); printf(" Load Address: %08x\n", hdr->ih_load); printf(" Entry Point: %08x\n", hdr->ih_ep); if (uimage_is_multi_image(handle)) { int i; printf(" Contents:\n"); for (i = 0; i < handle->nb_data_entries; i++) { struct uimage_handle_data *data = &handle->ihd[i]; printf(" Image %d: %ld (%s)\n", i, data->len, size_human_readable(data->len)); } } }
int do_ubiformat(int argc, char *argv[]) { int err, verbose; struct mtd_dev_info mtd; struct ubigen_info ui; struct ubi_scan_info *si; err = parse_opt(argc, argv); if (err) return err; err = mtd_get_dev_info(args.node, &mtd); if (err) { sys_errmsg("cannot get information about \"%s\"", args.node); goto out_close_mtd; } if (!is_power_of_2(mtd.min_io_size)) { errmsg("min. I/O size is %d, but should be power of 2", mtd.min_io_size); goto out_close_mtd; } if (args.subpage_size && args.subpage_size != mtd.subpage_size) { mtd.subpage_size = args.subpage_size; args.manual_subpage = 1; } if (args.manual_subpage) { /* Do some sanity check */ if (args.subpage_size > mtd.min_io_size) { errmsg("sub-page cannot be larger than min. I/O unit"); goto out_close_mtd; } if (mtd.min_io_size % args.subpage_size) { errmsg("min. I/O unit size should be multiple of " "sub-page size"); goto out_close_mtd; } } args.node_fd = open(args.node, O_RDWR); if (args.node_fd < 0) { sys_errmsg("cannot open \"%s\"", args.node); goto out_close_mtd; } /* Validate VID header offset if it was specified */ if (args.vid_hdr_offs != 0) { if (args.vid_hdr_offs % 8) { errmsg("VID header offset has to be multiple of min. I/O unit size"); goto out_close; } if (args.vid_hdr_offs + (int)UBI_VID_HDR_SIZE > mtd.eb_size) { errmsg("bad VID header offset"); goto out_close; } } if (!mtd.writable) { errmsg("%s (%s) is a read-only device", mtd.node, args.node); goto out_close; } /* Make sure this MTD device is not attached to UBI */ /* FIXME! Find a proper way to do this in barebox! */ if (!args.quiet) { normsg_cont("%s (%s), size %lld bytes (%s)", mtd.node, mtd.type_str, mtd.size, size_human_readable(mtd.size)); printf(", %d eraseblocks of %d bytes (%s)", mtd.eb_cnt, mtd.eb_size, size_human_readable(mtd.eb_size)); printf(", min. I/O size %d bytes\n", mtd.min_io_size); } if (args.quiet) verbose = 0; else if (args.verbose) verbose = 2; else verbose = 1; err = libscan_ubi_scan(&mtd, args.node_fd, &si, verbose); if (err) { errmsg("failed to scan %s (%s)", mtd.node, args.node); goto out_close; } if (si->good_cnt == 0) { errmsg("all %d eraseblocks are bad", si->bad_cnt); goto out_free; } if (si->good_cnt < 2 && (!args.novtbl || args.image)) { errmsg("too few non-bad eraseblocks (%d) on %s", si->good_cnt, mtd.node); goto out_free; } if (!args.quiet) { if (si->ok_cnt) normsg("%d eraseblocks have valid erase counter, mean value is %lld", si->ok_cnt, si->mean_ec); if (si->empty_cnt) normsg("%d eraseblocks are supposedly empty", si->empty_cnt); if (si->corrupted_cnt) normsg("%d corrupted erase counters", si->corrupted_cnt); print_bad_eraseblocks(&mtd, si); } if (si->alien_cnt) { if (!args.quiet) warnmsg("%d of %d eraseblocks contain non-ubifs data", si->alien_cnt, si->good_cnt); if (!args.yes && !args.quiet) warnmsg("use '-y' to force erasing"); if (!args.yes) goto out_free; } if (!args.override_ec && si->empty_cnt < si->good_cnt) { int percent = (si->ok_cnt * 100) / si->good_cnt; /* * Make sure the majority of eraseblocks have valid * erase counters. */ if (percent < 50) { if (!args.quiet) { warnmsg("only %d of %d eraseblocks have valid erase counter", si->ok_cnt, si->good_cnt); if (args.yes) { normsg("erase counter 0 will be used for all eraseblocks"); normsg("note, arbitrary erase counter value may be specified using -e option"); } else { warnmsg("use '-y' to force erase counters"); } } if (!args.yes) goto out_free; args.ec = 0; args.override_ec = 1; } else if (percent < 95) { if (!args.quiet) { warnmsg("only %d of %d eraseblocks have valid erase counter", si->ok_cnt, si->good_cnt); if (args.yes) normsg("mean erase counter %lld will be used for the rest of eraseblock", si->mean_ec); else warnmsg("use '-y' to force erase counters"); } if (!args.yes) goto out_free; args.ec = si->mean_ec; args.override_ec = 1; } } if (!args.quiet && args.override_ec) normsg("use erase counter %lld for all eraseblocks", args.ec); ubigen_info_init(&ui, mtd.eb_size, mtd.min_io_size, mtd.subpage_size, args.vid_hdr_offs, args.ubi_ver, args.image_seq); if (si->vid_hdr_offs != -1 && ui.vid_hdr_offs != si->vid_hdr_offs) { /* * Hmm, what we read from flash and what we calculated using * min. I/O unit size and sub-page size differs. */ if (!args.quiet) { warnmsg("VID header and data offsets on flash are %d and %d, " "which is different to requested offsets %d and %d", si->vid_hdr_offs, si->data_offs, ui.vid_hdr_offs, ui.data_offs); normsg("using offsets %d and %d", ui.vid_hdr_offs, ui.data_offs); } } if (args.image) { err = flash_image(&mtd, &ui, si); if (err < 0) goto out_free; err = format(&mtd, &ui, si, err, 1); if (err) goto out_free; } else { err = format(&mtd, &ui, si, 0, args.novtbl); if (err) goto out_free; } libscan_ubi_scan_free(si); close(args.node_fd); return 0; out_free: libscan_ubi_scan_free(si); out_close: close(args.node_fd); out_close_mtd: return 1; }
gboolean __scan_udisks2_devices(void) { GSList *node, *drives; udiskd *disk; gchar *udisks2_storage_list = NULL, *features = NULL, *moreinfo = NULL; gchar *devid, *label; const gchar *url, *vendor_str, *icon; int n = 0, i; static struct { char *media_prefix; char *icon; } media2icon[] = { { "thumb", "usbfldisk"}, { "flash", "usbfldisk"}, { "floppy", "media-floppy"}, { "optical", "cdrom"}, { NULL, NULL} }; moreinfo_del_with_prefix("DEV:UDISKS"); udisks2_storage_list = g_strdup(_("\n[UDisks2]\n")); drives = get_udisks2_all_drives_info(); for (node = drives; node != NULL; node = node->next) { disk = (udiskd *)node->data; devid = g_strdup_printf("UDISKS%d", n++); if (disk->vendor && strlen(disk->vendor) > 0) { label = g_strdup_printf("%s %s", disk->vendor, disk->model); vendor_str = disk->vendor; } else{ label = g_strdup(disk->model); vendor_str = disk->model; } icon = NULL; if (disk->media_compatibility){ for (i = 0; media2icon[i].media_prefix != NULL; i++) { if (g_str_has_prefix(disk->media_compatibility, media2icon[i].media_prefix)) { icon = media2icon[i].icon; break; } } } if (icon == NULL && disk->ejectable && g_strcmp0(disk->connection_bus, "usb") == 0) { icon = "usbfldisk"; } if (icon == NULL){ icon = "hdd"; } url = vendor_get_url(vendor_str); udisks2_storage_list = h_strdup_cprintf("$%s$%s=\n", udisks2_storage_list, devid, label); storage_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", storage_icons, devid, label, icon); features = h_strdup_cprintf("%s", features, disk->removable ? _("Removable"): _("Fixed")); if (disk->ejectable) { features = h_strdup_cprintf(", %s", features, _("Ejectable")); } if (disk->smart_enabled) { features = h_strdup_cprintf(", %s", features, _("Smart monitoring")); } moreinfo = g_strdup_printf(_("[Drive Information]\n" "Model=%s\n"), label); if (url) { moreinfo = h_strdup_cprintf(_("Vendor=%s (%s)\n"), moreinfo, vendor_get_name(vendor_str), url); } else { moreinfo = h_strdup_cprintf(_("Vendor=%s\n"), moreinfo, vendor_get_name(vendor_str)); } moreinfo = h_strdup_cprintf(_("Revision=%s\n" "Block Device=%s\n" "Serial=%s\n" "Size=%s\n" "Features=%s\n"), moreinfo, disk->revision, disk->block_dev, disk->serial, size_human_readable((gfloat) disk->size), features); if (disk->rotation_rate > 0) { moreinfo = h_strdup_cprintf(_("Rotation Rate=%d\n"), moreinfo, disk->rotation_rate); } if (disk->media_compatibility || disk->media) { moreinfo = h_strdup_cprintf(_("Media=%s\n" "Media compatibility=%s\n"), moreinfo, disk->media ? disk->media : _("(None)"), disk->media_compatibility ? disk->media_compatibility : _("(Unknown)")); } if (disk->connection_bus && strlen(disk->connection_bus) > 0) { moreinfo = h_strdup_cprintf(_("Connection bus=%s\n"), moreinfo, disk->connection_bus); } if (disk->smart_enabled) { moreinfo = h_strdup_cprintf(_("[Smart monitoring]\n" "Status=%s\n" "Bad Sectors=%ld\n" "Power on time=%d days %d hours\n" "Temperature=%d°C\n"), moreinfo, disk->smart_failing ? _("Failing"): _("OK"), disk->smart_bad_sectors, disk->smart_poweron/(60*60*24), (disk->smart_poweron/60/60) % 24, disk->smart_temperature); } moreinfo_add_with_prefix("DEV", devid, moreinfo); g_free(devid); g_free(features); g_free(label); features = NULL; moreinfo = NULL; devid = NULL; udiskd_free(disk); } g_slist_free(drives); if (n) { storage_list = h_strconcat(storage_list, udisks2_storage_list, NULL); g_free(udisks2_storage_list); return TRUE; } g_free(udisks2_storage_list); return FALSE; }
void scan_filesystems(void) { FILE *mtab; gchar buf[1024]; struct statfs sfs; int count = 0; g_free(fs_list); fs_list = g_strdup(""); moreinfo_del_with_prefix("COMP:FS"); mtab = fopen("/etc/mtab", "r"); if (!mtab) return; while (fgets(buf, 1024, mtab)) { gfloat size, used, avail; gchar **tmp; tmp = g_strsplit(buf, " ", 0); if (!statfs(tmp[1], &sfs)) { gfloat use_ratio; size = (float) sfs.f_bsize * (float) sfs.f_blocks; avail = (float) sfs.f_bsize * (float) sfs.f_bavail; used = size - avail; if (size == 0.0f) { continue; } if (avail == 0.0f) { use_ratio = 100.0f; } else { use_ratio = 100.0f * (used / size); } gchar *strsize = size_human_readable(size), *stravail = size_human_readable(avail), *strused = size_human_readable(used); gchar *strhash; strreplacechr(tmp[0], "#", '_'); strhash = g_strdup_printf("[%s]\n" "Filesystem=%s\n" "Mounted As=%s\n" "Mount Point=%s\n" "Size=%s\n" "Used=%s\n" "Available=%s\n", tmp[0], tmp[2], strstr(tmp[3], "rw") ? "Read-Write" : "Read-Only", tmp[1], strsize, strused, stravail); gchar *key = g_strdup_printf("FS%d", ++count); moreinfo_add_with_prefix("COMP", key, strhash); g_free(key); fs_list = h_strdup_cprintf("$FS%d$%s=%.2f %% (%s of %s)|%s\n", fs_list, count, tmp[0], use_ratio, stravail, strsize, tmp[1]); g_free(strsize); g_free(stravail); g_free(strused); } g_strfreev(tmp); } fclose(mtab); }