diff options
author | Mike Buland <mike@xagasoft.com> | 2024-07-15 12:59:18 -0700 |
---|---|---|
committer | Mike Buland <mike@xagasoft.com> | 2024-07-15 12:59:18 -0700 |
commit | 499cdaf05204a40d86e0e1b4dd32709b3ab67e20 (patch) | |
tree | 5fa31a6e4b4e2c3abde43b4e52ef3a88f6cab864 /src/extra/myriadfs.cpp | |
parent | 4bf0f0c256693e30017f9bea60cf55aa97f8994a (diff) | |
download | libbu++-499cdaf05204a40d86e0e1b4dd32709b3ab67e20.tar.gz libbu++-499cdaf05204a40d86e0e1b4dd32709b3ab67e20.tar.bz2 libbu++-499cdaf05204a40d86e0e1b4dd32709b3ab67e20.tar.xz libbu++-499cdaf05204a40d86e0e1b4dd32709b3ab67e20.zip |
MyriadFs improvements and new helper tool.
I think the interface could be a lot better...but it does work and we
can use it examine and work with MyriadFs files.
Diffstat (limited to 'src/extra/myriadfs.cpp')
-rw-r--r-- | src/extra/myriadfs.cpp | 334 |
1 files changed, 0 insertions, 334 deletions
diff --git a/src/extra/myriadfs.cpp b/src/extra/myriadfs.cpp deleted file mode 100644 index ff2df3d..0000000 --- a/src/extra/myriadfs.cpp +++ /dev/null | |||
@@ -1,334 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2023 Xagasoft, All rights reserved. | ||
3 | * | ||
4 | * This file is part of the libbu++ library and is released under the | ||
5 | * terms of the license contained in the file LICENSE. | ||
6 | */ | ||
7 | |||
8 | #define _FILE_OFFSET_BITS 64 | ||
9 | #define FUSE_USE_VERSION 26 | ||
10 | |||
11 | #include <fuse.h> | ||
12 | |||
13 | #include <string.h> | ||
14 | #include <errno.h> | ||
15 | |||
16 | #include <bu/file.h> | ||
17 | #include <bu/myriadfs.h> | ||
18 | #include <bu/myriadstream.h> | ||
19 | #include <bu/hash.h> | ||
20 | |||
21 | Bu::File *pF = NULL; | ||
22 | Bu::MyriadFs *pFs = NULL; | ||
23 | |||
24 | typedef Bu::Hash<int64_t, Bu::MyriadStream> FileHash; | ||
25 | FileHash hOpenFiles; | ||
26 | int64_t iNextFileId = 0; | ||
27 | |||
28 | #define TRACE | ||
29 | |||
30 | extern "C" { | ||
31 | static int myriadfs_getattr( const char *sPath, struct stat *stbuf ) | ||
32 | { | ||
33 | #ifdef TRACE | ||
34 | printf("myriadfs_getattr(\"%s\", ... );\n", sPath ); | ||
35 | #endif | ||
36 | try | ||
37 | { | ||
38 | Bu::MyriadFs::Stat st; | ||
39 | pFs->stat( sPath, st ); | ||
40 | stbuf->st_ino = st.iNode; | ||
41 | stbuf->st_mode = st.uPerms; | ||
42 | stbuf->st_nlink = st.iLinks; | ||
43 | stbuf->st_uid = st.iUser; | ||
44 | stbuf->st_gid = st.iGroup; | ||
45 | stbuf->st_rdev = Bu::MyriadFs::devToSys( st.uDev ); | ||
46 | stbuf->st_size = st.iSize; | ||
47 | stbuf->st_blocks = 8; | ||
48 | stbuf->st_atime = st.iATime; | ||
49 | stbuf->st_mtime = st.iMTime; | ||
50 | stbuf->st_ctime = st.iCTime; | ||
51 | return 0; | ||
52 | } | ||
53 | catch(...) | ||
54 | { | ||
55 | return -ENOENT; | ||
56 | } | ||
57 | } | ||
58 | |||
59 | static int myriadfs_readdir( const char *sPath, void *buf, | ||
60 | fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi ) | ||
61 | { | ||
62 | #ifdef TRACE | ||
63 | printf("myriadfs_readdir(\"%s\", ... );\n", sPath ); | ||
64 | #endif | ||
65 | Bu::MyriadFs::Dir lDir = pFs->readDir( sPath ); | ||
66 | filler( buf, ".", NULL, 0 ); | ||
67 | filler( buf, "..", NULL, 0 ); | ||
68 | for( Bu::MyriadFs::Dir::iterator i = lDir.begin(); i; i++ ) | ||
69 | { | ||
70 | filler( buf, (*i).sName.getStr(), NULL, 0 ); | ||
71 | } | ||
72 | |||
73 | return 0; | ||
74 | } | ||
75 | |||
76 | static int myriadfs_mkdir( const char *sPath, mode_t uMode ) | ||
77 | { | ||
78 | #ifdef TRACE | ||
79 | printf("myriadfs_mkdir(\"%s\", 0%o );\n", sPath, uMode ); | ||
80 | #endif | ||
81 | pFs->mkDir( sPath, uMode ); | ||
82 | return 0; | ||
83 | } | ||
84 | |||
85 | static int myriadfs_open( const char *sPath, struct fuse_file_info *fi ) | ||
86 | { | ||
87 | #ifdef TRACE | ||
88 | printf("myriadfs_open(\"%s\", ... );\n", sPath ); | ||
89 | #endif | ||
90 | try | ||
91 | { | ||
92 | Bu::MyriadStream ms = pFs->open( sPath, 0 ); | ||
93 | fi->fh = iNextFileId; | ||
94 | hOpenFiles.insert( iNextFileId++, ms ); | ||
95 | // printf("File '%s' opened, %d files open now.\n", | ||
96 | // sPath, hOpenFiles.getSize() ); | ||
97 | return 0; | ||
98 | } | ||
99 | catch(...) | ||
100 | { | ||
101 | return -EACCES; | ||
102 | } | ||
103 | } | ||
104 | |||
105 | static int myriadfs_read( const char *sPath, char *buf, size_t iSize, | ||
106 | off_t iOffset, struct fuse_file_info *fi ) | ||
107 | { | ||
108 | #ifdef TRACE | ||
109 | printf("myriadfs_read(\"%s\", ..., %d, %d, ... );\n", sPath, iSize, | ||
110 | iOffset ); | ||
111 | #endif | ||
112 | Bu::MyriadStream &ms = hOpenFiles.get( fi->fh ); | ||
113 | ms.setPos( iOffset ); | ||
114 | return ms.read( buf, iSize ); | ||
115 | } | ||
116 | |||
117 | static int myriadfs_write( const char *sPath, const char *buf, size_t iSize, | ||
118 | off_t iOffset, struct fuse_file_info *fi ) | ||
119 | { | ||
120 | #ifdef TRACE | ||
121 | printf("myriadfs_write(\"%s\", ..., %d, %d, ... );\n", sPath, iSize, | ||
122 | iOffset ); | ||
123 | #endif | ||
124 | Bu::MyriadStream &ms = hOpenFiles.get( fi->fh ); | ||
125 | ms.setPos( iOffset ); | ||
126 | return ms.write( buf, iSize ); | ||
127 | } | ||
128 | |||
129 | static int myriadfs_create( const char *sPath, mode_t uPerms, | ||
130 | struct fuse_file_info *fi ) | ||
131 | { | ||
132 | #ifdef TRACE | ||
133 | printf("myriadfs_create(\"%s\", 0%o, ... );\n", sPath, uPerms ); | ||
134 | #endif | ||
135 | try | ||
136 | { | ||
137 | Bu::MyriadStream ms = pFs->open( sPath, 0, uPerms ); | ||
138 | fi->fh = iNextFileId; | ||
139 | hOpenFiles.insert( iNextFileId++, ms ); | ||
140 | // printf("File '%s' created, %d files open now.\n", | ||
141 | // sPath, hOpenFiles.getSize() ); | ||
142 | return 0; | ||
143 | } | ||
144 | catch(...) | ||
145 | { | ||
146 | return -EACCES; | ||
147 | } | ||
148 | } | ||
149 | |||
150 | static int myriadfs_mknod( const char *sPath, mode_t uPerms, dev_t Dev ) | ||
151 | { | ||
152 | #ifdef TRACE | ||
153 | printf("myriadfs_mknod(\"%s\", 0%o, %x );\n", sPath, uPerms, Dev ); | ||
154 | #endif | ||
155 | try | ||
156 | { | ||
157 | pFs->create( sPath, uPerms, Bu::MyriadFs::sysToDev( Dev ) ); | ||
158 | return 0; | ||
159 | } | ||
160 | catch(...) | ||
161 | { | ||
162 | return -EACCES; | ||
163 | } | ||
164 | } | ||
165 | |||
166 | static int myriadfs_release( const char *sPath, struct fuse_file_info *fi ) | ||
167 | { | ||
168 | #ifdef TRACE | ||
169 | printf("myriadfs_release(\"%s\", ... );\n", sPath ); | ||
170 | #endif | ||
171 | hOpenFiles.erase( fi->fh ); | ||
172 | // printf("File '%s' released, %d files open now.\n", | ||
173 | // sPath, hOpenFiles.getSize() ); | ||
174 | |||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | static int myriadfs_utimens( const char *sPath, | ||
179 | const struct timespec tv[2] ) | ||
180 | { | ||
181 | #ifdef TRACE | ||
182 | printf("myriadfs_utimens(\"%s\", ... );\n", sPath ); | ||
183 | #endif | ||
184 | try | ||
185 | { | ||
186 | pFs->setTimes( sPath, tv[0].tv_sec, tv[1].tv_sec ); | ||
187 | } | ||
188 | catch(...) | ||
189 | { | ||
190 | return -EACCES; | ||
191 | } | ||
192 | return 0; | ||
193 | } | ||
194 | |||
195 | static int myriadfs_unlink( const char *sPath ) | ||
196 | { | ||
197 | #ifdef TRACE | ||
198 | printf("myriadfs_unlink(\"%s\");\n", sPath ); | ||
199 | #endif | ||
200 | try | ||
201 | { | ||
202 | pFs->unlink( sPath ); | ||
203 | } | ||
204 | catch( Bu::MyriadFsException &e ) | ||
205 | { | ||
206 | printf("MyriadFsException: %s\n", e.what() ); | ||
207 | return -EACCES; | ||
208 | } | ||
209 | return 0; | ||
210 | } | ||
211 | |||
212 | static int myriadfs_symlink( const char *sTarget, const char *sPath ) | ||
213 | { | ||
214 | #ifdef TRACE | ||
215 | printf("myriadfs_symlink(\"%s\", \"%s\");\n", sTarget, sPath ); | ||
216 | #endif | ||
217 | try | ||
218 | { | ||
219 | pFs->mkSymLink( sTarget, sPath ); | ||
220 | } | ||
221 | catch( Bu::MyriadFsException &e ) | ||
222 | { | ||
223 | printf("MyriadFsException: %s\n", e.what() ); | ||
224 | return -EACCES; | ||
225 | } | ||
226 | return 0; | ||
227 | } | ||
228 | |||
229 | static int myriadfs_readlink( const char *sPath, char *sOut, size_t s ) | ||
230 | { | ||
231 | #ifdef TRACE | ||
232 | printf("myriadfs_readlink(\"%s\", ... );\n", sPath ); | ||
233 | #endif | ||
234 | try | ||
235 | { | ||
236 | Bu::String sTrg = pFs->readSymLink( sPath ); | ||
237 | size_t iLen = (s-1>sTrg.getSize())?(sTrg.getSize()):(s-1); | ||
238 | memcpy( sOut, sTrg.getStr(), iLen ); | ||
239 | sOut[iLen] = '\0'; | ||
240 | } | ||
241 | catch( Bu::MyriadFsException &e ) | ||
242 | { | ||
243 | printf("MyriadFsException: %s\n", e.what() ); | ||
244 | return -EACCES; | ||
245 | } | ||
246 | return 0; | ||
247 | } | ||
248 | |||
249 | static int myriadfs_truncate( const char *sPath, off_t iSize ) | ||
250 | { | ||
251 | #ifdef TRACE | ||
252 | printf("myriadfs_truncate(\"%s\", %d );\n", sPath, iSize ); | ||
253 | #endif | ||
254 | |||
255 | try | ||
256 | { | ||
257 | pFs->setFileSize( sPath, iSize ); | ||
258 | } | ||
259 | catch( Bu::MyriadFsException &e ) | ||
260 | { | ||
261 | printf("MyriadFsException: %s\n", e.what() ); | ||
262 | return -ENOENT; | ||
263 | } | ||
264 | return 0; | ||
265 | } | ||
266 | |||
267 | static int myriadfs_link( const char *sTarget, const char *sPath ) | ||
268 | { | ||
269 | #ifdef TRACE | ||
270 | printf("myriadfs_link(\"%s\", \"%s\");\n", sTarget, sPath ); | ||
271 | #endif | ||
272 | |||
273 | try | ||
274 | { | ||
275 | pFs->mkHardLink( sTarget, sPath ); | ||
276 | } | ||
277 | catch( Bu::MyriadFsException &e ) | ||
278 | { | ||
279 | printf("MyriadFsException: %s\n", e.what() ); | ||
280 | return -EACCES; | ||
281 | } | ||
282 | return 0; | ||
283 | } | ||
284 | |||
285 | static int myriadfs_rename( const char *sFrom, const char *sTo ) | ||
286 | { | ||
287 | #ifdef TRACE | ||
288 | printf("myriadfs_rename(\"%s\", \"%s\");\n", sFrom, sTo ); | ||
289 | #endif | ||
290 | |||
291 | try | ||
292 | { | ||
293 | pFs->rename( sFrom, sTo ); | ||
294 | } | ||
295 | catch( Bu::MyriadFsException &e ) | ||
296 | { | ||
297 | printf("MyriadFsException: %s\n", e.what() ); | ||
298 | return -EACCES; | ||
299 | } | ||
300 | return 0; | ||
301 | } | ||
302 | |||
303 | static struct fuse_operations myriadfs_oper; | ||
304 | |||
305 | int main( int argc, char *argv[] ) | ||
306 | { | ||
307 | pF = new Bu::File("store.myr", Bu::File::Read|Bu::File::Write|Bu::File::Create ); | ||
308 | pFs = new Bu::MyriadFs( *pF, 512 ); | ||
309 | memset( &myriadfs_oper, sizeof(myriadfs_oper), 0 ); | ||
310 | myriadfs_oper.getattr = myriadfs_getattr; | ||
311 | myriadfs_oper.readdir = myriadfs_readdir; | ||
312 | myriadfs_oper.mkdir = myriadfs_mkdir; | ||
313 | myriadfs_oper.open = myriadfs_open; | ||
314 | myriadfs_oper.read = myriadfs_read; | ||
315 | myriadfs_oper.write = myriadfs_write; | ||
316 | myriadfs_oper.create = myriadfs_create; | ||
317 | myriadfs_oper.mknod = myriadfs_mknod; | ||
318 | myriadfs_oper.release = myriadfs_release; | ||
319 | myriadfs_oper.utimens = myriadfs_utimens; | ||
320 | myriadfs_oper.unlink = myriadfs_unlink; | ||
321 | myriadfs_oper.rmdir = myriadfs_unlink; | ||
322 | myriadfs_oper.symlink = myriadfs_symlink; | ||
323 | myriadfs_oper.readlink = myriadfs_readlink; | ||
324 | myriadfs_oper.truncate = myriadfs_truncate; | ||
325 | myriadfs_oper.link = myriadfs_link; | ||
326 | myriadfs_oper.rename = myriadfs_rename; | ||
327 | printf("Starting fuse_main.\n"); | ||
328 | int iRet = fuse_main( argc, argv, &myriadfs_oper, NULL ); | ||
329 | printf("Done with fuse_main.\n"); | ||
330 | delete pFs; | ||
331 | delete pF; | ||
332 | return iRet; | ||
333 | } | ||
334 | } | ||