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