#include <dirent.h>
#include <signal.h>
+int __offroot;
+
/*
* following taken from linux/blkpg.h because they aren't
* anywhere else and it isn't safe to #include linux/ * stuff.
{
struct utsname name;
char *cp;
- int a,b,c;
+ int a = 0, b = 0,c = 0;
if (uname(&name) <0)
return -1;
cp = name.release;
a = strtoul(cp, &cp, 10);
- if (*cp != '.') return -1;
- b = strtoul(cp+1, &cp, 10);
- if (*cp != '.') return -1;
- c = strtoul(cp+1, NULL, 10);
+ if (*cp == '.')
+ b = strtoul(cp+1, &cp, 10);
+ if (*cp == '.')
+ c = strtoul(cp+1, &cp, 10);
return (a*1000000)+(b*1000)+c;
}
+#ifndef MDASSEMBLE
int mdadm_version(char *version)
{
int a, b, c;
return (a*1000000)+(b*1000)+c;
}
-#ifndef MDASSEMBLE
long long parse_size(char *size)
{
/* parse 'size' which should be a number optionally
* followed by 'K', 'M', or 'G'.
* Without a suffix, K is assumed.
* Number returned is in sectors (half-K)
+ * -1 returned on error.
*/
char *c;
long long s = strtoll(size, &c, 10);
}
}
if (*c)
- s = 0;
+ s = -1;
return s;
}
{
/* Parse the layout string for 'faulty' */
int ln = strcspn(layout, "0123456789");
- char *m = strdup(layout);
+ char *m = xstrdup(layout);
int mode;
m[ln] = 0;
mode = map_name(faultylayout, m);
return mode | (atoi(layout+ln)<< ModeShift);
}
+
+long parse_num(char *num)
+{
+ /* Either return a valid number, or -1 */
+ char *c;
+ long rv = strtol(num, &c, 10);
+ if (rv < 0 || *c || !num[0])
+ return -1;
+ else
+ return rv;
+}
#endif
void remove_partitions(int fd)
return 1;
}
+int test_partition_from_id(dev_t id)
+{
+ char buf[20];
+ int fd, rv;
+
+ sprintf(buf, "%d:%d", major(id), minor(id));
+ fd = dev_open(buf, O_RDONLY);
+ if (fd < 0)
+ return -1;
+ rv = test_partition(fd);
+ close(fd);
+ return rv;
+}
-int enough(int level, int raid_disks, int layout, int clean,
- char *avail, int avail_disks)
+int enough(int level, int raid_disks, int layout, int clean, char *avail)
{
int copies, first;
+ int i;
+ int avail_disks = 0;
+
+ for (i = 0; i < raid_disks; i++)
+ avail_disks += !!avail[i];
+
switch (level) {
case 10:
/* This is the tricky one - we need to check
struct mdu_array_info_s array;
struct mdu_disk_info_s disk;
int avail_disks = 0;
- int i;
+ int i, rv;
char *avail;
if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
array.raid_disks <= 0)
return 0;
- avail = calloc(array.raid_disks, 1);
- for (i=0; i<array.raid_disks + array.nr_disks; i++) {
+ avail = xcalloc(array.raid_disks, 1);
+ for (i=0; i < MAX_DISKS && array.nr_disks > 0; i++) {
disk.number = i;
if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
continue;
+ if (disk.major == 0 && disk.minor == 0)
+ continue;
+ array.nr_disks--;
+
if (! (disk.state & (1<<MD_DISK_SYNC)))
continue;
if (disk.raid_disk < 0 || disk.raid_disk >= array.raid_disks)
avail[disk.raid_disk] = 1;
}
/* This is used on an active array, so assume it is clean */
- return enough(array.level, array.raid_disks, array.layout,
- 1,
- avail, avail_disks);
+ rv = enough(array.level, array.raid_disks, array.layout,
+ 1, avail);
+ free(avail);
+ return rv;
}
mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
- fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
+ pr_err("%s appears to contain an ext2fs file system\n",
name);
fprintf(stderr," size=%dK mtime=%s",
size*(1<<bsize), ctime(&mtime));
if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
return 0;
- fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
+ pr_err("%s appears to contain a reiserfs file system\n",name);
size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
fprintf(stderr, " size = %luK\n", size*4);
struct supertype *st = guess_super(fd);
if (!st) return 0;
+ st->ignore_hw_compat = 1;
st->ss->load_super(st, fd, name);
/* Looks like a raid array .. */
- fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
+ pr_err("%s appears to be part of a raid array:\n",
name);
st->ss->getinfo_super(st, &info, NULL);
st->ss->free_super(st);
return 0;
add = "(y/n) ";
}
- fprintf(stderr, Name ": assuming 'no'\n");
+ pr_err("assuming 'no'\n");
return 0;
}
#endif /* MDASSEMBLE */
-char *map_num(mapping_t *map, int num)
-{
- while (map->name) {
- if (map->num == num)
- return map->name;
- map++;
- }
- return NULL;
-}
-
-int map_name(mapping_t *map, char *name)
-{
- while (map->name) {
- if (strcmp(map->name, name)==0)
- return map->num;
- map++;
- }
- return UnSet;
-}
-
-
int is_standard(char *dev, int *nump)
{
/* tests if dev is a "standard" md dev name.
return type;
}
-
-/*
- * convert a major/minor pair for a block device into a name in /dev, if possible.
- * On the first call, walk /dev collecting name.
- * Put them in a simple linked listfor now.
- */
-struct devmap {
- int major, minor;
- char *name;
- struct devmap *next;
-} *devlist = NULL;
-int devlist_ready = 0;
-
-int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
-{
- struct stat st;
-
- if (S_ISLNK(stb->st_mode)) {
- if (stat(name, &st) != 0)
- return 0;
- stb = &st;
- }
-
- if ((stb->st_mode&S_IFMT)== S_IFBLK) {
- char *n = strdup(name);
- struct devmap *dm = malloc(sizeof(*dm));
- if (strncmp(n, "/dev/./", 7)==0)
- strcpy(n+4, name+6);
- if (dm) {
- dm->major = major(stb->st_rdev);
- dm->minor = minor(stb->st_rdev);
- dm->name = n;
- dm->next = devlist;
- devlist = dm;
- }
- }
- return 0;
-}
-
-#ifndef HAVE_NFTW
-#ifdef HAVE_FTW
-int add_dev_1(const char *name, const struct stat *stb, int flag)
-{
- return add_dev(name, stb, flag, NULL);
-}
-int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
-{
- return ftw(path, add_dev_1, nopenfd);
-}
-#else
-int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
-{
- return 0;
-}
-#endif /* HAVE_FTW */
-#endif /* HAVE_NFTW */
-
-/*
- * Find a block device with the right major/minor number.
- * If we find multiple names, choose the shortest.
- * If we find a name in /dev/md/, we prefer that.
- * This applies only to names for MD devices.
- */
-char *map_dev(int major, int minor, int create)
-{
- struct devmap *p;
- char *regular = NULL, *preferred=NULL;
- int did_check = 0;
-
- if (major == 0 && minor == 0)
- return NULL;
-
- retry:
- if (!devlist_ready) {
- char *dev = "/dev";
- struct stat stb;
- while(devlist) {
- struct devmap *d = devlist;
- devlist = d->next;
- free(d->name);
- free(d);
- }
- if (lstat(dev, &stb)==0 &&
- S_ISLNK(stb.st_mode))
- dev = "/dev/.";
- nftw(dev, add_dev, 10, FTW_PHYS);
- devlist_ready=1;
- did_check = 1;
- }
-
- for (p=devlist; p; p=p->next)
- if (p->major == major &&
- p->minor == minor) {
- if (strncmp(p->name, "/dev/md/",8) == 0) {
- if (preferred == NULL ||
- strlen(p->name) < strlen(preferred))
- preferred = p->name;
- } else {
- if (regular == NULL ||
- strlen(p->name) < strlen(regular))
- regular = p->name;
- }
- }
- if (!regular && !preferred && !did_check) {
- devlist_ready = 0;
- goto retry;
- }
- if (create && !regular && !preferred) {
- static char buf[30];
- snprintf(buf, sizeof(buf), "%d:%d", major, minor);
- regular = buf;
- }
-
- return preferred ? preferred : regular;
-}
-
unsigned long calc_csum(void *super, int bytes)
{
unsigned long long newcsum = 0;
* We allow upto 2048Megabytes before converting to
* gigabytes, as that shows more precision and isn't
* too large a number.
- * Terrabytes are not yet handled.
+ * Terabytes are not yet handled.
*/
if (bytes < 5000*1024)
unsigned long long calc_array_size(int level, int raid_disks, int layout,
int chunksize, unsigned long long devsize)
+{
+ if (level == 1)
+ return devsize;
+ devsize &= ~(unsigned long long)((chunksize>>9)-1);
+ return get_data_disks(level, layout, raid_disks) * devsize;
+}
+
+int get_data_disks(int level, int layout, int raid_disks)
{
int data_disks = 0;
switch (level) {
case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
break;
}
- devsize &= ~(unsigned long long)((chunksize>>9)-1);
- return data_disks * devsize;
-}
-
-int get_mdp_major(void)
-{
-static int mdp_major = -1;
- FILE *fl;
- char *w;
- int have_block = 0;
- int have_devices = 0;
- int last_num = -1;
- if (mdp_major != -1)
- return mdp_major;
- fl = fopen("/proc/devices", "r");
- if (!fl)
- return -1;
- while ((w = conf_word(fl, 1))) {
- if (have_block && strcmp(w, "devices:")==0)
- have_devices = 1;
- have_block = (strcmp(w, "Block")==0);
- if (isdigit(w[0]))
- last_num = atoi(w);
- if (have_devices && strcmp(w, "mdp")==0)
- mdp_major = last_num;
- free(w);
- }
- fclose(fl);
- return mdp_major;
+ return data_disks;
}
#if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
return fd;
}
-int open_dev(int devnum)
+int open_dev_flags(int devnum, int flags)
{
char buf[20];
sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
- return dev_open(buf, O_RDWR);
+ return dev_open(buf, flags);
+}
+
+int open_dev(int devnum)
+{
+ return open_dev_flags(devnum, O_RDONLY);
}
int open_dev_excl(int devnum)
{
char buf[20];
int i;
+ int flags = O_RDWR;
sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
for (i=0 ; i<25 ; i++) {
- int fd = dev_open(buf, O_RDWR|O_EXCL);
+ int fd = dev_open(buf, flags|O_EXCL);
if (fd >= 0)
return fd;
+ if (errno == EACCES && flags == O_RDWR) {
+ flags = O_RDONLY;
+ continue;
+ }
if (errno != EBUSY)
return fd;
usleep(200000);
char *dev = verstr+1;
subarray = strchr(dev, '/');
- if (subarray)
+ if (subarray) {
*subarray++ = '\0';
- subarray = strdup(subarray);
+ subarray = xstrdup(subarray);
+ }
container = devname2devnum(dev);
if (sra)
sysfs_free(sra);
if (!orig)
return orig;
- st = malloc(sizeof(*st));
- if (!st)
- return st;
- memset(st, 0, sizeof(*st));
+ st = xcalloc(1, sizeof(*st));
st->ss = orig->ss;
st->max_devs = orig->max_devs;
st->minor_version = orig->minor_version;
int bestsuper = -1;
int i;
- st = malloc(sizeof(*st));
- memset(st, 0, sizeof(*st));
+ st = xcalloc(1, sizeof(*st));
st->container_dev = NoMdDev;
for (i=0 ; superlist[i]; i++) {
if (guess_type == guess_partitions && ss->add_to_super != NULL)
continue;
memset(st, 0, sizeof(*st));
+ st->ignore_hw_compat = 1;
rv = ss->load_super(st, fd, NULL);
if (rv == 0) {
struct mdinfo info;
if (bestsuper != -1) {
int rv;
memset(st, 0, sizeof(*st));
+ st->ignore_hw_compat = 1;
rv = superlist[bestsuper]->load_super(st, fd, NULL);
if (rv == 0) {
superlist[bestsuper]->free_super(st);
+ st->ignore_hw_compat = 0;
return st;
}
}
ldsize <<= 9;
} else {
if (dname)
- fprintf(stderr, Name ": Cannot get size of %s: %s\b",
+ pr_err("Cannot get size of %s: %s\b",
dname, strerror(errno));
return 0;
}
static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
{
struct GPT gpt;
- unsigned char buf[512];
unsigned char empty_gpt_entry[16]= {0};
struct GPT_part_entry *part;
+ char buf[512];
unsigned long long curr_part_end;
unsigned all_partitions, entry_size;
unsigned part_nr;
*endofpart = 0;
BUILD_BUG_ON(sizeof(gpt) != 512);
- /* read GPT header */
+ /* skip protective MBR */
lseek(fd, 512, SEEK_SET);
+ /* read GPT header */
if (read(fd, &gpt, 512) != 512)
return 0;
/* sanity checks */
if (all_partitions > 1024 ||
- entry_size > 512)
+ entry_size > sizeof(buf))
return -1;
- /* read first GPT partition entries */
- if (read(fd, buf, 512) != 512)
- return 0;
-
- part = (struct GPT_part_entry*)buf;
+ part = (struct GPT_part_entry *)buf;
for (part_nr=0; part_nr < all_partitions; part_nr++) {
+ /* read partition entry */
+ if (read(fd, buf, entry_size) != (ssize_t)entry_size)
+ return 0;
+
/* is this valid partition? */
if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
/* check the last lba for the current partition */
*endofpart = curr_part_end;
}
- part = (struct GPT_part_entry*)((unsigned char*)part + entry_size);
-
- if ((unsigned char *)part >= buf + 512) {
- if (read(fd, buf, 512) != 512)
- return 0;
- part = (struct GPT_part_entry*)buf;
- }
}
return 1;
}
return retval;
}
-int check_partitions(int fd, char *dname, unsigned long long freesize)
+int check_partitions(int fd, char *dname, unsigned long long freesize,
+ unsigned long long size)
{
/*
* Check where the last partition ends
/* There appears to be a partition table here */
if (freesize == 0) {
/* partitions will not be visible in new device */
- fprintf(stderr,
- Name ": partition table exists on %s but will be lost or\n"
- " meaningless after creating array\n",
- dname);
+ pr_err("partition table exists on %s but will be lost or\n"
+ " meaningless after creating array\n",
+ dname);
return 1;
} else if (endofpart > freesize) {
/* last partition overlaps metadata */
- fprintf(stderr,
- Name ": metadata will over-write last partition on %s.\n",
- dname);
+ pr_err("metadata will over-write last partition on %s.\n",
+ dname);
+ return 1;
+ } else if (size && endofpart > size) {
+ /* partitions will be truncated in new device */
+ pr_err("array size is too small to cover all partitions on %s.\n",
+ dname);
return 1;
}
}
void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
{
int d;
+
ioctl(mdfd, GET_ARRAY_INFO, ainf);
- for (d = 0 ; d < ainf->raid_disks + ainf->nr_disks ; d++)
- if (ioctl(mdfd, GET_DISK_INFO, disk) == 0)
+ for (d = 0 ; d < MAX_DISKS ; d++) {
+ if (ioctl(mdfd, GET_DISK_INFO, disk) == 0 &&
+ (disk->major || disk->minor))
return;
+ }
}
int open_container(int fd)
for (ent = mdstat; ent; ent = ent->next)
if (is_container_member(ent, container))
- if (!subarray ||
- strcmp(to_subarray(ent, container), subarray) == 0)
+ if (strcmp(to_subarray(ent, container), subarray) == 0)
break;
free_mdstat(mdstat);
return ent != NULL;
}
-int is_container_active(char *container)
-{
- return is_subarray_active(NULL, container);
-}
-
/* open_subarray - opens a subarray in a container
* @dev: container device name
* @st: empty supertype
fd = open(dev, O_RDWR|O_EXCL);
if (fd < 0) {
if (!quiet)
- fprintf(stderr, Name ": Couldn't open %s, aborting\n",
+ pr_err("Couldn't open %s, aborting\n",
dev);
- return 2;
+ return -1;
}
st->devnum = fd2devnum(fd);
if (st->devnum == NoMdDev) {
if (!quiet)
- fprintf(stderr,
- Name ": Failed to determine device number for %s\n",
- dev);
+ pr_err("Failed to determine device number for %s\n",
+ dev);
goto close_fd;
}
mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
if (!mdi) {
if (!quiet)
- fprintf(stderr, Name ": Failed to read sysfs for %s\n",
+ pr_err("Failed to read sysfs for %s\n",
dev);
goto close_fd;
}
if (mdi->array.level != UnSet) {
if (!quiet)
- fprintf(stderr, Name ": %s is not a container\n", dev);
+ pr_err("%s is not a container\n", dev);
goto free_sysfs;
}
st->ss = version_to_superswitch(mdi->text_version);
if (!st->ss) {
if (!quiet)
- fprintf(stderr,
- Name ": Operation not supported for %s metadata\n",
- mdi->text_version);
+ pr_err("Operation not supported for %s metadata\n",
+ mdi->text_version);
goto free_sysfs;
}
st->devname = devnum2devname(st->devnum);
if (!st->devname) {
if (!quiet)
- fprintf(stderr, Name ": Failed to allocate device name\n");
+ pr_err("Failed to allocate device name\n");
goto free_sysfs;
}
if (!st->ss->load_container) {
if (!quiet)
- fprintf(stderr, Name ": %s is not a container\n", dev);
+ pr_err("%s is not a container\n", dev);
goto free_name;
}
if (st->ss->load_container(st, fd, NULL)) {
if (!quiet)
- fprintf(stderr, Name ": Failed to load metadata for %s\n",
+ pr_err("Failed to load metadata for %s\n",
dev);
goto free_name;
}
info = st->ss->container_content(st, subarray);
if (!info) {
if (!quiet)
- fprintf(stderr, Name ": Failed to find subarray-%s in %s\n",
+ pr_err("Failed to find subarray-%s in %s\n",
subarray, dev);
goto free_super;
}
if (sd2 == info)
break;
if (sd2 == NULL) {
- sd2 = malloc(sizeof(*sd2));
+ sd2 = xmalloc(sizeof(*sd2));
*sd2 = *info;
sd2->next = sra->devs;
sra->devs = sd2;
return recovery_start;
}
-void fmt_devname(char *name, int num)
-{
- if (num >= 0)
- sprintf(name, "md%d", num);
- else
- sprintf(name, "md_d%d", -1-num);
-}
-
-char *devnum2devname(int num)
-{
- char name[100];
- fmt_devname(name,num);
- return strdup(name);
-}
-
-int devname2devnum(char *name)
-{
- char *ep;
- int num;
- if (strncmp(name, "md_d", 4)==0)
- num = -1-strtoul(name+4, &ep, 10);
- else
- num = strtoul(name+2, &ep, 10);
- return num;
-}
-
-int stat2devnum(struct stat *st)
-{
- char path[30];
- char link[200];
- char *cp;
- int n;
-
- if ((S_IFMT & st->st_mode) == S_IFBLK) {
- if (major(st->st_rdev) == MD_MAJOR)
- return minor(st->st_rdev);
- else if (major(st->st_rdev) == (unsigned)get_mdp_major())
- return -1- (minor(st->st_rdev)>>MdpMinorShift);
-
- /* must be an extended-minor partition. Look at the
- * /sys/dev/block/%d:%d link which must look like
- * ../../block/mdXXX/mdXXXpYY
- */
- sprintf(path, "/sys/dev/block/%d:%d", major(st->st_rdev),
- minor(st->st_rdev));
- n = readlink(path, link, sizeof(link)-1);
- if (n <= 0)
- return NoMdDev;
- link[n] = 0;
- cp = strrchr(link, '/');
- if (cp) *cp = 0;
- cp = strrchr(link, '/');
- if (cp && strncmp(cp, "/md", 3) == 0)
- return devname2devnum(cp+1);
- }
- return NoMdDev;
-
-}
-
-int fd2devnum(int fd)
-{
- struct stat stb;
- if (fstat(fd, &stb) == 0)
- return stat2devnum(&stb);
- return NoMdDev;
-}
-
int mdmon_pid(int devnum)
{
char path[100];
int start_mdmon(int devnum)
{
- int i;
+ int i, skipped;
int len;
pid_t pid;
int status;
if (check_env("MDADM_NO_MDMON"))
return 0;
- len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
+ len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf)-1);
if (len > 0) {
char *sl;
pathbuf[len] = 0;
switch(fork()) {
case 0:
/* FIXME yuk. CLOSE_EXEC?? */
- for (i=3; i < 100; i++)
- close(i);
+ skipped = 0;
+ for (i=3; skipped < 20; i++)
+ if (close(i) < 0)
+ skipped++;
+ else
+ skipped = 0;
+
for (i=0; paths[i]; i++)
- if (paths[i][0])
- execl(paths[i], "mdmon",
- devnum2devname(devnum),
- NULL);
+ if (paths[i][0]) {
+ if (__offroot) {
+ execl(paths[i], "mdmon", "--offroot",
+ devnum2devname(devnum),
+ NULL);
+ } else {
+ execl(paths[i], "mdmon",
+ devnum2devname(devnum),
+ NULL);
+ }
+ }
exit(1);
- case -1: fprintf(stderr, Name ": cannot run mdmon. "
+ case -1: pr_err("cannot run mdmon. "
"Array remains readonly\n");
return -1;
default: /* parent - good */
void append_metadata_update(struct supertype *st, void *buf, int len)
{
- struct metadata_update *mu = malloc(sizeof(*mu));
+ struct metadata_update *mu = xmalloc(sizeof(*mu));
mu->buf = buf;
mu->len = len;
if (check_env("MDADM_EXPERIMENTAL"))
return 1;
else {
- fprintf(stderr, Name ": To use this feature MDADM_EXPERIMENTAL enviroment variable has to defined.\n");
+ pr_err("To use this feature MDADM_EXPERIMENTAL"
+ " environment variable has to be defined.\n");
return 0;
}
}
if (spare_group)
pol_add(&pol, pol_domain,
spare_group, NULL);
- if (!domain_test(domlist, pol, metadata))
+ if (domain_test(domlist, pol, metadata) != 1)
found = 0;
dev_policy_free(pol);
}
}
return disks;
}
+
+void *xmalloc(size_t len)
+{
+ void *rv = malloc(len);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+void *xrealloc(void *ptr, size_t len)
+{
+ void *rv = realloc(ptr, len);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+void *xcalloc(size_t num, size_t size)
+{
+ void *rv = calloc(num, size);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}
+
+char *xstrdup(const char *str)
+{
+ char *rv = strdup(str);
+ char *msg;
+ if (rv)
+ return rv;
+ msg = Name ": memory allocation failure - aborting\n";
+ exit(4+!!write(2, msg, strlen(msg)));
+}