/* * Copyright (C) 2017 David Oberhollenzer - sigma star gmbh * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; see the file COPYING. If not, write to the Free Software * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA. * * Author: David Oberhollenzer <david.oberhollenzer@sigma-star.at> */ #include "lsmtd.h" struct ubi_node *ubi_dev; int num_ubi_devices; struct mtd_node *mtd_dev; int num_mtd_devices; static int compare_mtd(const void *l, const void *r) { const struct mtd_node *a = l, *b = r; switch (sort_by->type) { case COL_DEVNAME: return a->info.mtd_num - b->info.mtd_num; case COL_DEVNUM: if (a->info.major == b->info.major) return a->info.minor - b->info.minor; return a->info.major - b->info.major; case COL_TYPE: return strcmp(a->info.type_str, b->info.type_str); case COL_NAME: return strcmp(a->info.name, b->info.name); case COL_SIZE: if (a->info.size < b->info.size) return -1; if (a->info.size > b->info.size) return 1; return 0; case COL_EBSIZE: return a->info.eb_size - b->info.eb_size; case COL_EBCOUNT: return a->info.eb_cnt - b->info.eb_cnt; case COL_MINIO: return a->info.min_io_size - b->info.min_io_size; case COL_SUBSIZE: return a->info.subpage_size - b->info.subpage_size; case COL_OOBSIZE: return a->info.oob_size - b->info.oob_size; case COL_RO: return !a->info.writable - !b->info.writable; case COL_BB: return a->info.bb_allowed - b->info.bb_allowed; case COL_REGION: return a->info.region_cnt - b->info.region_cnt; } return 0; } static int compare_ubi_vol(const void *l, const void *r) { const struct ubi_vol_info *a = l, *b = r; long long all, bll; switch (sort_by->type) { case COL_DEVNAME: if (a->dev_num == b->dev_num) return a->vol_id - b->vol_id; return a->dev_num - b->dev_num; case COL_DEVNUM: if (a->major == b->major) return a->minor - b->minor; return a->major - b->major; case COL_TYPE: if (a->type == b->type) return 0; return a->type == UBI_DYNAMIC_VOLUME ? 1 : -1; case COL_NAME: return strcmp(a->name, b->name); case COL_SIZE: all = a->rsvd_bytes; bll = b->rsvd_bytes; goto out_ll; case COL_EBSIZE: return a->leb_size - b->leb_size; case COL_EBCOUNT: return a->rsvd_lebs - b->rsvd_lebs; case COL_FREE: case COL_FREE_LEB: all = (a->rsvd_bytes - a->data_bytes); bll = (b->rsvd_bytes - b->data_bytes); goto out_ll; case COL_CORRUPTED: return a->corrupted - b->corrupted; } return 0; out_ll: return (all < bll) ? -1 : ((all > bll) ? 1 : 0); } static int scan_ubi_device(libubi_t lib_ubi, struct ubi_node *dev) { int lo = dev->info.lowest_vol_id, hi = dev->info.highest_vol_id; int i, idx = 0, dev_num = dev->info.dev_num; struct ubi_vol_info vol_info; if (!dev->info.vol_count) return 0; dev->vol_info = xcalloc(dev->info.vol_count, sizeof(dev->vol_info[0])); for (i = lo; i <= hi; ++i) { if (ubi_get_vol_info1(lib_ubi, dev_num, i, &vol_info)) { if (errno == ENOENT) continue; perror("ubi_get_vol_info1"); return -1; } dev->vol_info[idx++] = vol_info; } if (sort_by) qsort(dev->vol_info, idx, sizeof(vol_info), compare_ubi_vol); return 0; } int scan_ubi(libubi_t lib_ubi) { struct ubi_dev_info dev_info; struct ubi_info info; int i, j; if (ubi_get_info(lib_ubi, &info)) return -1; if (!info.dev_count) return 0; ubi_dev = xcalloc(info.dev_count, sizeof(ubi_dev[0])); for (i = info.lowest_dev_num; i <= info.highest_dev_num; ++i) { if (!ubi_dev_present(lib_ubi, i)) continue; if (ubi_get_dev_info1(lib_ubi, i, &dev_info)) { perror("ubi_get_dev_info1"); return -1; } for (j = 0; j < num_mtd_devices; ++j) { if (mtd_dev[j].info.mtd_num == dev_info.mtd_num) break; } if (j == num_mtd_devices) { fprintf(stderr, "Cannot find mtd device %d referred to " "by ubi device %d\n", dev_info.mtd_num, dev_info.dev_num); return -1; } ubi_dev[num_ubi_devices].info = dev_info; mtd_dev[j].ubi = ubi_dev + num_ubi_devices; if (scan_ubi_device(lib_ubi, ubi_dev + num_ubi_devices)) return -1; ++num_ubi_devices; } return 0; } int scan_mtd(libmtd_t lib_mtd) { struct mtd_dev_info dev_info; struct mtd_info info; int i, idx = 0; if (mtd_get_info(lib_mtd, &info)) return -1; if (!info.mtd_dev_cnt) return 0; mtd_dev = xcalloc(info.mtd_dev_cnt, sizeof(mtd_dev[0])); for (i = info.lowest_mtd_num; i <= info.highest_mtd_num; ++i) { if (!mtd_dev_present(lib_mtd, i)) continue; if (mtd_get_dev_info1(lib_mtd, i, &dev_info)) { perror("mtd_get_dev_info1"); return -1; } memcpy(&(mtd_dev[idx++].info), &dev_info, sizeof(dev_info)); } num_mtd_devices = idx; if (sort_by) qsort(mtd_dev, num_mtd_devices, sizeof(*mtd_dev), compare_mtd); return 0; } void scan_free(void) { int i; for (i = 0; i < num_ubi_devices; ++i) free(ubi_dev[i].vol_info); free(ubi_dev); free(mtd_dev); }