Debian Codegraph @

os/+dragonfly/dirfdfs.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use errors;
5 use fs;
6 use io;
7 use path;
8 use rt;
9 use strings;
10 use time;
11 use types::c;
12
13 type os_filesystem = struct {
14 fs: fs::fs,
15 dirfd: int,
16 getdents_bufsz: size,
17 };
18
19 // Opens a file descriptor as an [[fs::fs]]. This file descriptor must be a
20 // directory file. The file will be closed when the fs is closed.
21 export fn dirfdopen(fd: io::file) *fs::fs = {
22 let ofs = alloc(os_filesystem { ... })!;
23 let fs = static_dirfdopen(fd, ofs);
24 fs.close = &fs_close;
25 return fs;
26 };
27
28 fn static_dirfdopen(fd: io::file, filesystem: *os_filesystem) *fs::fs = {
29 *filesystem = os_filesystem {
30 fs = fs::fs {
31 open = &fs_open,
32 openfile = &fs_open_file,
33 create = &fs_create,
34 createfile = &fs_create_file,
35 remove = &fs_remove,
36 rename = &fs_rename,
37 iter = &fs_iter,
38 stat = &fs_stat,
39 readlink = &fs_readlink,
40 mkdir = &fs_mkdir,
41 rmdir = &fs_rmdir,
42 chmod = &fs_chmod,
43 chown = &fs_chown,
44 chtimes = &fs_chtimes,
45 fchtimes = &fs_fchtimes,
46 resolve = &fs_resolve,
47 ...
48 },
49 dirfd = fd,
50 getdents_bufsz = 32768, // 32 KiB
51 };
52 return &filesystem.fs;
53 };
54
55 // Sets the buffer size to use with the getdents(2) system call, for use with
56 // [[fs::iter]]. A larger buffer requires a larger runtime allocation, but can
57 // scan large directories faster. The default buffer size is 32 KiB.
58 //
59 // This function is not portable.
60 export fn dirfdfs_set_getdents_bufsz(fs: *fs::fs, sz: size) void = {
61 assert(fs.open == &fs_open);
62 let fs = fs: *os_filesystem;
63 fs.getdents_bufsz = sz;
64 };
65
66 // Returns an [[io::file]] for this filesystem. This function is not portable.
67 export fn dirfile(fs: *fs::fs) io::file = {
68 assert(fs.open == &fs_open);
69 let fs = fs: *os_filesystem;
70 return fs.dirfd;
71 };
72
73 fn errno_to_fs(err: rt::errno) fs::error = {
74 switch (err) {
75 case rt::ENOENT =>
76 return errors::noentry;
77 case rt::EEXIST =>
78 return errors::exists;
79 case rt::EACCES =>
80 return errors::noaccess;
81 case rt::EBUSY =>
82 return errors::busy;
83 case rt::ENOTDIR =>
84 return fs::wrongtype;
85 case rt::EOPNOTSUPP, rt::ENOSYS =>
86 return errors::unsupported;
87 case rt::EXDEV =>
88 return fs::cannotrename;
89 case =>
90 return errors::errno(err);
91 };
92 };
93
94 fn _fs_open(
95 fs: *fs::fs,
96 path: str,
97 flags: int,
98 mode: uint,
99 ) (io::file | fs::error) = {
100 let fs = fs: *os_filesystem;
101
102 let fd = match (rt::openat(fs.dirfd, path, flags, mode)) {
103 case let err: rt::errno =>
104 return errno_to_fs(err);
105 case let fd: int =>
106 yield fd;
107 };
108
109 return io::fdopen(fd);
110 };
111
112 fn fsflags_to_bsd(flags: fs::flag) (int | errors::unsupported) = {
113 let out = rt::O_NOCTTY | rt::O_CLOEXEC;
114 if (flags & fs::flag::WRONLY == fs::flag::WRONLY) {
115 out |= rt::O_WRONLY;
116 };
117 if (flags & fs::flag::RDWR == fs::flag::RDWR) {
118 out |= rt::O_RDWR;
119 };
120 if (flags & fs::flag::CREATE == fs::flag::CREATE) {
121 out |= rt::O_CREAT;
122 };
123 if (flags & fs::flag::EXCL == fs::flag::EXCL) {
124 out |= rt::O_EXCL;
125 };
126 if (flags & fs::flag::CTTY == fs::flag::CTTY) {
127 out &= ~rt::O_NOCTTY;
128 };
129 if (flags & fs::flag::TRUNC == fs::flag::TRUNC) {
130 out |= rt::O_TRUNC;
131 };
132 if (flags & fs::flag::APPEND == fs::flag::APPEND) {
133 out |= rt::O_APPEND;
134 };
135 if (flags & fs::flag::NONBLOCK == fs::flag::NONBLOCK) {
136 out |= rt::O_NONBLOCK;
137 };
138 if (flags & fs::flag::SYNC == fs::flag::SYNC) {
139 out |= rt::O_SYNC;
140 };
141 if (flags & fs::flag::RSYNC == fs::flag::RSYNC) {
142 out |= rt::O_SYNC;
143 };
144 if (flags & fs::flag::DIRECTORY == fs::flag::DIRECTORY) {
145 out |= rt::O_DIRECTORY;
146 };
147 if (flags & fs::flag::NOFOLLOW == fs::flag::NOFOLLOW) {
148 out |= rt::O_NOFOLLOW;
149 };
150 if (flags & fs::flag::NOCLOEXEC == fs::flag::NOCLOEXEC) {
151 out &= ~rt::O_CLOEXEC;
152 };
153 if (flags & fs::flag::PATH == fs::flag::PATH
154 || flags & fs::flag::NOATIME == fs::flag::NOATIME
155 || flags & fs::flag::TMPFILE == fs::flag::TMPFILE) {
156 return errors::unsupported;
157 };
158 return out;
159 };
160
161 fn bsd_to_fsflags(flags: int) fs::flag = {
162 let out: fs::flag = 0;
163 if (flags & rt::O_WRONLY == rt::O_WRONLY) {
164 out |= fs::flag::WRONLY;
165 };
166 if (flags & rt::O_RDWR == rt::O_RDWR) {
167 out |= fs::flag::RDWR;
168 };
169 if (flags & rt::O_CREAT == rt::O_CREAT) {
170 out |= fs::flag::CREATE;
171 };
172 if (flags & rt::O_EXCL == rt::O_EXCL) {
173 out |= fs::flag::EXCL;
174 };
175 if (flags & rt::O_NOCTTY == 0) {
176 out |= fs::flag::CTTY;
177 };
178 if (flags & rt::O_TRUNC == rt::O_TRUNC) {
179 out |= fs::flag::TRUNC;
180 };
181 if (flags & rt::O_APPEND == rt::O_APPEND) {
182 out |= fs::flag::APPEND;
183 };
184 if (flags & rt::O_NONBLOCK == rt::O_NONBLOCK) {
185 out |= fs::flag::NONBLOCK;
186 };
187 if (flags & rt::O_SYNC == rt::O_SYNC) {
188 out |= fs::flag::SYNC;
189 };
190 if (flags & rt::O_DIRECTORY == rt::O_DIRECTORY) {
191 out |= fs::flag::DIRECTORY;
192 };
193 if (flags & rt::O_NOFOLLOW == rt::O_NOFOLLOW) {
194 out |= fs::flag::NOFOLLOW;
195 };
196 if (flags & rt::O_CLOEXEC == 0) {
197 out |= fs::flag::NOCLOEXEC;
198 };
199 return out;
200 };
201
202 fn fs_open_file(
203 fs: *fs::fs,
204 path: str,
205 flags: fs::flag,
206 ) (io::file | fs::error) = {
207 return _fs_open(fs, path, fsflags_to_bsd(flags)?, 0);
208 };
209
210 fn fs_open(
211 fs: *fs::fs,
212 path: str,
213 flags: fs::flag,
214 ) (io::handle | fs::error) = fs_open_file(fs, path, flags)?;
215
216 fn fs_create_file(
217 fs: *fs::fs,
218 path: str,
219 mode: fs::mode,
220 flags: fs::flag,
221 ) (io::file | fs::error) = {
222 flags |= fs::flag::CREATE;
223 return _fs_open(fs, path, fsflags_to_bsd(flags)?, mode)?;
224 };
225
226 fn fs_create(
227 fs: *fs::fs,
228 path: str,
229 mode: fs::mode,
230 flags: fs::flag,
231 ) (io::handle | fs::error) = {
232 return fs_create_file(fs, path, mode, flags)?;
233 };
234
235 fn fs_remove(fs: *fs::fs, path: str) (void | fs::error) = {
236 let fs = fs: *os_filesystem;
237 match (rt::unlinkat(fs.dirfd, path, 0)) {
238 case let err: rt::errno =>
239 return errno_to_fs(err);
240 case void => void;
241 };
242 };
243
244 fn fs_rename(fs: *fs::fs, oldpath: str, newpath: str) (void | fs::error) = {
245 let fs = fs: *os_filesystem;
246 match (rt::renameat(fs.dirfd, oldpath, fs.dirfd, newpath)) {
247 case let err: rt::errno =>
248 return errno_to_fs(err);
249 case void => void;
250 };
251 };
252
253 fn fs_stat(fs: *fs::fs, path: str) (fs::filestat | fs::error) = {
254 let fs = fs: *os_filesystem;
255 let st = rt::st { ... };
256 match (rt::fstatat(fs.dirfd, path, &st, rt::AT_SYMLINK_NOFOLLOW)) {
257 case let err: rt::errno =>
258 return errno_to_fs(err);
259 case void => void;
260 };
261 return fs::filestat {
262 mask = fs::stat_mask::UID
263 | fs::stat_mask::GID
264 | fs::stat_mask::SIZE
265 | fs::stat_mask::INODE
266 | fs::stat_mask::ATIME
267 | fs::stat_mask::MTIME
268 | fs::stat_mask::CTIME,
269 mode = st.mode: fs::mode,
270 uid = st.uid,
271 gid = st.gid,
272 sz = st.sz: size,
273 inode = st.ino,
274 atime = time::instant {
275 sec = st.atime.tv_sec,
276 nsec = st.atime.tv_nsec,
277 },
278 mtime = time::instant {
279 sec = st.mtime.tv_sec,
280 nsec = st.mtime.tv_nsec,
281 },
282 ctime = time::instant {
283 sec = st.ctime.tv_sec,
284 nsec = st.ctime.tv_nsec,
285 },
286 };
287 };
288
289 fn fs_readlink(fs: *fs::fs, path: str) (str | fs::error) = {
290 let fs = fs: *os_filesystem;
291 static let buf: [rt::PATH_MAX]u8 = [0...];
292 let z = match (rt::readlinkat(fs.dirfd, path, buf[..])) {
293 case let err: rt::errno =>
294 switch (err) {
295 case rt::EINVAL =>
296 return fs::wrongtype;
297 case =>
298 return errno_to_fs(err);
299 };
300 case let z: size =>
301 yield z;
302 };
303 return strings::fromutf8(buf[..z])!;
304 };
305
306 fn fs_rmdir(fs: *fs::fs, path: str) (void | fs::error) = {
307 let fs = fs: *os_filesystem;
308 match (rt::unlinkat(fs.dirfd, path, rt::AT_REMOVEDIR)) {
309 case let err: rt::errno =>
310 return errno_to_fs(err);
311 case void => void;
312 };
313 };
314
315 fn fs_mkdir(fs: *fs::fs, path: str, mode: fs::mode) (void | fs::error) = {
316 let fs = fs: *os_filesystem;
317 match (rt::mkdirat(fs.dirfd, path, mode: uint)) {
318 case let err: rt::errno =>
319 switch (err) {
320 case rt::EISDIR =>
321 return errors::exists;
322 case =>
323 return errno_to_fs(err);
324 };
325 case void => void;
326 };
327 };
328
329 fn fs_chmod(fs: *fs::fs, path: str, mode: fs::mode) (void | fs::error) = {
330 let fs = fs: *os_filesystem;
331 match (rt::fchmodat(fs.dirfd, path, mode: uint, 0)) {
332 case let err: rt::errno =>
333 return errno_to_fs(err);
334 case void => void;
335 };
336 };
337
338 fn fs_fchmod(fd: io::file, mode: fs::mode) (void | fs::error) = {
339 match (rt::fchmod(fd, mode: uint)) {
340 case let err: rt::errno =>
341 return errno_to_fs(err);
342 case void => void;
343 };
344 };
345
346 fn fs_chown(fs: *fs::fs, path: str, uid: uint, gid: uint) (void | fs::error) = {
347 let fs = fs: *os_filesystem;
348 match (rt::fchownat(fs.dirfd, path, uid, gid, 0)) {
349 case let err: rt::errno =>
350 return errno_to_fs(err);
351 case void => void;
352 };
353 };
354
355 fn fs_fchown(fd: io::file, uid: uint, gid: uint) (void | fs::error) = {
356 match (rt::fchown(fd, uid, gid)) {
357 case let err: rt::errno =>
358 return errno_to_fs(err);
359 case void => void;
360 };
361 };
362
363 fn instant_to_timespec(time: (time::instant | void)) rt::timespec = {
364 match (time) {
365 case let t: time::instant =>
366 return time::instant_to_timespec(t);
367 case void =>
368 return rt::timespec{
369 tv_sec = rt::UTIME_OMIT,
370 tv_nsec = rt::UTIME_OMIT
371 };
372 };
373 };
374
375 fn fs_chtimes(fs: *fs::fs, path: str, atime: (time::instant | void),
376 mtime: (time::instant | void)) (void | fs::error) = {
377 let utimes: [2]rt::timespec = [
378 instant_to_timespec(atime),
379 instant_to_timespec(mtime),
380 ];
381 let fs = fs: *os_filesystem;
382 match (rt::utimensat(fs.dirfd, path, &utimes, 0)) {
383 case let err: rt::errno =>
384 return errno_to_fs(err);
385 case void => void;
386 };
387 };
388
389 fn fs_fchtimes(fd: io::file, atime: (time::instant | void),
390 mtime: (time::instant | void)) (void | fs::error) = {
391 let utimes: [2]rt::timespec = [
392 instant_to_timespec(atime),
393 instant_to_timespec(mtime),
394 ];
395 match (rt::futimens(fd, &utimes)) {
396 case let err: rt::errno =>
397 return errno_to_fs(err);
398 case void => void;
399 };
400 };
401
402 fn fs_resolve(fs: *fs::fs, path: str) str = {
403 if (path::abs(path)) {
404 return path;
405 };
406 // XXX: This approach might not be right if this fs is based on a subdir
407 static let buf = path::buffer { ... };
408 path::set(&buf, getcwd(), path)!;
409 return path::string(&buf);
410 };
411
412 fn fs_close(fs: *fs::fs) void = {
413 let fs = fs: *os_filesystem;
414 rt::close(fs.dirfd)!;
415 };
416
417 // Based on musl's readdir
418 type os_iterator = struct {
419 iter: fs::iterator,
420 fd: int,
421 buf_pos: size,
422 buf_end: size,
423 buf: []u8,
424 };
425
426 fn fs_iter(fs: *fs::fs, path: str) (*fs::iterator | fs::error) = {
427 let fs = fs: *os_filesystem;
428 let flags = rt::O_RDONLY | rt::O_CLOEXEC | rt::O_DIRECTORY;
429 let fd: int = match (rt::openat(fs.dirfd, path, flags, 0)) {
430 case let err: rt::errno =>
431 return errno_to_fs(err);
432 case let fd: int =>
433 yield fd;
434 };
435
436 // TODO: handle allocation failure
437 let buf = match (rt::malloc(fs.getdents_bufsz)) {
438 case let v: *opaque =>
439 yield v: *[*]u8;
440 case null =>
441 abort("out of memory");
442 };
443 let iter = alloc(os_iterator {
444 iter = fs::iterator {
445 next = &iter_next,
446 finish = &iter_finish,
447 },
448 fd = fd,
449 buf = buf[..fs.getdents_bufsz],
450 ...
451 })!;
452 return &iter.iter;
453 };
454
455 fn iter_next(iter: *fs::iterator) (fs::dirent | done | fs::error) = {
456 let iter = iter: *os_iterator;
457 if (iter.buf_pos >= iter.buf_end) {
458 let n = match (rt::getdents(iter.fd,
459 iter.buf: *[*]u8, len(iter.buf))) {
460 case let err: rt::errno =>
461 return errno_to_fs(err);
462 case let n: size =>
463 yield n;
464 };
465 if (n == 0) {
466 return done;
467 };
468 iter.buf_end = n;
469 iter.buf_pos = 0;
470 };
471 let de = &iter.buf[iter.buf_pos]: *rt::dragonfly_dirent;
472
473 iter.buf_pos += rt::DIRENT_RECLEN(de.d_namlen);
474
475 let name = c::tostr(&de.d_name: *const c::char)?;
476
477 if (name == "." || name == "..") {
478 return iter_next(iter);
479 };
480
481 let ftype: fs::mode = switch (de.d_type) {
482 case rt::DT_UNKNOWN =>
483 yield fs::mode::UNKNOWN;
484 case rt::DT_FIFO =>
485 yield fs::mode::FIFO;
486 case rt::DT_CHR =>
487 yield fs::mode::CHR;
488 case rt::DT_DIR =>
489 yield fs::mode::DIR;
490 case rt::DT_BLK =>
491 yield fs::mode::BLK;
492 case rt::DT_REG =>
493 yield fs::mode::REG;
494 case rt::DT_LNK =>
495 yield fs::mode::LINK;
496 case rt::DT_SOCK =>
497 yield fs::mode::SOCK;
498 case =>
499 yield fs::mode::UNKNOWN;
500 };
501 return fs::dirent {
502 name = name,
503 ftype = ftype,
504 };
505 };
506
507 fn iter_finish(iter: *fs::iterator) void = {
508 let iter = iter: *os_iterator;
509 rt::close(iter.fd)!;
510 free(iter.buf);
511 free(iter);
512 };