Microkernel and Component-based OS Devroom at FOSDEM 2024
CALL FOR PARTICIPATION
On-line version of this CfP: http://fosdem.microkernel.info/
The developers and users of several free and open source
microkernel-based, unikernel-based and component-based operating
systems will meet as part of FOSDEM 2024 [1] and will share
a developer room. The devroom is currently looking for content in
the form of talks and other activities related to microkernel-based,
unikernel-…
[View More]based, component-based operating systems and similar areas.
Possible topics of the devroom include, but are not limited to:
* introduction of a specific OS or framework
* design of subsystems and the general architecture of an OS
* languages, tools and toolchains used
* enabling support for hardware (architectures, device drivers)
and programming languages
* development processes, debugging
* maintenance, testing and release engineering
* safety, security and robustness
* trends and challenges
* research and open questions
* community and governance
* use cases, experiences and status updates
* best practices and lessons learned
* demos
The devroom has been scheduled to Saturday February 3rd 2024 in the
afternoon (Central European Time).
This is a call for your participation. We kindly ask you to submit
your proposals no later than on December 10th 2023 (End of Day,
Anywhere on Earth). Please use the pretalx [2] web site to submit
your proposals. Note that this is a new submission system and the
user accounts from the previous submission system (pentabarf) have
not been transferred.
Make sure to select the Microkernel and Component-based OS as the
track when submitting your proposal and include at least the
following information:
* title of your proposal
* short abstract (one or two paragraphs)
* duration (at least 15 minutes and no longer than 40 minutes)
* your full name
* your short bio
You can specify your preferred time slot of your proposal and any
other relevant information. The communication language of the
devroom is English. Please note that the devroom has been allocated
only a half of a day this year. Therefore the final decision on the
duration of the talks will be made by the devroom organizers based
on the number of accepted proposals.
The official devroom schedule (along with the accepted talks) will
be announced on December 15th 2023 on the devroom's mailing list [3]
and the speakers will be notified via e-mail. The schedule will be
published on the FOSDEM web site, too.
About the Devroom
Since the first Microkernel OS Devroom at FOSDEM 2012 [4], this
devroom has been a part of each following FOSDEM (with slight
variations of the name). The focus gradually widened to include
component-based, unikernel-based and other operating systems. By
now, it has become a somewhat institutionalized tradition for the
open source operating systems community, a kind of "extended family
meeting" and it is one of the places where microkernel and unikernel
enthusiasts meet regularly.
To this date, over two dozen projects have participated in one way
or another. Many of the projects face similar challenges but come up
with partially different solutions. Therefore, the goal of the
devroom is to bring the various projects together, let them exchange
ideas, cross-pollinate and socialize.
As every previous year, the devroom will offer the "stage" both to
established community members and to newcomers. We like to select
the talks in an inclusive manner, while staying true to the main
technical topics (system-level software, broadly speaking) and
creating a balanced and unbiased schedule. We would like to keep the
quality bar of the devroom same as in the previous years.
Presenting at FOSDEM implies that the recordings of the talks will
be published under Creative Commons license by FOSDEM. By submitting
a proposal, the speaker agrees to have the talk made available
publicly indefinitely. For organizational purposes, we also need
contact information of the speakers of accepted talks.
Microkernel Dinner
It has also become a habit that the devroom participants dine
together somewhere in Brussels. The year 2024 will not be any
different, so there is going to be a dinner on Saturday night. We
will inform you about the exact arrangements later.
About FOSDEM
FOSDEM [5] is a two-day conference organized by volunteers to
promote the widespread use of free and open source software. FOSDEM
is widely recognized as one of the largest and best such events
worldwide. FOSDEM covers a wide spectrum of free and open source
software and hardware projects and offers a platform for people to
collaborate.
To this end, FOSDEM has set up developer rooms (devrooms) where
teams can meet and showcase their projects. Devrooms are a place for
teams to discuss, hack and publicly present latest directions,
lightning talks, news and proposals. Besides developer rooms, FOSDEM
also offers main tracks, lightning talks, certification exams and
project stands.
In recent years, FOSDEM has been hosting more than 8000 developers
annually at the ULB Solbosch Campus in Brussels, Belgium. The
participation in FOSDEM is totally free, although the organizers
gratefully accept donations and sponsorship. No registration is
necessary. Attendees are expected to follow the FOSDEM's code of
conduct [6].
Important Dates Recap
* 2023-12-10: Deadline for proposal submission
* 2023-12-15: Schedule published and speakers notified of
acceptance
* 2024-02-03: Devroom taking place
Contact
For any comments, questions and suggestions, please do not hesitate
to use the devroom's mailing list [3] to contact the devroom
organizers.
The primary organizers of the devroom in 2024 are:
* Martin Decky
* Razvan Deaconescu
References
[1] https://fosdem.org/2024/
[2] https://pretalx.fosdem.org/fosdem-2024/cfp
[3] https://lists.fosdem.org/listinfo/microkernel-devroom
[4]
https://archive.fosdem.org/2012/schedule/track/microkernel_os_devroom.html
[5] https://fosdem.org/
[6] https://fosdem.org/2024/practical/conduct/
[View Less]
Hello,
Having seen a problem recur in programs running in L4Re just now involving
arrays of a relatively large size allocated statically in functions - about
100000 bytes or so - I was wondering if there are any implicit limitations
with this form of allocation in L4Re. Is it possible that programs have a
limited stack size and that the stack does not expand?
Here is an example of the kind of code that causes an unhandled exception:
uint32_t Spi_gpio::send_units(uint32_t bytes, const …
[View More]uint8_t data[],
uint8_t unit_size, uint8_t char_size)
{
uint32_t chars = bytes / unit_size;
int dc[chars];
And the exception looks like this:
Unhandled exception: PC=0x1019ca8 PFA=0xfffd075a LdrFlgs=0x0
The actual cause of the exception is an access to an element in the dc array.
When I eventually get back to my own experiments with initiating programs in
L4Re - not involved with the problem reported here - I intend to look more
closely at program stack allocation and expansion strategies, so I suppose
this is an appropriate prelude to such work.
Thanks for any guidance that might be offered, as always!
Paul
[View Less]
Hello,
I have been trying to get some sensible behaviour from various programs
running in L4Re that wish to read from standard input, hopefully using the
UART, since standard output is successfully sent across the serial connection.
However, it appears that Ned does something rather undesirable with the input
stream.
If I modify the hello example to use fgets and deploy it without Ned (the
hello.cfg example in conf/examples), as long as some kind of serial
initialisation has occurred, I …
[View More]can enter characters at the serial console and
have the program read them. However, if I deploy the same code using Ned (the
hello.cfg example in conf/examples), fgets repeatedly returns NULL.
Strangely, if I follow the instructions in the L4Re documentation...
https://l4re.org/doc/l4re_servers_ned.html#l4re_ned_interactive
The ned-prompt program itself just prints "Cmd>" over and over again, failing
to read anything. It is as if non-blocking I/O has been enabled, although ned-
prompt appears to use readline, so I imagine that there is likely to be a
somewhat different explanation. Attempting to enforce non-blocking input using
fcntl in the hello example also does not help.
Has anyone any suggestions as to why these things do not work? I have tried
this on physical hardware as well as in QEMU.
Thanks in advance,
Paul
[View Less]
Hi,
Is it possible to have a Windows guest OS running on top of L4Re? If so,
could you provide some insight into how that could work? It seems like uvmm
doesn't allow booting from an ISO image, or am I missing something?
Hi all,
I would like to try Fiasco/L4Re for a Mixed-Critical Xilinx UltraScale+
FPGA-MPSoC (the hardware accelerators on the FPGA should be
virtualized/isolated for mixed-critical applications) Is there somewhere
an example (or at least starting point) of an ARM Trustzone
configuration of a Normal World VM and Secure World VM (with UVMM/Fiasco
as hypervisor that also takes care of the ARM Trustzone configuration)?
Best regards
Micha
Hello,
Sorry to be lazy and not dig too deeply into the documentation and code, but
once upon a time it was possible to use the l4re_ma functions to allocate
pinned memory. Then, one would use the dataspace protocol to obtain the
physical address of the memory via the capability involved in memory
allocation.
This exercise would be sufficient to get into a position to initialise
peripherals in a system-on-a-chip, setting registers with the physical memory
addresses they would need for …
[View More]things like DMA. The initialisation of things
like framebuffers would rely on this procedure.
I see that the "phys" operation in the dataspace protocol was discarded some
time ago, and now there is a "DMA space" abstraction instead:
https://l4re.org/doc/group__api__l4re__c__dma.html
Are there any examples of how I might obtain a physical address associated
with a block of memory using this new API?
Thanks in advance for any guidance that might be offered!
Paul
[View Less]
Hello,
As part of reviewing my earlier efforts getting L4Re running on various MIPS-
based devices, I have been trying to get the bootstrap module to start the
kernel on the MIPS Creator CI20, and here I encounter a strange problem.
The bootstrap code appears to copy the different modules in the payload around
in memory, and for the kernel, it finds the different sections at 0x2f4000 in
physical memory (accessed via 0x802f4000), copying them into locations
relative to the indicated module …
[View More]base address (for example, 0x1100000 or
0x2000000). From their new locations, each section of the kernel is then
copied to its desired final address.
So, the section of the kernel providing its entry point can be found at
0x2f4000 + 0xa411c, this being copied to base + 0xa411c, before finally being
copied to 0x800d3000. However, the contents of memory at the final location
(0x800d3000) are not correct, nor are they at the "staging" location of base +
0xa411c, even though they do correspond to the expected contents of the kernel
binary at their original location.
What I expect to see at the entry point is...
40806000 mtc0 zero,c0_status
000000c0 ehb
What I see instead is...
ffffffff
bea3ffdf
Apart from at the original location in the payload (0x2f4000 + 0xa411c). As
far as I can tell, the second word is nonsense, and it is usually followed by
more ffffffff words. So, it is as if copying failed for this particular
section.
Oddly, this only seems to affect the section of the kernel providing the entry
point, and all other sections appear to be copied correctly from their
original locations. One factor might be that this section is the last one that
is copied.
Does this seem like recognisable behaviour of some kind of misconfiguration?
For the most part, I am just rebasing my old patches on the current L4Re and
Fiasco versions, so I didn't expect a problem at this level.
Regards,
Paul
[View Less]
Hello microkernel hackers from Dresden and afar,
the German Society of Informatics (GI) has a Special Interest Group on
Operating Systems ("Fachgruppe Betriebssysteme" [1]), with members from
both academia and industry. This group meets twice a year to network
and to discuss their current work. The upcoming spring meeting,
organized together with GI's fault-tolerance SIG ("Fachgruppe
Fehlertolerierende Rechensysteme" [2]) will be hosted by TU Dresden on
March 06+07 (noon to noon). …
[View More]Please consider attending and/or submitting
a talk (details below and on the following website):
https://www.betriebssysteme.org/aktivitaeten/treffen/2023-dresden/
Best regards,
Horst Schirmeier
[1] https://betriebssysteme.org
[2] https://fg-fers.gi.de/
=== Topic: "Operating Systems and Dependable Systems" ===
Dependability – the totality of safety, security, availability,
reliability, and maintainability – is a fundamental attribute of
safety-critical hardware and software systems. In the automotive
industry, for example, current trends in autonomous driving present
entirely new challenges in marrying fault tolerance and maximum
performance while keeping costs low. The answers to these research
questions ultimately call for a comprehensive investigation of the
interactions between applications, system software, and hardware.
In this spirit, the joint spring meeting of the GI's "Operating Systems"
(FGBS) and "Fault-Tolerant Computing Systems" (FERS) special interest
groups will be focusing on novel approaches to the analysis, design, and
evaluation of dependable systems and on the exchange of ideas between
the two communities. Areas of interest for submissions include, but are
not limited to:
- Fault tolerance mechanisms at all layers of the system
- Dependability and real-time
- Isolation and integration mechanisms in software
- Test, analysis, evaluation, and verification
- Robust system architectures and HW/SW co-design
- Practical and field reports on safety-critical systems and their
applications
- Models, development processes, and standards
Contributions outside the main focus of the event are most welcome as well.
Please submit either a one-page abstract (presentation only) or a 2- to
4-page unpublished paper (ACM conference style) in German or English. A
program committee consisting of members of the two steering boards will
review the submissions and decide on their acceptance. In case of
acceptance, papers (2-4 pages) will be published in the digital library
of the Gesellschaft für Informatik.
We explicitly welcome presentations in English. The talks' language will
be indicated in the program to facilitate non-German members'
participation in our workshops in the future. The event will also be
organized in a hybrid format.
--
Prof. Dr.-Ing. Horst Schirmeier
Professur für Betriebssysteme
Technische Universität Dresden
Fakultät Informatik
01062 Dresden
Tel.: +49 (351) 463-38321
office: Andreas-Pfitzmann-Bau, R.3102
Nöthnitzer Str. 46, 01187 Dresden
(Campus-Navigator: https://tud.link/seh0)
https://tud.de/inf/os
[View Less]
Hello,
I have been working through reimplementing the mechanisms involved with
launching programs in L4Re, managing to initiate programs apparently
successfully under QEMU emulating amd64 and x86, but I have been less
successful getting them to work under QEMU emulating a MIPS system (MIPS
Malta).
My arrangement of threads within tasks should be fairly similar to what L4Re
normally employs to host and run programs, and I wrote it up here:
"Gradual Explorations of Filesystems, Paging and …
[View More]L4Re"
https://blogs.fsfe.org/pboddie/?p=2540
The pictures at the end summarise what has been done. I have a region mapper
running in a thread in the same task as the program to be launched. The region
mapper handles page faults and interacts with dataspaces on the program's
behalf. Faults caused by the region mapper are handled by the initiating task.
What I seem to have avoided previously but now experience is that after the
region mapper has been started, it is able to service page faults, but after a
certain point in the execution of the program of interest, the region mapper
itself experiences an exception in the __pthread_cleanup_push_defer function
within uClib's pthreads implementation, specifically at this line:
buffer->__canceltype = THREAD_GETMEM(self, p_canceltype);
Digging into this, I found that self is apparently zero. Since self is
obtained from a call to thread_self which in turn obtains the user[0] member
of the thread control register structure (providing the thread descriptor
address), I can only conclude that either this member has not been initialised
or that it has been overwritten by the other thread as it started up.
Investigating uClibc startup, I notice that pthread initialisation does indeed
involve a traversal of UTCB areas, zeroing user[0] in the supposedly free UTCB
blocks. And with the region mapper having failed, the main program will also
fail fairly quickly, with an exception typically occurring in the
__pthread_initialize_minimal function, coincidentally just after this zeroing
has occurred, just before a call to __libc_setup_tls.
I have been looking for hints as to how this work is done in L4Re normally.
Given that the region mapper and the program being run are normal programs
that are executed via their conventional entry points, this resulting in the
initialisation of the C library and threading for each payload, it seems that
some measures must be in place to prevent this initialisation from causing
conflicts in the UTCB area.
For instance, I see that in the file...
pkg/l4re-core/l4re_kernel/server/src/main.cc
... the __libc_alloc_initial_tls function is redefined to presumably override
the weakly referenced version in uClibc, but if this were invoked it would
probably cause uClibc to fail during initialisation, at least unless the zero
page is going to be used (but it would need allocation somewhere else), so
maybe it doesn't override anything after all. In any case, this function would
only change some aspects of how __libc_setup_tls would work, so maybe it is a
distraction.
I did wonder if there was something specific about MIPS that would cause this
failure, investigating the user-local register (ULR) used to hold UTCB-related
information, but getting the UTCB address via the ULR would appear to work:
otherwise, the region mapper would probably not start up. I also wondered
about program initialisation issues, since I did experience problems on actual
MIPS hardware related to various registers not being set up correctly, but the
generated code seems fairly comprehensive in this regard these days (and maybe
it was all along but I encountered a confounding phenomenon).
Does anyone have any familiarity with how this actually works and might be
able to indicate what I am doing wrong?
As always, thanks for any help that can be offered!
Paul
[View Less]