Context Navigation

source: mainline/uspace/lib/libfs/libfs.c@ 854c564

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 854c564 was 83937ccd, checked in by Jakub Jermar <jakub@…>, 16 years ago
Rudimentary support for non-root mounts.
Property mode set to `100644`
File size: 11.0 KB

Rev	Line
[74303b6]	1	/*
[83937ccd]	2	* Copyright (c) 2009 Jakub Jermar
[74303b6]	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	*
	9	* - Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* - Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* - The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28
	29	/** @addtogroup libfs
	30	* @{
	31	*/
	32	/**
	33	* @file
	34	* Glue code which is commonod to all FS implementations.
	35	*/
	36
	37	#include "libfs.h"
[efd4a72]	38	#include "../../srv/vfs/vfs.h"
	39	#include <errno.h>
	40	#include <async.h>
	41	#include <ipc/ipc.h>
	42	#include <as.h>
[2c448fb]	43	#include <assert.h>
	44	#include <dirent.h>
[efd4a72]	45
	46	/** Register file system server.
	47	*
	48	* This function abstracts away the tedious registration protocol from
	49	* file system implementations and lets them to reuse this registration glue
	50	* code.
	51	*
	52	* @param vfs_phone Open phone for communication with VFS.
	53	* @param reg File system registration structure. It will be
	54	* initialized by this function.
	55	* @param info VFS info structure supplied by the file system
	56	* implementation.
	57	* @param conn Connection fibril for handling all calls originating in
	58	* VFS.
	59	*
	60	* @return EOK on success or a non-zero error code on errror.
	61	*/
	62	int fs_register(int vfs_phone, fs_reg_t reg, vfs_info_t info,
	63	async_client_conn_t conn)
	64	{
	65	/*
	66	* Tell VFS that we are here and want to get registered.
	67	* We use the async framework because VFS will answer the request
	68	* out-of-order, when it knows that the operation succeeded or failed.
	69	*/
	70	ipc_call_t answer;
	71	aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
	72
	73	/*
	74	* Send our VFS info structure to VFS.
	75	*/
[215e375]	76	int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
[efd4a72]	77	if (rc != EOK) {
	78	async_wait_for(req, NULL);
	79	return rc;
	80	}
	81
	82	/*
	83	* Ask VFS for callback connection.
	84	*/
	85	ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
	86
	87	/*
	88	* Allocate piece of address space for PLB.
	89	*/
	90	reg->plb_ro = as_get_mappable_page(PLB_SIZE);
	91	if (!reg->plb_ro) {
	92	async_wait_for(req, NULL);
	93	return ENOMEM;
	94	}
	95
	96	/*
	97	* Request sharing the Path Lookup Buffer with VFS.
	98	*/
[215e375]	99	rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
[efd4a72]	100	if (rc) {
	101	async_wait_for(req, NULL);
	102	return rc;
	103	}
	104
	105	/*
	106	* Pick up the answer for the request to the VFS_REQUEST call.
	107	*/
	108	async_wait_for(req, NULL);
	109	reg->fs_handle = (int) IPC_GET_ARG1(answer);
	110
	111	/*
	112	* Create a connection fibril to handle the callback connection.
	113	*/
	114	async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
	115
	116	/*
	117	* Tell the async framework that other connections are to be handled by
	118	* the same connection fibril as well.
	119	*/
	120	async_set_client_connection(conn);
	121
	122	return IPC_GET_RETVAL(answer);
	123	}
[74303b6]	124
[83937ccd]	125	void fs_node_initialize(fs_node_t *fn)
	126	{
	127	memset(fn, 0, sizeof(fs_node_t));
	128	}
	129
	130	void libfs_mount(libfs_ops_t ops, ipc_callid_t rid, ipc_call_t request)
	131	{
	132	dev_handle_t mp_dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
	133	fs_index_t mp_fs_index = (fs_index_t)IPC_GET_ARG2(*request);
	134	fs_handle_t mr_fs_handle = (fs_handle_t)IPC_GET_ARG3(*request);
	135	dev_handle_t mr_dev_handle = (dev_handle_t)IPC_GET_ARG4(*request);
	136	int res;
	137	ipcarg_t rc;
	138
	139	ipc_call_t call;
	140	ipc_callid_t callid;
	141
	142	/* accept the phone */
	143	callid = async_get_call(&call);
	144	int mountee_phone = (int)IPC_GET_ARG1(call);
	145	if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) \|\|
	146	mountee_phone < 0) {
	147	ipc_answer_0(callid, EINVAL);
	148	ipc_answer_0(rid, EINVAL);
	149	return;
	150	}
	151	ipc_answer_0(callid, EOK); /* acknowledge the mountee_phone */
	152
	153	res = ipc_data_write_receive(&callid, NULL);
	154	if (!res) {
	155	ipc_hangup(mountee_phone);
	156	ipc_answer_0(callid, EINVAL);
	157	ipc_answer_0(rid, EINVAL);
	158	return;
	159	}
	160
	161	fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index);
	162	if (!fn) {
	163	ipc_hangup(mountee_phone);
	164	ipc_answer_0(callid, ENOENT);
	165	ipc_answer_0(rid, ENOENT);
	166	return;
	167	}
	168
	169	if (fn->mp_data.mp_active) {
	170	ipc_hangup(mountee_phone);
	171	ops->node_put(fn);
	172	ipc_answer_0(callid, EBUSY);
	173	ipc_answer_0(rid, EBUSY);
	174	return;
	175	}
	176
	177	rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME);
	178	if (rc != 0) {
	179	ipc_hangup(mountee_phone);
	180	ops->node_put(fn);
	181	ipc_answer_0(callid, rc);
	182	ipc_answer_0(rid, rc);
	183	return;
	184	}
	185
	186	ipc_call_t answer;
	187	aid_t msg = async_send_1(mountee_phone, VFS_MOUNTED, mr_dev_handle,
	188	&answer);
	189	ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
	190	async_wait_for(msg, &rc);
	191
	192	if (rc == EOK) {
	193	fn->mp_data.mp_active = true;
	194	fn->mp_data.fs_handle = mr_fs_handle;
	195	fn->mp_data.dev_handle = mr_dev_handle;
	196	fn->mp_data.phone = mountee_phone;
	197	}
	198	/*
	199	* Do not release the FS node so that it stays in memory.
	200	*/
	201	ipc_answer_0(rid, rc);
	202	}
	203
[1e50f81]	204	/** Lookup VFS triplet by name in the file system name space.
[9bb85f3]	205	*
	206	* The path passed in the PLB must be in the canonical file system path format
	207	* as returned by the canonify() function.
[1e50f81]	208	*
	209	* @param ops libfs operations structure with function pointers to
	210	* file system implementation
	211	* @param fs_handle File system handle of the file system where to perform
	212	* the lookup.
	213	* @param rid Request ID of the VFS_LOOKUP request.
	214	* @param request VFS_LOOKUP request data itself.
	215	*/
[f2ec8c8]	216	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
[2c448fb]	217	ipc_call_t *request)
	218	{
[83937ccd]	219	unsigned first = IPC_GET_ARG1(*request);
[2c448fb]	220	unsigned last = IPC_GET_ARG2(*request);
[83937ccd]	221	unsigned next = first;
[f2ec8c8]	222	dev_handle_t dev_handle = IPC_GET_ARG3(*request);
[2c448fb]	223	int lflag = IPC_GET_ARG4(*request);
[f2ec8c8]	224	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */
[c9f6e49f]	225	char component[NAME_MAX + 1];
	226	int len;
[2c448fb]	227
	228	if (last < next)
	229	last += PLB_SIZE;
	230
[b6035ba]	231	fs_node_t *par = NULL;
	232	fs_node_t *cur = ops->root_get(dev_handle);
	233	fs_node_t *tmp = NULL;
[2c448fb]	234
[83937ccd]	235	if (cur->mp_data.mp_active) {
	236	ipc_forward_slow(rid, cur->mp_data.phone, VFS_LOOKUP,
	237	next, last, cur->mp_data.dev_handle, lflag, index,
	238	IPC_FF_ROUTE_FROM_ME);
	239	ops->node_put(cur);
	240	return;
	241	}
	242
[2c448fb]	243	if (ops->plb_get_char(next) == '/')
	244	next++; /* eat slash */
	245
[92f9baca]	246	while (next <= last && ops->has_children(cur)) {
[2c448fb]	247	/* collect the component */
[c9f6e49f]	248	len = 0;
[fa832eb]	249	while ((next <= last) && (ops->plb_get_char(next) != '/')) {
[2c448fb]	250	if (len + 1 == NAME_MAX) {
[abb2865]	251	/* component length overflow */
[2c448fb]	252	ipc_answer_0(rid, ENAMETOOLONG);
[06901c6b]	253	goto out;
[2c448fb]	254	}
	255	component[len++] = ops->plb_get_char(next);
	256	next++; /* process next character */
	257	}
	258
	259	assert(len);
	260	component[len] = '\0';
	261	next++; /* eat slash */
	262
	263	/* match the component */
[736c164]	264	tmp = ops->match(cur, component);
[83937ccd]	265	if (tmp && tmp->mp_data.mp_active) {
	266	if (next > last)
	267	next = last = first;
	268	else
	269	next--;
	270
	271	ipc_forward_slow(rid, tmp->mp_data.phone, VFS_LOOKUP,
	272	next, last, tmp->mp_data.dev_handle, lflag, index,
	273	IPC_FF_ROUTE_FROM_ME);
	274	ops->node_put(cur);
	275	ops->node_put(tmp);
	276	if (par)
	277	ops->node_put(par);
	278	return;
	279	}
[2c448fb]	280
	281	/* handle miss: match amongst siblings */
	282	if (!tmp) {
[a8e9ab8d]	283	if (next <= last) {
	284	/* there are unprocessed components */
	285	ipc_answer_0(rid, ENOENT);
[06901c6b]	286	goto out;
[a8e9ab8d]	287	}
	288	/* miss in the last component */
	289	if (lflag & (L_CREATE \| L_LINK)) {
	290	/* request to create a new link */
[2c448fb]	291	if (!ops->is_directory(cur)) {
	292	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	293	goto out;
[a8e9ab8d]	294	}
[b6035ba]	295	fs_node_t *fn;
[a8e9ab8d]	296	if (lflag & L_CREATE)
[b6035ba]	297	fn = ops->create(dev_handle, lflag);
[a8e9ab8d]	298	else
[b6035ba]	299	fn = ops->node_get(dev_handle,
[34f62f8]	300	index);
[b6035ba]	301	if (fn) {
[0013b9ce]	302	int rc;
	303
[b6035ba]	304	rc = ops->link(cur, fn, component);
[0013b9ce]	305	if (rc != EOK) {
[92f9baca]	306	if (lflag & L_CREATE) {
[b6035ba]	307	(void)ops->destroy(fn);
[92f9baca]	308	}
[0013b9ce]	309	ipc_answer_0(rid, rc);
[2c448fb]	310	} else {
	311	ipc_answer_5(rid, EOK,
	312	fs_handle, dev_handle,
[b6035ba]	313	ops->index_get(fn),
	314	ops->size_get(fn),
	315	ops->lnkcnt_get(fn));
	316	ops->node_put(fn);
[2c448fb]	317	}
	318	} else {
	319	ipc_answer_0(rid, ENOSPC);
	320	}
[06901c6b]	321	goto out;
[a8e9ab8d]	322	}
[2c448fb]	323	ipc_answer_0(rid, ENOENT);
[06901c6b]	324	goto out;
[2c448fb]	325	}
	326
[06901c6b]	327	if (par)
	328	ops->node_put(par);
	329
[2c448fb]	330	/* descend one level */
[7b6d98b]	331	par = cur;
[2c448fb]	332	cur = tmp;
[06901c6b]	333	tmp = NULL;
[2c448fb]	334	}
	335
	336	/* handle miss: excessive components */
[92f9baca]	337	if (next <= last && !ops->has_children(cur)) {
[a8e9ab8d]	338	if (lflag & (L_CREATE \| L_LINK)) {
[2c448fb]	339	if (!ops->is_directory(cur)) {
	340	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	341	goto out;
[2c448fb]	342	}
	343
	344	/* collect next component */
[c9f6e49f]	345	len = 0;
[2c448fb]	346	while (next <= last) {
	347	if (ops->plb_get_char(next) == '/') {
	348	/* more than one component */
	349	ipc_answer_0(rid, ENOENT);
[06901c6b]	350	goto out;
[2c448fb]	351	}
	352	if (len + 1 == NAME_MAX) {
	353	/* component length overflow */
	354	ipc_answer_0(rid, ENAMETOOLONG);
[06901c6b]	355	goto out;
[2c448fb]	356	}
	357	component[len++] = ops->plb_get_char(next);
	358	next++; /* process next character */
	359	}
	360	assert(len);
	361	component[len] = '\0';
	362
[b6035ba]	363	fs_node_t *fn;
[a8e9ab8d]	364	if (lflag & L_CREATE)
[b6035ba]	365	fn = ops->create(dev_handle, lflag);
[a8e9ab8d]	366	else
[b6035ba]	367	fn = ops->node_get(dev_handle, index);
	368	if (fn) {
[0013b9ce]	369	int rc;
	370
[b6035ba]	371	rc = ops->link(cur, fn, component);
[0013b9ce]	372	if (rc != EOK) {
[a8e9ab8d]	373	if (lflag & L_CREATE)
[b6035ba]	374	(void)ops->destroy(fn);
[0013b9ce]	375	ipc_answer_0(rid, rc);
[2c448fb]	376	} else {
	377	ipc_answer_5(rid, EOK,
	378	fs_handle, dev_handle,
[b6035ba]	379	ops->index_get(fn),
	380	ops->size_get(fn),
	381	ops->lnkcnt_get(fn));
	382	ops->node_put(fn);
[2c448fb]	383	}
	384	} else {
	385	ipc_answer_0(rid, ENOSPC);
	386	}
[06901c6b]	387	goto out;
[2c448fb]	388	}
	389	ipc_answer_0(rid, ENOENT);
[06901c6b]	390	goto out;
[2c448fb]	391	}
	392
	393	/* handle hit */
[a8e9ab8d]	394	if (lflag & L_UNLINK) {
[2c448fb]	395	unsigned old_lnkcnt = ops->lnkcnt_get(cur);
[cf95bc0]	396	int res = ops->unlink(par, cur, component);
[2c448fb]	397	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
	398	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
[06901c6b]	399	goto out;
[2c448fb]	400	}
[a8e9ab8d]	401	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|
	402	(lflag & L_LINK)) {
[2c448fb]	403	ipc_answer_0(rid, EEXIST);
[06901c6b]	404	goto out;
[2c448fb]	405	}
	406	if ((lflag & L_FILE) && (ops->is_directory(cur))) {
	407	ipc_answer_0(rid, EISDIR);
[06901c6b]	408	goto out;
[2c448fb]	409	}
	410	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
	411	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	412	goto out;
[2c448fb]	413	}
	414
	415	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
	416	ops->size_get(cur), ops->lnkcnt_get(cur));
[06901c6b]	417
	418	out:
	419	if (par)
	420	ops->node_put(par);
	421	if (cur)
	422	ops->node_put(cur);
	423	if (tmp)
	424	ops->node_put(tmp);
[2c448fb]	425	}
	426
[74303b6]	427	/** @}
	428	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: