static int do_part_list(int argc, char * const argv[]) { int ret; block_dev_desc_t *desc; if (argc < 2 || argc > 3) return CMD_RET_USAGE; ret = get_device(argv[0], argv[1], &desc); if (ret < 0) return 1; if (argc == 3) { int p; char str[512] = { 0, }; disk_partition_t info; for (p = 1; p < 128; p++) { int r = get_partition_info(desc, p, &info); if (r == 0) { char t[5]; sprintf(t, "%s%d", str[0] ? " " : "", p); strcat(str, t); } } setenv(argv[2], str); return 0; } print_part(desc); return 0; }
static void print_part(struct partition *part, size_t offset, int sect_off, int ext) { char *indent = ext ? " [" : ""; char *exdent = ext ? "]" : ""; int i; if (part->sys_ind) printf(fmtstring, indent, part->start_sect + sect_off, (part->start_sect + sect_off) * SECTOR_SIZE + offset, part->sys_ind, exdent); if (part->sys_ind == EXT_MAGIC && !ext) { char extblock[512]; lseek(fd, (off_t)part->start_sect * SECTOR_SIZE + offset, SEEK_SET); if (read(fd, extblock, 512) < 512) { perror("hdinfo: Could not read sector"); exit(1); } for (i = 0; i < 4; i++) { print_part((struct partition *) (extblock + 0x1be + i * 16), offset, part->start_sect, 1); } } }
static void print_buff(const buff_t * b){ while (b){ print_part(&b->part,b->part_size); b = b->next; } printf("\n"); }
int main(int argc, char *argv[]) { if (argc != 3) invocation_error(argv[0], "[output file] [size]"); char *output_file = argv[1]; size_t records = atol(argv[2]); size_t i, part_number, noun_count, adj_count; char *nouns[NOUN_MAX], noun_file_content[NOUN_BYTES]; char *adjectives[ADJ_MAX], adj_file_content[ADJ_BYTES]; int rc; Part p; Parts db = new_db(CHUNK_SIZE); noun_count = get_word_pointers(nouns, NOUN_FILE, noun_file_content, NOUN_BYTES); adj_count = get_word_pointers(adjectives, ADJ_FILE, adj_file_content, ADJ_BYTES); init_locale(); srand((unsigned int) time(NULL)); remove(output_file); for (part_number = 0, i = 0; i < records; i++) { part_number = jagged_sequence(part_number); p = set_part(part_number, random_part_name(nouns, noun_count, adjectives, adj_count), random_int(), random_int()); printf("%9ld: ", i + 1); print_part(p); if ((rc = insert_part(db, p))) { fprintf(stderr, "%s: %d insert_part() failed: return code %d on iteration %ld\n", __FILE__, __LINE__, rc, i); destroy_db(db); exit(EXIT_FAILURE); } if (i % CHUNK_SIZE == 0) { if (flush_to_disk(output_file, db) != 0) { destroy_db(db); exit_error(argv[0], output_file); } } } if (flush_to_disk(output_file, db) != 0) { destroy_db(db); exit_error(argv[0], output_file); } destroy_db(db); return 0; }
int do_part_list(int argc, char * const argv[]) { int ret; block_dev_desc_t *desc; if (argc != 2) return CMD_RET_USAGE; ret = get_device(argv[0], argv[1], &desc); if (ret < 0) return 1; print_part(desc); return 0; }
int main(int argc, char **argv) { int i, hdimage_off = 0; char *filename; char mbr[1024]; fmtstring = decfmt; if (argc == 3) { if (!strcmp(argv[1], "-h")) fmtstring = hexfmt; else { usage(); exit(1); } filename = argv[2]; } else if (argc == 2) filename = argv[1]; else { usage(); exit(1); } if ((fd = open(filename, O_RDONLY)) < 0) { perror("hdinfo: Cannot open file"); exit(1); } if (read(fd, mbr, 1024) < 1024) { perror("hdinfo: Could not read MBR\n"); exit(1); } if (!strncmp(mbr, "DOSEMU", 6)) hdimage_off = *(u_long *) (mbr + 19); else hdimage_off = 0; printf("Partition info for %s %s\n=================================================\n", filename, hdimage_off ? "(a DOSEMU hdimage file)" : ""); for (i = 0; i < 4; i++) print_part((struct partition *) (mbr + 0x1be + hdimage_off + i * 16), hdimage_off, 0, 0); return 0; }
int ft_printf(const char *format, ...) { va_list ap; const char *str; int len; len = 0; va_start(ap, format); str = format; while (*str) { if (*str == '%') { len += print_part(format, str); str = str + 1; len += do_format(&str, ap); format = str + 1; } str++; } len += pf_putstr(format); va_end(ap); return (len); }
static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { int rc = 0; if (argc == 2 && strcmp(argv[1], "init") == 0) return sata_initialize(); /* If the user has not yet run `sata init`, do it now */ if (sata_curr_device == -1) if (sata_initialize()) return 1; switch (argc) { case 0: case 1: return CMD_RET_USAGE; case 2: if (strncmp(argv[1],"inf", 3) == 0) { int i; putc('\n'); for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; ++i) { if (sata_dev_desc[i].type == DEV_TYPE_UNKNOWN) continue; printf ("SATA device %d: ", i); dev_print(&sata_dev_desc[i]); } return 0; } else if (strncmp(argv[1],"dev", 3) == 0) { if ((sata_curr_device < 0) || (sata_curr_device >= CONFIG_SYS_SATA_MAX_DEVICE)) { puts("\nno SATA devices available\n"); return 1; } printf("\nSATA device %d: ", sata_curr_device); dev_print(&sata_dev_desc[sata_curr_device]); return 0; } else if (strncmp(argv[1],"part",4) == 0) { int dev, ok; for (ok = 0, dev = 0; dev < CONFIG_SYS_SATA_MAX_DEVICE; ++dev) { if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) { ++ok; if (dev) putc ('\n'); print_part(&sata_dev_desc[dev]); } } if (!ok) { puts("\nno SATA devices available\n"); rc ++; } return rc; } return CMD_RET_USAGE; case 3: if (strncmp(argv[1], "dev", 3) == 0) { int dev = (int)simple_strtoul(argv[2], NULL, 10); printf("\nSATA device %d: ", dev); if (dev >= CONFIG_SYS_SATA_MAX_DEVICE) { puts ("unknown device\n"); return 1; } dev_print(&sata_dev_desc[dev]); if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN) return 1; sata_curr_device = dev; puts("... is now current device\n"); return 0; } else if (strncmp(argv[1], "part", 4) == 0) { int dev = (int)simple_strtoul(argv[2], NULL, 10); if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) { print_part(&sata_dev_desc[dev]); } else { printf("\nSATA device %d not available\n", dev); rc = 1; } return rc; } return CMD_RET_USAGE; default: /* at least 4 args */ if (strcmp(argv[1], "read") == 0) { ulong addr = simple_strtoul(argv[2], NULL, 16); ulong cnt = simple_strtoul(argv[4], NULL, 16); ulong n; lbaint_t blk = simple_strtoul(argv[3], NULL, 16); printf("\nSATA read: device %d block # %ld, count %ld ... ", sata_curr_device, blk, cnt); n = sata_read(sata_curr_device, blk, cnt, (u32 *)addr); /* flush cache after read */ flush_cache(addr, cnt * sata_dev_desc[sata_curr_device].blksz); printf("%ld blocks read: %s\n", n, (n==cnt) ? "OK" : "ERROR"); return (n == cnt) ? 0 : 1; } else if (strcmp(argv[1], "write") == 0) { ulong addr = simple_strtoul(argv[2], NULL, 16); ulong cnt = simple_strtoul(argv[4], NULL, 16); ulong n; lbaint_t blk = simple_strtoul(argv[3], NULL, 16); printf("\nSATA write: device %d block # %ld, count %ld ... ", sata_curr_device, blk, cnt); n = sata_write(sata_curr_device, blk, cnt, (u32 *)addr); printf("%ld blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR"); return (n == cnt) ? 0 : 1; } else { return CMD_RET_USAGE; } return rc; } }
/********************************************************************************* * scsi command intepreter */ int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { switch (argc) { case 0: case 1: return CMD_RET_USAGE; case 2: if (strncmp(argv[1],"res",3) == 0) { printf("\nReset SCSI\n"); scsi_bus_reset(); scsi_scan(1); return 0; } if (strncmp(argv[1],"inf",3) == 0) { int i; for (i=0; i<CONFIG_SYS_SCSI_MAX_DEVICE; ++i) { if(scsi_dev_desc[i].type==DEV_TYPE_UNKNOWN) continue; /* list only known devices */ printf ("SCSI dev. %d: ", i); dev_print(&scsi_dev_desc[i]); } return 0; } if (strncmp(argv[1],"dev",3) == 0) { if ((scsi_curr_dev < 0) || (scsi_curr_dev >= CONFIG_SYS_SCSI_MAX_DEVICE)) { printf("\nno SCSI devices available\n"); return 1; } printf ("\n Device %d: ", scsi_curr_dev); dev_print(&scsi_dev_desc[scsi_curr_dev]); return 0; } if (strncmp(argv[1],"scan",4) == 0) { scsi_scan(1); return 0; } if (strncmp(argv[1],"part",4) == 0) { int dev, ok; for (ok=0, dev=0; dev<CONFIG_SYS_SCSI_MAX_DEVICE; ++dev) { if (scsi_dev_desc[dev].type!=DEV_TYPE_UNKNOWN) { ok++; if (dev) printf("\n"); debug ("print_part of %x\n",dev); print_part(&scsi_dev_desc[dev]); } } if (!ok) printf("\nno SCSI devices available\n"); return 1; } return CMD_RET_USAGE; case 3: if (strncmp(argv[1],"dev",3) == 0) { int dev = (int)simple_strtoul(argv[2], NULL, 10); printf ("\nSCSI device %d: ", dev); if (dev >= CONFIG_SYS_SCSI_MAX_DEVICE) { printf("unknown device\n"); return 1; } printf ("\n Device %d: ", dev); dev_print(&scsi_dev_desc[dev]); if(scsi_dev_desc[dev].type == DEV_TYPE_UNKNOWN) { return 1; } scsi_curr_dev = dev; printf("... is now current device\n"); return 0; } if (strncmp(argv[1],"part",4) == 0) { int dev = (int)simple_strtoul(argv[2], NULL, 10); if(scsi_dev_desc[dev].type != DEV_TYPE_UNKNOWN) { print_part(&scsi_dev_desc[dev]); } else { printf ("\nSCSI device %d not available\n", dev); } return 1; } return CMD_RET_USAGE; default: /* at least 4 args */ if (strcmp(argv[1],"read") == 0) { ulong addr = simple_strtoul(argv[2], NULL, 16); ulong blk = simple_strtoul(argv[3], NULL, 16); ulong cnt = simple_strtoul(argv[4], NULL, 16); ulong n; printf ("\nSCSI read: device %d block # %ld, count %ld ... ", scsi_curr_dev, blk, cnt); n = scsi_read(scsi_curr_dev, blk, cnt, (ulong *)addr); printf ("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR"); return 0; } else if (strcmp(argv[1], "write") == 0) { ulong addr = simple_strtoul(argv[2], NULL, 16); ulong blk = simple_strtoul(argv[3], NULL, 16); ulong cnt = simple_strtoul(argv[4], NULL, 16); ulong n; printf("\nSCSI write: device %d block # %ld, " "count %ld ... ", scsi_curr_dev, blk, cnt); n = scsi_write(scsi_curr_dev, blk, cnt, (ulong *)addr); printf("%ld blocks written: %s\n", n, (n == cnt) ? "OK" : "ERROR"); return 0; } } /* switch */ return CMD_RET_USAGE; }
int mmc_part(int mmc_cont) { print_part(&mmc_blk_dev[mmc_cont]); return 0; }