void do_mount_mainfs(void)
{
#ifdef CONFIG_MTD
struct mtd_info *mtd = NULL;
char mtd_name[32];
mtd = get_mtd_device_nm(CONFIG_RG_MAINFS_MTDPART_NAME);
if (IS_ERR(mtd))
{
panic("Can not find %s MTD partition",
CONFIG_RG_MAINFS_MTDPART_NAME);
}
sprintf(mtd_name, "/dev/mtdblock%d", mtd->index);
printk("Found device %s on mtdblock%d\n",
CONFIG_RG_MAINFS_MTDPART_NAME, mtd->index);
if (do_mount(mtd_name, "/mnt/cramfs", "cramfs", MS_RDONLY, 0))
printk("Warning: unable to mount cramfs\n");
#else
if (do_mount("cramfs", "/mnt/cramfs", "cramfs_mainfs", MS_RDONLY, 0))
printk("Warning: unable to mount cramfs\n");
#endif
}
void Mount::run_mount(const QString& name)
{
const CryptTab::VolumeInfo vi = ctab.location(name);
const QString location = vi.location;
if (location.length()) {
State state = mounts.state(location, name);
switch(state) {
case disconnected: {
emit signal([&](){
QMessageBox msgBox;
msgBox.setWindowTitle("Fail to mount");
msgBox.setText("You can't mount a disconnected drive. Please, connect it first");
msgBox.exec();});
}
break;
case connected: {
QString text;
if (vi.ask_pass) { // ask password
bool ok;
QString cap("Unlocking");
cap.append(' ');
cap.append(name);
QString msg ("Please, enter passphrase");
emit (signal([&](){
text = QInputDialog::getText(parent,
cap,
msg,
QLineEdit::Password,
"",
&ok);
}));
if (!ok || text.isEmpty()) {
break;
}
}
if(do_cryptdisk_start(name, vi, text))
{
do_mount(name);
} else {
emit (signal([&](){
QMessageBox msgBox;
msgBox.setWindowTitle("Fail to mount");
msgBox.setText("Wrong password");
msgBox.exec();
}));
}
}
break;
case dm_started:
do_mount(name);
default: /* nothing to do here */
;;
}
}
}
static int do_mount_by_pattern(struct libmnt_context *cxt, const char *pattern)
{
int neg = pattern && strncmp(pattern, "no", 2) == 0;
int rc = -EINVAL;
char **filesystems, **fp;
assert(cxt);
assert((cxt->flags & MNT_FL_MOUNTFLAGS_MERGED));
if (!neg && pattern) {
/*
* try all types from the list
*/
char *p, *p0;
DBG(CXT, mnt_debug_h(cxt, "trying to mount by FS pattern list"));
p0 = p = strdup(pattern);
if (!p)
return -ENOMEM;
do {
char *end = strchr(p, ',');
if (end)
*end = '\0';
rc = do_mount(cxt, p);
p = end ? end + 1 : NULL;
} while (!mnt_context_get_status(cxt) && p);
free(p0);
if (mnt_context_get_status(cxt))
return rc;
}
/*
* try /etc/filesystems and /proc/filesystems
*/
DBG(CXT, mnt_debug_h(cxt, "trying to mount by filesystems lists"));
rc = mnt_get_filesystems(&filesystems, neg ? pattern : NULL);
if (rc)
return rc;
for (fp = filesystems; *fp; fp++) {
rc = do_mount(cxt, *fp);
if (mnt_context_get_status(cxt))
break;
if (mnt_context_get_syscall_errno(cxt) != EINVAL)
break;
}
mnt_free_filesystems(filesystems);
return rc;
}
uint8_t bootmgr_boot_sd(void)
{
bootmgr_set_lines_count(0);
bootmgr_set_fills_count(0);
char *path = (char*)malloc(200);
if(selected == 2)
{
bootmgr_printf(-1, 20, WHITE, "Booting from SD-card...");
sprintf(path, "/sdroot/multirom/rom");
}
else
{
sprintf(path, "/sdroot/multirom/backup/%s", backups[selected-5]);
bootmgr_printf(-1, 20, WHITE, "Booting \"%s\"...", backups[selected-5]);
}
selected = -1;
bootmgr_draw();
char *p = (char*)malloc(200);
char *s = (char*)malloc(50);
sprintf(p, "%s/boot", path);
bootmgr_import_boot(p);
char * mount_args[] = { NULL, "ext4", p, s, "bind" };
// /system
sprintf(p, "%s/system", path);
strcpy(s, "/system");
if(do_mount(5, mount_args) < 0)
{
bootmgr_printf(-1, 20, WHITE, "Mount %s failed", mount_args[2]);
bootmgr_draw();
return 0;
}
// /data
sprintf(p, "%s/data", path);
strcpy(s, "/data");
do_mount(5, mount_args);
// /cache
sprintf(p, "%s/cache", path);
strcpy(s, "/cache");
do_mount(5, mount_args);
free(p);
free(s);
free(path);
return 1;
}
static int mount_fuse(const char *mnt, const char *opts)
{
int res;
int fd;
char *dev;
struct stat stbuf;
char *type = NULL;
char *source = NULL;
char *mnt_opts = NULL;
const char *real_mnt = mnt;
int currdir_fd = -1;
int mountpoint_fd = -1;
fd = open_fuse_device(&dev);
if (fd == -1)
return -1;
if (getuid() != 0 && mount_max != -1) {
if (count_fuse_fs() >= mount_max) {
fprintf(stderr, "%s: too many mounted FUSE filesystems (%d+)\n",
progname, mount_max);
goto err;
}
}
res = check_perm(&real_mnt, &stbuf, &currdir_fd, &mountpoint_fd);
if (res != -1)
res = do_mount(real_mnt, &type, stbuf.st_mode & S_IFMT, fd, opts, dev,
&source, &mnt_opts);
if (currdir_fd != -1) {
__attribute__((unused))int ignored_fchdir_status =
fchdir(currdir_fd);
close(currdir_fd);
}
static bool do_format(const std::string &mountpoint)
{
if (mountpoint == SYSTEM || mountpoint == CACHE) {
// Need to mount the partition if we're using an image file and it
// hasn't been mounted
int needs_mount = (mountpoint == SYSTEM)
&& (access("/mb/system.img", F_OK) == 0)
&& (access(STAMP_FILE, F_OK) != 0);
if (needs_mount && !do_mount(mountpoint)) {
LOGE(TAG "Failed to mount {}", mountpoint);
return false;
}
if (!wipe_directory(mountpoint, true)) {
LOGE(TAG "Failed to wipe {}", mountpoint);
return false;
}
if (needs_mount && !do_unmount(mountpoint)) {
LOGE(TAG "Failed to unmount {}", mountpoint);
return false;
}
} else if (mountpoint == DATA) {
if (!wipe_directory(mountpoint, false)) {
LOGE(TAG "Failed to wipe {}", mountpoint);
return false;
}
}
LOGD(TAG "Formatted {}", mountpoint);
return true;
}
static int prepare_buffer(int argc, char * argv[])
{
if (argc<2) {
usage();
return -1;
}
if (strncmp(argv[1],"mount",5)==0) {
return do_mount(argc,argv);
} else if (strncmp(argv[1],"resume",6)==0) {
return do_resume(argc,argv);
} else if (strncmp(argv[1],"suspend",7)==0) {
return do_suspend(argc,argv);
} else if (strncmp(argv[1],"status",6)==0) {
return do_status(argc,argv);
} else if (strncmp(argv[1],"unmount",7)==0) {
return do_unmount(argc,argv);
} else if (strncmp(argv[1],"exit",4)==0) {
return do_exit(argc,argv);
} else {
usage();
return -1;
}
return 0;
}
/*===========================================================================*
* do_fslogin *
*===========================================================================*/
PUBLIC int do_fslogin()
{
/* Login before mount request */
if ((unsigned long)mount_m_in.m1_p3 != who_e) {
last_login_fs_e = who_e;
return SUSPEND;
}
/* Login after a suspended mount */
else {
/* Copy back original mount request message */
m_in = mount_m_in;
/* Set up last login FS */
last_login_fs_e = who_e;
/* Set up endpoint and call nr */
who_e = m_in.m_source;
who_p = _ENDPOINT_P(who_e);
call_nr = m_in.m_type;
fp = &fproc[who_p]; /* pointer to proc table struct */
super_user = (fp->fp_effuid == SU_UID ? TRUE : FALSE); /* su? */
return do_mount();
}
}
static bool do_format(const char *mountpoint)
{
if (!get_paths(mountpoint, nullptr, nullptr)) {
LOGE(TAG "%s: Invalid mountpoint", mountpoint);
return false;
}
bool needs_mount = !util::is_mounted(mountpoint);
if (needs_mount && !do_mount(mountpoint)) {
LOGE(TAG "%s: Failed to mount path", mountpoint);
return false;
}
std::vector<std::string> exclusions;
if (strcmp(mountpoint, DATA) == 0) {
exclusions.push_back("media");
}
if (!wipe_directory(mountpoint, exclusions)) {
LOGE(TAG "%s: Failed to wipe directory", mountpoint);
return false;
}
if (needs_mount && !do_unmount(mountpoint)) {
LOGE(TAG "%s: Failed to unmount path", mountpoint);
return false;
}
LOGD(TAG "Successfully formatted %s", mountpoint);
return true;
}
int main(int argc, char *argv[])
{
char *type = NULL;
int c;
progname = argv[0];
rwflag = MS_VERBOSE;
do {
c = getopt(argc, argv, "fhino:rt:w");
if (c == EOF)
break;
switch (c) {
case 'f':
/* we can't edit /etc/mtab yet anyway; exit */
exit(0);
case 'i':
/* ignore for now; no support for mount helpers */
break;
case 'h':
usage();
case 'n':
/* no mtab writing */
break;
case 'o':
rwflag = parse_mount_options(optarg, rwflag, &extra);
break;
case 'r':
rwflag |= MS_RDONLY;
break;
case 't':
type = optarg;
break;
case 'w':
rwflag &= ~MS_RDONLY;
break;
case '?':
fprintf(stderr, "%s: invalid option -%c\n",
progname, optopt);
exit(1);
}
} while (1);
if (optind == argc)
print_mount(type);
/*
* If remount, bind or move was specified, then we don't
* have a "type" as such. Use the dummy "none" type.
*/
if (rwflag & MS_TYPE)
type = "none";
if (optind + 2 != argc || type == NULL)
usage();
return do_mount(argv[optind], argv[optind + 1], type, rwflag,
extra.str);
}
asmlinkage int sunos_nfs_mount(char *dir_name, int linux_flags, void *data)
{
int ret = -ENODEV, error;
int server_fd;
char *the_name;
struct nfs_mount_data linux_nfs_mount;
struct sunos_nfs_mount_args *sunos_mount = data;
dev_t dev;
error = verify_area(VERIFY_READ, data, sizeof (struct sunos_nfs_mount_args));
if (error)
return error;
/* Ok, here comes the fun part: Linux's nfs mount needs a
* socket connection to the server, but SunOS mount does not
* require this, so we use the information on the destination
* address to create a socket and bind it to a reserved
* port on this system
*/
server_fd = sys_socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (server_fd < 0)
return -ENXIO;
if (!sunos_nfs_get_server_fd (server_fd, sunos_mount->addr)){
sys_close (server_fd);
return -ENXIO;
}
/* Now, bind it to a locally reserved port */
linux_nfs_mount.version = NFS_MOUNT_VERSION;
linux_nfs_mount.flags = sunos_mount->flags;
linux_nfs_mount.addr = *sunos_mount->addr;
linux_nfs_mount.root = *sunos_mount->fh;
linux_nfs_mount.fd = server_fd;
linux_nfs_mount.rsize = get_default (sunos_mount->rsize, 8192);
linux_nfs_mount.wsize = get_default (sunos_mount->wsize, 8192);
linux_nfs_mount.timeo = get_default (sunos_mount->timeo, 10);
linux_nfs_mount.retrans = sunos_mount->retrans;
linux_nfs_mount.acregmin = sunos_mount->acregmin;
linux_nfs_mount.acregmax = sunos_mount->acregmax;
linux_nfs_mount.acdirmin = sunos_mount->acdirmin;
linux_nfs_mount.acdirmax = sunos_mount->acdirmax;
if (getname (sunos_mount->hostname, &the_name))
return -EFAULT;
strncpy (linux_nfs_mount.hostname, the_name, 254);
linux_nfs_mount.hostname [255] = 0;
putname (the_name);
dev = get_unnamed_dev ();
ret = do_mount (dev, "", dir_name, "nfs", linux_flags, &linux_nfs_mount);
if (ret)
put_unnamed_dev(dev);
return ret;
}
static uint32_t sys_mount(uint32_t arg[])
{
const char *source = (const char *)arg[0];
const char *target = (const char *)arg[1];
const char *filesystemtype = (const char *)arg[2];
const void *data = (const void *)arg[3];
return do_mount(source, filesystemtype);
}
/* XXXXXXXXXXXXXXXXXXXX */
static int sunos_nfs_mount(char *dir_name, int linux_flags, void *data)
{
int server_fd;
char *the_name;
struct nfs_mount_data linux_nfs_mount;
struct sunos_nfs_mount_args sunos_mount;
/* Ok, here comes the fun part: Linux's nfs mount needs a
* socket connection to the server, but SunOS mount does not
* require this, so we use the information on the destination
* address to create a socket and bind it to a reserved
* port on this system
*/
if (copy_from_user(&sunos_mount, data, sizeof(sunos_mount)))
return -EFAULT;
server_fd = sys_socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (server_fd < 0)
return -ENXIO;
if (copy_from_user(&linux_nfs_mount.addr,sunos_mount.addr,
sizeof(*sunos_mount.addr)) ||
copy_from_user(&linux_nfs_mount.root,sunos_mount.fh,
sizeof(*sunos_mount.fh))) {
sys_close (server_fd);
return -EFAULT;
}
if (!sunos_nfs_get_server_fd (server_fd, &linux_nfs_mount.addr)){
sys_close (server_fd);
return -ENXIO;
}
/* Now, bind it to a locally reserved port */
linux_nfs_mount.version = NFS_MOUNT_VERSION;
linux_nfs_mount.flags = sunos_mount.flags;
linux_nfs_mount.fd = server_fd;
linux_nfs_mount.rsize = get_default (sunos_mount.rsize, 8192);
linux_nfs_mount.wsize = get_default (sunos_mount.wsize, 8192);
linux_nfs_mount.timeo = get_default (sunos_mount.timeo, 10);
linux_nfs_mount.retrans = sunos_mount.retrans;
linux_nfs_mount.acregmin = sunos_mount.acregmin;
linux_nfs_mount.acregmax = sunos_mount.acregmax;
linux_nfs_mount.acdirmin = sunos_mount.acdirmin;
linux_nfs_mount.acdirmax = sunos_mount.acdirmax;
the_name = getname(sunos_mount.hostname);
if(IS_ERR(the_name))
return PTR_ERR(the_name);
strlcpy(linux_nfs_mount.hostname, the_name,
sizeof(linux_nfs_mount.hostname));
putname (the_name);
return do_mount ("", dir_name, "nfs", linux_flags, &linux_nfs_mount);
}
int parse_mount(struct autofs_point *ap, const char *name,
int name_len, const char *mapent, void *context)
{
char source[HESIOD_LEN + 1];
char fstype[HESIOD_LEN + 1];
char options[HESIOD_LEN + 1];
char *q;
const char *p;
int ret;
ap->entry->current = NULL;
master_source_current_signal(ap->entry);
p = mapent;
q = fstype;
/* Skip any initial whitespace... */
while (isspace(*p))
p++;
/* Isolate the filesystem type... */
while (!isspace(*p)) {
*q++ = tolower(*p++);
}
*q = 0;
/* If it's an error message... */
if (!strcasecmp(fstype, "err")) {
error(ap->logopt, MODPREFIX "%s", mapent);
return 1;
/* If it's an AFS fs... */
} else if (!strcasecmp(fstype, "afs"))
ret = parse_afs(ap, mapent, name, name_len,
source, sizeof(source), options,
sizeof(options));
/* If it's NFS... */
else if (!strcasecmp(fstype, "nfs"))
ret = parse_nfs(ap, mapent, name, name_len,
source, sizeof(source), options,
sizeof(options));
/* Punt. */
else
ret = parse_generic(ap, mapent, name, name_len,
source, sizeof(source), options,
sizeof(options));
if (ret) {
error(ap->logopt, MODPREFIX "failed to parse entry");
return 1;
} else {
debug(ap->logopt,
MODPREFIX "mount %s is type %s from %s",
name, fstype, source);
}
return do_mount(ap, ap->path, name, name_len, source, fstype, options);
}
/*
* Unmount the device
*
* If timeout, wait until the unmount command returns 0.
* If !timeout, try to unmount the device only once.
*/
bool win32_file_device::unmount_backend(DCR *dcr, int timeout)
{
bool retval = true;
if (requires_mount() && device->unmount_command) {
retval = do_mount(dcr, false, timeout);
}
return retval;
}
/*
* Mount the device.
*
* If timeout, wait until the mount command returns 0.
* If !timeout, try to mount the device only once.
*/
bool unix_fifo_device::mount_backend(DCR *dcr, int timeout)
{
bool retval = true;
if (requires_mount() && device->mount_command) {
retval = do_mount(dcr, true, timeout);
}
return retval;
}
/**
* mnt_context_do_mount
* @cxt: context
*
* Call mount(2) or mount.type helper. Unnecessary for mnt_context_mount().
*
* Note that this function could be called only once. If you want to mount
* another source or target than you have to call mnt_reset_context().
*
* If you want to call mount(2) for the same source and target with a diffrent
* mount flags or fstype then call mnt_context_reset_status() and then try
* again mnt_context_do_mount().
*
* WARNING: non-zero return code does not mean that mount(2) syscall or
* mount.type helper wasn't successfully called.
*
* Check mnt_context_get_status() after error!
*
* Returns: 0 on success;
* >0 in case of mount(2) error (returns syscall errno),
* <0 in case of other errors.
*/
int mnt_context_do_mount(struct libmnt_context *cxt)
{
const char *type;
int res;
assert(cxt);
assert(cxt->fs);
assert(cxt->helper_exec_status == 1);
assert(cxt->syscall_status == 1);
assert((cxt->flags & MNT_FL_MOUNTFLAGS_MERGED));
assert((cxt->flags & MNT_FL_PREPARED));
assert((cxt->action == MNT_ACT_MOUNT));
DBG(CXT, mnt_debug_h(cxt, "mount: do mount"));
if (!(cxt->flags & MNT_FL_MOUNTDATA))
cxt->mountdata = (char *) mnt_fs_get_fs_options(cxt->fs);
type = mnt_fs_get_fstype(cxt->fs);
if (type)
res = do_mount(cxt, NULL);
else
res = do_mount_by_pattern(cxt, cxt->fstype_pattern);
if (mnt_context_get_status(cxt)
&& !mnt_context_is_fake(cxt)
&& !cxt->helper) {
/*
* Mounted by mount(2), do some post-mount checks
*
* Kernel allows to use MS_RDONLY for bind mounts, but the
* read-only request could be silently ignored. Check it to
* avoid 'ro' in mtab and 'rw' in /proc/mounts.
*/
if ((cxt->mountflags & MS_BIND)
&& (cxt->mountflags & MS_RDONLY)
&& !mnt_is_readonly(mnt_context_get_target(cxt)))
mnt_context_set_mflags(cxt,
cxt->mountflags & ~MS_RDONLY);
/* Kernel can silently add MS_RDONLY flag when mounting file
* system that does not have write support. Check this to avoid
* 'ro' in /proc/mounts and 'rw' in mtab.
*/
if (!(cxt->mountflags & (MS_RDONLY | MS_PROPAGATION | MS_MOVE))
&& mnt_is_readonly(mnt_context_get_target(cxt)))
mnt_context_set_mflags(cxt,
cxt->mountflags | MS_RDONLY);
}
return res;
}
int
main(int argc, char** argv)
{
if(argc != 2) {
fprintf(stderr, "dmg-mount <file>\n");
exit(EXIT_FAILURE);
}
setuid(0);
if(strcmp(argv[1], "-u") == 0) {
chmod("/mnt/dmg", 0755);
do_umount();
} else {
if(do_mount(argv[1]) == 0)
chmod("/mnt/dmg", 0777);
}
exit(EXIT_SUCCESS);
}
COMPAT_SYSCALL_DEFINE5(mount, const char __user *, dev_name,
const char __user *, dir_name,
const char __user *, type, compat_ulong_t, flags,
const void __user *, data)
{
char *kernel_type;
void *options;
char *kernel_dev;
int retval;
kernel_type = copy_mount_string(type);
retval = PTR_ERR(kernel_type);
if (IS_ERR(kernel_type))
goto out;
kernel_dev = copy_mount_string(dev_name);
retval = PTR_ERR(kernel_dev);
if (IS_ERR(kernel_dev))
goto out1;
options = copy_mount_options(data);
retval = PTR_ERR(options);
if (IS_ERR(options))
goto out2;
if (kernel_type && options) {
if (!strcmp(kernel_type, NCPFS_NAME)) {
do_ncp_super_data_conv(options);
} else if (!strcmp(kernel_type, NFS4_NAME)) {
retval = -EINVAL;
if (do_nfs4_super_data_conv(options))
goto out3;
}
}
retval = do_mount(kernel_dev, dir_name, kernel_type, flags, options);
out3:
kfree(options);
out2:
kfree(kernel_dev);
out1:
kfree(kernel_type);
out:
return retval;
}
static int osf_procfs_mount(char * dirname, struct procfs_args * args, int flags)
{
kdev_t dev;
int retval;
struct procfs_args tmp;
retval = verify_area(VERIFY_READ, args, sizeof(*args));
if (retval)
return retval;
memcpy_fromfs(&tmp, args, sizeof(tmp));
dev = get_unnamed_dev();
if (!dev)
return -ENODEV;
retval = do_mount(dev, "", dirname, "proc", flags, NULL);
if (retval)
put_unnamed_dev(dev);
return retval;
}
static int mount_fuse(const char *mnt, int flags)
{
int res;
int fd;
const char *dev = FUSE_DEV;
const char *type = "fuse";
struct stat stbuf;
res = check_perm(mnt, &stbuf);
if(res == -1)
return -1;
fd = open(dev, O_RDWR);
if(fd == -1) {
int status;
pid_t pid = fork();
if(pid == 0) {
setuid(0);
execl("/sbin/modprobe", "/sbin/modprobe", "fuse", NULL);
exit(1);
}
if(pid != -1)
waitpid(pid, &status, 0);
fd = open(dev, O_RDWR);
}
if(fd == -1) {
fprintf(stderr, "%s: unable to open fuse device %s: %s\n", progname,
dev, strerror(errno));
return -1;
}
res = do_mount(dev, mnt, type, stbuf.st_mode & S_IFMT, fd, flags);
if(res == -1)
return -1;
res = add_mount(dev, mnt, type);
if(res == -1) {
umount(mnt);
return -1;
}
return fd;
}
/*
* The zgetdump main function
*/
int main(int argc, char *argv[])
{
sig_handler_init();
opts_parse(argc, argv);
switch (g.opts.action) {
case ZG_ACTION_STDOUT:
return do_stdout();
case ZG_ACTION_DUMP_INFO:
return do_dump_info();
case ZG_ACTION_DEVICE_INFO:
return do_device_info();
case ZG_ACTION_MOUNT:
return do_mount();
case ZG_ACTION_UMOUNT:
return do_umount();
}
ABORT("Invalid action: %i", g.opts.action);
}
static long unpacked_mount(const char *dev_name, const char *dir_name,
const char *type, unsigned long flags, const void *data)
{
struct file_system_type *fstype;
struct inode *inode;
struct file_operations *fops;
dev_t dev;
int error;
if (flags & MS_REMOUNT) {
return do_remount(dir_name, flags, data);
}
flags &= MS_MOUNT_MASK;
if (!type || !(fstype = get_fs_type(type)))
return -ENODEV;
if (fstype->requires_dev) {
if (!dev_name)
return -ENOTBLK;
error = namei(dev_name, &inode);
if (error)
return error;
if (!S_ISBLK(inode->i_mode))
return -ENOTBLK;
dev = inode->i_rdev;
} else {
if (!(dev = get_unnamed_dev()))
return -EMFILE;
inode = NULL;
}
fops = get_blkfops(major(dev));
if (fops && fops->open) {
if ((error = fops->open(inode, NULL))) {
iput(inode);
return error;
}
}
error = do_mount(dev, dir_name, type, flags, NULL);
if (error && fops && fops->release)
fops->release(inode, NULL);
iput(inode);
return error;
}
static int osf_cdfs_mount(char * dirname, struct cdfs_args * args, int flags)
{
int retval;
struct inode * inode;
struct cdfs_args tmp;
retval = verify_area(VERIFY_READ, args, sizeof(*args));
if (retval)
return retval;
memcpy_fromfs(&tmp, args, sizeof(tmp));
retval = getdev(tmp.devname, 1, &inode);
if (retval)
return retval;
retval = do_mount(inode->i_rdev, tmp.devname, dirname, "iso9660", flags, NULL);
if (retval)
putdev(inode);
iput(inode);
return retval;
}
void main(struct multiboot *mboot) {
int rc;
/* init the kmsg buffer and printk */
console_sys_init();
kmsg_init();
console_register(&kmsg_con);
/* arch might want to setup stuff */
arch_early_init();
printk("kmsg: buffer setup!\n");
printk("sys: kernel relocation: 0x%x -> 0x%x size 0x%x\n",
&kernel_base, &kernel_end,
(uintptr_t)&kernel_end - (uintptr_t)&kernel_base);
parse_multiboot(mboot);
paging_fini();
heap_install();
/* arch should finish init now */
arch_late_init();
printk("sys: init done!\n");
drivers_init();
do_mount();
do_test();
syscall_init();
/* wait forever */
asm volatile("mov $0x1337, %eax");
asm volatile("mov $0x1337, %ebx");
asm volatile("mov $0x1337, %ecx");
asm volatile("mov $0x1337, %edx");
start_sched();
panic("finished with main, but no idle task was started\n");
}
static int sys_mount(mount_args_t *arg)
{
mount_args_t kern_args;
char *source;
char *target;
char *type;
int ret;
if (copy_from_user(&kern_args, arg, sizeof(kern_args)) < 0) {
curthr->kt_errno = EFAULT;
return -1;
}
/* null is okay only for the source */
source = user_strdup(&kern_args.spec);
if (NULL == (target = user_strdup(&kern_args.dir))) {
kfree(source);
curthr->kt_errno = EINVAL;
return -1;
}
if (NULL == (type = user_strdup(&kern_args.fstype))) {
kfree(source);
kfree(target);
curthr->kt_errno = EINVAL;
return -1;
}
ret = do_mount(source, target, type);
kfree(source);
kfree(target);
kfree(type);
if (ret) {
curthr->kt_errno = -ret;
return -1;
}
return 0;
}
/**
* Starts sleuthmount.
*
* \param argc The number of arguments
* \param argv The argument array
* \returns 0 on success, -1 on error
*/
int main(int argc, char *argv[])
{
SHORT_PROCESS_NAME = basename_safe(argv[0]);
PROCESS_NAME = argv[0];
if (argc != 2)
{
print_usage(argv[0]);
return -1;
}
// Adding some sample files into our filesystem
add_file(10, "ten", 10);
add_file(100, "hundred", 100);
add_file(1000, "something_else", 60);
int ret = do_mount(argv[argc - 1]);
// There may not be a purpose to doing this
cleanup();
return ret;
}
int update_binary_tool_main(int argc, char *argv[])
{
int opt;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
int long_index = 0;
while ((opt = getopt_long(argc, argv, "h", long_options, &long_index)) != -1) {
switch (opt) {
case 'h':
update_binary_tool_usage(0);
return EXIT_SUCCESS;
default:
update_binary_tool_usage(1);
return EXIT_FAILURE;
}
}
if (argc - optind != 2) {
update_binary_tool_usage(1);
return EXIT_FAILURE;
}
// Log to stderr, so the output is ordered correctly in /tmp/recovery.log
util::log_set_logger(std::make_shared<util::StdioLogger>(stderr));
std::string action = argv[optind];
std::string mountpoint = argv[optind + 1];
if (action != ACTION_MOUNT
&& action != ACTION_UNMOUNT
&& action != ACTION_FORMAT) {
update_binary_tool_usage(1);
return EXIT_FAILURE;
}
if (mountpoint != SYSTEM
&& mountpoint != CACHE
&& mountpoint != DATA) {
update_binary_tool_usage(1);
return EXIT_FAILURE;
}
if (access("/.chroot", F_OK) < 0) {
fprintf(stderr, "update-binary-tool must be run inside the chroot\n");
return EXIT_FAILURE;
}
bool ret = false;
if (action == ACTION_MOUNT) {
ret = do_mount(mountpoint);
} else if (action == ACTION_UNMOUNT) {
ret = do_unmount(mountpoint);
} else if (action == ACTION_FORMAT) {
ret = do_format(mountpoint);
}
return ret ? EXIT_SUCCESS : EXIT_FAILURE;
}
/*
* Mount the given filesystem.
*/
int
zfs_mount(zfs_handle_t *zhp, const char *options, int flags)
{
struct stat buf;
char mountpoint[ZFS_MAXPROPLEN];
char mntopts[MNT_LINE_MAX];
libzfs_handle_t *hdl = zhp->zfs_hdl;
int remount = 0, rc;
if (options == NULL) {
(void) strlcpy(mntopts, MNTOPT_DEFAULTS, sizeof (mntopts));
} else {
(void) strlcpy(mntopts, options, sizeof (mntopts));
}
if (strstr(mntopts, MNTOPT_REMOUNT) != NULL)
remount = 1;
/*
* If the pool is imported read-only then all mounts must be read-only
*/
if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))
(void) strlcat(mntopts, "," MNTOPT_RO, sizeof (mntopts));
/*
* Load encryption key if required and not already present.
* Don't need to check ZFS_PROP_ENCRYPTION because encrypted
* datasets have keystatus of ZFS_CRYPT_KEY_NONE.
*/
fprintf(stderr, "zfs_mount: mount, keystatus is %d\r\n",
zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS));
if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
ZFS_CRYPT_KEY_UNAVAILABLE) {
fprintf(stderr, "loading KEY\r\n");
(void )zfs_key_load(zhp, B_FALSE, B_FALSE, B_FALSE);
}
/*
* Append default mount options which apply to the mount point.
* This is done because under Linux (unlike Solaris) multiple mount
* points may reference a single super block. This means that just
* given a super block there is no back reference to update the per
* mount point options.
*/
rc = zfs_add_options(zhp, mntopts, sizeof (mntopts));
if (rc) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"default options unavailable"));
return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
mountpoint));
}
/*
* Append zfsutil option so the mount helper allow the mount
*/
strlcat(mntopts, "," MNTOPT_ZFSUTIL, sizeof (mntopts));
if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
return (0);
/* Create the directory if it doesn't already exist */
if (lstat(mountpoint, &buf) != 0) {
if (mkdirp(mountpoint, 0755) != 0) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"failed to create mountpoint"));
return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
mountpoint));
}
}
/*
* Determine if the mountpoint is empty. If so, refuse to perform the
* mount. We don't perform this check if 'remount' is
* specified or if overlay option(-O) is given
*/
if ((flags & MS_OVERLAY) == 0 && !remount &&
!dir_is_empty(mountpoint)) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"directory is not empty"));
return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));
}
/* perform the mount */
rc = do_mount(zfs_get_name(zhp), mountpoint, mntopts);
if (rc) {
/*
* Generic errors are nasty, but there are just way too many
* from mount(), and they're well-understood. We pick a few
* common ones to improve upon.
*/
if (rc == EBUSY) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"mountpoint or dataset is busy"));
} else if (rc == EPERM) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"Insufficient privileges"));
} else if (rc == ENOTSUP) {
char buf[256];
int spa_version;
VERIFY(zfs_spa_version(zhp, &spa_version) == 0);
(void) snprintf(buf, sizeof (buf),
dgettext(TEXT_DOMAIN, "Can't mount a version %lld "
"file system on a version %d pool. Pool must be"
" upgraded to mount this file system."),
(u_longlong_t)zfs_prop_get_int(zhp,
ZFS_PROP_VERSION), spa_version);
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, buf));
} else {
zfs_error_aux(hdl, strerror(rc));
}
return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
zhp->zfs_name));
}
/* remove the mounted entry before re-adding on remount */
if (remount)
libzfs_mnttab_remove(hdl, zhp->zfs_name);
/* add the mounted entry into our cache */
libzfs_mnttab_add(hdl, zfs_get_name(zhp), mountpoint, mntopts);
return (0);
}
static int mount_fuse(const char *mnt, const char *opts, char *devfd)
{
int res;
int fd;
char *dev;
struct stat stbuf;
char *type = NULL;
char *source = NULL;
char *mnt_opts = NULL;
const char *real_mnt = mnt;
int mountpoint_fd = -1;
fd = devfd ? check_fuse_device(devfd, &dev) : open_fuse_device(&dev);
if (fd == -1)
return -1;
drop_privs();
read_conf();
if (getuid() != 0 && mount_max != -1) {
int mount_count = count_fuse_fs();
if (mount_count >= mount_max) {
fprintf(stderr, "%s: too many FUSE filesystems mounted; mount_max=N can be set in /etc/fuse.conf\n", progname);
goto fail_close_fd;
}
}
res = check_version(dev);
if (res != -1) {
res = check_perm(&real_mnt, &stbuf, &mountpoint_fd);
restore_privs();
if (res != -1)
res = do_mount(real_mnt, &type, stbuf.st_mode & S_IFMT,
fd, opts, dev, &source, &mnt_opts,
stbuf.st_size);
} else
restore_privs();
if (mountpoint_fd != -1)
close(mountpoint_fd);
if (res == -1)
goto fail_close_fd;
res = chdir("/");
if (res == -1) {
fprintf(stderr, "%s: failed to chdir to '/'\n", progname);
goto fail_close_fd;
}
if (geteuid() == 0) {
res = add_mount(source, mnt, type, mnt_opts);
if (res == -1) {
/* Can't clean up mount in a non-racy way */
goto fail_close_fd;
}
}
out_free:
free(source);
free(type);
free(mnt_opts);
free(dev);
return fd;
fail_close_fd:
close(fd);
fd = -1;
goto out_free;
}