/* checks if a and b are identical or device
* files associated with the same block device or
* if one file is a loop device that uses the other
* file.
*/
int is_same_loop_file(const char* a, const char* b)
{
char res_a[PATH_MAX];
char res_b[PATH_MAX];
const char* final_a;
const char* final_b;
int ret;
/* Resolve a if it is a loop device */
if((ret = is_loop_device(a)) < 0) {
return ret;
} else if(ret) {
if((ret = resolve_loop_device(a, res_a, sizeof(res_a))) < 0)
return ret;
final_a = res_a;
} else {
final_a = a;
}
/* Resolve b if it is a loop device */
if((ret = is_loop_device(b)) < 0) {
return ret;
} else if(ret) {
if((ret = resolve_loop_device(b, res_b, sizeof(res_b))) < 0)
return ret;
final_b = res_b;
} else {
final_b = b;
}
return is_same_blk_file(final_a, final_b);
}
/* Umount a single device. Return a status code, so don't exit
on a non-fatal error. We lock/unlock around each umount. */
static int
umount_one (const char *spec, const char *node, const char *type,
const char *opts, struct mntentchn *mc) {
int umnt_err = 0;
int isroot;
int res;
int status;
const char *loopdev;
int myloop = 0;
/* Special case for root. As of 0.99pl10 we can (almost) unmount root;
the kernel will remount it readonly so that we can carry on running
afterwards. The readonly remount is illegal if any files are opened
for writing at the time, so we can't update mtab for an unmount of
root. As it is only really a remount, this doesn't matter too
much. [sct May 29, 1993] */
isroot = (streq (node, "/") || streq (node, "root")
|| streq (node, "rootfs"));
if (isroot)
nomtab++;
/*
* Call umount.TYPE for types that require a separate umount program.
* All such special things must occur isolated in the types string.
*/
if (check_special_umountprog(spec, node, type, &status))
return status;
/*
* Ignore the option "-d" for non-loop devices and loop devices with
* LO_FLAGS_AUTOCLEAR flag.
*/
if (delloop && is_loop_device(spec) && !is_loop_autoclear(spec))
myloop = 1;
if (lazy) {
res = umount2 (node, MNT_DETACH);
if (res < 0)
umnt_err = errno;
goto writemtab;
}
if (force) { /* only supported for NFS */
res = umount2 (node, MNT_FORCE);
if (res == -1) {
int errsv = errno;
perror("umount2");
errno = errsv;
if (errno == ENOSYS) {
if (verbose)
printf(_("no umount2, trying umount...\n"));
res = umount (node);
}
}
} else
res = umount (node);
if (res < 0)
umnt_err = errno;
if (res < 0 && remount && umnt_err == EBUSY) {
/* Umount failed - let us try a remount */
res = mount(spec, node, NULL,
MS_MGC_VAL | MS_REMOUNT | MS_RDONLY, NULL);
if (res == 0) {
struct my_mntent remnt;
fprintf(stderr,
_("umount: %s busy - remounted read-only\n"),
spec);
remnt.mnt_type = remnt.mnt_fsname = NULL;
remnt.mnt_dir = xstrdup(node);
remnt.mnt_opts = xstrdup("ro");
if (!nomtab)
update_mtab(node, &remnt);
return 0;
} else if (errno != EBUSY) { /* hmm ... */
perror("remount");
fprintf(stderr,
_("umount: could not remount %s read-only\n"),
spec);
}
}
loopdev = 0;
if (res >= 0) {
/* Umount succeeded */
if (verbose)
printf (_("%s umounted\n"), spec);
/* Free any loop devices that we allocated ourselves */
if (mc) {
char *optl;
/* old style mtab line? */
if (streq(mc->m.mnt_type, "loop")) {
loopdev = spec;
goto gotloop;
}
/* new style mtab line? */
optl = mc->m.mnt_opts ? xstrdup(mc->m.mnt_opts) : "";
for (optl = strtok (optl, ","); optl;
optl = strtok (NULL, ",")) {
if (!strncmp(optl, "loop=", 5)) {
loopdev = optl+5;
goto gotloop;
}
}
} else {
/*
* If option "-o loop=spec" occurs in mtab,
* note the mount point, and delete mtab line.
*/
if ((mc = getmntoptfile (spec)) != NULL)
node = mc->m.mnt_dir;
}
/* Also free loop devices when -d flag is given */
if (myloop)
loopdev = spec;
}
gotloop:
if (loopdev)
del_loop(loopdev);
writemtab:
if (!nomtab &&
(umnt_err == 0 || umnt_err == EINVAL || umnt_err == ENOENT)) {
update_mtab (node, NULL);
}
if (res >= 0)
return 0;
if (umnt_err)
complain(umnt_err, node);
return 1;
}