• Welcome to OS2World OLD-STATIC-BACKUP Forum.
 

News:

This is an old OS2World backup forum for reference only. IT IS READ ONLY!!!

If you need help with OS/2 - eComStation visit http://www.os2world.com/forum

Main Menu
Menu

Show posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Show posts Menu

Messages - phaelonimaire

#1
I've seen the topic of replacing the OS/2 kernel come and go over the years, never really making any progress.  Everyone has a different opinion, and few seem to understand what a kernel really does. 
The level of interest in replacing the OS/2 kernel seems to be fairly high, yet the willingness to actually do anything seems to be zero. 
As I am also in this category, I have been thinking about a way to replace the kernel without writing an entire operating system.  This is what I've come up with:

If I remember correctly, DOSCALLS.DLL is pretty much the main interface between the kernel and applications (or drivers, I think).  There are others, obviously, but my intentions here are to give a general perspective of an idea - not a roadmap.
If someone were to write a new DOSCALLS.DLL which could interface between OS/2 programs (and maybe drivers) and SOME OTHER KERNEL, one should be able to run OS/2 applications (to some degree) with a different kernel. 
The entry points of DOSCALLS.DLL are well documented, and a lot of the OS/2 API calls themselves have documented linux replacements (thanks to IBM). 

The big picture looks like this:
If the core OS/2 subsystems are mapped to a different kernel properly, you should be able to run OS/2 on top of another kernel.  Additionally, since the core components would (hopefully) open source, new functionallity could be provided.  This gives you the ability to take advantage of new drivers from the "stolen" kernel, as well as allow us to continue to run what it is we all desire - OS/2.  Way in the future, it could be possible to eventually replace all of the original OS/2 subsystems with new components without having to start with nothing.

This would require someone to already have OS/2, but I don't think that's really the biggest problem at the moment.  This is not an easy task, but it isn't quite as difficult as rewriting everything at once.  In this model, one could slowly relpace legacy components over time.

Short runtime example if using a linux kernel:
* Kernel decompresses and initializes. 
* After mounting the root device, linux normally runs initd.
* initd is replaced with the new OS/2 subsystem
* The new OS/2 subsystem loads the required files, and provides the proper translation passthtroughs to simulate a  "normal" OS/2 environment.  This could be controlled by a config.sys variant.
* After initialization is complete, you are essentially running OS/2.  The only outward sign that the kernel has changed is what happened during the boot cycle. 
#2
Since these features are already available on other operating systems, why is it that we're here - talking about OS/2?  While other operating systems may provide advanced feature sets and "better" hardware support, that doesn't mean their method of implementation works for every situation.  There are a number of markets where OS/2 seems far easier to use than Linux or Windows.  When it comes to industrial control PCs, kiosks, or ATMs, OS/2 is much easier to set up.  It is possible to have it easily run only the GUI (PM) app you want (unlike Windows XP and the dreaded winlogon API), and is far less complicated than trying to both learn and then customize the standard linux distribution. 

From the application development point of view, working with OS/2 is easier than Linux in some respects.  I've found that writing OS/2 (and even Windows) GUI applications is much easier than trying to develop with GTK or other toolkits.  I write mostly in C and Assembly, so packages such as wxWidgets and Qt do little or nothing for me.  Keep in mind that this applies only when portability to other operating systems is not an issue.

The kernel and API are important to an operating system because they do far more than control the hardware and provide access to it.  The way the kernel handles memory and I/O will dictate how the OS feels and performs.  The way the API is designed will impact the way a developer writes an application, and may even contribute to its overall stability.  A good example is the X11 event loop versus the Windows event loop.  With X11, you can use select() to monitor the event loop and any other socket.  With Windows, you must either use PeekMessage with a timeout/loop, or you have to create a separate thread to handle other sockets, which may or may not be the best solution. 

I completely understand what you're saying about "playing catch-up".  This is why everyone I know that used to run OS/2 now runs something else.  Although there have been a number of great enhancements made to OS/2 since the start of the "Convenience Pak" days, we have not seen any major development on the core OS.  This is not going to change until either the complete source code meets someone who will maintain it, or a replacement is written.  Until then, the gap between OS/2 and the other operating systems will continue to grow. 

As stated before (in this thread and numerous other places), something has to be done.  We can either keep patching what IBM gave us, support those who are already working on an alternative (Voyager / osfree.org), or start from scratch and hope for the best.
#3
The topic I have mentioned would be kernel replacement, and general advancement of OS/2 as an operating system.  Shortly after the announcement of the Voyager project, there was a thread on this website about what kernel to use.  The debate was over rather it mattered which kernel was to be used.  Shortly afterward, the topic of why we weren't using the Linux kernel and GNU software was raised.  When the 64-bit x86 CPUs were 'new' a couple years ago, another topic surfaced about building a 64-bit OS/2 kernel.  At that time, osfree.org was mentioned as a possible avenue. 

History is a very broad category.  There is the history of OS/2, which is important.  There is also the history of one's personal experience regarding something related to OS/2 - this is somewhat irrelevant.  When one looks to the future, one must also study the past.  However, you have to evaluate what history you are following, and if it is helpful in arriving at a conclusion.  What I've seen so far seems to have little to do with what to do about getting a 64-bit kernel, which I though this topic "Ecomstation 64 Bit Kernel" was about.

"...IBM has service offerings that continue to be available for customers who need ongoing support for OS/2, although IBM has no plans for product enhancements. IBM has recommended that customers on OS/2 consider migration to alternative solution offerings, and has a broad array of software assets and services to help customers migrate."

We were talking about a 64-bit kernel, right?  Do you count that as "support" or an "enhancement"?  If I call IBM tomorrow and tell them that there is a bug in the USB Mass Storage, what kind of support do you think I will get?  Most likely, they will try to help me "migrate" to Windows or Linux.  If I wanted to do that,  I would have done it by now.

True, IBM says they support OS/2.  The question is, do they support OS/2 in a way that helps us?  Perhaps if they will support OS/2, perhaps we should petition for a new version. 

Or, perhaps we should continue on without IBM.  It will not be easy, but at least we are free to succeed or fail.  At the moment, we don't seem to be doing much of anything.

Now that I have clarified my point of view, how do you suppose we move forward? 
#4
This is not the first, second, or third time that this topic has been brought up.  I've seen this topic more than once, and made comments each time.  This time it has come in the form of a 64 bit kernel.  I understand why a 64 bit kernel is necessary, but I also know that at the moment, we do not have a (maintainable) kernel at all, 64 bit or otherwise!  Without a kernel, you don't have an operating system.  Without an operating system, it doesn't matter who has or doesn't have Lotus Notes, or any other application. 
It seems obvious that we're not going to legally get the kernel source, or any other aid from IBM.  We must either write a new kernel, or try to modify one that already exists.  Waiting for an IBM handout will kill us.

The Wine developers do not have source for the API which they recreated, nor do the ReactOS developers.  Both groups have managed to get somewhere, and they did so by moving forward.  We can argue about our knowledge of OS/2 history and who was where, but it doesn't help any of us.  There are a number of projects in the works to do exactly what has been said here, yet we're behaving as if they do not exist.  osfree has plans to recreate OS/2.  Most importantly, they've actually worked at it, and have something to show for their work.  Even though their chosen path is a difficult one, it is much better than waiting on IBM to feel sorry for us.  I don't think sorrow is part of their corporate policy.
We know what we want - it's now a matter of making it happen. 

This topic can be summed up like this:
IBM no longer supports OS/2.  There will not be a 64-bit kernel for OS/2 from IBM.
We, as a community, are looking for ways to enhance OS/2 without IBM or IBM's code.  There are a number of groups working on this - some of which have made progress. 
Would you like to help?  This is a major task - we need all the hands we can get.

Now, a rant:  if you take a look at netlabs or osfree, you'll notice that their websites are all broken.  It would appear as if the community is gone.  If you dig deeper, you'll find that there are people working.  How do you expect to draw attention or developers when they can't even figure out if you're still alive?  I thought for sure osfree was dead, until I looked at the dates in svn.