kernel/fs/vfs.cpp

358 	void* buffer, size_t* _bytes);
360 	const void* buffer, size_t* _bytes);
370 	struct file_descriptor* descriptor, struct dirent* buffer,
373 	void* cookie, struct dirent* buffer, size_t bufferSize, uint32* _count);
378 	struct file_descriptor* descriptor, struct dirent* buffer,
384 	void* buffer, size_t* _bytes);
386 	const void* buffer, size_t* _bytes);
396 	struct file_descriptor* descriptor, struct dirent* buffer,
402 	struct file_descriptor* descriptor, struct dirent* buffer,
409 	void* buffer, size_t length);
420 static status_t dir_vnode_to_path(struct vnode* vnode, char* buffer,
1992 	the entry identified by the original path, and into the buffer \a filename
1999 	\param filename The buffer into which the leaf name will be written.
2113 	component. This function clobbers the buffer pointed to by \a path only
2215 			char* buffer;
2223 			buffer = (char*)object_cache_alloc(sPathNameCache, 0);
2224 			if (buffer == NULL)
2229 				status = FS_CALL(nextVnode.Get(), read_symlink, buffer, &bufferSize);
2232 					buffer[bufferSize] = '\0';
2237 				free(buffer);
2245 			path = buffer;
2274 			object_cache_free(sPathNameCache, buffer, 0);
2362 	The path buffer must be able to store at least one additional character.
2389 	\param path The absolute or relative path. Must not be \c NULL. The buffer
2394 	\param filename A buffer of size B_FILE_NAME_LENGTH or larger into which
2435 	\param path The absolute or relative path. Must not be \c NULL. The buffer
2440 	\param filename A buffer of size B_FILE_NAME_LENGTH or larger into which
2468 /*! Returns a vnode's name in the d_name field of a supplied dirent buffer.
2471 get_vnode_name(struct vnode* vnode, struct vnode* parent, struct dirent* buffer,
2487 		if (FS_CALL(vnode, get_vnode_name, buffer->d_name,
2488 			(char*)buffer + bufferSize - buffer->d_name) == B_OK)
2507 			status = FS_CALL(parent, read_dir, cookie, buffer, bufferSize,
2516 			if (vnode->id == buffer->d_ino) {
2533 	char buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH + 1];
2534 	struct dirent* dirent = (struct dirent*)buffer;
2536 	status_t status = get_vnode_name(vnode, parent, dirent, sizeof(buffer),
2564 dir_vnode_to_path(struct vnode* vnode, char* buffer, size_t bufferSize,
2567 	FUNCTION(("dir_vnode_to_path(%p, %p, %lu)\n", vnode, buffer, bufferSize));
2569 	if (vnode == NULL || buffer == NULL || bufferSize == 0)
2575 	char* path = buffer;
2654 	// move the path to the start of the buffer
2656 	memmove(buffer, path + insert, length);
2666 	The given path buffer must be able to store at least one
3035 debug_prepend_vnode_name_to_path(char* buffer, size_t& bufferSize,
3038 	bool insertSlash = buffer[bufferSize] != '\0';
3045 		buffer[--bufferSize] = '/';
3048 	memcpy(buffer + bufferSize, name, nameLength);
3055 debug_prepend_vnode_id_to_path(char* buffer, size_t& bufferSize, dev_t devID,
3061 	bool insertSlash = buffer[bufferSize] != '\0';
3063 		buffer[--bufferSize] = '/';
3065 	size_t size = snprintf(buffer, bufferSize,
3074 		memmove(buffer + bufferSize - size, buffer, size);
3082 debug_resolve_vnode_path(struct vnode* vnode, char* buffer, size_t bufferSize,
3086 	buffer[--bufferSize] = '\0';
3095 				buffer[--bufferSize] = '/';
3096 			return buffer + bufferSize;
3105 			_truncated = !debug_prepend_vnode_id_to_path(buffer, bufferSize,
3107 			return buffer + bufferSize;
3111 		if (!debug_prepend_vnode_name_to_path(buffer, bufferSize, name)) {
3113 			return buffer + bufferSize;
3119 			_truncated = !debug_prepend_vnode_id_to_path(buffer, bufferSize,
3121 			return buffer + bufferSize;
3149 		void* buffer = debug_malloc(B_PATH_NAME_LENGTH);
3150 		if (buffer != NULL) {
3152 			char* path = debug_resolve_vnode_path(vnode, (char*)buffer,
3163 			debug_free(buffer);
4188 	char* buffer = pathBuffer.LockBuffer();
4189 	strlcpy(buffer, path, pathBuffer.BufferSize());
4192 	status_t status = path_to_vnode(buffer, true, vnode, NULL, kernel);
4293 	char* buffer = pathBuffer.LockBuffer();
4294 	strlcpy(buffer, path, pathBuffer.BufferSize());
4298 	if (buffer[0] == '/')
4299 		status = path_to_vnode(buffer, traverseLeafLink, vnode, NULL, kernel);
4303 		status = vnode_path_to_vnode(mount->root_vnode, buffer, traverseLeafLink,
4380 	// the path buffer had been clobbered by the above call
4449 	\param buffer The buffer into which the normalized path will be written.
4451 	\param bufferSize The size of \a buffer.
4459 vfs_normalize_path(const char* path, char* buffer, size_t bufferSize,
4462 	if (!path || !buffer || bufferSize < 1)
4465 	if (path != buffer) {
4466 		if (strlcpy(buffer, path, bufferSize) >= bufferSize)
4470 	return normalize_path(buffer, bufferSize, traverseLink, kernel);
5696 file_read(struct file_descriptor* descriptor, off_t pos, void* buffer,
5700 	FUNCTION(("file_read: buf %p, pos %" B_PRIdOFF ", len %p = %ld\n", buffer,
5708 	return FS_CALL(vnode, read, descriptor->cookie, pos, buffer, length);
5713 file_write(struct file_descriptor* descriptor, off_t pos, const void* buffer,
5717 	FUNCTION(("file_write: buf %p, pos %" B_PRIdOFF ", len %p\n", buffer, pos,
5728 	return FS_CALL(vnode, write, descriptor->cookie, pos, buffer, length);
6015 	struct dirent* buffer, size_t bufferSize, uint32* _count)
6017 	return dir_read(ioContext, descriptor->u.vnode, descriptor->cookie, buffer,
6056 	struct dirent* buffer, size_t bufferSize, uint32* _count)
6061 	status_t error = FS_CALL(vnode, read_dir, cookie, buffer, bufferSize,
6069 		error = fix_dirent(vnode, buffer, ioContext);
6073 		buffer = (struct dirent*)((uint8*)buffer + buffer->d_reclen);
6139 common_ioctl(struct file_descriptor* descriptor, ulong op, void* buffer,
6145 		return FS_CALL(vnode, ioctl, descriptor->cookie, op, buffer, length);
6439 common_read_link(int fd, char* path, char* buffer, size_t* _bufferSize,
6450 		status = FS_CALL(vnode.Get(), read_symlink, buffer, _bufferSize);
6731 	struct dirent* buffer, size_t bufferSize, uint32* _count)
6738 		return FS_CALL(vnode, read_attr_dir, descriptor->cookie, buffer,
6868 attr_read(struct file_descriptor* descriptor, off_t pos, void* buffer,
6873 	FUNCTION(("attr_read: buf %p, pos %" B_PRIdOFF ", len %p = %ld\n", buffer,
6879 	return FS_CALL(vnode, read_attr, descriptor->cookie, pos, buffer, length);
6884 attr_write(struct file_descriptor* descriptor, off_t pos, const void* buffer,
6889 	FUNCTION(("attr_write: buf %p, pos %" B_PRIdOFF ", len %p\n", buffer, pos,
6895 	return FS_CALL(vnode, write_attr, descriptor->cookie, pos, buffer, length);
7098 	struct dirent* buffer, size_t bufferSize, uint32* _count)
7103 		return FS_MOUNT_CALL(mount, read_index_dir, descriptor->cookie, buffer,
7301 	struct dirent* buffer, size_t bufferSize, uint32* _count)
7306 		return FS_MOUNT_CALL(mount, read_query, descriptor->cookie, buffer,
8057 	void *buffer, size_t readBytes)
8063 	ssize_t bytesRead = _kern_read(attrFD, pos, buffer, readBytes);
8072 get_cwd(char* buffer, size_t size, bool kernel)
8078 	FUNCTION(("vfs_get_cwd: buf %p, size %ld\n", buffer, size));
8089 		status = dir_vnode_to_path(vnode, buffer, size, kernel);
8447 	will still be updated to reflect the required buffer size.
8451 	\param buffer The buffer into which the contents of the symlink shall be
8453 	\param _bufferSize A pointer to the size of the supplied buffer.
8457 _kern_read_link(int fd, const char* path, char* buffer, size_t* _bufferSize)
8464 		buffer, _bufferSize, true);
8589 	\param stat The buffer the stat data shall be written into.
8590 	\param statSize The size of the supplied stat buffer.
8634 	\param stat The buffer containing the stat data to be written.
8635 	\param statSize The size of the supplied stat buffer.
8757 _kern_getcwd(char* buffer, size_t size)
8759 	TRACE(("_kern_getcwd: buf %p, %ld\n", buffer, size));
8762 	return get_cwd(buffer, size, true);
9010 _user_normalize_path(const char* userPath, bool traverseLink, char* buffer)
9012 	if (userPath == NULL || buffer == NULL)
9014 	if (!IS_USER_ADDRESS(userPath) || !IS_USER_ADDRESS(buffer))
9033 	int len = user_strlcpy(buffer, path, B_PATH_NAME_LENGTH);
9073 	char* buffer = path.LockBuffer();
9077 	status_t status = user_copy_name(buffer, userPath, B_PATH_NAME_LENGTH);
9082 		return file_create(fd, buffer, openMode, perms, false);
9084 	return file_open(fd, buffer, openMode, false);
9116 	char* buffer = path.LockBuffer();
9120 	status_t status = user_copy_name(buffer, userPath, B_PATH_NAME_LENGTH);
9124 	return dir_open(fd, buffer, false);
9135 	If a name buffer is supplied and the name does not fit the buffer, the
9136 	function fails. A buffer of size \c B_FILE_NAME_LENGTH should be safe.
9141 	\param nameLength Size of the name buffer.
9170 		struct dirent* buffer = (struct dirent*)_buffer;
9171 		status_t status = get_vnode_name(dirVNode, parentVNode, buffer,
9176 		// copy the name to the userland buffer
9177 		int len = user_strlcpy(userName, buffer->d_name, nameLength);
9352 	char* buffer = linkBuffer.LockBuffer();
9366 	status_t status = common_read_link(fd, userPath ? path : NULL, buffer,
9378 	if (user_memcpy(userBuffer, buffer, bufferSize) != B_OK)
9748 	const void* buffer, size_t writeBytes)
9767 	ssize_t bytes = _user_write(attr, pos, buffer, writeBytes);
10021 	// alloc path buffer