L4Re Operating System Framework
Interface and Usage Documentation
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
vfs.h
1/*
2 * (c) 2010 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
3 * Alexander Warg <warg@os.inf.tu-dresden.de>
4 * economic rights: Technische Universität Dresden (Germany)
5 *
6 * License: see LICENSE.spdx (in this directory or the directories above)
7 */
8#pragma once
9
10#include <l4/sys/compiler.h>
11
12#include <unistd.h>
13#include <stdarg.h>
14#include <fcntl.h>
15#include <sys/stat.h>
16#include <sys/mman.h>
17#include <sys/socket.h>
18#include <utime.h>
19#include <errno.h>
20
21#ifndef AT_FDCWD
22# define AT_FDCWD -100
23#endif
24
25#ifdef __cplusplus
26
27#include <l4/sys/capability>
28#include <l4/re/cap_alloc>
29#include <l4/re/dataspace>
30#include <l4/cxx/pair>
31#include <l4/cxx/ref_ptr>
32
33namespace L4Re {
37namespace Vfs {
38
39class Mount_tree;
40class File;
41
52{
53public:
59 enum Ready_type : unsigned
60 {
61 Read = 0,
62 Write,
63 Exception
64 };
65
66 virtual ~Generic_file() noexcept = 0;
67
79 virtual int unlock_all_locks() noexcept = 0;
80
89 virtual int fstat64(struct stat64 *buf) const noexcept = 0;
90
96 virtual int fchmod(mode_t) noexcept = 0;
97
107 virtual int get_status_flags() const noexcept = 0;
108
124 virtual int set_status_flags(long flags) noexcept = 0;
125
126 virtual int utime(const struct utimbuf *) noexcept = 0;
127 virtual int utimes(const struct timeval [2]) noexcept = 0;
128 virtual ssize_t readlink(char *, size_t) = 0;
129
145 virtual bool check_ready(Ready_type rt) noexcept = 0;
146};
147
148inline
149Generic_file::~Generic_file() noexcept
150{}
151
160{
161public:
162 virtual ~Directory() noexcept = 0;
163
177 virtual int faccessat(const char *path, int mode, int flags) noexcept = 0;
178
191 virtual int mkdir(const char *path, mode_t mode) noexcept = 0;
192
203 virtual int unlink(const char *path) noexcept = 0;
204
218 virtual int rename(const char *src_path, const char *dst_path) noexcept = 0;
219
233 virtual int link(const char *src_path, const char *dst_path) noexcept = 0;
234
247 virtual int symlink(const char *src_path, const char *dst_path) noexcept = 0;
248
259 virtual int rmdir(const char *path) noexcept = 0;
260 virtual int openat(const char *path, int flags, mode_t mode,
261 cxx::Ref_ptr<File> *f) noexcept = 0;
262
263 virtual ssize_t getdents(char *buf, size_t sizebytes) noexcept = 0;
264
265 virtual int fchmodat(const char *pathname,
266 mode_t mode, int flags) noexcept = 0;
267
268 virtual int utimensat(const char *pathname,
269 const struct timespec times[2], int flags) noexcept = 0;
270
274 virtual int get_entry(const char *, int, mode_t, cxx::Ref_ptr<File> *) noexcept = 0;
275};
276
277inline
278Directory::~Directory() noexcept
279{}
280
287{
288public:
289 virtual ~Regular_file() noexcept = 0;
290
301 virtual L4::Cap<L4Re::Dataspace> data_space() noexcept = 0;
302
312 virtual ssize_t readv(const struct iovec*, int iovcnt) noexcept = 0;
313
324 virtual ssize_t writev(const struct iovec*, int iovcnt) noexcept = 0;
325
326 virtual ssize_t preadv(const struct iovec *iov, int iovcnt, off64_t offset) noexcept = 0;
327 virtual ssize_t pwritev(const struct iovec *iov, int iovcnt, off64_t offset) noexcept = 0;
328
336 virtual off64_t lseek64(off64_t, int) noexcept = 0;
337
338
346 virtual int ftruncate64(off64_t pos) noexcept = 0;
347
353 virtual int fsync() const noexcept = 0;
354
360 virtual int fdatasync() const noexcept = 0;
361
371 virtual int get_lock(struct flock64 *lock) noexcept = 0;
372
381 virtual int set_lock(struct flock64 *lock, bool wait) noexcept = 0;
382};
383
384inline
385Regular_file::~Regular_file() noexcept
386{}
387
388class Socket
389{
390public:
391 virtual ~Socket() noexcept = 0;
392 virtual int bind(sockaddr const *, socklen_t) noexcept = 0;
393 virtual int connect(sockaddr const *, socklen_t) noexcept = 0;
394 virtual ssize_t send(void const *, size_t, int) noexcept = 0;
395 virtual ssize_t recv(void *, size_t, int) noexcept = 0;
396 virtual ssize_t sendto(void const *, size_t, int, sockaddr const *, socklen_t) noexcept = 0;
397 virtual ssize_t recvfrom(void *, size_t, int, sockaddr *, socklen_t *) noexcept = 0;
398 virtual ssize_t sendmsg(msghdr const *, int) noexcept = 0;
399 virtual ssize_t recvmsg(msghdr *, int) noexcept = 0;
400 virtual int getsockopt(int level, int opt, void *, socklen_t *) noexcept = 0;
401 virtual int setsockopt(int level, int opt, void const *, socklen_t) noexcept = 0;
402 virtual int listen(int) noexcept = 0;
403 virtual int accept(sockaddr *addr, socklen_t *) noexcept = 0;
404 virtual int shutdown(int) noexcept = 0;
405
406 virtual int getsockname(sockaddr *, socklen_t *) noexcept = 0;
407 virtual int getpeername(sockaddr *, socklen_t *) noexcept = 0;
408};
409
410inline
411Socket::~Socket() noexcept
412{}
413
420{
421public:
422 virtual ~Special_file() noexcept = 0;
423
434 virtual int ioctl(unsigned long cmd, va_list args) noexcept = 0;
435};
436
437inline
438Special_file::~Special_file() noexcept
439{}
440
454class File :
455 public Generic_file,
456 public Regular_file,
457 public Directory,
458 public Special_file,
459 public Socket
460{
461 friend class Mount_tree;
462
463private:
464 void operator = (File const &);
465
466protected:
467 File() noexcept : _ref_cnt(0) {}
468 File(File const &)
469 : Generic_file(),Regular_file(), Directory(), Special_file(), _ref_cnt(0)
470 {}
471
472public:
473
474 const char *get_mount(const char *path, cxx::Ref_ptr<File> *dir,
475 cxx::Ref_ptr<Mount_tree> *mt = 0) noexcept;
476
477 int openat(const char *path, int flags, mode_t mode,
478 cxx::Ref_ptr<File> *f) noexcept override;
479
480 void add_ref() noexcept { ++_ref_cnt; }
481 int remove_ref() noexcept { return --_ref_cnt; }
482
483 virtual ~File() noexcept = 0;
484
485 cxx::Ref_ptr<Mount_tree> mount_tree() const noexcept
486 { return _mount_tree; }
487
488private:
489 int _ref_cnt;
490 cxx::Ref_ptr<Mount_tree> _mount_tree;
491};
492
493inline
494File::~File() noexcept
495{}
496
497class Path
498{
499private:
500 char const *_p;
501 unsigned _l;
502
503public:
504 Path() noexcept : _p(0), _l(0) {}
505
506 explicit Path(char const *p) noexcept : _p(p)
507 { for (_l = 0; *p; ++p, ++_l) ; }
508
509 Path(char const *p, unsigned l) noexcept : _p(p), _l(l)
510 {}
511
512 static bool __is_sep(char s) noexcept;
513
514 Path cmp_path(char const *prefix) const noexcept;
515
516 struct Invalid_ptr;
517 operator Invalid_ptr const * () const
518 { return reinterpret_cast<Invalid_ptr const *>(_p); }
519
520 unsigned length() const { return _l; }
521 char const *path() const { return _p; }
522
523 bool empty() const { return _l == 0; }
524
525 bool is_sep(unsigned offset) const { return __is_sep(_p[offset]); }
526
527 bool strip_sep()
528 {
529 bool s = false;
530 for (; __is_sep(*_p) && _l; ++_p, --_l)
531 s = true;
532 return s;
533 }
534
535 Path first() const
536 {
537 unsigned i;
538 for (i = 0; i < _l && !is_sep(i); ++i)
539 ;
540
541 return Path(_p, i);
542 }
543
544 Path strip_first()
545 {
546 Path r = first();
547 _p += r.length();
548 _l -= r.length();
549 strip_sep();
550 return r;
551 }
552
553};
554
555
562class Mount_tree
563{
564public:
565
566 explicit Mount_tree(char *n) noexcept;
567
568 Path lookup(Path const &path, cxx::Ref_ptr<Mount_tree> *mt,
569 cxx::Ref_ptr<Mount_tree> *mp = 0) noexcept;
570
571 Path find(Path const &p, cxx::Ref_ptr<Mount_tree> *t) noexcept;
572
573 cxx::Ref_ptr<File> mount() const
574 { return _mount; }
575
576 void mount(cxx::Ref_ptr<File> const &m)
577 {
578 m->_mount_tree = cxx::ref_ptr(this);
579 _mount = m;
580 }
581
582 static int create_tree(cxx::Ref_ptr<Mount_tree> const &root,
583 char const *path,
584 cxx::Ref_ptr<File> const &dir) noexcept;
585
586 void add_child_node(cxx::Ref_ptr<Mount_tree> const &cld);
587
588 virtual ~Mount_tree() noexcept = 0;
589
590 void add_ref() noexcept { ++_ref_cnt; }
591 int remove_ref() noexcept { return --_ref_cnt; }
592
593private:
594 friend class Real_mount_tree;
595
596 int _ref_cnt;
597 char *_name;
600 cxx::Ref_ptr<File> _mount;
601};
602
603inline
604Mount_tree::~Mount_tree() noexcept
605{}
606
607inline bool
608Path::__is_sep(char s) noexcept
609{ return s == '/'; }
610
611inline Path
612Path::cmp_path(char const *n) const noexcept
613{
614 char const *p = _p;
615 for (; *p && !__is_sep(*p) && *n; ++p, ++n)
616 if (*p != *n)
617 return Path();
618
619 if (*n || (*p && !__is_sep(*p)))
620 return Path();
621
622 return Path(p, _l - (p - _p));
623}
624
625inline
626Mount_tree::Mount_tree(char *n) noexcept
627: _ref_cnt(0), _name(n)
628{}
629
630inline Path
631Mount_tree::find(Path const &p, cxx::Ref_ptr<Mount_tree> *t) noexcept
632{
633 if (!_cld)
634 return Path();
635
636 for (cxx::Ref_ptr<Mount_tree> x = _cld; x; x = x->_sib)
637 {
638 Path const r = p.cmp_path(x->_name);
639 if (r)
640 {
641 *t = x;
642 return r;
643 }
644 }
645
646 return Path();
647}
648
649inline Path
650Mount_tree::lookup(Path const &path, cxx::Ref_ptr<Mount_tree> *mt,
651 cxx::Ref_ptr<Mount_tree> *mp) noexcept
652{
654 Path p = path;
655
656 if (p.first().cmp_path("."))
657 p.strip_first();
658
659 Path last_mp = p;
660
661 if (mp)
662 *mp = x;;
663
664 while (1)
665 {
666 Path r = x->find(p, &x);
667
668 if (!r)
669 {
670 if (mp)
671 return last_mp;
672
673 if (mt)
674 *mt = x;
675
676 return p;
677 }
678
679 r.strip_sep();
680
681 if (mp && x->_mount)
682 {
683 last_mp = r;
684 *mp = x;
685 }
686
687 if (r.empty())
688 {
689 if (mt)
690 *mt = x;
691
692 if (mp)
693 return last_mp;
694 else
695 return r;
696 }
697
698 p = r;
699 }
700}
701
702inline
703void
704Mount_tree::add_child_node(cxx::Ref_ptr<Mount_tree> const &cld)
705{
706 cld->_sib = _cld;
707 _cld = cld;
708}
709
710inline
711const char *
712File::get_mount(const char *path, cxx::Ref_ptr<File> *dir,
713 cxx::Ref_ptr<Mount_tree> *mt) noexcept
714{
715 if (!_mount_tree)
716 {
717 *dir = cxx::ref_ptr(this);
718 return path;
719 }
720
722 Path p = _mount_tree->lookup(Path(path), mt, &mp);
723 if (mp->mount())
724 {
725 *dir = mp->mount();
726 return p.path();
727 }
728 else
729 {
730 *dir = cxx::ref_ptr(this);
731 return path;
732 }
733}
734
735inline int
736File::openat(const char *path, int flags, mode_t mode,
737 cxx::Ref_ptr<File> *f) noexcept
738{
741 path = get_mount(path, &dir, &mt);
742
743 int res = dir->get_entry(path, flags, mode, f);
744
745 if (res < 0)
746 return res;
747
748 if (!(*f)->_mount_tree && mt)
749 (*f)->_mount_tree = mt;
750
751 return res;
752}
753
762class Mman
763{
764public:
766 virtual int mmap2(void *start, size_t len, int prot, int flags, int fd,
767 off_t offset, void **ptr) noexcept = 0;
768
770 virtual int munmap(void *start, size_t len) noexcept = 0;
771
773 virtual int mremap(void *old, size_t old_sz, size_t new_sz, int flags,
774 void **new_addr) noexcept = 0;
775
777 virtual int mprotect(const void *a, size_t sz, int prot) noexcept = 0;
778
780 virtual int msync(void *addr, size_t len, int flags) noexcept = 0;
781
783 virtual int madvise(void *addr, size_t len, int advice) noexcept = 0;
784
785 virtual ~Mman() noexcept = 0;
786};
787
788inline
789Mman::~Mman() noexcept {}
790
791class File_factory
792{
793private:
794 int _ref_cnt = 0;
795 int _proto = 0;
796 char const *_proto_name = 0;
797
798 template<typename T> friend struct cxx::Default_ref_counter;
799 void add_ref() noexcept { ++_ref_cnt; }
800 int remove_ref() noexcept { return --_ref_cnt; }
801
802public:
803 explicit File_factory(int proto) : _proto(proto) {}
804 explicit File_factory(char const *proto_name) : _proto_name(proto_name) {}
805 File_factory(int proto, char const *proto_name)
806 : _proto(proto), _proto_name(proto_name)
807 {}
808
809 File_factory(File_factory const &) = delete;
810 File_factory &operator = (File_factory const &) = delete;
811
812 char const *proto_name() const { return _proto_name; }
813 int proto() const { return _proto; }
814
815 virtual ~File_factory() noexcept = 0;
816 virtual cxx::Ref_ptr<File> create(L4::Cap<void> file) = 0;
817};
818
819inline File_factory::~File_factory() noexcept {}
820
821template<typename IFACE, typename IMPL>
822class File_factory_t : public File_factory
823{
824public:
825 File_factory_t()
826 : File_factory(IFACE::Protocol, L4::kobject_typeid<IFACE>()->name())
827 {}
828
829 cxx::Ref_ptr<File> create(L4::Cap<void> file) override
830 { return cxx::make_ref_obj<IMPL>(L4::cap_cast<IFACE>(file)); }
831};
832
847{
848protected:
849 File_system *_next;
850
851public:
852 File_system() noexcept : _next(0) {}
858 virtual char const *type() const noexcept = 0;
859
876 virtual int mount(char const *source, unsigned long mountflags,
877 void const *data, cxx::Ref_ptr<File> *dir) noexcept = 0;
878
879 virtual ~File_system() noexcept = 0;
880
885 File_system *next() const noexcept { return _next; }
886 File_system *&next() noexcept { return _next; }
887 void next(File_system *n) noexcept { _next = n; }
888};
889
890inline
891File_system::~File_system() noexcept
892{}
893
894class File_system_list
895{
896public:
897 class Iterator
898 {
899 public:
900 explicit constexpr Iterator(File_system *c = nullptr) : _c(c) {}
901
902 Iterator &operator++()
903 {
904 if (_c)
905 _c = _c->next();
906 return *this;
907 }
908
909 bool operator==(Iterator const &other) const { return _c == other._c; }
910 bool operator!=(Iterator const &other) const { return _c != other._c; }
911 File_system *operator*() const { return _c; }
912 File_system *operator->() const { return _c; }
913
914 private:
915 File_system *_c;
916 };
917
918 File_system_list(File_system *head) : _head(head) {}
919
920 constexpr Iterator begin() const
921 { return Iterator(_head); }
922
923 constexpr Iterator end() const
924 { return Iterator(); }
925
926private:
927 File_system *_head;
928};
929
935class Fs
936{
937public:
943 virtual cxx::Ref_ptr<File> get_file(int fd) noexcept = 0;
944
946 virtual cxx::Ref_ptr<File> get_root() noexcept = 0;
947
949 virtual cxx::Ref_ptr<File> get_cwd() noexcept { return get_root(); }
950
952 virtual void set_cwd(cxx::Ref_ptr<File> const &) noexcept {}
953
959 virtual int alloc_fd(cxx::Ref_ptr<File> const &f = cxx::Ref_ptr<>::Nil) noexcept = 0;
960
971 virtual cxx::Pair<cxx::Ref_ptr<File>, int>
972 set_fd(int fd, cxx::Ref_ptr<File> const &f = cxx::Ref_ptr<>::Nil) noexcept = 0;
973
979 virtual cxx::Ref_ptr<File> free_fd(int fd) noexcept = 0;
980
988 virtual int mount(char const *path, cxx::Ref_ptr<File> const &dir) noexcept = 0;
989
997 virtual int register_file_system(File_system *f) noexcept = 0;
998
1006 virtual int unregister_file_system(File_system *f) noexcept = 0;
1007
1015 virtual File_system *get_file_system(char const *fstype) noexcept = 0;
1016
1025 virtual File_system_list file_system_list() noexcept = 0;
1026
1030 int mount(char const *source, char const *target,
1031 char const *fstype, unsigned long mountflags,
1032 void const *data) noexcept;
1033
1034 virtual int register_file_factory(cxx::Ref_ptr<File_factory> f) noexcept = 0;
1035 virtual int unregister_file_factory(cxx::Ref_ptr<File_factory> f) noexcept = 0;
1036 virtual cxx::Ref_ptr<File_factory> get_file_factory(int proto) noexcept = 0;
1037 virtual cxx::Ref_ptr<File_factory> get_file_factory(char const *proto_name) noexcept = 0;
1038
1039 virtual ~Fs() = 0;
1040
1041private:
1042 int mount_one(char const *source, char const *target,
1043 File_system *fs, unsigned long mountflags,
1044 void const *data) noexcept;
1045};
1046
1047inline int
1048Fs::mount_one(char const *source, char const *target,
1049 File_system *fs, unsigned long mountflags,
1050 void const *data) noexcept
1051{
1053 int res = fs->mount(source, mountflags, data, &dir);
1054
1055 if (res < 0)
1056 return res;
1057
1058 return mount(target, dir);
1059}
1060
1061inline int
1062Fs::mount(char const *source, char const *target,
1063 char const *fstype, unsigned long mountflags,
1064 void const *data) noexcept
1065{
1066 if ( fstype[0] == 'a'
1067 && fstype[1] == 'u'
1068 && fstype[2] == 't'
1069 && fstype[3] == 'o'
1070 && fstype[4] == 0)
1071 {
1072 File_system_list fsl = file_system_list();
1073 for (File_system_list::Iterator c = fsl.begin(); c != fsl.end(); ++c)
1074 if (mount_one(source, target, *c, mountflags, data) == 0)
1075 return 0;
1076
1077 return -ENODEV;
1078 }
1079
1080 File_system *fs = get_file_system(fstype);
1081
1082 if (!fs)
1083 return -ENODEV;
1084
1085 return mount_one(source, target, fs, mountflags, data);
1086}
1087
1088inline
1089Fs::~Fs()
1090{}
1091
1098class Ops : public Mman, public Fs
1099{
1100public:
1101 virtual void *malloc(size_t bytes) noexcept = 0;
1102 virtual void free(void *mem) noexcept = 0;
1103 virtual ~Ops() noexcept = 0;
1104
1105 char *strndup(char const *str, unsigned l) noexcept
1106 {
1107 unsigned len;
1108 for (len = 0; str[len] && len < l; ++len)
1109 ;
1110
1111 if (len == 0)
1112 return nullptr;
1113
1114 ++len;
1115
1116 char *b = static_cast<char *>(this->malloc(len));
1117 if (b == nullptr)
1118 return nullptr;
1119
1120 char *r = b;
1121 for (; len - 1 > 0 && *str; --len, ++b, ++str)
1122 *b = *str;
1123
1124 *b = 0;
1125 return r;
1126 }
1127
1128};
1129
1130inline
1131Ops::~Ops() noexcept
1132{}
1133
1134}}
1135
1136#endif
1137
Abstract capability-allocator interface.
L4::Cap related definitions.
Interface for a POSIX file that is a directory.
Definition vfs.h:160
virtual int mkdir(const char *path, mode_t mode) noexcept=0
Create a new subdirectory.
virtual int link(const char *src_path, const char *dst_path) noexcept=0
Create a hard link (second name) for the given file.
virtual int unlink(const char *path) noexcept=0
Unlink the given file from that directory.
virtual int symlink(const char *src_path, const char *dst_path) noexcept=0
Create a symbolic link for the given file.
virtual int rmdir(const char *path) noexcept=0
Delete an empty directory.
virtual int rename(const char *src_path, const char *dst_path) noexcept=0
Rename the given file.
virtual int faccessat(const char *path, int mode, int flags) noexcept=0
Check access permissions on the given file.
Basic interface for an L4Re::Vfs file system.
Definition vfs.h:847
virtual char const * type() const noexcept=0
Returns the type of the file system used in mount as fstype argument.
The basic interface for an open POSIX file.
Definition vfs.h:460
POSIX File-system related functionality.
Definition vfs.h:936
virtual void set_cwd(cxx::Ref_ptr< File > const &) noexcept
Set the current working directory for the application.
Definition vfs.h:952
virtual int mount(char const *path, cxx::Ref_ptr< File > const &dir) noexcept=0
Mount a given file object at the given global path in the VFS.
virtual cxx::Ref_ptr< File > get_file(int fd) noexcept=0
Get the L4Re::Vfs::File for the file descriptor fd.
virtual cxx::Ref_ptr< File > free_fd(int fd) noexcept=0
Free the file descriptor fd.
virtual cxx::Pair< cxx::Ref_ptr< File >, int > set_fd(int fd, cxx::Ref_ptr< File > const &f=cxx::Ref_ptr<>::Nil) noexcept=0
Set the file object referenced by the file descriptor fd.
virtual int alloc_fd(cxx::Ref_ptr< File > const &f=cxx::Ref_ptr<>::Nil) noexcept=0
Allocate the next free file descriptor.
virtual cxx::Ref_ptr< File > get_root() noexcept=0
Get the directory object for the application's root directory.
The common interface for an open POSIX file.
Definition vfs.h:52
virtual int unlock_all_locks() noexcept=0
Unlock all locks on the file.
virtual int fchmod(mode_t) noexcept=0
Change POSIX access rights on the file.
virtual int fstat64(struct stat64 *buf) const noexcept=0
Get status information for the file.
virtual int set_status_flags(long flags) noexcept=0
Set file status flags (fcntl F_SETFL).
Ready_type
Type of I/O operation/condition a file can indicate readiness.
Definition vfs.h:60
virtual bool check_ready(Ready_type rt) noexcept=0
Check whether the file is ready for an I/O operation/condition.
virtual int get_status_flags() const noexcept=0
Get file status flags (fcntl F_GETFL).
Interface for POSIX memory management.
Definition vfs.h:763
virtual int mmap2(void *start, size_t len, int prot, int flags, int fd, off_t offset, void **ptr) noexcept=0
Backend for the mmap2 system call.
virtual int msync(void *addr, size_t len, int flags) noexcept=0
Backend for the msync system call.
virtual int munmap(void *start, size_t len) noexcept=0
Backend for the munmap system call.
virtual int mremap(void *old, size_t old_sz, size_t new_sz, int flags, void **new_addr) noexcept=0
Backend for the mremap system call.
virtual int madvise(void *addr, size_t len, int advice) noexcept=0
Backend for the madvice system call.
virtual int mprotect(const void *a, size_t sz, int prot) noexcept=0
Backend for the mprotect system call.
Interface for the POSIX backends of an application.
Definition vfs.h:1099
Interface for a POSIX file that provides regular file semantics.
Definition vfs.h:287
virtual L4::Cap< L4Re::Dataspace > data_space() noexcept=0
Get an L4Re::Dataspace object for the file.
Interface for a POSIX file that provides special file semantics.
Definition vfs.h:420
virtual int ioctl(unsigned long cmd, va_list args) noexcept=0
The famous IO control.
C++ interface for capabilities.
Definition capability.h:219
A reference-counting pointer with automatic cleanup.
Definition ref_ptr:71
L4 compiler related defines.
Dataspace interface.
Type_info const * kobject_typeid() noexcept
Get the L4::Type_info for the L4Re interface given in T.
Definition __typeinfo.h:682
L4Re C++ Interfaces.
Definition cmd_control:14
L4 low-level kernel interface.
Our C++ library.
Definition arith:11
Pair implementation.
Pair of two values.
Definition pair:28