nuttx/fs/inode/fs_inode.c

657 lines
19 KiB
C
Raw Normal View History

/****************************************************************************
2014-09-28 19:06:21 +02:00
* fs/inode/fs_inode.c
*
* Copyright (C) 2007-2009, 2011-2012, 2016-2017 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <assert.h>
2017-02-02 20:01:21 +01:00
#include <limits.h>
#include <semaphore.h>
#include <assert.h>
#include <errno.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs/fs.h>
#include "inode/inode.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define NO_HOLDER ((pid_t)-1)
/****************************************************************************
* Private Types
****************************************************************************/
/* Implements a re-entrant mutex for inode access. This must be re-entrant
* because there can be cycles. For example, it may be necessary to destroy
* a block driver inode on umount() after a removable block device has been
* removed. In that case umount() hold the inode semaphore, but the block
* driver may callback to unregister_blockdriver() after the un-mount,
* requiring the seamphore again.
*/
struct inode_sem_s
{
sem_t sem; /* The semaphore */
pid_t holder; /* The current holder of the semaphore */
int16_t count; /* Number of counts held */
};
/****************************************************************************
* Private Data
****************************************************************************/
static struct inode_sem_s g_inode_sem;
/****************************************************************************
* Public Data
****************************************************************************/
2015-06-11 19:24:20 +02:00
FAR struct inode *g_root_inode = NULL;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: _inode_compare
*
* Description:
* Compare two inode names
*
****************************************************************************/
static int _inode_compare(FAR const char *fname,
FAR struct inode *node)
{
char *nname = node->i_name;
if (!nname)
{
return 1;
}
if (!fname)
{
return -1;
}
for (; ; )
{
/* At end of node name? */
if (!*nname)
{
/* Yes.. also end of find name? */
if (!*fname || *fname == '/')
{
/* Yes.. return match */
return 0;
}
else
{
/* No... return find name > node name */
return 1;
}
}
/* At end of find name? */
else if (!*fname || *fname == '/')
{
/* Yes... return find name < node name */
return -1;
}
/* Check for non-matching characters */
else if (*fname > *nname)
{
return 1;
}
else if (*fname < *nname)
{
return -1;
}
/* Not at the end of either string and all of the
* characters still match. keep looking.
*/
else
{
fname++;
nname++;
}
}
}
2017-02-02 20:01:21 +01:00
/****************************************************************************
* Name: _inode_dereference
*
* Description:
* If the inode is a soft link, then (1) get the name of the full path of
* the soft link, (2) recursively look-up the inode referenced by the soft
* link, and (3) return the inode referenced by the soft link.
*
* Assumptions:
* The caller holds the g_inode_sem semaphore
*
****************************************************************************/
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
static inline FAR struct inode *
_inode_dereference(FAR struct inode *node, FAR struct inode **peer,
FAR struct inode **parent, FAR const char **relpath)
{
FAR const char *copy;
2017-02-02 20:01:21 +01:00
unsigned int count = 0;
/* An infinite loop is avoided only by the loop count.
*
* REVISIT: The ELOOP error should be reported to the application in that
* case but there is no simple mechanism to do that.
*/
while (node != NULL && INODE_IS_SOFTLINK(node))
{
/* Careful: inode_search_nofollow overwrites the input string pointer */
copy = (FAR const char *)node->u.i_link;
/* Now, look-up the inode associated with the target path */
node = inode_search_nofollow(&copy, peer, parent, relpath);
if (node == NULL && ++count > SYMLOOP_MAX)
2017-02-02 20:01:21 +01:00
{
return NULL;
}
}
return node;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: inode_initialize
*
* Description:
* This is called from the OS initialization logic to configure the file
* system.
*
****************************************************************************/
void inode_initialize(void)
{
/* Initialize the semaphore to one (to support one-at-a-time access to the
* inode tree).
*/
(void)sem_init(&g_inode_sem.sem, 0, 1);
g_inode_sem.holder = NO_HOLDER;
g_inode_sem.count = 0;
/* Initialize files array (if it is used) */
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
if (files_initialize != NULL)
#endif
{
files_initialize();
}
}
/****************************************************************************
* Name: inode_semtake
*
* Description:
* Get exclusive access to the in-memory inode tree (g_inode_sem).
*
****************************************************************************/
void inode_semtake(void)
{
pid_t me;
/* Do we already hold the semaphore? */
me = getpid();
if (me == g_inode_sem.holder)
{
/* Yes... just increment the count */
g_inode_sem.count++;
DEBUGASSERT(g_inode_sem.count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
while (sem_wait(&g_inode_sem.sem) != 0)
{
/* The only case that an error should occr here is if
* the wait was awakened by a signal.
*/
ASSERT(get_errno() == EINTR);
}
/* No we hold the semaphore */
g_inode_sem.holder = me;
g_inode_sem.count = 1;
}
}
/****************************************************************************
* Name: inode_semgive
*
* Description:
* Relinquish exclusive access to the in-memory inode tree (g_inode_sem).
*
****************************************************************************/
void inode_semgive(void)
{
DEBUGASSERT(g_inode_sem.holder == getpid());
/* Is this our last count on the semaphore? */
if (g_inode_sem.count > 1)
{
/* No.. just decrement the count */
g_inode_sem.count--;
}
/* Yes.. then we can really release the semaphore */
else
{
g_inode_sem.holder = NO_HOLDER;
g_inode_sem.count = 0;
sem_post(&g_inode_sem.sem);
}
}
/****************************************************************************
2017-02-02 20:01:21 +01:00
* Name: inode_search and inode_search_nofollow
*
* Description:
* Find the inode associated with 'path' returning the inode references
* and references to its companion nodes.
*
2017-02-02 20:01:21 +01:00
* Both versions will follow soft links in path leading up to the terminal
* node. inode_search() will deference that terminal node,
* inode_search_nofollow will not.
*
* Assumptions:
* The caller holds the g_inode_sem semaphore
*
****************************************************************************/
2017-02-02 20:01:21 +01:00
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
FAR struct inode *inode_search_nofollow(FAR const char **path,
FAR struct inode **peer,
FAR struct inode **parent,
FAR const char **relpath)
#else
2014-07-29 20:49:40 +02:00
FAR struct inode *inode_search(FAR const char **path,
FAR struct inode **peer,
FAR struct inode **parent,
2014-07-29 20:49:40 +02:00
FAR const char **relpath)
2017-02-02 20:01:21 +01:00
#endif
{
2014-07-29 20:49:40 +02:00
FAR const char *name = *path + 1; /* Skip over leading '/' */
2015-06-11 19:24:20 +02:00
FAR struct inode *node = g_root_inode;
FAR struct inode *left = NULL;
FAR struct inode *above = NULL;
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
FAR struct inode *newnode;
#endif
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* Handle the case were the root node is a symbolic link */
#warning Missing logic
#endif
/* Traverse the pseudo file system node tree until either (1) all nodes
* have been examined without finding the matching node, or (2) the
* matching node is found.
*/
2017-02-02 20:01:21 +01:00
while (node != NULL)
{
int result = _inode_compare(name, node);
/* Case 1: The name is less than the name of the node.
* Since the names are ordered, these means that there
* is no peer node with this name and that there can be
* no match in the fileystem.
*/
if (result < 0)
{
node = NULL;
break;
}
/* Case 2: the name is greater than the name of the node.
* In this case, the name may still be in the list to the
* "right"
*/
else if (result > 0)
{
2017-02-02 20:01:21 +01:00
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* If the inode in the is a soft link and this is the inode at
* at the head of the peer list and not the final node in the
* path), then (1) get the name of the full path of the soft
* link, (2) recursively look-up the inode referenced by the
* soft link, and (3) use the peer of that inode instead.
*/
FAR const char *nextname = inode_nextname(name);
if (*nextname != '\0')
{
newnode = _inode_dereference(node, NULL, &above, relpath);
if (newnode == NULL)
2017-02-02 20:01:21 +01:00
{
/* Probably means that the node is a symbolic link, but
* that the target of the symbolic link does not exist.
*/
2017-02-02 20:01:21 +01:00
break;
}
else if (newnode != node)
{
/* The node was a valid symbolic link and we have jumped to a
* different, spot in the the pseudo file system tree. Reset
* everything and continue looking at the next level "down"
* from that new spot in the tree.
*/
above = newnode;
left = NULL;
node = newnode->i_child;
continue;
}
2017-02-02 20:01:21 +01:00
}
#endif
/* Continue looking to the left */
left = node;
node = node->i_peer;
}
/* The names match */
else
{
2017-02-02 20:01:21 +01:00
/* Now there are three remaining possibilities:
* (1) This is the node that we are looking for.
* (2) The node we are looking for is "below" this one.
* (3) This node is a mountpoint and will absorb all request
* below this one
*/
name = inode_nextname(name);
2017-02-02 20:01:21 +01:00
if (*name == '\0' || INODE_IS_MOUNTPT(node))
{
/* Either (1) we are at the end of the path, so this must be the
* node we are looking for or else (2) this node is a mountpoint
* and will handle the remaining part of the pathname
*/
if (relpath)
{
*relpath = name;
}
2017-02-02 20:01:21 +01:00
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* NOTE that if the terminal inode is a soft link, it is not
* deferenced in this case. The raw inode is returned.
*
* In that case a wrapper function will perform that operation.
*/
#endif
break;
}
else
{
/* More nodes to be examined in the path... */
2017-02-02 20:01:21 +01:00
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* If this intermediate inode in the is a soft link, then (1)
* get the name of the full path of the soft link, (2) recursively
* look-up the inode referenced by the sof link, and (3)
* continue searching with that inode instead.
*/
newnode = _inode_dereference(node, NULL, NULL, relpath);
if (newnode == NULL)
2017-02-02 20:01:21 +01:00
{
/* Probably means that the node is a symbolic link, but
* that the target of the symbolic link does not exist.
*/
2017-02-02 20:01:21 +01:00
break;
}
else if (newnode != node)
{
/* The node was a valid symbolic link and we have jumped to a
* different, spot in the the pseudo file system tree. Reset
* everything and continue looking to the right (if possible)
* otherwise at the next level "down" from that new spot in
* the tree.
*/
if (newnode->i_peer != NULL)
{
above = NULL; /* REVISIT: This can't be right */
left = newnode;
node = newnode->i_peer;
/* Did the symbolic link take us to a mountpoint? */
if (INODE_IS_MOUNTPT(newnode))
{
/* Yes.. return the mountpoint information */
if (relpath)
{
*relpath = name;
}
break;
}
}
}
2017-02-02 20:01:21 +01:00
#endif
/* Keep looking at the next level "down" */
above = node;
left = NULL;
2017-02-02 20:01:21 +01:00
node = node->i_child;
}
}
}
/* node is null. This can happen in one of four cases:
* With node = NULL
* (1) We went left past the final peer: The new node
* name is larger than any existing node name at
* that level.
* (2) We broke out in the middle of the list of peers
* because the name was not found in the ordered
* list.
* (3) We went down past the final parent: The new node
* name is "deeper" than anything that we currently
* have in the tree.
* with node != NULL
* (4) When the node matching the full path is found
*/
if (peer)
{
*peer = left;
}
if (parent)
{
*parent = above;
}
*path = name;
return node;
}
2017-02-02 20:01:21 +01:00
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
FAR struct inode *inode_search(FAR const char **path,
FAR struct inode **peer,
FAR struct inode **parent,
FAR const char **relpath)
{
/* Lookup the terminal inode */
FAR struct inode *node = inode_search_nofollow(path, peer, parent, relpath);
/* Did we find it? */
if (node != NULL)
{
/* Yes.. If the terminal inode in the is a soft link, then (1) get
* the name of the full path of the soft link, (2) recursively
* look-up the inode referenced by the soft link, and (3)
* return that inode instead.
*/
return _inode_dereference(node, peer, parent, relpath);
}
return node;
}
#endif
/****************************************************************************
* Name: inode_free
*
* Description:
* Free resources used by an inode
*
****************************************************************************/
void inode_free(FAR struct inode *node)
{
2015-06-11 19:24:20 +02:00
/* Verify that we were passed valid pointer to an inode */
if (node != NULL)
{
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* Symbol links should never have peers or children */
DEBUGASSERT(!INODE_IS_SOFTLINK(node) ||
(node->i_peer == NULL && node->i_child == NULL));
#endif
/* Free all peers and children of this i_node */
inode_free(node->i_peer);
inode_free(node->i_child);
#ifdef CONFIG_PSEUDOFS_SOFTLINKS
/* If the inode is a symbolic link, the free the path to the linked
* entity.
*/
if (INODE_IS_SOFTLINK(node) && node->u.i_link != NULL)
{
kmm_free(node->u.i_link);
}
#endif
kmm_free(node);
}
}
/****************************************************************************
* Name: inode_nextname
*
* Description:
* Given a path with node names separated by '/', return the next path
* segment name.
*
****************************************************************************/
FAR const char *inode_nextname(FAR const char *name)
{
/* Search for the '/' delimiter or the NUL terminator at the end of the
* path segment.
*/
while (*name && *name != '/')
{
name++;
}
/* If we found the '/' delimiter, then the path segment we want begins at
* the next character (which might also be the NUL terminator).
*/
if (*name)
{
name++;
}
return name;
}