Slashdot Mirror
Hurd: H2 CD Images
An anonymous submitter sends in: "The Debian GNU/Hurd team released a new Hurd CD Image. Snapshot images are produced at a four to eight week interval and the H2 images are the tenth of the series. The Hurd has grown from one CD image in August 2000 (A1) to four images in December 2001 (H2). These images are snapshots of a developing operating system, so suitable precautions must be taken when making an installation. Similar to other architectures, most important programs reside on CD 1, while the other ones contain less important packages. For the moment, Hurd doesn't support card sound and partition size is still limited to 1 GB. Hurd use the Debian packaging system (dpkg and apt as for Debian linux) , so it is simple to install and update packages."
Until Hurd is closer to Linux or BSD in partition size and overall capabilities, it isn't going to pick up much in the way of popularity.
What they have now is a rather "chicken and the egg" syndrome - it won't achieve popularity until more people start developing for it, and people won't care enough to develop for it until it's more popular.
However, the biggest drawback to Hurd is probably the fact that the people it might most appeal to (people who don't like linux or bsd style unix purists) are less likely to use it because they won't want to put up with the Hurd philosophy, when BSD is already there.
Who is going to use it? Linux has all the bells and whistles for people who love the GPL, and the BSD people who like pure unix and freedom (I know, what is pure unix anyway) are going to stick with *BSD.
I remember Stallamn saying that hurd was going to be ready for real use in the near future. Of couse I'm somewhat fuzzy on the details because this was in a talk he gave in 1985 or so.
The only reason microkernels exist is limitations in existing protection mechanisms. There are only two levels, kernel and user, and each must be protected from the other. My question is this: what about something like the x86 segmentation mechanism? x86 segments have the cool property that a piece of code has the privelege level of the segment containing it. The nifty thing about that is that there are 4 privlege levels, so that you can have the kernel at the lowest level, less important stuff like the GUI at a higher level, and the app at the highest level. That way nothing can crash a more important component. I was wondering why this scheme hasn't been extend to paging. On every memory reference, the processor could check the privelege level of the page containing the currently executing code, and make sure that the target memory has an appropriate privlege level. This makes things even faster than a mono-kernel, since the only thing that is necessary to do a system call is a simple jump to the appropriate code (which would be dozens of times faster than a standard system call on x86). This shouldn't be any slower than the current way of doing things. The privlege of the current code would only have to be read whenever a page boundry was crossed, and would only reference memory during a TLB fault (which would have to reference memory anyway). The proc already does a protection check on the kernel/user bit on the page table entry anyway, so that scheme could be extended to multiple privlege levels without a slowdown. Am I missing something, or does an existing processor already do this?
A deep unwavering belief is a sure sign you're missing something...
most of the people here would have read about the differences between micro and monolithic kernels [almost a holy war in os design] . in reality it has been the case that the micokernel design has been very much an academicia exercise rather than a commercial one. though it might be due to various other reasons, it does show that there is some merit into 1) making things work for a particular case 2) once working, making it work for others RATHER than trying in one go to get a simpler solution.
i _do_ know that microkernels are much more than what i seem to think of them from the above:) yes the design and the philosophy is very different and surely interesting but practical ?....
i have taken advanced OS classes and i really do feel that the Mach though it had great ideas WAY beyond its time , was horribly complex and interwoven and so much so that anyone cringes on hearing a system based on the Mach:)
i think the Hurd is in a good position to prove us all wrong:) as its closely tied with the debian developers [who have done great work till now] and it has been slowly [very:)] progressing....
best of luck to them:)
vv
Beos.
Except free (as the spoken beer is...), and not quite hitting puberty yet...
I've scanned all the postings, and I haven't seen any other comparisons, but the descriptions from here and from the web page seem like about the same architecture...minus the extreme multi-threading and the integrated gui...
At any rate, it sure seems like this would be (yet another) great base to work from for re-building that OS that ain't no more...
Sig currently under construction. Mind the gap....
Dude, nice attempt to bait the GNU people.
You imply that people either love freedom or the GPL, but not both. Do we *really* have to have that conversation again here? Unless you're being paid by microsoft, this is just senseless infighting between two groups whose goals are almost totally in alignment.
It reminds me of a time some friends of mine wouldn't speak to each other. Why? They were both animal rights advocates- but one group thought that it was a good idea to argue that animal testing was ineffective, and the other team thought this was a bad idea because it implied that if testing worked, it would be a good idea. As a result, the movement splintered, while the research advocates ("animal rights opponents") spoke with a unified voice. The internal strategic debate ruined the overall message they were both trying to send.
The parallel to the BSD vs. GPL debate is striking. It is a fun and important debate to have, but ultimately the harm that comes from ubiquitous closed-source can't-build-on-it software, which satisfies the goals of neither camp, vastly overwhelms the importance of this philosophical discussion. It makes it seem like theologians arguing over how many angels can fit on the head of a pin. If I was Microsoft's head evangelist, I'd be silently funding extremists on both sides trying to create bad political blood between these groups.
I'm not saying we shouldn't argue, obviously the issues need to be fleshed out. I'm just saying that these arguments ought to show respect for the other side (no more "we're more freedom-loving than you" namecalling), and that they ought to always be mindful of the context they are operating in - discussing the best way to create a body of free software in a world of proprietary de facto standards.
So I'm begging with all of you, show respect for your adversaries in this discussion. Acknowledge that the point of view held by the other side is understandable even if you believe that it's in error, but most importantly always make a special effort to identify the context of the discussion: that is, how can we best preserve freedom against those who would prefer all software to be proprietary?
microsoftword.mp3 - it doesn't care that they're not words...
The basic premise behind a microkernel is that device drivers will be black box proprietary binary code from untrusted third parties, hence require clumsy run-time protection. This hypothesis has been invalidated in practice for proprietary systems, and doesn't even make sense in theory for free software systems.
There is no need whatsoever for expansive memory protection between modules at runtime. Modularity is great, but at development-time, not runtime. HURD doesn't give you any additional development-time modularity; if anything, it removes it. If you want development-time modularity, drop that stupid C language, and use a modular language, such as Modula-3 (SPIN-OS), SML (Fox, Express), or Erlang (standalone Erlang).
Microkernels were the latest hype in the 1980's for OS development. They've only ever been hype, and it's sad that GNU people waste their time with such a stupid concept, whereas there's so much more to OS design, including lots of proven concepts, that just await to be implemented in free software (who's gonna implement the lost features from Genera? from Eumel?)
-- Faré @ TUNES.org
Reflection & Cybernet
I would have to disagree. The kernel could easily provide services that would provide memory mapping to the driver. I don't see why not. In fact, with proper protection mechanisms in place there's no reason why any user app should not be able to figure out real memory addresses. I don't think that would be ugly.
>>>>
It would be quite ugly. There are several problems that crop up. First, each driver would have to dynamically map pieces of process address space into its own space during execution (paltry 4GB address space on x86). To do that, you not only have to make a round-trip to the kernel, but you have to mess with the process address space (which involves an AVL-tree lookup and attempts to merge regions). The kernel doesn't have to do this, because whenever a system call is invoked, the current process's address space is already mapped. Then there is the fact that it becomes a pain to manage all those shared mappings. There can easily be hundreds of processes in the system, and multiple drivers processes would have to map each one. Managing that many shared mappings quickly becomes very messy (and very dangerous, due to the extensive sharing of memory).
A deep unwavering belief is a sure sign you're missing something...