Context Navigation

source: mainline/uspace/lib/libfs/libfs.c@ 45f244b

Visit:

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

Last change on this file since 45f244b was 80e8482, checked in by Jakub Jermar <jakub@…>, 17 years ago
Add stubs for unimplemented FAT libfs operations.
Property mode set to `100644`
File size: 8.8 KB

Rev	Line
[74303b6]	1	/*
[2c448fb]	2	* Copyright (c) 2008 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
[1e50f81]	125	/** Lookup VFS triplet by name in the file system name space.
[9bb85f3]	126	*
	127	* The path passed in the PLB must be in the canonical file system path format
	128	* as returned by the canonify() function.
[1e50f81]	129	*
	130	* @param ops libfs operations structure with function pointers to
	131	* file system implementation
	132	* @param fs_handle File system handle of the file system where to perform
	133	* the lookup.
	134	* @param rid Request ID of the VFS_LOOKUP request.
	135	* @param request VFS_LOOKUP request data itself.
	136	*/
[f2ec8c8]	137	void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
[2c448fb]	138	ipc_call_t *request)
	139	{
	140	unsigned next = IPC_GET_ARG1(*request);
	141	unsigned last = IPC_GET_ARG2(*request);
[f2ec8c8]	142	dev_handle_t dev_handle = IPC_GET_ARG3(*request);
[2c448fb]	143	int lflag = IPC_GET_ARG4(*request);
[f2ec8c8]	144	fs_index_t index = IPC_GET_ARG5(request); / when L_LINK specified */
[c9f6e49f]	145	char component[NAME_MAX + 1];
	146	int len;
[2c448fb]	147
	148	if (last < next)
	149	last += PLB_SIZE;
	150
[7b6d98b]	151	void *par = NULL;
[74ea3c6]	152	void *cur = ops->root_get(dev_handle);
[06901c6b]	153	void *tmp = NULL;
[2c448fb]	154
	155	if (ops->plb_get_char(next) == '/')
	156	next++; /* eat slash */
	157
[736c164]	158	while (ops->has_children(cur) && next <= last) {
[2c448fb]	159	/* collect the component */
[c9f6e49f]	160	len = 0;
[9ad75d5]	161	while ((ops->plb_get_char(next) != '/') && (next <= last)) {
[2c448fb]	162	if (len + 1 == NAME_MAX) {
	163	/* comopnent length overflow */
	164	ipc_answer_0(rid, ENAMETOOLONG);
[06901c6b]	165	goto out;
[2c448fb]	166	}
	167	component[len++] = ops->plb_get_char(next);
	168	next++; /* process next character */
	169	}
	170
	171	assert(len);
	172	component[len] = '\0';
	173	next++; /* eat slash */
	174
	175	/* match the component */
[736c164]	176	tmp = ops->match(cur, component);
[2c448fb]	177
	178	/* handle miss: match amongst siblings */
	179	if (!tmp) {
[a8e9ab8d]	180	if (next <= last) {
	181	/* there are unprocessed components */
	182	ipc_answer_0(rid, ENOENT);
[06901c6b]	183	goto out;
[a8e9ab8d]	184	}
	185	/* miss in the last component */
	186	if (lflag & (L_CREATE \| L_LINK)) {
	187	/* request to create a new link */
[2c448fb]	188	if (!ops->is_directory(cur)) {
	189	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	190	goto out;
[a8e9ab8d]	191	}
	192	void *nodep;
	193	if (lflag & L_CREATE)
	194	nodep = ops->create(lflag);
	195	else
[94b0b63]	196	nodep = ops->node_get(dev_handle,
[e1e3b26]	197	index, ops->index_get(cur));
[2c448fb]	198	if (nodep) {
	199	if (!ops->link(cur, nodep, component)) {
[a8e9ab8d]	200	if (lflag & L_CREATE)
[80e8482]	201	(void)ops->destroy(nodep);
[2c448fb]	202	ipc_answer_0(rid, ENOSPC);
	203	} else {
	204	ipc_answer_5(rid, EOK,
	205	fs_handle, dev_handle,
[a8e9ab8d]	206	ops->index_get(nodep),
	207	ops->size_get(nodep),
[2c448fb]	208	ops->lnkcnt_get(nodep));
[06901c6b]	209	ops->node_put(nodep);
[2c448fb]	210	}
	211	} else {
	212	ipc_answer_0(rid, ENOSPC);
	213	}
[06901c6b]	214	goto out;
[a8e9ab8d]	215	} else if (lflag & L_PARENT) {
	216	/* return parent */
	217	ipc_answer_5(rid, EOK, fs_handle, dev_handle,
	218	ops->index_get(cur), ops->size_get(cur),
	219	ops->lnkcnt_get(cur));
	220	}
[2c448fb]	221	ipc_answer_0(rid, ENOENT);
[06901c6b]	222	goto out;
[2c448fb]	223	}
	224
[06901c6b]	225	if (par)
	226	ops->node_put(par);
	227
[2c448fb]	228	/* descend one level */
[7b6d98b]	229	par = cur;
[2c448fb]	230	cur = tmp;
[06901c6b]	231	tmp = NULL;
[2c448fb]	232	}
	233
	234	/* handle miss: excessive components */
[736c164]	235	if (!ops->has_children(cur) && next <= last) {
[a8e9ab8d]	236	if (lflag & (L_CREATE \| L_LINK)) {
[2c448fb]	237	if (!ops->is_directory(cur)) {
	238	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	239	goto out;
[2c448fb]	240	}
	241
	242	/* collect next component */
[c9f6e49f]	243	len = 0;
[2c448fb]	244	while (next <= last) {
	245	if (ops->plb_get_char(next) == '/') {
	246	/* more than one component */
	247	ipc_answer_0(rid, ENOENT);
[06901c6b]	248	goto out;
[2c448fb]	249	}
	250	if (len + 1 == NAME_MAX) {
	251	/* component length overflow */
	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	assert(len);
	259	component[len] = '\0';
	260
[a8e9ab8d]	261	void *nodep;
	262	if (lflag & L_CREATE)
	263	nodep = ops->create(lflag);
	264	else
[e1e3b26]	265	nodep = ops->node_get(dev_handle, index,
	266	ops->index_get(cur));
[2c448fb]	267	if (nodep) {
	268	if (!ops->link(cur, nodep, component)) {
[a8e9ab8d]	269	if (lflag & L_CREATE)
[80e8482]	270	(void)ops->destroy(nodep);
[2c448fb]	271	ipc_answer_0(rid, ENOSPC);
	272	} else {
	273	ipc_answer_5(rid, EOK,
	274	fs_handle, dev_handle,
[a8e9ab8d]	275	ops->index_get(nodep),
	276	ops->size_get(nodep),
[2c448fb]	277	ops->lnkcnt_get(nodep));
[06901c6b]	278	ops->node_put(nodep);
[2c448fb]	279	}
	280	} else {
	281	ipc_answer_0(rid, ENOSPC);
	282	}
[06901c6b]	283	goto out;
[2c448fb]	284	}
	285	ipc_answer_0(rid, ENOENT);
[06901c6b]	286	goto out;
[2c448fb]	287	}
	288
	289	/* handle hit */
[a8e9ab8d]	290	if (lflag & L_PARENT) {
[06901c6b]	291	ops->node_put(cur);
[a8e9ab8d]	292	cur = par;
[06901c6b]	293	par = NULL;
[a8e9ab8d]	294	if (!cur) {
	295	ipc_answer_0(rid, ENOENT);
[06901c6b]	296	goto out;
[a8e9ab8d]	297	}
	298	}
	299	if (lflag & L_UNLINK) {
[2c448fb]	300	unsigned old_lnkcnt = ops->lnkcnt_get(cur);
[7b6d98b]	301	int res = ops->unlink(par, cur);
[2c448fb]	302	ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
	303	ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
[06901c6b]	304	goto out;
[2c448fb]	305	}
[a8e9ab8d]	306	if (((lflag & (L_CREATE \| L_EXCLUSIVE)) == (L_CREATE \| L_EXCLUSIVE)) \|\|
	307	(lflag & L_LINK)) {
[2c448fb]	308	ipc_answer_0(rid, EEXIST);
[06901c6b]	309	goto out;
[2c448fb]	310	}
	311	if ((lflag & L_FILE) && (ops->is_directory(cur))) {
	312	ipc_answer_0(rid, EISDIR);
[06901c6b]	313	goto out;
[2c448fb]	314	}
	315	if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
	316	ipc_answer_0(rid, ENOTDIR);
[06901c6b]	317	goto out;
[2c448fb]	318	}
	319
	320	ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
	321	ops->size_get(cur), ops->lnkcnt_get(cur));
[06901c6b]	322
	323	out:
	324	if (par)
	325	ops->node_put(par);
	326	if (cur)
	327	ops->node_put(cur);
	328	if (tmp)
	329	ops->node_put(tmp);
[2c448fb]	330	}
	331
[74303b6]	332	/** @}
	333	*/

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

Download in other formats: