int map_update(struct map_ent **mpp, char *devnm, char *metadata, int *uuid, char *path) { struct map_ent *map, *mp; int rv; if (mpp && *mpp) map = *mpp; else map_read(&map); for (mp = map ; mp ; mp=mp->next) if (strcmp(mp->devnm, devnm) == 0) { strcpy(mp->metadata, metadata); memcpy(mp->uuid, uuid, 16); free(mp->path); mp->path = path ? xstrdup(path) : NULL; mp->bad = 0; break; } if (!mp) map_add(&map, devnm, metadata, uuid, path); if (mpp) *mpp = NULL; rv = map_write(map); map_free(map); return rv; }
static int map_cmd(int argc, char *argv[]) { if (argc != 2) fprintf(stderr, "usage: map <file>\n"); return map_write(fs, argv[1]); }
void map_remove(struct map_ent **mapp, char *devnm) { if (devnm[0] == 0) return; map_delete(mapp, devnm); map_write(*mapp); map_free(*mapp); }
void copyumap(int y, int x, int fullvis) { char c; c = at(y, x); if (!fullvis && c == SPACE && map_read(umap, y, x) != SPACE) c = OBSPACE; map_write(umap, y, x, c); }
/* redefine ncurses werase */ void werase (char *pane) { int y, x; int maxy, maxx; getmaxyx(&maxy, &maxx); for (y = 0; y <= maxy; y++) for (x = 0; x <= maxx; x++) map_write(pane, y, x, SPACE); }
static int mapram_erase (struct mtd_info *mtd, struct erase_info *instr) { struct map_info *map = mtd->priv; map_word allff; unsigned long i; allff = map_word_ff(map); for (i=0; i<instr->len; i += map_bankwidth(map)) map_write(map, allff, instr->addr + i); instr->state = MTD_ERASE_DONE; mtd_erase_callback(instr); return 0; }
static int mapram_erase (struct mtd_info *mtd, struct erase_info *instr) { /* Yeah, it's inefficient. Who cares? It's faster than a _real_ flash erase. */ struct map_info *map = mtd->priv; map_word allff; unsigned long i; allff = map_word_ff(map); for (i=0; i<instr->len; i += map_bankwidth(map)) map_write(map, allff, instr->addr + i); instr->state = MTD_ERASE_DONE; mtd_erase_callback(instr); return 0; }
int mbx_write(char *mailbox, int md, FILE *fp, int id, long last, long pos, off_t stop, int mapping, int noisy) { register int i, j, size; off_t start; long off; register char *cp; char buffer[BUFSIZ]; off = (long) lseek (md, (off_t) 0, SEEK_CUR); j = strlen (mmdlm1); if (write (md, mmdlm1, j) != j) return NOTOK; start = lseek (md, (off_t) 0, SEEK_CUR); size = 0; fseek (fp, pos, SEEK_SET); while (fgets (buffer, sizeof(buffer), fp) && (pos < stop)) { i = strlen (buffer); for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++) continue; for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++) continue; if (write (md, buffer, i) != i) return NOTOK; pos += (long) i; if (mapping) for (cp = buffer; i-- > 0; size++) if (*cp++ == '\n') size++; } stop = lseek (md, (off_t) 0, SEEK_CUR); j = strlen (mmdlm2); if (write (md, mmdlm2, j) != j) return NOTOK; if (mapping) map_write (mailbox, md, id, last, start, stop, off, size, noisy); return OK; }
void RebuildMap(void) { struct mdstat_ent *mdstat = mdstat_read(0, 0); struct mdstat_ent *md; struct map_ent *map = NULL; int require_homehost; char sys_hostname[256]; char *homehost = conf_get_homehost(&require_homehost); if (homehost == NULL || strcmp(homehost, "<system>")==0) { if (gethostname(sys_hostname, sizeof(sys_hostname)) == 0) { sys_hostname[sizeof(sys_hostname)-1] = 0; homehost = sys_hostname; } } for (md = mdstat ; md ; md = md->next) { struct mdinfo *sra = sysfs_read(-1, md->devnm, GET_DEVS); struct mdinfo *sd; if (!sra) continue; for (sd = sra->devs ; sd ; sd = sd->next) { char namebuf[100]; char dn[30]; int dfd; int ok; int devid; struct supertype *st; char *subarray = NULL; char *path; struct mdinfo *info; sprintf(dn, "%d:%d", sd->disk.major, sd->disk.minor); dfd = dev_open(dn, O_RDONLY); if (dfd < 0) continue; st = guess_super(dfd); if ( st == NULL) ok = -1; else { subarray = get_member_info(md); ok = st->ss->load_super(st, dfd, NULL); } close(dfd); if (ok != 0) continue; if (subarray) info = st->ss->container_content(st, subarray); else { info = xmalloc(sizeof(*info)); st->ss->getinfo_super(st, info, NULL); } if (!info) continue; devid = devnm2devid(md->devnm); path = map_dev(major(devid), minor(devid), 0); if (path == NULL || strncmp(path, "/dev/md/", 8) != 0) { /* We would really like a name that provides * an MD_DEVNAME for udev. * The name needs to be unique both in /dev/md/ * and in this mapfile. * It needs to match what -I or -As would come * up with. * That means: * Check if array is in mdadm.conf * - if so use that. * determine trustworthy from homehost etc * find a unique name based on metadata name. * */ struct mddev_ident *match = conf_match(st, info, NULL, 0, NULL); struct stat stb; if (match && match->devname && match->devname[0] == '/') { path = match->devname; if (path[0] != '/') { strcpy(namebuf, "/dev/md/"); strcat(namebuf, path); path = namebuf; } } else { int unum = 0; char *sep = "_"; const char *name; int conflict = 1; if ((homehost == NULL || st->ss->match_home(st, homehost) != 1) && st->ss->match_home(st, "any") != 1 && (require_homehost || ! conf_name_is_free(info->name))) /* require a numeric suffix */ unum = 0; else /* allow name to be used as-is if no conflict */ unum = -1; name = info->name; if (!*name) { name = st->ss->name; if (!isdigit(name[strlen(name)-1]) && unum == -1) { unum = 0; sep = ""; } } if (strchr(name, ':')) { /* Probably a uniquifying * hostname prefix. Allow * without a suffix, and strip * hostname if it is us. */ if (homehost && unum == -1 && strncmp(name, homehost, strlen(homehost)) == 0 && name[strlen(homehost)] == ':') name += strlen(homehost)+1; unum = -1; } while (conflict) { if (unum >= 0) sprintf(namebuf, "/dev/md/%s%s%d", name, sep, unum); else sprintf(namebuf, "/dev/md/%s", name); unum++; if (lstat(namebuf, &stb) != 0 && (map == NULL || !map_by_name(&map, namebuf+8))) conflict = 0; } path = namebuf; } } map_add(&map, md->devnm, info->text_version, info->uuid, path); st->ss->free_super(st); free(info); break; } sysfs_free(sra); } /* Only trigger a change if we wrote a new map file */ if (map_write(map)) for (md = mdstat ; md ; md = md->next) { struct mdinfo *sra = sysfs_read(-1, md->devnm, GET_VERSION); if (sra) sysfs_uevent(sra, "change"); sysfs_free(sra); } map_free(map); free_mdstat(mdstat); }
static int autcpu12_nvram_probe(struct platform_device *pdev) { map_word tmp, save0, save1; struct resource *res; struct autcpu12_nvram_priv *priv; priv = devm_kzalloc(&pdev->dev, sizeof(struct autcpu12_nvram_priv), GFP_KERNEL); if (!priv) return -ENOMEM; platform_set_drvdata(pdev, priv); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "failed to get memory resource\n"); return -ENOENT; } priv->map.bankwidth = 4; priv->map.phys = res->start; priv->map.size = resource_size(res); priv->map.virt = devm_ioremap_resource(&pdev->dev, res); strcpy((char *)priv->map.name, res->name); if (IS_ERR(priv->map.virt)) return PTR_ERR(priv->map.virt); simple_map_init(&priv->map); /* * Check for 32K/128K * read ofs 0 * read ofs 0x10000 * Write complement to ofs 0x100000 * Read and check result on ofs 0x0 * Restore contents */ save0 = map_read(&priv->map, 0); save1 = map_read(&priv->map, 0x10000); tmp.x[0] = ~save0.x[0]; map_write(&priv->map, tmp, 0x10000); tmp = map_read(&priv->map, 0); /* if we find this pattern on 0x0, we have 32K size */ if (!map_word_equal(&priv->map, tmp, save0)) { map_write(&priv->map, save0, 0x0); priv->map.size = SZ_32K; } else map_write(&priv->map, save1, 0x10000); priv->mtd = do_map_probe("map_ram", &priv->map); if (!priv->mtd) { dev_err(&pdev->dev, "probing failed\n"); return -ENXIO; } priv->mtd->owner = THIS_MODULE; priv->mtd->erasesize = 16; priv->mtd->dev.parent = &pdev->dev; if (!mtd_device_register(priv->mtd, NULL, 0)) { dev_info(&pdev->dev, "NV-RAM device size %ldKiB registered on AUTCPU12\n", priv->map.size / SZ_1K); return 0; } map_destroy(priv->mtd); dev_err(&pdev->dev, "NV-RAM device addition failed\n"); return -ENOMEM; }
int mbx_copy (char *mailbox, int mbx_style, int md, int fd, int mapping, char *text, int noisy) { int i, j, size; off_t start, stop; long pos; char *cp, buffer[BUFSIZ]; FILE *fp; pos = (long) lseek (md, (off_t) 0, SEEK_CUR); size = 0; switch (mbx_style) { case MMDF_FORMAT: default: j = strlen (mmdlm1); if (write (md, mmdlm1, j) != j) return NOTOK; start = lseek (md, (off_t) 0, SEEK_CUR); if (text) { i = strlen (text); if (write (md, text, i) != i) return NOTOK; for (cp = text; *cp++; size++) if (*cp == '\n') size++; } while ((i = read (fd, buffer, sizeof(buffer))) > 0) { /* valgrind noticed that stringdex depends on null termination. */ buffer[i] = '\0'; for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++) continue; for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++) continue; if (write (md, buffer, i) != i) return NOTOK; if (mapping) for (cp = buffer; i-- > 0; size++) if (*cp++ == '\n') size++; } stop = lseek (md, (off_t) 0, SEEK_CUR); j = strlen (mmdlm2); if (write (md, mmdlm2, j) != j) return NOTOK; if (mapping) map_write (mailbox, md, 0, (long) 0, start, stop, pos, size, noisy); return (i != NOTOK ? OK : NOTOK); case MBOX_FORMAT: if ((j = dup (fd)) == NOTOK) return NOTOK; if ((fp = fdopen (j, "r")) == NULL) { close (j); return NOTOK; } start = lseek (md, (off_t) 0, SEEK_CUR); /* If text is given, we add it to top of message */ if (text) { i = strlen (text); if (write (md, text, i) != i) return NOTOK; for (cp = text; *cp++; size++) if (*cp == '\n') size++; } for (j = 0; fgets (buffer, sizeof(buffer), fp) != NULL; j++) { /* * Check the first line, and make some changes. */ if (j == 0 && !text) { /* * Change the "Return-Path:" field (if in first line) * back to "From ". */ if (!strncmp (buffer, "Return-Path:", 12)) { char tmpbuffer[BUFSIZ]; char *tp, *ep, *fp; strncpy(tmpbuffer, buffer, sizeof(tmpbuffer)); ep = tmpbuffer + 13; if (!(fp = strchr(ep + 1, ' '))) fp = strchr(ep + 1, '\n'); tp = dctime(dlocaltimenow()); snprintf (buffer, sizeof(buffer), "From %.*s %s", (int)(fp - ep), ep, tp); } else if (!strncmp (buffer, "X-Envelope-From:", 16)) { /* * Change the "X-Envelope-From:" field * (if first line) back to "From ". */ char tmpbuffer[BUFSIZ]; char *ep; strncpy(tmpbuffer, buffer, sizeof(tmpbuffer)); ep = tmpbuffer + 17; snprintf (buffer, sizeof(buffer), "From %s", ep); } else if (strncmp (buffer, "From ", 5)) { /* * If there is already a "From " line, * then leave it alone. Else we add one. */ char tmpbuffer[BUFSIZ]; char *tp, *ep; strncpy(tmpbuffer, buffer, sizeof(tmpbuffer)); ep = "nobody@nowhere"; tp = dctime(dlocaltimenow()); snprintf (buffer, sizeof(buffer), "From %s %s%s", ep, tp, tmpbuffer); } } /* * If this is not first line, and begins with * "From ", then prepend line with ">". */ if (j != 0 && strncmp (buffer, "From ", 5) == 0) { write (md, ">", 1); size++; } i = strlen (buffer); if (write (md, buffer, i) != i) { fclose (fp); return NOTOK; } if (mapping) for (cp = buffer; i-- > 0; size++) if (*cp++ == '\n') size++; } if (write (md, "\n", 1) != 1) { fclose (fp); return NOTOK; } if (mapping) size += 2; fclose (fp); lseek (fd, (off_t) 0, SEEK_END); stop = lseek (md, (off_t) 0, SEEK_CUR); if (mapping) map_write (mailbox, md, 0, (long) 0, start, stop, pos, size, noisy); return OK; } }
static int __init init_autcpu12_sram (void) { map_word tmp, save0, save1; int err; autcpu12_sram_map.virt = ioremap(0x12000000, SZ_128K); if (!autcpu12_sram_map.virt) { printk("Failed to ioremap autcpu12 NV-RAM space\n"); err = -EIO; goto out; } simple_map_init(&autcpu12_sram_map); /* * Check for 32K/128K * read ofs 0 * read ofs 0x10000 * Write complement to ofs 0x100000 * Read and check result on ofs 0x0 * Restore contents */ save0 = map_read(&autcpu12_sram_map, 0); save1 = map_read(&autcpu12_sram_map, 0x10000); tmp.x[0] = ~save0.x[0]; map_write(&autcpu12_sram_map, tmp, 0x10000); /* if we find this pattern on 0x0, we have 32K size * restore contents and exit */ tmp = map_read(&autcpu12_sram_map, 0); if (!map_word_equal(&autcpu12_sram_map, tmp, save0)) { map_write(&autcpu12_sram_map, save0, 0x0); goto map; } /* We have a 128K found, restore 0x10000 and set size * to 128K */ map_write(&autcpu12_sram_map, save1, 0x10000); autcpu12_sram_map.size = SZ_128K; map: sram_mtd = do_map_probe("map_ram", &autcpu12_sram_map); if (!sram_mtd) { printk("NV-RAM probe failed\n"); err = -ENXIO; goto out_ioremap; } sram_mtd->owner = THIS_MODULE; sram_mtd->erasesize = 16; if (mtd_device_register(sram_mtd, NULL, 0)) { printk("NV-RAM device addition failed\n"); err = -ENOMEM; goto out_probe; } printk("NV-RAM device size %ldKiB registered on AUTCPU12\n",autcpu12_sram_map.size/SZ_1K); return 0; out_probe: map_destroy(sram_mtd); sram_mtd = 0; out_ioremap: iounmap((void *)autcpu12_sram_map.virt); out: return err; }