tools/fs_shell/vfs.cpp

78 	fssh_mount_id	device;
95 	fssh_mount_id	device;
164  *	to the immutable fields (device, id, private_node, mount) to which
428 /** Finds the mounted device (the fs_mount structure) with the given ID.
544 	if (vnode->device == key->device && vnode->id == key->vnode)
560 		return VHASH(vnode->device, vnode->id) % range;
562 	return VHASH(key->device, key->vnode) % range;
602 	vnode->device = mountID;
750 	key.device = mountID;
957 	*resolvedMountID = node->device;
1071 	*_vnode = lookup_vnode(dir->device, id);
1076 			"vnid %" FSSH_B_PRIdINO ")\n", (int)dir->device, id);
1749 		// now directly read the data from the device
1761 		// TODO: this is a work-around for buggy device drivers!
1767 			//dprintf("warning: device driver %p doesn't respect total length in read_pages() call!\n", ref->device);
2318  *	open cookie and not with a device cookie.
2422 	*_mountID = vnode->device;
2483 	if (vnode->device != volume->id) {
2685 		*_mountID = context->cwd->device;
2716 		stat->fssh_st_dev = vnode->device;
2732 vfs_entry_ref_to_path(fssh_dev_t device, fssh_ino_t inode, const char *leaf,
2746 		status = entry_ref_to_vnode(device, inode, leaf, &vnode);
2749 		status = get_vnode(device, inode, &vnode, false);
2974 	vnode = lookup_vnode(directory->device, newID);
3398 	entry->d_pdev = parent->device;
3415 			entry->d_dev = vnode->device;
3427 			entry->d_dev = vnode->covered_by->device;
3847 	if (fromVnode->device != toVnode->device) {
3882 		stat->fssh_st_dev = vnode->device;
3921 		stat->fssh_st_dev = vnode->device;
4279 	if (fromVnode->device != toVnode->device) {
4462 query_open(fssh_dev_t device, const char *query, uint32_t flags,
4468 	FUNCTION(("query_open(device = %ld, query = \"%s\", kernel = %d)\n", device, query, kernel));
4470 	fssh_status_t status = get_mount(device, &mount);
4555 fs_mount(char *path, const char *device, const char *fsName, uint32_t flags,
4565 	// A NULL fsName is OK, if a device was given and the FS is not virtual.
4568 		if (!device || flags & FSSH_B_MOUNT_VIRTUAL_DEVICE)
4575 	// If the file system is not a "virtual" one, the device argument should
4576 	// point to a real file/device (if given at all).
4580 	if (!(flags & FSSH_B_MOUNT_VIRTUAL_DEVICE) && device) {
4581 		// normalize the device path
4582 //		status = normalizedDevice.SetTo(device, true);
4584 		status = normalizedDevice.SetTo(device, false);
4588 		device = normalizedDevice.Path();
4589 			// correct path to file device
4610 	mount->device_name = fssh_strdup(device);
4611 		// "device" can be NULL
4650 		status = mount->fs->mount(mount->volume, device, flags, args, &rootID);
4682 		status = mount->fs->mount(mount->volume, device, flags, args, &rootID);
4748 	mount = find_mount(vnode->device);
4869 fs_sync(fssh_dev_t device)
4872 	fssh_status_t status = get_mount(device, &mount);
4928 fs_read_info(fssh_dev_t device, struct fssh_fs_info *info)
4931 	fssh_status_t status = get_mount(device, &mount);
4960 fs_write_info(fssh_dev_t device, const struct fssh_fs_info *info, int mask)
4963 	fssh_status_t status = get_mount(device, &mount);
4981 	fssh_dev_t device = *_cookie;
4985 	// Since device IDs are assigned sequentially, this algorithm
4986 	// does work good enough. It makes sure that the device list
4987 	// returned is sorted, and that no device is skipped when an
4988 	// already visited device got unmounted.
4990 	while (device < sNextMountID) {
4991 		mount = find_mount(device++);
4996 	*_cookie = device;
4999 		device = mount->id;
5001 		device = FSSH_B_BAD_VALUE;
5005 	return device;
5082 _kern_mount(const char *path, const char *device, const char *fsName,
5089 	return fs_mount(pathBuffer.LockBuffer(), device, fsName, flags, args, true);
5105 _kern_read_fs_info(fssh_dev_t device, struct fssh_fs_info *info)
5110 	return fs_read_info(device, info);
5115 _kern_write_fs_info(fssh_dev_t device, const struct fssh_fs_info *info, int mask)
5120 	return fs_write_info(device, info, mask);
5129 	fssh_dev_t device;
5130 	while ((device = fs_next_device(&cookie)) >= 0) {
5131 		fssh_status_t status = fs_sync(device);
5133 			fssh_dprintf("sync: device %d couldn't sync: %s\n", (int)device, fssh_strerror(status));
5148 _kern_open_entry_ref(fssh_dev_t device, fssh_ino_t inode, const char *name, int openMode, int perms)
5151 		return file_create_entry_ref(device, inode, name, openMode, perms, true);
5153 	return file_open_entry_ref(device, inode, name, openMode, true);
5190  *	by \a device and \a inode will be opened. Otherwise \a device and
5194  *	\param device If \a name is specified the ID of the device the parent
5196  *		   the device of the directory itself.
5201  *		   the \a device + \a inode pair identify the node to be opened.
5207 _kern_open_dir_entry_ref(fssh_dev_t device, fssh_ino_t inode, const char *name)
5209 	return dir_open_entry_ref(device, inode, name, true);
5267 _kern_create_dir_entry_ref(fssh_dev_t device, fssh_ino_t inode, const char *name, int perms)
5269 	return dir_create_entry_ref(device, inode, name, perms, true);
5641 _kern_open_index_dir(fssh_dev_t device)
5643 	return index_dir_open(device, true);
5648 _kern_create_index(fssh_dev_t device, const char *name, uint32_t type, uint32_t flags)
5650 	return index_create(device, name, type, flags, true);
5655 _kern_read_index_stat(fssh_dev_t device, const char *name, fssh_struct_stat *stat)
5657 	return index_name_read_stat(device, name, stat, true);
5662 _kern_remove_index(fssh_dev_t device, const char *name)
5664 	return index_remove(device, name, true);
5699 	// The partition argument should point to a real file/device.
5732 _kern_entry_ref_to_path(fssh_dev_t device, fssh_ino_t inode, const char *leaf,
5735 	return vfs_entry_ref_to_path(device, inode, leaf, true, path, pathLength);
5740 _kern_open_query(fssh_dev_t device, const char *query, fssh_size_t queryLength,
5743 	return query_open(device, query, flags, port, token, false);