#include <lunaix/foptions.h>
-#include <lunaix/fs.h>
+#include <lunaix/fs/api.h>
#include <lunaix/mm/valloc.h>
#include <lunaix/process.h>
#include <lunaix/spike.h>
+#include <lunaix/syscall_utils.h>
#include <lunaix/syslog.h>
#include <lunaix/types.h>
struct llist_header all_mnts = { .next = &all_mnts, .prev = &all_mnts };
-struct v_mount*
-vfs_create_mount(struct v_mount* parent, struct v_dnode* mnt_point)
+static void
+__vfs_attach_vmnt(struct v_dnode* mnt_point, struct v_mount* vmnt)
+{
+ vmnt->mnt_point = mnt_point;
+ vfs_d_assign_vmnt(mnt_point, vmnt);
+ vfs_ref_dnode(mnt_point);
+}
+
+static struct v_mount*
+__vfs_create_mount(struct v_mount* parent, struct v_superblock* mnt_sb)
{
struct v_mount* mnt = vzalloc(sizeof(struct v_mount));
if (!mnt) {
}
llist_init_head(&mnt->submnts);
+ llist_init_head(&mnt->sibmnts);
llist_append(&all_mnts, &mnt->list);
mutex_init(&mnt->lock);
mnt->parent = parent;
- mnt->mnt_point = mnt_point;
- mnt->super_block = mnt_point->super_block;
+ vfs_vmnt_assign_sb(mnt, mnt_sb);
if (parent) {
mnt_mkbusy(parent);
mutex_unlock(&mnt->parent->lock);
}
- atomic_fetch_add(&mnt_point->ref_count, 1);
-
return mnt;
}
-int
+static void
+__vfs_detach_vmnt(struct v_mount* mnt)
+{
+ assert(llist_empty(&mnt->submnts));
+
+ vfs_unref_dnode(mnt->mnt_point);
+ assert(!mnt->busy_counter);
+
+ if (mnt->parent) {
+ mnt_chillax(mnt->parent);
+ }
+
+ mnt->mnt_point->mnt = NULL;
+
+ llist_delete(&mnt->sibmnts);
+ llist_delete(&mnt->list);
+ vfree(mnt);
+}
+
+static inline void
+__detach_node_cache_ref(struct hbucket* bucket)
+{
+ if (!bucket->head) {
+ return;
+ }
+
+ bucket->head->pprev = 0;
+}
+
+static int
__vfs_do_unmount(struct v_mount* mnt)
{
int errno = 0;
return errno;
}
- llist_delete(&mnt->list);
- llist_delete(&mnt->sibmnts);
-
// detached the inodes from cache, and let lru policy to recycle them
for (size_t i = 0; i < VFS_HASHTABLE_SIZE; i++) {
- struct hbucket* bucket = &sb->i_cache[i];
- if (!bucket) {
- continue;
- }
- bucket->head->pprev = 0;
+ __detach_node_cache_ref(&sb->i_cache.pool[i]);
+ __detach_node_cache_ref(&sb->d_cache.pool[i]);
}
- mnt_chillax(mnt->parent);
+ struct v_dnode *pos, *next;
+ llist_for_each(pos, next, &mnt->mnt_point->children, siblings)
+ {
+ vfs_d_free(pos);
+ }
- vfs_sb_free(sb);
- vfs_d_free(mnt->mnt_point);
- vfree(mnt);
+ __vfs_detach_vmnt(mnt);
+ vfs_d_assign_vmnt(mnt->mnt_point, mnt->parent);
return errno;
}
return errno;
}
-int
-vfs_mount_at(const char* fs_name,
- struct device* device,
- struct v_dnode* mnt_point,
- int options)
+static int
+vfs_mount_fsat(struct filesystem* fs,
+ struct device* device,
+ struct v_dnode* mnt_point,
+ int options)
{
+
if (device && device->dev_type != DEV_IFVOL) {
return ENOTBLK;
}
- if (mnt_point->inode && !(mnt_point->inode->itype & VFS_IFDIR)) {
+ if (mnt_point->inode && !check_directory_node(mnt_point->inode)) {
return ENOTDIR;
}
- struct filesystem* fs = fsm_get(fs_name);
- if (!fs) {
- return ENODEV;
- }
-
- if (fs->types == FSTYPE_ROFS) {
+ if ((fs->types & FSTYPE_ROFS)) {
options |= MNT_RO;
}
- char* dev_name = "sys";
- struct v_mount* parent_mnt = mnt_point->mnt;
- struct v_superblock *sb = vfs_sb_alloc(), *old_sb = mnt_point->super_block;
- sb->dev = device;
- mnt_point->super_block = sb;
-
- if (device) {
- dev_name = device->name_val;
+ if (!(fs->types & FSTYPE_PSEUDO) && !device) {
+ return ENODEV;
}
int errno = 0;
- if (!(errno = fs->mount(sb, mnt_point))) {
- sb->fs = fs;
- sb->root = mnt_point;
+ char* dev_name;
+ char* fsname;
+ struct v_mount *parent_mnt, *vmnt;
+ struct v_superblock *sb;
- if (!(mnt_point->mnt = vfs_create_mount(parent_mnt, mnt_point))) {
- errno = ENOMEM;
- goto cleanup;
- }
+ fsname = HSTR_VAL(fs->fs_name);
+ parent_mnt = mnt_point->mnt;
+ sb = vfs_sb_alloc();
- kprintf("mount: dev=%s, fs=%s, mode=%d\n", dev_name, fs_name, options);
+ dev_name = device ? device->name_val : "sys";
+
+ // prepare v_superblock for fs::mount invoke
+ sb->dev = device;
+ sb->fs = fs;
+ sb->root = mnt_point;
+
+ vmnt = __vfs_create_mount(parent_mnt, sb);
- mnt_point->mnt->flags = options;
+ if (!vmnt) {
+ errno = ENOMEM;
+ goto cleanup;
+ }
+
+ __vfs_attach_vmnt(mnt_point, vmnt);
+
+ mnt_point->mnt->flags = options;
+ if (!(errno = fs->mount(sb, mnt_point))) {
+ kprintf("mount: dev=%s, fs=%s, mode=%d",
+ dev_name, fsname, options);
} else {
goto cleanup;
}
return errno;
cleanup:
- kprintf(KERROR "mount: dev=%s, fs=%s, mode=%d, err=%d\n",
- dev_name,
- fs_name,
- options,
- errno);
- mnt_point->super_block = old_sb;
- vfs_sb_free(sb);
+ ERROR("failed mount: dev=%s, fs=%s, mode=%d, err=%d",
+ dev_name, fsname, options, errno);
+
+ __vfs_detach_vmnt(mnt_point->mnt);
+ vfs_d_assign_vmnt(mnt_point, parent_mnt);
+
+ mnt_point->mnt = parent_mnt;
+
+ return errno;
+}
+
+int
+vfs_mount_at(const char* fs_name,
+ struct device* device,
+ struct v_dnode* mnt_point,
+ int options)
+{
+ if (fs_name) {
+ struct filesystem* fs = fsm_get(fs_name);
+ if (!fs) {
+ return ENODEV;
+ }
+
+ return vfs_mount_fsat(fs, device, mnt_point, options);
+ }
+
+ int errno = ENODEV;
+ struct fs_iter fsi;
+
+ fsm_itbegin(&fsi);
+ while (fsm_itnext(&fsi))
+ {
+ if ((fsi.fs->types & FSTYPE_PSEUDO)) {
+ continue;
+ }
+
+ INFO("mount attempt: %s", HSTR_VAL(fsi.fs->fs_name));
+ errno = vfs_mount_fsat(fsi.fs, device, mnt_point, options);
+ if (!errno) {
+ break;
+ }
+ }
+
return errno;
}
vfs_unmount_at(struct v_dnode* mnt_point)
{
int errno = 0;
- struct v_superblock* sb = mnt_point->super_block;
+ struct v_superblock* sb;
+
+ sb = mnt_point->super_block;
if (!sb) {
return EINVAL;
}
return EINVAL;
}
- if (mnt_point->mnt->busy_counter) {
+ if (mnt_check_busy(mnt_point->mnt)) {
return EBUSY;
}
- if (!(errno = __vfs_do_unmount(mnt_point->mnt))) {
- atomic_fetch_sub(&mnt_point->ref_count, 1);
- }
-
- return errno;
+ return __vfs_do_unmount(mnt_point->mnt);
}
int
if ((dnode->mnt->flags & MNT_RO)) {
return EROFS;
}
+
+ if (!check_allow_write(dnode->inode)) {
+ return EPERM;
+ }
+
return 0;
}
int,
options)
{
- struct v_dnode *dev, *mnt;
+ struct device* device = NULL;
+ struct v_dnode *dev = NULL, *mnt = NULL;
int errno = 0;
- if ((errno = vfs_walk(__current->cwd, source, &dev, NULL, 0))) {
- goto done;
- }
+ // It is fine if source is not exist, as some mounting don't require it
+ vfs_walk(__current->cwd, source, &dev, NULL, 0);
if ((errno = vfs_walk(__current->cwd, target, &mnt, NULL, 0))) {
goto done;
goto done;
}
- // By our convention.
- // XXX could we do better?
- struct device* device = (struct device*)dev->inode->data;
-
- if (!(dev->inode->itype & VFS_IFVOLDEV) || !device) {
- errno = ENOTDEV;
+ if (mnt->mnt->mnt_point == mnt) {
+ errno = EBUSY;
goto done;
}
+ if (dev) {
+ if (!check_voldev_node(dev->inode)) {
+ errno = ENOTDEV;
+ goto done;
+ }
+
+ device = resolve_device(dev->inode->data);
+ assert(device);
+ }
+
errno = vfs_mount_at(fstype, device, mnt, options);
done:
git://scm.lunaixsky.com / lunaix-os.git / blobdiff