/**************************************************************************** * fs/inode/inode.h * * Copyright (C) 2007, 2009, 2012, 2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * 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. * ****************************************************************************/ #ifndef __FS_INODE_H #define __FS_INODE_H /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /* Inode i_flag values */ #define FSNODEFLAG_TYPE_MASK 0x00000007 /* Isolates type field */ #define FSNODEFLAG_TYPE_DRIVER 0x00000000 /* Character driver */ #define FSNODEFLAG_TYPE_BLOCK 0x00000001 /* Block driver */ #define FSNODEFLAG_TYPE_MOUNTPT 0x00000002 /* Mount point */ #define FSNODEFLAG_TYPE_SPECIAL 0x00000004 /* Special OS type */ #define FSNODEFLAG_TYPE_NAMEDSEM 0x00000004 /* Named semaphore */ #define FSNODEFLAG_TYPE_MQUEUE 0x00000005 /* Message Queue */ #define FSNODEFLAG_TYPE_SHM 0x00000006 /* Shared memory region */ #define FSNODEFLAG_DELETED 0x00000008 /* Unlinked */ #define INODE_IS_TYPE(i,t) \ (((i)->i_flags & FSNODEFLAG_TYPE_MASK) == (t)) #define INODE_IS_SPECIAL(i) \ (((i)->i_flags & FSNODEFLAG_TYPE_SPECIAL) != 0) #define INODE_IS_DRIVER(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_DRIVER) #define INODE_IS_BLOCK(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_BLOCK) #define INODE_IS_MOUNTPT(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_MOUNTPT) #define INODE_IS_NAMEDSEM(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_NAMEDSEM) #define INODE_IS_MQUEUE(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_MQUEUE) #define INODE_IS_SHM(i) INODE_IS_TYPE(i,FSNODEFLAG_TYPE_SHM) #define INODE_GET_TYPE(i) ((i)->i_flags & FSNODEFLAG_TYPE_MASK) #define INODE_SET_TYPE(i,t) \ do \ { \ (i)->i_flags = ((i)->i_flags & ~FSNODEFLAG_TYPE_MASK) | (t); \ } \ while (0) #define INODE_SET_DRIVER(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_DRIVER) #define INODE_SET_BLOCK(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_BLOCK) #define INODE_SET_MOUNTPT(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_MOUNTPT) #define INODE_SET_NAMEDSEM(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_NAMEDSEM) #define INODE_SET_MQUEUE(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_MQUEUE) #define INODE_SET_SHM(i) INODE_SET_TYPE(i,FSNODEFLAG_TYPE_SHM) /* Mountpoint fd_flags values */ #define DIRENTFLAGS_PSEUDONODE 1 #define DIRENT_SETPSEUDONODE(f) do (f) |= DIRENTFLAGS_PSEUDONODE; while (0) #define DIRENT_ISPSEUDONODE(f) (((f) & DIRENTFLAGS_PSEUDONODE) != 0) /**************************************************************************** * Public Types ****************************************************************************/ /* Callback used by foreach_inode to traverse all inodes in the pseudo- * file system. */ typedef int (*foreach_inode_t)(FAR struct inode *node, FAR char dirpath[PATH_MAX], FAR void *arg); /**************************************************************************** * Public Data ****************************************************************************/ #undef EXTERN #if defined(__cplusplus) #define EXTERN extern "C" extern "C" { #else #define EXTERN extern #endif EXTERN FAR struct inode *g_root_inode; /**************************************************************************** * Public Function Prototypes ****************************************************************************/ /* fs_inode.c ***************************************************************/ /**************************************************************************** * Name: inode_initialize * * Description: * This is called from the OS initialization logic to configure the file * system. * ****************************************************************************/ void inode_initialize(void); /**************************************************************************** * Name: inode_semtake * * Description: * Get exclusive access to the in-memory inode tree (tree_sem). * ****************************************************************************/ void inode_semtake(void); /**************************************************************************** * Name: inode_semgive * * Description: * Relinquish exclusive access to the in-memory inode tree (tree_sem). * ****************************************************************************/ void inode_semgive(void); /**************************************************************************** * Name: inode_search * * Description: * Find the inode associated with 'path' returning the inode references * and references to its companion nodes. * * Assumptions: * The caller holds the tree_sem * ****************************************************************************/ FAR struct inode *inode_search(FAR const char **path, FAR struct inode **peer, FAR struct inode **parent, FAR const char **relpath); /**************************************************************************** * Name: inode_free * * Description: * Free resources used by an inode * ****************************************************************************/ void inode_free(FAR struct inode *node); /**************************************************************************** * Name: inode_nextname * * Description: * Given a path with node names separated by '/', return the next node * name. * ****************************************************************************/ const char *inode_nextname(FAR const char *name); /* fs_inodereserver.c *******************************************************/ /**************************************************************************** * Name: inode_reserve * * Description: * Reserve an (initialized) inode the pseudo file system. * * NOTE: Caller must hold the inode semaphore * * Input parameters: * path - The path to the inode to create * inode - The location to return the inode pointer * * Returned Value: * Zero on success (with the inode point in 'inode'); A negated errno * value is returned on failure: * * EINVAL - 'path' is invalid for this operation * EEXIST - An inode already exists at 'path' * ENOMEM - Failed to allocate in-memory resources for the operation * ****************************************************************************/ int inode_reserve(FAR const char *path, FAR struct inode **inode); /* fs_inoderemove.c *********************************************************/ /**************************************************************************** * Name: inode_unlink * * Description: * Given a path, remove a the node from the in-memory, inode tree that the * path refers to. This is normally done in preparation to removing or * moving an inode. * * Assumptions/Limitations: * The caller must hold the inode semaphore * ****************************************************************************/ FAR struct inode *inode_unlink(FAR const char *path); /**************************************************************************** * Name: inode_remove * * Description: * Given a path, remove a the node from the in-memory, inode tree that the * path refers to and free all resources related to the inode. If the * inode is in-use, then it will be unlinked, but will not be freed until * the last reference to the inode is released. * * Assumptions/Limitations: * The caller must hold the inode semaphore * ****************************************************************************/ int inode_remove(FAR const char *path); /* fs_inodefind.c ***********************************************************/ /**************************************************************************** * Name: inode_find * * Description: * This is called from the open() logic to get a reference to the inode * associated with a path. * ****************************************************************************/ FAR struct inode *inode_find(FAR const char *path, const char **relpath); /* fs_inodeaddref.c *********************************************************/ void inode_addref(FAR struct inode *inode); /* fs_inoderelease.c ********************************************************/ void inode_release(FAR struct inode *inode); /* fs_foreachinode.c ********************************************************/ /**************************************************************************** * Name: foreach_inode * * Description: * Visit each inode in the pseudo-file system. The traversal is terminated * when the callback 'handler' returns a non-zero value, or when all of * the inodes have been visited. * * NOTE 1: Use with caution... The pseudo-file system is locked throughout * the traversal. * NOTE 2: The search algorithm is recursive and could, in principle, use * an indeterminant amount of stack space. This will not usually be a * real work issue. * ****************************************************************************/ int foreach_inode(foreach_inode_t handler, FAR void *arg); /* fs_files.c ***************************************************************/ /**************************************************************************** * Name: files_initialize * * Description: * This is called from the FS initialization logic to configure the files. * ****************************************************************************/ void weak_function files_initialize(void); /**************************************************************************** * Name: files_allocate * * Description: * Allocate a struct files instance and associate it with an inode instance. * Returns the file descriptor == index into the files array. * ****************************************************************************/ int files_allocate(FAR struct inode *inode, int oflags, off_t pos, int minfd); /**************************************************************************** * Name: files_close * * Description: * Close an inode (if open) * * Assumuptions: * Caller holds the list semaphore because the file descriptor will be freed. * ****************************************************************************/ int files_close(int fd); /**************************************************************************** * Name: files_release * * Assumuptions: * Similar to files_close(). Called only from open() logic on error * conditions. * ****************************************************************************/ void files_release(int fd); #undef EXTERN #if defined(__cplusplus) } #endif #endif /* __FS_INODE_H */