Debian Codegraph @

os/+netbsd/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::DSYNC == fs::flag::DSYNC) {
139 out |= rt::O_DSYNC;
140 };
141 if (flags & fs::flag::SYNC == fs::flag::SYNC) {
142 out |= rt::O_SYNC;
143 };
144 if (flags & fs::flag::RSYNC == fs::flag::RSYNC) {
145 out |= rt::O_SYNC;
146 };
147 if (flags & fs::flag::DIRECTORY == fs::flag::DIRECTORY) {
148 out |= rt::O_DIRECTORY;
149 };
150 if (flags & fs::flag::NOFOLLOW == fs::flag::NOFOLLOW) {
151 out |= rt::O_NOFOLLOW;
152 };
153 if (flags & fs::flag::NOCLOEXEC == fs::flag::NOCLOEXEC) {
154 out &= ~rt::O_CLOEXEC;
155 };
156 if (flags & fs::flag::PATH == fs::flag::PATH
157 || flags & fs::flag::NOATIME == fs::flag::NOATIME
158 || flags & fs::flag::TMPFILE == fs::flag::TMPFILE) {
159 return errors::unsupported;
160 };
161 return out;
162 };
163
164 fn bsd_to_fsflags(flags: int) fs::flag = {
165 let out: fs::flag = 0;
166 if (flags & rt::O_WRONLY == rt::O_WRONLY) {
167 out |= fs::flag::WRONLY;
168 };
169 if (flags & rt::O_RDWR == rt::O_RDWR) {
170 out |= fs::flag::RDWR;
171 };
172 if (flags & rt::O_CREAT == rt::O_CREAT) {
173 out |= fs::flag::CREATE;
174 };
175 if (flags & rt::O_EXCL == rt::O_EXCL) {
176 out |= fs::flag::EXCL;
177 };
178 if (flags & rt::O_NOCTTY == 0) {
179 out |= fs::flag::CTTY;
180 };
181 if (flags & rt::O_TRUNC == rt::O_TRUNC) {
182 out |= fs::flag::TRUNC;
183 };
184 if (flags & rt::O_APPEND == rt::O_APPEND) {
185 out |= fs::flag::APPEND;
186 };
187 if (flags & rt::O_NONBLOCK == rt::O_NONBLOCK) {
188 out |= fs::flag::NONBLOCK;
189 };
190 if (flags & rt::O_DSYNC == rt::O_DSYNC) {
191 out |= fs::flag::DSYNC;
192 };
193 if (flags & rt::O_SYNC == rt::O_SYNC) {
194 out |= fs::flag::SYNC;
195 };
196 if (flags & rt::O_DIRECTORY == rt::O_DIRECTORY) {
197 out |= fs::flag::DIRECTORY;
198 };
199 if (flags & rt::O_NOFOLLOW == rt::O_NOFOLLOW) {
200 out |= fs::flag::NOFOLLOW;
201 };
202 if (flags & rt::O_CLOEXEC == 0) {
203 out |= fs::flag::NOCLOEXEC;
204 };
205 return out;
206 };
207
208 fn fs_open_file(
209 fs: *fs::fs,
210 path: str,
211 flags: fs::flag,
212 ) (io::file | fs::error) = {
213 return _fs_open(fs, path, fsflags_to_bsd(flags)?, 0);
214 };
215
216 fn fs_open(
217 fs: *fs::fs,
218 path: str,
219 flags: fs::flag,
220 ) (io::handle | fs::error) = fs_open_file(fs, path, flags)?;
221
222 fn fs_create_file(
223 fs: *fs::fs,
224 path: str,
225 mode: fs::mode,
226 flags: fs::flag,
227 ) (io::file | fs::error) = {
228 flags |= fs::flag::CREATE;
229 return _fs_open(fs, path, fsflags_to_bsd(flags)?, mode)?;
230 };
231
232 fn fs_create(
233 fs: *fs::fs,
234 path: str,
235 mode: fs::mode,
236 flags: fs::flag,
237 ) (io::handle | fs::error) = {
238 return fs_create_file(fs, path, mode, flags)?;
239 };
240
241 fn fs_remove(fs: *fs::fs, path: str) (void | fs::error) = {
242 let fs = fs: *os_filesystem;
243 match (rt::unlinkat(fs.dirfd, path, 0)) {
244 case let err: rt::errno =>
245 return errno_to_fs(err);
246 case void => void;
247 };
248 };
249
250 fn fs_rename(fs: *fs::fs, oldpath: str, newpath: str) (void | fs::error) = {
251 let fs = fs: *os_filesystem;
252 match (rt::renameat(fs.dirfd, oldpath, fs.dirfd, newpath)) {
253 case let err: rt::errno =>
254 return errno_to_fs(err);
255 case void => void;
256 };
257 };
258
259 fn fs_stat(fs: *fs::fs, path: str) (fs::filestat | fs::error) = {
260 let fs = fs: *os_filesystem;
261 let st = rt::st { ... };
262 match (rt::fstatat(fs.dirfd, path, &st, rt::AT_SYMLINK_NOFOLLOW)) {
263 case let err: rt::errno =>
264 return errno_to_fs(err);
265 case void => void;
266 };
267 return fs::filestat {
268 mask = fs::stat_mask::UID
269 | fs::stat_mask::GID
270 | fs::stat_mask::SIZE
271 | fs::stat_mask::INODE
272 | fs::stat_mask::ATIME
273 | fs::stat_mask::MTIME
274 | fs::stat_mask::CTIME,
275 mode = st.mode: fs::mode,
276 uid = st.uid,
277 gid = st.gid,
278 sz = st.sz: size,
279 inode = st.ino,
280 atime = time::instant {
281 sec = st.atime.tv_sec,
282 nsec = st.atime.tv_nsec,
283 },
284 mtime = time::instant {
285 sec = st.mtime.tv_sec,
286 nsec = st.mtime.tv_nsec,
287 },
288 ctime = time::instant {
289 sec = st.ctime.tv_sec,
290 nsec = st.ctime.tv_nsec,
291 },
292 };
293 };
294
295 fn fs_readlink(fs: *fs::fs, path: str) (str | fs::error) = {
296 let fs = fs: *os_filesystem;
297 static let buf: [rt::PATH_MAX]u8 = [0...];
298 let z = match (rt::readlinkat(fs.dirfd, path, buf[..])) {
299 case let err: rt::errno =>
300 switch (err) {
301 case rt::EINVAL =>
302 return fs::wrongtype;
303 case =>
304 return errno_to_fs(err);
305 };
306 case let z: size =>
307 yield z;
308 };
309 return strings::fromutf8(buf[..z])!;
310 };
311
312 fn fs_rmdir(fs: *fs::fs, path: str) (void | fs::error) = {
313 let fs = fs: *os_filesystem;
314 match (rt::unlinkat(fs.dirfd, path, rt::AT_REMOVEDIR)) {
315 case let err: rt::errno =>
316 return errno_to_fs(err);
317 case void => void;
318 };
319 };
320
321 fn fs_mkdir(fs: *fs::fs, path: str, mode: fs::mode) (void | fs::error) = {
322 let fs = fs: *os_filesystem;
323 match (rt::mkdirat(fs.dirfd, path, mode: uint)) {
324 case let err: rt::errno =>
325 switch (err) {
326 case rt::EISDIR =>
327 return errors::exists;
328 case =>
329 return errno_to_fs(err);
330 };
331 case void => void;
332 };
333 };
334
335 fn fs_chmod(fs: *fs::fs, path: str, mode: fs::mode) (void | fs::error) = {
336 let fs = fs: *os_filesystem;
337 match (rt::fchmodat(fs.dirfd, path, mode: uint, 0)) {
338 case let err: rt::errno =>
339 return errno_to_fs(err);
340 case void => void;
341 };
342 };
343
344 fn fs_fchmod(fd: io::file, mode: fs::mode) (void | fs::error) = {
345 match (rt::fchmod(fd, mode: uint)) {
346 case let err: rt::errno =>
347 return errno_to_fs(err);
348 case void => void;
349 };
350 };
351
352 fn fs_chown(fs: *fs::fs, path: str, uid: uint, gid: uint) (void | fs::error) = {
353 let fs = fs: *os_filesystem;
354 match (rt::fchownat(fs.dirfd, path, uid, gid, 0)) {
355 case let err: rt::errno =>
356 return errno_to_fs(err);
357 case void => void;
358 };
359 };
360
361 fn fs_fchown(fd: io::file, uid: uint, gid: uint) (void | fs::error) = {
362 match (rt::fchown(fd, uid, gid)) {
363 case let err: rt::errno =>
364 return errno_to_fs(err);
365 case void => void;
366 };
367 };
368
369 fn instant_to_timespec(time: (time::instant | void)) rt::timespec = {
370 match (time) {
371 case let t: time::instant =>
372 return time::instant_to_timespec(t);
373 case void =>
374 return rt::timespec{
375 tv_sec = rt::UTIME_OMIT,
376 tv_nsec = rt::UTIME_OMIT
377 };
378 };
379 };
380
381 fn fs_chtimes(fs: *fs::fs, path: str, atime: (time::instant | void),
382 mtime: (time::instant | void)) (void | fs::error) = {
383 let utimes: [2]rt::timespec = [
384 instant_to_timespec(atime),
385 instant_to_timespec(mtime),
386 ];
387 let fs = fs: *os_filesystem;
388 match (rt::utimensat(fs.dirfd, path, &utimes, 0)) {
389 case let err: rt::errno =>
390 return errno_to_fs(err);
391 case void => void;
392 };
393 };
394
395 fn fs_fchtimes(fd: io::file, atime: (time::instant | void),
396 mtime: (time::instant | void)) (void | fs::error) = {
397 let utimes: [2]rt::timespec = [
398 instant_to_timespec(atime),
399 instant_to_timespec(mtime),
400 ];
401 match (rt::futimens(fd, &utimes)) {
402 case let err: rt::errno =>
403 return errno_to_fs(err);
404 case void => void;
405 };
406 };
407
408 // TODO: cannot handle errors, i.e. path too long or cannot resolve.
409 fn fs_resolve(fs: *fs::fs, path: str) str = {
410 let fs = fs: *os_filesystem;
411 static let buf = path::buffer { ... };
412
413 if (path::abs(path)) {
414 return path;
415 };
416
417 if (fs.dirfd == rt::AT_FDCWD) {
418 path::set(&buf, getcwd(), path)!;
419 } else {
420 // XXX: this is the best we can for now. we should probably
421 // return an error
422 path::set(&buf, "<unknown>", path)!;
423 };
424
425 return path::string(&buf);
426 };
427
428 fn fs_close(fs: *fs::fs) void = {
429 let fs = fs: *os_filesystem;
430 rt::close(fs.dirfd)!;
431 };
432
433 // Based on musl's readdir
434 type os_iterator = struct {
435 iter: fs::iterator,
436 fd: int,
437 buf_pos: size,
438 buf_end: size,
439 buf: []u8,
440 };
441
442 fn fs_iter(fs: *fs::fs, path: str) (*fs::iterator | fs::error) = {
443 let fs = fs: *os_filesystem;
444 let flags = rt::O_RDONLY | rt::O_CLOEXEC | rt::O_DIRECTORY;
445 let fd: int = match (rt::openat(fs.dirfd, path, flags, 0)) {
446 case let err: rt::errno =>
447 return errno_to_fs(err);
448 case let fd: int =>
449 yield fd;
450 };
451
452 // TODO: handle allocation failure
453 let buf = match (rt::malloc(fs.getdents_bufsz)) {
454 case let v: *opaque =>
455 yield v: *[*]u8;
456 case null =>
457 abort("out of memory");
458 };
459 let iter = alloc(os_iterator {
460 iter = fs::iterator {
461 next = &iter_next,
462 finish = &iter_finish,
463 },
464 fd = fd,
465 buf = buf[..fs.getdents_bufsz],
466 ...
467 })!;
468 return &iter.iter;
469 };
470
471 fn iter_next(iter: *fs::iterator) (fs::dirent | done | fs::error) = {
472 let iter = iter: *os_iterator;
473 if (iter.buf_pos >= iter.buf_end) {
474 let n = match (rt::getdents(iter.fd,
475 iter.buf: *[*]u8, len(iter.buf))) {
476 case let err: rt::errno =>
477 return errno_to_fs(err);
478 case let n: size =>
479 yield n;
480 };
481 if (n == 0) {
482 return done;
483 };
484 iter.buf_end = n;
485 iter.buf_pos = 0;
486 };
487 let de = &iter.buf[iter.buf_pos]: *rt::dirent;
488 iter.buf_pos += de.d_reclen;
489 let name = c::tostr(&de.d_name: *const c::char)?;
490 if (name == "." || name == "..") {
491 return iter_next(iter);
492 };
493
494 let ftype: fs::mode = switch (de.d_type) {
495 case rt::DT_UNKNOWN =>
496 yield fs::mode::UNKNOWN;
497 case rt::DT_FIFO =>
498 yield fs::mode::FIFO;
499 case rt::DT_CHR =>
500 yield fs::mode::CHR;
501 case rt::DT_DIR =>
502 yield fs::mode::DIR;
503 case rt::DT_BLK =>
504 yield fs::mode::BLK;
505 case rt::DT_REG =>
506 yield fs::mode::REG;
507 case rt::DT_LNK =>
508 yield fs::mode::LINK;
509 case rt::DT_SOCK =>
510 yield fs::mode::SOCK;
511 case =>
512 yield fs::mode::UNKNOWN;
513 };
514 return fs::dirent {
515 name = name,
516 ftype = ftype,
517 };
518 };
519
520 fn iter_finish(iter: *fs::iterator) void = {
521 let iter = iter: *os_iterator;
522 rt::close(iter.fd)!;
523 free(iter.buf);
524 free(iter);
525 };