1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* ----> DO NOT REMOVE THE FOLLOWING NOTICE <----
Copyright (c) 2014-2015 Datalight, Inc.
All Rights Reserved Worldwide.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; use version 2 of the License.
This program is distributed in the hope that it will be useful,
but "AS-IS," WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/* Businesses and individuals that for commercial or other reasons cannot
comply with the terms of the GPLv2 license may obtain a commercial license
before incorporating Reliance Edge into proprietary software for
distribution in any form. Visit http://www.datalight.com/reliance-edge for
more information.
*/
/** @file
@brief Interface for the Reliance Edge POSIX-like API.
The POSIX-like file system API is the primary file system API for
Reliance Edge, which supports the full functionality of the file system.
This API aims to be compatible with POSIX where reasonable, but it is
simplified considerably to meet the needs of resource-constrained embedded
systems. The API has also been extended to provide access to the unique
features of Reliance Edge, and to cover areas (like mountins and formatting)
which do not have APIs in the POSIX specification.
*/
#ifndef REDPOSIX_H
#define REDPOSIX_H
/* This header is intended for application use; some applications are written
in C++.
*/
#ifdef __cplusplus
extern "C" {
#endif
#include <redconf.h>
#if REDCONF_API_POSIX == 1
#include <redtypes.h>
#include "redapimacs.h"
#include "rederrno.h"
#include "redstat.h"
/** Open for reading only. */
#define RED_O_RDONLY 0x00000001U
/** Open for writing only. */
#define RED_O_WRONLY 0x00000002U
/** Open for reading and writing. */
#define RED_O_RDWR 0x00000004U
/** File offset for all writes is end-of-file. */
#define RED_O_APPEND 0x00000008U
/** Create the file. */
#define RED_O_CREAT 0x00000010U
/** Error if path already exists. */
#define RED_O_EXCL 0x00000020U
/** Truncate file to size zero. */
#define RED_O_TRUNC 0x00000040U
/** @brief Last file system error (errno).
Under normal circumstances, each task using the file system has an
independent `red_errno` value. Applications do not need to worry about
one task obliterating an error value that another task needed to read. The
value is initially zero. When one of the POSIX-like APIs return an
indication of error, `red_errno` is set to an error value.
In some circumstances, `red_errno` will be a global errno location which
is shared by multiple tasks. If the calling task is not registered as a
file system user and all of the task slots are full, there can be no
task-specific errno, so the global errno is used. Likewise, if the file
system driver is uninitialized, there are no registered file system users
and `red_errno` always refers to the global errno. Under these
circumstances, multiple tasks manipulating `red_errno` could be
problematic. When the task count is set to one, `red_errno` always refers
to the global errno.
Note that `red_errno` is usable as an lvalue; i.e., in addition to reading
the error value, the error value can be set:
~~~{.c}
red_errno = 0;
~~~
*/
#define red_errno (*red_errnoptr())
/** @brief Positions from which to seek within a file.
*/
typedef enum
{
/* 0/1/2 are the traditional values for SET/CUR/END, respectively. Prior
to the release of Unix System V in 1983, the SEEK_* symbols did not
exist and C programs hard-coded the 0/1/2 values with those meanings.
*/
RED_SEEK_SET = 0, /**< Set file offset to given offset. */
RED_SEEK_CUR = 1, /**< Set file offset to current offset plus signed offset. */
RED_SEEK_END = 2 /**< Set file offset to EOF plus signed offset. */
} REDWHENCE;
#if REDCONF_API_POSIX_READDIR == 1
/** @brief Opaque directory handle.
*/
typedef struct sREDHANDLE REDDIR;
/** @brief Directory entry information.
*/
typedef struct
{
uint32_t d_ino; /**< File serial number (inode number). */
char d_name[REDCONF_NAME_MAX+1U]; /**< Name of entry. */
REDSTAT d_stat; /**< File information (POSIX extension). */
} REDDIRENT;
#endif
int32_t red_init(void);
int32_t red_uninit(void);
int32_t red_mount(const char *pszVolume);
int32_t red_umount(const char *pszVolume);
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_FORMAT == 1)
int32_t red_format(const char *pszVolume);
#endif
#if REDCONF_READ_ONLY == 0
int32_t red_transact(const char *pszVolume);
#endif
#if REDCONF_READ_ONLY == 0
int32_t red_settransmask(const char *pszVolume, uint32_t ulEventMask);
#endif
int32_t red_gettransmask(const char *pszVolume, uint32_t *pulEventMask);
int32_t red_statvfs(const char *pszVolume, REDSTATFS *pStatvfs);
int32_t red_open(const char *pszPath, uint32_t ulOpenMode);
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_UNLINK == 1)
int32_t red_unlink(const char *pszPath);
#endif
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_MKDIR == 1)
int32_t red_mkdir(const char *pszPath);
#endif
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_RMDIR == 1)
int32_t red_rmdir(const char *pszPath);
#endif
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_RENAME == 1)
int32_t red_rename(const char *pszOldPath, const char *pszNewPath);
#endif
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_LINK == 1)
int32_t red_link(const char *pszPath, const char *pszHardLink);
#endif
int32_t red_close(int32_t iFildes);
int32_t red_read(int32_t iFildes, void *pBuffer, uint32_t ulLength);
#if REDCONF_READ_ONLY == 0
int32_t red_write(int32_t iFildes, const void *pBuffer, uint32_t ulLength);
#endif
#if REDCONF_READ_ONLY == 0
int32_t red_fsync(int32_t iFildes);
#endif
int64_t red_lseek(int32_t iFildes, int64_t llOffset, REDWHENCE whence);
#if (REDCONF_READ_ONLY == 0) && (REDCONF_API_POSIX_FTRUNCATE == 1)
int32_t red_ftruncate(int32_t iFildes, uint64_t ullSize);
#endif
int32_t red_fstat(int32_t iFildes, REDSTAT *pStat);
#if REDCONF_API_POSIX_READDIR == 1
REDDIR *red_opendir(const char *pszPath);
REDDIRENT *red_readdir(REDDIR *pDirStream);
void red_rewinddir(REDDIR *pDirStream);
int32_t red_closedir(REDDIR *pDirStream);
#endif
REDSTATUS *red_errnoptr(void);
#endif /* REDCONF_API_POSIX */
#ifdef __cplusplus
}
#endif
#endif
|
